@opencloning/opencloningdb 1.7.1

package/src/common.test.js

@@ -0,0 +1,108 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import {
+  baseUrl,
+  clearWorkspaceHeader,
+  openCloningDBHttpClient,
+  setUnauthorizedHandler,
+  setWorkspaceHeader,
+} from './common';
+
+const requestFulfilled = openCloningDBHttpClient.interceptors.request.handlers[0].fulfilled;
+const responseFulfilled = openCloningDBHttpClient.interceptors.response.handlers[0].fulfilled;
+const responseRejected = openCloningDBHttpClient.interceptors.response.handlers[0].rejected;
+
+beforeEach(() => {
+  localStorage.clear();
+  clearWorkspaceHeader();
+  setUnauthorizedHandler(null);
+});
+
+afterEach(() => {
+  localStorage.clear();
+  clearWorkspaceHeader();
+  setUnauthorizedHandler(null);
+});
+
+describe('common', () => {
+  it('exports the expected base URL', () => {
+    expect(baseUrl).toBe('http://localhost:8001');
+  });
+
+  it('sets and clears the workspace header', () => {
+    setWorkspaceHeader(12);
+
+    expect(openCloningDBHttpClient.defaults.headers.common['X-Workspace-Id']).toBe(12);
+
+    clearWorkspaceHeader();
+
+    expect(openCloningDBHttpClient.defaults.headers.common['X-Workspace-Id']).toBeUndefined();
+  });
+
+  it('serializes scalars and arrays while skipping nullish values', () => {
+    const serialized = openCloningDBHttpClient.defaults.paramsSerializer({
+      single: 'value',
+      number: 3,
+      ignored: undefined,
+      ignoredToo: null,
+      list: ['a', undefined, 'b', null, 4],
+    });
+
+    expect(serialized).toBe('single=value&number=3&list=a&list=b&list=4');
+  });
+
+  it('returns an empty query string when params are missing', () => {
+    expect(openCloningDBHttpClient.defaults.paramsSerializer()).toBe('');
+  });
+
+  it('adds the bearer token to request headers when present', () => {
+    localStorage.setItem('token', '__TEST_TOKEN__');
+    const config = { headers: {} };
+
+    const result = requestFulfilled(config);
+
+    expect(result).toBe(config);
+    expect(config.headers.Authorization).toBe('Bearer __TEST_TOKEN__');
+  });
+
+  it('leaves request headers unchanged when there is no token', () => {
+    const config = { headers: {} };
+
+    const result = requestFulfilled(config);
+
+    expect(result).toBe(config);
+    expect(config.headers.Authorization).toBeUndefined();
+  });
+
+  it('passes successful responses through unchanged', () => {
+    const response = { data: { ok: true } };
+
+    expect(responseFulfilled(response)).toBe(response);
+  });
+
+  it('calls the unauthorized handler for 401 responses', async () => {
+    const handler = vi.fn();
+    const error = { response: { status: 401 } };
+    setUnauthorizedHandler(handler);
+
+    await expect(responseRejected(error)).rejects.toBe(error);
+
+    expect(handler).toHaveBeenCalledTimes(1);
+  });
+
+  it('does not call the unauthorized handler for non-401 responses', async () => {
+    const handler = vi.fn();
+    const error = { response: { status: 500 } };
+    setUnauthorizedHandler(handler);
+
+    await expect(responseRejected(error)).rejects.toBe(error);
+
+    expect(handler).not.toHaveBeenCalled();
+  });
+
+  it('rejects 401 responses even when no unauthorized handler is set', async () => {
+    const error = { response: { status: 401 } };
+
+    await expect(responseRejected(error)).rejects.toBe(error);
+  });
+});

package/src/endpoints.js

@@ -0,0 +1,46 @@
+const endpoints = {
+  sequences: '/sequences',
+  sequence: (id) => `/sequences/${id}`,
+  sequenceTextFile: (id) => `/sequences/${id}/text_file_sequence`,
+  sequenceChangeAnnotation: (id) => `/sequences/${id}/change_annotation`,
+  sequenceCloningStrategy: (id) => `/sequences/${id}/cloning_strategy`,
+  sequenceChildren: (id) => `/sequences/${id}/children`,
+  sequenceLines: (id) => `/sequences/${id}/lines`,
+  sequenceChangeCircularity: (id) => `/sequences/${id}/change_circularity`,
+  sequencePrimers: (id) => `/sequences/${id}/primers`,
+  sequenceSequencingFiles: (id) => `/sequences/${id}/sequencing_files`,
+  sequenceSearch: '/sequences/search',
+  sequencesValidateUpload: '/sequences/validate-upload',
+  sequencesBulk: '/sequences/bulk',
+  sequencingFileDownload: (id) => `/sequencing_files/${id}/download`,
+  sequenceSequencingFileDelete: (sequenceId, fileId) => `/sequences/${sequenceId}/sequencing_files/${fileId}`,
+  postSequence: '/sequences',
+  primers: '/primers',
+  primersValidateUpload: '/primers/validate-upload',
+  primersBulk: '/primers/bulk',
+  primer: (id) => `/primers/${id}`,
+  primerTemplateSequences: (id) => `/primers/${id}/sequences`,
+  postPrimer: '/primers',
+  lines: '/lines',
+  line: (id) => `/lines/${id}`,
+  lineChildren: (id) => `/lines/${id}/children`,
+  lineTags: (id) => `/lines/${id}/tags`,
+  inputEntityTags: (id) => `/input_entities/${id}/tags`,
+  postLine: '/lines',
+  tags: '/tags',
+  tagPost: '/tags',
+  tagUnlinkLine: (lineId, tagId) => `/lines/${lineId}/tags/${tagId}`,
+  tagUnlinkInputEntity: (inputEntityId, tagId) => `/input_entities/${inputEntityId}/tags/${tagId}`,
+  sequenceSamples: '/sequence_samples',
+  postSequenceSample: '/sequence_samples',
+  sequenceSample: (uid) => `/sequence_samples/${uid}`,
+  authToken: '/auth/token',
+  authRegister: '/auth/register',
+  authMe: '/auth/me',
+  workspaces: '/workspaces',
+  postWorkspace: '/workspaces',
+  workspace: (id) => `/workspaces/${id}`,
+  templateSequences: '/template_sequences',
+};
+
+export default endpoints;

package/src/index.js

@@ -0,0 +1,4 @@
+export { default as OpenCloningDBInterface } from './OpenCloningDBInterface.js';
+export { openCloningDBHttpClient, setUnauthorizedHandler, setWorkspaceHeader, clearWorkspaceHeader } from './common.js';
+export { default as endpoints } from './endpoints.js';
+export { default as SequenceSelect } from './SequenceSelect.jsx';

package/src/testUtils.test.js

@@ -0,0 +1,90 @@
+import fs from 'fs';
+import { http, HttpResponse } from 'msw';
+import { describe, expect, it } from 'vitest';
+import { baseUrl } from './common';
+
+const STUB_FOLDER = `${__dirname}/../../../OpenCloning_backend/stubs/db`;
+
+/**
+ * @typedef {Object} DbStub
+ * @property {unknown} body
+ * @property {string} endpoint
+ * @property {Record<string, string>} headers
+ * @property {string} method
+ * @property {unknown} params
+ * @property {{
+ *   body: unknown,
+ *   headers: Record<string, string>,
+ *   status_code: number
+ * }} response
+ */
+
+/**
+ * @param {string} stubName
+ * @returns {DbStub}
+ */
+export function getStub(stubName) {
+  if (!fs.existsSync(`${STUB_FOLDER}/${stubName}.json`)) {
+    throw new Error(`Stub ${stubName} not found`);
+  }
+  return /** @type {DbStub} */ (
+    JSON.parse(fs.readFileSync(`${STUB_FOLDER}/${stubName}.json`, 'utf8'))
+  );
+}
+
+/**
+ * @param {unknown} server
+ * @param {DbStub} stub
+ */
+export function addStubToServer(server, stub) {
+  const url = new URL(stub.endpoint, baseUrl);
+  server.use(
+    http[stub.method.toLowerCase()](url.toString(), async ({ request, params }) => {
+      const plainParams = Object.fromEntries(Object.entries(params ?? {}));
+      const actualParams = Object.keys(plainParams).length === 0 ? null : plainParams;
+      let actualBody;
+      if (request.headers.get('content-type')?.includes('multipart/form-data')) {
+        throw new Error('Multipart form data is not supported');
+      } else {
+        actualBody = await request
+          .clone()
+          .json()
+          .catch(() => null);
+      }
+      expect(actualParams).toEqual(stub.params);
+      expect(actualBody).toEqual(stub.body);
+
+      const actualHeaders = Object.fromEntries(request.headers.entries());
+      delete actualHeaders['content-type'];
+      delete actualHeaders['accept'];
+      expect(actualHeaders).toMatchObject(stub.headers);
+
+      if (stub.response.headers['content-disposition']) {
+        return new HttpResponse(Buffer.from(stub.response.body, 'base64'), {
+          status: stub.response.status_code,
+          headers: stub.response.headers,
+        });
+      }
+
+      return HttpResponse.json(stub.response.body, {
+        status: stub.response.status_code,
+        headers: stub.response.headers,
+      });
+    }),
+  );
+}
+
+export function setupToken() {
+  localStorage.setItem('token', '__TEST_TOKEN__');
+}
+
+export function clearToken() {
+  localStorage.removeItem('token');
+}
+
+describe('test utility module', () => {
+  it('exports helpers for other test files', () => {
+    expect(typeof getStub).toBe('function');
+    expect(typeof addStubToServer).toBe('function');
+  });
+});

package/vitest.config.js

@@ -0,0 +1,8 @@
+import { defineConfig } from 'vitest/config';
+import { testConfig } from '../../vitest.common.config';
+
+export default defineConfig({
+  test: {
+    ...testConfig,
+  },
+});