summaryrefslogtreecommitdiff
path: root/packages/integrations/deno/test/basics.test.ts
blob: 78672d34b2470918b9194ac9f07c3b44d4797c9b (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
/* Deno types consider DOM elements nullable */
/* eslint-disable @typescript-eslint/no-unnecessary-type-assertion */
import { DOMParser } from 'https://deno.land/x/deno_dom@v0.1.35-alpha/deno-dom-wasm.ts';
import { assert, assertEquals } from 'https://deno.land/std@0.158.0/testing/asserts.ts';
import { runBuildAndStartApp, defaultTestPermissions } from './helpers.ts';

// this needs to be here and not in the specific test case, because
// the variables are loaded in the global scope of the built server
// module, which is only executed once upon the first load
const varContent = 'this is a value stored in env variable';
Deno.env.set('SOME_VARIABLE', varContent);

Deno.test({
	name: 'Basics',
	permissions: defaultTestPermissions,
	sanitizeResources: false,
	sanitizeOps: false,
	async fn(t) {
		const app = await runBuildAndStartApp('./fixtures/basics/');

		await t.step('Works', async () => {
			const resp = await fetch(app.url);
			assertEquals(resp.status, 200);

			const html = await resp.text();
			assert(html);

			const doc = new DOMParser().parseFromString(html, `text/html`);
			const div = doc!.querySelector('#react');

			assert(div, 'div exists');
		});

		await t.step('Custom 404', async () => {
			const resp = await fetch(new URL('this-does-not-exist', app.url));
			assertEquals(resp.status, 404);

			const html = await resp.text();
			assert(html);

			const doc = new DOMParser().parseFromString(html, `text/html`);
			const header = doc!.querySelector('#custom-404');
			assert(header, 'displays custom 404');
		});

		await t.step('Loads style assets', async () => {
			let resp = await fetch(app.url);
			const html = await resp.text();

			const doc = new DOMParser().parseFromString(html, `text/html`);
			const style = doc!.querySelector('style');

			assertEquals(style?.getAttribute('type'), 'text/css');

			assert(style?.textContent?.includes('Courier New'));
		});

		await t.step('Correctly loads run-time env variables', async () => {
			const resp = await fetch(app.url);
			const html = await resp.text();

			const doc = new DOMParser().parseFromString(html, `text/html`);
			const p = doc!.querySelector('p#env-value');
			assertEquals(p!.innerText, varContent);
		});

		await t.step('Can use a module with top-level await', async () => {
			const resp = await fetch(app.url);
			const html = await resp.text();

			const doc = new DOMParser().parseFromString(html, `text/html`);
			const p = doc!.querySelector('p#module-value');
			assertEquals(p!.innerText, 'bar');
		});

		await t.step('Works with Markdown', async () => {
			const resp = await fetch(new URL('markdown', app.url));
			const html = await resp.text();

			const doc = new DOMParser().parseFromString(html, `text/html`);
			const h1 = doc!.querySelector('h1');
			assertEquals(h1!.innerText, 'Heading from Markdown');
		});

		await t.step('Works with MDX', async () => {
			const resp = await fetch(new URL('mdx', app.url));
			const html = await resp.text();

			const doc = new DOMParser().parseFromString(html, `text/html`);
			const h1 = doc!.querySelector('h1');
			assertEquals(h1!.innerText, 'Heading from MDX');
		});

		await t.step('Astro.cookies', async () => {
			const url = new URL('/admin', app.url);
			const resp = await fetch(url, { redirect: 'manual' });
			assertEquals(resp.status, 302);

			const headers = resp.headers;
			assertEquals(headers.get('set-cookie'), 'logged-in=false; Max-Age=77760000; Path=/');
		});

		await t.step('perendering', async () => {
			const resp = await fetch(new URL('/prerender', app.url));
			assertEquals(resp.status, 200);

			const html = await resp.text();
			assert(html);

			const doc = new DOMParser().parseFromString(html, `text/html`);
			const h1 = doc!.querySelector('h1');
			assertEquals(h1!.innerText, 'test');
		});

		await t.step('node compatibility', async () => {
			const resp = await fetch(new URL('/nodecompat', app.url));
			assertEquals(resp.status, 200);
			await resp.text();
		});

		app.stop();
	},
});