dynamini 1.8.2 → 1.9.1

data/spec/dynamini/batch_operations_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe Dynamini::BatchOperations do
+
+  let(:model_attributes) {
+    {
+        name: 'Widget',
+        price: 9.99,
+        id: 'abcd1234',
+        hash_key: '009'
+    }
+  }
+
+  let(:model) { Dynamini::Base.new(model_attributes) }
+
+  subject { Dynamini::Base }
+
+  describe '.import' do
+    it 'should generate timestamps for each model' do
+      model1 = Dynamini::Base.new(model_attributes)
+      model2 = Dynamini::Base.new(model_attributes.merge(id: '2'))
+
+      subject.import([model1, model2])
+
+      expect(subject.find(model1.id).updated_at).not_to be_nil
+      expect(subject.find(model1.id).created_at).not_to be_nil
+      expect(subject.find(model2.id).updated_at).not_to be_nil
+      expect(subject.find(model2.id).created_at).not_to be_nil
+    end
+
+    it 'should call .dynamo_batch_save with batches of 25 models' do
+      models = Array.new(30, model)
+      expect(subject).to receive(:dynamo_batch_save).with(array_including(models[0..24])).ordered
+      expect(subject).to receive(:dynamo_batch_save).with(array_including(models[25..29])).ordered
+      subject.import(models)
+    end
+  end
+
+  describe '.dynamo_batch_save' do
+    it 'should batch write the models to dynamo' do
+      model2 = Dynamini::Base.new(id: '123')
+      model3 = Dynamini::Base.new(id: '456')
+      Dynamini::Base.dynamo_batch_save([model2, model3])
+      expect(Dynamini::Base.find('123')).to_not be_nil
+      expect(Dynamini::Base.find('456')).to_not be_nil
+    end
+  end
+
+  describe '.batch_find' do
+    before do
+      model.save
+    end
+    context 'when requesting 0 items' do
+      it 'should return an empty array' do
+        expect(Dynamini::Base.batch_find).to eq []
+      end
+    end
+    context 'when requesting 2 items' do
+      it 'should return a 2-length array containing each item' do
+        Dynamini::Base.create(id: '4321')
+        objects = Dynamini::Base.batch_find(['abcd1234', '4321'])
+        expect(objects.length).to eq 2
+        expect(objects.first.id).to eq model.id
+        expect(objects.last.id).to eq '4321'
+      end
+    end
+    context 'when requesting too many items' do
+      it 'should raise an error' do
+        a = []
+        150.times { a << 'foo' }
+        expect { Dynamini::Base.batch_find(a) }.to raise_error StandardError
+      end
+    end
+  end
+
+end
+

data/spec/dynamini/test_client_spec.rb

@@ -0,0 +1,187 @@
+require 'spec_helper'
+
+describe Dynamini::TestClient do
+
+  let(:table_name) { 'table' }
+
+  describe '#update_item' do
+
+    context 'with hash key ONLY' do
+      it 'should be able to save a record' do
+        test_client = Dynamini::TestClient.new(:hash_key_name)
+        test_client.update_item(table_name: table_name, key: {hash_key_name: 'hash_key_value'}, attribute_updates: {abc: {value: 'abc', action: 'PUT'}})
+        expect(test_client.data[table_name]['hash_key_value']).to eq(abc: 'abc', :hash_key_name => "hash_key_value")
+      end
+
+      it 'should be able to update an existing record' do
+        test_client = Dynamini::TestClient.new(:hash_key_name)
+        test_client.update_item(table_name: table_name, key: {hash_key_name: 'hash_key_value'}, attribute_updates: {abc: {value: 'abc', action: 'PUT'}})
+        test_client.update_item(table_name: table_name, key: {hash_key_name: 'hash_key_value'}, attribute_updates: {abc: {value: 'def', action: 'PUT'}})
+        expect(test_client.data[table_name]['hash_key_value']).to eq(abc: 'def', :hash_key_name => "hash_key_value")
+      end
+
+    end
+
+    context 'with Hash key and range key' do
+      it 'should be able to save a record' do
+        test_client = Dynamini::TestClient.new(:hash_key_name, :range_key_name)
+        test_client.update_item(table_name: table_name, key: {hash_key_name: 'hash_key_value', range_key_name: 'range_key_value'}, attribute_updates: {abc: {value: 'abc', action: 'PUT'}})
+        expect(test_client.data[table_name]['hash_key_value']['range_key_value']).to eq({abc: 'abc', :hash_key_name => "hash_key_value", :range_key_name => "range_key_value"})
+      end
+
+      it 'should update an existing record' do
+        test_client = Dynamini::TestClient.new(:hash_key_name, :range_key_name)
+        test_client.update_item(table_name: table_name, key: {hash_key_name: 'hash_key_value', range_key_name: 'range_key_value'}, attribute_updates: {abc: {value: 'abc', action: 'PUT'}})
+
+        test_client.update_item(table_name: table_name, key: {hash_key_name: 'hash_key_value', range_key_name: 'range_key_value'}, attribute_updates: {abc: {value: 'def', action: 'PUT'}})
+
+        expect(test_client.data[table_name]['hash_key_value']['range_key_value']).to eq({abc: 'def', :hash_key_name => "hash_key_value", :range_key_name => "range_key_value"})
+      end
+
+    end
+
+    context 'invalid args' do
+      it 'should not try to add invalid args for a hash key only table' do
+        test_client = Dynamini::TestClient.new(:hash_key_name)
+        test_client.update_item(table_name: table_name, key: {}, attribute_updates: {abc: {value: 'def', action: 'PUT'}})
+
+        expect(test_client.data[table_name]).to eq({})
+      end
+
+      it 'should not try to add invalid args for a hash key and range key table' do
+        test_client = Dynamini::TestClient.new(:hash_key_name, :range_key_name)
+        test_client.update_item(table_name: table_name, key: {}, attribute_updates: {abc: {value: 'def', action: 'PUT'}})
+
+        expect(test_client.data[table_name]).to eq({})
+      end
+    end
+  end
+
+  describe '#get_item' do
+    context 'table with just a hash key' do
+      let(:test_client) { Dynamini::TestClient.new(:hash_key_name) }
+
+      it 'should return the item identified by the hash_key' do
+        test_client.update_item(table_name: table_name, key: {test_client.hash_key_attr => "abc"}, attribute_updates: {test_attr: {value: 'test', action: 'PUT'}})
+
+        expect(test_client.get_item(table_name: table_name, key: {test_client.hash_key_attr => "abc"}).item[:test_attr]).to eq('test')
+      end
+
+      it 'should returns nil if the item does not exist' do
+        expect(test_client.get_item(table_name: table_name, key: {test_client.hash_key_attr => "abc"}).item).to eq(nil)
+      end
+
+      it 'should ignore any extra keys in the args' do
+        test_client.update_item(table_name: table_name, key: {test_client.hash_key_attr => "abc"}, attribute_updates: {test_attr: {value: 'test', action: 'PUT'}})
+
+        expect(test_client.get_item(table_name: table_name, key: {test_client.hash_key_attr => "abc", :extra_key => "extra"}).item[:test_attr]).to eq('test')
+      end
+    end
+
+    context 'table with hash and range key' do
+      let(:test_client) { Dynamini::TestClient.new(:hash_key_name, :range_key_name) }
+
+      it 'should return the item identified by the hash_key' do
+        test_client.update_item(table_name: table_name, key: {test_client.hash_key_attr => "abc", test_client.range_key_attr => 'def'}, attribute_updates: {test_attr: {value: 'test_range', action: 'PUT'}})
+
+        expect(test_client.get_item(table_name: table_name, key: {test_client.hash_key_attr => "abc", test_client.range_key_attr => 'def'}).item[:test_attr]).to eq('test_range')
+      end
+
+      it 'should returns nil if the item does not exist' do
+        expect(test_client.get_item(table_name: table_name, key: {test_client.hash_key_attr => "abc", test_client.range_key_attr => 'def'}).item).to eq(nil)
+      end
+
+      it 'should return nil when only supplied range key' do
+        expect(test_client.get_item(table_name: table_name, key: {test_client.range_key_attr => 'def'}).item).to eq(nil)
+      end
+    end
+  end
+
+  describe '#query' do
+
+    let(:test_client) { Dynamini::TestClient.new(:hash_key_field, :range_key_field) }
+
+    before do
+      4.times do |i|
+        test_client.update_item(table_name: table_name, key: {hash_key_field: 'foo', range_key_field: i + 1}, attribute_updates: {abc: {value: 'abc', action: 'PUT'}})
+      end
+    end
+    context 'with LE operator' do
+      it 'should return all items with range key less than or equal to the provided value' do
+        response = test_client.query(
+            table_name: table_name,
+            key_condition_expression: "hash_key_field = :h AND user_id <= :e",
+            expression_attribute_values: {
+                ":h" => 'foo',
+                ":e" => 2
+            }
+        )
+        expect(response.items.length).to eq(2)
+        expect(response.items.first[:range_key_field]).to eq(1)
+        expect(response.items.last[:range_key_field]).to eq(2)
+      end
+    end
+    context 'with GE operator' do
+      it 'should return all items with range key greater than or equal to the provided value' do
+        response = test_client.query(
+            table_name: table_name,
+            key_condition_expression: "hash_key_field = :h AND user_id >= :s",
+            expression_attribute_values: {
+                ":h" => 'foo',
+                ":s" => 2
+            }
+        )
+        expect(response.items.length).to eq(3)
+        expect(response.items.first[:range_key_field]).to eq(2)
+        expect(response.items.last[:range_key_field]).to eq(4)
+      end
+    end
+    context 'with BETWEEN operator' do
+      it 'should return all items with range key between the provided values' do
+        response = test_client.query(
+            table_name: table_name,
+            key_condition_expression: "hash_key_field = :h AND user_id BETWEEN :s AND :e",
+            expression_attribute_values: {
+                ":h" => 'foo',
+                ":s" => 2,
+                ":e" => 3
+            }
+        )
+        expect(response.items.length).to eq(2)
+        expect(response.items.first[:range_key_field]).to eq(2)
+        expect(response.items.last[:range_key_field]).to eq(3)
+      end
+    end
+    context 'with no operator' do
+      it 'should return all items with range key between the provided values' do
+        response = test_client.query(
+            table_name: table_name,
+            key_condition_expression: "hash_key_field = :h",
+            expression_attribute_values: {
+                ":h" => 'foo'
+            }
+        )
+        expect(response.items.length).to eq(4)
+        expect(response.items.first[:range_key_field]).to eq(1)
+        expect(response.items.last[:range_key_field]).to eq(4)
+      end
+    end
+  end
+
+  describe '#batch_write_item' do
+    let(:test_client) { Dynamini::TestClient.new(:id) }
+
+    it 'should store all items in the table correctly' do
+      item1 = {'foo' => 'bar', 'id' => 1}
+      item2 = {'foo' => 'bar', 'id' => 2}
+      put_requests = [{put_request: {item: item1}},
+                      {put_request: {item: item2}}]
+
+      request_options = {request_items: {table_name => put_requests}}
+
+      test_client.batch_write_item(request_options)
+      expect(test_client.data[table_name][1]).to eq(item1)
+      expect(test_client.data[table_name][2]).to eq(item2)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+require 'bundler/setup'
+Bundler.setup
+
+require 'aws-sdk'
+require 'pry'
+require 'fuubar'
+require 'dynamini'
+
+RSpec.configure do |config|
+  # For running just wanted tests in guard
+  config.filter_run :focus => true
+  config.run_all_when_everything_filtered = true
+  config.before(:all) { Dynamini::Base.in_memory = true }
+  config.after(:each) { Dynamini::Base.client.reset }
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dynamini
 version: !ruby/object:Gem::Version
-  version: 1.8.2
+  version: 1.9.1
 platform: ruby
 authors:
 - Greg Ward
@@ -130,10 +130,26 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- Gemfile.lock
+- Guardfile
+- LICENSE
+- README.md
+- Rakefile
+- dynamini.gemspec
+- lib/.DS_Store
 - lib/dynamini.rb
 - lib/dynamini/base.rb
+- lib/dynamini/batch_operations.rb
 - lib/dynamini/configuration.rb
 - lib/dynamini/test_client.rb
+- spec/dynamini/base_spec.rb
+- spec/dynamini/batch_operations_spec.rb
+- spec/dynamini/test_client_spec.rb
+- spec/spec_helper.rb
 homepage: https://github.com/47colborne/dynamini
 licenses:
 - MIT
@@ -154,8 +170,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: DynamoDB interface
-test_files: []
+test_files:
+- spec/dynamini/base_spec.rb
+- spec/dynamini/batch_operations_spec.rb
+- spec/dynamini/test_client_spec.rb
+- spec/spec_helper.rb