lotus-dynamodb 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8b6e1c051b76f678f3694e0e0cb8f70871a3dbce
-  data.tar.gz: d7e164efdaa51814a36a7c803c959ad9c21c3b71
+  metadata.gz: 4afda395af46d537deed3ac0619746f3c693f53b
+  data.tar.gz: f4c3028928436d9c3d035e48a8ec7a17dab6137c
 SHA512:
-  metadata.gz: 5a326db3a7714f0573be6b4ebadd1dc2ad5dc7fea5303be5c61c09bcfdd37435084215ff60837156f9c4481c044f24af96b8b65d504a9b4e25a3f8f5f6069771
-  data.tar.gz: d1a6068ecc5898cf70ce48ed8b751498ff405fbca62f0a60990f36197d40fe4489e21c0011fff4bd04f215f7642c20763219b624966acaf2578f62be566c308a
+  metadata.gz: f35e5aa974d0cb68835e04f6fc6e4b7e77d87f8239ef13a84f5acdf23e6c927d2b1e468d67bf19f82854755cc94e119073b13fb4e16bd0f493668a8eb08395e8
+  data.tar.gz: 0d2fea387a98192508cda33c444500374ba1cfe4ff5a2b5b157ecaf1d75e84c4519ec8e8002dffbc84c75a0de6311c0a514f439996f7971173881fcdd3ffdee9

data/CHANGELOG.md

@@ -0,0 +1,14 @@
+v0.1.1
+------
+
+* Bump lotus-model dependency to 0.1.1
+* Switch Lotus::Utils::Kernel.* to Lotus::Model::Mapping::Coercions.*
+* Improve Query#all to return real all entries
+* Improve Query#count to return real count
+* Improve Query#each to iterate over batches of entries
+* Improve DynamodbAdapter#clear to clear even large tables
+
+v0.1.0
+------
+
+* Initial version

data/Gemfile

@@ -10,7 +10,11 @@ gem 'simplecov', require: false
 gem 'coveralls', require: false
 
 # Benchmarking
-gem 'benchmark-ips', '~> 1.2'
+gem 'benchmark-ips', '~> 2.0'
 
 # Fixes are not merged yet
 gem 'fake_dynamo', github: 'krasnoukhov/fake_dynamo'
+
+# Upstream
+gem 'lotus-utils', github: 'lotus/utils'
+gem 'lotus-model', github: 'lotus/model'

data/README.md

@@ -16,12 +16,12 @@ It is built using ```AWS::DynamoDB::Client```, which is a part of ```aws-sdk```
 [![Build Status](https://secure.travis-ci.org/krasnoukhov/lotus-dynamodb.svg?branch=master)](http://travis-ci.org/krasnoukhov/lotus-dynamodb?branch=master)
 [![Coverage Status](https://img.shields.io/coveralls/krasnoukhov/lotus-dynamodb.svg)](https://coveralls.io/r/krasnoukhov/lotus-dynamodb?branch=master)
 [![Code Climate](https://img.shields.io/codeclimate/github/krasnoukhov/lotus-dynamodb.svg)](https://codeclimate.com/github/krasnoukhov/lotus-dynamodb)
-[![Inline docs](http://inch-pages.github.io/github/krasnoukhov/lotus-dynamodb.svg)](http://inch-pages.github.io/github/krasnoukhov/lotus-dynamodb)
+[![Inline docs](http://inch-ci.org/github/krasnoukhov/lotus-dynamodb.svg)](http://inch-ci.org/github/krasnoukhov/lotus-dynamodb)
 [![Dependencies](https://gemnasium.com/krasnoukhov/lotus-dynamodb.svg)](https://gemnasium.com/krasnoukhov/lotus-dynamodb)
 
 ## Links
 
-* API Doc: [http://rdoc.info/github/krasnoukhov/lotus-dynamodb](http://rdoc.info/github/krasnoukhov/lotus-dynamodb)
+* API Doc: [http://rdoc.info/gems/lotus-dynamodb](http://rdoc.info/gems/lotus-dynamodb)
 * Bugs/Issues: [https://github.com/krasnoukhov/lotus-dynamodb/issues](https://github.com/krasnoukhov/lotus-dynamodb/issues)
 
 ## Installation
@@ -73,31 +73,31 @@ Following methods are not supported since it's incompatible with DynamoDB:
 
 Generic methods supported by DynamoDB adapter:
 
-* [all](http://rdoc.info/github/krasnoukhov/lotus-dynamodb/Lotus/Model/Adapters/Dynamodb/Query#all-instance_method)
-* [where](http://rdoc.info/github/krasnoukhov/lotus-dynamodb/Lotus/Model/Adapters/Dynamodb/Query#where-instance_method) (aliases: ```eq```, ```in```, ```between```)
-* [or](http://rdoc.info/github/krasnoukhov/lotus-dynamodb/Lotus/Model/Adapters/Dynamodb/Query#or-instance_method)
-* [exclude](http://rdoc.info/github/krasnoukhov/lotus-dynamodb/Lotus/Model/Adapters/Dynamodb/Query#exclude-instance_method) (aliases: ```not```, ```ne```)
-* [select](http://rdoc.info/github/krasnoukhov/lotus-dynamodb/Lotus/Model/Adapters/Dynamodb/Query#select-instance_method)
-* [order](http://rdoc.info/github/krasnoukhov/lotus-dynamodb/Lotus/Model/Adapters/Dynamodb/Query#order-instance_method) (alias: ```asc```)
-* [desc](http://rdoc.info/github/krasnoukhov/lotus-dynamodb/Lotus/Model/Adapters/Dynamodb/Query#desc-instance_method)
-* [limit](http://rdoc.info/github/krasnoukhov/lotus-dynamodb/Lotus/Model/Adapters/Dynamodb/Query#limit-instance_method)
-* [exists?](http://rdoc.info/github/krasnoukhov/lotus-dynamodb/Lotus/Model/Adapters/Dynamodb/Query#exist%3F-instance_method) (alias: ```exist?```)
-* [count](http://rdoc.info/github/krasnoukhov/lotus-dynamodb/Lotus/Model/Adapters/Dynamodb/Query#count-instance_method)
+* [all](http://rdoc.info/gems/lotus-dynamodb/Lotus/Model/Adapters/Dynamodb/Query#all-instance_method)
+* [where](http://rdoc.info/gems/lotus-dynamodb/Lotus/Model/Adapters/Dynamodb/Query#where-instance_method) (aliases: ```eq```, ```in```, ```between```)
+* [or](http://rdoc.info/gems/lotus-dynamodb/Lotus/Model/Adapters/Dynamodb/Query#or-instance_method)
+* [exclude](http://rdoc.info/gems/lotus-dynamodb/Lotus/Model/Adapters/Dynamodb/Query#exclude-instance_method) (aliases: ```not```, ```ne```)
+* [select](http://rdoc.info/gems/lotus-dynamodb/Lotus/Model/Adapters/Dynamodb/Query#select-instance_method)
+* [order](http://rdoc.info/gems/lotus-dynamodb/Lotus/Model/Adapters/Dynamodb/Query#order-instance_method) (alias: ```asc```)
+* [desc](http://rdoc.info/gems/lotus-dynamodb/Lotus/Model/Adapters/Dynamodb/Query#desc-instance_method)
+* [limit](http://rdoc.info/gems/lotus-dynamodb/Lotus/Model/Adapters/Dynamodb/Query#limit-instance_method)
+* [exists?](http://rdoc.info/gems/lotus-dynamodb/Lotus/Model/Adapters/Dynamodb/Query#exist%3F-instance_method) (alias: ```exist?```)
+* [count](http://rdoc.info/gems/lotus-dynamodb/Lotus/Model/Adapters/Dynamodb/Query#count-instance_method)
 
 DynamoDB-specific methods:
 
-* [query](http://rdoc.info/github/krasnoukhov/lotus-dynamodb/Lotus/Model/Adapters/Dynamodb/Query#query-instance_method) – ensure ```query``` operation is performed instead of ```scan```
-* [consistent](http://rdoc.info/github/krasnoukhov/lotus-dynamodb/Lotus/Model/Adapters/Dynamodb/Query#consistent-instance_method) – require consistent read for query
-* [index](http://rdoc.info/github/krasnoukhov/lotus-dynamodb/Lotus/Model/Adapters/Dynamodb/Query#index-instance_method) – perform query on specific index
-* [le](http://rdoc.info/github/krasnoukhov/lotus-dynamodb/Lotus/Model/Adapters/Dynamodb/Query#le-instance_method)
-* [lt](http://rdoc.info/github/krasnoukhov/lotus-dynamodb/Lotus/Model/Adapters/Dynamodb/Query#lt-instance_method)
-* [ge](http://rdoc.info/github/krasnoukhov/lotus-dynamodb/Lotus/Model/Adapters/Dynamodb/Query#ge-instance_method)
-* [gt](http://rdoc.info/github/krasnoukhov/lotus-dynamodb/Lotus/Model/Adapters/Dynamodb/Query#gt-instance_method)
-* [contains](http://rdoc.info/github/krasnoukhov/lotus-dynamodb/Lotus/Model/Adapters/Dynamodb/Query#contains-instance_method)
-* [not_contains](http://rdoc.info/github/krasnoukhov/lotus-dynamodb/Lotus/Model/Adapters/Dynamodb/Query#not_contains-instance_method)
-* [begins_with](http://rdoc.info/github/krasnoukhov/lotus-dynamodb/Lotus/Model/Adapters/Dynamodb/Query#begins_with-instance_method)
-* [null](http://rdoc.info/github/krasnoukhov/lotus-dynamodb/Lotus/Model/Adapters/Dynamodb/Query#null-instance_method)
-* [not_null](http://rdoc.info/github/krasnoukhov/lotus-dynamodb/Lotus/Model/Adapters/Dynamodb/Query#not_null-instance_method)
+* [query](http://rdoc.info/gems/lotus-dynamodb/Lotus/Model/Adapters/Dynamodb/Query#query-instance_method) – ensure ```query``` operation is performed instead of ```scan```
+* [consistent](http://rdoc.info/gems/lotus-dynamodb/Lotus/Model/Adapters/Dynamodb/Query#consistent-instance_method) – require consistent read for query
+* [index](http://rdoc.info/gems/lotus-dynamodb/Lotus/Model/Adapters/Dynamodb/Query#index-instance_method) – perform query on specific index
+* [le](http://rdoc.info/gems/lotus-dynamodb/Lotus/Model/Adapters/Dynamodb/Query#le-instance_method)
+* [lt](http://rdoc.info/gems/lotus-dynamodb/Lotus/Model/Adapters/Dynamodb/Query#lt-instance_method)
+* [ge](http://rdoc.info/gems/lotus-dynamodb/Lotus/Model/Adapters/Dynamodb/Query#ge-instance_method)
+* [gt](http://rdoc.info/gems/lotus-dynamodb/Lotus/Model/Adapters/Dynamodb/Query#gt-instance_method)
+* [contains](http://rdoc.info/gems/lotus-dynamodb/Lotus/Model/Adapters/Dynamodb/Query#contains-instance_method)
+* [not_contains](http://rdoc.info/gems/lotus-dynamodb/Lotus/Model/Adapters/Dynamodb/Query#not_contains-instance_method)
+* [begins_with](http://rdoc.info/gems/lotus-dynamodb/Lotus/Model/Adapters/Dynamodb/Query#begins_with-instance_method)
+* [null](http://rdoc.info/gems/lotus-dynamodb/Lotus/Model/Adapters/Dynamodb/Query#null-instance_method)
+* [not_null](http://rdoc.info/gems/lotus-dynamodb/Lotus/Model/Adapters/Dynamodb/Query#not_null-instance_method)
 
 ### Example
 

data/benchmarks/coercer.rb

@@ -18,34 +18,27 @@ class Project
     :attr5, :attr6, :attr7, :attr8, :attr9
 end
 
-default_collection = Lotus::Model::Mapping::Collection.new(:projects, Lotus::Model::Mapping::Coercer) do
-  entity Project
+spec = ->(c) {
+  c.entity Project
+
+  c.attribute :id,    Integer
+  c.attribute :attr1, String
+  c.attribute :attr2, String
+  c.attribute :attr3, String
+  c.attribute :attr4, String
+  c.attribute :attr5, String
+  c.attribute :attr6, String
+  c.attribute :attr7, String
+  c.attribute :attr8, String
+  c.attribute :attr9, String
+}
 
-  attribute :id,    Integer
-  attribute :attr1, String
-  attribute :attr2, String
-  attribute :attr3, String
-  attribute :attr4, String
-  attribute :attr5, String
-  attribute :attr6, String
-  attribute :attr7, String
-  attribute :attr8, String
-  attribute :attr9, String
+default_collection = Lotus::Model::Mapping::Collection.new(:projects, Lotus::Model::Mapping::Coercer) do
+  spec.call(self)
 end
 
 dynamodb_collection = Lotus::Model::Mapping::Collection.new(:projects, Lotus::Model::Adapters::Dynamodb::Coercer) do
-  entity Project
-
-  attribute :id,    Integer
-  attribute :attr1, String
-  attribute :attr2, String
-  attribute :attr3, String
-  attribute :attr4, String
-  attribute :attr5, String
-  attribute :attr6, String
-  attribute :attr7, String
-  attribute :attr8, String
-  attribute :attr9, String
+  spec.call(self)
 end
 
 record = Hash[id: '23', attr1: 'attr1', attr2: 'attr2',

data/lib/lotus/dynamodb/version.rb

@@ -3,6 +3,6 @@ module Lotus
     # Defines the version
     #
     # @since 0.1.0
-    VERSION = '0.1.0'
+    VERSION = '0.1.1'
   end
 end

data/lib/lotus/model/adapters/dynamodb/coercer.rb

@@ -1,4 +1,4 @@
-require 'lotus/utils/kernel'
+require 'lotus/model/mapping/coercions'
 require 'multi_json'
 
 module Lotus
@@ -126,6 +126,16 @@ module Lotus
           # @api private
           # @since 0.1.0
           def _compile!
+            _compile_skipped!
+            _compile_record!
+            _compile_serialization!
+          end
+
+          # Compile skipped klasses methods.
+          #
+          # @api private
+          # @since 0.1.1
+          def _compile_skipped!
             instance_eval(SKIPPED_KLASSES.map do |klass|
               %{
               def from_#{_method_name(klass)}(value)
@@ -137,19 +147,13 @@ module Lotus
               end
               }
             end.join("\n"))
+          end
 
-            code = @collection.attributes.map do |_,(klass,mapped)|
-              %{
-              def deserialize_#{ mapped }(value)
-                #{kernel_wrap(klass) { "from_#{_method_name(klass)}(value)" }}
-              end
-
-              def serialize_#{ mapped }(value)
-                from_#{_method_name(klass)}(value)
-              end
-              }
-            end.join("\n")
-
+          # Compile record methods.
+          #
+          # @api private
+          # @since 0.1.1
+          def _compile_record!
             instance_eval %{
               def to_record(entity)
                 if entity.id
@@ -161,23 +165,39 @@ module Lotus
 
               def from_record(record)
                 #{ @collection.entity }.new(
-                  Hash[*[#{ @collection.attributes.map{|name,(klass,mapped)| ":#{name},#{kernel_wrap(klass) { "to_#{_method_name(klass)}(record[:#{mapped}])" }}"}.join(',') }]]
+                  Hash[*[#{ @collection.attributes.map{|name,(klass,mapped)| ":#{name},#{coercions_wrap(klass) { "to_#{_method_name(klass)}(record[:#{mapped}])" }}"}.join(',') }]]
                 )
               end
-
-              #{ code }
             }
           end
 
-          # Wraps string in Lotus::Utils::Kernel call if needed.
+          # Compile deserialise/serialize methods.
+          #
+          # @api private
+          # @since 0.1.1
+          def _compile_serialization!
+            instance_eval(@collection.attributes.map do |_,(klass,mapped)|
+              %{
+              def deserialize_#{ mapped }(value)
+                #{coercions_wrap(klass) { "from_#{_method_name(klass)}(value)" }}
+              end
+
+              def serialize_#{ mapped }(value)
+                from_#{_method_name(klass)}(value)
+              end
+              }
+            end.join("\n"))
+          end
+
+          # Wraps string in Lotus::Model::Mapping::Coercions call if needed.
           #
           # @api private
           # @since 0.1.0
-          def kernel_wrap(klass)
+          def coercions_wrap(klass)
             if klass.to_s.include?("::")
               yield
             else
-              "Lotus::Utils::Kernel.#{klass}(#{yield})"
+              "Lotus::Model::Mapping::Coercions.#{klass}(#{yield})"
             end
           end
 

data/lib/lotus/model/adapters/dynamodb/collection.rb

@@ -18,10 +18,11 @@ module Lotus
           # @api private
           # @since 0.1.0
           class Response
-            attr_accessor :count, :entities
+            attr_accessor :count, :entities, :last_evaluated_key
 
-            def initialize(count, entities = nil)
-              @count, @entities = count, entities
+            def initialize
+              @count = 0
+              @entities = []
             end
           end
 
@@ -136,6 +137,7 @@ module Lotus
           # Performs DynamoDB query operation.
           #
           # @param options [Hash] AWS::DynamoDB::Client options
+          # @param previous_response [Response] deserialized response from a previous operation
           #
           # @see http://docs.aws.amazon.com/AWSRubySDK/latest/AWS/DynamoDB/Client/V20120810.html#query-instance_method
           #
@@ -143,14 +145,15 @@ module Lotus
           #
           # @api private
           # @since 0.1.0
-          def query(options = {})
+          def query(options = {}, previous_response = nil)
             response = @client.query(options.merge(table_name: name))
-            deserialize_response(response)
+            deserialize_response(response, previous_response)
           end
 
           # Performs DynamoDB scan operation.
           #
           # @param options [Hash] AWS::DynamoDB::Client options
+          # @param previous_response [Response] deserialized response from a previous operation
           #
           # @see http://docs.aws.amazon.com/AWSRubySDK/latest/AWS/DynamoDB/Client/V20120810.html#scan-instance_method
           #
@@ -158,9 +161,9 @@ module Lotus
           #
           # @api private
           # @since 0.1.0
-          def scan(options = {})
+          def scan(options = {}, previous_response = nil)
             response = @client.scan(options.merge(table_name: name))
-            deserialize_response(response)
+            deserialize_response(response, previous_response)
           end
 
           # Fetches DynamoDB table schema.
@@ -286,19 +289,22 @@ module Lotus
           # Deserialize DynamoDB scan/query response.
           #
           # @param response [Hash] the serialized response
+          # @param previous_response [Response] deserialized response from a previous operation
           #
-          # @return [Hash] the deserialized response
+          # @return [Response] the deserialized response
           #
           # @api private
           # @since 0.1.0
-          def deserialize_response(response)
-            result = Response.new(response[:count])
+          def deserialize_response(response, previous_response = nil)
+            current_response = previous_response || Response.new
+            current_response.count += response[:count]
 
-            result.entities = response[:member].map do |item|
+            current_response.entities += response[:member].map do |item|
               deserialize_item(item)
             end if response[:member]
 
-            result
+            current_response.last_evaluated_key = response[:last_evaluated_key]
+            current_response
           end
 
           # Deserialize item from DynamoDB response.

data/lib/lotus/model/adapters/dynamodb/command.rb

@@ -84,19 +84,6 @@ module Lotus
             ).first
           end
 
-          # Deletes all the records from the table.
-          #
-          # @see Lotus::Model::Adapters::Dynamodb::Collection#scan
-          # @see Lotus::Model::Mapping::Collection
-          #
-          # @api private
-          # @since 0.1.0
-          def clear
-            @collection.deserialize(@dataset.scan.entities).each do |entity|
-              delete(entity)
-            end
-          end
-
           private
           # Serialize the given entity before to persist in the database.
           #

data/lib/lotus/model/adapters/dynamodb/query.rb

@@ -41,7 +41,7 @@ module Lotus
           include Enumerable
           extend  Forwardable
 
-          def_delegators :all, :each, :to_s, :empty?
+          def_delegators :all, :to_s, :empty?
 
           # @attr_reader operation [Symbol] operation to perform
           #
@@ -81,7 +81,36 @@ module Lotus
           #
           # @since 0.1.0
           def all
-            @collection.deserialize(run.entities)
+            response = run
+            while !@options[:limit] && response.last_evaluated_key
+              @options[:exclusive_start_key] = response.last_evaluated_key
+              response = run(response)
+            end
+
+            @collection.deserialize(response.entities)
+          end
+
+          # Iterates over fetched records.
+          #
+          # @return [Integer] total count of records
+          #
+          # @since 0.1.1
+          def each
+            response = run
+            entities = @collection.deserialize(response.entities)
+            entities.each { |x| yield(x) }
+
+            while !@options[:limit] && response.last_evaluated_key
+              response.entities = []
+
+              @options[:exclusive_start_key] = response.last_evaluated_key
+              response = run(response)
+
+              entities = @collection.deserialize(response.entities)
+              entities.each { |x| yield(x) }
+            end
+
+            response.count
           end
 
           # Set operation to be query instead of scan.
@@ -443,7 +472,14 @@ module Lotus
             @options[:select] = "COUNT"
             @options.delete(:attributes_to_get)
 
-            run.count
+            response = run
+
+            while !@options[:limit] && response.last_evaluated_key
+              @options[:exclusive_start_key] = response.last_evaluated_key
+              response = run(response)
+            end
+
+            response.count
           end
 
           # This method is not implemented.
@@ -545,12 +581,14 @@ module Lotus
 
           # Apply all the options and return a filtered collection.
           #
+          # @param previous_response [Response] deserialized response from a previous operation
+          #
           # @return [Array]
           #
           # @api private
           # @since 0.1.0
-          def run
-            @dataset.public_send(operation, @options)
+          def run(previous_response = nil)
+            @dataset.public_send(operation, @options, previous_response)
           end
         end
       end

data/lib/lotus/model/adapters/dynamodb_adapter.rb

@@ -88,7 +88,8 @@ module Lotus
         # @api private
         # @since 0.1.0
         def clear(collection)
-          command(collection).clear
+          blk = Proc.new {}
+          query(collection, blk).each { |entity| delete(collection, entity) }
         end
 
         # Returns an unique record from the given collection, with the given

data/lotus-dynamodb.gemspec

@@ -17,7 +17,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
-  spec.add_runtime_dependency 'lotus-model', '~> 0.1'
+  spec.add_runtime_dependency 'lotus-model', '~> 0.1', '>= 0.1.1'
   spec.add_runtime_dependency 'aws-sdk',     '~> 1.0'
   spec.add_runtime_dependency 'multi_json',  '~> 1.10'
 

data/test/fixtures.rb

@@ -10,8 +10,8 @@ begin
       { attribute_name: "id", key_type: "HASH" },
     ],
     provisioned_throughput: {
-      read_capacity_units: 10,
-      write_capacity_units: 10,
+      read_capacity_units: 50,
+      write_capacity_units: 50,
     },
   )
 
@@ -26,8 +26,8 @@ begin
       { attribute_name: "created_at", key_type: "RANGE" },
     ],
     provisioned_throughput: {
-      read_capacity_units: 10,
-      write_capacity_units: 10,
+      read_capacity_units: 50,
+      write_capacity_units: 50,
     },
   )
 
@@ -62,13 +62,13 @@ begin
         projection_type: "ALL",
       },
       provisioned_throughput: {
-        read_capacity_units: 10,
-        write_capacity_units: 10,
+        read_capacity_units: 50,
+        write_capacity_units: 50,
       },
     }],
     provisioned_throughput: {
-      read_capacity_units: 10,
-      write_capacity_units: 10,
+      read_capacity_units: 50,
+      write_capacity_units: 50,
     },
   )
 rescue AWS::DynamoDB::Errors::ResourceInUseException

data/test/model/adapters/dynamodb/query_test.rb

@@ -2,7 +2,7 @@ require 'test_helper'
 
 describe Lotus::Model::Adapters::Dynamodb::Query do
   before do
-    MockResponse = Struct.new(:entities)
+    MockResponse = Struct.new(:entities, :last_evaluated_key)
 
     class MockDataset
       include AWS::DynamoDB::Types
@@ -15,11 +15,11 @@ describe Lotus::Model::Adapters::Dynamodb::Query do
         @records = MockResponse.new(entities)
       end
 
-      def query(options = {})
+      def query(options = {}, previous_response = nil)
         records
       end
 
-      def scan(options = {})
+      def scan(options = {}, previous_response = nil)
         records
       end
 

data/test/model/adapters/dynamodb_adapter_test.rb

@@ -59,18 +59,6 @@ describe Lotus::Model::Adapters::DynamodbAdapter do
 
   let(:collection) { :test_users }
 
-  describe '#first' do
-    it 'raises an error' do
-      -> { @adapter.first(collection) }.must_raise NotImplementedError
-    end
-  end
-
-  describe '#last' do
-    it 'raises an error' do
-      -> { @adapter.last(collection) }.must_raise NotImplementedError
-    end
-  end
-
   describe 'multiple collections' do
     it 'create records' do
       user   = TestUser.new
@@ -87,6 +75,18 @@ describe Lotus::Model::Adapters::DynamodbAdapter do
     end
   end
 
+  describe '#first' do
+    it 'raises an error' do
+      -> { @adapter.first(collection) }.must_raise NotImplementedError
+    end
+  end
+
+  describe '#last' do
+    it 'raises an error' do
+      -> { @adapter.last(collection) }.must_raise NotImplementedError
+    end
+  end
+
   describe '#persist' do
     describe 'when the given entity is not persisted' do
       let(:entity) { TestUser.new }
@@ -179,6 +179,64 @@ describe Lotus::Model::Adapters::DynamodbAdapter do
         @adapter.all(collection).must_equal [entity]
       end
     end
+
+    describe 'when large records set is persisted' do
+      before do
+        entities.each do |entity|
+          @adapter.create(collection, entity)
+        end
+      end
+
+      let(:entities) { 25.times.map { TestUser.new(name: 'A'*50_000) } }
+
+      it 'returns all of them' do
+        @adapter.all(collection).count.must_equal entities.count
+      end
+    end
+  end
+
+  describe '#each' do
+    describe 'when no records are persisted' do
+      it 'returns an empty collection' do
+        query = Proc.new {}
+        counter = 0
+        @adapter.query(collection, &query).each { |x| counter += 1 }
+        counter.must_equal 0
+      end
+    end
+
+    describe 'when some records are persisted' do
+      before do
+        @adapter.create(collection, entity)
+      end
+
+      let(:entity) { TestUser.new }
+
+      it 'returns all of them' do
+        query = Proc.new {}
+        counter = 0
+        @adapter.query(collection, &query).each { |x| counter += 1 }
+        counter.must_equal 1
+      end
+    end
+
+    describe 'when large records set is persisted' do
+      before do
+        entities.each do |entity|
+          @adapter.create(collection, entity)
+        end
+      end
+
+      let(:entities) { 25.times.map { TestUser.new(name: 'A'*50_000) } }
+
+      it 'returns all of them' do
+        query = Proc.new {}
+        counter = 0
+        count = @adapter.query(collection, &query).each { |x| counter += 1 }
+        counter.must_equal entities.count
+        count.must_equal entities.count
+      end
+    end
   end
 
   describe '#find' do
@@ -866,6 +924,33 @@ describe Lotus::Model::Adapters::DynamodbAdapter do
           result.must_equal 2
         end
       end
+
+      describe 'with large records set' do
+        before do
+          purchases.each do |entity|
+            @adapter.create(collection, entity)
+          end
+        end
+
+        let(:purchases) do
+          25.times.map do |i|
+            TestPurchase.new(
+              region: 'europe',
+              content: ('A'..'Z').to_a[i]*50_000,
+              created_at: Time.new,
+            )
+          end
+        end
+
+        it 'returns all of them' do
+          query = Proc.new {
+            where(region: 'europe')
+          }
+
+          result = @adapter.query(collection, &query).count
+          result.must_equal purchases.count
+        end
+      end
     end
 
     describe 'consistent' do

data/test/test_helper.rb

@@ -22,6 +22,8 @@ require 'lotus-dynamodb'
 
 if ENV['AWS']
   AWS.config(
+    # logger: Logger.new($stdout),
+    # log_level: :debug,
     access_key_id: ENV['AWS_KEY'],
     secret_access_key: ENV['AWS_SECRET'],
   )

data/test/version_test.rb

@@ -2,6 +2,6 @@ require 'test_helper'
 
 describe Lotus::Dynamodb::VERSION do
   it 'returns current version' do
-    Lotus::Dynamodb::VERSION.must_equal '0.1.0'
+    Lotus::Dynamodb::VERSION.must_equal '0.1.1'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lotus-dynamodb
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Dmitry Krasnoukhov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-20 00:00:00.000000000 Z
+date: 2014-06-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lotus-model
@@ -17,6 +17,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -24,6 +27,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.1
 - !ruby/object:Gem::Dependency
   name: aws-sdk
   requirement: !ruby/object:Gem::Requirement
@@ -146,6 +152,7 @@ files:
 - ".gitignore"
 - ".travis.yml"
 - ".yardopts"
+- CHANGELOG.md
 - Gemfile
 - LICENSE.md
 - Procfile