repoimage 0.2.0

package/test/server.test.js

@@ -0,0 +1,308 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const http = require('http');
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const { createRepoimageServer } = require('../server/dist/server');
+
+const MINI_PNG = Buffer.from(
+  'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==',
+  'base64'
+);
+
+function tempDir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'repoimage-srv-'));
+}
+
+function postJson(port, pathname, payload) {
+  const body = JSON.stringify(payload);
+  return new Promise((resolve, reject) => {
+    const req = http.request(
+      {
+        hostname: '127.0.0.1',
+        port,
+        path: pathname,
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Content-Length': Buffer.byteLength(body)
+        }
+      },
+      res => {
+        const chunks = [];
+        res.on('data', c => chunks.push(c));
+        res.on('end', () => {
+          const text = Buffer.concat(chunks).toString('utf8');
+          let json = null;
+          try {
+            json = JSON.parse(text);
+          } catch {
+            // leave json null
+          }
+          resolve({ status: res.statusCode, text, json });
+        });
+      }
+    );
+    req.on('error', reject);
+    req.write(body);
+    req.end();
+  });
+}
+
+function httpGet(port, pathname) {
+  return new Promise((resolve, reject) => {
+    http
+      .get({ hostname: '127.0.0.1', port, path: pathname }, res => {
+        const chunks = [];
+        res.on('data', c => chunks.push(c));
+        res.on('end', () => {
+          const body = Buffer.concat(chunks);
+          resolve({
+            status: res.statusCode,
+            text: body.toString('utf8'),
+            body
+          });
+        });
+      })
+      .on('error', reject);
+  });
+}
+
+test('POST /api/scan returns images for an existing folder', async () => {
+  const dir = tempDir();
+  fs.writeFileSync(path.join(dir, 'x.png'), MINI_PNG);
+
+  const server = createRepoimageServer();
+  await new Promise((resolve, reject) => {
+    server.listen(0, resolve);
+    server.on('error', reject);
+  });
+  const port = server.address().port;
+
+  try {
+    const { status, json } = await postJson(port, '/api/scan', { folders: [dir] });
+    assert.equal(status, 200);
+    assert.ok(json);
+    assert.equal(json.images.length, 1);
+    assert.equal(json.images[0].path, 'x.png');
+    assert.ok(Array.isArray(json.issues));
+  } finally {
+    await new Promise(resolve => server.close(resolve));
+  }
+});
+
+test('POST /api/scan with empty folders returns 400', async () => {
+  const server = createRepoimageServer();
+  await new Promise((resolve, reject) => {
+    server.listen(0, resolve);
+    server.on('error', reject);
+  });
+  const port = server.address().port;
+
+  try {
+    const { status, json } = await postJson(port, '/api/scan', { folders: [] });
+    assert.equal(status, 400);
+    assert.ok(json && json.error);
+  } finally {
+    await new Promise(resolve => server.close(resolve));
+  }
+});
+
+test('POST /api/scan accepts single "folder" string', async () => {
+  const dir = tempDir();
+  fs.writeFileSync(path.join(dir, 'y.png'), MINI_PNG);
+
+  const server = createRepoimageServer();
+  await new Promise((resolve, reject) => {
+    server.listen(0, resolve);
+    server.on('error', reject);
+  });
+  const port = server.address().port;
+
+  try {
+    const { status, json } = await postJson(port, '/api/scan', { folder: dir });
+    assert.equal(status, 200);
+    assert.equal(json.images.length, 1);
+    assert.equal(json.images[0].path, 'y.png');
+  } finally {
+    await new Promise(resolve => server.close(resolve));
+  }
+});
+
+test('POST /api/scan-entries enriches client-provided rows', async () => {
+  const server = createRepoimageServer();
+  await new Promise((resolve, reject) => {
+    server.listen(0, resolve);
+    server.on('error', reject);
+  });
+  const port = server.address().port;
+
+  try {
+    const { status, json } = await postJson(port, '/api/scan-entries', {
+      entries: [{ path: 'a/b.png', size: 100, width: 10, height: 10 }]
+    });
+    assert.equal(status, 200);
+    assert.equal(json.images.length, 1);
+    assert.equal(json.images[0].path, 'a/b.png');
+    assert.ok(json.images[0].compressionRatio != null);
+  } finally {
+    await new Promise(resolve => server.close(resolve));
+  }
+});
+
+test('POST /api/scan-entries with empty entries returns 400', async () => {
+  const server = createRepoimageServer();
+  await new Promise((resolve, reject) => {
+    server.listen(0, resolve);
+    server.on('error', reject);
+  });
+  const port = server.address().port;
+
+  try {
+    const { status, json } = await postJson(port, '/api/scan-entries', { entries: [] });
+    assert.equal(status, 400);
+    assert.ok(json && json.error);
+  } finally {
+    await new Promise(resolve => server.close(resolve));
+  }
+});
+
+test('GET /api/fs/home returns a path string', async () => {
+  const server = createRepoimageServer();
+  await new Promise((resolve, reject) => {
+    server.listen(0, '127.0.0.1', resolve);
+    server.on('error', reject);
+  });
+  const port = server.address().port;
+
+  try {
+    const { status, text } = await httpGet(port, '/api/fs/home');
+    const json = JSON.parse(text);
+    assert.equal(status, 200);
+    assert.ok(typeof json.path === 'string' && json.path.length > 0);
+  } finally {
+    await new Promise(resolve => server.close(resolve));
+  }
+});
+
+test('GET /api/fs/list returns directory entries', async () => {
+  const dir = tempDir();
+  fs.writeFileSync(path.join(dir, 'x.dat'), '');
+
+  const server = createRepoimageServer();
+  await new Promise((resolve, reject) => {
+    server.listen(0, '127.0.0.1', resolve);
+    server.on('error', reject);
+  });
+  const port = server.address().port;
+  const q = encodeURIComponent(dir);
+  try {
+    const { status, text } = await httpGet(port, `/api/fs/list?path=${q}`);
+    const json = JSON.parse(text);
+    assert.equal(status, 200);
+    assert.ok(json.entries.some(e => e.name === 'x.dat'));
+  } finally {
+    await new Promise(resolve => server.close(resolve));
+  }
+});
+
+test('POST /api/fs/list accepts path in JSON body', async () => {
+  const dir = tempDir();
+
+  const server = createRepoimageServer();
+  await new Promise((resolve, reject) => {
+    server.listen(0, '127.0.0.1', resolve);
+    server.on('error', reject);
+  });
+  const port = server.address().port;
+
+  try {
+    const { status, json } = await postJson(port, '/api/fs/list', { path: dir });
+    assert.equal(status, 200);
+    assert.ok(Array.isArray(json.entries));
+  } finally {
+    await new Promise(resolve => server.close(resolve));
+  }
+});
+
+test('GET /api/file serves an image by absolute path', async () => {
+  const dir = tempDir();
+  const imgPath = path.join(dir, 'thumb.png');
+  fs.writeFileSync(imgPath, MINI_PNG);
+
+  const server = createRepoimageServer();
+  await new Promise((resolve, reject) => {
+    server.listen(0, '127.0.0.1', resolve);
+    server.on('error', reject);
+  });
+  const port = server.address().port;
+
+  try {
+    const q = encodeURIComponent(imgPath);
+    const { status, body } = await httpGet(port, `/api/file?path=${q}`);
+    assert.equal(status, 200);
+    assert.equal(body.length, MINI_PNG.length);
+    assert.equal(body.compare(MINI_PNG), 0);
+  } finally {
+    await new Promise(resolve => server.close(resolve));
+  }
+});
+
+test('POST /api/scan with excludeCommonFolders filters results', async () => {
+  const dir = tempDir();
+  const nodeModulesDir = path.join(dir, 'node_modules');
+  const assetsDir = path.join(dir, 'assets');
+  fs.mkdirSync(nodeModulesDir, { recursive: true });
+  fs.mkdirSync(assetsDir, { recursive: true });
+
+  fs.writeFileSync(path.join(nodeModulesDir, 'dep.png'), MINI_PNG);
+  fs.writeFileSync(path.join(assetsDir, 'logo.png'), MINI_PNG);
+
+  const server = createRepoimageServer();
+  await new Promise((resolve, reject) => {
+    server.listen(0, resolve);
+    server.on('error', reject);
+  });
+  const port = server.address().port;
+
+  try {
+    const { status: status1, json: json1 } = await postJson(port, '/api/scan', {
+      folders: [dir],
+      excludeCommonFolders: false
+    });
+    const { status: status2, json: json2 } = await postJson(port, '/api/scan', {
+      folders: [dir],
+      excludeCommonFolders: true
+    });
+
+    assert.equal(status1, 200);
+    assert.equal(status2, 200);
+    assert.equal(json1.images.length, 2);
+    assert.equal(json2.images.length, 1);
+    assert.equal(json2.images[0].path, 'assets/logo.png');
+  } finally {
+    await new Promise(resolve => server.close(resolve));
+  }
+});
+
+test('GET / serves index.html from client dist', async () => {
+  const clientRoot = path.join(__dirname, '..', 'client', 'dist');
+  const server = createRepoimageServer({ clientRoot });
+  await new Promise((resolve, reject) => {
+    server.listen(0, resolve);
+    server.on('error', reject);
+  });
+  const port = server.address().port;
+
+  try {
+    const { status, text } = await httpGet(port, '/');
+    assert.equal(status, 200);
+    assert.match(text, /RepoImage/);
+  } finally {
+    await new Promise(resolve => server.close(resolve));
+  }
+});

package/tsconfig.base.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "CommonJS",
+    "moduleResolution": "Node",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  }
+}