@equinor/fusion-framework-module-services 5.1.1-msal-0b0dadf270ee512f019a325c2f1586f91f9150a4 → 5.1.2

package/tests/context.test.ts

@@ -0,0 +1,109 @@
+import { describe, expect, it, vi, beforeEach, afterEach, type MockInstance } from 'vitest';
+
+import { BASE_URL } from './setup';
+
+import { ContextApiClient, ApiVersion } from '../src/context';
+
+import { HttpClient } from '@equinor/fusion-framework-module-http/client';
+import { UnsupportedApiVersion } from '../src/errors';
+
+import { mockContextItem } from './mocks';
+
+describe('Context', () => {
+  let httpClient: HttpClient;
+  let httpClientWatcher: MockInstance;
+  let contextClient: ContextApiClient;
+
+  beforeEach(() => {
+    httpClient = new HttpClient(BASE_URL, {
+      /* options */
+    });
+    httpClientWatcher = vi.spyOn(httpClient, 'json');
+    contextClient = new ContextApiClient(httpClient, 'json');
+  });
+
+  afterEach(() => {
+    httpClientWatcher.mockRestore();
+  });
+
+  describe('get', () => {
+    it('should generate parameters for valid API version and arguments for V1', async () => {
+      const contextId = '123e4567-e89b-12d3-a456-426614174000';
+      const expected = mockContextItem(contextId);
+      const result = await contextClient.get('v1', { id: contextId });
+
+      expect(result).toMatchObject(expected);
+
+      expect(httpClientWatcher).toHaveBeenCalledWith(
+        `/contexts/${contextId}/?api-version=${ApiVersion.v1}`,
+        undefined,
+      );
+    });
+
+    it('should throw UnsupportedApiVersion for unsupported API version', async () => {
+      // Attempt to get context with an unsupported API version 'v2'
+      // This should throw an UnsupportedApiVersion error because 'v2' is not a valid API version
+      try {
+        await contextClient.get('v2', { id: '123e4567-e89b-12d3-a456-426614174000' });
+        expect(true).toBe(false); // This line should not be reached
+      } catch (error) {
+        // Verify that the error is of type UnsupportedApiVersion
+        expect(error).toBeInstanceOf(UnsupportedApiVersion);
+      }
+    });
+  });
+
+  describe('query', () => {
+    it('should generate parameters for valid API version and arguments for V1', async () => {
+      const result = await contextClient.query('v1', { query: { filter: { type: ['master'] } } });
+
+      expect(result).toHaveLength(10);
+
+      const searchParams = new URLSearchParams();
+      searchParams.append('$filter', "type in ('master')");
+      searchParams.append('api-version', ApiVersion.v1);
+
+      expect(httpClientWatcher).toHaveBeenCalledWith(`/contexts/?${searchParams}`, undefined);
+    });
+
+    it('should throw UnsupportedApiVersion for unsupported API version', async () => {
+      // Attempt to get context with an unsupported API version 'v2'
+      // This should throw an UnsupportedApiVersion error because 'v2' is not a valid API version
+      try {
+        await contextClient.query('v2', { query: { filter: { type: ['master'] } } });
+        expect(true).toBe(false); // This line should not be reached
+      } catch (error) {
+        // Verify that the error is of type UnsupportedApiVersion
+        expect(error).toBeInstanceOf(UnsupportedApiVersion);
+      }
+    });
+  });
+
+  describe('related', () => {
+    it('should generate parameters for valid API version and arguments for V1', async () => {
+      const contextId = '123e4567-e89b-12d3-a456-426614174000';
+
+      await contextClient.related('v1', { id: contextId, query: { filter: { type: ['master'] } } });
+
+      const searchParams = new URLSearchParams();
+      searchParams.append('$filter', "type in ('master')");
+      searchParams.append('api-version', ApiVersion.v1);
+
+      expect(httpClientWatcher).toHaveBeenCalledWith(
+        `/contexts/${contextId}/relations?${searchParams}`,
+        undefined,
+      );
+    });
+    it('should throw UnsupportedApiVersion for unsupported API version', async () => {
+      // Attempt to get context with an unsupported API version 'v2'
+      // This should throw an UnsupportedApiVersion error because 'v2' is not a valid API version
+      try {
+        await contextClient.related('v2', { id: '123e4567-e89b-12d3-a456-426614174000' });
+        expect(true).toBe(false); // This line should not be reached
+      } catch (error) {
+        // Verify that the error is of type UnsupportedApiVersion
+        expect(error).toBeInstanceOf(UnsupportedApiVersion);
+      }
+    });
+  });
+});

package/tests/mocks/get-context-item.ts

@@ -0,0 +1,60 @@
+import { Faker, da, en } from '@faker-js/faker';
+import { type ApiContextEntity, ApiVersion } from '../../src/context';
+
+import { createHash } from 'node:crypto';
+
+/**
+ * Converts a string to a seed for the Faker.js library.
+ *
+ * @param uuid - The UUID string to convert.
+ * @returns A numeric seed derived from the UUID.
+ */
+function stringToSeed(uuid: string): number {
+  const hash = createHash('sha256').update(uuid).digest('hex');
+  return Number.parseInt(hash.slice(0, 8), 16);
+}
+
+/**
+ * Since generation of dates might have a slight difference in milliseconds
+ * we normalize the date to the nearest minute, so we can compare them.
+ * 
+ * @note
+ * This might fail at exactly midnight, but the odds for that are slim. Rerun the test if it fails.
+ * 
+ * @param date date to normalize
+ * @returns string
+ */
+function normalizeDateMock(date: Date): string {
+  date.setMinutes(0);
+  date.setSeconds(0);
+  date.setMilliseconds(0);
+  return date.toISOString();
+}
+
+export const mockContextItem = <V extends ApiVersion = ApiVersion.v1>(
+  id: string,
+  version: V = ApiVersion.v1 as V,
+): ApiContextEntity<V> => {
+  const seed = stringToSeed(id);
+  const faker = new Faker({ seed, locale: en });
+  switch (version) {
+    case ApiVersion.v1:
+      return {
+        id: String(id),
+        externalId: faker.string.uuid(),
+        created: normalizeDateMock(faker.date.recent()),
+        source: faker.string.uuid(),
+        type: {
+          id: faker.string.uuid(),
+          isChildType: false,
+          parentTypeIds: null,
+        },
+        value: null,
+        title: faker.lorem.sentence(),
+        isActive: true,
+        isDeleted: false,
+        updated: normalizeDateMock(faker.date.past()),
+      } satisfies ApiContextEntity<ApiVersion.v1> as ApiContextEntity<V>;
+  }
+  throw new Error('Not implemented');
+};

package/tests/mocks/index.ts

@@ -0,0 +1 @@
+export { mockContextItem } from './get-context-item';

package/tests/setup.ts

@@ -0,0 +1,73 @@
+import { afterAll, afterEach, beforeAll } from 'vitest';
+
+import { setupServer } from 'msw/node';
+import { http, HttpResponse } from 'msw';
+
+import { mockContextItem } from './mocks';
+
+import type { ApiVersion } from '../src/context';
+
+export const BASE_URL = 'https://localhost';
+
+// Define mock handlers for fetch requests
+const handlers = [
+  // Mock GET /contexts
+  http.get(new URL('contexts', BASE_URL).toString(), (req) => {
+    const url = new URL(req.request.url);
+    const apiVersion = url.searchParams.get('api-version');
+    if (!apiVersion) {
+      return HttpResponse.error();
+    }
+    return HttpResponse.json(
+      new Array(10)
+        .fill(null)
+        .map((_, index) => mockContextItem(`context-item-${index}`, apiVersion as ApiVersion.v1)),
+    );
+  }),
+
+  // Mock GET /contexts/:id
+  http.get(new URL('contexts/:id', BASE_URL).toString(), (req) => {
+    const { id } = req.params;
+    if (!id || typeof id !== 'string') {
+      return HttpResponse.error();
+    }
+    const url = new URL(req.request.url);
+    const apiVersion = url.searchParams.get('api-version');
+    if (!apiVersion) {
+      return HttpResponse.error();
+    }
+    return HttpResponse.json(mockContextItem(id, apiVersion as ApiVersion.v1));
+  }),
+
+  // Mock GET /contexts/:id/relations
+  http.get(new URL('contexts/:id/relations', BASE_URL).toString(), (req) => {
+    const { id } = req.params;
+    if (!id || typeof id !== 'string') {
+      return HttpResponse.error();
+    }
+    const url = new URL(req.request.url);
+    const apiVersion = url.searchParams.get('api-version');
+    if (!apiVersion) {
+      return HttpResponse.error();
+    }
+    return HttpResponse.json(
+      new Array(3)
+        .fill(null)
+        .map((_, index) =>
+          mockContextItem(`context--related-item-${index}`, apiVersion as ApiVersion.v1),
+        ),
+    );
+  }),
+];
+
+// Initialize the server
+export const server = setupServer(...handlers);
+
+// Start server before all tests
+beforeAll(() => server.listen({ onUnhandledRequest: 'warn' }));
+
+// Reset handlers after each test
+afterEach(() => server.resetHandlers());
+
+// Stop server after all tests
+afterAll(() => server.close());

package/tsconfig.json

@@ -7,7 +7,7 @@
     
     "paths": {
       "@equinor/fusion-framework-module-services": [
-        "."
+        "./"
       ],
       "@equinor/fusion-framework-module-services/*": [
         "./*"
@@ -29,10 +29,11 @@
     }
   ],
   "include": [
-    "src/**/*",
+    "src/**/*", "tests/**/*",
   ],
   "exclude": [
     "node_modules",
-    "lib"
+    "lib",
+    "tests"
   ]
 }

package/vitest.config.ts

@@ -0,0 +1,11 @@
+import { defineProject } from 'vitest/config';
+
+import { name, version } from './package.json';
+
+export default defineProject({
+  test: {
+    include: ['tests/**/*.test.ts'],
+    name: `${name}@${version}`,
+    setupFiles: ['tests/setup.ts'],
+  },
+});