fake_dynamo 0.0.1

data/lib/fake_dynamo/validation.rb

@@ -0,0 +1,155 @@
+require 'yaml'
+
+module FakeDynamo
+  module Validation
+
+    def validate!(&block)
+      @api_errors = []
+      yield
+      unless @api_errors.empty?
+        plural = @api_errors.size == 1 ? '' : 's'
+        message = "#{@api_errors.size} error#{plural} detected: #{@api_errors.join('; ')}"
+        raise ValidationException, message
+      end
+    end
+
+
+    def add_errors(message)
+      @api_errors << message
+    end
+
+    def validate_payload(operation, data)
+      validate! do
+        validate_operation(operation)
+        validate_input(operation, data)
+      end
+    end
+
+    def validate_operation(operation)
+      raise UnknownOperationException, "Unknown operation: #{operation}" unless available_operations.include? operation
+    end
+
+    def available_operations
+      api_config[:operations].keys
+    end
+
+    def validate_input(operation, data)
+      api_input_spec(operation).each do |attribute, spec|
+        validate_spec(attribute, data[attribute], spec, [])
+      end
+    end
+
+    def validate_spec(attribute, data, spec, parents)
+      if not data
+        if spec.include?(:required)
+          add_errors("value null at '#{param(attribute, parents)}' failed to satisfy the constraint: Member must not be null")
+        end
+        return
+      end
+
+      spec.each do |constrain|
+        case constrain
+        when :string
+          add_errors("The parameter '#{param(attribute, parents)}' must be a string") unless data.kind_of? String
+        when :long
+          add_errors("The parameter '#{param(attribute, parents)}' must be a long") unless data.kind_of? Fixnum
+        when :integer
+          add_errors("The parameter '#{param(attribute, parents)}' must be a integer") unless data.kind_of? Fixnum
+        when :boolean
+          add_errors("The parameter '#{param(attribute, parents)}' must be a boolean") unless (data.kind_of? TrueClass or data.kind_of? FalseClass)
+        when Hash
+          new_parents = parents + [attribute]
+          case constrain.keys.first
+          when :pattern
+            pattern = constrain[:pattern]
+            unless data =~ pattern
+              add_errors("The parameter '#{param(attribute, parents)}' should match the pattern #{pattern}")
+            end
+          when :within
+            range = constrain[:within]
+            unless range.include? data.size
+              add_errors("The parameter '#{param(attribute, parents)}' value '#{data}' should be within #{range} characters")
+            end
+          when :enum
+            enum = constrain[:enum]
+            unless enum.include? data
+              add_errors("Value '#{data}' at '#{param(attribute, parents)}' failed to satisfy the constraint: Member must satisfy enum values set: #{enum}")
+            end
+          when :structure
+            structure = constrain[:structure]
+            structure.each do |attribute, spec|
+              validate_spec(attribute, data[attribute], spec, new_parents)
+            end
+          when :map
+            map = constrain[:map]
+            raise "#{param(attribute, parents)} must be a Hash" unless data.kind_of? Hash
+            data.each do |key, value|
+              validate_spec(key, key, map[:key], new_parents)
+              validate_spec(key, value, map[:value], new_parents)
+            end
+          when :list
+            raise "#{param(attribute, parents)} must be a Array" unless data.kind_of? Array
+            data.each do |element|
+              validate_spec(element, element, constrain[:list], new_parents)
+            end
+          else
+            raise "Unhandled constraint #{constrain}"
+          end
+        when :required
+          # handled earlier
+        else
+          raise "Unhandled constraint #{constrain}"
+        end
+      end
+    end
+
+    def param(attribute, parents)
+      (parents + [attribute]).join('.')
+    end
+
+    def api_input_spec(operation)
+      api_config[:operations][operation][:input]
+    end
+
+    def api_config
+      @api_config ||= YAML.load_file(api_config_path)
+    end
+
+    def api_config_path
+      File.join File.expand_path(File.dirname(__FILE__)), 'api.yml'
+    end
+
+    def validate_type(value, attribute)
+      if attribute.kind_of?(Attribute)
+        expected_type = value.keys.first
+        if expected_type != attribute.type
+          raise ValidationException, "Type mismatch for key #{attribute.name}"
+        end
+      else
+        raise 'Unknown attribute'
+      end
+    end
+
+    def validate_key_schema(data, key_schema)
+      key = data[key_schema.hash_key.name] or raise ValidationException, "Missing the key #{key_schema.hash_key.name} in the item"
+      validate_type(key, key_schema.hash_key)
+
+      if key_schema.range_key
+        range_key = data[key_schema.range_key.name] or raise ValidationException, "Missing the key #{key_schema.range_key.name} in the item"
+        validate_type(range_key, key_schema.range_key)
+      end
+    end
+
+    def validate_key_data(data, key_schema)
+      validate_type(data['HashKeyElement'], key_schema.hash_key)
+
+      if key_schema.range_key
+        range_key = data['RangeKeyElement'] or raise ValidationException, "Missing the key RangeKeyElement in the Key"
+        validate_type(range_key, key_schema.range_key)
+      elsif data['RangeKeyElement']
+        raise ValidationException, "RangeKeyElement is not present in the schema"
+      end
+    end
+
+  end
+end

data/lib/fake_dynamo/version.rb

@@ -0,0 +1,3 @@
+module FakeDynamo
+  VERSION = "0.0.1"
+end

data/spec/fake_dynamo/db_spec.rb

@@ -0,0 +1,257 @@
+require 'spec_helper'
+
+module FakeDynamo
+  describe DB do
+    let(:data) do
+      {
+        "TableName" => "Table1",
+        "KeySchema" =>
+        {"HashKeyElement" => {"AttributeName" => "AttributeName1","AttributeType" => "S"},
+          "RangeKeyElement" => {"AttributeName" => "AttributeName2","AttributeType" => "N"}},
+        "ProvisionedThroughput" => {"ReadCapacityUnits" => 5,"WriteCapacityUnits" => 10}
+      }
+    end
+
+    let(:user_table) do
+      {"TableName" => "User",
+        "KeySchema" =>
+        {"HashKeyElement" => {"AttributeName" => "id","AttributeType" => "S"}},
+        "ProvisionedThroughput" => {"ReadCapacityUnits" => 5,"WriteCapacityUnits" => 10}
+      }
+    end
+
+    it 'should not allow to create duplicate tables' do
+      subject.create_table(data)
+      expect { subject.create_table(data) }.to raise_error(ResourceInUseException, /duplicate/i)
+    end
+
+    it 'should fail on unknown operation' do
+      expect { subject.process('unknown', data) }.to raise_error(UnknownOperationException, /unknown/i)
+    end
+
+    context 'DescribeTable' do
+      it 'should describe table' do
+        table = subject.create_table(data)
+        description = subject.describe_table({'TableName' => 'Table1'})
+        description.should include({
+          "ItemCount"=>0,
+          "TableSizeBytes"=>0})
+      end
+
+      it 'should fail on unavailable table' do
+        expect { subject.describe_table({'TableName' => 'Table1'}) }.to raise_error(ResourceNotFoundException, /table1 not found/i)
+      end
+
+      it 'should fail on invalid payload' do
+        expect { subject.process('DescribeTable', {}) }.to raise_error(ValidationException, /null/)
+      end
+    end
+
+    context 'DeleteTable' do
+      it "should delete table" do
+        subject.create_table(data)
+        response = subject.delete_table(data)
+        subject.tables.should be_empty
+        response['TableDescription']['TableStatus'].should == 'DELETING'
+      end
+
+      it "should not allow to delete the same table twice" do
+        subject.create_table(data)
+        subject.delete_table(data)
+        expect { subject.delete_table(data) }.to raise_error(ResourceNotFoundException, /table1 not found/i)
+      end
+    end
+
+    context 'ListTable' do
+      before :each do
+        (1..5).each do |i|
+          data['TableName'] = "Table#{i}"
+          subject.create_table(data)
+        end
+      end
+
+      it "should list all table" do
+        result = subject.list_tables({})
+        result.should eq({"TableNames"=>["Table1", "Table2", "Table3", "Table4", "Table5"]})
+      end
+
+      it 'should handle limit and exclusive_start_table_name' do
+        result = subject.list_tables({'Limit' => 3,
+                                       'ExclusiveStartTableName' => 'Table1'})
+        result.should eq({'TableNames'=>["Table2", "Table3", "Table4"],
+                           'LastEvaluatedTableName' => "Table4"})
+
+        result = subject.list_tables({'Limit' => 3,
+                                       'ExclusiveStartTableName' => 'Table2'})
+        result.should eq({'TableNames' => ['Table3', 'Table4', 'Table5']})
+
+        result = subject.list_tables({'ExclusiveStartTableName' => 'blah'})
+        result.should eq({"TableNames"=>["Table1", "Table2", "Table3", "Table4", "Table5"]})
+      end
+
+      it 'should validate payload' do
+        expect { subject.process('ListTables', {'Limit' => 's'}) }.to raise_error(ValidationException)
+      end
+    end
+
+    context 'UpdateTable' do
+
+      it 'should update throughput' do
+        subject.create_table(data)
+        response = subject.update_table({'TableName' => 'Table1',
+                               'ProvisionedThroughput' => {
+                                 'ReadCapacityUnits' => 7,
+                                 'WriteCapacityUnits' => 15
+                               }})
+
+        response['TableDescription'].should include({'TableStatus' => 'UPDATING'})
+      end
+
+      it 'should handle validation' do
+        subject.create_table(data)
+        expect { subject.process('UpdateTable', {'TableName' => 'Table1'}) }.to raise_error(ValidationException, /null/)
+      end
+    end
+
+    context 'delegate to table' do
+      subject do
+        db = DB.new
+        db.create_table(data)
+        db
+      end
+
+      let(:item) do
+        { 'TableName' => 'Table1',
+          'Item' => {
+            'AttributeName1' => { 'S' => "test" },
+            'AttributeName2' => { 'N' => '11' },
+            'AttributeName3' => { 'S' => "another" }
+          }}
+      end
+
+      it 'should delegate to table' do
+        subject.process('PutItem', item)
+        subject.process('GetItem', {
+                          'TableName' => 'Table1',
+                          'Key' => {
+                            'HashKeyElement' => { 'S' => 'test' },
+                            'RangeKeyElement' => { 'N' => '11' }
+                          },
+                          'AttributesToGet' => ['AttributeName3']
+                        })
+        subject.process('DeleteItem', {
+                          'TableName' => 'Table1',
+                          'Key' => {
+                            'HashKeyElement' => { 'S' => 'test' },
+                            'RangeKeyElement' => { 'N' => '11' }
+                          }})
+        subject.process('UpdateItem', {
+                          'TableName' => 'Table1',
+                          'Key' => {
+                            'HashKeyElement' => { 'S' => 'test' },
+                            'RangeKeyElement' => { 'N' => '11' }
+                          },
+                          'AttributeUpdates' =>
+                          {'AttributeName3' =>
+                            {'Value' => {'S' => 'AttributeValue3_New'},
+                              'Action' => 'PUT'}
+                          },
+                          'ReturnValues' => 'ALL_NEW'
+                        })
+
+        subject.process('Query', {
+                          'TableName' => 'Table1',
+                          'Limit' => 5,
+                          'Count' => true,
+                          'HashKeyValue' => {'S' => 'att1'},
+                          'RangeKeyCondition' => {
+                            'AttributeValueList' => [{'N' => '1'}],
+                            'ComparisonOperator' => 'GT'
+                          },
+                          'ScanIndexForward' => true
+                        })
+      end
+    end
+
+    context 'batch get item' do
+      subject do
+        db = DB.new
+        db.create_table(data)
+        db.create_table(user_table)
+
+        db.put_item({ 'TableName' => 'Table1',
+                      'Item' => {
+                        'AttributeName1' => { 'S' => "test" },
+                        'AttributeName2' => { 'N' => '11' },
+                        'AttributeName3' => { 'S' => "another" }
+                      }})
+
+        db.put_item({'TableName' => 'User',
+                      'Item' => { 'id' => { 'S' => '1' }}
+                    })
+        db.put_item({'TableName' => 'User',
+                      'Item' => { 'id' => { 'S' => '2' }}
+                    })
+        db
+      end
+
+      it 'should validate payload' do
+        expect {
+          subject.process('BatchGetItem', {})
+        }.to raise_error(FakeDynamo::ValidationException)
+      end
+
+      it 'should return items' do
+        response = subject.process('BatchGetItem', { 'RequestItems' =>
+                                     {
+                                       'User' => {
+                                         'Keys' => [{ 'HashKeyElement' => { 'S' => '1' }},
+                                                    { 'HashKeyElement' => { 'S' => '2' }}]
+                                       },
+                                       'Table1' => {
+                                         'Keys' => [{'HashKeyElement' => { 'S' => 'test' },
+                                                      'RangeKeyElement' => { 'N' => '11' }}],
+                                         'AttributesToGet' => ['AttributeName1', 'AttributeName2']
+                                       }
+                                     }})
+
+        response.should eq({"Responses"=>
+                             {"User"=>
+                               {"ConsumedCapacityUnits"=>1,
+                                 "Items"=>[{"id"=>{"S"=>"1"}}, {"id"=>{"S"=>"2"}}]},
+                               "Table1"=>
+                               {"ConsumedCapacityUnits"=>1,
+                                 "Items"=>
+                                 [{"AttributeName1"=>{"S"=>"test"},
+                                    "AttributeName2"=>{"N"=>"11"}}]}},
+                             "UnprocessedKeys"=>{}})
+      end
+
+      it 'should handle missing items' do
+        response = subject.process('BatchGetItem', { 'RequestItems' =>
+                                     {
+                                       'User' => {
+                                         'Keys' => [{ 'HashKeyElement' => { 'S' => '1' }},
+                                                    { 'HashKeyElement' => { 'S' => 'asd' }}]
+                                       }
+                                     }})
+        response.should eq({"Responses"=>
+                             {"User"=>
+                               {"ConsumedCapacityUnits"=>1,
+                                 "Items"=>[{"id"=>{"S"=>"1"}}]}},
+                             "UnprocessedKeys"=>{}})
+      end
+
+      it 'should fail if table not found' do
+        expect {
+          subject.process('BatchGetItem', { 'RequestItems' =>
+                            {
+                              'xxx' => {
+                                'Keys' => [{ 'HashKeyElement' => { 'S' => '1' }},
+                                           { 'HashKeyElement' => { 'S' => 'asd' }}]}
+                            }})
+        }.to raise_error(FakeDynamo::ResourceNotFoundException)
+      end
+    end
+  end
+end

data/spec/fake_dynamo/filter_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+
+module FakeDynamo
+
+  class FilterTest
+    include Filter
+  end
+
+  describe Filter do
+    subject { FilterTest.new }
+
+    let(:s_attr) { Attribute.new('test', 'bcd', 'S')}
+    let(:ss_attr) { Attribute.new('test', ['ab', 'cd'], 'SS') }
+    let(:n_attr) { Attribute.new('test', '10', 'N')}
+    let(:ns_attr) { Attribute.new('test', ['1', '2', '3', '4'], 'NS')}
+
+
+    it 'tests eq' do
+      subject.eq_filter([{'S' => 'bcd'}], s_attr, false).should be_true
+      subject.eq_filter([{'S' => '10'}], n_attr, false).should be_false
+      expect { subject.eq_filter([{'S' => '10'}], n_attr, true) }.to raise_error(ValidationException, /mismatch/)
+    end
+
+    it 'tests le' do
+      subject.le_filter([{'S' => 'c'}], s_attr, false).should be_true
+      subject.le_filter([{'S' => 'bcd'}], s_attr, false).should be_true
+      subject.le_filter([{'N' => 'bcd'}], s_attr, false).should be_false
+      subject.le_filter([{'S' => 'a'}], s_attr, false).should be_false
+      subject.le_filter([{'N' => '10'}], n_attr, false).should be_true
+      subject.le_filter([{'N' => '11'}], n_attr, false).should be_true
+      subject.le_filter([{'N' => '1'}], n_attr, false).should be_false
+    end
+
+    it 'tests lt' do
+      subject.lt_filter([{'S' => 'c'}], s_attr, false).should be_true
+      subject.lt_filter([{'S' => 'bcd'}], s_attr, false).should be_false
+      subject.lt_filter([{'N' => 'bcd'}], s_attr, false).should be_false
+      subject.lt_filter([{'S' => 'a'}], s_attr, false).should be_false
+      subject.lt_filter([{'N' => '10'}], n_attr, false).should be_false
+      subject.lt_filter([{'N' => '11'}], n_attr, false).should be_true
+      subject.lt_filter([{'N' => '1'}], n_attr, false).should be_false
+    end
+
+    it 'test ge' do
+      subject.ge_filter([{'S' => 'c'}], s_attr, false).should be_false
+      subject.ge_filter([{'S' => 'bcd'}], s_attr, false).should be_true
+      subject.ge_filter([{'N' => 'bcd'}], s_attr, false).should be_false
+      subject.ge_filter([{'S' => 'a'}], s_attr, false).should be_true
+      subject.ge_filter([{'N' => '10'}], n_attr, false).should be_true
+      subject.ge_filter([{'N' => '11'}], n_attr, false).should be_false
+      subject.ge_filter([{'N' => '1'}], n_attr, false).should be_true
+    end
+
+    it 'test gt' do
+      subject.gt_filter([{'S' => 'c'}], s_attr, false).should be_false
+      subject.gt_filter([{'S' => 'bcd'}], s_attr, false).should be_false
+      subject.gt_filter([{'N' => 'bcd'}], s_attr, false).should be_false
+      subject.gt_filter([{'S' => 'a'}], s_attr, false).should be_true
+      subject.gt_filter([{'N' => '10'}], n_attr, false).should be_false
+      subject.gt_filter([{'N' => '11'}], n_attr, false).should be_false
+      subject.gt_filter([{'N' => '1'}], n_attr, false).should be_true
+    end
+
+    it 'test begins_with' do
+      subject.begins_with_filter([{'S' => 'bc'}], s_attr, false).should be_true
+      subject.begins_with_filter([{'S' => 'cd'}], s_attr, false).should be_false
+      expect {
+        subject.begins_with_filter([{'N' => '10'}], n_attr, false)
+      }.to raise_error(ValidationException, /not supported/)
+    end
+
+    it 'test between' do
+      expect {
+        subject.between_filter([{'S' => 'bc'}], s_attr, false)
+      }.to raise_error(ValidationException, /argument count/)
+      subject.between_filter([{'S' => 'a'},{'S' => 'c'}], s_attr, false).should be_true
+      subject.between_filter([{'S' => 'bcd'},{'S' => 'bcd'}], s_attr, false).should be_true
+      subject.between_filter([{'N' => '9'},{'N' => '11'}], n_attr, false).should be_true
+      subject.between_filter([{'S' => '9'},{'S' => '11'}], n_attr, false).should be_false
+    end
+
+    it 'test ne' do
+      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
+    end
+
+    it 'test not null' do
+      subject.not_null_filter(nil, nil, false).should be_false
+      subject.not_null_filter(nil, s_attr, false).should be_true
+    end
+
+    it 'test  null' do
+      subject.null_filter(nil, nil, false).should be_true
+      subject.null_filter(nil, s_attr, false).should be_false
+    end
+
+    it 'test contains' do
+      subject.contains_filter([{'S' => 'cd'}], s_attr, false).should be_true
+      subject.contains_filter([{'S' => 'cd'}], ss_attr, false).should be_true
+      subject.contains_filter([{'N' => '2'}], ns_attr, false).should be_true
+      subject.contains_filter([{'N' => '10'}], n_attr, false).should be_false
+    end
+
+    it 'test not contains' do
+      subject.not_contains_filter([{'S' => 'xx'}], s_attr, false).should be_true
+      subject.not_contains_filter([{'S' => 'cd'}], s_attr, false).should be_false
+      subject.not_contains_filter([{'S' => 'cd'}], ss_attr, false).should be_false
+      subject.not_contains_filter([{'N' => '2'}], ns_attr, false).should be_false
+      subject.not_contains_filter([{'N' => '12'}], ns_attr, false).should be_true
+      subject.not_contains_filter([{'N' => '10'}], n_attr, false).should be_false
+    end
+
+    it 'test in' do
+      subject.in_filter([{'S' => 'bcd'}], s_attr, false).should be_true
+      subject.in_filter([{'S' => 'bcd'}, {'N' => '10'}], n_attr, true).should be_true
+      subject.in_filter([{'N' => '1'}], ns_attr, true).should be_false
+      subject.in_filter([{'S' => 'xx'}], s_attr, false).should be_false
+    end
+  end
+end