add tests for entity actions from table instance

Author: jeremydaly

__tests__/entity.parse.unit.test.js

@@ -0,0 +1,87 @@
+const { DocumentClient } = require('./bootstrap-tests')
+
+// Require Table and Entity classes
+const Table = require('../classes/Table')
+const Entity = require('../classes/Entity')
+
+// Create basic entity
+const TestEntity = new Entity(require('./entities/test-entity.js'))
+const SimpleEntity = new Entity(require('./entities/simple-entity.js'))
+
+// Create basic table
+const TestTable = new Table({
+  name: 'test-table',
+  partitionKey: 'pk',
+  sortKey: 'sk',
+  entities: [TestEntity,SimpleEntity],
+  DocumentClient
+})
+
+
+describe('parse',()=>{
+
+  it('parses single item', ()=>{
+    let item = TestEntity.parse({ pk: 'test@test.com', sk: 'email', test_string: 'test', _et: 'TestEntity' })
+    expect(item).toEqual({
+      email: 'test@test.com',
+      test_type: 'email',
+      test_string: 'test',
+      entity: 'TestEntity'
+    })
+  })
+
+  it('parses single item and includes certain fields', ()=>{
+    let item = TestEntity.parse({ pk: 'test@test.com', sk: 'email', test_string: 'test', _et: 'TestEntity' }, ['email','sk'])
+    expect(item).toEqual({
+      email: 'test@test.com',
+      test_type: 'email'
+    })
+  })
+
+  it('parses multiple items', ()=>{
+    let items = TestEntity.parse([
+      { pk: 'test@test.com', sk: 'email', test_string: 'test' },
+      { pk: 'test2@test.com', sk: 'email2', test_string: 'test2' }
+    ])
+    expect(items).toEqual([
+      {
+        email: 'test@test.com',
+        test_type: 'email',
+        test_string: 'test'
+      },
+      {
+        email: 'test2@test.com',
+        test_type: 'email2',
+        test_string: 'test2'
+      }
+    ])
+  })
+
+  it('parses multiple items and incudes certain field', ()=>{
+    let items = TestEntity.parse([
+      { pk: 'test@test.com', sk: 'email', test_string: 'test' },
+      { pk: 'test2@test.com', sk: 'email2', test_string: 'test2' }
+    ],['pk','test_string'])
+    expect(items).toEqual([
+      {
+        email: 'test@test.com',
+        test_string: 'test'
+      },
+      {
+        email: 'test2@test.com',
+        test_string: 'test2'
+      }
+    ])
+  })
+
+  it('parses composite field', ()=>{
+    let item = SimpleEntity.parse({ pk: 'test@test.com', sk: 'active#email', test_composite: 'test' })
+    expect(item).toEqual({
+      pk: 'test@test.com',
+      test_composite: 'test',
+      test_composite2: 'email',
+    })
+  })
+
+
+}) // end parse

__tests__/table.entity-actions.unit.test.js

@@ -0,0 +1,94 @@
+const { Table, Entity } = require('../index')
+const { DocumentClient } = require('./bootstrap-tests')
+
+const TestTable = new Table({
+  name: 'test-table',
+  partitionKey: 'pk',
+  sortKey: 'sk',
+  indexes: { GSI1: { partitionKey: 'GSI1pk', sortKey: 'GSIsk1' } },
+  DocumentClient,
+  autoExecute: false
+})
+
+const TestEntity = new Entity({
+  name: 'TestEntity',
+  autoExecute: false,
+  attributes: {
+    email: { type: 'string', partitionKey: true },
+    sort: { type: 'string', sortKey: true },
+    test: 'string'
+  },
+  table: TestTable
+})
+
+describe('table.get',()=>{
+
+  it('gets an entity from the table', async () => {
+    let result = await TestTable.get('TestEntity',{ email: 'val1', sort: 'val2' })
+    expect(result).toEqual({ TableName: 'test-table', Key: { pk: 'val1', sk: 'val2' } })
+  })
+
+  it('fails on invalid entity when performing a get', () => {
+    expect(TestTable.get('TestEntityX')).rejects.toThrow(`'TestEntityX' is not a valid Entity`)
+  })
+})
+
+describe('table.delete',()=>{
+
+  it('deletes an entity from the table', async () => {
+    let result = await TestTable.delete('TestEntity',{ email: 'val1', sort: 'val2' })
+    expect(result).toEqual({ TableName: 'test-table', Key: { pk: 'val1', sk: 'val2' } })
+  })
+
+  it('fails on invalid entity when performing a delete', () => {
+    expect(TestTable.delete('TestEntityX')).rejects.toThrow(`'TestEntityX' is not a valid Entity`)
+  })
+})
+
+describe('table.update',()=>{
+
+  it('updates an entity from the table', async () => {
+    let result = await TestTable.update('TestEntity',{ email: 'val1', sort: 'val2', test: 'testing' })
+    expect(result.TableName).toBe('test-table')
+    expect(result.Key).toEqual({ pk: 'val1', sk: 'val2' })
+    expect(result.UpdateExpression).toBe('SET #_ct = if_not_exists(#_ct,:_ct), #_md = :_md, #_et = if_not_exists(#_et,:_et), #test = :test')
+  })
+
+  it('fails on invalid entity when performing an update', () => {
+    expect(TestTable.update('TestEntityX')).rejects.toThrow(`'TestEntityX' is not a valid Entity`)
+  })
+})
+
+describe('table.put',()=>{
+
+  it('puts an entity to the table', async () => {
+    let result = await TestTable.put('TestEntity',{ email: 'val1', sort: 'val2', test: 'testing' })    
+    expect(result.TableName).toBe('test-table')
+    expect(result.Item.pk).toBe('val1')
+    expect(result.Item.sk).toBe('val2')
+    expect(result.Item.test).toBe('testing')
+  })
+
+  it('fails on invalid entity when performing a put', () => {
+    expect(TestTable.put('TestEntityX')).rejects.toThrow(`'TestEntityX' is not a valid Entity`)
+  })
+})
+
+
+describe('table.parse',()=>{
+
+  it('parses single item', async ()=>{
+    let item = await TestTable.parse('TestEntity',{ pk: 'test@test.com', sk: 'email', test: 'testing', _et: 'TestEntity' })
+    expect(item).toEqual({
+      email: 'test@test.com',
+      sort: 'email',
+      test: 'testing',
+      entity: 'TestEntity'
+    })
+  })
+
+  it('fails on invalid entity when performing a parse', () => {
+    expect(TestTable.parse('TestEntityX')).rejects.toThrow(`'TestEntityX' is not a valid Entity`)
+  })
+
+}) // end table.parse

classes/Table.js

@@ -1030,27 +1030,27 @@ class Table {
 
 
   // Entity operation references
-  parse(entity,input,include=[]) {
+  async parse(entity,input,include=[]) {
     if (!this[entity]) error(`'${entity}' is not a valid Entity`)
     return this[entity].parse(input,include)
   }
 
-  get(entity,item={},options={},params={}) {
+  async get(entity,item={},options={},params={}) {
     if (!this[entity]) error(`'${entity}' is not a valid Entity`)
     return this[entity].get(item,options,params)
   }
 
-  delete(entity,item={},options={},params={}) {
+  async delete(entity,item={},options={},params={}) {
     if (!this[entity]) error(`'${entity}' is not a valid Entity`)
     return this[entity].delete(item,options,params)
   }
 
-  update(entity,item={},options={},params={}) {
+  async update(entity,item={},options={},params={}) {
     if (!this[entity]) error(`'${entity}' is not a valid Entity`)
     return this[entity].update(item,options,params)
   }
 
-  put(entity,item={},options={},params={}) {
+  async put(entity,item={},options={},params={}) {
     if (!this[entity]) error(`'${entity}' is not a valid Entity`)
     return this[entity].put(item,options,params)
   }