serverus/tests/01_static_files.test.ts

import * as asserts from '@std/assert';
import * as fs from '@std/fs';
import * as path from '@std/path';
import { EPHEMERAL_SERVER, get_ephemeral_listen_server } from './helpers.ts';
import { ensureFile } from '@std/fs/ensure-file';

Deno.test({
	name: 'GET static file',
	permissions: {
		env: true,
		read: true,
		write: true,
		net: true
	},
	fn: async () => {
		let test_server_info: EPHEMERAL_SERVER | null = null;
		const cwd = Deno.cwd();

		try {
			Deno.chdir('./tests/www');
			test_server_info = await get_ephemeral_listen_server();

			const response = await fetch(`http://${test_server_info.hostname}:${test_server_info.port}/test.txt`, {
				method: 'GET'
			});

			const body = await response.text();

			asserts.assert(response.ok);
			asserts.assert(body);
			asserts.assertEquals(body, 'this is a test\n');
		} finally {
			Deno.chdir(cwd);
			if (test_server_info) {
				await test_server_info?.server?.stop();
			}
		}
	}
});

Deno.test({
	name: 'HEAD static file',
	permissions: {
		env: true,
		read: true,
		write: true,
		net: true
	},
	fn: async () => {
		let test_server_info: EPHEMERAL_SERVER | null = null;
		const cwd = Deno.cwd();

		try {
			Deno.chdir('./tests/www');
			test_server_info = await get_ephemeral_listen_server();

			const response = await fetch(`http://${test_server_info.hostname}:${test_server_info.port}/test.txt`, {
				method: 'HEAD'
			});

			asserts.assert(response.ok);
			asserts.assert(response.headers);
			asserts.assertEquals(response.headers.get('Content-Length'), '15');
		} finally {
			Deno.chdir(cwd);
			if (test_server_info) {
				await test_server_info?.server?.stop();
			}
		}
	}
});

Deno.test({
	name: 'OPTIONS static file',
	permissions: {
		env: true,
		read: true,
		write: true,
		net: true
	},
	fn: async () => {
		let test_server_info: EPHEMERAL_SERVER | null = null;
		const cwd = Deno.cwd();

		try {
			Deno.chdir('./tests/www');
			test_server_info = await get_ephemeral_listen_server();

			const response = await fetch(`http://${test_server_info.hostname}:${test_server_info.port}/test.txt`, {
				method: 'OPTIONS'
			});

			await response.text();

			asserts.assert(response.ok);
			asserts.assert(response.headers);
			asserts.assertEquals(response.headers.get('Allow'), ['DELETE', 'GET', 'HEAD', 'OPTIONS', 'PUT'].join(','));
		} finally {
			Deno.chdir(cwd);
			if (test_server_info) {
				await test_server_info?.server?.stop();
			}
		}
	}
});

Deno.test({
	name: 'allow PUT to static files if SERVERUS_PUT_PATHS_ALLOWED is set',
	permissions: {
		env: true,
		read: true,
		write: true,
		net: true
	},

	sanitizeResources: false,
	sanitizeOps: false,

	fn: async () => {
		let test_server_info: EPHEMERAL_SERVER | null = null;
		const cwd = Deno.cwd();

		const PREVIOUS_PUT_PATHS_ALLOWED = Deno.env.get('SERVERUS_PUT_PATHS_ALLOWED');
		try {
			Deno.chdir('./tests/www');
			Deno.env.set('SERVERUS_PUT_PATHS_ALLOWED', path.join(Deno.cwd(), 'files'));

			test_server_info = await get_ephemeral_listen_server();

			const put_body = new FormData();
			let test_file: File | undefined = new File(['this is a test PUT upload'], 'test_put_upload.txt');
			put_body.append('file', test_file);

			// Sending a single file
			const put_response = await fetch(`http://${test_server_info.hostname}:${test_server_info.port}/files/test_put_upload.txt`, {
				method: 'PUT',
				body: put_body
			});

			asserts.assert(put_response.ok);

			const put_response_body = await put_response.json();
			asserts.assert(put_response_body);
			asserts.assert(put_response_body.written);
			asserts.assertEquals(
				put_response_body.written?.[0],
				`http://${test_server_info.hostname}:${test_server_info.port}/files/test_put_upload.txt`
			);

			put_body.delete('file');
			test_file = undefined;

			const get_response = await fetch(`http://${test_server_info.hostname}:${test_server_info.port}/files/test_put_upload.txt`, {
				method: 'GET'
			});

			asserts.assert(get_response.ok);
			asserts.assert(get_response.body);

			const local_download_path = path.join(Deno.cwd(), 'files', 'test_put_upload.txt-downloaded');
			await ensureFile(local_download_path);

			const file = await Deno.open(local_download_path, { truncate: true, write: true });
			await get_response.body.pipeTo(file.writable);

			const download_content = await Deno.readTextFile(local_download_path);
			asserts.assert(download_content);
			asserts.assertEquals(download_content, 'this is a test PUT upload');

			await Deno.remove(local_download_path);
			asserts.assert(!fs.existsSync(local_download_path));

			const local_upload_path = path.join(Deno.cwd(), 'files', 'test_put_upload.txt');
			asserts.assert(fs.existsSync(local_upload_path));

			const stat = await Deno.lstat(local_upload_path);
			asserts.assert(stat);
			asserts.assert(stat.isFile);
			asserts.assertEquals(stat.size, 25);
			asserts.assertEquals(stat.mode! & 0o777, 0o755);

			await Deno.remove(local_upload_path);
			asserts.assert(!fs.existsSync(local_upload_path));
		} finally {
			Deno.chdir(cwd);
			if (PREVIOUS_PUT_PATHS_ALLOWED) {
				Deno.env.set('SERVERUS_PUT_PATHS_ALLOWED', PREVIOUS_PUT_PATHS_ALLOWED);
			} else {
				Deno.env.delete('SERVERUS_PUT_PATHS_ALLOWED');
			}

			if (test_server_info) {
				await test_server_info?.server?.stop();
			}
		}
	}
});

Deno.test({
	name: 'allow PUT to multiple files in a directory',
	permissions: {
		env: true,
		read: true,
		write: true,
		net: true
	},

	sanitizeResources: false,
	sanitizeOps: false,

	fn: async () => {
		let test_server_info: EPHEMERAL_SERVER | null = null;
		const cwd = Deno.cwd();

		const PREVIOUS_PUT_PATHS_ALLOWED = Deno.env.get('SERVERUS_PUT_PATHS_ALLOWED');
		try {
			Deno.chdir('./tests/www');
			Deno.env.set('SERVERUS_PUT_PATHS_ALLOWED', path.join(Deno.cwd(), 'files'));

			test_server_info = await get_ephemeral_listen_server();

			const put_body = new FormData();

			for (const i of [1, 2, 3]) {
				put_body.append('file', new File([`this is a test PUT upload ${i}`], `test_put_upload_${i}.txt`));
			}

			const put_response = await fetch(`http://${test_server_info.hostname}:${test_server_info.port}/files/test_multiple/`, {
				method: 'PUT',
				body: put_body
			});

			asserts.assert(put_response.ok);

			const put_response_body = await put_response.json();
			asserts.assert(put_response_body);
			asserts.assert(put_response_body.written);

			for await (const i of [1, 2, 3]) {
				const url = put_response_body.written?.[i - 1];

				asserts.assertEquals(
					url,
					`http://${test_server_info.hostname}:${test_server_info.port}/files/test_multiple/test_put_upload_${i}.txt`
				);

				const get_response = await fetch(url, {
					method: 'GET'
				});

				asserts.assert(get_response.ok);
				asserts.assert(get_response.body);

				const local_download_path = path.join(Deno.cwd(), 'files', 'test_multiple', `test_put_upload_${i}.txt-downloaded`);
				await ensureFile(local_download_path);

				const file = await Deno.open(local_download_path, { truncate: true, write: true });
				await get_response.body.pipeTo(file.writable);

				const download_content = await Deno.readTextFile(local_download_path);
				asserts.assert(download_content);
				asserts.assertEquals(download_content, `this is a test PUT upload ${i}`);

				await Deno.remove(local_download_path);
				asserts.assert(!fs.existsSync(local_download_path));

				const local_upload_path = path.join(Deno.cwd(), 'files', 'test_multiple', `test_put_upload_${i}.txt`);
				asserts.assert(fs.existsSync(local_upload_path));

				const stat = await Deno.lstat(local_upload_path);
				asserts.assert(stat);
				asserts.assert(stat.isFile);
				asserts.assertEquals(stat.size, 27);
				asserts.assertEquals(stat.mode! & 0o777, 0o755);

				await Deno.remove(local_upload_path);
				asserts.assert(!fs.existsSync(local_upload_path));
			}

			const uploads_directory = path.join(Deno.cwd(), 'files', 'test_multiple');
			await Deno.remove(uploads_directory);
			asserts.assert(!fs.existsSync(uploads_directory));
		} finally {
			Deno.chdir(cwd);
			if (PREVIOUS_PUT_PATHS_ALLOWED) {
				Deno.env.set('SERVERUS_PUT_PATHS_ALLOWED', PREVIOUS_PUT_PATHS_ALLOWED);
			} else {
				Deno.env.delete('SERVERUS_PUT_PATHS_ALLOWED');
			}

			if (test_server_info) {
				await test_server_info?.server?.stop();
			}
		}
	}
});

Deno.test({
	name: 'allow DELETE to static files if SERVERUS_DELETE_PATHS_ALLOWED is set',
	permissions: {
		env: true,
		read: true,
		write: true,
		net: true
	},

	sanitizeResources: false,
	sanitizeOps: false,

	fn: async () => {
		let test_server_info: EPHEMERAL_SERVER | null = null;
		const cwd = Deno.cwd();

		const PREVIOUS_DELETE_PATHS_ALLOWED = Deno.env.get('SERVERUS_DELETE_PATHS_ALLOWED');
		try {
			Deno.chdir('./tests/www');
			Deno.env.set('SERVERUS_DELETE_PATHS_ALLOWED', path.join(Deno.cwd(), 'files'));

			test_server_info = await get_ephemeral_listen_server();

			const put_body = new FormData();
			let test_file: File | undefined = new File(['this is a test DELETE upload'], 'test_delete_upload.txt');
			put_body.append('file', test_file);

			const put_response = await fetch(`http://${test_server_info.hostname}:${test_server_info.port}/files/test_delete_upload.txt`, {
				method: 'PUT',
				body: put_body
			});

			asserts.assert(put_response.ok);

			const put_response_body = await put_response.json();
			asserts.assert(put_response_body);
			asserts.assert(put_response_body.written);
			asserts.assertEquals(
				put_response_body.written?.[0],
				`http://${test_server_info.hostname}:${test_server_info.port}/files/test_delete_upload.txt`
			);

			put_body.delete('file');
			test_file = undefined;

			const get_response = await fetch(`http://${test_server_info.hostname}:${test_server_info.port}/files/test_delete_upload.txt`, {
				method: 'GET'
			});

			asserts.assert(get_response.ok);
			asserts.assert(get_response.body);

			const local_download_path = path.join(Deno.cwd(), 'files', 'test_delete_upload.txt-downloaded');
			await ensureFile(local_download_path);

			const file = await Deno.open(local_download_path, { truncate: true, write: true });
			await get_response.body.pipeTo(file.writable);

			const download_content = await Deno.readTextFile(local_download_path);
			asserts.assert(download_content);
			asserts.assertEquals(download_content, 'this is a test DELETE upload');

			await Deno.remove(local_download_path);
			asserts.assert(!fs.existsSync(local_download_path));

			const local_upload_path = path.join(Deno.cwd(), 'files', 'test_delete_upload.txt');
			asserts.assert(fs.existsSync(local_upload_path));

			const stat = await Deno.lstat(local_upload_path);
			asserts.assert(stat);
			asserts.assert(stat.isFile);
			asserts.assertEquals(stat.size, 28);
			asserts.assertEquals(stat.mode! & 0o777, 0o755);

			const delete_response = await fetch(
				`http://${test_server_info.hostname}:${test_server_info.port}/files/test_delete_upload.txt`,
				{
					method: 'DELETE'
				}
			);

			asserts.assert(delete_response.ok);

			asserts.assert(!fs.existsSync(local_upload_path));
		} finally {
			Deno.chdir(cwd);
			if (PREVIOUS_DELETE_PATHS_ALLOWED) {
				Deno.env.set('SERVERUS_DELETE_PATHS_ALLOWED', PREVIOUS_DELETE_PATHS_ALLOWED);
			} else {
				Deno.env.delete('SERVERUS_DELETE_PATHS_ALLOWED');
			}

			if (test_server_info) {
				await test_server_info?.server?.stop();
			}
		}
	}
});

Deno.test({
	name: 'allow DELETE directory',
	permissions: {
		env: true,
		read: true,
		write: true,
		net: true
	},

	sanitizeResources: false,
	sanitizeOps: false,

	fn: async () => {
		let test_server_info: EPHEMERAL_SERVER | null = null;
		const cwd = Deno.cwd();

		const PREVIOUS_DELETE_PATHS_ALLOWED = Deno.env.get('SERVERUS_DELETE_PATHS_ALLOWED');
		try {
			Deno.chdir('./tests/www');
			Deno.env.set('SERVERUS_DELETE_PATHS_ALLOWED', path.join(Deno.cwd(), 'files'));

			test_server_info = await get_ephemeral_listen_server();

			const put_body = new FormData();
			let test_file: File | undefined = new File(['this is a test DELETE upload'], 'test_delete_directory_upload.txt');
			put_body.append('file', test_file);

			const put_response = await fetch(
				`http://${test_server_info.hostname}:${test_server_info.port}/files/delete_directory_test/test_delete_directory_upload.txt`,
				{
					method: 'PUT',
					body: put_body
				}
			);

			asserts.assert(put_response.ok);

			const put_response_body = await put_response.json();
			asserts.assert(put_response_body);
			asserts.assert(put_response_body.written);
			asserts.assertEquals(
				put_response_body.written?.[0],
				`http://${test_server_info.hostname}:${test_server_info.port}/files/delete_directory_test/test_delete_directory_upload.txt`
			);

			put_body.delete('file');
			test_file = undefined;

			const local_upload_path = path.join(Deno.cwd(), 'files', 'delete_directory_test', 'test_delete_directory_upload.txt');
			asserts.assert(fs.existsSync(local_upload_path));

			const stat = await Deno.lstat(local_upload_path);
			asserts.assert(stat);
			asserts.assert(stat.isFile);
			asserts.assertEquals(stat.size, 28);
			asserts.assertEquals(stat.mode! & 0o777, 0o755);

			const delete_response = await fetch(
				`http://${test_server_info.hostname}:${test_server_info.port}/files/delete_directory_test`,
				{
					method: 'DELETE'
				}
			);

			asserts.assert(delete_response.ok);

			asserts.assert(!fs.existsSync(local_upload_path));
			asserts.assert(!fs.existsSync(path.dirname(local_upload_path)));
		} finally {
			Deno.chdir(cwd);
			if (PREVIOUS_DELETE_PATHS_ALLOWED) {
				Deno.env.set('SERVERUS_DELETE_PATHS_ALLOWED', PREVIOUS_DELETE_PATHS_ALLOWED);
			} else {
				Deno.env.delete('SERVERUS_DELETE_PATHS_ALLOWED');
			}

			if (test_server_info) {
				await test_server_info?.server?.stop();
			}
		}
	}
});

Deno.test({
	name: 'these methods should not work on static files',
	permissions: {
		env: true,
		read: true,
		write: true,
		net: true
	},
	fn: async () => {
		let test_server_info: EPHEMERAL_SERVER | null = null;
		const cwd = Deno.cwd();

		try {
			Deno.chdir('./tests/www');
			test_server_info = await get_ephemeral_listen_server();

			for await (const method of ['POST', 'PATCH']) {
				const response = await fetch(`http://${test_server_info.hostname}:${test_server_info.port}/test.txt`, {
					method,
					body: method === 'TRACE' ? undefined : JSON.stringify({})
				});

				asserts.assert(!response.ok);

				const body = await response.json();
				asserts.assert(body);

				asserts.assertEquals(body, {
					error: {
						cause: 'not_found',
						message: 'Not found'
					}
				});
			}
		} finally {
			Deno.chdir(cwd);
			if (test_server_info) {
				await test_server_info?.server?.stop();
			}
		}
	}
});