dynamodb_framework 1.3.0 → 1.4.0

data/spec/dynamodb_migration_manager_spec.rb

@@ -0,0 +1,134 @@
+require 'spec_helper'
+
+RSpec.describe DynamoDbFramework::MigrationManager do
+
+  let(:store) do
+    DynamoDbFramework::Store.new({ endpoint: DYNAMODB_STORE_ENDPOINT, aws_region: 'eu-west-1' })
+  end
+
+  let(:table_manager) do
+    DynamoDbFramework::TableManager.new(store)
+  end
+
+  let(:migration_table_name) do
+    'dynamodb_framework_migrations'
+  end
+
+  let(:repository) do
+    repository = DynamoDbFramework::Repository.new(store)
+    repository.table_name = migration_table_name
+    repository
+  end
+
+  subject do
+    DynamoDbFramework::MigrationManager.new(store)
+  end
+
+  context '#connect' do
+
+    it 'should create the migration table when not found' do
+
+      table_manager.drop(migration_table_name)
+
+      subject.connect()
+
+      table_manager.exists?(migration_table_name)
+
+    end
+
+    it 'should connect when migration table already exists' do
+
+      if !table_manager.exists?(migration_table_name)
+        builder = DynamoDbFramework::AttributesBuilder.new
+        builder.add(:id, :S)
+        table_manager.create(migration_table_name, builder.attributes, :id)
+      end
+
+      subject.connect()
+
+      table_manager.drop(migration_table_name)
+
+    end
+
+  end
+
+  context '#apply' do
+
+    it 'should apply all migration scripts when none have been applied previously' do
+
+      table_manager.drop(migration_table_name)
+
+      subject.connect()
+
+      subject.apply()
+
+      expect(table_manager.exists?('test1')).to eq(true)
+      expect(table_manager.exists?('test2')).to eq(true)
+
+      records = repository.all()
+      expect(records.length).to eq(2)
+      expect(records[0]['timestamp']).to eq('20160318110710')
+      expect(records[1]['timestamp']).to eq('20160318110730')
+
+    end
+
+    it 'should only apply migration scripts that have not been previously applied' do
+
+      table_manager.drop(migration_table_name)
+
+      subject.connect()
+
+      #setup migration history to have already previously applied script 1
+      script1 = TestMigrationScript1.new
+      script1.apply()
+
+      expect(table_manager.exists?('test1')).to eq(true)
+      repository.put({ :timestamp => script1.timestamp })
+      records = repository.all()
+      expect(records.length).to eq(1)
+      expect(records[0]['timestamp']).to eq('20160318110710')
+
+      #run migration apply
+      subject.apply()
+
+      #verify that script2 has been ran
+      records = repository.all()
+      expect(records.length).to eq(2)
+      expect(records[1]['timestamp']).to eq('20160318110730')
+
+    end
+
+  end
+
+  context '#rollback' do
+
+    it 'should roll back the last migration script that was applied' do
+
+      table_manager.drop(migration_table_name)
+      subject.connect()
+
+      #setup migration history to have already previously applied script 1
+      script1 = TestMigrationScript1.new
+      script1.apply()
+
+      expect(table_manager.exists?('test1')).to eq(true)
+      repository.put({ :timestamp => script1.timestamp })
+      records = repository.all()
+      expect(records.length).to eq(1)
+      expect(records[0]['timestamp']).to eq('20160318110710')
+
+      #execute a rollback
+      subject.rollback()
+
+      #verify that the test1 table has been removed as part of the rollback
+      expect(table_manager.exists?('test1')).to eq(false)
+
+    end
+
+  end
+
+  after do
+    table_manager.drop(migration_table_name)
+  end
+
+end

data/spec/dynamodb_namespace_migration_manager_spec.rb

@@ -0,0 +1,134 @@
+require 'spec_helper'
+
+RSpec.describe DynamoDbFramework::Namespace::MigrationManager do
+
+  let(:store) do
+    DynamoDbFramework::Store.new({ endpoint: DYNAMODB_STORE_ENDPOINT, aws_region: 'eu-west-1' })
+  end
+
+  let(:table_manager) do
+    DynamoDbFramework::TableManager.new(store)
+  end
+
+  let(:migration_table_name) do
+    'dynamodb_framework_migration_history'
+  end
+
+  let(:repository) do
+    repository = DynamoDbFramework::Repository.new(store)
+    repository.table_name = migration_table_name
+    repository
+  end
+
+  subject do
+    DynamoDbFramework::Namespace::MigrationManager.new(store)
+  end
+
+  context '#connect' do
+
+    it 'should create the migration table when not found' do
+
+      table_manager.drop(migration_table_name)
+
+      subject.connect()
+
+      table_manager.exists?(migration_table_name)
+
+    end
+
+    it 'should connect when migration table already exists' do
+
+      if !table_manager.exists?(migration_table_name)
+        builder = DynamoDbFramework::AttributesBuilder.new
+        builder.add(:id, :S)
+        table_manager.create(migration_table_name, builder.attributes, :id)
+      end
+
+      subject.connect()
+
+      table_manager.drop(migration_table_name)
+
+    end
+
+  end
+
+  context '#apply' do
+
+    it 'should apply all migration scripts when none have been applied previously' do
+
+      table_manager.drop(migration_table_name)
+
+      subject.connect()
+
+      subject.apply('test_namespace')
+
+      expect(table_manager.exists?('test1')).to eq(true)
+      expect(table_manager.exists?('test2')).to eq(true)
+
+      records = repository.all()
+      expect(records.length).to eq(2)
+      expect(records[0]['timestamp']).to eq('20160318110710')
+      expect(records[1]['timestamp']).to eq('20160318110730')
+
+    end
+
+    it 'should only apply migration scripts that have not been previously applied' do
+
+      table_manager.drop(migration_table_name)
+
+      subject.connect()
+
+      #setup migration history to have already previously applied script 1
+      script1 = TestMigrationScript1.new
+      script1.apply()
+
+      expect(table_manager.exists?('test1')).to eq(true)
+      repository.put({ :timestamp => script1.timestamp, :namespace => script1.namespace })
+      records = repository.all()
+      expect(records.length).to eq(1)
+      expect(records[0]['timestamp']).to eq('20160318110710')
+
+      #run migration apply
+      subject.apply('test_namespace')
+
+      #verify that script2 has been ran
+      records = repository.all()
+      expect(records.length).to eq(2)
+      expect(records[1]['timestamp']).to eq('20160318110730')
+
+    end
+
+  end
+
+  context '#rollback' do
+
+    it 'should roll back the last migration script that was applied' do
+
+      table_manager.drop(migration_table_name)
+      subject.connect()
+
+      #setup migration history to have already previously applied script 1
+      script1 = TestMigrationScript1.new
+      script1.apply()
+
+      expect(table_manager.exists?('test1')).to eq(true)
+      repository.put({ :timestamp => script1.timestamp, :namespace => script1.namespace })
+      records = repository.all()
+      expect(records.length).to eq(1)
+      expect(records[0]['timestamp']).to eq('20160318110710')
+
+      #execute a rollback
+      subject.rollback('test_namespace')
+
+      #verify that the test1 table has been removed as part of the rollback
+      expect(table_manager.exists?('test1')).to eq(false)
+
+    end
+
+  end
+
+  after do
+    table_manager.drop(migration_table_name)
+  end
+
+end

data/spec/dynamodb_query_spec.rb

@@ -0,0 +1,87 @@
+RSpec.describe DynamoDbFramework::Query do
+
+  let(:store) do
+    DynamoDbFramework::Store.new({ endpoint: DYNAMODB_STORE_ENDPOINT, aws_region: 'eu-west-1' })
+  end
+
+  let(:repository) do
+    DynamoDbFramework::Repository.new(store)
+  end
+
+  let(:table_manager) do
+    DynamoDbFramework::TableManager.new(store)
+  end
+
+  let(:table_name) { ExampleTable2.config[:table_name] }
+
+  def create_query_item(name, number)
+    item = TestItem.new
+    item.id = SecureRandom.uuid
+    item.name = name
+    item.timestamp = Time.now
+    item.number = number
+    repository.table_name = table_name
+    repository.put(item)
+  end
+
+  before do
+    table_manager.drop(table_name)
+    ExampleTable2.create(store: store)
+
+    create_query_item('name 1', 1)
+    create_query_item('name 1', 2)
+    create_query_item('name 1', 3)
+    create_query_item('name 1', 4)
+    create_query_item('name 2', 1)
+    create_query_item('name 2', 2)
+    create_query_item('name 2', 3)
+    create_query_item('name 3', 1)
+    create_query_item('name 3', 2)
+  end
+
+  describe '#build' do
+    it 'should correctly generate the expression string and params' do
+      string,params = DynamoDbFramework::Query.new(table_name: table_name, partition_key: :name, partition_value: 'name 1')
+                          .number.gt_eq(1)
+                          .and
+                          .number.lt_eq(5)
+                          .build
+      expect(string).to eq '#number >= :p0 and #number <= :p1'
+      expect(params['#number']).to eq 'number'
+      expect(params[':p0']).to eq 1
+      expect(params[':p1']).to eq 5
+    end
+  end
+
+  describe '#execute' do
+    it 'should return the expected items' do
+      results = DynamoDbFramework::Query.new(table_name: table_name, partition_key: :name, partition_value: 'name 1')
+                    .number.gt_eq(1)
+                    .and
+                    .number.lt_eq(5)
+                    .execute(store: store)
+      expect(results.length).to eq 4
+    end
+    context 'when limit is specified' do
+      it 'should return the expected items' do
+        results = DynamoDbFramework::Query.new(table_name: table_name, partition_key: :name, partition_value: 'name 1')
+                      .number.gt_eq(1)
+                      .and
+                      .number.lt_eq(5)
+                      .execute(store: store, limit: 1)
+        expect(results.length).to eq 1
+      end
+    end
+    context 'when count is specified' do
+      it 'should return the expected count' do
+        count = DynamoDbFramework::Query.new(table_name: table_name, partition_key: :name, partition_value: 'name 1')
+                    .number.gt_eq(1)
+                    .and
+                    .number.lt_eq(5)
+                    .execute(store: store, count: 4)
+        expect(count).to eq 4
+      end
+    end
+  end
+
+end

data/spec/dynamodb_repository_spec.rb

@@ -0,0 +1,306 @@
+require 'spec_helper'
+
+RSpec.describe DynamoDbFramework::Repository do
+  let(:store) do
+    DynamoDbFramework::Store.new({ endpoint: DYNAMODB_STORE_ENDPOINT, aws_region: 'eu-west-1' })
+  end
+
+  let(:schema_manager) do
+    DynamoDbFramework::TableManager.new(store)
+  end
+
+  subject do
+    DynamoDbFramework::Repository.new(store)
+  end
+
+  def create_query_item(name, number, table_name)
+    item = TestItem.new
+    item.id = SecureRandom.uuid
+    item.name = name
+    item.timestamp = Time.now
+    item.number = number
+    subject.table_name = table_name
+    subject.put(item)
+  end
+
+  describe '#put' do
+    let(:current_time) { Time.now          }
+    let(:id          ) { 'Item1'           }
+    let(:name        ) { 'Name'            }
+    let(:timestamp   ) { current_time }
+    let(:number      ) { 5                 }
+
+    let(:item) do
+      TestItem.new.tap do |obj|
+        obj.id        = id
+        obj.name      = name
+        obj.timestamp = timestamp
+        obj.number    = number
+      end
+    end
+
+    before do
+      schema_manager.drop('put')
+      attributes_builder = DynamoDbFramework::AttributesBuilder.new
+      attributes_builder.add(:id, :S)
+      schema_manager.create('put', attributes_builder.attributes, :id)
+      subject.table_name = 'put'
+    end
+
+    it 'can store an item in a table' do
+      expect { subject.put(item) }.to_not raise_error
+    end
+
+    context 'when one of the entity values is nil' do
+      let(:name) { nil }
+
+      it 'does not raise an error' do
+        expect { subject.put(item) }.to_not raise_error
+
+        stored_item = subject.get_by_key('id', id)
+
+        expect(stored_item['id']).to eq(id)
+        expect(stored_item['name']).to eq(name)
+        expect(stored_item['number']).to eq(number)
+      end
+    end
+
+    context 'when one of the entity values is an empty string' do
+      let(:name) { '' }
+
+      it 'does not raise an error' do
+        expect { subject.put(item) }.to_not raise_error
+
+        stored_item = subject.get_by_key('id', id)
+
+        expect(stored_item['id']).to eq(id)
+        expect(stored_item['name']).to eq(nil)
+        expect(stored_item['number']).to eq(number)
+      end
+    end
+
+    context 'when a date attribute is a DateTime class' do
+      let(:timestamp) {DateTime.now}
+
+      it 'stores the attribute in an iso8601 string format' do
+
+        subject.put(item)
+        stored_item = subject.get_by_key('id', id)
+
+        expect(stored_item['timestamp']).to eq(timestamp.iso8601)
+      end
+    end
+
+    context 'when a date attribute is a Time class' do
+      let(:timestamp) {Time.now}
+
+      it 'stores the attribute as an Epoch int' do
+        subject.put(item)
+        stored_item = subject.get_by_key('id', id)
+
+        expect(stored_item['timestamp']).to eq(timestamp.to_i)
+      end
+    end
+
+    after do
+      schema_manager.drop('put')
+    end
+
+  end
+
+  context '#delete' do
+    before do
+      schema_manager.drop('delete')
+      attributes_builder = DynamoDbFramework::AttributesBuilder.new
+      attributes_builder.add(:id, :S)
+      schema_manager.create('delete', attributes_builder.attributes, :id)
+    end
+
+    it 'can delete an item from a table' do
+      item = TestItem.new
+      item.id = 'Item1'
+      item.name = 'Name'
+      item.timestamp = Time.now.to_i
+      item.number = 5
+
+      subject.table_name = 'delete'
+      subject.put(item)
+
+      subject.delete({ id: item.id })
+    end
+
+    after do
+      schema_manager.drop('delete')
+    end
+
+  end
+
+  context '#get_by_key' do
+    before do
+      schema_manager.drop('get_by_key')
+      attributes_builder = DynamoDbFramework::AttributesBuilder.new
+      attributes_builder.add(:id, :S)
+      schema_manager.create('get_by_key', attributes_builder.attributes, :id)
+    end
+
+    it 'can get an item from a table by the item key' do
+      item = TestItem.new
+      item.id = 'Item1'
+      item.name = 'Name'
+      item.timestamp = Time.now.to_i
+      item.number = 5
+
+      subject.table_name = 'get_by_key'
+      subject.put(item)
+
+      item = subject.get_by_key('id', item.id)
+      expect(item).to_not be_nil
+      expect(item["id"]).to eq('Item1')
+      expect(item["name"]).to eq('Name')
+    end
+
+    after do
+      schema_manager.drop('get_by_key')
+    end
+
+  end
+
+  context '#query no index' do
+    before do
+      schema_manager.drop('query')
+
+      attributes_builder = DynamoDbFramework::AttributesBuilder.new
+      attributes_builder.add(:name, :S, :partition)
+      attributes_builder.add(:id, :S, :range)
+
+      schema_manager.create_table(name: 'query', attributes: attributes_builder.attributes)
+
+
+      create_query_item('name 1', 1, 'query')
+      create_query_item('name 1', 2, 'query')
+      create_query_item('name 1', 3, 'query')
+      create_query_item('name 1', 4, 'query')
+      create_query_item('name 2', 1, 'query')
+      create_query_item('name 2', 2, 'query')
+      create_query_item('name 2', 3, 'query')
+      create_query_item('name 3', 1, 'query')
+      create_query_item('name 3', 2, 'query')
+    end
+
+    it 'should return all items within a partition that match a filter expression' do
+      subject.table_name = 'query'
+
+      results = subject.query(:name, 'name 1', nil, nil, '#number > :number', { '#number' => 'number', ':number' => 2})
+
+      expect(results.length).to eq(2)
+    end
+
+    it 'should count all items within a partition that match a filter expression' do
+      subject.table_name = 'query'
+
+      count = subject.query(:name, 'name 1', nil, nil, '#number > :number', { '#number' => 'number', ':number' => 2}, nil, nil, true)
+
+      expect(count).to eq(2)
+    end
+
+    after do
+      schema_manager.drop('query')
+    end
+  end
+
+  context '#query index' do
+    before do
+      schema_manager.drop('query_index')
+
+      attributes_builder = DynamoDbFramework::AttributesBuilder.new
+      attributes_builder.add(:id, :S)
+      attributes_builder.add(:name, :S)
+
+      global_indexes = []
+      index1 = schema_manager.create_global_index('name_index', :name)
+      global_indexes.push(index1)
+      schema_manager.create('query_index', attributes_builder.attributes, :id, nil, 20, 10, global_indexes)
+
+
+      create_query_item('name 1', 1, 'query_index')
+      create_query_item('name 1', 2, 'query_index')
+      create_query_item('name 1', 3, 'query_index')
+      create_query_item('name 1', 4, 'query_index')
+      create_query_item('name 2', 1, 'query_index')
+      create_query_item('name 2', 2, 'query_index')
+      create_query_item('name 2', 3, 'query_index')
+      create_query_item('name 3', 1, 'query_index')
+      create_query_item('name 3', 2, 'query_index')
+    end
+
+    it 'should return all items within an index partition that match a filter expression' do
+      subject.table_name = 'query_index'
+
+      results = subject.query(:name, 'name 1', nil, nil, '#number > :number', { '#number' => 'number', ':number' => 2}, 'name_index')
+
+      expect(results.length).to eq(2)
+    end
+
+    it 'should count all items within an index partition that match a filter expression' do
+      subject.table_name = 'query_index'
+
+      count = subject.query(:name, 'name 1', nil, nil, '#number > :number', { '#number' => 'number', ':number' => 2}, 'name_index', nil, true)
+
+      expect(count).to eq(2)
+    end
+
+    after do
+      schema_manager.drop('query_index')
+    end
+  end
+
+  context '#scan' do
+    before do
+      schema_manager.drop('scan')
+
+      attributes_builder = DynamoDbFramework::AttributesBuilder.new
+      attributes_builder.add(:id, :S)
+
+      schema_manager.create('scan', attributes_builder.attributes, :id)
+
+
+      create_query_item('name 1', 1, 'scan')
+      create_query_item('name 1', 2, 'scan')
+      create_query_item('name 1', 3, 'scan')
+      create_query_item('name 1', 4, 'scan')
+      create_query_item('name 2', 1, 'scan')
+      create_query_item('name 2', 2, 'scan')
+      create_query_item('name 2', 3, 'scan')
+      create_query_item('name 3', 1, 'scan')
+      create_query_item('name 3', 2, 'scan')
+    end
+
+    it 'should return all items from a table' do
+      subject.table_name = 'scan'
+
+      results = subject.all()
+
+      expect(results.length).to eq(9)
+    end
+
+    it 'should count all items from a table that match a filter expression' do
+      subject.table_name = 'scan'
+
+      count = subject.scan('#name = :name', { '#name' => :name, ':name' => 'name 1' }, nil, true)
+
+      expect(count).to eq(4)
+    end
+
+    it 'should return all items from a table that match a filter expression' do
+      subject.table_name = 'scan'
+
+      results = subject.scan('#name = :name', { '#name' => :name, ':name' => 'name 1' })
+
+      expect(results.length).to eq(4)
+    end
+
+    after do
+      schema_manager.drop('scan')
+    end
+  end
+end