feature: allow for static file uploads and deletions

feature: add HEAD and OPTIONS support to static files
This commit is contained in:
Andy Burke 2025-08-01 20:11:17 -07:00
parent 582636ab5a
commit 3ef936d2d6
7 changed files with 900 additions and 120 deletions

View file

@ -0,0 +1,521 @@
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();
}
}
}
});