fake_dynamo 0.1.4 → 0.2.0

data/lib/fake_dynamo/validation.rb

@@ -30,10 +30,6 @@ module FakeDynamo
       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, [])
@@ -71,7 +67,7 @@ module FakeDynamo
           when :within
             range = constrain[:within]
             unless range.include? data.size
-              add_errors("The parameter '#{param(attribute, parents)}' value '#{data}' should be within #{range} characters")
+              add_errors("The parameter '#{param(attribute, parents)}' value '#{data}' should be within #{range}")
             end
           when :enum
             enum = constrain[:enum]
@@ -81,7 +77,7 @@ module FakeDynamo
           when :structure
             structure = constrain[:structure]
             structure.each do |attribute, spec|
-              validate_spec(attribute, data[attribute], spec, new_parents)
+              validate_spec(attribute, data[attribute], spec, parents + ["member"])
             end
           when :map
             map = constrain[:map]
@@ -92,8 +88,8 @@ module FakeDynamo
             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)
+            data.each_with_index do |element, i|
+              validate_spec(element, element, constrain[:list], new_parents + [(i+1).to_s])
             end
           else
             raise "Unhandled constraint #{constrain}"
@@ -111,7 +107,11 @@ module FakeDynamo
     end
 
     def api_input_spec(operation)
-      api_config[:operations][operation][:input]
+      api_config[:operations].find { |spec| spec[:name] == operation }[:inputs]
+    end
+
+    def available_operations
+      @available_operations ||= api_config[:operations].map { |spec| spec[:name] }
     end
 
     def api_config
@@ -119,7 +119,7 @@ module FakeDynamo
     end
 
     def api_config_path
-      File.join File.expand_path(File.dirname(__FILE__)), 'api.yml'
+      File.join File.expand_path(File.dirname(__FILE__)), 'api_2012-08-10.yml'
     end
 
     def validate_type(value, attribute)
@@ -144,21 +144,73 @@ module FakeDynamo
     end
 
     def validate_key_data(data, key_schema)
-      validate_type(data['HashKeyElement'], key_schema.hash_key)
+      hash_key = data[key_schema.hash_key.name] or key_schema_mismatch
+      validate_type(hash_key, key_schema.hash_key)
 
       if key_schema.range_key
-        range_key = data['RangeKeyElement'] or raise ValidationException, "Missing the key RangeKeyElement in the Key"
+        range_key = data[key_schema.range_key.name] or key_schema_mismatch
         validate_type(range_key, key_schema.range_key)
-      elsif data['RangeKeyElement']
-        raise ValidationException, "RangeKeyElement is not present in the schema"
+        key_schema_mismatch if data.size != 2
+      else
+        key_schema_mismatch if data.size != 1
       end
     end
 
+    def key_schema_mismatch
+      raise ValidationException, "The provided key element does not match the schema"
+    end
+
     def validate_request_size(data)
       if data.to_s.bytesize > 1 * 1024 * 1024
         raise ValidationException, "Request size can't exceed 1 mb"
       end
     end
 
+    def validate_range_key(key_schema)
+      unless key_schema.range_key
+        raise ValidationException, 'Table KeySchema does not have a range key'
+      end
+    end
+
+    def validate_hash_key(index, table)
+      if index.hash_key != table.hash_key
+        raise ValidationException, "Index KeySchema does not have the same leading hash key as table KeySchema for index"
+      end
+    end
+
+    def validate_projection(projection)
+      if projection.type == 'INCLUDE'
+        unless projection.non_key_attributes
+          raise ValidationException, "ProjectionType is #{projection.type}, but NonKeyAttributes is not specified"
+        end
+      else
+        if projection.non_key_attributes
+          raise ValidationException, "ProjectionType is #{projection.type}, but NonKeyAttributes is specified"
+        end
+      end
+    end
+
+    def validate_index_names(indexes)
+      names = indexes.map(&:name)
+      if names.uniq.size != names.size
+        raise ValidationException, "Duplicate index name: #{names.find { |n| names.count(n) > 1 }}"
+      end
+    end
+
+    def validate_hash_condition(condition)
+      unless condition
+        raise ValidationException, "Query condition missed key schema element #{key_schema.hash_key.name}"
+      end
+
+      if condition['ComparisonOperator'] != 'EQ'
+        raise ValidationException, "Query key condition not supported"
+      end
+    end
+
+    def validate_range_condition(condition, schema)
+      unless condition.has_key?(schema.range_key.name)
+        raise ValidationException, "Query condition missed key schema element #{schema.range_key.name}"
+      end
+    end
   end
 end

data/lib/fake_dynamo/version.rb

@@ -1,3 +1,3 @@
 module FakeDynamo
-  VERSION = "0.1.4"
+  VERSION = "0.2.0"
 end

data/lib/fake_dynamo.rb

@@ -6,6 +6,8 @@ require 'active_support/core_ext/class/attribute'
 require 'fake_dynamo/exceptions'
 require 'fake_dynamo/validation'
 require 'fake_dynamo/filter'
+require 'fake_dynamo/local_secondary_index'
+require 'fake_dynamo/projection'
 require 'fake_dynamo/attribute'
 require 'fake_dynamo/key_schema'
 require 'fake_dynamo/item'

data/spec/fake_dynamo/db_spec.rb

@@ -5,24 +5,107 @@ module FakeDynamo
     let(:data) do
       {
         "TableName" => "Table1",
+        "AttributeDefinitions" =>
+        [{"AttributeName" => "AttributeName1","AttributeType" => "S"},
+         {"AttributeName" => "AttributeName2","AttributeType" => "N"}],
         "KeySchema" =>
-        {"HashKeyElement" => {"AttributeName" => "AttributeName1","AttributeType" => "S"},
-          "RangeKeyElement" => {"AttributeName" => "AttributeName2","AttributeType" => "N"}},
+        [{"AttributeName" => "AttributeName1","KeyType" => "HASH"},
+         {"AttributeName" => "AttributeName2","KeyType" => "RANGE"}],
         "ProvisionedThroughput" => {"ReadCapacityUnits" => 5,"WriteCapacityUnits" => 10}
       }
     end
 
     let(:user_table) do
       {"TableName" => "User",
+        "AttributeDefinitions" =>
+        [{"AttributeName" => "id","AttributeType" => "S"}],
         "KeySchema" =>
-        {"HashKeyElement" => {"AttributeName" => "id","AttributeType" => "S"}},
+        [{"AttributeName" => "id","KeyType" => "HASH"}],
         "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)
+    let(:user_table_a) do
+      {"TableName" => "User",
+        "AttributeDefinitions" =>
+        [{"AttributeName" => "id","AttributeType" => "S"},
+         {"AttributeName" => "age","AttributeType" => "S"},
+         {"AttributeName" => "name","AttributeType" => "S"}],
+        "KeySchema" =>
+        [{"AttributeName" => "id","KeyType" => "HASH"},
+         {"AttributeName" => "age", "KeyType" => "RANGE"}],
+        "LocalSecondaryIndexes" =>
+        [{"IndexName" => "age",
+           "KeySchema" =>
+           [{"AttributeName" => "id", "KeyType" => "HASH"},
+            {"AttributeName" => "name", "KeyType" => "RANGE"}],
+           "Projection" => {
+             "ProjectionType" => "INCLUDE",
+             "NonKeyAttributes" => ["name", "gender"]
+           }
+         }],
+        "ProvisionedThroughput" => {"ReadCapacityUnits" => 5,"WriteCapacityUnits" => 10}
+      }
+    end
+
+    context 'CreateTable' do
+      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 allow to create table with secondary indexes' do
+        subject.create_table(user_table_a)
+      end
+
+      it 'should fail on extra attribute' do
+        user_table_a['AttributeDefinitions'] << {"AttributeName" => "gender","AttributeType" => "S"}
+        expect { subject.create_table(user_table_a) }.to raise_error(ValidationException, /some attributedefinitions.*not.*used/i)
+      end
+
+      it 'should fail on missing attribute' do
+        user_table_a['AttributeDefinitions'].delete_at(1)
+        expect { subject.create_table(user_table_a) }.to raise_error(ValidationException, /some.*attributes.*not.*defined/i)
+      end
+
+      context 'LocalSecondaryIndex' do
+        let(:lsi) { user_table_a['LocalSecondaryIndexes'][0] }
+
+        it 'should fail on invalid KeyType' do
+          lsi["KeySchema"][0]['KeyType'] = 'invalid'
+          expect { subject.process('CreateTable', user_table_a) }.to raise_error(ValidationException, /invalid.*enum/)
+        end
+
+        it 'should fail if range key is missing' do
+          lsi['KeySchema'].delete_at(1)
+          expect { subject.create_table(user_table_a) }.to raise_error(ValidationException, /not.*range.*key/i)
+        end
+
+        it 'should fail on duplicate index names' do
+          duplicate = lsi.clone()
+          user_table_a['LocalSecondaryIndexes'] << duplicate
+          expect { subject.create_table(user_table_a) }.to raise_error(ValidationException, /duplicate index/i)
+        end
+
+        it 'should fail on different hash key' do
+          lsi['KeySchema'][0]['AttributeName'] = 'age'
+          expect { subject.create_table(user_table_a) }.to raise_error(ValidationException, /not have.*same.*hash key/i)
+        end
+
+        context 'projection' do
+          let(:projection) { user_table_a['LocalSecondaryIndexes'][0]['Projection'] }
+
+          it 'should fail if non key attributes are specified unnecessarily' do
+            projection['ProjectionType'] = 'KEYS_ONLY'
+            expect { subject.create_table(user_table_a) }.to raise_error(ValidationException, /NonKeyAttributes.*specified/i)
+          end
+
+          it 'should fail if non key attributes are not specified' do
+            projection.delete('NonKeyAttributes')
+            expect { subject.create_table(user_table_a) }.to raise_error(ValidationException, /NonKeyAttributes.*not.*specified/i)
+          end
+        end
+      end
     end
 
     it 'should fail on unknown operation' do
@@ -33,7 +116,7 @@ module FakeDynamo
       it 'should describe table' do
         table = subject.create_table(data)
         description = subject.describe_table({'TableName' => 'Table1'})
-        description.should include({
+        description['Table'].should include({
           "ItemCount"=>0,
           "TableSizeBytes"=>0})
       end
@@ -134,22 +217,22 @@ module FakeDynamo
         subject.process('GetItem', {
                           'TableName' => 'Table1',
                           'Key' => {
-                            'HashKeyElement' => { 'S' => 'test' },
-                            'RangeKeyElement' => { 'N' => '11' }
+                            'AttributeName1' => { 'S' => 'test' },
+                            'AttributeName2' => { 'N' => '11' }
                           },
                           'AttributesToGet' => ['AttributeName3']
                         })
         subject.process('DeleteItem', {
                           'TableName' => 'Table1',
                           'Key' => {
-                            'HashKeyElement' => { 'S' => 'test' },
-                            'RangeKeyElement' => { 'N' => '11' }
+                            'AttributeName1' => { 'S' => 'test' },
+                            'AttributeName2' => { 'N' => '11' }
                           }})
         subject.process('UpdateItem', {
                           'TableName' => 'Table1',
                           'Key' => {
-                            'HashKeyElement' => { 'S' => 'test' },
-                            'RangeKeyElement' => { 'N' => '11' }
+                            'AttributeName1' => { 'S' => 'test' },
+                            'AttributeName2' => { 'N' => '11' }
                           },
                           'AttributeUpdates' =>
                           {'AttributeName3' =>
@@ -163,10 +246,15 @@ module FakeDynamo
                           'TableName' => 'Table1',
                           'Limit' => 5,
                           'Count' => true,
-                          'HashKeyValue' => {'S' => 'att1'},
-                          'RangeKeyCondition' => {
-                            'AttributeValueList' => [{'N' => '1'}],
-                            'ComparisonOperator' => 'GT'
+                          'KeyConditions' => {
+                            'AttributeName1' => {
+                              'AttributeValueList' => [{'S' => 'att1'}],
+                              'ComparisonOperator' => 'EQ'
+                            },
+                            'AttributeName2' => {
+                              'AttributeValueList' => [{'N' => '1'}],
+                              'ComparisonOperator' => 'GT'
+                            }
                           },
                           'ScanIndexForward' => true
                         })
@@ -205,25 +293,22 @@ module FakeDynamo
         response = subject.process('BatchGetItem', { 'RequestItems' =>
                                      {
                                        'User' => {
-                                         'Keys' => [{ 'HashKeyElement' => { 'S' => '1' }},
-                                                    { 'HashKeyElement' => { 'S' => '2' }}]
+                                         'Keys' => [{ 'id' => { 'S' => '1' }},
+                                                    { 'id' => { 'S' => '2' }}]
                                        },
                                        'Table1' => {
-                                         'Keys' => [{'HashKeyElement' => { 'S' => 'test' },
-                                                      'RangeKeyElement' => { 'N' => '11' }}],
+                                         'Keys' => [{'AttributeName1' => { 'S' => 'test' },
+                                                      'AttributeName2' => { 'N' => '11' }}],
                                          'AttributesToGet' => ['AttributeName1', 'AttributeName2']
                                        }
                                      }})
 
         response.should eq({"Responses"=>
                              {"User"=>
-                               {"ConsumedCapacityUnits"=>1,
-                                 "Items"=>[{"id"=>{"S"=>"1"}}, {"id"=>{"S"=>"2"}}]},
+                               [{"id"=>{"S"=>"1"}}, {"id"=>{"S"=>"2"}}],
                                "Table1"=>
-                               {"ConsumedCapacityUnits"=>1,
-                                 "Items"=>
-                                 [{"AttributeName1"=>{"S"=>"test"},
-                                    "AttributeName2"=>{"N"=>"11"}}]}},
+                               [{"AttributeName1"=>{"S"=>"test"},
+                                   "AttributeName2"=>{"N"=>"11"}}]},
                              "UnprocessedKeys"=>{}})
       end
 
@@ -231,15 +316,15 @@ module FakeDynamo
         response = subject.process('BatchGetItem', { 'RequestItems' =>
                                      {
                                        'User' => {
-                                         'Keys' => [{ 'HashKeyElement' => { 'S' => '1' }},
-                                                    { 'HashKeyElement' => { 'S' => 'asd' }}]
+                                         'Keys' => [{ 'id' => { 'S' => '1' }},
+                                                    { 'id' => { 'S' => 'asd' }}]
                                        }
-                                     }})
+                                     },
+                                     'ReturnConsumedCapacity' => 'TOTAL'})
         response.should eq({"Responses"=>
-                             {"User"=>
-                               {"ConsumedCapacityUnits"=>1,
-                                 "Items"=>[{"id"=>{"S"=>"1"}}]}},
-                             "UnprocessedKeys"=>{}})
+                             {"User"=> [{"id"=>{"S"=>"1"}}]},
+                             "UnprocessedKeys"=>{},
+                             "ConsumedCapacity" => ['CapacityUnits' => 1, 'TableName' => 'User']})
       end
 
       it 'should fail if table not found' do
@@ -247,8 +332,8 @@ module FakeDynamo
           subject.process('BatchGetItem', { 'RequestItems' =>
                             {
                               'xxx' => {
-                                'Keys' => [{ 'HashKeyElement' => { 'S' => '1' }},
-                                           { 'HashKeyElement' => { 'S' => 'asd' }}]}
+                                'Keys' => [{ 'AttributeName1' => { 'S' => '1' }},
+                                           { 'AttributeName1' => { 'S' => 'asd' }}]}
                             }})
         }.to raise_error(FakeDynamo::ResourceNotFoundException)
       end
@@ -261,6 +346,8 @@ module FakeDynamo
         db
       end
 
+      let(:consumed_capacity) { {'ConsumedCapacity' => { 'CapacityUnits' => 1, 'TableName' => 'User' }} }
+
       it 'should validate payload' do
         expect {
           subject.process('BatchWriteItem', {})
@@ -271,7 +358,7 @@ module FakeDynamo
         expect {
           subject.process('BatchWriteItem', {
                             'RequestItems' => {
-                              'xxx' => ['DeleteRequest' => { 'Key' => { 'HashKeyElement' => { 'S' => 'ananth' }}}]
+                              'xxx' => ['DeleteRequest' => { 'Key' => { 'AttributeName1' => { 'S' => 'ananth' }}}]
                             }
                           })
         }.to raise_error(FakeDynamo::ResourceNotFoundException, /table.*not.*found/i)
@@ -281,8 +368,8 @@ module FakeDynamo
         expect {
         subject.process('BatchWriteItem', {
                           'RequestItems' => {
-                            'User' => [{ 'DeleteRequest' => { 'Key' => { 'HashKeyElement' => { 'S' => 'ananth' }}}},
-                                       { 'DeleteRequest' => { 'Key' => { 'HashKeyElement' => { 'S' => 'ananth' }}}}]
+                            'User' => [{ 'DeleteRequest' => { 'Key' => { 'id' => { 'S' => 'ananth' }}}},
+                                       { 'DeleteRequest' => { 'Key' => { 'id' => { 'S' => 'ananth' }}}}]
                           }
                         })
         }.to raise_error(FakeDynamo::ValidationException, /duplicate/i)
@@ -290,7 +377,7 @@ module FakeDynamo
         expect {
           subject.process('BatchWriteItem', {
                             'RequestItems' => {
-                              'User' => [{ 'DeleteRequest' => { 'Key' => { 'HashKeyElement' => { 'S' => 'ananth' }}}},
+                              'User' => [{ 'DeleteRequest' => { 'Key' => { 'id' => { 'S' => 'ananth' }}}},
                                          {'PutRequest' => {'Item' => { 'id' => { 'S' => 'ananth'}}}}]
                             }
                           })
@@ -310,31 +397,38 @@ module FakeDynamo
         response = subject.process('BatchWriteItem', {
                                      'RequestItems' => {
                                        'User' => [{'PutRequest' => {'Item' => { 'id' => { 'S' => 'ananth'}}}}]
-                                     }
+                                     },
+                                     'ReturnConsumedCapacity' => 'TOTAL'
                                    })
-
-        response['Responses'].should eq('User' => { 'ConsumedCapacityUnits' => 1 })
+        response['ItemCollectionMetrics'].should be_nil
+        response.should eq('ConsumedCapacity' => [consumed_capacity['ConsumedCapacity']],
+                            'UnprocessedItems' => {})
 
         response = subject.get_item({'TableName' => 'User',
-                                      'Key' => {'HashKeyElement' => { 'S' => 'ananth'}}})
+                                      'Key' => {'id' => { 'S' => 'ananth'}}})
 
         response['Item']['id'].should eq('S' => 'ananth')
 
-        subject.process('BatchWriteItem', {
-                          'RequestItems' => {
-                            'User' => [{ 'DeleteRequest' => { 'Key' => { 'HashKeyElement' => { 'S' => 'ananth' }}}}]
-                          }
-                        })
+        response = subject.process('BatchWriteItem', {
+                                     'RequestItems' => {
+                                       'User' => [{ 'DeleteRequest' => { 'Key' => { 'id' => { 'S' => 'ananth' }}}}]
+                                     },
+                                     'ReturnItemCollectionMetrics' => 'SIZE'
+                                   })
+
+        response['ItemCollectionMetrics'].should_not be_nil
 
         response = subject.get_item({'TableName' => 'User',
-                                      'Key' => {'HashKeyElement' => { 'S' => 'ananth'}}})
+                                      'Key' => {'id' => { 'S' => 'ananth'}},
+                                      'ReturnConsumedCapacity' => 'TOTAL'})
+
+        response.should eq(consumed_capacity)
 
-        response.should eq({"ConsumedCapacityUnits"=>1})
       end
 
       it 'fails it the requested operation is more than 25' do
         expect {
-          requests = (1..26).map { |i| { 'DeleteRequest' => { 'Key' => { 'HashKeyElement' => { 'S' => "ananth#{i}" }}}} }
+          requests = (1..26).map { |i| { 'DeleteRequest' => { 'Key' => { 'id' => { 'S' => "ananth#{i}" }}}} }
 
           subject.process('BatchWriteItem', {
                             'RequestItems' => {
@@ -342,7 +436,7 @@ module FakeDynamo
                             }
                           })
 
-        }.to raise_error(FakeDynamo::ValidationException, /too many items/i)
+        }.to raise_error(FakeDynamo::ValidationException, /within.*25/i)
       end
 
       it 'should fail on request size greater than 1 mb' do

data/spec/fake_dynamo/server_spec.rb

@@ -7,9 +7,12 @@ module FakeDynamo
     let(:data) do
       {
         "TableName" => "Table1",
+        "AttributeDefinitions" =>
+        [{"AttributeName" => "AttributeName1","AttributeType" => "S"},
+         {"AttributeName" => "AttributeName2","AttributeType" => "N"}],
         "KeySchema" =>
-        {"HashKeyElement" => {"AttributeName" => "AttributeName1","AttributeType" => "S"},
-          "RangeKeyElement" => {"AttributeName" => "AttributeName2","AttributeType" => "N"}},
+        [{"AttributeName" => "AttributeName1","KeyType" => "HASH"},
+         {"AttributeName" => "AttributeName2","KeyType" => "RANGE"}],
         "ProvisionedThroughput" => {"ReadCapacityUnits" => 5,"WriteCapacityUnits" => 10}
       }
     end

data/spec/fake_dynamo/storage_spec.rb

@@ -6,8 +6,10 @@ module FakeDynamo
 
     let(:table) do
       {"TableName" => "User",
+        "AttributeDefinitions" =>
+        [{"AttributeName" => "id","AttributeType" => "S"}],
         "KeySchema" =>
-        {"HashKeyElement" => {"AttributeName" => "id","AttributeType" => "S"}},
+        [{"AttributeName" => "id","KeyType" => "HASH"}],
         "ProvisionedThroughput" => {"ReadCapacityUnits" => 5,"WriteCapacityUnits" => 10}
       }
     end