Merge #1048

1048: Make tests use await consistently inplace of .then r=bidoubiwa a=K-Kumar-01

Closes #1046 

Co-authored-by: k-kumar-01 <[email protected]>

Author: bors[bot]

tests/client_tests.ts

@@ -195,64 +195,52 @@ describe.each([
 
     describe('Test on indexes methods', () => {
       test(`${permission} key: create with no primary key`, async () => {
-        await client.createIndex(indexNoPk.uid).then((response) => {
-          expect(response).toHaveProperty('uid', indexNoPk.uid)
-          expect(response).toHaveProperty('primaryKey', null)
-        })
+        const newIndex = await client.createIndex(indexNoPk.uid)
+        expect(newIndex).toHaveProperty('uid', indexNoPk.uid)
+        expect(newIndex).toHaveProperty('primaryKey', null)
 
-        await client
-          .index(indexNoPk.uid)
-          .getRawInfo()
-          .then((response: IndexResponse) => {
-            expect(response).toHaveProperty('uid', indexNoPk.uid)
-            expect(response).toHaveProperty('primaryKey', null)
-            expect(response).toHaveProperty('createdAt', expect.any(String))
-            expect(response).toHaveProperty('updatedAt', expect.any(String))
-          })
+        const rawIndex = await client.index(indexNoPk.uid).getRawInfo()
+        expect(rawIndex).toHaveProperty('uid', indexNoPk.uid)
+        expect(rawIndex).toHaveProperty('primaryKey', null)
+        expect(rawIndex).toHaveProperty('createdAt', expect.any(String))
+        expect(rawIndex).toHaveProperty('updatedAt', expect.any(String))
 
-        await client.getIndex(indexNoPk.uid).then((response) => {
-          expect(response.primaryKey).toBe(null)
-          expect(response.uid).toBe(indexNoPk.uid)
-        })
+        const response = await client.getIndex(indexNoPk.uid)
+        expect(response.primaryKey).toBe(null)
+        expect(response.uid).toBe(indexNoPk.uid)
       })
 
       test(`${permission} key: create with primary key`, async () => {
-        await client
-          .createIndex(indexPk.uid, {
-            primaryKey: indexPk.primaryKey,
-          })
-          .then((response) => {
-            expect(response).toHaveProperty('uid', indexPk.uid)
-            expect(response).toHaveProperty('primaryKey', indexPk.primaryKey)
-          })
-        await client
-          .index(indexPk.uid)
-          .getRawInfo()
-          .then((response: IndexResponse) => {
-            expect(response).toHaveProperty('primaryKey', indexPk.primaryKey)
-            expect(response).toHaveProperty('createdAt', expect.any(String))
-            expect(response).toHaveProperty('updatedAt', expect.any(String))
-          })
-        await client.getIndex(indexPk.uid).then((response) => {
-          expect(response.primaryKey).toBe(indexPk.primaryKey)
-          expect(response.uid).toBe(indexPk.uid)
+        const newIndex = await client.createIndex(indexPk.uid, {
+          primaryKey: indexPk.primaryKey,
         })
+        expect(newIndex).toHaveProperty('uid', indexPk.uid)
+        expect(newIndex).toHaveProperty('primaryKey', indexPk.primaryKey)
+
+        const rawIndex = await client.index(indexPk.uid).getRawInfo()
+        expect(rawIndex).toHaveProperty('primaryKey', indexPk.primaryKey)
+        expect(rawIndex).toHaveProperty('createdAt', expect.any(String))
+        expect(rawIndex).toHaveProperty('updatedAt', expect.any(String))
+
+        const response = await client.getIndex(indexPk.uid)
+        expect(response.primaryKey).toBe(indexPk.primaryKey)
+        expect(response.uid).toBe(indexPk.uid)
       })
 
       test(`${permission} key: get all indexes when not empty`, async () => {
         await client.createIndex(indexPk.uid)
-        await client.getIndexes().then((response: IndexResponse[]) => {
-          const indexes = response.map((index) => index.uid)
-          expect(indexes).toEqual(expect.arrayContaining([indexPk.uid]))
-          expect(indexes.length).toEqual(1)
-        })
+
+        const response: IndexResponse[] = await client.getIndexes()
+        const indexes = response.map((index) => index.uid)
+        expect(indexes).toEqual(expect.arrayContaining([indexPk.uid]))
+        expect(indexes.length).toEqual(1)
       })
 
       test(`${permission} key: Get index that exists`, async () => {
         await client.createIndex(indexPk.uid)
-        await client.getIndex(indexPk.uid).then((response) => {
-          expect(response).toHaveProperty('uid', indexPk.uid)
-        })
+
+        const response = await client.getIndex(indexPk.uid)
+        expect(response).toHaveProperty('uid', indexPk.uid)
       })
 
       test(`${permission} key: Get index that does not exist`, async () => {
@@ -264,12 +252,12 @@ describe.each([
 
       test(`${permission} key: update primary key`, async () => {
         await client.createIndex(indexPk.uid)
-        await client
-          .updateIndex(indexPk.uid, { primaryKey: 'newPrimaryKey' })
-          .then((response: Index<any>) => {
-            expect(response).toHaveProperty('uid', indexPk.uid)
-            expect(response).toHaveProperty('primaryKey', 'newPrimaryKey')
-          })
+
+        const response: Index<any> = await client.updateIndex(indexPk.uid, {
+          primaryKey: 'newPrimaryKey',
+        })
+        expect(response).toHaveProperty('uid', indexPk.uid)
+        expect(response).toHaveProperty('primaryKey', 'newPrimaryKey')
       })
 
       test(`${permission} key: update primary key that already exists`, async () => {
@@ -288,9 +276,10 @@ describe.each([
 
       test(`${permission} key: delete index`, async () => {
         await client.createIndex(indexNoPk.uid)
-        await client.deleteIndex(indexNoPk.uid).then((response: void) => {
-          expect(response).toBe(undefined)
-        })
+
+        const response: void = await client.deleteIndex(indexNoPk.uid)
+        expect(response).toBe(undefined)
+
         await expect(client.getIndexes()).resolves.toHaveLength(0)
       })
 
@@ -311,11 +300,10 @@ describe.each([
       })
       test(`${permission} key: delete index if exists on existing index`, async () => {
         await client.createIndex(indexPk.uid)
-        await client
-          .deleteIndexIfExists(indexPk.uid)
-          .then((response: boolean) => {
-            expect(response).toBe(true)
-          })
+
+        const response: boolean = await client.deleteIndexIfExists(indexPk.uid)
+        expect(response).toBe(true)
+
         await expect(client.getIndex(indexPk.uid)).rejects.toHaveProperty(
           'errorCode',
           ErrorStatusCode.INDEX_NOT_FOUND
@@ -324,11 +312,9 @@ describe.each([
 
       test(`${permission} key: delete index if exists on index that does not exist`, async () => {
         const indexes = await client.getIndexes()
-        await client
-          .deleteIndexIfExists('badIndex')
-          .then((response: boolean) => {
-            expect(response).toBe(false)
-          })
+        const response: boolean = await client.deleteIndexIfExists('badIndex')
+        expect(response).toBe(false)
+
         await expect(client.getIndex('badIndex')).rejects.toHaveProperty(
           'errorCode',
           ErrorStatusCode.INDEX_NOT_FOUND
@@ -347,41 +333,36 @@ describe.each([
 
     describe('Test on base routes', () => {
       test(`${permission} key: get health`, async () => {
-        await client.health().then((response: Health) => {
-          expect(response).toHaveProperty(
-            'status',
-            expect.stringMatching('available')
-          )
-        })
+        const response: Health = await client.health()
+        expect(response).toHaveProperty(
+          'status',
+          expect.stringMatching('available')
+        )
       })
 
       test(`${permission} key: is server healthy`, async () => {
-        await client.isHealthy().then((response: boolean) => {
-          expect(response).toBe(true)
-        })
+        const response: boolean = await client.isHealthy()
+        expect(response).toBe(true)
       })
 
       test(`${permission} key: is healthy return false on bad host`, async () => {
         const client = new MeiliSearch({ host: 'http://localhost:9345' })
-        await client.isHealthy().then((response: boolean) => {
-          expect(response).toBe(false)
-        })
+        const response: boolean = await client.isHealthy()
+        expect(response).toBe(false)
       })
 
       test(`${permission} key: get version`, async () => {
-        await client.getVersion().then((response: Version) => {
-          expect(response).toHaveProperty('commitSha', expect.any(String))
-          expect(response).toHaveProperty('commitDate', expect.any(String))
-          expect(response).toHaveProperty('pkgVersion', expect.any(String))
-        })
+        const response: Version = await client.getVersion()
+        expect(response).toHaveProperty('commitSha', expect.any(String))
+        expect(response).toHaveProperty('commitDate', expect.any(String))
+        expect(response).toHaveProperty('pkgVersion', expect.any(String))
       })
 
       test(`${permission} key: get /stats information`, async () => {
-        await client.getStats().then((response: Stats) => {
-          expect(response).toHaveProperty('databaseSize', expect.any(Number))
-          expect(response).toHaveProperty('lastUpdate') // TODO: Could be null, find out why
-          expect(response).toHaveProperty('indexes', expect.any(Object))
-        })
+        const response: Stats = await client.getStats()
+        expect(response).toHaveProperty('databaseSize', expect.any(Number))
+        expect(response).toHaveProperty('lastUpdate') // TODO: Could be null, find out why
+        expect(response).toHaveProperty('indexes', expect.any(Object))
       })
     })
   }
@@ -435,12 +416,11 @@ describe.each([{ client: publicClient, permission: 'Public' }])(
 
     describe('Test on misc client methods', () => {
       test(`${permission} key: get health`, async () => {
-        await client.health().then((response: Health) => {
-          expect(response).toHaveProperty(
-            'status',
-            expect.stringMatching('available')
-          )
-        })
+        const response: Health = await client.health()
+        expect(response).toHaveProperty(
+          'status',
+          expect.stringMatching('available')
+        )
       })
 
       test(`${permission} key: try to get version and be denied`, async () => {
@@ -528,12 +508,11 @@ describe.each([{ client: anonymousClient, permission: 'No' }])(
 
     describe('Test on misc client methods', () => {
       test(`${permission} key: get health`, async () => {
-        await client.health().then((response: Health) => {
-          expect(response).toHaveProperty(
-            'status',
-            expect.stringMatching('available')
-          )
-        })
+        const response: Health = await client.health()
+        expect(response).toHaveProperty(
+          'status',
+          expect.stringMatching('available')
+        )
       })
 
       test(`${permission} key: try to get version and be denied`, async () => {

tests/displayed_attributes_tests.ts

@@ -48,64 +48,52 @@ describe.each([
   })
 
   test(`${permission} key: Get default displayed attributes`, async () => {
-    await client
-      .index(index.uid)
-      .getDisplayedAttributes()
-      .then((response: string[]) => {
-        expect(response).toEqual(['*'])
-      })
+    const response = await client.index(index.uid).getDisplayedAttributes()
+    expect(response).toEqual(['*'])
   })
 
   test(`${permission} key: Update displayed attributes`, async () => {
     const newDisplayedAttribute = ['title']
-    const { updateId } = await client
+    const updatedAttributes: EnqueuedUpdate = await client
       .index(index.uid)
       .updateDisplayedAttributes(newDisplayedAttribute)
-      .then((response: EnqueuedUpdate) => {
-        expect(response).toHaveProperty('updateId', expect.any(Number))
-        return response
-      })
-    await client.index(index.uid).waitForPendingUpdate(updateId)
+    expect(updatedAttributes).toHaveProperty('updateId', expect.any(Number))
     await client
+      .index(index.uid)
+      .waitForPendingUpdate(updatedAttributes.updateId)
+
+    const response: string[] = await client
       .index(index.uid)
       .getDisplayedAttributes()
-      .then((response: string[]) => {
-        expect(response).toEqual(newDisplayedAttribute)
-      })
+    expect(response).toEqual(newDisplayedAttribute)
   })
 
   test(`${permission} key: Update displayed attributes at null`, async () => {
-    const { updateId } = await client
+    const updatedAttributes: EnqueuedUpdate = await client
       .index(index.uid)
       .updateDisplayedAttributes(null)
-      .then((response: EnqueuedUpdate) => {
-        expect(response).toHaveProperty('updateId', expect.any(Number))
-        return response
-      })
-    await client.index(index.uid).waitForPendingUpdate(updateId)
+    expect(updatedAttributes).toHaveProperty('updateId', expect.any(Number))
     await client
+      .index(index.uid)
+      .waitForPendingUpdate(updatedAttributes.updateId)
+
+    const response: string[] = await client
       .index(index.uid)
       .getDisplayedAttributes()
-      .then((response: string[]) => {
-        expect(response).toEqual(['*'])
-      })
+    expect(response).toEqual(['*'])
   })
 
   test(`${permission} key: Reset displayed attributes`, async () => {
-    const { updateId } = await client
+    const attributes: EnqueuedUpdate = await client
       .index(index.uid)
       .resetDisplayedAttributes()
-      .then((response: EnqueuedUpdate) => {
-        expect(response).toHaveProperty('updateId', expect.any(Number))
-        return response
-      })
-    await client.index(index.uid).waitForPendingUpdate(updateId)
-    await client
+    expect(attributes).toHaveProperty('updateId', expect.any(Number))
+    await client.index(index.uid).waitForPendingUpdate(attributes.updateId)
+
+    const response: string[] = await client
       .index(index.uid)
       .getDisplayedAttributes()
-      .then((response: string[]) => {
-        expect(response).toEqual(['*'])
-      })
+    expect(response).toEqual(['*'])
   })
 })