fake_dynamo 0.2.1 → 0.2.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: aa98039cb0185d49b68cf2c5d7f4fc2e397b46d5
+  data.tar.gz: 46c7912a403e2a286845ac5adeed6222f165581b
+SHA512:
+  metadata.gz: 6e44b53a1d8bfc7635386a0723bac32b24e09bc796a480499934aec4bc72b3682b52946d3ebc76d8f0fdcc1b4b330b841c1d2250c213f8fb8f70020f5f0c8da3
+  data.tar.gz: c71684a8780aa64b655b33dcca221979114e7986940d12016d3955fed1075c337d567bd3206dc72eafbd91e72b98064ca17b3bbfebd0ed5b6de9f829168abc13

data/.gitignore

@@ -15,3 +15,7 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+bin/node_modules/*
+bin/*.json
+bin/reverse_dynamo
+bin/test_binary

data/.travis.yml

@@ -1,6 +1,7 @@
 language: ruby
 rvm:
   - 1.9.3
+  - 2.0.0
   - jruby-19mode
   - rbx-19mode
 script: "bundle exec rspec"

data/README.md

@@ -6,16 +6,13 @@ local hosted, inmemory Amazon DynamoDB emulator.
 
 | Amazon DynamoDB | FakeDynamo  |
 | --------------- | ----------- |
-| 2012-08-10      | 0.2.1       |
+| 2012-08-10      | 0.2.2       |
 | 2011-12-05      | 0.1.3       |
 
 
 ## Caveats
 
 *  `ConsumedCapacityUnits` value will be 1 always.
-*  The response size is not constrained by 1mb limit. So operation
-   like `BatchGetItem` will return all items irrespective of the
-   response size
 
 ## Usage
 
@@ -35,7 +32,7 @@ curl -X DELETE http://localhost:4567
 
 ## Clients
 
-* aws-sdk
+* aws-sdk-ruby (AWS SDK for Ruby)
 
 ````ruby
 AWS.config(:use_ssl => false,
@@ -45,6 +42,17 @@ AWS.config(:use_ssl => false,
            :secret_access_key => "xxx")
 ````
 
+* aws-sdk-js (AWS SDK for Node.js)
+
+````js
+ AWS.config.update({apiVersion:      "2012-08-10",
+                    sslEnabled:      false,
+                    endpoint:        "localhost:4567",
+                    accessKeyId:     "xxx",
+                    secretAccessKey: "xxx",
+                    region:          "xxx"});
+````
+
 __please open a pull request with your configuration if you are using
 fake_dynamo with clients other than the ones mentioned above__.
 

data/bin/fake_dynamo

@@ -4,7 +4,8 @@ $:.unshift(File.dirname(__FILE__) + '/../lib')
 require 'fake_dynamo'
 require 'optparse'
 
-options = { :port => 4567, :bind => '127.0.0.1', :compact => false, :db => '/usr/local/var/fake_dynamo/db.fdb' }
+options = { :port => 4567, :bind => '127.0.0.1', :compact => false,
+  :db => '/usr/local/var/fake_dynamo/db.fdb', :log_level => :warn }
 OptionParser.new do |opts|
   opts.banner = "Usage: fake_dynamo [options]"
 
@@ -32,6 +33,10 @@ OptionParser.new do |opts|
     options[:daemonize] = daemonize
   end
 
+  opts.on "-l", "--log-level LEVEL", [:debug, :info, :warn, :error, :fatal], "(debug, info, warn, error, fatal) Default: #{options[:log_level]}" do |level|
+    options[:log_level] = level
+  end
+
 end.parse!
 
 if options[:daemonize]
@@ -53,6 +58,7 @@ if (pid = options[:pid])
 end
 
 FakeDynamo::Storage.db_path = options[:db]
+FakeDynamo::Logger.setup(options[:log_level])
 
 if options[:compact]
   FakeDynamo::Storage.instance.load_aof
@@ -60,7 +66,9 @@ if options[:compact]
 end
 
 FakeDynamo::Storage.instance.load_aof
-FakeDynamo::Server.run!(:port => options[:port], :bind => options[:bind])
+FakeDynamo::Server.run!(:port => options[:port], :bind => options[:bind]) do |server|
+  server.config[:AccessLog] = []
+end
 
 at_exit {
   FakeDynamo::Storage.instance.shutdown

data/lib/fake_dynamo.rb

@@ -3,7 +3,10 @@ require 'json'
 require 'base64'
 require 'active_support/inflector'
 require 'active_support/core_ext/class/attribute'
+require 'pp'
+require 'logger'
 require 'fake_dynamo/exceptions'
+require 'fake_dynamo/num'
 require 'fake_dynamo/validation'
 require 'fake_dynamo/filter'
 require 'fake_dynamo/local_secondary_index'
@@ -12,9 +15,9 @@ require 'fake_dynamo/attribute'
 require 'fake_dynamo/key_schema'
 require 'fake_dynamo/item'
 require 'fake_dynamo/key'
+require 'fake_dynamo/sack'
 require 'fake_dynamo/table'
 require 'fake_dynamo/db'
 require 'fake_dynamo/storage'
 require 'fake_dynamo/server'
-require 'pp'
-
+require 'fake_dynamo/logger'

data/lib/fake_dynamo/api_2012-08-10.yml

@@ -1222,6 +1222,12 @@
     ReturnConsumedCapacity:
     - :string
     - :enum: [TOTAL, NONE]
+    TotalSegments:
+    - :integer
+    - :within: !ruby/range 1..4096
+    Segment:
+    - :integer
+    - :within: !ruby/range 0..4095
   :outputs:
     Items:
       :sym: :member

data/lib/fake_dynamo/attribute.rb

@@ -3,44 +3,31 @@ module FakeDynamo
     attr_accessor :name, :value, :type
 
     def initialize(name, value, type)
-      @name, @value, @type = name, value, type
+      @name, @type = name, type
+      validate_name!
+      return unless value
 
-      if @type == 'B' and value
-        @value = Base64.decode64(value)
-      end
+      @value = decode(value)
+      validate_value!
+    end
 
-      if @type == 'BS'
-        @value = value.map { |v| Base64.decode64(v) }
+    def validate_name!
+      if name == ''
+        raise ValidationException, 'Empty attribute name'
       end
+    end
 
+    def validate_value!
       if ['NS', 'SS', 'BS'].include? @type
-        raise ValidationException, 'An AttributeValue may not contain an empty set' if value.empty?
+        raise ValidationException, 'An AttributeValue may not contain an empty set' if @value.empty?
         raise ValidationException, 'Input collection contains duplicates' if value.uniq!
       end
 
-      if ['NS', 'N'].include? @type
-        Array(@value).each do |n|
-          numeric(n)
-        end
-      end
-
       if ['S', 'SS', 'S', 'BS'].include? @type
-        Array(value).each do |v|
+        Array(@value).each do |v|
           raise ValidationException, 'An AttributeValue may not contain an empty string or empty binary' if v == ''
         end
       end
-
-      if name == ''
-        raise ValidationException, 'Empty attribute name'
-      end
-    end
-
-    def numeric(n)
-      begin
-        Float(n)
-      rescue
-        raise ValidationException, "The parameter cannot be converted to a numeric value: #{n}"
-      end
     end
 
     def description
@@ -50,30 +37,38 @@ module FakeDynamo
       }
     end
 
+    def decode(value)
+      case @type
+      when 'B' then Base64.decode64(value)
+      when 'BS' then value.map { |v| Base64.decode64(v) }
+      when 'N' then Num.new(value)
+      when 'NS' then value.map { |v| Num.new(v) }
+      else value
+      end
+    end
+
+    def encode(value)
+      case @type
+      when 'B' then Base64.encode64(value)
+      when 'BS' then value.map { |v| Base64.encode64(v) }
+      when 'N' then value.to_s
+      when 'NS' then value.map(&:to_s)
+      else value
+      end
+    end
+
     def as_hash
-      value = if @type == 'B'
-                Base64.encode64(@value)
-              elsif @type == 'BS'
-                @value.map { |v| Base64.encode64(v) }
-              else
-                @value
-              end
-
-      { @name => { @type => value } }
+      { @name => { @type => encode(@value) } }
     end
 
     def ==(attribute)
       @name == attribute.name &&
         @type == attribute.type &&
-        (@type == 'N' ? @value.to_f == attribute.value.to_f : @value == attribute.value)
+        @value == attribute.value
     end
 
     def <=>(other)
-      if @type == 'N'
-        @value.to_f <=> other.value.to_f
-      else
-        @value <=> other.value
-      end
+      @value <=> other.value
     end
 
     def eql?(attribute)
@@ -83,7 +78,7 @@ module FakeDynamo
     end
 
     def hash
-      name.hash ^ (type == 'N' ? value.to_f : value).hash ^ type.hash
+      name.hash ^ value.hash ^ type.hash
     end
 
     class << self

data/lib/fake_dynamo/db.rb

@@ -91,6 +91,8 @@ module FakeDynamo
     def batch_get_item(data)
       response = {}
       consumed_capacity = {}
+      unprocessed_keys = {}
+      sack = Sack.new
 
       data['RequestItems'].each do |table_name, table_data|
         table = find_table(table_name)
@@ -101,13 +103,23 @@ module FakeDynamo
         end
 
         table_data['Keys'].each do |key|
-          if item_hash = table.get_raw_item(key, table_data['AttributesToGet'])
-            response[table_name] << item_hash
+          if sack.has_space?
+            if item_hash = table.get_raw_item(key, table_data['AttributesToGet'])
+              response[table_name] << item_hash
+              sack.add(item_hash)
+            end
+          else
+            unless unprocessed_keys[table_name]
+              unprocessed_keys[table_name] = {'Keys' => []}
+              unprocessed_keys[table_name]['AttributesToGet'] = table_data['AttributesToGet'] if table_data['AttributesToGet']
+            end
+
+            unprocessed_keys[table_name]['Keys'] << key
           end
         end
       end
 
-      response = { 'Responses' => response, 'UnprocessedKeys' => {} }
+      response = { 'Responses' => response, 'UnprocessedKeys' => unprocessed_keys }
       merge_consumed_capacity(consumed_capacity, response)
     end
 
@@ -195,7 +207,7 @@ module FakeDynamo
 
 
     def find_table(table_name)
-      tables[table_name] or raise ResourceNotFoundException, "Table : #{table_name} not found"
+      tables[table_name] or raise ResourceNotFoundException, "Table: #{table_name} not found"
     end
 
     def check_max_request(count)

data/lib/fake_dynamo/filter.rb

@@ -23,11 +23,7 @@ module FakeDynamo
         return false if target_attribute.type != value_attribute.type
       end
 
-      if target_attribute.type == 'N'
-        comparator.call(target_attribute.value.to_f, *value_attribute_list.map(&:value).map(&:to_f))
-      else
-        comparator.call(target_attribute.value, *value_attribute_list.map(&:value))
-      end
+      comparator.call(target_attribute.value, *value_attribute_list.map(&:value))
     end
 
     def validate_supported_types(value_attribute, supported_types)

data/lib/fake_dynamo/item.rb

@@ -39,6 +39,10 @@ module FakeDynamo
       result
     end
 
+    def to_json(*)
+      as_hash.to_json
+    end
+
     def update(name, data)
       if key[name]
         raise ValidationException, "Cannot update attribute #{name}. This attribute is part of the key"
@@ -90,12 +94,7 @@ module FakeDynamo
         validate_type(value, old_attribute)
         case attribute.type
         when "N"
-          new_value = (old_attribute.value.to_f + attribute.value.to_f)
-          if new_value.truncate == new_value
-            new_value = new_value.truncate
-          end
-
-          old_attribute.value = new_value.to_s
+          old_attribute.value = old_attribute.value.add(attribute.value)
         else
           old_attribute.value += attribute.value
           old_attribute.value.uniq!

data/lib/fake_dynamo/logger.rb

@@ -0,0 +1,24 @@
+module FakeDynamo
+  module Logger
+    class << self
+      attr_accessor :log
+
+      def setup(level)
+        logger = ::Logger.new(STDOUT)
+        logger.level = [:debug, :info, :warn, :error, :fatal].index(level)
+        logger.formatter = proc do |severity, datetime, progname, msg|
+          "#{msg}\n"
+        end
+
+        def logger.pp(object)
+          return if level > ::Logger::INFO
+          output = ''
+          PP.pp(object, output)
+          info(output)
+        end
+
+        @log = logger
+      end
+    end
+  end
+end

data/lib/fake_dynamo/num.rb

@@ -0,0 +1,63 @@
+require 'bigdecimal'
+
+module FakeDynamo
+  class Num
+    include Comparable
+    attr_accessor :internal
+    LOW = BigDecimal.new('-.1e126')
+    HIGH = BigDecimal.new('.1e126')
+
+    def initialize(value)
+      validate!(value)
+      @internal = BigDecimal.new(value)
+    end
+
+    def validate!(n)
+      begin
+        Float(n)
+      rescue
+        raise ValidationException, "The parameter cannot be converted to a numeric value: #{n}"
+      end
+
+      b = BigDecimal.new(n)
+      if b < LOW
+        raise ValidationException, "Number underflow. Attempting to store a number with magnitude smaller than supported range"
+      end
+
+      if b > HIGH
+        raise ValidationException, "Number overflow. Attempting to store a number with magnitude larger than supported range"
+      end
+
+      significant = b.to_s('F').sub('.', '')
+        .sub(/^0*/, '').sub(/0*$/, '').size
+
+      if significant > 38
+        raise ValidationException, "Attempting to store more than 38 significant digits in a Number"
+      end
+    end
+
+    def <=>(other)
+      @internal <=> other.internal
+    end
+
+    def ==(other)
+      @internal == other.internal
+    end
+
+    def hash
+      to_s.hash
+    end
+
+    def add(other)
+      return Num.new(@internal + other.internal)
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    def to_s
+      @internal.to_s('F').sub(/\.0$/, '')
+    end
+  end
+end

data/lib/fake_dynamo/sack.rb

@@ -0,0 +1,18 @@
+module FakeDynamo
+  class Sack
+    attr_accessor :size, :item, :max_size
+
+    def initialize(max_size = 1 * 1024 * 1024) # 1 mb
+      @size = 0
+      @max_size = max_size
+    end
+
+    def add(item)
+      @size += item.to_json.bytesize
+    end
+
+    def has_space?
+      @size < @max_size
+    end
+  end
+end

data/lib/fake_dynamo/server.rb

@@ -13,16 +13,16 @@ module FakeDynamo
       begin
         data = JSON.parse(request.body.read)
         operation = extract_operation(request.env)
-        puts "operation #{operation}"
-        puts "data"
-        pp data
+        log.info "operation #{operation}"
+        log.info "data"
+        log.pp(data)
         response = db.process(operation, data)
         storage.persist(operation, data)
       rescue FakeDynamo::Error => e
         response, status = e.response, e.status
       end
-      puts "response"
-      pp response
+      log.info "response"
+      log.pp(response)
       [status, response.to_json]
     end
 
@@ -40,6 +40,10 @@ module FakeDynamo
       Storage.instance
     end
 
+    def log
+      Logger.log
+    end
+
     def extract_operation(env)
       if env['HTTP_X_AMZ_TARGET'] =~ /DynamoDB_\d+\.([a-zA-z]+)/
         $1

data/lib/fake_dynamo/storage.rb

@@ -14,6 +14,10 @@ module FakeDynamo
       end
     end
 
+    def log
+      Logger.log
+    end
+
     def initialize
       init_db
     end
@@ -42,7 +46,7 @@ module FakeDynamo
     end
 
     def reset
-      puts "resetting database ..."
+      log.warn "resetting database ..."
       @aof.close if @aof
       @aof = nil
       delete_db
@@ -57,7 +61,7 @@ module FakeDynamo
     end
 
     def shutdown
-      puts "shutting down fake_dynamo ..."
+      log.warn "shutting down fake_dynamo ..."
       @aof.close if @aof
     end
 
@@ -73,7 +77,7 @@ module FakeDynamo
     def load_aof
       return if @loaded
       file = File.new(db_path, 'r')
-      puts "Loading fake_dynamo data ..."
+      log.warn "Loading fake_dynamo data ..."
       loop do
         operation = file.readline.chomp
         size = Integer(file.readline.chomp)
@@ -100,7 +104,7 @@ module FakeDynamo
     def compact!
       return if @compacted
       @aof = Tempfile.new('compact')
-      puts "Compacting db ..."
+      log.warn "Compacting db ..."
       db.tables.each do |_, table|
         persist('CreateTable', table.create_table_data)
         table.items.each do |_, item|

data/lib/fake_dynamo/table.rb

@@ -212,7 +212,7 @@ module FakeDynamo
 
     def query(data)
       range_key_present
-      select_and_attributes_to_get_present(data)
+      select_and_attributes_to_get_present?(data)
       validate_limit(data)
 
       index = nil
@@ -244,7 +244,7 @@ module FakeDynamo
         conditions = {}
       end
 
-      results, last_evaluated_item, _ = filter(matched_items, conditions, data['Limit'], true)
+      results, last_evaluated_item, _ = filter(matched_items, conditions, data['Limit'], true, sack_attributes(data, index))
 
       response = {'Count' => results.size}.merge(consumed_capacity(data))
       merge_items(response, data, results, index)
@@ -260,10 +260,21 @@ module FakeDynamo
     end
 
     def scan(data)
-      select_and_attributes_to_get_present(data)
+      select_and_attributes_to_get_present?(data)
+      total_segments_and_segment_present?(data)
       validate_limit(data)
+
       conditions = data['ScanFilter'] || {}
-      all_items = drop_till_start(items.values, data['ExclusiveStartKey'], true, key_schema)
+
+
+      if (segment = data['Segment']) && (total_segments = data['TotalSegments'])
+        chunk_size = (items.values.size / total_segments.to_f).ceil
+        current_segment = items.values.slice(segment * chunk_size, chunk_size) || []
+      else
+        current_segment = items.values
+      end
+
+      all_items = drop_till_start(current_segment, data['ExclusiveStartKey'], true, key_schema)
       results, last_evaluated_item, scaned_count = filter(all_items, conditions, data['Limit'], false)
       response = {
         'Count' => results.size,
@@ -279,19 +290,45 @@ module FakeDynamo
     end
 
     def merge_items(response, data, results, index = nil)
+      if (attrs = attributes_to_get(data, index)) != false
+        response['Items'] = results.map { |r| filter_attributes(r, attrs) }
+      end
+      response
+    end
+
+    def attributes_to_get(data, index)
       if data['Select'] != 'COUNT'
-        attributes_to_get = nil # select everything
+        if index
+          attributes_to_get = projected_attributes(index)
+        else
+          attributes_to_get = nil # select everything
+        end
+
 
         if data['AttributesToGet']
           attributes_to_get = data['AttributesToGet']
         elsif data['Select'] == 'ALL_PROJECTED_ATTRIBUTES'
           attributes_to_get = projected_attributes(index)
+        elsif data['Select'] == 'ALL_ATTRIBUTES'
+          attributes_to_get = nil
         end
+      else
+        false
+      end
+    end
+
+    def sack_attributes(data, index)
+      return unless index
 
-        response['Items'] = results.map { |r| filter_attributes(r, attributes_to_get) }
+      if data['Select'] == 'COUNT'
+        return projected_attributes(index)
       end
 
-      response
+      if attrs = attributes_to_get(data, index)
+        if (attrs - projected_attributes(index)).empty?
+          return projected_attributes(index)
+        end
+      end
     end
 
     def projected_attributes(index)
@@ -309,13 +346,30 @@ module FakeDynamo
       end
     end
 
-    def select_and_attributes_to_get_present(data)
+    def select_and_attributes_to_get_present?(data)
       select = data['Select']
       if select and data['AttributesToGet'] and (select != 'SPECIFIC_ATTRIBUTES')
         raise ValidationException, "Cannot specify the AttributesToGet when choosing to get only the #{select}"
       end
     end
 
+    def total_segments_and_segment_present?(data)
+      segment, total_segments = data['Segment'], data['TotalSegments']
+
+      if (total_segments && !segment)
+        raise ValidationException, "The Segment parameter is required but was not present in the request when parameter TotalSegments is present"
+      end
+
+      if (segment && !total_segments)
+        raise ValidationException, "The TotalSegments parameter is required but was not present in the request when Segment parameter is present"
+      end
+
+      if (segment && total_segments) &&
+          (segment >= total_segments)
+        raise ValidationException, "The Segment parameter is zero-based and must be less than parameter TotalSegments: Segment: #{segment} is not less than TotalSegments: #{total_segments}"
+      end
+    end
+
     def validate_limit(data)
       if data['Limit'] and data['Limit'] <= 0
         raise ValidationException, "Limit failed to satisfy constraint: Member must have value greater than or equal to 1"
@@ -364,9 +418,10 @@ module FakeDynamo
       end
     end
 
-    def filter(items, conditions, limit, fail_on_type_mismatch)
+    def filter(items, conditions, limit, fail_on_type_mismatch, sack_attributes = nil)
       limit ||= -1
       result = []
+      sack = Sack.new
       last_evaluated_item = nil
       scaned_count = 0
       items.each do |item|
@@ -384,7 +439,13 @@ module FakeDynamo
 
         if select
           result << item
-          if (limit -= 1) == 0
+          if sack_attributes
+            sack.add(filter_attributes(item, sack_attributes))
+          else
+            sack.add(item)
+          end
+
+          if (limit -= 1) == 0 || (!sack.has_space?)
             last_evaluated_item = item
             break
           end

data/lib/fake_dynamo/validation.rb

@@ -66,7 +66,7 @@ module FakeDynamo
             end
           when :within
             range = constrain[:within]
-            unless range.include? data.size
+            unless range.include?(Numeric === data ? data : data.size)
               add_errors("The parameter '#{param(attribute, parents)}' value '#{data}' should be within #{range}")
             end
           when :enum

data/lib/fake_dynamo/version.rb

@@ -1,3 +1,3 @@
 module FakeDynamo
-  VERSION = "0.2.1"
+  VERSION = "0.2.2"
 end

data/spec/fake_dynamo/db_spec.rb

@@ -289,6 +289,20 @@ module FakeDynamo
         }.to raise_error(FakeDynamo::ValidationException)
       end
 
+      it 'should return unprocessed keys if the response is more than 1 mb' do
+        keys = []
+        request = { 'RequestItems' => {'User' => { 'Keys' => keys }}}
+
+        25.times do |i|
+          subject.put_item({'TableName' => 'User',
+              'Item' => { 'id' => { 'S' => i.to_s },
+                'payload' => { 'S' => ('x' * 50 * 1024) }}})
+          keys << { 'id' => { 'S' => i.to_s } }
+        end
+        response = subject.process('BatchGetItem', request);
+        response['UnprocessedKeys']['User']['Keys'].should_not be_empty
+      end
+
       it 'should return items' do
         response = subject.process('BatchGetItem', { 'RequestItems' =>
                                      {

data/spec/fake_dynamo/filter_spec.rb

@@ -102,7 +102,7 @@ module FakeDynamo
       subject.ne_filter([{'S' => 'bcd'}], s_attr, false).should be_false
       subject.ne_filter([{'S' => '10'}], n_attr, false).should be_false
       subject.ne_filter([{'S' => 'xx'}], s_attr, false).should be_true
-      subject.ne_filter([{'S' => '10'}], n_attr, false).should be_false
+      subject.ne_filter([{'N' => '10.0'}], n_attr, false).should be_false
       subject.ne_filter([{'B' => bstr}], b_attr, false).should be_false
     end
 

data/spec/fake_dynamo/item_spec.rb

@@ -48,7 +48,7 @@ module FakeDynamo
       it "should delete values" do
         subject.attributes['friends'] = Attribute.new('friends', ["1", "2"], "NS")
         subject.delete('friends', { "NS" => ["2", "4"]})
-        subject.attributes['friends'].value.should == ["1"]
+        subject.attributes['friends'].value.should == [Num.new("1")]
       end
     end
 
@@ -73,7 +73,13 @@ module FakeDynamo
       it "should increment numbers" do
         subject.attributes['number'] = Attribute.new('number', '5', 'N')
         subject.add('number', { 'N' => '3'})
-        subject.attributes['number'].value.should eq('8')
+        subject.attributes['number'].value.should eq(Num.new('8'))
+      end
+
+      it "should decrement numbers" do
+        subject.attributes['number'] = Attribute.new('number', '5', 'N')
+        subject.add('number', { 'N' => '-3'})
+        subject.attributes['number'].value.should eq(Num.new('2'))
       end
 
       it "should handle sets" do

data/spec/fake_dynamo/num_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+module FakeDynamo
+  describe Num do
+    it 'should validate number' do
+      ['10000000000000000000000000000000000101',
+        '0.1',
+        '1000000000000000000000.0000000000000101',
+        '.00000000000000000000000000000000000001011',
+        '.10000000000000000000000000000000001011',
+        '.1e126',
+        '-.1e126',
+        '-3'].each do |n|
+        Num.new(n)
+      end
+    end
+
+    it 'should raise on number larger that 38 significant digits' do
+      ['1000000000000000000000.00000000000001011',
+        '1.00000000000000000000000000000000001011',
+        '.100000000000000000000000000000000001011'].each do |n|
+        expect { Num.new(n) }.to raise_error(ValidationException, /significant/)
+      end
+    end
+
+    it 'shoud raise on overflow' do
+      ['.1e127',
+        '-.1e127'].each do |n|
+        expect { Num.new(n) }.to raise_error(ValidationException, /Number .*flow/)
+      end
+    end
+  end
+end

data/spec/fake_dynamo/table_spec.rb

@@ -115,15 +115,16 @@ module FakeDynamo
                              'AttributeName2' => { 'N' => "3" },
                              'AttributeName3' => { 'N' => "4.44444" }
                            }})
-        response = subject.get_item({'TableName' => 'Table1',
-                                      'Key' => {
-                                        'AttributeName1' => { 'S' => 'test' },
-                                        'AttributeName2' => { 'N' => '3' }
-                                      }})
-
-        response['Item']['AttributeName3'].should eq('N' => '4.44444')
 
+        ['3', '3.0', '3e0', '.3e1', '003'].each do |n|
+          response = subject.get_item({'TableName' => 'Table1',
+                                        'Key' => {
+                                          'AttributeName1' => { 'S' => 'test' },
+                                          'AttributeName2' => { 'N' => n }
+                                        }})
 
+          response['Item']['AttributeName3'].should eq('N' => '4.44444')
+        end
       end
 
       it 'should fail if range key is not present' do
@@ -491,6 +492,21 @@ module FakeDynamo
           response = t.query(query)
           response['Items'].first.keys.size.should eq(4)
         end
+
+        it 'should return last evaluated key when the item processed size exceeds 1 mb' do
+          t = Table.new(data)
+          t.put_item(item)
+          25.times do |i|
+            t.put_item({'TableName' => 'User',
+                'Item' => { 'AttributeName1' => { 'S' => '1' },
+                  'AttributeName2' => { 'N' => i},
+                  'payload' => { 'S' => ('x' * 50 * 1024) }}})
+          end
+          query['KeyConditions']['AttributeName1']['AttributeValueList'] = [{'S' => '1'}]
+          query['KeyConditions'].delete('AttributeName2')
+          response = t.query(query)
+          response['LastEvaluatedKey'].should_not be_empty
+        end
       end
 
 

data/spec/spec_helper.rb

@@ -24,3 +24,4 @@ module FakeDynamo
 end
 
 FakeDynamo::Storage.db_path = '/tmp/test_db.fdb'
+FakeDynamo::Logger.setup(:debug)

metadata

@@ -1,49 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: fake_dynamo
 version: !ruby/object:Gem::Version
-  version: 0.2.1
-  prerelease: 
+  version: 0.2.2
 platform: ruby
 authors:
 - Anantha Kumaran
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-02 00:00:00.000000000 Z
+date: 2013-06-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sinatra
-  requirement: &70292157821000 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70292157821000
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: activesupport
-  requirement: &70292157820120 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70292157820120
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: json
-  requirement: &70292157812900 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70292157812900
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email:
 - ananthakumaran@gmail.com
@@ -73,7 +81,10 @@ files:
 - lib/fake_dynamo/key.rb
 - lib/fake_dynamo/key_schema.rb
 - lib/fake_dynamo/local_secondary_index.rb
+- lib/fake_dynamo/logger.rb
+- lib/fake_dynamo/num.rb
 - lib/fake_dynamo/projection.rb
+- lib/fake_dynamo/sack.rb
 - lib/fake_dynamo/server.rb
 - lib/fake_dynamo/storage.rb
 - lib/fake_dynamo/table.rb
@@ -82,6 +93,7 @@ files:
 - spec/fake_dynamo/db_spec.rb
 - spec/fake_dynamo/filter_spec.rb
 - spec/fake_dynamo/item_spec.rb
+- spec/fake_dynamo/num_spec.rb
 - spec/fake_dynamo/server_spec.rb
 - spec/fake_dynamo/storage_spec.rb
 - spec/fake_dynamo/table_spec.rb
@@ -89,35 +101,34 @@ files:
 - spec/spec_helper.rb
 homepage: 
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: 1.9.0
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.15
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: local hosted, inmemory fake dynamodb
 test_files:
 - spec/fake_dynamo/db_spec.rb
 - spec/fake_dynamo/filter_spec.rb
 - spec/fake_dynamo/item_spec.rb
+- spec/fake_dynamo/num_spec.rb
 - spec/fake_dynamo/server_spec.rb
 - spec/fake_dynamo/storage_spec.rb
 - spec/fake_dynamo/table_spec.rb
 - spec/fake_dynamo/validation_spec.rb
 - spec/spec_helper.rb
-has_rdoc: