chore: generate test

Author: shortcuts

clients/algoliasearch-client-javascript/packages/client-common/src/transporter/errors.ts

@@ -12,6 +12,24 @@ export class AlgoliaError extends Error {
   }
 }
 
+export class IndexNotFoundError extends AlgoliaError {
+  constructor(indexName: string) {
+    super(`${indexName} does not exist`, 'IndexNotFoundError');
+  }
+}
+
+export class IndicesInSameAppError extends AlgoliaError {
+  constructor() {
+    super('Indices are in the same application. Use operationIndex instead.', 'IndicesInSameAppError');
+  }
+}
+
+export class IndexAlreadyExistsError extends AlgoliaError {
+  constructor(indexName: string) {
+    super(`${indexName} index already exists.`, 'IndexAlreadyExistsError');
+  }
+}
+
 export class ErrorWithStackTrace extends AlgoliaError {
   stackTrace: StackFrame[];
 

playground/javascript/node/algoliasearch.ts

@@ -131,4 +131,14 @@ async function testAlgoliasearch() {
   }
 }
 
-testAlgoliasearch();
+async function testAccountCopyIndex() {
+  try {
+    await client.accountCopyIndex({destinationClient: client, destinationIndexName: "foo", sourceIndexName: "bar"})
+  } catch(e) {
+    console.log(e)
+  }
+
+}
+
+// testAlgoliasearch();
+testAccountCopyIndex()

playground/javascript/node/realtimePersonalization.ts

@@ -0,0 +1,187 @@
+import type { Server } from 'http';
+
+import { expect } from 'chai';
+import type { Express } from 'express';
+import express from 'express';
+
+import { setupServer } from './index.ts';
+
+const aciState: Record<
+  string,
+  {
+    setSettingsCount: number;
+    getSettingsCount: number;
+    saveRulesCount: number;
+    browseRulesCount: number;
+    saveSynonymsCount: number;
+    browseSynonymsCount: number;
+    saveObjectsCount: number;
+    browseObjectsCount: number;
+    waitTaskCount: number;
+    successful: boolean;
+  }
+> = {};
+
+export function assertValidAccountCopyIndex(expectedCount: number): void {
+  expect(Object.keys(aciState)).to.have.length(expectedCount);
+  for (const lang in aciState) {
+    expect(aciState[lang].successful).to.equal(true);
+  }
+}
+
+function addRoutes(app: Express): void {
+  app.use(express.urlencoded({ extended: true }));
+  app.use(
+    express.json({
+      type: ['application/json', 'text/plain'], // the js client sends the body as text/plain
+    }),
+  );
+
+  app.get('/1/indexes/:indexName/settings', (req, res) => {
+    const lang = req.params.indexName.match(/^cts_e2e_account_copy_index_(source|destination)_(.*)\d+$/)?.[1] as string;
+    expect(aciState).to.include.keys(lang);
+
+    aciState[lang].getSettingsCount++;
+
+    res.json({
+      minWordSizefor1Typo: 4,
+      minWordSizefor2Typos: 8,
+      hitsPerPage: 100,
+      maxValuesPerFacet: 100,
+      paginationLimitedTo: 10,
+      exactOnSingleWordQuery: 'attribute',
+      ranking: ['typo', 'geo', 'words', 'filters', 'proximity', 'attribute', 'exact', 'custom'],
+      separatorsToIndex: '',
+      removeWordsIfNoResults: 'none',
+      queryType: 'prefixLast',
+      highlightPreTag: '<em>',
+      highlightPostTag: '</em>',
+      alternativesAsExact: ['ignorePlurals', 'singleWordSynonym'],
+    });
+  });
+
+  app.put('/1/indexes/:indexName/settings', (req, res) => {
+    const lang = req.params.indexName.match(/^cts_e2e_account_copy_index_destination_(.*)\d+$/)?.[1] as string;
+    expect(aciState).to.include.keys(lang);
+
+    aciState[lang].setSettingsCount++;
+
+    res.json({ taskID: 123 + aciState[lang].setSettingsCount, updatedAt: '2021-01-01T00:00:00.000Z' });
+  });
+
+  app.get('/1/indexes/:indexName/rules/search', (req, res) => {
+    const lang = req.params.indexName.match(/^cts_e2e_account_copy_index_source_(.*)\d+$/)?.[1] as string;
+    expect(aciState).to.include.keys(lang);
+
+    aciState[lang].browseRulesCount++;
+
+    res.json({
+      hits: [
+        {
+          conditions: [
+            {
+              alternatives: true,
+              anchoring: 'contains',
+              pattern: 'zorro',
+            },
+          ],
+          consequence: {
+            params: {
+              ignorePlurals: 'true',
+            },
+            filterPromotes: true,
+            promote: [
+              {
+                objectIDs: ['\u00C6on Flux'],
+                position: 0,
+              },
+            ],
+          },
+          description: 'test_rule',
+          enabled: true,
+          objectID: 'qr-1725004648916',
+        },
+      ],
+      nbHits: 1,
+      nbPages: 1,
+      page: 0,
+    });
+  });
+
+  app.post('/1/indexes/:indexName/rules/batch', (req, res) => {
+    const lang = req.params.indexName.match(/^cts_e2e_account_copy_index_destination_(.*)\d+$/)?.[1] as string;
+    expect(aciState).to.include.keys(lang);
+
+    aciState[lang].saveRulesCount++;
+
+    res.json({ taskID: 456 + aciState[lang].saveRulesCount, updatedAt: '2021-01-01T00:00:00.000Z' });
+  });
+
+  app.get('/1/indexes/:indexName/synonyms/search', (req, res) => {
+    const lang = req.params.indexName.match(/^cts_e2e_account_copy_index_source_(.*)\d+$/)?.[1] as string;
+    expect(aciState).to.include.keys(lang);
+
+    aciState[lang].browseSynonymsCount++;
+
+    res.json({
+      hits: [
+        {
+          objectID: 'foo',
+        },
+      ],
+      nbHits: 1,
+      nbPages: 1,
+      page: 0,
+    });
+  });
+
+  app.post('/1/indexes/:indexName/synonyms/batch', (req, res) => {
+    const lang = req.params.indexName.match(/^cts_e2e_account_copy_index_destination_(.*)\d+$/)?.[1] as string;
+    expect(aciState).to.include.keys(lang);
+
+    aciState[lang].saveSynonymsCount++;
+
+    res.json({ taskID: 789 + aciState[lang].saveSynonymsCount, updatedAt: '2021-01-01T00:00:00.000Z' });
+  });
+
+  app.post('/1/indexes/:indexName/browse', (req, res) => {
+    const lang = req.params.indexName.match(/^cts_e2e_account_copy_index_source_(.*)\d+$/)?.[1] as string;
+    expect(aciState).to.include.keys(lang);
+
+    aciState[lang].browseObjectsCount++;
+
+    res.json({
+      page: 0,
+      nbHits: 1,
+      nbPages: 1,
+      hitsPerPage: 1000,
+      query: '',
+      params: '',
+      hits: [{ objectID: 'bar' }],
+    });
+  });
+
+  app.post('/1/indexes/:indexName/batch', (req, res) => {
+    const lang = req.params.indexName.match(/^cts_e2e_account_copy_index_destination_(.*)\d+$/)?.[1] as string;
+    expect(aciState).to.include.keys(lang);
+
+    aciState[lang].saveObjectsCount++;
+
+    res.json({ taskID: 10 + aciState[lang].saveObjectsCount, updatedAt: '2021-01-01T00:00:00.000Z' });
+  });
+
+  app.get('/1/indexes/:indexName/task/:taskID', (req, res) => {
+    const lang = req.params.indexName.match(/^cts_e2e_account_copy_index_destination_(.*)\d+$/)?.[1] as string;
+    expect(aciState).to.include.keys(lang);
+
+    aciState[lang].waitTaskCount++;
+
+    res.json({ status: 'published', updatedAt: '2021-01-01T00:00:00.000Z' });
+  });
+}
+
+export function accountCopyIndexServer(): Promise<Server> {
+  // this server is used to simulate the responses for the accountCopyIndex method,
+  // and uses a state machine to determine if the logic is correct.
+  return setupServer('accountCopyIndex', 6687, addRoutes);
+}

scripts/cts/testServer/accountCopyIndex.ts

@@ -7,6 +7,7 @@ import { createSpinner } from '../../spinners.ts';
 import type { CTSType } from '../runCts.ts';
 
 import { expect } from 'chai';
+import { accountCopyIndexServer } from './accountCopyIndex.ts';
 import { algoliaMockServer } from './algoliaMock.ts';
 import { apiKeyServer } from './apiKey.ts';
 import { benchmarkServer } from './benchmark.ts';
@@ -26,6 +27,7 @@ export async function startTestServer(suites: Record<CTSType, boolean>): Promise
       timeoutServer(),
       gzipServer(),
       timeoutServerBis(),
+      accountCopyIndexServer(),
       replaceAllObjectsServer(),
       replaceAllObjectsServerFailed(),
       replaceAllObjectsScopesServer(),

scripts/cts/testServer/index.ts

@@ -1,28 +1,34 @@
 method:
-  post:
+  get:
     x-helper: true
     tags:
       - Account
     operationId: accountCopyIndex
-    summary: Copies the index of an Algolia application, to an other Algolia application
+    summary: Copies the given `sourceIndexName` records, rules and synonyms to an other Algolia application for the given `destinationIndexName`
     description: |
-      Copies the index of an Algolia application, to an other Algolia application.
+      Copies the given `sourceIndexName` records, rules and synonyms to an other Algolia application for the given `destinationIndexName`.
     parameters:
       - in: query
         name: sourceIndexName
-        description: The name of the index to copy in the `sourceClient`.
+        description: The name of the index to copy.
         required: true
         schema:
           type: string
       - in: query
-        name: destinationClient
-        description: The already initialized search client with write ACL credentials, this is the application to copy the index to.
+        name: destinationAppID
+        description: The application ID to write the index to.
         required: true
         schema:
-          type: object
+          type: string
+      - in: query
+        name: destinationApiKey
+        description: The API Key of the `destinationAppID` to write the index to, must have write ACLs.
+        required: true
+        schema:
+          type: string
       - in: query
         name: destinationIndexName
-        description: The name of the index to write the copied index to in the `destinationClient`.
+        description: The name of the index to write the copied index to.
         required: true
         schema:
           type: string

specs/search/helpers/accountCopyIndex.yml

@@ -372,6 +372,9 @@ paths:
   /generateSecuredApiKey:
     $ref: 'helpers/generateSecuredApiKey.yml#/method'
 
+  /accountCopyIndex:
+    $ref: 'helpers/accountCopyIndex.yml#/method'
+
   /replaceAllObjects:
     $ref: 'helpers/replaceAllObjects.yml#/method'