dynamodb_framework 1.3.0 → 1.4.0

data/spec/dynamodb_table_manager_spec.rb

@@ -0,0 +1,156 @@
+require 'spec_helper'
+
+RSpec.describe DynamoDbFramework::TableManager do
+
+  let(:store) do
+    DynamoDbFramework::Store.new({ endpoint: DYNAMODB_STORE_ENDPOINT, aws_region: 'eu-west-1' })
+  end
+
+  subject do
+    DynamoDbFramework::TableManager.new(store)
+  end
+
+  attributes_builder = DynamoDbFramework::AttributesBuilder.new
+
+  before do
+    attributes_builder = DynamoDbFramework::AttributesBuilder.new
+    attributes_builder.add(:id, :S)
+
+    subject.create('update_throughput', attributes_builder.attributes, :id)
+
+    subject.create('add_index', attributes_builder.attributes, :id)
+  end
+
+  it 'can create, check exists & drop tables' do
+
+    exists = subject.exists?('create_drop_test')
+
+    if exists
+      subject.drop('create_drop_test')
+    end
+
+    subject.create('create_drop_test', attributes_builder.attributes, :id)
+
+    subject.drop('create_drop_test')
+  end
+
+  it 'can create a table with a hash key and a range key' do
+
+    exists = subject.exists?('dual_key')
+
+    if exists
+      subject.drop('dual_key')
+    end
+
+    subject.create('dual_key', attributes_builder.attributes, :id)
+
+    subject.drop('dual_key')
+
+  end
+
+  it 'can create a table with a global secondary index' do
+
+    exists = subject.exists?('index_test')
+
+    if exists
+      subject.drop('index_test')
+    end
+
+    global_indexes = []
+    index1 = subject.create_global_index('index1', :name, :number)
+    global_indexes.push(index1)
+
+    builder = DynamoDbFramework::AttributesBuilder.new
+    builder.add(:id, :S)
+    builder.add(:name, :S)
+    builder.add(:number, :N)
+
+    subject.create('index_test', builder.attributes, :id, nil, 20, 10, global_indexes)
+
+    subject.drop('index_test')
+
+  end
+
+  it 'can update the throughput of a table' do
+
+    subject.update_throughput('update_throughput', 30, 30)
+
+  end
+
+  it 'can add a global index to an existing table' do
+
+    builder = DynamoDbFramework::AttributesBuilder.new
+    builder.add(:id, :S)
+    builder.add(:name, :S)
+
+    index = subject.create_global_index('new_index', :name, nil)
+    subject.add_index('add_index', builder.attributes, index)
+
+    has_index = subject.has_index?('add_index', 'new_index')
+
+    expect(has_index).to eq(true)
+
+  end
+
+  it 'can update the throughput of a global secondary index' do
+
+    exists = subject.exists?('update_index_throughput_test')
+
+    if exists
+      subject.drop('update_index_throughput_test')
+    end
+
+    global_indexes = []
+    index1 = subject.create_global_index('index1', :name, :number)
+    global_indexes.push(index1)
+
+    builder = DynamoDbFramework::AttributesBuilder.new
+    builder.add(:id, :S)
+    builder.add(:name, :S)
+    builder.add(:number, :N)
+
+    subject.create('update_index_throughput_test', builder.attributes, :id, nil, 20, 10, global_indexes)
+
+    subject.update_index_throughput('update_index_throughput_test', 'index1', 50, 50)
+
+    subject.drop('update_index_throughput_test')
+
+  end
+
+  it 'can drop an existing global secondary index' do
+
+    exists = subject.exists?('drop_index_test')
+
+    if exists
+      subject.drop('drop_index_test')
+    end
+
+    global_indexes = []
+    index1 = subject.create_global_index('index1', :name, :number)
+    global_indexes.push(index1)
+
+    builder = DynamoDbFramework::AttributesBuilder.new
+    builder.add(:id, :S)
+    builder.add(:name, :S)
+    builder.add(:number, :N)
+
+    subject.create('drop_index_test', builder.attributes, :id, nil, 20, 10, global_indexes)
+
+    subject.drop_index('drop_index_test', 'index1')
+
+    has_index = subject.has_index?('drop_index_test', 'index1')
+
+    subject.drop('drop_index_test')
+
+    expect(has_index).to eq(false)
+
+  end
+
+  after do
+
+    subject.drop('update_throughput')
+    subject.drop('add_index')
+
+  end
+
+end

data/spec/dynamodb_table_spec.rb

@@ -0,0 +1,245 @@
+RSpec.describe DynamoDbFramework::Table 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
+
+  describe '#create' do
+    context 'when a valid table class calls the create method' do
+      context 'with a range key' do
+        let(:table_name) { ExampleTable.config[:table_name] }
+        before do
+          table_manager.drop(table_name)
+        end
+        it 'should create the table' do
+          expect(table_manager.exists?(table_name)).to be false
+          ExampleTable.create(store: store)
+          expect(table_manager.exists?(table_name)).to be true
+        end
+      end
+
+      context 'without a range key' do
+        let(:table_name) { ExampleTableWithoutRangeKey.config[:table_name] }
+        before do
+          table_manager.drop(table_name)
+        end
+        it 'should create the table' do
+          expect(table_manager.exists?(table_name)).to be false
+          ExampleTableWithoutRangeKey.create(store: store)
+          expect(table_manager.exists?(table_name)).to be true
+        end
+      end
+    end
+    context 'when an invalid table class calls the create method' do
+      context 'without a table_name specified' do
+        it 'should raise an exception' do
+          expect{ ExampleTableWithoutTableName.create(store: store) }.to raise_error(DynamoDbFramework::Table::InvalidConfigException)
+        end
+      end
+      context 'without a partition_key specified' do
+        it 'should raise an exception' do
+          expect{ ExampleTableWithoutPartitionKey.create(store: store) }.to raise_error(DynamoDbFramework::Table::InvalidConfigException)
+        end
+      end
+    end
+  end
+
+  describe '#update' do
+    context 'when a valid table class calls the update method' do
+      let(:table_name) { ExampleTable.config[:table_name] }
+      before do
+        table_manager.drop(table_name)
+        ExampleTable.create(store: store)
+      end
+      it 'should update the table' do
+        ExampleTable.update(store: store, read_capacity: 50, write_capacity: 50)
+      end
+    end
+    context 'when an invalid table class calls the update method' do
+      context 'without a table_name specified' do
+        it 'should raise an exception' do
+          expect{ ExampleTableWithoutTableName.update(store: store, read_capacity: 50, write_capacity: 50) }.to raise_error(DynamoDbFramework::Table::InvalidConfigException)
+        end
+      end
+    end
+  end
+
+  describe '#drop' do
+    context 'when a valid table class calls the drop method' do
+      let(:table_name) { ExampleTable.config[:table_name] }
+      before do
+        table_manager.drop(table_name)
+        ExampleTable.create(store: store)
+      end
+      it 'should drop the table' do
+        ExampleTable.drop(store: store)
+        expect(table_manager.exists?(table_name)).to be false
+      end
+    end
+    context 'when an invalid table class calls the drop method' do
+      context 'without a table_name specified' do
+        it 'should raise an exception' do
+          expect{ ExampleTableWithoutTableName.drop(store: store) }.to raise_error(DynamoDbFramework::Table::InvalidConfigException)
+        end
+      end
+    end
+  end
+
+  describe '#exists?' do
+    context 'when a table already exists' do
+      let(:table_name) { ExampleTable.config[:table_name] }
+      before do
+        table_manager.drop(table_name)
+        ExampleTable.create(store: store)
+      end
+      it 'should return true' do
+        expect(ExampleTable.exists?(store: store)).to be true
+      end
+    end
+    context 'when a table does NOT already exist' do
+      let(:table_name) { ExampleTable.config[:table_name] }
+      before do
+        table_manager.drop(table_name)
+      end
+      it 'should return false' do
+        expect(ExampleTable.exists?(store: store)).to be false
+      end
+    end
+  end
+
+  describe '#query' do
+
+    let(:repository) do
+      DynamoDbFramework::Repository.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
+
+    it 'should return the expected items' do
+      results = ExampleTable2.query(partition: '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 = ExampleTable2.query(partition: '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 = ExampleTable2.query(partition: 'name 1')
+                    .number.gt_eq(1)
+                    .and
+                    .number.lt_eq(5)
+                    .execute(store: store, count: 4)
+        expect(count).to eq 4
+      end
+    end
+  end
+
+  describe '#all' do
+    let(:repository) do
+      DynamoDbFramework::Repository.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
+
+    it 'should return all items' do
+      results = ExampleTable2.all(store: store)
+      expect(results.length).to eq 9
+    end
+  end
+
+  describe '#CRUD' do
+    let(:repository) do
+      DynamoDbFramework::Repository.new(store)
+    end
+
+    let(:table_name) { ExampleTable.config[:table_name] }
+
+    let(:item) do
+      item = TestItem.new
+      item.id = SecureRandom.uuid
+      item.name = 'abc'
+      item.timestamp = Time.now
+      item.number = 1
+      item
+    end
+
+    let(:table_name) { ExampleTable.config[:table_name] }
+    before do
+      table_manager.drop(table_name)
+      ExampleTable.create(store: store)
+    end
+
+    it 'should add, get and delete the item to the table' do
+      ExampleTable.put_item(store: store, item: item)
+      expect(ExampleTable.get_item(store: store, partition: item.id, range: item.timestamp)).not_to be_nil
+      ExampleTable.delete_item(store: store, partition: item.id, range: item.timestamp)
+      expect(ExampleTable.get_item(store: store, partition: item.id, range: item.timestamp)).to be_nil
+    end
+  end
+
+end

data/spec/example_index.rb

@@ -0,0 +1,45 @@
+class ExampleIndex
+  extend DynamoDbFramework::Index
+
+  index_name 'example_index'
+  table ExampleTable
+  partition_key :name, :S
+  range_key :id, :S
+
+end
+
+class ExampleIndexWithoutIndexName
+  extend DynamoDbFramework::Index
+
+  table ExampleTable
+  partition_key :name, :S
+  range_key :id, :S
+
+end
+
+class ExampleIndexWithoutTable
+  extend DynamoDbFramework::Index
+
+  index_name 'example_index'
+  partition_key :name, :S
+  range_key :id, :S
+
+end
+
+class ExampleIndexWithoutPartitionKey
+  extend DynamoDbFramework::Index
+
+  table ExampleTable
+  index_name 'example_index'
+  range_key :id, :S
+
+end
+
+class ExampleIndexWithoutRangeKey
+  extend DynamoDbFramework::Index
+
+  index_name 'example_index'
+  table ExampleTable
+  partition_key :name, :S
+
+end

data/spec/example_table.rb

@@ -0,0 +1,41 @@
+class ExampleTable
+  extend DynamoDbFramework::Table
+
+  table_name 'example'
+  partition_key :id, :S
+  range_key :timestamp, :N
+
+end
+
+class ExampleTable2
+  extend DynamoDbFramework::Table
+
+  table_name 'example2'
+  partition_key :name, :S
+  range_key :id, :S
+
+end
+
+class ExampleTableWithoutTableName
+  extend DynamoDbFramework::Table
+
+  partition_key :id, :S
+  range_key :timestamp, :N
+
+end
+
+class ExampleTableWithoutPartitionKey
+  extend DynamoDbFramework::Table
+
+  table_name 'example'
+  range_key :timestamp, :N
+
+end
+
+class ExampleTableWithoutRangeKey
+  extend DynamoDbFramework::Table
+
+  table_name 'example'
+  partition_key :id, :S
+
+end

data/spec/hash_helper_spec.rb

@@ -0,0 +1,129 @@
+require 'spec_helper'
+
+RSpec.describe DynamoDbFramework::HashHelper do
+  describe '#to_hash' do
+    let(:service_klass) do
+      Class.new do
+        attr_accessor :code, :created
+      end
+    end
+    let(:account_klass) do
+      Class.new do
+        attr_accessor :name, :email, :services
+      end
+    end
+
+    let(:current_time       ) { Time.now                }
+    let(:name               ) { 'Service User'          }
+    let(:email              ) { 'service.user@sage,com' }
+    let(:hr_service_code    ) { 'HR'                    }
+    let(:hr_service_created ) { current_time.to_i       }
+    let(:crm_service_code   ) { 'CRM'                   }
+    let(:crm_service_created) { current_time.to_i       }
+
+    let(:hr_service) do
+      service_klass.new.tap do |obj|
+        obj.code    = hr_service_code
+        obj.created = hr_service_created
+      end
+    end
+    let(:crm_service) do
+      service_klass.new.tap do |obj|
+        obj.code    = crm_service_code
+        obj.created = crm_service_created
+      end
+    end
+    let(:account) do
+      account_klass.new.tap do |obj|
+        obj.name = name
+        obj.email = email
+        obj.services = [hr_service, crm_service]
+      end
+    end
+
+    context 'when given a hash' do
+      let(:obj) do
+        {
+          name: name,
+          email: email
+        }
+      end
+
+      it { expect(subject.to_hash(obj)).to eq(obj) }
+
+      context 'and one item in the hash is nil' do
+        let(:name) { nil }
+        let(:expected) { { email: email } }
+
+        it { expect(subject.to_hash(obj)).to eq(expected) }
+      end
+    end
+
+    context 'when all attributes are present' do
+      let(:expected) do
+        {
+          name: "Service User",
+          email: "service.user@sage,com",
+          services: [
+            { code: hr_service_code , created: hr_service_created },
+            { code: crm_service_code, created: crm_service_created}
+          ]
+        }
+      end
+
+      it { expect(subject.to_hash(account)).to eq(expected) }
+    end
+
+    context 'when parent obj has nil attribute' do
+      let(:name) { nil }
+      let(:expected) do
+        {
+          email: "service.user@sage,com",
+          services: [
+            { code: hr_service_code , created: hr_service_created },
+            { code: crm_service_code, created: crm_service_created}
+          ]
+        }
+      end
+
+      it { expect(subject.to_hash(account)).to eq(expected) }
+    end
+
+    context 'when child objects have nil attributes' do
+      let(:hr_service_code    ) { nil }
+      let(:crm_service_created) { nil }
+
+      let(:expected) do
+        {
+          name: name,
+          email: email,
+          services: [
+            { created: hr_service_created },
+            { code: crm_service_code}
+          ]
+        }
+      end
+
+      it { expect(subject.to_hash(account)).to eq(expected) }
+    end
+
+    context 'when parent and child objects have nil attributes' do
+      let(:email              ) { nil }
+      let(:hr_service_code    ) { nil }
+      let(:crm_service_created) { nil }
+
+      let(:expected) do
+        {
+          name: name,
+          services: [
+            { created: hr_service_created },
+            { code: crm_service_code}
+          ]
+        }
+      end
+
+      it { expect(subject.to_hash(account)).to eq(expected) }
+    end
+  end
+  it { expect({a: 1, b: nil}.reject{|k, v| v.nil?}).to eq({a: 1}) }
+end

data/spec/spec_helper.rb

@@ -0,0 +1,34 @@
+require "rubygems"
+require "bundler"
+require 'aws-sdk-core'
+require 'dynamodb_framework'
+require_relative '../spec/test_migration_script1'
+require_relative '../spec/test_migration_script2'
+require_relative '../spec/test_item.rb'
+require_relative '../spec/example_table'
+require_relative '../spec/example_index'
+require 'pry'
+
+require 'simplecov'
+SimpleCov.start do
+  add_filter '/spec/'
+end
+
+DYNAMODB_STORE_ENDPOINT = 'http://dynamodb:8000'
+
+Aws.config[:credentials] = Aws::Credentials.new('test_key', 'test_secret')
+Aws.config[:region] = 'eu-west-1'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.order = :defined
+end
+
+DynamoDbFramework.logger.level = Logger::ERROR

data/spec/test_item.rb

@@ -0,0 +1,6 @@
+class TestItem
+  attr_accessor :id
+  attr_accessor :name
+  attr_accessor :timestamp
+  attr_accessor :number
+end

data/spec/test_migration_script1.rb

@@ -0,0 +1,24 @@
+class TestMigrationScript1 < DynamoDbFramework::MigrationScript
+
+  def initialize
+    @timestamp = '20160318110710'
+    @namespace = 'test_namespace'
+    @store = DynamoDbFramework::Store.new({ endpoint: DYNAMODB_STORE_ENDPOINT, aws_region: 'eu-west-1' })
+    @table_manager = DynamoDbFramework::TableManager.new(@store)
+  end
+
+  def apply
+
+    builder = DynamoDbFramework::AttributesBuilder.new
+    builder.add({ name: :id, type: :string, key: :hash })
+    @table_manager.create_table({ name: 'test1', attributes: builder.attributes })
+
+  end
+
+  def undo
+
+    @table_manager.drop('test1')
+
+  end
+
+end

data/spec/test_migration_script2.rb

@@ -0,0 +1,24 @@
+class TestMigrationScript2 < DynamoDbFramework::MigrationScript
+
+  def initialize
+    @timestamp = '20160318110730'
+    @namespace = 'test_namespace'
+    @store = DynamoDbFramework::Store.new({ endpoint: DYNAMODB_STORE_ENDPOINT, aws_region: 'eu-west-1' })
+    @table_manager = DynamoDbFramework::TableManager.new(@store)
+  end
+
+  def apply
+
+    builder = DynamoDbFramework::AttributesBuilder.new
+    builder.add(:id, :S)
+    @table_manager.create('test2', builder.attributes, :id)
+
+  end
+
+  def undo
+
+    @table_manager.drop('test2')
+
+  end
+
+end