test: add unit tests for semantic entitites

Author: msieroslawska

test/unit/create-environment-api.test.ts

@@ -18,6 +18,10 @@ import {
   extensionMock,
   functionCollectionMock,
   functionLogMock,
+  semanticDuplicatesMock,
+  semanticRecommendationsMock,
+  semanticReferenceSuggestionsMock,
+  semanticSearchMock,
 } from './mocks/entities'
 import { describe, test, expect } from 'vitest'
 import { toPlainObject } from 'contentful-sdk-core'
@@ -771,6 +775,62 @@ describe('A createEnvironmentApi', () => {
     })
   })
 
+  test('API call getSemanticDuplicates', async () => {
+    return makeGetEntityTest(setup, {
+      entityType: 'SemanticDuplicates',
+      mockToReturn: semanticDuplicatesMock,
+      methodToTest: 'getSemanticDuplicates',
+    })
+  })
+
+  test('API call getSemanticDuplicates fails', async () => {
+    return makeEntityMethodFailingTest(setup, {
+      methodToTest: 'getSemanticDuplicates',
+    })
+  })
+
+  test('API call getSemanticRecommendations', async () => {
+    return makeGetEntityTest(setup, {
+      entityType: 'SemanticRecommendations',
+      mockToReturn: semanticRecommendationsMock,
+      methodToTest: 'getSemanticRecommendations',
+    })
+  })
+
+  test('API call getSemanticRecommendations fails', async () => {
+    return makeEntityMethodFailingTest(setup, {
+      methodToTest: 'getSemanticRecommendations',
+    })
+  })
+
+  test('API call getSemanticReferenceSuggestions', async () => {
+    return makeGetEntityTest(setup, {
+      entityType: 'SemanticReferenceSuggestions',
+      mockToReturn: semanticReferenceSuggestionsMock,
+      methodToTest: 'getSemanticReferenceSuggestions',
+    })
+  })
+
+  test('API call getSemanticReferenceSuggestions fails', async () => {
+    return makeEntityMethodFailingTest(setup, {
+      methodToTest: 'getSemanticReferenceSuggestions',
+    })
+  })
+
+  test('API call getSemanticSearch', async () => {
+    return makeGetEntityTest(setup, {
+      entityType: 'SemanticSearch',
+      mockToReturn: semanticSearchMock,
+      methodToTest: 'getSemanticSearch',
+    })
+  })
+
+  test('API call getSemanticSearch fails', async () => {
+    return makeEntityMethodFailingTest(setup, {
+      methodToTest: 'getSemanticSearch',
+    })
+  })
+
   // Embargoed Assets
 
   test('API call createAssetKey', async () => {

test/unit/entities/semantic-duplicates.test.ts

@@ -0,0 +1,18 @@
+import { cloneMock } from '../mocks/entities'
+import setupMakeRequest from '../mocks/makeRequest'
+import { wrapSemanticDuplicates } from '../../../lib/entities/semantic-duplicates'
+import { entityWrappedTest } from '../test-creators/instance-entity-methods'
+import { describe, test } from 'vitest'
+
+function setup(promise) {
+  return {
+    makeRequest: setupMakeRequest(promise),
+    entityMock: cloneMock('semanticDuplicates'),
+  }
+}
+
+describe('Entity SemanticDuplicates', () => {
+  test('SemanticDuplicates is wrapped', async () => {
+    return entityWrappedTest(setup, { wrapperMethod: wrapSemanticDuplicates })
+  })
+})

test/unit/entities/semantic-recommendations.test.ts

@@ -0,0 +1,18 @@
+import { cloneMock } from '../mocks/entities'
+import setupMakeRequest from '../mocks/makeRequest'
+import { wrapSemanticRecommendations } from '../../../lib/entities/semantic-recommendations'
+import { entityWrappedTest } from '../test-creators/instance-entity-methods'
+import { describe, test } from 'vitest'
+
+function setup(promise) {
+  return {
+    makeRequest: setupMakeRequest(promise),
+    entityMock: cloneMock('semanticRecommendations'),
+  }
+}
+
+describe('Entity SemanticRecommendations', () => {
+  test('SemanticRecommendations is wrapped', async () => {
+    return entityWrappedTest(setup, { wrapperMethod: wrapSemanticRecommendations })
+  })
+})

test/unit/entities/semantic-reference-suggestions.test.ts

@@ -0,0 +1,18 @@
+import { cloneMock } from '../mocks/entities'
+import setupMakeRequest from '../mocks/makeRequest'
+import { wrapSemanticReferenceSuggestions } from '../../../lib/entities/semantic-reference-suggestions'
+import { entityWrappedTest } from '../test-creators/instance-entity-methods'
+import { describe, test } from 'vitest'
+
+function setup(promise) {
+  return {
+    makeRequest: setupMakeRequest(promise),
+    entityMock: cloneMock('semanticReferenceSuggestions'),
+  }
+}
+
+describe('Entity SemanticReferenceSuggestions', () => {
+  test('SemanticReferenceSuggestions is wrapped', async () => {
+    return entityWrappedTest(setup, { wrapperMethod: wrapSemanticReferenceSuggestions })
+  })
+})

test/unit/entities/semantic-search.test.ts

@@ -0,0 +1,18 @@
+import { cloneMock } from '../mocks/entities'
+import setupMakeRequest from '../mocks/makeRequest'
+import { wrapSemanticSearch } from '../../../lib/entities/semantic-search'
+import { entityWrappedTest } from '../test-creators/instance-entity-methods'
+import { describe, test } from 'vitest'
+
+function setup(promise) {
+  return {
+    makeRequest: setupMakeRequest(promise),
+    entityMock: cloneMock('semanticSearch'),
+  }
+}
+
+describe('Entity SemanticSearch', () => {
+  test('SemanticSearch is wrapped', async () => {
+    return entityWrappedTest(setup, { wrapperMethod: wrapSemanticSearch })
+  })
+})

test/unit/mocks/entities.ts

@@ -84,7 +84,14 @@ import {
   AiActionInvocationProps,
   AiActionInvocationType,
 } from '../../../lib/entities/ai-action-invocation'
-import { VectorizationStatusProps } from '../../../lib/entities/vectorization-status'
+import {
+  EmbeddingSetStatus,
+  VectorizationStatusProps,
+} from '../../../lib/entities/vectorization-status'
+import { SemanticDuplicatesProps } from '../../../lib/entities/semantic-duplicates'
+import { SemanticReferenceSuggestionsProps } from '../../../lib/entities/semantic-reference-suggestions'
+import { SemanticSearchProps } from '../../../lib/entities/semantic-search'
+import { SemanticRecommendationsProps } from '../../../lib/entities/semantic-recommendations'
 
 const linkMock: MetaLinkProps = {
   id: 'linkid',
@@ -1391,6 +1398,75 @@ const vectorizationStatusMock: VectorizationStatusProps = {
     {
       sys: {
         space: makeLink('Space', 'mock-space-id'),
+        status: EmbeddingSetStatus.ACTIVE,
+        type: 'VectorizationStatus',
+        createdAt: '2025-01-01T10:00:00Z',
+        updatedAt: '2025-01-01T10:00:00Z',
+      },
+    },
+  ],
+}
+
+const semanticDuplicatesMock: SemanticDuplicatesProps = {
+  sys: {
+    type: 'Array',
+  },
+  items: [
+    {
+      sys: {
+        entity: makeLink('Entry', 'mock-entry-id'),
+        space: makeLink('Space', 'mock-space-id'),
+        environment: makeLink('Environment', 'mock-environment-id'),
+        type: 'SemanticDuplicatesResult',
+      },
+      label: 'high',
+    },
+  ],
+}
+
+const semanticRecommendationsMock: SemanticRecommendationsProps = {
+  sys: {
+    type: 'Array',
+  },
+  items: [
+    {
+      sys: {
+        entity: makeLink('Entry', 'mock-entry-id'),
+        space: makeLink('Space', 'mock-space-id'),
+        environment: makeLink('Environment', 'mock-environment-id'),
+        type: 'SemanticRecommendationsResult',
+      },
+    },
+  ],
+}
+
+const semanticReferenceSuggestionsMock: SemanticReferenceSuggestionsProps = {
+  sys: {
+    type: 'Array',
+  },
+  items: [
+    {
+      sys: {
+        entity: makeLink('Entry', 'mock-entry-id'),
+        space: makeLink('Space', 'mock-space-id'),
+        environment: makeLink('Environment', 'mock-environment-id'),
+        type: 'SemanticReferenceSuggestionsResult',
+      },
+    },
+  ],
+}
+
+const semanticSearchMock: SemanticSearchProps = {
+  sys: {
+    type: 'Array',
+  },
+  items: [
+    {
+      sys: {
+        entity: makeLink('Entry', 'mock-entry-id'),
+        space: makeLink('Space', 'mock-space-id'),
+        environment: makeLink('Environment', 'mock-environment-id'),
+        type: 'SemanticSearchResult',
       },
     },
   ],
@@ -1457,6 +1533,10 @@ const mocks = {
   resourceProvider: resourceProviderMock,
   resourceType: resourceTypeMock,
   scheduledAction: scheduledActionMock,
+  semanticDuplicates: semanticDuplicatesMock,
+  semanticRecommendations: semanticRecommendationsMock,
+  semanticReferenceSuggestions: semanticReferenceSuggestionsMock,
+  semanticSearch: semanticSearchMock,
   snapshot: snapShotMock,
   spaceMember: spaceMemberMock,
   spaceMembership: spaceMembershipMock,
@@ -1726,6 +1806,18 @@ function setupEntitiesMock() {
     VectorizationStatus: {
       wrapVectorizationStatus: vi.fn(),
     },
+    SemanticDuplicates: {
+      wrapSemanticDuplicates: vi.fn(),
+    },
+    SemanticRecommendations: {
+      wrapSemanticRecommendations: vi.fn(),
+    },
+    SemanticReferenceSuggestions: {
+      wrapSemanticReferenceSuggestions: vi.fn(),
+    },
+    SemanticSearch: {
+      wrapSemanticSearch: vi.fn(),
+    },
   }
 
   return entitiesMock
@@ -1800,4 +1892,8 @@ export {
   functionLogMock,
   functionLogCollectionMock,
   vectorizationStatusMock,
+  semanticDuplicatesMock,
+  semanticRecommendationsMock,
+  semanticReferenceSuggestionsMock,
+  semanticSearchMock,
 }