From de7afdf9aa623da4de8c53ecf1e282d628865a37 Mon Sep 17 00:00:00 2001 From: Charlotte Vermandel Date: Tue, 14 Jun 2022 15:23:33 +0200 Subject: [PATCH 01/11] Update tasks API --- src/clients/client.ts | 50 ++++--- src/indexes.ts | 37 +++--- src/task.ts | 88 +++++-------- src/types/types.ts | 17 ++- tests/task.test.ts | 182 ++++++++++++++------------ tests/utils/meilisearch-test-utils.ts | 19 ++- 6 files changed, 190 insertions(+), 203 deletions(-) diff --git a/src/clients/client.ts b/src/clients/client.ts index 26282c7c2..bea58dfba 100644 --- a/src/clients/client.ts +++ b/src/clients/client.ts @@ -24,6 +24,8 @@ import { Result, TokenSearchRules, TokenOptions, + TaskParams, + WaitOptions, } from '../types' import { HttpRequests } from '../http-requests' import { TaskClient } from '../task' @@ -87,8 +89,8 @@ class Client { * @returns {Promise} Promise returning array of raw index information */ async getIndexes(): Promise { - const response = await this.getRawIndexes() - const indexes: Index[] = response.map( + const { results } = await this.getRawIndexes() + const indexes: Index[] = results.map( (index) => new Index(this.config, index.uid, index.primaryKey) ) return indexes @@ -98,11 +100,11 @@ class Client { * Get all the indexes in their raw value (no Index instances). * @memberof MeiliSearch * @method getRawIndexes - * @returns {Promise} Promise returning array of raw index information + * @returns {Promise>} Promise returning array of raw index information */ - async getRawIndexes(): Promise { + async getRawIndexes(): Promise> { const url = `indexes` - return await this.httpRequest.get(url) + return await this.httpRequest.get>(url) } /** @@ -177,61 +179,57 @@ class Client { * @method getTasks * @returns {Promise>} - Promise returning all tasks */ - async getTasks(): Promise> { - return await this.tasks.getClientTasks() + async getTasks(params?: TaskParams): Promise> { + return await this.tasks.getTasks(params) } /** * Get one task on the client scope * @memberof MeiliSearch * @method getTask - * @param {number} taskId - Task identifier + * @param {number} taskUid - Task identifier * @returns {Promise} - Promise returning a task */ - async getTask(taskId: number): Promise { - return await this.tasks.getClientTask(taskId) + async getTask(taskUid: number): Promise { + return await this.tasks.getTask(taskUid) } /** - * Wait for a batch of tasks to be processed. + * Wait for multiple tasks to be finished. + * * @memberof MeiliSearch * @method waitForTasks - * @param {number[]} taskIds - Tasks identifier + * @param {number[]} taskUids - Tasks identifier * @param {WaitOptions} waitOptions - Options on timeout and interval * * @returns {Promise>} - Promise returning an array of tasks */ async waitForTasks( - taskIds: number[], - { - timeOutMs = 5000, - intervalMs = 50, - }: { timeOutMs?: number; intervalMs?: number } = {} + taskUids: number[], + { timeOutMs = 5000, intervalMs = 50 }: WaitOptions = {} ): Promise> { - return await this.tasks.waitForClientTasks(taskIds, { + return await this.tasks.waitForTasks(taskUids, { timeOutMs, intervalMs, }) } /** - * Wait for a task to be processed. + * Wait for a task to be finished. * * @memberof MeiliSearch * @method waitForTask - * @param {number} taskId - Task identifier + * + * @param {number} taskUid - Task identifier * @param {WaitOptions} waitOptions - Options on timeout and interval * * @returns {Promise} - Promise returning an array of tasks */ async waitForTask( - taskId: number, - { - timeOutMs = 5000, - intervalMs = 50, - }: { timeOutMs?: number; intervalMs?: number } = {} + taskUid: number, + { timeOutMs = 5000, intervalMs = 50 }: WaitOptions = {} ): Promise { - return await this.tasks.waitForClientTask(taskId, { + return await this.tasks.waitForTask(taskUid, { timeOutMs, intervalMs, }) diff --git a/src/indexes.ts b/src/indexes.ts index 670eef4b3..7567180a1 100644 --- a/src/indexes.ts +++ b/src/indexes.ts @@ -35,6 +35,7 @@ import { DisplayedAttributes, TypoTolerance, Result, + WaitOptions, } from './types' import { removeUndefinedFromObject } from './utils' import { HttpRequests } from './http-requests' @@ -222,7 +223,7 @@ class Index> { /// /** - * Get the list of all the index tasks. + * Get the list of all the tasks of the index. * * @memberof Indexes * @method getTasks @@ -230,7 +231,7 @@ class Index> { * @returns {Promise>} - Promise containing all tasks */ async getTasks(): Promise> { - return await this.tasks.getIndexTasks(this.uid) + return await this.tasks.getTasks({ indexUid: this.uid }) } /** @@ -238,55 +239,49 @@ class Index> { * * @memberof Indexes * @method getTask - * @param {number} taskId - Task identifier + * @param {number} taskUid - Task identifier * * @returns {Promise} - Promise containing a task */ - async getTask(taskId: number): Promise { - return await this.tasks.getIndexTask(this.uid, taskId) + async getTask(taskUid: number): Promise { + return await this.tasks.getTask(taskUid) } /** - * Wait for a batch of an index tasks to be processed. + * Wait for multiple tasks to be processed. * * @memberof Indexes * @method waitForTasks - * @param {number[]} taskIds - Tasks identifier + * @param {number[]} taskUids - Tasks identifier * @param {WaitOptions} waitOptions - Options on timeout and interval * * @returns {Promise>} - Promise containing an array of tasks */ async waitForTasks( - taskIds: number[], - { - timeOutMs = 5000, - intervalMs = 50, - }: { timeOutMs?: number; intervalMs?: number } = {} + taskUids: number[], + { timeOutMs = 5000, intervalMs = 50 }: WaitOptions = {} ): Promise> { - return await this.tasks.waitForClientTasks(taskIds, { + return await this.tasks.waitForTasks(taskUids, { timeOutMs, intervalMs, }) } /** - * Wait for an index task to be processed. + * Wait for a task to be processed. * * @memberof Indexes * @method waitForTask - * @param {number} taskId - Task identifier + * @param {number} taskuid - Task identifier * @param {WaitOptions} waitOptions - Options on timeout and interval * * @returns {Promise} - Promise containing an array of tasks */ async waitForTask( - taskId: number, - { - timeOutMs = 5000, - intervalMs = 50, - }: { timeOutMs?: number; intervalMs?: number } = {} + taskuid: number, + { timeOutMs = 5000, intervalMs = 50 }: WaitOptions = {} ): Promise { - return await this.tasks.waitForClientTask(taskId, { + return await this.tasks.waitForTask(taskuid, { timeOutMs, intervalMs, }) diff --git a/src/task.ts b/src/task.ts index 0b529b770..7c2bd4ffb 100644 --- a/src/task.ts +++ b/src/task.ts @@ -1,5 +1,12 @@ import { MeiliSearchTimeOutError } from './errors' -import { Config, Task, WaitOptions, TaskStatus, Result } from './types' +import { + Config, + Task, + WaitOptions, + TaskStatus, + Result, + TaskParams, +} from './types' import { HttpRequests } from './http-requests' import { sleep } from './utils' @@ -10,24 +17,27 @@ class TaskClient { this.httpRequest = new HttpRequests(config) } - async getClientTask(uid: string | number): Promise { + /** + * Get one task + * + * @param {number} uid - unique identifier of the task + * + * @returns { Promise> } + */ + async getTask(uid: number): Promise { const url = `tasks/${uid}` return await this.httpRequest.get(url) } - - async getClientTasks(): Promise> { + /** + * Get tasks + * + * @param {TaskParams} params - query parameters + * + * @returns { Promise> } + */ + async getTasks(params: TaskParams = {}): Promise> { const url = `tasks` - return await this.httpRequest.get>(url) - } - - async getIndexTask(indexUid: string | number, taskId: number): Promise { - const url = `indexes/${indexUid}/tasks/${taskId}` - return await this.httpRequest.get(url) - } - - async getIndexTasks(indexUid: string | number): Promise> { - const url = `indexes/${indexUid}/tasks` - return await this.httpRequest.get>(url) + return await this.httpRequest.get>(url, params) } /** @@ -35,15 +45,16 @@ class TaskClient { * * @param {number} uid Task identifier * @param {WaitOptions} options Additional configuration options + * * @returns {Promise} Promise returning a task after it has been processed */ - async waitForClientTask( - taskId: number, + async waitForTask( + taskUid: number, { timeOutMs = 5000, intervalMs = 50 }: WaitOptions = {} ): Promise { const startingTime = Date.now() while (Date.now() - startingTime < timeOutMs) { - const response = await this.getClientTask(taskId) + const response = await this.getTask(taskUid) if ( ![TaskStatus.TASK_ENQUEUED, TaskStatus.TASK_PROCESSING].includes( response.status @@ -53,24 +64,25 @@ class TaskClient { await sleep(intervalMs) } throw new MeiliSearchTimeOutError( - `timeout of ${timeOutMs}ms has exceeded on process ${taskId} when waiting a task to be resolved.` + `timeout of ${timeOutMs}ms has exceeded on process ${taskUid} when waiting a task to be resolved.` ) } /** * Waits for multiple tasks to be processed * - * @param {number} taskIds Tasks identifier list + * @param {number} taskUids Tasks identifier list * @param {WaitOptions} options Wait options + * * @returns {Promise>} Promise returning a list of tasks after they have been processed */ - async waitForClientTasks( - taskIds: number[], + async waitForTasks( + taskUids: number[], { timeOutMs = 5000, intervalMs = 50 }: WaitOptions = {} ): Promise> { const tasks: Task[] = [] - for (const taskId of taskIds) { - const task = await this.waitForClientTask(taskId, { + for (const taskUid of taskUids) { + const task = await this.waitForTask(taskUid, { timeOutMs, intervalMs, }) @@ -78,34 +90,6 @@ class TaskClient { } return { results: tasks } } - - /** - * Waits for a task to be processed - * - * @param {number} taskId Task identifier - * @param {WaitOptions} options Wait options - * @returns {Promise} Promise returning a task after it has been processed - */ - async waitForIndexTask( - indexUid: number | string, - taskId: number, - { timeOutMs = 5000, intervalMs = 50 }: WaitOptions = {} - ): Promise { - const startingTime = Date.now() - while (Date.now() - startingTime < timeOutMs) { - const response = await this.getIndexTask(indexUid, taskId) - if ( - ![TaskStatus.TASK_ENQUEUED, TaskStatus.TASK_PROCESSING].includes( - response.status - ) - ) - return response - await sleep(intervalMs) - } - throw new MeiliSearchTimeOutError( - `timeout of ${timeOutMs}ms has exceeded on process ${taskId} when waiting for pending update to resolve.` - ) - } } export { TaskClient } diff --git a/src/types/types.ts b/src/types/types.ts index dcb5c5111..86f1bb2f8 100644 --- a/src/types/types.ts +++ b/src/types/types.ts @@ -191,18 +191,21 @@ export const enum TaskStatus { TASK_ENQUEUED = 'enqueued', } +export type TaskParams = { + indexUid?: string +} + export type EnqueuedTask = { - uid: number + taskUid: number indexUid: string status: TaskStatus type: string enqueuedAt: string } -export type Task = { - status: TaskStatus +export type Task = Omit & { uid: number - type: string + batchUid: number details: { // Number of documents sent receivedDocuments?: number @@ -240,10 +243,10 @@ export type Task = { // Distinct attribute on settings actions distinctAttribute: DistinctAttribute } - duration: string - enqueuedAt: string - processedAt: string error?: MeiliSearchErrorInfo + duration: string + startedAt: string + finishedAt: string } export type EnqueuedDump = { diff --git a/tests/task.test.ts b/tests/task.test.ts index d5fe8bc10..b2cd8c4f8 100644 --- a/tests/task.test.ts +++ b/tests/task.test.ts @@ -19,128 +19,134 @@ afterAll(() => { }) describe.each([{ permission: 'Master' }, { permission: 'Private' }])( - 'Test on updates', + 'Tests on tasks', ({ permission }) => { beforeEach(async () => { const client = await getClient('Master') - const { uid } = await client.createIndex(index.uid) - await client.waitForTask(uid) + const { taskUid } = await client.createIndex(index.uid) + await client.waitForTask(taskUid) }) test(`${permission} key: Get one enqueued task`, async () => { const client = await getClient(permission) - const response: EnqueuedTask = await client + + const enqueuedTask: EnqueuedTask = await client .index(index.uid) .addDocuments(dataset) - expect(response).toHaveProperty('uid', expect.any(Number)) - expect(response).toHaveProperty('indexUid', index.uid) - expect(response).toHaveProperty('status') - expect(response).toHaveProperty('type', 'documentAddition') - expect(response).toHaveProperty('enqueuedAt') - await client.waitForTask(response.uid) - - const stausReponse: Task = await client - .index(index.uid) - .getTask(response.uid) - - expect(stausReponse).toHaveProperty('status', TaskStatus.TASK_SUCCEEDED) - expect(stausReponse).toHaveProperty('uid', expect.any(Number)) - expect(stausReponse).toHaveProperty('type', 'documentAddition') - expect(stausReponse).toHaveProperty('details') - expect(stausReponse.details).toHaveProperty('indexedDocuments', 7) - expect(stausReponse.details).toHaveProperty('receivedDocuments', 7) - expect(stausReponse).toHaveProperty('duration', expect.any(String)) - expect(stausReponse).toHaveProperty('enqueuedAt', expect.any(String)) - expect(stausReponse).toHaveProperty('finishedAt', expect.any(String)) - expect(stausReponse).toHaveProperty('startedAt', expect.any(String)) + + expect(enqueuedTask.taskUid).toBeDefined() + expect(enqueuedTask.indexUid).toEqual(index.uid) + expect(enqueuedTask.status).toBeDefined() + expect(enqueuedTask.type).toEqual('documentAdditionOrUpdate') + expect(enqueuedTask.enqueuedAt).toBeDefined() }) - test(`${permission} key: Get one update`, async () => { + test(`${permission} key: Get one task`, async () => { const client = await getClient(permission) - const response: EnqueuedTask = await client + const enqueuedTask: EnqueuedTask = await client .index(index.uid) .addDocuments(dataset) - expect(response).toHaveProperty('uid', expect.any(Number)) - await client.waitForTask(response.uid) - - const stausReponse: Task = await client - .index(index.uid) - .getTask(response.uid) - - expect(stausReponse).toHaveProperty('status', TaskStatus.TASK_SUCCEEDED) - expect(stausReponse).toHaveProperty('uid', expect.any(Number)) - expect(stausReponse).toHaveProperty('type', 'documentAddition') - expect(stausReponse).toHaveProperty('details') - expect(stausReponse.details).toHaveProperty('indexedDocuments', 7) - expect(stausReponse.details).toHaveProperty('receivedDocuments', 7) - expect(stausReponse).toHaveProperty('duration', expect.any(String)) - expect(stausReponse).toHaveProperty('enqueuedAt', expect.any(String)) - expect(stausReponse).toHaveProperty('finishedAt', expect.any(String)) - expect(stausReponse).toHaveProperty('startedAt', expect.any(String)) + await client.waitForTask(enqueuedTask.taskUid) + + const task: Task = await client.getTask(enqueuedTask.taskUid) + + expect(task.indexUid).toEqual(index.uid) + expect(task.status).toEqual(TaskStatus.TASK_SUCCEEDED) + expect(task.type).toEqual('documentAdditionOrUpdate') + expect(task.enqueuedAt).toBeDefined() + expect(task.uid).toEqual(enqueuedTask.taskUid) + expect(task).toHaveProperty('details') + expect(task.details.indexedDocuments).toEqual(7) + expect(task.details.receivedDocuments).toEqual(7) + expect(task.duration).toBeDefined() + expect(task.enqueuedAt).toBeDefined() + expect(task.finishedAt).toBeDefined() + expect(task.startedAt).toBeDefined() }) - test(`${permission} key: Get all updates`, async () => { + test(`${permission} key: Get all tasks`, async () => { const client = await getClient(permission) - const { uid } = await client.index(index.uid).addDocuments([{ id: 1 }]) - await client.waitForTask(uid) + const enqueuedTask = await client + .index(index.uid) + .addDocuments([{ id: 1 }]) + await client.waitForTask(enqueuedTask.taskUid) - const response = await client.index(index.uid).getTasks() + const tasks = await client.getTasks() - expect(response.results[0]).toHaveProperty( + expect(tasks.results[0]).toHaveProperty( 'status', TaskStatus.TASK_SUCCEEDED ) - expect(response.results[0]).toHaveProperty('uid', expect.any(Number)) - expect(response.results[0].type).toEqual('documentAddition') - expect(response.results[0]).toHaveProperty('duration', expect.any(String)) - expect(response.results[0]).toHaveProperty( - 'enqueuedAt', - expect.any(String) - ) - expect(response.results[0]).toHaveProperty( - 'finishedAt', - expect.any(String) - ) - expect(response.results[0]).toHaveProperty( - 'startedAt', - expect.any(String) - ) + // should be replaced with taskUid in v0.28.0rc1 + expect(tasks.results[0].indexUid).toEqual(index.uid) + expect(tasks.results[0].status).toEqual(TaskStatus.TASK_SUCCEEDED) + expect(tasks.results[0].type).toEqual('documentAdditionOrUpdate') + expect(tasks.results[0].enqueuedAt).toBeDefined() + expect(tasks.results[0].uid).toBeDefined() + expect(tasks.results[0].type).toEqual('documentAdditionOrUpdate') + expect(tasks.results[0].duration).toBeDefined() + expect(tasks.results[0].finishedAt).toBeDefined() + expect(tasks.results[0].startedAt).toBeDefined() }) - test(`${permission} key: Try to get update that does not exist`, async () => { + test(`${permission} key: Get all indexes tasks`, async () => { const client = await getClient(permission) - await expect( - client.index(index.uid).getTask(2545) - ).rejects.toHaveProperty('code', ErrorStatusCode.TASK_NOT_FOUND) - }) - } -) + const enqueuedTask = await client + .index(index.uid) + .addDocuments([{ id: 1 }]) + await client.waitForTask(enqueuedTask.taskUid) -describe.each([{ permission: 'Public' }])( - 'Test on updates', - ({ permission }) => { - beforeEach(async () => { - await clearAllIndexes(config) + const tasks = await client.getTasks({ indexUid: index.uid }) + + expect(tasks.results[0]).toHaveProperty( + 'status', + TaskStatus.TASK_SUCCEEDED + ) + // should be replaced with taskUid in v0.28.0rc1 + expect(tasks.results[0].indexUid).toEqual(index.uid) + expect(tasks.results[0].status).toEqual(TaskStatus.TASK_SUCCEEDED) + expect(tasks.results[0].type).toEqual('documentAdditionOrUpdate') + expect(tasks.results[0].enqueuedAt).toBeDefined() + expect(tasks.results[0].uid).toBeDefined() + expect(tasks.results[0].type).toEqual('documentAdditionOrUpdate') + expect(tasks.results[0].duration).toBeDefined() + expect(tasks.results[0].finishedAt).toBeDefined() + expect(tasks.results[0].startedAt).toBeDefined() }) - test(`${permission} key: Try to get a update and be denied`, async () => { + test(`${permission} key: Try to get a task that does not exist`, async () => { const client = await getClient(permission) - await expect(client.index(index.uid).getTask(0)).rejects.toHaveProperty( + + await expect(client.getTask(254500)).rejects.toHaveProperty( 'code', - ErrorStatusCode.INVALID_API_KEY + ErrorStatusCode.TASK_NOT_FOUND ) }) } ) -describe.each([{ permission: 'No' }])('Test on updates', ({ permission }) => { +describe.each([{ permission: 'Public' }])('Test on tasks', ({ permission }) => { + beforeEach(async () => { + await clearAllIndexes(config) + }) + + test(`${permission} key: Try to get a task and be denied`, async () => { + const client = await getClient(permission) + await expect(client.getTask(0)).rejects.toHaveProperty( + 'code', + ErrorStatusCode.INVALID_API_KEY + ) + }) +}) + +describe.each([{ permission: 'No' }])('Test on tasks', ({ permission }) => { beforeEach(async () => { await clearAllIndexes(config) }) - test(`${permission} key: Try to get an update and be denied`, async () => { + test(`${permission} key: Try to get an task and be denied`, async () => { const client = await getClient(permission) - await expect(client.index(index.uid).getTask(0)).rejects.toHaveProperty( + await expect(client.getTask(0)).rejects.toHaveProperty( 'code', ErrorStatusCode.MISSING_AUTHORIZATION_HEADER ) @@ -151,11 +157,12 @@ describe.each([ { host: BAD_HOST, trailing: false }, { host: `${BAD_HOST}/api`, trailing: false }, { host: `${BAD_HOST}/trailing/`, trailing: true }, -])('Tests on url construction', ({ host, trailing }) => { - test(`Test getUpdateStatus route`, async () => { - const route = `indexes/${index.uid}/tasks/1` +])('Tests on task url construction', ({ host, trailing }) => { + test(`Test on getTask route`, async () => { + const route = `tasks/1` const client = new MeiliSearch({ host }) const strippedHost = trailing ? host.slice(0, -1) : host + await expect(client.index(index.uid).getTask(1)).rejects.toHaveProperty( 'message', `request to ${strippedHost}/${route} failed, reason: connect ECONNREFUSED ${BAD_HOST.replace( @@ -165,10 +172,11 @@ describe.each([ ) }) - test(`Test getAllUpdateStatus route`, async () => { - const route = `indexes/${index.uid}/tasks` + test(`Test on getTasks route`, async () => { + const route = `tasks?indexUid=movies_test` const client = new MeiliSearch({ host }) const strippedHost = trailing ? host.slice(0, -1) : host + await expect(client.index(index.uid).getTasks()).rejects.toHaveProperty( 'message', `request to ${strippedHost}/${route} failed, reason: connect ECONNREFUSED ${BAD_HOST.replace( diff --git a/tests/utils/meilisearch-test-utils.ts b/tests/utils/meilisearch-test-utils.ts index 8b843f643..ee9dfcda2 100644 --- a/tests/utils/meilisearch-test-utils.ts +++ b/tests/utils/meilisearch-test-utils.ts @@ -34,16 +34,14 @@ async function getKey(permission: string): Promise { const { results: keys } = await masterClient.getKeys() if (permission === 'Public') { - const key = keys.find((key: any) => - key.description.startsWith('Default Search API') - )?.key + const key = keys.find((key: any) => key.name === 'Default Search API Key') + ?.key return key || '' } if (permission === 'Private') { - const key = keys.find((key: any) => - key.description.startsWith('Default Admin API') - )?.key + const key = keys.find((key: any) => key.name === 'Default Admin API Key') + ?.key return key || '' } return MASTER_KEY @@ -81,14 +79,15 @@ async function getClient(permission: string): Promise { const clearAllIndexes = async (config: Config): Promise => { const client = new MeiliSearch(config) - const response = await client.getRawIndexes() - const indexes = response.map((elem) => elem.uid) + const { results } = await client.getRawIndexes() + const indexes = results.map((elem) => elem.uid) const taskIds = [] for (const indexUid of indexes) { - const { uid } = await client.index(indexUid).delete() - taskIds.push(uid) + const { taskUid } = await client.index(indexUid).delete() + taskIds.push(taskUid) } + await client.waitForTasks(taskIds) await expect(client.getIndexes()).resolves.toHaveLength(0) From 558f852e0f2411f116b517f765f45e7289f8e0a8 Mon Sep 17 00:00:00 2001 From: Charlotte Vermandel Date: Tue, 14 Jun 2022 17:04:19 +0200 Subject: [PATCH 02/11] Add additional tests on index tasks routes --- tests/task.test.ts | 59 +++++++++++++++++++++++++++++++++++++++------- 1 file changed, 50 insertions(+), 9 deletions(-) diff --git a/tests/task.test.ts b/tests/task.test.ts index b2cd8c4f8..4ba46da90 100644 --- a/tests/task.test.ts +++ b/tests/task.test.ts @@ -30,9 +30,7 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( test(`${permission} key: Get one enqueued task`, async () => { const client = await getClient(permission) - const enqueuedTask: EnqueuedTask = await client - .index(index.uid) - .addDocuments(dataset) + const enqueuedTask = await client.index(index.uid).addDocuments(dataset) expect(enqueuedTask.taskUid).toBeDefined() expect(enqueuedTask.indexUid).toEqual(index.uid) @@ -43,9 +41,7 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( test(`${permission} key: Get one task`, async () => { const client = await getClient(permission) - const enqueuedTask: EnqueuedTask = await client - .index(index.uid) - .addDocuments(dataset) + const enqueuedTask = await client.index(index.uid).addDocuments(dataset) await client.waitForTask(enqueuedTask.taskUid) const task: Task = await client.getTask(enqueuedTask.taskUid) @@ -64,6 +60,29 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( expect(task.startedAt).toBeDefined() }) + test(`${permission} key: Get one task with index instance`, async () => { + const client = await getClient(permission) + const enqueuedTask = await client.index(index.uid).addDocuments(dataset) + await client.waitForTask(enqueuedTask.taskUid) + + const task: Task = await client + .index(index.uid) + .getTask(enqueuedTask.taskUid) + + expect(task.indexUid).toEqual(index.uid) + expect(task.status).toEqual(TaskStatus.TASK_SUCCEEDED) + expect(task.type).toEqual('documentAdditionOrUpdate') + expect(task.enqueuedAt).toBeDefined() + expect(task.uid).toEqual(enqueuedTask.taskUid) + expect(task).toHaveProperty('details') + expect(task.details.indexedDocuments).toEqual(7) + expect(task.details.receivedDocuments).toEqual(7) + expect(task.duration).toBeDefined() + expect(task.enqueuedAt).toBeDefined() + expect(task.finishedAt).toBeDefined() + expect(task.startedAt).toBeDefined() + }) + test(`${permission} key: Get all tasks`, async () => { const client = await getClient(permission) const enqueuedTask = await client @@ -77,7 +96,6 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( 'status', TaskStatus.TASK_SUCCEEDED ) - // should be replaced with taskUid in v0.28.0rc1 expect(tasks.results[0].indexUid).toEqual(index.uid) expect(tasks.results[0].status).toEqual(TaskStatus.TASK_SUCCEEDED) expect(tasks.results[0].type).toEqual('documentAdditionOrUpdate') @@ -89,7 +107,7 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( expect(tasks.results[0].startedAt).toBeDefined() }) - test(`${permission} key: Get all indexes tasks`, async () => { + test(`${permission} key: Get all indexes tasks with query parameters`, async () => { const client = await getClient(permission) const enqueuedTask = await client .index(index.uid) @@ -102,7 +120,30 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( 'status', TaskStatus.TASK_SUCCEEDED ) - // should be replaced with taskUid in v0.28.0rc1 + expect(tasks.results[0].indexUid).toEqual(index.uid) + expect(tasks.results[0].status).toEqual(TaskStatus.TASK_SUCCEEDED) + expect(tasks.results[0].type).toEqual('documentAdditionOrUpdate') + expect(tasks.results[0].enqueuedAt).toBeDefined() + expect(tasks.results[0].uid).toBeDefined() + expect(tasks.results[0].type).toEqual('documentAdditionOrUpdate') + expect(tasks.results[0].duration).toBeDefined() + expect(tasks.results[0].finishedAt).toBeDefined() + expect(tasks.results[0].startedAt).toBeDefined() + }) + + test(`${permission} key: Get all indexes tasks with index instance`, async () => { + const client = await getClient(permission) + const enqueuedTask = await client + .index(index.uid) + .addDocuments([{ id: 1 }]) + await client.waitForTask(enqueuedTask.taskUid) + + const tasks = await client.index(index.uid).getTasks() + + expect(tasks.results[0]).toHaveProperty( + 'status', + TaskStatus.TASK_SUCCEEDED + ) expect(tasks.results[0].indexUid).toEqual(index.uid) expect(tasks.results[0].status).toEqual(TaskStatus.TASK_SUCCEEDED) expect(tasks.results[0].type).toEqual('documentAdditionOrUpdate') From 6058a5eeae5757425d2d539d86892c50a620be3e Mon Sep 17 00:00:00 2001 From: Charlotte Vermandel Date: Tue, 14 Jun 2022 17:04:49 +0200 Subject: [PATCH 03/11] Update readme api references --- README.md | 34 ++++++++++++++++------------------ 1 file changed, 16 insertions(+), 18 deletions(-) diff --git a/README.md b/README.md index 02bdb1da4..46a2171da 100644 --- a/README.md +++ b/README.md @@ -413,37 +413,35 @@ If you want to know more about the development workflow or want to contribute, p ### Tasks -- [Get task info using the client](https://docs.meilisearch.com/reference/api/tasks.html#get-all-tasks): +- [Get all tasks](https://docs.meilisearch.com/reference/api/tasks.html#get-all-tasks) -Task list: -`client.getTasks(): Promise>` + `client.getTasks(): Promise>` -One task: -`client.getTask(uid: number): Promise` +- [Get one task](https://docs.meilisearch.com/reference/api/tasks.html#get-task) -- [Get task info using the index](https://docs.meilisearch.com/reference/api/tasks.html#get-all-tasks-by-index): + `client.getTask(uid: number): Promise` -Task list: -`index.getTasks(): Promise>` +- [Get all tasks of an index](https://docs.meilisearch.com/reference/api/tasks.html#get-all-tasks-by-index) -One task: -`index.getTask(uid: number): Promise` + `index.getTasks(): Promise>` + +- [Get on task of an index](https://docs.meilisearch.com/reference/api/tasks.html#get-task) + + `index.getTask(uid: number): Promise` - Wait for one task: -Using de client: -`client.waitForTask(uid: number, { timeOutMs?: number, intervalMs?: number }): Promise` + `client.waitForTask(uid: number, { timeOutMs?: number, intervalMs?: number }): Promise` -Using the index: -`index.waitForTask(uid: number, { timeOutMs?: number, intervalMs?: number }): Promise` + With an index instance: + `index.waitForTask(uid: number, { timeOutMs?: number, intervalMs?: number }): Promise` - Wait for multiple tasks: -Using the client: -`client.waitForTasks(uids: number[], { timeOutMs?: number, intervalMs?: number }): Promise>` + `client.waitForTasks(uids: number[], { timeOutMs?: number, intervalMs?: number }): Promise>` -Using the index: -`index.waitForTasks(uids: number[], { timeOutMs?: number, intervalMs?: number }): Promise>` + With an index instance: + `index.waitForTasks(uids: number[], { timeOutMs?: number, intervalMs?: number }): Promise>` ### Indexes From 0fb8bbd6652598b66f152597106b461fcda19ef3 Mon Sep 17 00:00:00 2001 From: Charlotte Vermandel Date: Tue, 14 Jun 2022 17:27:42 +0200 Subject: [PATCH 04/11] Make task typs an enum --- README.md | 2 +- src/types/types.ts | 13 +++++++++++-- tests/task.test.ts | 38 ++++++++++++++++++++++++-------------- 3 files changed, 36 insertions(+), 17 deletions(-) diff --git a/README.md b/README.md index 46a2171da..e514360df 100644 --- a/README.md +++ b/README.md @@ -425,7 +425,7 @@ If you want to know more about the development workflow or want to contribute, p `index.getTasks(): Promise>` -- [Get on task of an index](https://docs.meilisearch.com/reference/api/tasks.html#get-task) +- [Get one task of an index](https://docs.meilisearch.com/reference/api/tasks.html#get-task) `index.getTask(uid: number): Promise` diff --git a/src/types/types.ts b/src/types/types.ts index 86f1bb2f8..68c41c337 100644 --- a/src/types/types.ts +++ b/src/types/types.ts @@ -197,12 +197,21 @@ export type TaskParams = { export type EnqueuedTask = { taskUid: number - indexUid: string + indexUid?: string status: TaskStatus - type: string + type: TaskTypes enqueuedAt: string } +export const enum TaskTypes { + INDEX_CREATION = 'indexCreation', + INDEX_UPDATE = 'indexUpdate', + INDEX_DELETION = 'indexDeletion', + DOCUMENTS_ADDITION_OR_UPDATE = 'documentAdditionOrUpdate', + DOCUMENTS_DELETION = 'documentsDeletion', + SETTINGS_UPDATE = 'settingsUpdate', +} + export type Task = Omit & { uid: number batchUid: number diff --git a/tests/task.test.ts b/tests/task.test.ts index 4ba46da90..91ffd9fbb 100644 --- a/tests/task.test.ts +++ b/tests/task.test.ts @@ -1,4 +1,4 @@ -import { ErrorStatusCode, EnqueuedTask, Task, TaskStatus } from '../src/types' +import { ErrorStatusCode, TaskTypes, TaskStatus } from '../src/types' import { clearAllIndexes, config, @@ -35,7 +35,7 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( expect(enqueuedTask.taskUid).toBeDefined() expect(enqueuedTask.indexUid).toEqual(index.uid) expect(enqueuedTask.status).toBeDefined() - expect(enqueuedTask.type).toEqual('documentAdditionOrUpdate') + expect(enqueuedTask.type).toEqual(TaskTypes.DOCUMENTS_ADDITION_OR_UPDATE) expect(enqueuedTask.enqueuedAt).toBeDefined() }) @@ -44,11 +44,11 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( const enqueuedTask = await client.index(index.uid).addDocuments(dataset) await client.waitForTask(enqueuedTask.taskUid) - const task: Task = await client.getTask(enqueuedTask.taskUid) + const task = await client.getTask(enqueuedTask.taskUid) expect(task.indexUid).toEqual(index.uid) expect(task.status).toEqual(TaskStatus.TASK_SUCCEEDED) - expect(task.type).toEqual('documentAdditionOrUpdate') + expect(task.type).toEqual(TaskTypes.DOCUMENTS_ADDITION_OR_UPDATE) expect(task.enqueuedAt).toBeDefined() expect(task.uid).toEqual(enqueuedTask.taskUid) expect(task).toHaveProperty('details') @@ -65,13 +65,11 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( const enqueuedTask = await client.index(index.uid).addDocuments(dataset) await client.waitForTask(enqueuedTask.taskUid) - const task: Task = await client - .index(index.uid) - .getTask(enqueuedTask.taskUid) + const task = await client.index(index.uid).getTask(enqueuedTask.taskUid) expect(task.indexUid).toEqual(index.uid) expect(task.status).toEqual(TaskStatus.TASK_SUCCEEDED) - expect(task.type).toEqual('documentAdditionOrUpdate') + expect(task.type).toEqual(TaskTypes.DOCUMENTS_ADDITION_OR_UPDATE) expect(task.enqueuedAt).toBeDefined() expect(task.uid).toEqual(enqueuedTask.taskUid) expect(task).toHaveProperty('details') @@ -98,10 +96,14 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( ) expect(tasks.results[0].indexUid).toEqual(index.uid) expect(tasks.results[0].status).toEqual(TaskStatus.TASK_SUCCEEDED) - expect(tasks.results[0].type).toEqual('documentAdditionOrUpdate') + expect(tasks.results[0].type).toEqual( + TaskTypes.DOCUMENTS_ADDITION_OR_UPDATE + ) expect(tasks.results[0].enqueuedAt).toBeDefined() expect(tasks.results[0].uid).toBeDefined() - expect(tasks.results[0].type).toEqual('documentAdditionOrUpdate') + expect(tasks.results[0].type).toEqual( + TaskTypes.DOCUMENTS_ADDITION_OR_UPDATE + ) expect(tasks.results[0].duration).toBeDefined() expect(tasks.results[0].finishedAt).toBeDefined() expect(tasks.results[0].startedAt).toBeDefined() @@ -122,10 +124,14 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( ) expect(tasks.results[0].indexUid).toEqual(index.uid) expect(tasks.results[0].status).toEqual(TaskStatus.TASK_SUCCEEDED) - expect(tasks.results[0].type).toEqual('documentAdditionOrUpdate') + expect(tasks.results[0].type).toEqual( + TaskTypes.DOCUMENTS_ADDITION_OR_UPDATE + ) expect(tasks.results[0].enqueuedAt).toBeDefined() expect(tasks.results[0].uid).toBeDefined() - expect(tasks.results[0].type).toEqual('documentAdditionOrUpdate') + expect(tasks.results[0].type).toEqual( + TaskTypes.DOCUMENTS_ADDITION_OR_UPDATE + ) expect(tasks.results[0].duration).toBeDefined() expect(tasks.results[0].finishedAt).toBeDefined() expect(tasks.results[0].startedAt).toBeDefined() @@ -146,10 +152,14 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( ) expect(tasks.results[0].indexUid).toEqual(index.uid) expect(tasks.results[0].status).toEqual(TaskStatus.TASK_SUCCEEDED) - expect(tasks.results[0].type).toEqual('documentAdditionOrUpdate') + expect(tasks.results[0].type).toEqual( + TaskTypes.DOCUMENTS_ADDITION_OR_UPDATE + ) expect(tasks.results[0].enqueuedAt).toBeDefined() expect(tasks.results[0].uid).toBeDefined() - expect(tasks.results[0].type).toEqual('documentAdditionOrUpdate') + expect(tasks.results[0].type).toEqual( + TaskTypes.DOCUMENTS_ADDITION_OR_UPDATE + ) expect(tasks.results[0].duration).toBeDefined() expect(tasks.results[0].finishedAt).toBeDefined() expect(tasks.results[0].startedAt).toBeDefined() From e70864d798a0411a811e20a7a19ba3f77cdf95fe Mon Sep 17 00:00:00 2001 From: Charlotte Vermandel Date: Tue, 14 Jun 2022 17:52:20 +0200 Subject: [PATCH 05/11] Update wait for tasks tests --- src/types/types.ts | 20 ++++---- tests/task.test.ts | 57 ++++++++++++++------- tests/wait_for_task.test.ts | 98 ++++++++++++++++++++++++++++--------- 3 files changed, 125 insertions(+), 50 deletions(-) diff --git a/src/types/types.ts b/src/types/types.ts index 68c41c337..ce34118a8 100644 --- a/src/types/types.ts +++ b/src/types/types.ts @@ -191,8 +191,19 @@ export const enum TaskStatus { TASK_ENQUEUED = 'enqueued', } +export const enum TaskTypes { + INDEX_CREATION = 'indexCreation', + INDEX_UPDATE = 'indexUpdate', + INDEX_DELETION = 'indexDeletion', + DOCUMENTS_ADDITION_OR_UPDATE = 'documentAdditionOrUpdate', + DOCUMENTS_DELETION = 'documentsDeletion', + SETTINGS_UPDATE = 'settingsUpdate', +} + export type TaskParams = { indexUid?: string + type?: TaskTypes + status?: TaskStatus } export type EnqueuedTask = { @@ -203,15 +214,6 @@ export type EnqueuedTask = { enqueuedAt: string } -export const enum TaskTypes { - INDEX_CREATION = 'indexCreation', - INDEX_UPDATE = 'indexUpdate', - INDEX_DELETION = 'indexDeletion', - DOCUMENTS_ADDITION_OR_UPDATE = 'documentAdditionOrUpdate', - DOCUMENTS_DELETION = 'documentsDeletion', - SETTINGS_UPDATE = 'settingsUpdate', -} - export type Task = Omit & { uid: number batchUid: number diff --git a/tests/task.test.ts b/tests/task.test.ts index 91ffd9fbb..1f1e9fb4c 100644 --- a/tests/task.test.ts +++ b/tests/task.test.ts @@ -109,32 +109,55 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( expect(tasks.results[0].startedAt).toBeDefined() }) - test(`${permission} key: Get all indexes tasks with query parameters`, async () => { + test(`${permission} key: Get all tasks with type filter`, async () => { const client = await getClient(permission) const enqueuedTask = await client .index(index.uid) .addDocuments([{ id: 1 }]) await client.waitForTask(enqueuedTask.taskUid) - const tasks = await client.getTasks({ indexUid: index.uid }) - - expect(tasks.results[0]).toHaveProperty( - 'status', - TaskStatus.TASK_SUCCEEDED + const tasks = await client.getTasks({ + type: TaskTypes.DOCUMENTS_ADDITION_OR_UPDATE, + }) + const onlyDocumentAddition = new Set( + tasks.results.map((task) => task.type) ) - expect(tasks.results[0].indexUid).toEqual(index.uid) - expect(tasks.results[0].status).toEqual(TaskStatus.TASK_SUCCEEDED) - expect(tasks.results[0].type).toEqual( - TaskTypes.DOCUMENTS_ADDITION_OR_UPDATE + + expect(onlyDocumentAddition.size).toEqual(1) + }) + + test(`${permission} key: Get all tasks with status filter`, async () => { + const client = await getClient(permission) + const enqueuedTask = await client + .index(index.uid) + .addDocuments([{ id: 1 }]) + await client.waitForTask(enqueuedTask.taskUid) + + const tasks = await client.getTasks({ + status: TaskStatus.TASK_SUCCEEDED, + }) + const onlySuccesFullTasks = new Set( + tasks.results.map((task) => task.status) ) - expect(tasks.results[0].enqueuedAt).toBeDefined() - expect(tasks.results[0].uid).toBeDefined() - expect(tasks.results[0].type).toEqual( - TaskTypes.DOCUMENTS_ADDITION_OR_UPDATE + + expect(onlySuccesFullTasks.size).toEqual(1) + }) + + test(`${permission} key: Get all tasks with indexUid filter`, async () => { + const client = await getClient(permission) + const enqueuedTask = await client + .index(index.uid) + .addDocuments([{ id: 1 }]) + await client.waitForTask(enqueuedTask.taskUid) + + const tasks = await client.getTasks({ + indexUid: index.uid, + }) + const onlyTaskWithSameUid = new Set( + tasks.results.map((task) => task.indexUid) ) - expect(tasks.results[0].duration).toBeDefined() - expect(tasks.results[0].finishedAt).toBeDefined() - expect(tasks.results[0].startedAt).toBeDefined() + + expect(onlyTaskWithSameUid.size).toEqual(1) }) test(`${permission} key: Get all indexes tasks with index instance`, async () => { diff --git a/tests/wait_for_task.test.ts b/tests/wait_for_task.test.ts index 730032a33..671b77eed 100644 --- a/tests/wait_for_task.test.ts +++ b/tests/wait_for_task.test.ts @@ -21,99 +21,149 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( ({ permission }) => { beforeEach(async () => { const client = await getClient('Master') - const { uid } = await client.createIndex(index.uid) - await client.waitForTask(uid) + const { taskUid } = await client.createIndex(index.uid) + await client.waitForTask(taskUid) }) - // Client Wait for tasks + // Client Wait for task test(`${permission} key: Tests wait for task in client until done and resolved`, async () => { const client = await getClient(permission) - const { uid } = await client.index(index.uid).addDocuments(dataset) - const update = await client.waitForTask(uid) + const { taskUid } = await client.index(index.uid).addDocuments(dataset) + + const update = await client.waitForTask(taskUid) + expect(update).toHaveProperty('status', TaskStatus.TASK_SUCCEEDED) }) test(`${permission} key: Tests wait for task in client with custom interval and timeout until done and resolved`, async () => { const client = await getClient(permission) - const { uid } = await client.index(index.uid).addDocuments(dataset) - const update = await client.waitForTask(uid, { + const { taskUid } = await client.index(index.uid).addDocuments(dataset) + + const update = await client.waitForTask(taskUid, { timeOutMs: 6000, intervalMs: 100, }) + expect(update).toHaveProperty('status', TaskStatus.TASK_SUCCEEDED) }) test(`${permission} key: Tests wait for task in client with custom timeout and interval at 0 done and resolved`, async () => { const client = await getClient(permission) - const { uid } = await client.index(index.uid).addDocuments(dataset) - const update = await client.waitForTask(uid, { + const { taskUid } = await client.index(index.uid).addDocuments(dataset) + + const update = await client.waitForTask(taskUid, { timeOutMs: 6000, intervalMs: 0, }) + expect(update).toHaveProperty('status', TaskStatus.TASK_SUCCEEDED) }) test(`${permission} key: Try to wait for task in client with small timeout and raise an error`, async () => { const client = await getClient(permission) - const { uid } = await client.index(index.uid).addDocuments(dataset) + + const { taskUid } = await client.index(index.uid).addDocuments(dataset) + await expect( - client.waitForTask(uid, { timeOutMs: 0 }) + client.waitForTask(taskUid, { timeOutMs: 0 }) ).rejects.toHaveProperty('name', 'MeiliSearchTimeOutError') }) - // Client Wait for tasks + // Index Wait for task + test(`${permission} key: Tests wait for task with an index instance`, async () => { + const client = await getClient(permission) + const { taskUid } = await client.index(index.uid).addDocuments(dataset) + + const update = await client.index(index.uid).waitForTask(taskUid) + + expect(update).toHaveProperty('status', TaskStatus.TASK_SUCCEEDED) + }) + // Client Wait for tasks test(`${permission} key: Tests wait for tasks in client until done and resolved`, async () => { const client = await getClient(permission) - const { uid: task1 } = await client.index(index.uid).addDocuments(dataset) - const { uid: task2 } = await client + const { taskUid: task1 } = await client + .index(index.uid) + .addDocuments(dataset) + const { taskUid: task2 } = await client .index(index.uid) - .updateSettings({ searchableAttributes: [] }) + .addDocuments(dataset) + const update = await client.waitForTasks([task1, task2]) const [update1, update2] = update.results + expect(update1).toHaveProperty('status', TaskStatus.TASK_SUCCEEDED) expect(update2).toHaveProperty('status', TaskStatus.TASK_SUCCEEDED) }) test(`${permission} key: Tests wait for tasks in client with custom interval and timeout until done and resolved`, async () => { const client = await getClient(permission) - const { uid: task1 } = await client.index(index.uid).addDocuments(dataset) - const { uid: task2 } = await client + const { taskUid: task1 } = await client .index(index.uid) - .updateSettings({ searchableAttributes: [] }) + .addDocuments(dataset) + const { taskUid: task2 } = await client + .index(index.uid) + .addDocuments(dataset) + const update = await client.waitForTasks([task1, task2], { timeOutMs: 6000, intervalMs: 100, }) const [update1, update2] = update.results + expect(update1).toHaveProperty('status', TaskStatus.TASK_SUCCEEDED) expect(update2).toHaveProperty('status', TaskStatus.TASK_SUCCEEDED) }) test(`${permission} key: Tests wait for tasks in client with custom timeout and interval at 0 done and resolved`, async () => { const client = await getClient(permission) - const { uid: task1 } = await client.index(index.uid).addDocuments(dataset) - const { uid: task2 } = await client + const { taskUid: task1 } = await client .index(index.uid) - .updateSettings({ searchableAttributes: [] }) + .addDocuments(dataset) + const { taskUid: task2 } = await client + .index(index.uid) + .addDocuments(dataset) + const update = await client.waitForTasks([task1, task2], { timeOutMs: 6000, intervalMs: 0, }) const [update1, update2] = update.results + expect(update1).toHaveProperty('status', TaskStatus.TASK_SUCCEEDED) expect(update2).toHaveProperty('status', TaskStatus.TASK_SUCCEEDED) }) test(`${permission} key: Tests to wait for tasks in client with small timeout and raise an error`, async () => { const client = await getClient(permission) - const { uid: task1 } = await client.index(index.uid).addDocuments(dataset) - const { uid: task2 } = await client + + const { taskUid: task1 } = await client + .index(index.uid) + .addDocuments(dataset) + const { taskUid: task2 } = await client .index(index.uid) - .updateSettings({ searchableAttributes: [] }) + .addDocuments(dataset) + await expect( client.waitForTasks([task1, task2], { timeOutMs: 0 }) ).rejects.toHaveProperty('name', 'MeiliSearchTimeOutError') }) + + // Index Wait for tasks + test(`${permission} key: Tests wait for tasks with indx instance`, async () => { + const client = await getClient(permission) + const { taskUid: task1 } = await client + .index(index.uid) + .addDocuments(dataset) + const { taskUid: task2 } = await client + .index(index.uid) + .addDocuments(dataset) + + const update = await client.index(index.uid).waitForTasks([task1, task2]) + const [update1, update2] = update.results + + expect(update1).toHaveProperty('status', TaskStatus.TASK_SUCCEEDED) + expect(update2).toHaveProperty('status', TaskStatus.TASK_SUCCEEDED) + }) } ) From 47a2c238b7b8ba1b6c0b4406f3e5dfbecda3254e Mon Sep 17 00:00:00 2001 From: Charlotte Vermandel Date: Tue, 14 Jun 2022 19:07:20 +0200 Subject: [PATCH 06/11] Update getTasks filter to arrays --- src/indexes.ts | 2 +- src/task.ts | 13 +++++++++++-- src/types/types.ts | 8 ++++---- tests/task.test.ts | 36 ++++++++++++++++++++++-------------- 4 files changed, 38 insertions(+), 21 deletions(-) diff --git a/src/indexes.ts b/src/indexes.ts index 7567180a1..5691a2bc7 100644 --- a/src/indexes.ts +++ b/src/indexes.ts @@ -231,7 +231,7 @@ class Index> { * @returns {Promise>} - Promise containing all tasks */ async getTasks(): Promise> { - return await this.tasks.getTasks({ indexUid: this.uid }) + return await this.tasks.getTasks({ indexUid: [this.uid] }) } /** diff --git a/src/task.ts b/src/task.ts index 7c2bd4ffb..3edc731fe 100644 --- a/src/task.ts +++ b/src/task.ts @@ -8,7 +8,7 @@ import { TaskParams, } from './types' import { HttpRequests } from './http-requests' -import { sleep } from './utils' +import { removeUndefinedFromObject, sleep } from './utils' class TaskClient { httpRequest: HttpRequests @@ -37,7 +37,16 @@ class TaskClient { */ async getTasks(params: TaskParams = {}): Promise> { const url = `tasks` - return await this.httpRequest.get>(url, params) + + const queryParams = { + indexUid: params?.indexUid?.join(','), + type: params?.type?.join(','), + status: params?.status?.join(','), + } + return await this.httpRequest.get>( + url, + removeUndefinedFromObject(queryParams) + ) } /** diff --git a/src/types/types.ts b/src/types/types.ts index ce34118a8..ee1662cd0 100644 --- a/src/types/types.ts +++ b/src/types/types.ts @@ -196,14 +196,14 @@ export const enum TaskTypes { INDEX_UPDATE = 'indexUpdate', INDEX_DELETION = 'indexDeletion', DOCUMENTS_ADDITION_OR_UPDATE = 'documentAdditionOrUpdate', - DOCUMENTS_DELETION = 'documentsDeletion', + DOCUMENT_DELETION = 'documentDeletion', SETTINGS_UPDATE = 'settingsUpdate', } export type TaskParams = { - indexUid?: string - type?: TaskTypes - status?: TaskStatus + indexUid?: string[] + type?: TaskTypes[] + status?: TaskStatus[] } export type EnqueuedTask = { diff --git a/tests/task.test.ts b/tests/task.test.ts index 1f1e9fb4c..2ea4a4793 100644 --- a/tests/task.test.ts +++ b/tests/task.test.ts @@ -12,6 +12,10 @@ const index = { uid: 'movies_test', } +const index2 = { + uid: 'movies_test2', +} + jest.setTimeout(100 * 1000) afterAll(() => { @@ -111,19 +115,23 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( test(`${permission} key: Get all tasks with type filter`, async () => { const client = await getClient(permission) - const enqueuedTask = await client - .index(index.uid) - .addDocuments([{ id: 1 }]) - await client.waitForTask(enqueuedTask.taskUid) + const task1 = await client.index(index.uid).addDocuments([{ id: 1 }]) + await client.waitForTask(task1.taskUid) + + const task2 = await client.index(index.uid).deleteDocument(1) + await client.waitForTask(task2.taskUid) const tasks = await client.getTasks({ - type: TaskTypes.DOCUMENTS_ADDITION_OR_UPDATE, + type: [ + TaskTypes.DOCUMENTS_ADDITION_OR_UPDATE, + TaskTypes.DOCUMENT_DELETION, + ], }) const onlyDocumentAddition = new Set( tasks.results.map((task) => task.type) ) - expect(onlyDocumentAddition.size).toEqual(1) + expect(onlyDocumentAddition.size).toEqual(2) }) test(`${permission} key: Get all tasks with status filter`, async () => { @@ -134,30 +142,30 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( await client.waitForTask(enqueuedTask.taskUid) const tasks = await client.getTasks({ - status: TaskStatus.TASK_SUCCEEDED, + status: [TaskStatus.TASK_SUCCEEDED, TaskStatus.TASK_FAILED], }) const onlySuccesFullTasks = new Set( tasks.results.map((task) => task.status) ) - expect(onlySuccesFullTasks.size).toEqual(1) + expect(onlySuccesFullTasks.size).toEqual(2) }) test(`${permission} key: Get all tasks with indexUid filter`, async () => { const client = await getClient(permission) - const enqueuedTask = await client - .index(index.uid) - .addDocuments([{ id: 1 }]) - await client.waitForTask(enqueuedTask.taskUid) + const task1 = await client.index(index.uid).addDocuments([{ id: 1 }]) + const task2 = await client.index(index2.uid).addDocuments([{ id: 1 }]) + await client.waitForTask(task1.taskUid) + await client.waitForTask(task2.taskUid) const tasks = await client.getTasks({ - indexUid: index.uid, + indexUid: [index.uid, index2.uid], }) const onlyTaskWithSameUid = new Set( tasks.results.map((task) => task.indexUid) ) - expect(onlyTaskWithSameUid.size).toEqual(1) + expect(onlyTaskWithSameUid.size).toEqual(2) }) test(`${permission} key: Get all indexes tasks with index instance`, async () => { From 9502482699b8ef00054c55eebe8eb82640ac6f34 Mon Sep 17 00:00:00 2001 From: Charlotte Vermandel Date: Wed, 15 Jun 2022 13:25:03 +0200 Subject: [PATCH 07/11] Fix taskUid parameter naming in waitForTask --- src/indexes.ts | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/indexes.ts b/src/indexes.ts index 5691a2bc7..7ee40c746 100644 --- a/src/indexes.ts +++ b/src/indexes.ts @@ -272,16 +272,16 @@ class Index> { * * @memberof Indexes * @method waitForTask - * @param {number} taskuid - Task identifier + * @param {number} taskUid - Task identifier * @param {WaitOptions} waitOptions - Options on timeout and interval * * @returns {Promise} - Promise containing an array of tasks */ async waitForTask( - taskuid: number, + taskUid: number, { timeOutMs = 5000, intervalMs = 50 }: WaitOptions = {} ): Promise { - return await this.tasks.waitForTask(taskuid, { + return await this.tasks.waitForTask(taskUid, { timeOutMs, intervalMs, }) From b160c8b3021e7a9c6544dee23ea930cbbe011c57 Mon Sep 17 00:00:00 2001 From: Charlotte Vermandel Date: Wed, 15 Jun 2022 13:25:20 +0200 Subject: [PATCH 08/11] Make task tests more relevant --- tests/task.test.ts | 87 +++++++++++++--------------------------------- 1 file changed, 24 insertions(+), 63 deletions(-) diff --git a/tests/task.test.ts b/tests/task.test.ts index 2ea4a4793..ffda6c6ed 100644 --- a/tests/task.test.ts +++ b/tests/task.test.ts @@ -16,6 +16,10 @@ const index2 = { uid: 'movies_test2', } +const index3 = { + uid: 'movies_test2', +} + jest.setTimeout(100 * 1000) afterAll(() => { @@ -72,17 +76,7 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( const task = await client.index(index.uid).getTask(enqueuedTask.taskUid) expect(task.indexUid).toEqual(index.uid) - expect(task.status).toEqual(TaskStatus.TASK_SUCCEEDED) - expect(task.type).toEqual(TaskTypes.DOCUMENTS_ADDITION_OR_UPDATE) - expect(task.enqueuedAt).toBeDefined() expect(task.uid).toEqual(enqueuedTask.taskUid) - expect(task).toHaveProperty('details') - expect(task.details.indexedDocuments).toEqual(7) - expect(task.details.receivedDocuments).toEqual(7) - expect(task.duration).toBeDefined() - expect(task.enqueuedAt).toBeDefined() - expect(task.finishedAt).toBeDefined() - expect(task.startedAt).toBeDefined() }) test(`${permission} key: Get all tasks`, async () => { @@ -94,32 +88,15 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( const tasks = await client.getTasks() - expect(tasks.results[0]).toHaveProperty( - 'status', - TaskStatus.TASK_SUCCEEDED - ) - expect(tasks.results[0].indexUid).toEqual(index.uid) - expect(tasks.results[0].status).toEqual(TaskStatus.TASK_SUCCEEDED) - expect(tasks.results[0].type).toEqual( - TaskTypes.DOCUMENTS_ADDITION_OR_UPDATE - ) - expect(tasks.results[0].enqueuedAt).toBeDefined() - expect(tasks.results[0].uid).toBeDefined() - expect(tasks.results[0].type).toEqual( - TaskTypes.DOCUMENTS_ADDITION_OR_UPDATE - ) - expect(tasks.results[0].duration).toBeDefined() - expect(tasks.results[0].finishedAt).toBeDefined() - expect(tasks.results[0].startedAt).toBeDefined() + expect(tasks.results).toBeInstanceOf(Array) + expect(tasks.results[0].uid).toEqual(enqueuedTask.taskUid) }) test(`${permission} key: Get all tasks with type filter`, async () => { const client = await getClient(permission) - const task1 = await client.index(index.uid).addDocuments([{ id: 1 }]) - await client.waitForTask(task1.taskUid) - - const task2 = await client.index(index.uid).deleteDocument(1) - await client.waitForTask(task2.taskUid) + await client.index(index.uid).addDocuments([{ id: 1 }]) + await client.index(index.uid).deleteDocument(1) + await client.createIndex(index2.uid) const tasks = await client.getTasks({ type: [ @@ -136,27 +113,26 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( test(`${permission} key: Get all tasks with status filter`, async () => { const client = await getClient(permission) - const enqueuedTask = await client - .index(index.uid) - .addDocuments([{ id: 1 }]) - await client.waitForTask(enqueuedTask.taskUid) + const task1 = await client.index(index.uid).addDocuments([{ id: 1 }]) + const task2 = await client.index(index.uid).addDocuments([{}]) + await client.waitForTask(task1.taskUid) + await client.waitForTask(task2.taskUid) const tasks = await client.getTasks({ status: [TaskStatus.TASK_SUCCEEDED, TaskStatus.TASK_FAILED], }) - const onlySuccesFullTasks = new Set( + const onlySuccesfullTasks = new Set( tasks.results.map((task) => task.status) ) - expect(onlySuccesFullTasks.size).toEqual(2) + expect(onlySuccesfullTasks.size).toEqual(2) }) test(`${permission} key: Get all tasks with indexUid filter`, async () => { const client = await getClient(permission) - const task1 = await client.index(index.uid).addDocuments([{ id: 1 }]) - const task2 = await client.index(index2.uid).addDocuments([{ id: 1 }]) - await client.waitForTask(task1.taskUid) - await client.waitForTask(task2.taskUid) + await client.index(index.uid).addDocuments([{ id: 1 }]) + await client.index(index2.uid).addDocuments([{ id: 1 }]) + await client.index(index3.uid).addDocuments([{ id: 1 }]) const tasks = await client.getTasks({ indexUid: [index.uid, index2.uid], @@ -170,30 +146,15 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( test(`${permission} key: Get all indexes tasks with index instance`, async () => { const client = await getClient(permission) - const enqueuedTask = await client - .index(index.uid) - .addDocuments([{ id: 1 }]) - await client.waitForTask(enqueuedTask.taskUid) + await client.index(index.uid).addDocuments([{ id: 1 }]) + await client.index(index2.uid).addDocuments([{ id: 1 }]) const tasks = await client.index(index.uid).getTasks() - - expect(tasks.results[0]).toHaveProperty( - 'status', - TaskStatus.TASK_SUCCEEDED - ) - expect(tasks.results[0].indexUid).toEqual(index.uid) - expect(tasks.results[0].status).toEqual(TaskStatus.TASK_SUCCEEDED) - expect(tasks.results[0].type).toEqual( - TaskTypes.DOCUMENTS_ADDITION_OR_UPDATE - ) - expect(tasks.results[0].enqueuedAt).toBeDefined() - expect(tasks.results[0].uid).toBeDefined() - expect(tasks.results[0].type).toEqual( - TaskTypes.DOCUMENTS_ADDITION_OR_UPDATE + const onlyTaskWithSameUid = new Set( + tasks.results.map((task) => task.indexUid) ) - expect(tasks.results[0].duration).toBeDefined() - expect(tasks.results[0].finishedAt).toBeDefined() - expect(tasks.results[0].startedAt).toBeDefined() + + expect(onlyTaskWithSameUid.size).toEqual(1) }) test(`${permission} key: Try to get a task that does not exist`, async () => { From 4d6308938af6e49111ad5326a9aa1b9968fe38d9 Mon Sep 17 00:00:00 2001 From: Charlotte Vermandel Date: Tue, 14 Jun 2022 19:26:08 +0200 Subject: [PATCH 09/11] Update the tests impacted by the task api changes --- playgrounds/javascript/src/app.js | 6 +- tests/client.test.ts | 54 +++--- tests/displayed_attributes.test.ts | 49 ++--- tests/distinct_attribute.test.ts | 44 ++--- tests/documents.test.ts | 258 ++++++++++--------------- tests/env/browser/index.html | 4 +- tests/env/express/public/headers.html | 4 +- tests/env/express/public/index.html | 6 +- tests/env/node/getting_started.js | 2 + tests/env/node/search_example.js | 8 +- tests/env/typescript-node/src/index.ts | 4 +- tests/filterable_attributes.test.ts | 32 +-- tests/get_search.test.ts | 14 +- tests/index.test.ts | 132 +++++++------ tests/ranking_rules.test.ts | 16 +- tests/search.test.ts | 24 +-- tests/searchable_attributes.test.ts | 35 ++-- tests/settings.test.ts | 85 ++++---- tests/sortable_attributes.test.ts | 55 +++--- tests/stop_words.test.ts | 18 +- tests/synonyms.test.ts | 27 ++- tests/token.test.ts | 8 +- tests/typed_search.test.ts | 25 +-- tests/typo_tolerance.test.ts | 40 ++-- 24 files changed, 431 insertions(+), 519 deletions(-) diff --git a/playgrounds/javascript/src/app.js b/playgrounds/javascript/src/app.js index 77ec9a680..6917685cf 100644 --- a/playgrounds/javascript/src/app.js +++ b/playgrounds/javascript/src/app.js @@ -10,8 +10,8 @@ const indexUid = 'movies' const addDataset = async () => { await client.deleteIndex(indexUid) - const { uid } = await client.createIndex(indexUid) - await client.index(indexUid).waitForTask(uid) + const task = await client.createIndex(indexUid) + await client.index(indexUid).waitForTask(task.taskUid) const documents = await client.index(indexUid).getDocuments() @@ -29,7 +29,7 @@ const addDataset = async () => { ] if (documents.length === 0) { const task = await client.index(indexUid).addDocuments(dataset) - await client.index(indexUid).waitForTask(task.uid) + await client.index(indexUid).waitForTask(task.taskUid) } } diff --git a/tests/client.test.ts b/tests/client.test.ts index 0d8b010c2..0fd2ac95b 100644 --- a/tests/client.test.ts +++ b/tests/client.test.ts @@ -173,19 +173,22 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( }) expect(client.config.headers).toStrictEqual({ Expect: '200-OK' }) const health = await client.isHealthy() + expect(health).toBe(true) - const status = await client.createIndex('test') - await client.waitForTask(status.uid) + + const task = await client.createIndex('test') + await client.waitForTask(task.taskUid) const indexes = await client.getIndexes() + expect(indexes.length).toBe(1) }) describe('Test on indexes methods', () => { test(`${permission} key: create with no primary key`, async () => { const client = await getClient(permission) - const task = await client.createIndex(indexNoPk.uid) - await client.waitForTask(task.uid) + await client.waitForTask(task.taskUid) + const newIndex = await client.getIndex(indexNoPk.uid) expect(newIndex).toHaveProperty('uid', indexNoPk.uid) expect(newIndex).toHaveProperty('primaryKey', null) @@ -203,11 +206,11 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( test(`${permission} key: create with primary key`, async () => { const client = await getClient(permission) - - const { uid } = await client.createIndex(indexPk.uid, { + const { taskUid } = await client.createIndex(indexPk.uid, { primaryKey: indexPk.primaryKey, }) - await client.waitForTask(uid) + await client.waitForTask(taskUid) + const newIndex = await client.getIndex(indexPk.uid) expect(newIndex).toHaveProperty('uid', indexPk.uid) @@ -226,8 +229,8 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( test(`${permission} key: get all indexes when not empty`, async () => { const client = await getClient(permission) - const { uid } = await client.createIndex(indexPk.uid) - await client.waitForTask(uid) + const { taskUid } = await client.createIndex(indexPk.uid) + await client.waitForTask(taskUid) const response: IndexResponse[] = await client.getRawIndexes() const indexes = response.map((index) => index.uid) @@ -238,15 +241,17 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( test(`${permission} key: Get index that exists`, async () => { const client = await getClient(permission) - const { uid } = await client.createIndex(indexPk.uid) - await client.waitForTask(uid) + const { taskUid } = await client.createIndex(indexPk.uid) + await client.waitForTask(taskUid) const response = await client.getIndex(indexPk.uid) + expect(response).toHaveProperty('uid', indexPk.uid) }) test(`${permission} key: Get index that does not exist`, async () => { const client = await getClient(permission) + await expect(client.getIndex('does_not_exist')).rejects.toHaveProperty( 'code', ErrorStatusCode.INDEX_NOT_FOUND @@ -255,10 +260,9 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( test(`${permission} key: update primary key`, async () => { const client = await getClient(permission) - const { uid: createTask } = await client.createIndex(indexPk.uid) + const { taskUid: createTask } = await client.createIndex(indexPk.uid) await client.waitForTask(createTask) - - const { uid: updateTask } = await client.updateIndex(indexPk.uid, { + const { taskUid: updateTask } = await client.updateIndex(indexPk.uid, { primaryKey: 'newPrimaryKey', }) await client.waitForTask(updateTask) @@ -271,12 +275,11 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( test(`${permission} key: update primary key that already exists`, async () => { const client = await getClient(permission) - const { uid: createTask } = await client.createIndex(indexPk.uid, { + const { taskUid: createTask } = await client.createIndex(indexPk.uid, { primaryKey: indexPk.primaryKey, }) await client.waitForTask(createTask) - - const { uid: updateTask } = await client.updateIndex(indexPk.uid, { + const { taskUid: updateTask } = await client.updateIndex(indexPk.uid, { primaryKey: 'newPrimaryKey', }) await client.waitForTask(updateTask) @@ -289,31 +292,34 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( test(`${permission} key: delete index`, async () => { const client = await getClient(permission) - const { uid: createTask } = await client.createIndex(indexNoPk.uid) + const { taskUid: createTask } = await client.createIndex(indexNoPk.uid) await client.waitForTask(createTask) - const { uid: deleteTask } = await client.deleteIndex(indexNoPk.uid) + const { taskUid: deleteTask } = await client.deleteIndex(indexNoPk.uid) const task = await client.waitForTask(deleteTask) - expect(task.status).toBe(TaskStatus.TASK_SUCCEEDED) + expect(task.status).toBe(TaskStatus.TASK_SUCCEEDED) await expect(client.getIndexes()).resolves.toHaveLength(0) }) test(`${permission} key: create index with already existing uid should fail`, async () => { const client = await getClient(permission) - const { uid: firstCreate } = await client.createIndex(indexPk.uid) + const { taskUid: firstCreate } = await client.createIndex(indexPk.uid) await client.waitForTask(firstCreate) - const { uid: secondCreate } = await client.createIndex(indexPk.uid) + const { taskUid: secondCreate } = await client.createIndex(indexPk.uid) const task = await client.waitForTask(secondCreate) + expect(task.status).toBe('failed') }) test(`${permission} key: delete index with uid that does not exist should fail`, async () => { const client = await getClient(permission) const index = client.index(indexNoPk.uid) - const { uid } = await index.delete() - const task = await client.waitForTask(uid) + const { taskUid } = await index.delete() + + const task = await client.waitForTask(taskUid) + expect(task.status).toEqual('failed') }) diff --git a/tests/displayed_attributes.test.ts b/tests/displayed_attributes.test.ts index 4d43b1369..3e88595b9 100644 --- a/tests/displayed_attributes.test.ts +++ b/tests/displayed_attributes.test.ts @@ -1,4 +1,4 @@ -import { EnqueuedTask, ErrorStatusCode } from '../src/types' +import { ErrorStatusCode } from '../src/types' import { clearAllIndexes, config, @@ -24,8 +24,8 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( beforeEach(async () => { await clearAllIndexes(config) const client = await getClient('Master') - const { uid } = await client.index(index.uid).addDocuments(dataset) - await client.waitForTask(uid) + const { taskUid } = await client.index(index.uid).addDocuments(dataset) + await client.waitForTask(taskUid) }) test(`${permission} key: Get default displayed attributes`, async () => { @@ -37,47 +37,36 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( test(`${permission} key: Update displayed attributes`, async () => { const client = await getClient(permission) - const newDisplayedAttribute = ['title'] - const task: EnqueuedTask = await client + const task = await client .index(index.uid) .updateDisplayedAttributes(newDisplayedAttribute) - expect(task).toHaveProperty('uid', expect.any(Number)) - await client.index(index.uid).waitForTask(task.uid) + await client.index(index.uid).waitForTask(task.taskUid) + + const response = await client.index(index.uid).getDisplayedAttributes() - const response: string[] = await client - .index(index.uid) - .getDisplayedAttributes() expect(response).toEqual(newDisplayedAttribute) }) test(`${permission} key: Update displayed attributes at null`, async () => { const client = await getClient(permission) - const task: EnqueuedTask = await client - .index(index.uid) - .updateDisplayedAttributes(null) - expect(task).toHaveProperty('uid', expect.any(Number)) - await client.index(index.uid).waitForTask(task.uid) + const task = await client.index(index.uid).updateDisplayedAttributes(null) + await client.index(index.uid).waitForTask(task.taskUid) + + const response = await client.index(index.uid).getDisplayedAttributes() - const response: string[] = await client - .index(index.uid) - .getDisplayedAttributes() expect(response).toEqual(['*']) }) test(`${permission} key: Reset displayed attributes`, async () => { const client = await getClient(permission) - const task: EnqueuedTask = await client - .index(index.uid) - .resetDisplayedAttributes() - expect(task).toHaveProperty('uid', expect.any(Number)) - await client.index(index.uid).waitForTask(task.uid) + const task = await client.index(index.uid).resetDisplayedAttributes() + await client.index(index.uid).waitForTask(task.taskUid) + + const response = await client.index(index.uid).getDisplayedAttributes() - const response: string[] = await client - .index(index.uid) - .getDisplayedAttributes() expect(response).toEqual(['*']) }) } @@ -89,8 +78,8 @@ describe.each([{ permission: 'Public' }])( beforeEach(async () => { await clearAllIndexes(config) const client = await getClient('Master') - const { uid } = await client.createIndex(index.uid) - await client.waitForTask(uid) + const { taskUid } = await client.createIndex(index.uid) + await client.waitForTask(taskUid) }) test(`${permission} key: try to get displayed attributes and be denied`, async () => { @@ -122,8 +111,8 @@ describe.each([{ permission: 'No' }])( beforeEach(async () => { await clearAllIndexes(config) const client = await getClient('Master') - const { uid } = await client.createIndex(index.uid) - await client.waitForTask(uid) + const { taskUid } = await client.createIndex(index.uid) + await client.waitForTask(taskUid) }) test(`${permission} key: try to get displayed attributes and be denied`, async () => { diff --git a/tests/distinct_attribute.test.ts b/tests/distinct_attribute.test.ts index 010117b51..83e955a41 100644 --- a/tests/distinct_attribute.test.ts +++ b/tests/distinct_attribute.test.ts @@ -1,4 +1,4 @@ -import { EnqueuedTask, ErrorStatusCode } from '../src/types' +import { ErrorStatusCode } from '../src/types' import { clearAllIndexes, config, @@ -25,58 +25,46 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( await clearAllIndexes(config) const client = await getClient('master') - const { uid } = await client.index(index.uid).addDocuments(dataset) - await client.waitForTask(uid) + const { taskUid } = await client.index(index.uid).addDocuments(dataset) + await client.waitForTask(taskUid) }) test(`${permission} key: Get default distinct attribute`, async () => { const client = await getClient(permission) - const response: string | null = await client - .index(index.uid) - .getDistinctAttribute() + const response = await client.index(index.uid).getDistinctAttribute() expect(response).toEqual(null) }) test(`${permission} key: Update distinct attribute`, async () => { const client = await getClient(permission) const newDistinctAttribute = 'title' - const task: EnqueuedTask = await client + const task = await client .index(index.uid) .updateDistinctAttribute(newDistinctAttribute) - expect(task).toHaveProperty('uid', expect.any(Number)) - await client.index(index.uid).waitForTask(task.uid) + await client.index(index.uid).waitForTask(task.taskUid) + + const response = await client.index(index.uid).getDistinctAttribute() - const response: string | null = await client - .index(index.uid) - .getDistinctAttribute() expect(response).toEqual(newDistinctAttribute) }) test(`${permission} key: Update distinct attribute at null`, async () => { const client = await getClient(permission) - const task: EnqueuedTask = await client - .index(index.uid) - .updateDistinctAttribute(null) - expect(task).toHaveProperty('uid', expect.any(Number)) - await client.index(index.uid).waitForTask(task.uid) + const task = await client.index(index.uid).updateDistinctAttribute(null) + await client.index(index.uid).waitForTask(task.taskUid) + + const response = await client.index(index.uid).getDistinctAttribute() - const response: string | null = await client - .index(index.uid) - .getDistinctAttribute() expect(response).toEqual(null) }) test(`${permission} key: Reset distinct attribute`, async () => { const client = await getClient(permission) - const task: EnqueuedTask = await client - .index(index.uid) - .resetDistinctAttribute() - expect(task).toHaveProperty('uid', expect.any(Number)) - await client.index(index.uid).waitForTask(task.uid) + const task = await client.index(index.uid).resetDistinctAttribute() + await client.index(index.uid).waitForTask(task.taskUid) + + const response = await client.index(index.uid).getDistinctAttribute() - const response: string | null = await client - .index(index.uid) - .getDistinctAttribute() expect(response).toEqual(null) }) } diff --git a/tests/documents.test.ts b/tests/documents.test.ts index 307438095..2ef0af489 100644 --- a/tests/documents.test.ts +++ b/tests/documents.test.ts @@ -1,9 +1,4 @@ -import { - ErrorStatusCode, - EnqueuedTask, - IndexResponse, - TaskStatus, -} from '../src/types' +import { ErrorStatusCode, TaskStatus, TaskTypes } from '../src/types' import { clearAllIndexes, config, @@ -35,11 +30,11 @@ describe('Documents tests', () => { beforeEach(async () => { await clearAllIndexes(config) const client = await getClient('Master') - - const { uid: taskCreateNoPk } = await client.createIndex(indexNoPk.uid) + const { taskUid: taskCreateNoPk } = await client.createIndex( + indexNoPk.uid + ) await client.waitForTask(taskCreateNoPk) - - const { uid: taskCreateWithPk } = await client.createIndex( + const { taskUid: taskCreateWithPk } = await client.createIndex( indexPk.uid, { primaryKey: indexPk.primaryKey, @@ -48,92 +43,84 @@ describe('Documents tests', () => { await client.waitForTask(taskCreateWithPk) }) - test(`${permission} key: Add documents to uid with NO primary key`, async () => { - const client = await getClient(permission) - const response = await client.index(indexNoPk.uid).addDocuments(dataset) - expect(response).toHaveProperty('uid', expect.any(Number)) - await client.index(indexNoPk.uid).waitForTask(response.uid) - }) - - test(`${permission} key: Add documents to uid with primary key`, async () => { - const client = await getClient(permission) - const response = await client.index(indexPk.uid).addDocuments(dataset) - expect(response).toHaveProperty('uid', expect.any(Number)) - await client.index(indexPk.uid).waitForTask(response.uid) - }) - test(`${permission} key: Add documents to uid with primary key in batch`, async () => { const client = await getClient(permission) const tasks = await client .index(indexPk.uid) .addDocumentsInBatches(dataset, 4) - expect(tasks).toBeInstanceOf(Array) expect(tasks).toHaveLength(2) - expect(tasks[0]).toHaveProperty('uid', expect.any(Number)) for (const task of tasks) { - const { type, status } = await client.waitForTask(task.uid) + const { type, status } = await client.waitForTask(task.taskUid) expect(status).toBe(TaskStatus.TASK_SUCCEEDED) - expect(type).toBe('documentAddition') + expect(type).toBe(TaskTypes.DOCUMENTS_ADDITION_OR_UPDATE) } }) test(`${permission} key: Get documents with string attributesToRetrieve`, async () => { const client = await getClient(permission) - const response = await client.index(indexNoPk.uid).getDocuments({ + + const documents = await client.index(indexNoPk.uid).getDocuments({ attributesToRetrieve: 'id', }) - expect(response.find((x) => Object.keys(x).length !== 1)).toEqual( + + expect(documents.find((x) => Object.keys(x).length !== 1)).toEqual( undefined ) }) test(`${permission} key: Get documents with array attributesToRetrieve`, async () => { const client = await getClient(permission) - const response = await client.index(indexNoPk.uid).getDocuments({ + + const documents = await client.index(indexNoPk.uid).getDocuments({ attributesToRetrieve: ['id'], }) - expect(response.find((x) => Object.keys(x).length !== 1)).toEqual( + + expect(documents.find((x) => Object.keys(x).length !== 1)).toEqual( undefined ) }) test(`${permission} key: Get documents from index that has NO primary key`, async () => { const client = await getClient(permission) - const { uid } = await client.index(indexNoPk.uid).addDocuments(dataset) - await client.index(indexNoPk.uid).waitForTask(uid) + const { taskUid } = await client + .index(indexNoPk.uid) + .addDocuments(dataset) + await client.index(indexNoPk.uid).waitForTask(taskUid) - const response = await client.index(indexNoPk.uid).getDocuments({ + const documents = await client.index(indexNoPk.uid).getDocuments({ attributesToRetrieve: 'id', }) - expect(response.length).toEqual(dataset.length) + + expect(documents.length).toEqual(dataset.length) }) test(`${permission} key: Get documents from index that has a primary key`, async () => { const client = await getClient(permission) - const { uid } = await client.index(indexPk.uid).addDocuments(dataset) - await client.index(indexPk.uid).waitForTask(uid) + const { taskUid } = await client + .index(indexPk.uid) + .addDocuments(dataset) + await client.index(indexPk.uid).waitForTask(taskUid) - const response = await client.index(indexPk.uid).getDocuments() - expect(response.length).toEqual(dataset.length) + const documents = await client.index(indexPk.uid).getDocuments() + expect(documents.length).toEqual(dataset.length) }) test(`${permission} key: Replace documents from index that has NO primary key`, async () => { const client = await getClient(permission) - const { uid: addDocUpdate } = await client + const { taskUid: addDocUpdate } = await client .index(indexNoPk.uid) .addDocuments(dataset) await client.index(indexNoPk.uid).waitForTask(addDocUpdate) - const id = 2 const title = 'The Red And The Black' - const documents: EnqueuedTask = await client + + const task = await client .index(indexNoPk.uid) .addDocuments([{ id, title }]) - expect(documents).toHaveProperty('uid', expect.any(Number)) - await client.index(indexNoPk.uid).waitForTask(documents.uid) - + await client.index(indexNoPk.uid).waitForTask(task.taskUid) const response = await client.index(indexNoPk.uid).getDocument(id) + expect(response).toHaveProperty('id', id) expect(response).toHaveProperty('title', title) }) @@ -142,13 +129,13 @@ describe('Documents tests', () => { const client = await getClient(permission) const id = 2 const title = 'The Red And The Black' - const documents: EnqueuedTask = await client + + const task = await client .index(indexPk.uid) .addDocuments([{ id, title }]) - expect(documents).toHaveProperty('uid', expect.any(Number)) - await client.index(indexPk.uid).waitForTask(documents.uid) - + await client.index(indexPk.uid).waitForTask(task.taskUid) const response = await client.index(indexPk.uid).getDocument(id) + expect(response).toHaveProperty('id', id) expect(response).toHaveProperty('title', title) }) @@ -158,13 +145,12 @@ describe('Documents tests', () => { const id = 456 const title = 'The Little Prince' - const documents: EnqueuedTask = await client + const task = await client .index(indexNoPk.uid) .updateDocuments([{ id, title }]) - expect(documents).toHaveProperty('uid', expect.any(Number)) - await client.index(indexNoPk.uid).waitForTask(documents.uid) - + await client.index(indexNoPk.uid).waitForTask(task.taskUid) const response = await client.index(indexNoPk.uid).getDocument(id) + expect(response).toHaveProperty('id', id) expect(response).toHaveProperty('title', title) }) @@ -173,13 +159,12 @@ describe('Documents tests', () => { const client = await getClient(permission) const id = 456 const title = 'The Little Prince' - const documents: EnqueuedTask = await client + const task = await client .index(indexPk.uid) .updateDocuments([{ id, title }]) - expect(documents).toHaveProperty('uid', expect.any(Number)) - await client.index(indexPk.uid).waitForTask(documents.uid) - + await client.index(indexPk.uid).waitForTask(task.taskUid) const response = await client.index(indexPk.uid).getDocument(id) + expect(response).toHaveProperty('id', id) expect(response).toHaveProperty('title', title) }) @@ -187,10 +172,10 @@ describe('Documents tests', () => { test(`${permission} key: Partial update of a document`, async () => { const client = await getClient(permission) const id = 456 - const documents: EnqueuedTask = await client + const task = await client .index(indexPk.uid) .updateDocuments([{ id }]) - await client.index(indexPk.uid).waitForTask(documents.uid) + await client.index(indexPk.uid).waitForTask(task.taskUid) const response = await client.index(indexPk.uid).getDocument(id) @@ -203,16 +188,15 @@ describe('Documents tests', () => { const tasks = await client .index(indexPk.uid) .updateDocumentsInBatches(dataset, 2) - expect(tasks).toBeInstanceOf(Array) - expect(tasks).toHaveLength(4) - expect(tasks[0]).toHaveProperty('uid', expect.any(Number)) + for (const EnqueuedTask of tasks) { const task = await client .index(indexPk.uid) - .waitForTask(EnqueuedTask.uid) + .waitForTask(EnqueuedTask.taskUid) expect(task.status).toBe(TaskStatus.TASK_SUCCEEDED) - expect(task.type).toBe('documentPartial') + expect(task.type).toBe(TaskTypes.DOCUMENTS_ADDITION_OR_UPDATE) } + expect(tasks).toHaveLength(4) }) test(`${permission} key: Partial update of a document in batch`, async () => { @@ -223,169 +207,142 @@ describe('Documents tests', () => { .index(indexPk.uid) .updateDocumentsInBatches([partialDocument], 2) - expect(tasks).toBeInstanceOf(Array) - expect(tasks).toHaveLength(1) - expect(tasks[0]).toHaveProperty('uid', expect.any(Number)) - for (const EnqueuedTask of tasks) { const task = await client .index(indexPk.uid) - .waitForTask(EnqueuedTask.uid) + .waitForTask(EnqueuedTask.taskUid) expect(task.status).toBe(TaskStatus.TASK_SUCCEEDED) - expect(task.type).toBe('documentPartial') + expect(task.type).toBe(TaskTypes.DOCUMENTS_ADDITION_OR_UPDATE) } + expect(tasks).toHaveLength(1) }) test(`${permission} key: Add document with update documents function from index that has NO primary key`, async () => { const client = await getClient(permission) - const { uid: addDocUpdate } = await client + const { taskUid: addDocUpdate } = await client .index(indexNoPk.uid) .addDocuments(dataset) await client.index(indexNoPk.uid).waitForTask(addDocUpdate) - const id = 9 const title = '1984' - const documents: EnqueuedTask = await client + const task = await client .index(indexNoPk.uid) .updateDocuments([{ id, title }]) - expect(documents).toHaveProperty('uid', expect.any(Number)) - await client.index(indexNoPk.uid).waitForTask(documents.uid) - + await client.index(indexNoPk.uid).waitForTask(task.taskUid) const document = await client.index(indexNoPk.uid).getDocument(id) + const documents = await client.index(indexNoPk.uid).getDocuments() + expect(document).toHaveProperty('id', id) expect(document).toHaveProperty('title', title) - - const response = await client.index(indexNoPk.uid).getDocuments() - expect(response.length).toEqual(dataset.length + 1) + expect(documents.length).toEqual(dataset.length + 1) }) test(`${permission} key: Add document with update documents function from index that has a primary key`, async () => { const client = await getClient(permission) - const { uid: addDocUpdate } = await client + const { taskUid: addDocUpdate } = await client .index(indexPk.uid) .addDocuments(dataset) await client.index(indexPk.uid).waitForTask(addDocUpdate) - const id = 9 const title = '1984' - const documents: EnqueuedTask = await client + const task = await client .index(indexPk.uid) .updateDocuments([{ id, title }]) - expect(documents).toHaveProperty('uid', expect.any(Number)) - await client.index(indexPk.uid).waitForTask(documents.uid) + await client.index(indexPk.uid).waitForTask(task.taskUid) const document = await client.index(indexPk.uid).getDocument(id) + const documents = await client.index(indexPk.uid).getDocuments() + expect(document).toHaveProperty('id', id) expect(document).toHaveProperty('title', title) - - const response = await client.index(indexPk.uid).getDocuments() - expect(response.length).toEqual(dataset.length + 1) + expect(documents.length).toEqual(dataset.length + 1) }) test(`${permission} key: Delete a document from index that has NO primary key`, async () => { const client = await getClient(permission) - const { uid: addDocUpdate } = await client + const { taskUid: addDocUpdate } = await client .index(indexNoPk.uid) .addDocuments(dataset) await client.index(indexNoPk.uid).waitForTask(addDocUpdate) - const id = 9 - const document: EnqueuedTask = await client - .index(indexNoPk.uid) - .deleteDocument(id) - expect(document).toHaveProperty('uid', expect.any(Number)) - await client.index(indexNoPk.uid).waitForTask(document.uid) + const task = await client.index(indexNoPk.uid).deleteDocument(id) + await client.index(indexNoPk.uid).waitForTask(task.taskUid) + const documents = await client.index(indexNoPk.uid).getDocuments() - const response = await client.index(indexNoPk.uid).getDocuments() - expect(response.length).toEqual(dataset.length) + expect(documents.length).toEqual(dataset.length) }) test(`${permission} key: Delete a document from index that has a primary key`, async () => { const client = await getClient(permission) - const { uid: addDocUpdate } = await client + const { taskUid: addDocUpdate } = await client .index(indexPk.uid) .addDocuments(dataset) await client.index(indexPk.uid).waitForTask(addDocUpdate) const id = 9 - const document: EnqueuedTask = await client - .index(indexPk.uid) - .deleteDocument(id) - expect(document).toHaveProperty('uid', expect.any(Number)) - await client.index(indexPk.uid).waitForTask(document.uid) - + const task = await client.index(indexPk.uid).deleteDocument(id) + await client.index(indexPk.uid).waitForTask(task.taskUid) const response = await client.index(indexPk.uid).getDocuments() + expect(response.length).toEqual(dataset.length) }) test(`${permission} key: Delete some documents from index that has NO primary key`, async () => { const client = await getClient(permission) - const { uid: addDocUpdate } = await client + const { taskUid: addDocUpdate } = await client .index(indexNoPk.uid) .addDocuments(dataset) await client.index(indexNoPk.uid).waitForTask(addDocUpdate) const ids = [1, 2] + const task = await client.index(indexNoPk.uid).deleteDocuments(ids) + await client.index(indexNoPk.uid).waitForTask(task.taskUid) - const documents: EnqueuedTask = await client - .index(indexNoPk.uid) - .deleteDocuments(ids) - expect(documents).toHaveProperty('uid', expect.any(Number)) - await client.index(indexNoPk.uid).waitForTask(documents.uid) + const documents = await client.index(indexNoPk.uid).getDocuments() + const returnedIds = documents.map((x) => x.id) - const response = await client.index(indexNoPk.uid).getDocuments() - expect(response.length).toEqual(dataset.length - 2) - const returnedIds = response.map((x) => x.id) + expect(documents.length).toEqual(dataset.length - 2) expect(returnedIds).not.toContain(ids[0]) expect(returnedIds).not.toContain(ids[1]) }) test(`${permission} key: Delete some documents from index that has a primary key`, async () => { const client = await getClient(permission) - const { uid: addDocUpdate } = await client + const { taskUid: addDocUpdate } = await client .index(indexPk.uid) .addDocuments(dataset) await client.index(indexPk.uid).waitForTask(addDocUpdate) const ids = [1, 2] - const documents: EnqueuedTask = await client - .index(indexPk.uid) - .deleteDocuments(ids) - expect(documents).toHaveProperty('uid', expect.any(Number)) - await client.index(indexPk.uid).waitForTask(documents.uid) + const task = await client.index(indexPk.uid).deleteDocuments(ids) + await client.index(indexPk.uid).waitForTask(task.taskUid) + const documents = await client.index(indexPk.uid).getDocuments() + const returnedIds = documents.map((x) => x.id) - const response = await client.index(indexPk.uid).getDocuments() - expect(response.length).toEqual(dataset.length - 2) - const returnedIds = response.map((x) => x.id) + expect(documents.length).toEqual(dataset.length - 2) expect(returnedIds).not.toContain(ids[0]) expect(returnedIds).not.toContain(ids[1]) }) test(`${permission} key: Delete all document from index that has NO primary key`, async () => { const client = await getClient(permission) - const documents: EnqueuedTask = await client - .index(indexNoPk.uid) - .deleteAllDocuments() - expect(documents).toHaveProperty('uid', expect.any(Number)) - await client.index(indexNoPk.uid).waitForTask(documents.uid) + const task = await client.index(indexNoPk.uid).deleteAllDocuments() + await client.index(indexNoPk.uid).waitForTask(task.taskUid) - const response = await client.index(indexNoPk.uid).getDocuments() - expect(response.length).toEqual(0) + const documents = await client.index(indexNoPk.uid).getDocuments() + expect(documents.length).toEqual(0) }) test(`${permission} key: Delete all document from index that has a primary key`, async () => { const client = await getClient(permission) - const documents: EnqueuedTask = await client - .index(indexPk.uid) - .deleteAllDocuments() - expect(documents).toHaveProperty('uid', expect.any(Number)) - await client.index(indexPk.uid).waitForTask(documents.uid) + const task = await client.index(indexPk.uid).deleteAllDocuments() + await client.index(indexPk.uid).waitForTask(task.taskUid) - const response = await client.index(indexPk.uid).getDocuments() - expect(response.length).toEqual(0) + const documents = await client.index(indexPk.uid).getDocuments() + expect(documents.length).toEqual(0) }) test(`${permission} key: Try to get deleted document from index that has NO primary key`, async () => { @@ -411,23 +368,16 @@ describe('Documents tests', () => { title: 'Le Rouge et le Noir', }, ] - const pkIndex = 'update_pk' - const { uid } = await client.createIndex(pkIndex) - await client.waitForTask(uid) - - const index = await client.getIndex(pkIndex) - expect(index).toHaveProperty('uid', pkIndex) + const { taskUid } = await client.createIndex(pkIndex) + await client.waitForTask(taskUid) - const task: EnqueuedTask = await client + const task = await client .index(pkIndex) .addDocuments(docs, { primaryKey: 'unique' }) + await client.waitForTask(task.taskUid) - expect(task).toHaveProperty('uid', expect.any(Number)) - - await client.waitForTask(task.uid) - - const response: IndexResponse = await client.index(pkIndex).getRawInfo() + const response = await client.index(pkIndex).getRawInfo() expect(response).toHaveProperty('uid', pkIndex) expect(response).toHaveProperty('primaryKey', 'unique') }) @@ -439,8 +389,10 @@ describe('Documents tests', () => { title: 'Le Rouge et le Noir', }, ] - const { uid } = await client.index(indexNoPk.uid).addDocuments(docs) - const { error } = await client.waitForTask(uid) + + const { taskUid } = await client.index(indexNoPk.uid).addDocuments(docs) + const { error } = await client.waitForTask(taskUid) + expect(error).toHaveProperty('code') expect(error).toHaveProperty('link') expect(error).toHaveProperty('message') @@ -449,16 +401,16 @@ describe('Documents tests', () => { test(`${permission} key: Try to add documents from index with no primary key with NO valid primary key, update should fail`, async () => { const client = await getClient(permission) - const { uid } = await client.index(indexNoPk.uid).addDocuments([ + const { taskUid } = await client.index(indexNoPk.uid).addDocuments([ { unique: 2, title: 'Le Rouge et le Noir', }, ]) - const task = await client.waitForTask(uid) - + const task = await client.waitForTask(taskUid) const index = await client.index(indexNoPk.uid).getRawInfo() + expect(index.uid).toEqual(indexNoPk.uid) expect(index.primaryKey).toEqual(null) expect(task.status).toEqual('failed') diff --git a/tests/env/browser/index.html b/tests/env/browser/index.html index b4598b87c..092a96469 100644 --- a/tests/env/browser/index.html +++ b/tests/env/browser/index.html @@ -26,10 +26,10 @@ apiKey: 'masterKey', }) const task = await client.createIndex(UID) - await client.waitForTask(task.uid) + await client.waitForTask(task.taskUid) const documentTask = await client.index(UID).addDocuments([{ id: 1, title: "wonder woman" }]) - await client.waitForTask(documentTask.uid) + await client.waitForTask(documentTask.taskUid) const index = await client.index(UID).getRawInfo() diff --git a/tests/env/express/public/headers.html b/tests/env/express/public/headers.html index 7be21ba33..798ffbad8 100644 --- a/tests/env/express/public/headers.html +++ b/tests/env/express/public/headers.html @@ -24,7 +24,7 @@ let error = 'NO ERRORS' try { const task = await client.createIndex(UID) - await client.waitForTask(task.uid) + await client.waitForTask(task.taskUid) await fetch(`http://localhost:7700/indexes/${UID}/documents`, { method: 'POST', headers: { @@ -42,7 +42,7 @@ document.body.insertBefore(errorDiv, document.querySelector("#content")); const deleteTask = await client.index(UID).delete() - await client.waitForTask(deleteTask.uid) + await client.waitForTask(deleteTask.taskUid) })() diff --git a/tests/env/express/public/index.html b/tests/env/express/public/index.html index ffd25f5b3..b4666ff1e 100644 --- a/tests/env/express/public/index.html +++ b/tests/env/express/public/index.html @@ -28,10 +28,10 @@ try { const task = await client.createIndex(UID) - await client.waitForTask(task.uid) + await client.waitForTask(task.taskUid) const documentTask = await client.index(UID).addDocuments([{ id: 1, title: "wonder woman" }]) - await client.waitForTask(documentTask.uid) + await client.waitForTask(documentTask.taskUid) const index = await client.index(UID).getRawInfo() @@ -52,7 +52,7 @@ searchDiv.innerHTML = content document.body.insertBefore(searchDiv, document.querySelector("#content")); const deleteTask = await client.index(UID).delete() - await client.waitForTask(deleteTask.uid) + await client.waitForTask(deleteTask.taskUid) })() diff --git a/tests/env/node/getting_started.js b/tests/env/node/getting_started.js index 900cde673..2d1364380 100644 --- a/tests/env/node/getting_started.js +++ b/tests/env/node/getting_started.js @@ -28,6 +28,8 @@ const { MeiliSearch } = require('../../../dist/bundles/meilisearch.umd.js') console.log(response) // => { "updateId": 0 } + await client.waitForTask(response.taskUid) + const search = await index.search('philoudelphia') console.log({ search, hit: search.hits }) const filteredSearch = await index.search('Wonder', { diff --git a/tests/env/node/search_example.js b/tests/env/node/search_example.js index ebcaf930f..e85d21261 100644 --- a/tests/env/node/search_example.js +++ b/tests/env/node/search_example.js @@ -11,15 +11,15 @@ const indexUid = 'movies' const addDataset = async () => { await client.deleteIndex(indexUid) - const { uid } = await client.createIndex(indexUid) - await client.waitForTask(uid) + const { taskUid } = await client.createIndex(indexUid) + await client.waitForTask(taskUid) const index = client.index(indexUid) const documents = await index.getDocuments() if (documents.length === 0) { - const { uid } = await index.addDocuments(dataset) - await index.waitForTask(uid) + const { taskUid } = await index.addDocuments(dataset) + await index.waitForTask(taskUid) } } diff --git a/tests/env/typescript-node/src/index.ts b/tests/env/typescript-node/src/index.ts index 070130fc3..0edf6d4d7 100644 --- a/tests/env/typescript-node/src/index.ts +++ b/tests/env/typescript-node/src/index.ts @@ -26,8 +26,8 @@ const indexUid = "movies" ;(async () => { await client.deleteIndex(indexUid) - const { uid } = await client.createIndex(indexUid) - await client.waitForTask(uid) + const { taskUid } = await client.createIndex(indexUid) + await client.waitForTask(taskUid) const index = client.index(indexUid) const indexes = await client.getRawIndexes() diff --git a/tests/filterable_attributes.test.ts b/tests/filterable_attributes.test.ts index 78c99ebca..08e324ef6 100644 --- a/tests/filterable_attributes.test.ts +++ b/tests/filterable_attributes.test.ts @@ -1,4 +1,4 @@ -import { ErrorStatusCode, EnqueuedTask } from '../src/types' +import { ErrorStatusCode } from '../src/types' import { clearAllIndexes, config, @@ -23,8 +23,8 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( ({ permission }) => { beforeEach(async () => { const client = await getClient('Master') - const { uid } = await client.index(index.uid).addDocuments(dataset) - await client.waitForTask(uid) + const { taskUid } = await client.index(index.uid).addDocuments(dataset) + await client.waitForTask(taskUid) }) test(`${permission} key: Get default attributes for filtering`, async () => { @@ -32,17 +32,17 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( const response: string[] = await client .index(index.uid) .getFilterableAttributes() + expect(response.sort()).toEqual([]) }) test(`${permission} key: Update attributes for filtering`, async () => { const client = await getClient(permission) const newFilterableAttributes = ['genre'] - const task: EnqueuedTask = await client + const task = await client .index(index.uid) .updateFilterableAttributes(newFilterableAttributes) - expect(task).toHaveProperty('uid', expect.any(Number)) - await client.index(index.uid).waitForTask(task.uid) + await client.index(index.uid).waitForTask(task.taskUid) const response: string[] = await client .index(index.uid) @@ -52,29 +52,29 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( test(`${permission} key: Update attributes for filtering at null`, async () => { const client = await getClient(permission) - const task: EnqueuedTask = await client + const task = await client .index(index.uid) .updateFilterableAttributes(null) expect(task).toHaveProperty('uid', expect.any(Number)) - await client.index(index.uid).waitForTask(task.uid) + await client.index(index.uid).waitForTask(task.taskUid) const response: string[] = await client .index(index.uid) .getFilterableAttributes() + expect(response.sort()).toEqual([]) }) test(`${permission} key: Reset attributes for filtering`, async () => { const client = await getClient(permission) - const task: EnqueuedTask = await client - .index(index.uid) - .resetFilterableAttributes() + const task = await client.index(index.uid).resetFilterableAttributes() expect(task).toHaveProperty('uid', expect.any(Number)) - await client.index(index.uid).waitForTask(task.uid) + await client.index(index.uid).waitForTask(task.taskUid) const response: string[] = await client .index(index.uid) .getFilterableAttributes() + expect(response.sort()).toEqual([]) }) } @@ -85,8 +85,8 @@ describe.each([{ permission: 'Public' }])( ({ permission }) => { beforeEach(async () => { const client = await getClient('Master') - const { uid } = await client.createIndex(index.uid) - await client.waitForTask(uid) + const { taskUid } = await client.createIndex(index.uid) + await client.waitForTask(taskUid) }) test(`${permission} key: try to get attributes for filtering and be denied`, async () => { @@ -117,8 +117,8 @@ describe.each([{ permission: 'No' }])( ({ permission }) => { beforeEach(async () => { const client = await getClient('Master') - const { uid } = await client.createIndex(index.uid) - await client.waitForTask(uid) + const { taskUid } = await client.createIndex(index.uid) + await client.waitForTask(taskUid) }) test(`${permission} key: try to get attributes for filtering and be denied`, async () => { diff --git a/tests/get_search.test.ts b/tests/get_search.test.ts index 1f5e92314..aa58cdd84 100644 --- a/tests/get_search.test.ts +++ b/tests/get_search.test.ts @@ -68,13 +68,13 @@ describe.each([ beforeAll(async () => { await clearAllIndexes(config) const client = await getClient('Master') - const { uid: task1 } = await client.createIndex(index.uid) + const { taskUid: task1 } = await client.createIndex(index.uid) await client.waitForTask(task1) - const { uid: task2 } = await client.createIndex(emptyIndex.uid) + const { taskUid: task2 } = await client.createIndex(emptyIndex.uid) await client.waitForTask(task2) const newFilterableAttributes = ['genre', 'title', 'id'] - const { uid: task3 }: EnqueuedTask = await client + const { taskUid: task3 }: EnqueuedTask = await client .index(index.uid) .updateSettings({ filterableAttributes: newFilterableAttributes, @@ -82,7 +82,9 @@ describe.each([ }) await client.waitForTask(task3) - const { uid: task4 } = await client.index(index.uid).addDocuments(dataset) + const { taskUid: task4 } = await client + .index(index.uid) + .addDocuments(dataset) await client.waitForTask(task4) }) @@ -433,8 +435,8 @@ describe.each([ test(`${permission} key: Try to search on deleted index and fail`, async () => { const client = await getClient(permission) const masterClient = await getClient('Master') - const { uid } = await masterClient.index(index.uid).delete() - await masterClient.waitForTask(uid) + const { taskUid } = await masterClient.index(index.uid).delete() + await masterClient.waitForTask(taskUid) await expect( client.index(index.uid).searchGet('prince') ).rejects.toHaveProperty('code', ErrorStatusCode.INDEX_NOT_FOUND) diff --git a/tests/index.test.ts b/tests/index.test.ts index dcded393e..119db5215 100644 --- a/tests/index.test.ts +++ b/tests/index.test.ts @@ -1,4 +1,4 @@ -import { IndexResponse, ErrorStatusCode } from '../src/types' +import { ErrorStatusCode } from '../src/types' import { clearAllIndexes, config, @@ -28,16 +28,15 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( test(`${permission} key: create index with NO primary key`, async () => { const client = await getClient(permission) - const { uid } = await client.createIndex(indexNoPk.uid) - await client.waitForTask(uid) + const { taskUid } = await client.createIndex(indexNoPk.uid) + await client.waitForTask(taskUid) + const newIndex = await client.getIndex(indexNoPk.uid) expect(newIndex).toHaveProperty('uid', indexNoPk.uid) expect(newIndex).toHaveProperty('primaryKey', null) - const rawIndex: IndexResponse = await client - .index(indexNoPk.uid) - .getRawInfo() + const rawIndex = await client.index(indexNoPk.uid).getRawInfo() expect(rawIndex).toHaveProperty('uid', indexNoPk.uid) expect(rawIndex).toHaveProperty('primaryKey', null) @@ -47,18 +46,18 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( test(`${permission} key: create index with primary key`, async () => { const client = await getClient(permission) - const { uid } = await client.createIndex(indexPk.uid, { + const { taskUid } = await client.createIndex(indexPk.uid, { primaryKey: indexPk.primaryKey, }) - await client.waitForTask(uid) + await client.waitForTask(taskUid) + const newIndex = await client.getIndex(indexPk.uid) expect(newIndex).toHaveProperty('uid', indexPk.uid) expect(newIndex).toHaveProperty('primaryKey', indexPk.primaryKey) - const rawIndex: IndexResponse = await client - .index(indexPk.uid) - .getRawInfo() + const rawIndex = await client.index(indexPk.uid).getRawInfo() + expect(rawIndex).toHaveProperty('uid', indexPk.uid) expect(rawIndex).toHaveProperty('primaryKey', indexPk.primaryKey) expect(rawIndex).toHaveProperty('createdAt', expect.any(String)) @@ -67,17 +66,18 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( test(`${permission} key: Get raw index that exists`, async () => { const client = await getClient(permission) - const { uid } = await client.createIndex(indexPk.uid) - await client.waitForTask(uid) + const { taskUid } = await client.createIndex(indexPk.uid) + await client.waitForTask(taskUid) const response = await client.getRawIndex(indexPk.uid) + expect(response).toHaveProperty('uid', indexPk.uid) }) test(`${permission} key: Get all indexes in Index instances`, async () => { const client = await getClient(permission) - const { uid } = await client.createIndex(indexPk.uid) - await client.waitForTask(uid) + const { taskUid } = await client.createIndex(indexPk.uid) + await client.waitForTask(taskUid) const response = await client.getRawIndexes() @@ -103,10 +103,11 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( test(`${permission} key: Get raw index info through client with primary key`, async () => { const client = await getClient(permission) - const { uid } = await client.createIndex(indexPk.uid, { + const { taskUid } = await client.createIndex(indexPk.uid, { primaryKey: indexPk.primaryKey, }) - await client.waitForTask(uid) + await client.waitForTask(taskUid) + const response = await client.getRawIndex(indexPk.uid) expect(response).toHaveProperty('uid', indexPk.uid) @@ -115,8 +116,8 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( test(`${permission} key: Get raw index info through client with NO primary key`, async () => { const client = await getClient(permission) - const { uid } = await client.createIndex(indexNoPk.uid) - await client.waitForTask(uid) + const { taskUid } = await client.createIndex(indexNoPk.uid) + await client.waitForTask(taskUid) const response = await client.getRawIndex(indexNoPk.uid) @@ -126,10 +127,11 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( test(`${permission} key: Get raw index info with primary key`, async () => { const client = await getClient(permission) - const { uid } = await client.createIndex(indexPk.uid, { + const { taskUid } = await client.createIndex(indexPk.uid, { primaryKey: indexPk.primaryKey, }) - await client.waitForTask(uid) + await client.waitForTask(taskUid) + const response = await client.index(indexPk.uid).getRawInfo() expect(response).toHaveProperty('uid', indexPk.uid) @@ -138,113 +140,118 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( test(`${permission} key: Get raw index info with NO primary key`, async () => { const client = await getClient(permission) - const { uid } = await client.createIndex(indexNoPk.uid) - await client.waitForTask(uid) + const { taskUid } = await client.createIndex(indexNoPk.uid) + await client.waitForTask(taskUid) const response = await client.index(indexNoPk.uid).getRawInfo() + expect(response).toHaveProperty('uid', indexNoPk.uid) expect(response).toHaveProperty('primaryKey', null) }) test(`${permission} key: fetch index with primary key`, async () => { const client = await getClient(permission) - const { uid } = await client.createIndex(indexPk.uid, { + const { taskUid } = await client.createIndex(indexPk.uid, { primaryKey: indexPk.primaryKey, }) - await client.waitForTask(uid) + await client.waitForTask(taskUid) const index = client.index(indexPk.uid) const response = await index.fetchInfo() + expect(response).toHaveProperty('uid', indexPk.uid) expect(response).toHaveProperty('primaryKey', indexPk.primaryKey) }) test(`${permission} key: fetch primary key on an index with primary key`, async () => { const client = await getClient(permission) - const { uid } = await client.createIndex(indexPk.uid, { + const { taskUid } = await client.createIndex(indexPk.uid, { primaryKey: indexPk.primaryKey, }) - await client.waitForTask(uid) + await client.waitForTask(taskUid) const index = client.index(indexPk.uid) const response: string | undefined = await index.fetchPrimaryKey() + expect(response).toBe(indexPk.primaryKey) }) test(`${permission} key: fetch primary key on an index with NO primary key`, async () => { const client = await getClient(permission) - const { uid } = await client.createIndex(indexNoPk.uid) - await client.waitForTask(uid) + const { taskUid } = await client.createIndex(indexNoPk.uid) + await client.waitForTask(taskUid) const index = client.index(indexNoPk.uid) const response: string | undefined = await index.fetchPrimaryKey() + expect(response).toBe(null) }) test(`${permission} key: fetch index with primary key`, async () => { const client = await getClient(permission) - const { uid } = await client.createIndex(indexPk.uid, { + const { taskUid } = await client.createIndex(indexPk.uid, { primaryKey: indexPk.primaryKey, }) - await client.waitForTask(uid) + await client.waitForTask(taskUid) const index = client.index(indexPk.uid) const response = await index.fetchInfo() + expect(response).toHaveProperty('uid', indexPk.uid) expect(response).toHaveProperty('primaryKey', indexPk.primaryKey) }) test(`${permission} key: fetch index with NO primary key`, async () => { const client = await getClient(permission) - const { uid } = await client.createIndex(indexNoPk.uid) - await client.waitForTask(uid) + const { taskUid } = await client.createIndex(indexNoPk.uid) + await client.waitForTask(taskUid) const index = client.index(indexNoPk.uid) const response = await index.fetchInfo() + expect(response).toHaveProperty('uid', indexNoPk.uid) expect(response).toHaveProperty('primaryKey', null) }) test(`${permission} key: update primary key on an index that has no primary key already`, async () => { const client = await getClient(permission) - const { uid: createTask } = await client.createIndex(indexNoPk.uid) - await client.waitForTask(createTask) - - const { uid: updateTask } = await client.index(indexNoPk.uid).update({ + const { taskUid: createTask } = await client.createIndex(indexNoPk.uid) + const { taskUid: updateTask } = await client.index(indexNoPk.uid).update({ primaryKey: 'newPrimaryKey', }) + await client.waitForTask(createTask) await client.waitForTask(updateTask) const index = await client.getIndex(indexNoPk.uid) + expect(index).toHaveProperty('uid', indexNoPk.uid) expect(index).toHaveProperty('primaryKey', 'newPrimaryKey') }) test(`${permission} key: update primary key on an index that has NO primary key already through client`, async () => { const client = await getClient(permission) - const { uid: createTask } = await client.createIndex(indexNoPk.uid) - await client.waitForTask(createTask) - - const { uid: updateTask } = await client.updateIndex(indexNoPk.uid, { + const { taskUid: createTask } = await client.createIndex(indexNoPk.uid) + const { taskUid: updateTask } = await client.updateIndex(indexNoPk.uid, { primaryKey: indexPk.primaryKey, }) + await client.waitForTask(createTask) await client.waitForTask(updateTask) const index = await client.getIndex(indexNoPk.uid) + expect(index).toHaveProperty('uid', indexNoPk.uid) expect(index).toHaveProperty('primaryKey', indexPk.primaryKey) }) test(`${permission} key: update primary key on an index that has already a primary key and fail through client`, async () => { const client = await getClient(permission) - const { uid: createTask } = await client.createIndex(indexPk.uid, { + const { taskUid: createTask } = await client.createIndex(indexPk.uid, { primaryKey: indexPk.primaryKey, }) - await client.waitForTask(createTask) - - const { uid: updateTask } = await client.updateIndex(indexPk.uid, { + const { taskUid: updateTask } = await client.updateIndex(indexPk.uid, { primaryKey: 'newPrimaryKey', }) + await client.waitForTask(createTask) await client.waitForTask(updateTask) const index = await client.getIndex(indexPk.uid) @@ -255,14 +262,13 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( test(`${permission} key: update primary key on an index that has already a primary key and fail`, async () => { const client = await getClient(permission) - const { uid: createTask } = await client.createIndex(indexPk.uid, { + const { taskUid: createTask } = await client.createIndex(indexPk.uid, { primaryKey: indexPk.primaryKey, }) - await client.waitForTask(createTask) - - const { uid: updateTask } = await client.index(indexPk.uid).update({ + const { taskUid: updateTask } = await client.index(indexPk.uid).update({ primaryKey: 'newPrimaryKey', }) + await client.waitForTask(createTask) await client.waitForTask(updateTask) const index = await client.getIndex(indexPk.uid) @@ -273,10 +279,9 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( test(`${permission} key: delete index`, async () => { const client = await getClient(permission) - const { uid: createTask } = await client.createIndex(indexNoPk.uid) + const { taskUid: createTask } = await client.createIndex(indexNoPk.uid) + const { taskUid: updateTask } = await client.index(indexNoPk.uid).delete() await client.waitForTask(createTask) - - const { uid: updateTask } = await client.index(indexNoPk.uid).delete() await client.waitForTask(updateTask) await expect(client.getIndexes()).resolves.toHaveLength(0) @@ -284,9 +289,9 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( test(`${permission} key: delete index using client`, async () => { const client = await getClient(permission) + const { taskUid } = await client.deleteIndex(indexPk.uid) await client.createIndex(indexPk.uid) - const { uid } = await client.deleteIndex(indexPk.uid) - await client.waitForTask(uid) + await client.waitForTask(taskUid) await expect(client.getIndexes()).resolves.toHaveLength(0) }) @@ -311,17 +316,20 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( test(`${permission} key: delete index with uid that does not exist should fail`, async () => { const client = await getClient(permission) const index = client.index(indexNoPk.uid) - const { uid } = await index.delete() - const task = await client.waitForTask(uid) + const { taskUid } = await index.delete() + + const task = await client.waitForTask(taskUid) + expect(task.status).toBe('failed') }) test(`${permission} key: get stats of an index`, async () => { const client = await getClient(permission) - const { uid } = await client.createIndex(indexNoPk.uid) - await client.waitForTask(uid) + const { taskUid } = await client.createIndex(indexNoPk.uid) + await client.waitForTask(taskUid) const response = await client.index(indexNoPk.uid).getStats() + expect(response).toHaveProperty('numberOfDocuments', 0) expect(response).toHaveProperty('isIndexing', false) expect(response).toHaveProperty('fieldDistribution', {}) @@ -329,8 +337,8 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( test(`${permission} key: Get updatedAt and createdAt through fetch info`, async () => { const client = await getClient(permission) - const { uid } = await client.createIndex(indexPk.uid) - await client.waitForTask(uid) + const { taskUid } = await client.createIndex(indexPk.uid) + await client.waitForTask(taskUid) const index = await client.index(indexPk.uid).fetchInfo() @@ -340,8 +348,8 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( test(`${permission} key: Get updatedAt and createdAt index through getRawInfo`, async () => { const client = await getClient(permission) - const { uid } = await client.createIndex(indexPk.uid) - await client.waitForTask(uid) + const { taskUid } = await client.createIndex(indexPk.uid) + await client.waitForTask(taskUid) const index = client.index(indexPk.uid) diff --git a/tests/ranking_rules.test.ts b/tests/ranking_rules.test.ts index 411b45f9d..487d781e0 100644 --- a/tests/ranking_rules.test.ts +++ b/tests/ranking_rules.test.ts @@ -33,8 +33,8 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( beforeEach(async () => { await clearAllIndexes(config) const client = await getClient('master') - const { uid } = await client.index(index.uid).addDocuments(dataset) - await client.waitForTask(uid) + const { taskUid } = await client.index(index.uid).addDocuments(dataset) + await client.waitForTask(taskUid) }) test(`${permission} key: Get default ranking rules`, async () => { @@ -49,10 +49,10 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( const task: EnqueuedTask = await client .index(index.uid) .updateRankingRules(newRankingRules) - expect(task).toHaveProperty('uid', expect.any(Number)) - await client.index(index.uid).waitForTask(task.uid) + await client.index(index.uid).waitForTask(task.taskUid) const response: string[] = await client.index(index.uid).getRankingRules() + expect(response).toEqual(newRankingRules) }) @@ -61,10 +61,10 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( const task: EnqueuedTask = await client .index(index.uid) .updateRankingRules(null) - expect(task).toHaveProperty('uid', expect.any(Number)) - await client.index(index.uid).waitForTask(task.uid) + await client.index(index.uid).waitForTask(task.taskUid) const response: string[] = await client.index(index.uid).getRankingRules() + expect(response).toEqual(defaultRankingRules) }) @@ -73,10 +73,10 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( const task: EnqueuedTask = await client .index(index.uid) .resetRankingRules() - expect(task).toHaveProperty('uid', expect.any(Number)) - await client.index(index.uid).waitForTask(task.uid) + await client.index(index.uid).waitForTask(task.taskUid) const response: string[] = await client.index(index.uid).getRankingRules() + expect(response).toEqual(defaultRankingRules) }) } diff --git a/tests/search.test.ts b/tests/search.test.ts index fb0adc843..9594db53a 100644 --- a/tests/search.test.ts +++ b/tests/search.test.ts @@ -70,7 +70,7 @@ describe.each([ await client.createIndex(emptyIndex.uid) const newFilterableAttributes = ['genre', 'title', 'id'] - const { uid: task1 }: EnqueuedTask = await client + const { taskUid: task1 }: EnqueuedTask = await client .index(index.uid) .updateSettings({ filterableAttributes: newFilterableAttributes, @@ -78,7 +78,9 @@ describe.each([ }) await client.waitForTask(task1) - const { uid: task2 } = await client.index(index.uid).addDocuments(dataset) + const { taskUid: task2 } = await client + .index(index.uid) + .addDocuments(dataset) await client.waitForTask(task2) }) @@ -497,8 +499,8 @@ describe.each([ test(`${permission} key: Try to search on deleted index and fail`, async () => { const client = await getClient(permission) const masterClient = await getClient('Master') - const { uid } = await masterClient.index(index.uid).delete() - await masterClient.waitForTask(uid) + const { taskUid } = await masterClient.index(index.uid).delete() + await masterClient.waitForTask(taskUid) await expect( client.index(index.uid).search('prince', {}) @@ -511,8 +513,8 @@ describe.each([{ permission: 'No' }])( ({ permission }) => { beforeAll(async () => { const client = await getClient('Master') - const { uid } = await client.createIndex(index.uid) - await client.waitForTask(uid) + const { taskUid } = await client.createIndex(index.uid) + await client.waitForTask(taskUid) }) test(`${permission} key: Try Basic search and be denied`, async () => { @@ -535,7 +537,7 @@ describe.each([{ permission: 'Master' }])( const client = await getClient('Master') await client.createIndex(index.uid) - const { uid: documentAdditionTask } = await client + const { taskUid: documentAdditionTask } = await client .index(index.uid) .addDocuments(datasetWithNests) await client.waitForTask(documentAdditionTask) @@ -557,7 +559,7 @@ describe.each([{ permission: 'Master' }])( test(`${permission} key: search on nested content with searchable on specific nested field`, async () => { const client = await getClient(permission) - const { uid: settingsUpdateTask }: EnqueuedTask = await client + const { taskUid: settingsUpdateTask }: EnqueuedTask = await client .index(index.uid) .updateSettings({ searchableAttributes: ['title', 'info.comment'], @@ -578,7 +580,7 @@ describe.each([{ permission: 'Master' }])( test(`${permission} key: search on nested content with sort`, async () => { const client = await getClient(permission) - const { uid: settingsUpdateTask }: EnqueuedTask = await client + const { taskUid: settingsUpdateTask }: EnqueuedTask = await client .index(index.uid) .updateSettings({ searchableAttributes: ['title', 'info.comment'], @@ -610,8 +612,8 @@ describe.each([ beforeAll(async () => { const client = await getClient('Master') await clearAllIndexes(config) - const { uid } = await client.createIndex(index.uid) - await client.waitForTask(uid) + const { taskUid } = await client.createIndex(index.uid) + await client.waitForTask(taskUid) }) test(`${permission} key: search on index and abort`, async () => { diff --git a/tests/searchable_attributes.test.ts b/tests/searchable_attributes.test.ts index a83b20444..649572556 100644 --- a/tests/searchable_attributes.test.ts +++ b/tests/searchable_attributes.test.ts @@ -23,59 +23,58 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( ({ permission }) => { beforeEach(async () => { const client = await getClient('Master') - const { uid } = await client.index(index.uid).addDocuments(dataset) - await client.waitForTask(uid) - await client.index(index.uid).waitForTask(uid) + const { taskUid } = await client.index(index.uid).addDocuments(dataset) + await client.waitForTask(taskUid) }) test(`${permission} key: Get default searchable attributes`, async () => { const client = await getClient(permission) + const response: string[] = await client .index(index.uid) .getSearchableAttributes() + expect(response).toEqual(['*']) }) test(`${permission} key: Update searchable attributes`, async () => { const client = await getClient(permission) const newSearchableAttributes = ['title'] - const task: EnqueuedTask = await client + const task = await client .index(index.uid) .updateSearchableAttributes(newSearchableAttributes) - expect(task).toHaveProperty('uid', expect.any(Number)) - await client.index(index.uid).waitForTask(task.uid) + await client.index(index.uid).waitForTask(task.taskUid) const response: string[] = await client .index(index.uid) .getSearchableAttributes() + expect(response).toEqual(newSearchableAttributes) }) test(`${permission} key: Update searchable attributes at null`, async () => { const client = await getClient(permission) - const task: EnqueuedTask = await client + const task = await client .index(index.uid) .updateSearchableAttributes(null) - expect(task).toHaveProperty('uid', expect.any(Number)) - await client.index(index.uid).waitForTask(task.uid) + await client.index(index.uid).waitForTask(task.taskUid) const response: string[] = await client .index(index.uid) .getSearchableAttributes() + expect(response).toEqual(['*']) }) test(`${permission} key: Reset searchable attributes`, async () => { const client = await getClient(permission) - const task: EnqueuedTask = await client - .index(index.uid) - .resetSearchableAttributes() - expect(task).toHaveProperty('uid', expect.any(Number)) - await client.index(index.uid).waitForTask(task.uid) + const task = await client.index(index.uid).resetSearchableAttributes() + await client.index(index.uid).waitForTask(task.taskUid) const response: string[] = await client .index(index.uid) .getSearchableAttributes() + expect(response).toEqual(['*']) }) } @@ -86,8 +85,8 @@ describe.each([{ permission: 'Public' }])( ({ permission }) => { beforeEach(async () => { const client = await getClient('Master') - const { uid } = await client.createIndex(index.uid) - await client.waitForTask(uid) + const { taskUid } = await client.createIndex(index.uid) + await client.waitForTask(taskUid) }) test(`${permission} key: try to get searchable attributes and be denied`, async () => { @@ -118,8 +117,8 @@ describe.each([{ permission: 'No' }])( ({ permission }) => { beforeAll(async () => { const client = await getClient('Master') - const { uid } = await client.createIndex(index.uid) - await client.waitForTask(uid) + const { taskUid } = await client.createIndex(index.uid) + await client.waitForTask(taskUid) }) test(`${permission} key: try to get searchable attributes and be denied`, async () => { diff --git a/tests/settings.test.ts b/tests/settings.test.ts index 8b8cc3914..cf0ed0623 100644 --- a/tests/settings.test.ts +++ b/tests/settings.test.ts @@ -1,4 +1,4 @@ -import { ErrorStatusCode, EnqueuedTask, Settings } from '../src/types' +import { ErrorStatusCode } from '../src/types' import { clearAllIndexes, config, @@ -64,14 +64,14 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( beforeEach(async () => { await clearAllIndexes(config) const client = await getClient('Master') - const { uid: AddDocPkTask } = await client + const { taskUid: AddDocPkTask } = await client .index(indexAndPK.uid) .addDocuments(dataset, { primaryKey: indexAndPK.primaryKey, }) await client.waitForTask(AddDocPkTask) - const { uid: AddDocTask } = await client + const { taskUid: AddDocTask } = await client .index(index.uid) .addDocuments(dataset, {}) await client.waitForTask(AddDocTask) @@ -79,7 +79,9 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( test(`${permission} key: Get default settings of an index`, async () => { const client = await getClient(permission) - const response: Settings = await client.index(index.uid).getSettings() + + const response = await client.index(index.uid).getSettings() + expect(response).toHaveProperty('rankingRules', defaultRankingRules) expect(response).toHaveProperty('distinctAttribute', null) expect(response).toHaveProperty('searchableAttributes', ['*']) @@ -91,9 +93,9 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( test(`${permission} key: Get default settings of empty index with primary key`, async () => { const client = await getClient(permission) - const response: Settings = await client - .index(indexAndPK.uid) - .getSettings() + + const response = await client.index(indexAndPK.uid).getSettings() + expect(response).toHaveProperty('rankingRules', defaultRankingRules) expect(response).toHaveProperty('distinctAttribute', null) expect(response).toHaveProperty('searchableAttributes', ['*']) @@ -125,14 +127,11 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( }, } // Add the settings - const task: EnqueuedTask = await client - .index(index.uid) - .updateSettings(newSettings) - expect(task).toHaveProperty('uid', expect.any(Number)) - await client.index(index.uid).waitForTask(task.uid) + const task = await client.index(index.uid).updateSettings(newSettings) + await client.index(index.uid).waitForTask(task.taskUid) // Fetch the settings - const response: Settings = await client.index(index.uid).getSettings() + const response = await client.index(index.uid).getSettings() // tests expect(response).toEqual(newSettings) @@ -160,14 +159,11 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( }, } // Add the settings - const task: EnqueuedTask = await client - .index(index.uid) - .updateSettings(newSettings) - expect(task).toHaveProperty('uid', expect.any(Number)) - await client.index(index.uid).waitForTask(task.uid) + const task = await client.index(index.uid).updateSettings(newSettings) + await client.index(index.uid).waitForTask(task.taskUid) // Fetch the settings - const response: Settings = await client.index(index.uid).getSettings() + const response = await client.index(index.uid).getSettings() // tests expect(response).toEqual(defaultSettings) @@ -180,16 +176,13 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( rankingRules: ['title:asc', 'typo'], stopWords: ['the'], } - - const task: EnqueuedTask = await client + const task = await client .index(indexAndPK.uid) .updateSettings(newSettings) - expect(task).toHaveProperty('uid', expect.any(Number)) - await client.index(indexAndPK.uid).waitForTask(task.uid) + await client.index(indexAndPK.uid).waitForTask(task.taskUid) + + const response = await client.index(indexAndPK.uid).getSettings() - const response: Settings = await client - .index(indexAndPK.uid) - .getSettings() expect(response).toHaveProperty('rankingRules', newSettings.rankingRules) expect(response).toHaveProperty( 'distinctAttribute', @@ -203,11 +196,11 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( test(`${permission} key: Reset settings`, async () => { const client = await getClient(permission) - const task: EnqueuedTask = await client.index(index.uid).resetSettings() - expect(task).toHaveProperty('uid', expect.any(Number)) - await client.index(index.uid).waitForTask(task.uid) + const task = await client.index(index.uid).resetSettings() + await client.index(index.uid).waitForTask(task.taskUid) + + const response = await client.index(index.uid).getSettings() - const response: Settings = await client.index(index.uid).getSettings() expect(response).toHaveProperty('rankingRules', defaultRankingRules) expect(response).toHaveProperty('distinctAttribute', null) expect(response).toHaveProperty('searchableAttributes', ['*']) @@ -219,15 +212,11 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( test(`${permission} key: Reset settings of empty index`, async () => { const client = await getClient(permission) - const task: EnqueuedTask = await client - .index(indexAndPK.uid) - .resetSettings() - expect(task).toHaveProperty('uid', expect.any(Number)) - await client.index(index.uid).waitForTask(task.uid) + const task = await client.index(indexAndPK.uid).resetSettings() + await client.index(index.uid).waitForTask(task.taskUid) + + const response = await client.index(indexAndPK.uid).getSettings() - const response: Settings = await client - .index(indexAndPK.uid) - .getSettings() expect(response).toHaveProperty('rankingRules', defaultRankingRules) expect(response).toHaveProperty('distinctAttribute', null) expect(response).toHaveProperty('searchableAttributes', ['*']) @@ -241,13 +230,11 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( const newSettings = { searchableAttributes: ['title'], } - const task: EnqueuedTask = await client - .index(index.uid) - .updateSettings(newSettings) - expect(task).toHaveProperty('uid', expect.any(Number)) - await client.index(index.uid).waitForTask(task.uid) + const task = await client.index(index.uid).updateSettings(newSettings) + await client.index(index.uid).waitForTask(task.taskUid) + + const response = await client.index(index.uid).getSettings() - const response: Settings = await client.index(index.uid).getSettings() expect(response).toHaveProperty('rankingRules', defaultRankingRules) expect(response).toHaveProperty( 'distinctAttribute', @@ -268,24 +255,20 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( searchableAttributes: ['title'], } // Update settings - const task: EnqueuedTask = await client + const task = await client .index(indexAndPK.uid) .updateSettings(newSettings) // Wait for setting addition to be done - await client.index(index.uid).waitForTask(task.uid) + await client.index(index.uid).waitForTask(task.taskUid) // Fetch settings - const response: Settings = await client - .index(indexAndPK.uid) - .getSettings() + const response = await client.index(indexAndPK.uid).getSettings() // Compare searchableAttributes expect(response).toHaveProperty( 'searchableAttributes', newSettings.searchableAttributes ) - - expect(task).toHaveProperty('uid', expect.any(Number)) expect(response).toHaveProperty('rankingRules', defaultRankingRules) expect(response).toHaveProperty( 'distinctAttribute', diff --git a/tests/sortable_attributes.test.ts b/tests/sortable_attributes.test.ts index ce99c18d4..20be4f135 100644 --- a/tests/sortable_attributes.test.ts +++ b/tests/sortable_attributes.test.ts @@ -1,4 +1,4 @@ -import { ErrorStatusCode, EnqueuedTask } from '../src/types' +import { ErrorStatusCode } from '../src/types' import { clearAllIndexes, config, @@ -23,10 +23,10 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( ({ permission }) => { beforeEach(async () => { const client = await getClient('Master') - const { uid } = await client.createIndex(index.uid) - await client.waitForTask(uid) + const { taskUid } = await client.createIndex(index.uid) + await client.waitForTask(taskUid) - const { uid: docTask } = await client + const { taskUid: docTask } = await client .index(index.uid) .addDocuments(dataset) await client.waitForTask(docTask) @@ -34,52 +34,41 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( test(`${permission} key: Get default sortable attributes`, async () => { const client = await getClient(permission) - const response: string[] = await client - .index(index.uid) - .getSortableAttributes() + + const response = await client.index(index.uid).getSortableAttributes() + expect(response).toEqual([]) }) test(`${permission} key: Update sortable attributes`, async () => { const client = await getClient(permission) const newSortableAttributes = ['title'] - const task: EnqueuedTask = await client + const task = await client .index(index.uid) .updateSortableAttributes(newSortableAttributes) - expect(task).toHaveProperty('uid', expect.any(Number)) - await client.index(index.uid).waitForTask(task.uid) + await client.index(index.uid).waitForTask(task.taskUid) - const response: string[] = await client - .index(index.uid) - .getSortableAttributes() + const response = await client.index(index.uid).getSortableAttributes() expect(response).toEqual(newSortableAttributes) }) test(`${permission} key: Update sortable attributes at null`, async () => { const client = await getClient(permission) - const task: EnqueuedTask = await client - .index(index.uid) - .updateSortableAttributes(null) - expect(task).toHaveProperty('uid', expect.any(Number)) - await client.index(index.uid).waitForTask(task.uid) + const task = await client.index(index.uid).updateSortableAttributes(null) + await client.index(index.uid).waitForTask(task.taskUid) + + const response = await client.index(index.uid).getSortableAttributes() - const response: string[] = await client - .index(index.uid) - .getSortableAttributes() expect(response).toEqual([]) }) test(`${permission} key: Reset sortable attributes`, async () => { const client = await getClient(permission) - const task: EnqueuedTask = await client - .index(index.uid) - .resetSortableAttributes() - expect(task).toHaveProperty('uid', expect.any(Number)) - await client.index(index.uid).waitForTask(task.uid) + const task = await client.index(index.uid).resetSortableAttributes() + await client.index(index.uid).waitForTask(task.taskUid) + + const response = await client.index(index.uid).getSortableAttributes() - const response: string[] = await client - .index(index.uid) - .getSortableAttributes() expect(response).toEqual([]) }) } @@ -90,8 +79,8 @@ describe.each([{ permission: 'Public' }])( ({ permission }) => { beforeEach(async () => { const client = await getClient('Master') - const { uid } = await client.createIndex(index.uid) - await client.waitForTask(uid) + const { taskUid } = await client.createIndex(index.uid) + await client.waitForTask(taskUid) }) test(`${permission} key: try to get sortable attributes and be denied`, async () => { @@ -122,8 +111,8 @@ describe.each([{ permission: 'No' }])( ({ permission }) => { beforeAll(async () => { const client = await getClient('Master') - const { uid } = await client.createIndex(index.uid) - await client.waitForTask(uid) + const { taskUid } = await client.createIndex(index.uid) + await client.waitForTask(taskUid) }) test(`${permission} key: try to get sortable attributes and be denied`, async () => { diff --git a/tests/stop_words.test.ts b/tests/stop_words.test.ts index ed8b6cf9b..1f2438e2f 100644 --- a/tests/stop_words.test.ts +++ b/tests/stop_words.test.ts @@ -23,14 +23,14 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( ({ permission }) => { beforeEach(async () => { const client = await getClient('Master') - - const { uid } = await client.index(index.uid).addDocuments(dataset) - await client.waitForTask(uid) + const { taskUid } = await client.index(index.uid).addDocuments(dataset) + await client.waitForTask(taskUid) }) test(`${permission} key: Get default stop words`, async () => { const client = await getClient(permission) const response: string[] = await client.index(index.uid).getStopWords() + expect(response).toEqual([]) }) @@ -40,10 +40,10 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( const task: EnqueuedTask = await client .index(index.uid) .updateStopWords(newStopWords) - expect(task).toHaveProperty('uid', expect.any(Number)) - await client.index(index.uid).waitForTask(task.uid) + await client.index(index.uid).waitForTask(task.taskUid) const response: string[] = await client.index(index.uid).getStopWords() + expect(response).toEqual(newStopWords) }) @@ -53,20 +53,20 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( const task: EnqueuedTask = await client .index(index.uid) .updateStopWords(newStopWords) - expect(task).toHaveProperty('uid', expect.any(Number)) - await client.index(index.uid).waitForTask(task.uid) + await client.index(index.uid).waitForTask(task.taskUid) const response: string[] = await client.index(index.uid).getStopWords() + expect(response).toEqual([]) }) test(`${permission} key: Reset stop words`, async () => { const client = await getClient(permission) const task: EnqueuedTask = await client.index(index.uid).resetStopWords() - expect(task).toHaveProperty('uid', expect.any(Number)) - await client.index(index.uid).waitForTask(task.uid) + await client.index(index.uid).waitForTask(task.taskUid) const response: string[] = await client.index(index.uid).getStopWords() + expect(response).toEqual([]) }) } diff --git a/tests/synonyms.test.ts b/tests/synonyms.test.ts index a616d06e4..8ae4eeaeb 100644 --- a/tests/synonyms.test.ts +++ b/tests/synonyms.test.ts @@ -1,4 +1,4 @@ -import { ErrorStatusCode, EnqueuedTask } from '../src/types' +import { ErrorStatusCode } from '../src/types' import { clearAllIndexes, config, @@ -26,46 +26,45 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( const { uid } = await client.index(index.uid).addDocuments(dataset) await client.waitForTask(uid) }) + test(`${permission} key: Get default synonyms`, async () => { const client = await getClient(permission) const response: object = await client.index(index.uid).getSynonyms() + expect(response).toEqual({}) }) + test(`${permission} key: Update synonyms`, async () => { const client = await getClient(permission) const newSynonyms = { hp: ['harry potter'], } - const task: EnqueuedTask = await client - .index(index.uid) - .updateSynonyms(newSynonyms) - expect(task).toHaveProperty('uid', expect.any(Number)) - await client.waitForTask(task.uid) + const task = await client.index(index.uid).updateSynonyms(newSynonyms) + await client.waitForTask(task.taskUid) const response: object = await client.index(index.uid).getSynonyms() + expect(response).toEqual(newSynonyms) }) test(`${permission} key: Update synonyms with null value`, async () => { const client = await getClient(permission) const newSynonyms = null - const task: EnqueuedTask = await client - .index(index.uid) - .updateSynonyms(newSynonyms) - expect(task).toHaveProperty('uid', expect.any(Number)) - await client.waitForTask(task.uid) + const task = await client.index(index.uid).updateSynonyms(newSynonyms) + await client.waitForTask(task.taskUid) const response: object = await client.index(index.uid).getSynonyms() + expect(response).toEqual({}) }) test(`${permission} key: Reset synonyms`, async () => { const client = await getClient(permission) - const task: EnqueuedTask = await client.index(index.uid).resetSynonyms() - expect(task).toHaveProperty('uid', expect.any(Number)) - await client.waitForTask(task.uid) + const task = await client.index(index.uid).resetSynonyms() + await client.waitForTask(task.taskUid) const response: object = await client.index(index.uid).getSynonyms() + expect(response).toEqual({}) }) } diff --git a/tests/token.test.ts b/tests/token.test.ts index 901d61771..b4040e42d 100644 --- a/tests/token.test.ts +++ b/tests/token.test.ts @@ -24,8 +24,8 @@ describe.each([{ permission: 'Private' }])( beforeEach(async () => { const client = await getClient('Master') await client.index(UID).delete() - const { uid } = await client.index(UID).addDocuments(dataset) - await client.waitForTask(uid) + const { taskUid } = await client.index(UID).addDocuments(dataset) + await client.waitForTask(taskUid) }) test(`${permission} key: create a tenant token and test header`, async () => { @@ -171,10 +171,10 @@ describe.each([{ permission: 'Private' }])( test(`${permission} key: Search in tenant token with specific index and specific rules`, async () => { // add filterable const masterClient = await getClient('master') - const { uid } = await masterClient + const { taskUid } = await masterClient .index(UID) .updateFilterableAttributes(['id']) - await masterClient.waitForTask(uid) + await masterClient.waitForTask(taskUid) const client = await getClient(permission) const token = client.generateTenantToken({ diff --git a/tests/typed_search.test.ts b/tests/typed_search.test.ts index 81bd8b5ca..fcdfa4b4a 100644 --- a/tests/typed_search.test.ts +++ b/tests/typed_search.test.ts @@ -89,18 +89,20 @@ describe.each([ await clearAllIndexes(config) const task1 = await client.createIndex(index.uid) - await client.waitForTask(task1.uid) + await client.waitForTask(task1.taskUid) const task2 = await client.createIndex(emptyIndex.uid) - await client.waitForTask(task2.uid) + await client.waitForTask(task2.taskUid) const newFilterableAttributes = ['genre', 'title'] - const response: EnqueuedTask = await client + const task: EnqueuedTask = await client .index(index.uid) .updateFilterableAttributes(newFilterableAttributes) - await client.waitForTask(response.uid) - const { uid } = await client.index(index.uid).addDocuments(dataset) - await client.waitForTask(uid) + await client.waitForTask(task.taskUid) + const { taskUid } = await client + .index(index.uid) + .addDocuments(dataset) + await client.waitForTask(taskUid) }) test(`${permission} key: Basic search`, async () => { @@ -356,8 +358,9 @@ describe.each([ test(`${permission} key: Try to Search on deleted index and fail`, async () => { const client = await getClient(permission) const masterClient = await getClient('Master') - const { uid } = await masterClient.index(index.uid).delete() - await masterClient.waitForTask(uid) + const { taskUid } = await masterClient.index(index.uid).delete() + await masterClient.waitForTask(taskUid) + await expect( client.index(index.uid).search('prince') ).rejects.toHaveProperty('code', ErrorStatusCode.INDEX_NOT_FOUND) @@ -372,7 +375,7 @@ describe.each([{ permission: 'Master' }])( const client = await getClient('Master') await client.createIndex(index.uid) - const { uid: documentAdditionTask } = await client + const { taskUid: documentAdditionTask } = await client .index(index.uid) .addDocuments(datasetWithNests) await client.waitForTask(documentAdditionTask) @@ -390,7 +393,7 @@ describe.each([{ permission: 'Master' }])( test(`${permission} key: search on nested content with searchable on specific nested field`, async () => { const client = await getClient(permission) - const { uid: settingsUpdateTask }: EnqueuedTask = await client + const { taskUid: settingsUpdateTask }: EnqueuedTask = await client .index(index.uid) .updateSettings({ searchableAttributes: ['title', 'info.comment'], @@ -407,7 +410,7 @@ describe.each([{ permission: 'Master' }])( test(`${permission} key: search on nested content with sort`, async () => { const client = await getClient(permission) - const { uid: settingsUpdateTask }: EnqueuedTask = await client + const { taskUid: settingsUpdateTask }: EnqueuedTask = await client .index(index.uid) .updateSettings({ searchableAttributes: ['title', 'info.comment'], diff --git a/tests/typo_tolerance.test.ts b/tests/typo_tolerance.test.ts index afe8911e6..d41d93022 100644 --- a/tests/typo_tolerance.test.ts +++ b/tests/typo_tolerance.test.ts @@ -1,4 +1,4 @@ -import { ErrorStatusCode, EnqueuedTask } from '../src/types' +import { ErrorStatusCode } from '../src/types' import { clearAllIndexes, config, @@ -34,8 +34,8 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( beforeEach(async () => { await clearAllIndexes(config) const client = await getClient('master') - const { uid } = await client.index(index.uid).addDocuments(dataset) - await client.waitForTask(uid) + const { taskUid } = await client.index(index.uid).addDocuments(dataset) + await client.waitForTask(taskUid) }) test(`${permission} key: Get default typo tolerance settings`, async () => { @@ -57,43 +57,33 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( disableOnWords: ['title'], disableOnAttributes: ['hello'], } - const task: EnqueuedTask = await client + const task = await client .index(index.uid) .updateTypoTolerance(newTypoTolerance) - expect(task).toHaveProperty('uid', expect.any(Number)) - await client.index(index.uid).waitForTask(task.uid) + await client.index(index.uid).waitForTask(task.taskUid) + + const response = await client.index(index.uid).getTypoTolerance() - const response: string[] = await client - .index(index.uid) - .getTypoTolerance() expect(response).toEqual(newTypoTolerance) }) test(`${permission} key: Update typo tolerance using null as value`, async () => { const client = await getClient(permission) - const task: EnqueuedTask = await client - .index(index.uid) - .updateTypoTolerance(null) - expect(task).toHaveProperty('uid', expect.any(Number)) - await client.index(index.uid).waitForTask(task.uid) + const task = await client.index(index.uid).updateTypoTolerance(null) + await client.index(index.uid).waitForTask(task.taskUid) + + const response = await client.index(index.uid).getTypoTolerance() - const response: string[] = await client - .index(index.uid) - .getTypoTolerance() expect(response).toEqual(defaultTypoTolerance) }) test(`${permission} key: Reset typo tolerance settings`, async () => { const client = await getClient(permission) - const task: EnqueuedTask = await client - .index(index.uid) - .resetTypoTolerance() - expect(task).toHaveProperty('uid', expect.any(Number)) - await client.index(index.uid).waitForTask(task.uid) + const task = await client.index(index.uid).resetTypoTolerance() + await client.index(index.uid).waitForTask(task.taskUid) + + const response = await client.index(index.uid).getTypoTolerance() - const response: string[] = await client - .index(index.uid) - .getTypoTolerance() expect(response).toEqual(defaultTypoTolerance) }) } From 4dcf944f1d25678c4ea0e0a9cb6f06d8d0a333a1 Mon Sep 17 00:00:00 2001 From: Charlotte Vermandel Date: Wed, 15 Jun 2022 13:38:39 +0200 Subject: [PATCH 10/11] Keep task destructing in tests --- playgrounds/javascript/src/app.js | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/playgrounds/javascript/src/app.js b/playgrounds/javascript/src/app.js index 6917685cf..0b08dd2a9 100644 --- a/playgrounds/javascript/src/app.js +++ b/playgrounds/javascript/src/app.js @@ -10,8 +10,8 @@ const indexUid = 'movies' const addDataset = async () => { await client.deleteIndex(indexUid) - const task = await client.createIndex(indexUid) - await client.index(indexUid).waitForTask(task.taskUid) + const { taskUid } = await client.createIndex(indexUid) + await client.index(indexUid).waitForTask(taskUid) const documents = await client.index(indexUid).getDocuments() @@ -28,8 +28,8 @@ const addDataset = async () => { { id: 6, title: 'Philadelphia', genres: ['Drama'] }, ] if (documents.length === 0) { - const task = await client.index(indexUid).addDocuments(dataset) - await client.index(indexUid).waitForTask(task.taskUid) + const { taskUid } = await client.index(indexUid).addDocuments(dataset) + await client.index(indexUid).waitForTask(taskUid) } } From ec81fbaf002b9a21f3269e30df934c579e8c8295 Mon Sep 17 00:00:00 2001 From: Charlotte Vermandel Date: Wed, 15 Jun 2022 13:56:06 +0200 Subject: [PATCH 11/11] Fix linting --- tests/filterable_attributes.test.ts | 2 -- tests/searchable_attributes.test.ts | 2 +- 2 files changed, 1 insertion(+), 3 deletions(-) diff --git a/tests/filterable_attributes.test.ts b/tests/filterable_attributes.test.ts index 08e324ef6..64f985a06 100644 --- a/tests/filterable_attributes.test.ts +++ b/tests/filterable_attributes.test.ts @@ -55,7 +55,6 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( const task = await client .index(index.uid) .updateFilterableAttributes(null) - expect(task).toHaveProperty('uid', expect.any(Number)) await client.index(index.uid).waitForTask(task.taskUid) const response: string[] = await client @@ -68,7 +67,6 @@ describe.each([{ permission: 'Master' }, { permission: 'Private' }])( test(`${permission} key: Reset attributes for filtering`, async () => { const client = await getClient(permission) const task = await client.index(index.uid).resetFilterableAttributes() - expect(task).toHaveProperty('uid', expect.any(Number)) await client.index(index.uid).waitForTask(task.taskUid) const response: string[] = await client diff --git a/tests/searchable_attributes.test.ts b/tests/searchable_attributes.test.ts index 649572556..b85cdb0d3 100644 --- a/tests/searchable_attributes.test.ts +++ b/tests/searchable_attributes.test.ts @@ -1,4 +1,4 @@ -import { ErrorStatusCode, EnqueuedTask } from '../src/types' +import { ErrorStatusCode } from '../src/types' import { clearAllIndexes, config,