test(various): cleanup, add tests for abstract request class

Author: mumenthalers

src/decorator/metadata/metadata.ts

@@ -72,7 +72,6 @@ export class Metadata<T> {
    * @throws Throws an error if an indexName was delivered but no index was found for given name or the found index has no sort key defined
    */
   getSortKey(indexName?: string): keyof T | null {
-    // todo: is this ok?! it returns null when no sortKey is defined but throws when no sortKey when index was given
     if (indexName) {
       const index = this.getIndex(indexName)
       if (index) {

src/dynamo/dynamo-rx.spec.ts

@@ -77,6 +77,4 @@ describe('dynamo rx', () => {
     expect(dynamoRx.dynamoDb.config.credentials).toBe(credentials)
   })
 
-  xit('should use the given aws region', () => {})
-
 })

src/dynamo/request/batchgetsingletable/batch-get-single-table.request.spec.ts

@@ -2,11 +2,7 @@ import { of } from 'rxjs'
 // tslint:disable:no-unnecessary-class
 // tslint:disable:no-unused-expression
 import { getTableName } from '../../../../test/helper'
-import {
-  Organization,
-  SimpleWithCompositePartitionKeyModel,
-  SimpleWithPartitionKeyModel,
-} from '../../../../test/models'
+import { Organization, SimpleWithPartitionKeyModel } from '../../../../test/models'
 import { updateDynamoEasyConfig } from '../../../config'
 import { BatchGetSingleTableRequest } from './batch-get-single-table.request'
 
@@ -18,12 +14,6 @@ describe('batch get', () => {
       expect(() => new BatchGetSingleTableRequest(<any>null, <any>null, 'tableName', [])).toThrow()
     })
 
-    xit('should throw when a class without metadata was given', () => {
-      class NoModelClass {}
-
-      expect(() => new BatchGetSingleTableRequest(<any>null, NoModelClass, 'tableName', [])).toThrow()
-    })
-
     it('should throw when adding a key without partition key', () => {
       expect(() => {
         new BatchGetSingleTableRequest(<any>null, SimpleWithPartitionKeyModel, 'tableName', [{}])
@@ -33,12 +23,6 @@ describe('batch get', () => {
       }).toThrow()
     })
 
-    xit('should throw when sort key is missing', () => {
-      expect(() => {
-        new BatchGetSingleTableRequest(<any>null, SimpleWithCompositePartitionKeyModel, 'tableName', [{ partitionKey: 'aKey' }])
-      }).toThrow()
-    })
-
   })
 
   describe('correct params', () => {

src/dynamo/request/query/query.request.spec.ts

@@ -107,17 +107,6 @@ describe('query request', () => {
     })
   })
 
-  // describe('calls endpoint with correct params', () => {
-  //   const dynamoRx: DynamoRx = DYNAMO_RX_MOCK as DynamoRx
-  //   let querySpy: jasmine.Spy
-  //   let request: QueryRequest<ComplexModel>
-  //
-  //   beforeEach(() => {
-  //     request = new QueryRequest(<any>null, ComplexModel, getTableName(ComplexModel))
-  //     querySpy = spyOn(dynamoRx, 'query').and.callThrough()
-  //   })
-  // })
-
   describe('scan direction', () => {
     let req: QueryRequest<SimpleWithPartitionKeyModel>
     beforeEach(() => req = new QueryRequest(<any>null, SimpleWithPartitionKeyModel, 'tableName'))

src/dynamo/request/query/query.request.ts

@@ -137,7 +137,7 @@ export class QueryRequest<T> extends Request<T, QueryRequest<T>, QueryInput, Que
   }
 
   execSingle(): Observable<T | null> {
-    // fixme, copy params, don't add limit on member (too implicit)
+    // fixme, copy params, don't add limit on member (too implicit, --> request instance can't be reused to fetch many)
     this.limit(1)
     this.logger.debug('single request', this.params)
     return this.dynamoRx.query(this.params).pipe(

src/dynamo/request/request.model.spec.ts

@@ -0,0 +1,113 @@
+import { getTableName } from '../../../test/helper'
+import {
+  ModelWithABunchOfIndexes,
+  SimpleWithCompositePartitionKeyModel,
+  SimpleWithPartitionKeyModel,
+} from '../../../test/models'
+import { INDEX_ACTIVE_CREATED_AT, INDEX_COUNT } from '../../../test/models/model-with-indexes.model'
+import { ModelConstructor } from '../../model/model-constructor'
+import { Request } from './request.model'
+
+
+class TestRequest<T> extends Request<T, any, any, any> {
+
+  constructor(modelClazz: ModelConstructor<T>) {
+    super(<any>null, modelClazz, getTableName(modelClazz))
+  }
+
+  exec() {return <any>null}
+
+  execCount() {return <any>null}
+
+  execFullResponse() {return <any>null}
+
+  execNoMap() {return <any>null}
+
+  execSingle() {return <any>null}
+
+}
+
+
+describe('Request', () => {
+  let request: TestRequest<any>
+
+  describe('constructor', () => {
+    beforeEach(() => {
+      request = new TestRequest(SimpleWithPartitionKeyModel)
+    })
+    it('should set the default limit to params', () => {
+      expect(request.params).toBeDefined()
+      expect(request.params.Limit).toBe(Request.DEFAULT_LIMIT)
+    })
+  })
+
+  describe('exclusiveStartKey', () => {
+    beforeEach(() => {
+      request = new TestRequest(SimpleWithPartitionKeyModel)
+    })
+
+    it('should add ExclusiveStartKey to params', () => {
+      request.exclusiveStartKey({ id: { S: 'myId' } })
+      expect(request.params.ExclusiveStartKey).toEqual({ id: { S: 'myId' } })
+    })
+
+    it('should remove ExclusiveStartKey when providing null', () => {
+      request.exclusiveStartKey({ id: { S: 'myId' } })
+      expect(request.params.ExclusiveStartKey).toEqual({ id: { S: 'myId' } })
+
+      request.exclusiveStartKey(null)
+      expect(request.params.ExclusiveStartKey).toBeUndefined()
+      expect(Object.keys(request.params).includes('ExclusiveStartKey')).toBeFalsy()
+    })
+  })
+
+  describe('index', () => {
+    beforeEach(() => {
+      request = new TestRequest(ModelWithABunchOfIndexes)
+    })
+
+    it('[GSI] should set index on params ', () => {
+      request.index(INDEX_ACTIVE_CREATED_AT)
+      expect(request.params.IndexName).toBe(INDEX_ACTIVE_CREATED_AT)
+    })
+
+    it('[LSI] should set index on params ', () => {
+      request.index(INDEX_COUNT)
+      expect(request.params.IndexName).toBe(INDEX_COUNT)
+    })
+
+    it('should throw when index does not exist on model', () => {
+      expect(() => request.index('NON_EXISTENT_INDEX')).toThrow()
+    })
+
+  })
+
+  describe('limit', () => {
+    beforeEach(() => {
+      request = new TestRequest(SimpleWithCompositePartitionKeyModel)
+    })
+
+    it('should throw when a number was given less than 1 (except -1, which means INFINITE)', () => {
+      expect(() => request.limit(-100)).toThrow()
+      expect(() => request.limit(0)).toThrow()
+    })
+
+    it('should set limit to params and be overridable', () => {
+      request.limit(5)
+      expect(request.params.Limit).toBe(5)
+
+      request.limit(10)
+      expect(request.params.Limit).toBe(10)
+    })
+
+    it('should remove limit when INFINITE_LIMIT was given as arg', () => {
+      request.limit(5)
+      expect(request.params.Limit).toBe(5)
+      request.limit(Request.INFINITE_LIMIT)
+      expect(request.params.Limit).toBeUndefined()
+      expect(Object.keys(request.params).includes('Limit')).toBeFalsy()
+    })
+
+  })
+
+})

src/dynamo/request/scan/scan.request.spec.ts

@@ -86,7 +86,7 @@ describe('scan request', () => {
 
     it('execSingle', async () => {
       const res = await scanRequest.execSingle().toPromise()
-      // fixme
+      // todo: uncomment when todo in scanRequest::execSingle was done
       // expect(scanSpy).toHaveBeenCalled()
       // expect(scanSpy.calls.mostRecent().args[0]).toBeDefined()
       // expect(scanSpy.calls.mostRecent().args[0].Limit).toBe(1)

src/dynamo/request/scan/scan.request.ts

@@ -66,6 +66,7 @@ export class ScanRequest<T> extends Request<T, ScanRequest<T>, ScanInput, ScanRe
   }
 
   execSingle(): Observable<T | null> {
+    // todo: add Limit=1 to params
     delete this.params.Select
     this.logger.debug('single request', this.params)
     return this.dynamoRx.scan(this.params).pipe(