fake_dynamo 0.1.4 → 0.2.0

data/spec/fake_dynamo/table_spec.rb

@@ -6,9 +6,21 @@ module FakeDynamo
     let(:data) do
       {
         "TableName" => "Table1",
+        "AttributeDefinitions" =>
+        [{"AttributeName" => "AttributeName1","AttributeType" => "S"},
+          {"AttributeName" => "AttributeName2","AttributeType" => "N"},
+          {"AttributeName" => "AttributeName3","AttributeType" => "N"}],
         "KeySchema" =>
-        {"HashKeyElement" => {"AttributeName" => "AttributeName1","AttributeType" => "S"},
-          "RangeKeyElement" => {"AttributeName" => "AttributeName2","AttributeType" => "N"}},
+        [{"AttributeName" => "AttributeName1", "KeyType" => "HASH"},
+          {"AttributeName" => "AttributeName2", "KeyType" => "RANGE"}],
+        "LocalSecondaryIndexes" => [{
+            "IndexName" => "one",
+            "KeySchema" => [{"AttributeName" => "AttributeName1", "KeyType" => "HASH"},
+              {"AttributeName" => "AttributeName3", "KeyType" => "RANGE"}],
+            "Projection" => {
+              "ProjectionType" => "ALL"
+            }
+          }],
         "ProvisionedThroughput" => {"ReadCapacityUnits" => 5,"WriteCapacityUnits" => 10}
       }
     end
@@ -21,18 +33,21 @@ module FakeDynamo
           'AttributeName3' => { 'S' => "another" },
           'binary' => { 'B' => Base64.encode64("binary") },
           'binary_set' => { 'BS' => [Base64.encode64("binary")] }
-        }}
+        },
+        'ReturnConsumedCapacity' => 'TOTAL'
+      }
     end
 
     let(:key) do
       {'TableName' => 'Table1',
         'Key' => {
-          'HashKeyElement' => { 'S' => 'test' },
-          'RangeKeyElement' => { 'N' => '11' }
-        }}
+          'AttributeName1' => { 'S' => 'test' },
+          'AttributeName2' => { 'N' => '11' }
+        },
+        'ReturnConsumedCapacity' => 'TOTAL'}
     end
 
-    let(:consumed_capacity) { { 'ConsumedCapacityUnits' => 1 } }
+    let(:consumed_capacity) { {'ConsumedCapacity' => { 'CapacityUnits' => 1, 'TableName' => 'Table1' }} }
 
     subject { Table.new(data) }
 
@@ -102,8 +117,8 @@ module FakeDynamo
                            }})
         response = subject.get_item({'TableName' => 'Table1',
                                       'Key' => {
-                                        'HashKeyElement' => { 'S' => 'test' },
-                                        'RangeKeyElement' => { 'N' => '3' }
+                                        'AttributeName1' => { 'S' => 'test' },
+                                        'AttributeName2' => { 'N' => '3' }
                                       }})
 
         response['Item']['AttributeName3'].should eq('N' => '4.44444')
@@ -229,23 +244,24 @@ module FakeDynamo
       it 'should return empty when the key is not found' do
         response = subject.get_item({'TableName' => 'Table1',
                                       'Key' => {
-                                        'HashKeyElement' => { 'S' => 'xxx' },
-                                        'RangeKeyElement' => { 'N' => '11' }
+                                        'AttributeName1' => { 'S' => 'xxx' },
+                                        'AttributeName2' => { 'N' => '11' }
                                       }
                                     })
-        response.should eq(consumed_capacity)
+        response.should eq({})
       end
 
       it 'should filter attributes' do
         response = subject.get_item({'TableName' => 'Table1',
                                       'Key' => {
-                                        'HashKeyElement' => { 'S' => 'test' },
-                                        'RangeKeyElement' => { 'N' => '11' }
+                                        'AttributeName1' => { 'S' => 'test' },
+                                        'AttributeName2' => { 'N' => '11' }
                                       },
-                                      'AttributesToGet' => ['AttributeName3', 'xxx']
+                                      'AttributesToGet' => ['AttributeName3', 'xxx'],
+                                      'ReturnConsumedCapacity' => 'TOTAL'
                                     })
-        response.should eq({ 'Item' => { 'AttributeName3' => { 'S' => 'another'}},
-                             'ConsumedCapacityUnits' => 1})
+        response.should eq({ 'Item' => { 'AttributeName3' => { 'S' => 'another'}}}
+            .merge(consumed_capacity))
       end
     end
 
@@ -316,7 +332,7 @@ module FakeDynamo
         subject.get_item(key).should include('Item' => item['Item'])
 
         expect do
-          key['Key']['HashKeyElement']['S'] = 'unknown'
+          key['Key']['AttributeName1']['S'] = 'unknown'
           put['AttributeUpdates'].merge!({ 'xx' => { 'Value' => { 'N' => 'one'}, 'Action' => 'ADD'}})
           subject.update_item(key.merge(put))
         end.to raise_error(ValidationException, /numeric/)
@@ -332,7 +348,7 @@ module FakeDynamo
       end
 
       it "should create new item if the key doesn't exist" do
-        key['Key']['HashKeyElement']['S'] = 'new'
+        key['Key']['AttributeName1']['S'] = 'new'
         subject.update_item(key.merge(put))
         subject.get_item(key).should include( "Item"=>
                                               {"AttributeName1"=>{"S"=>"new"},
@@ -341,7 +357,7 @@ module FakeDynamo
       end
 
       it "shouldn't create a new item if key doesn't exist and action is delete" do
-        key['Key']['HashKeyElement']['S'] = 'new'
+        key['Key']['AttributeName1']['S'] = 'new'
         subject.update_item(key.merge(delete))
         subject.get_item(key).should eq(consumed_capacity)
       end
@@ -384,12 +400,12 @@ module FakeDynamo
     context '#query' do
       subject do
         t = Table.new(data)
-        t.put_item(item)
         (1..3).each do |i|
           (15.downto(1)).each do |j|
             next if j.even?
             item['Item']['AttributeName1']['S'] = "att#{i}"
             item['Item']['AttributeName2']['N'] = j.to_s
+            item['Item']['AttributeName3'] = {'N' => j.to_s}
             t.put_item(item)
           end
         end
@@ -400,23 +416,96 @@ module FakeDynamo
         {
           'TableName' => 'Table1',
           'Limit' => 5,
-          'HashKeyValue' => {'S' => 'att1'},
-          'RangeKeyCondition' => {
-            'AttributeValueList' => [{'N' => '1'}],
-            'ComparisonOperator' => 'GT'
+          'KeyConditions' => {
+            'AttributeName1' => {
+              'AttributeValueList' => [{'S' => 'att1'}],
+              'ComparisonOperator' => 'EQ'
+            },
+            'AttributeName2' => {
+              'AttributeValueList' => [{'N' => '1'}],
+              'ComparisonOperator' => 'GT'
+            }
+          },
+          'ScanIndexForward' => true
+        }
+      end
+
+      let(:index_query) do
+        {
+          'TableName' => 'Table1',
+          'Limit' => 5,
+          'IndexName' => 'one',
+          'KeyConditions' => {
+            'AttributeName1' => {
+              'AttributeValueList' => [{'S' => 'att1'}],
+              'ComparisonOperator' => 'EQ'
+            },
+            'AttributeName3' => {
+              'AttributeValueList' => [{'N' => '1'}],
+              'ComparisonOperator' => 'GT'
+            }
           },
           'ScanIndexForward' => true
         }
       end
 
+      context 'query projection' do
+        let(:query) do
+          {
+            'TableName' => 'Table1',
+            'Limit' => 5,
+            'Select' => 'ALL_PROJECTED_ATTRIBUTES',
+            'IndexName' => 'one',
+            'KeyConditions' => {
+              'AttributeName1' => {
+                'AttributeValueList' => [{'S' => 'test'}],
+                'ComparisonOperator' => 'EQ'
+              }
+            },
+            'ScanIndexForward' => true
+          }
+        end
+
+        let(:projection) { data['LocalSecondaryIndexes'][0]['Projection'] }
+
+        it 'should return all attributes' do
+          t = Table.new(data)
+          t.put_item(item)
+          response = t.query(query)
+          response['Items'].first.keys.size.should eq(5)
+        end
+
+        it 'should return return only the keys' do
+          projection['ProjectionType'] = 'KEYS_ONLY'
+          t = Table.new(data)
+          t.put_item(item)
+          response = t.query(query)
+          response['Items'].first.keys.size.should eq(3)
+        end
+
+        it 'should return return only the non key attributes' do
+          projection['ProjectionType'] = 'INCLUDE'
+          projection['NonKeyAttributes'] = ['binary_set']
+          t = Table.new(data)
+          t.put_item(item)
+          response = t.query(query)
+          response['Items'].first.keys.size.should eq(4)
+        end
+      end
+
+
+
       it 'should not allow count and attributes_to_get simutaneously' do
         expect {
-          subject.query({'Count' => 0, 'AttributesToGet' => ['xx']})
+          subject.query({'Select' => 'COUNT', 'AttributesToGet' => ['xx']})
         }.to raise_error(ValidationException, /count/i)
       end
 
       it 'should not allow to query on a table without rangekey' do
-        data['KeySchema'].delete('RangeKeyElement')
+        data['KeySchema'].delete_at(1)
+        data['AttributeDefinitions'].delete_at(1)
+        data['AttributeDefinitions'].delete_at(1)
+        data.delete('LocalSecondaryIndexes')
         t = Table.new(data)
         expect {
           t.query(query)
@@ -434,13 +523,34 @@ module FakeDynamo
         result['Count'].should eq(5)
       end
 
+      it 'should fail if index name is missing' do
+        index_query.delete('IndexName')
+        expect { subject.query(index_query) }.to raise_error(ValidationException, /missed.*key/i)
+      end
+
+      it 'should fail if hash condition is missing' do
+        index_query['KeyConditions'].delete('AttributeName1')
+        expect { subject.query(index_query) }.to raise_error(ValidationException, /missed.*key.*schema/i)
+      end
+
+      it 'should fail if hash condition is not EQ' do
+        index_query['KeyConditions']['AttributeName1']['ComparisonOperator'] = 'GT'
+        expect { subject.query(index_query) }.to raise_error(ValidationException, /condition not supported/i)
+      end
+
+      it 'should handle index query' do
+        result = subject.query(index_query)
+        result['Count'].should eq(5)
+      end
+
+
       it 'should handle scanindexforward' do
         result = subject.query(query)
         result['Items'].first['AttributeName2'].should eq({'N' => '3'})
         result = subject.query(query.merge({'ScanIndexForward' => false}))
         result['Items'].first['AttributeName2'].should eq({'N' => '15'})
 
-        query['ExclusiveStartKey'] = { 'HashKeyElement' => { 'S' => 'att1' }, 'RangeKeyElement' => { "N" => '7' }}
+        query['ExclusiveStartKey'] = { 'AttributeName1' => { 'S' => 'att1' }, 'AttributeName2' => { "N" => '7' }}
         result = subject.query(query)
         result['Items'][0]['AttributeName1'].should eq({'S' => 'att1'})
         result['Items'][0]['AttributeName2'].should eq({'N' => '9'})
@@ -449,7 +559,7 @@ module FakeDynamo
         result['Items'][0]['AttributeName1'].should eq({'S' => 'att1'})
         result['Items'][0]['AttributeName2'].should eq({'N' => '5'})
 
-        query['ExclusiveStartKey'] = { 'HashKeyElement' => { 'S' => 'att1' }, 'RangeKeyElement' => { "N" => '8' }}
+        query['ExclusiveStartKey'] = { 'AttributeName1' => { 'S' => 'att1' }, 'AttributeName2' => { "N" => '8' }}
         result = subject.query(query)
         result['Items'][0]['AttributeName1'].should eq({'S' => 'att1'})
         result['Items'][0]['AttributeName2'].should eq({'N' => '9'})
@@ -461,7 +571,7 @@ module FakeDynamo
 
       it 'should return lastevaluated key' do
         result = subject.query(query)
-        result['LastEvaluatedKey'].should == {"HashKeyElement"=>{"S"=>"att1"}, "RangeKeyElement"=>{"N"=>"11"}}
+        result['LastEvaluatedKey'].should == {"AttributeName1"=>{"S"=>"att1"}, "AttributeName2"=>{"N"=>"11"}}
         result = subject.query(query.merge('Limit' => 100))
         result['LastEvaluatedKey'].should be_nil
 
@@ -471,26 +581,26 @@ module FakeDynamo
       end
 
       it 'should handle exclusive start key' do
-        result = subject.query(query.merge({'ExclusiveStartKey' => {"HashKeyElement"=>{"S"=>"att1"}, "RangeKeyElement"=>{"N"=>"7"}}}))
+        result = subject.query(query.merge({'ExclusiveStartKey' => {"AttributeName1"=>{"S"=>"att1"}, "AttributeName2"=>{"N"=>"7"}}}))
         result['Count'].should eq(4)
         result['Items'].first['AttributeName2'].should eq({'N' => '9'})
-        result = subject.query(query.merge({'ExclusiveStartKey' => {"HashKeyElement"=>{"S"=>"att1"}, "RangeKeyElement"=>{"N"=>"8"}}}))
+        result = subject.query(query.merge({'ExclusiveStartKey' => {"AttributeName1"=>{"S"=>"att1"}, "AttributeName2"=>{"N"=>"8"}}}))
         result['Count'].should eq(4)
         result['Items'].first['AttributeName2'].should eq({'N' => '9'})
-        result = subject.query(query.merge({'ExclusiveStartKey' => {"HashKeyElement"=>{"S"=>"att1"}, "RangeKeyElement"=>{"N"=>"88"}}}))
+        result = subject.query(query.merge({'ExclusiveStartKey' => {"AttributeName1"=>{"S"=>"att1"}, "AttributeName2"=>{"N"=>"88"}}}))
         result['Count'].should eq(0)
         result['Items'].should be_empty
       end
 
 
       it 'should return all elements if not rangekeycondition is given' do
-        query.delete('RangeKeyCondition')
+        query['KeyConditions'].delete('AttributeName2')
         result = subject.query(query)
         result['Count'].should eq(5)
       end
 
       it 'should handle between operator' do
-        query['RangeKeyCondition'] = {
+        query['KeyConditions']['AttributeName2'] = {
           'AttributeValueList' => [{'N' => '1'}, {'N' => '7'}],
             'ComparisonOperator' => 'BETWEEN'
         }
@@ -534,10 +644,22 @@ module FakeDynamo
 
       it 'should not allow count and attributes_to_get simutaneously' do
         expect {
-          subject.scan({'Count' => 0, 'AttributesToGet' => ['xx']})
+          subject.scan({'Select' => 'COUNT', 'AttributesToGet' => ['xx']})
         }.to raise_error(ValidationException, /count/i)
       end
 
+      it 'should only return count' do
+        scan['Select'] = 'COUNT'
+        response = subject.scan(scan)
+        response['Count'].should eq(24)
+        response['Items'].should be_nil
+      end
+
+      it 'should not allow ALL_PROJECTED_ATTRIBUTES' do
+        scan['Select'] = 'ALL_PROJECTED_ATTRIBUTES'
+        expect { subject.scan(scan) }.to raise_error(ValidationException, /querying.*indexname/i)
+      end
+
       it 'should only allow limit greater than zero' do
         expect {
           subject.scan(scan.merge('Limit' => 0))
@@ -555,7 +677,7 @@ module FakeDynamo
       it 'should return lastevaluated key' do
         scan['Limit'] = 5
         result = subject.scan(scan)
-        result['LastEvaluatedKey'].should == {"HashKeyElement"=>{"S"=>"att1"}, "RangeKeyElement"=>{"N"=>"9"}}
+        result['LastEvaluatedKey'].should == {"AttributeName1"=>{"S"=>"att1"}, "AttributeName2"=>{"N"=>"9"}}
         result = subject.scan(scan.merge('Limit' => 100))
         result['LastEvaluatedKey'].should be_nil
 
@@ -565,12 +687,12 @@ module FakeDynamo
       end
 
       it 'should handle ordering' do
-        scan['ExclusiveStartKey'] = { 'HashKeyElement' => { 'S' => 'att2' }, 'RangeKeyElement' => { "N" => '7' }}
+        scan['ExclusiveStartKey'] = { 'AttributeName1' => { 'S' => 'att2' }, 'AttributeName2' => { "N" => '7' }}
         result = subject.scan(scan)
         result['Items'][0]['AttributeName1'].should eq({'S' => 'att2'})
         result['Items'][0]['AttributeName2'].should eq({'N' => '9'})
 
-        scan['ExclusiveStartKey'] = { 'HashKeyElement' => { 'S' => 'att2' }, 'RangeKeyElement' => { "N" => '8' }}
+        scan['ExclusiveStartKey'] = { 'AttributeName1' => { 'S' => 'att2' }, 'AttributeName2' => { "N" => '8' }}
         result['Items'][0]['AttributeName1'].should eq({'S' => 'att2'})
         result['Items'][0]['AttributeName2'].should eq({'N' => '9'})
       end

data/spec/fake_dynamo/validation_spec.rb

@@ -9,9 +9,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
@@ -38,34 +41,30 @@ module FakeDynamo
 
     context '#validate_key_data' do
       let(:schema) do
-        KeySchema.new({'HashKeyElement' => { 'AttributeName' => 'id', 'AttributeType' => 'S'}})
+        KeySchema.new(
+          [{ 'AttributeName' => 'id', 'KeyType' => 'HASH'}],
+          [{"AttributeName" => "id","AttributeType" => "S"}])
       end
 
       let(:schema_with_range) do
-        KeySchema.new({'HashKeyElement' => { 'AttributeName' => 'id', 'AttributeType' => 'S'},
-                        'RangeKeyElement' => { 'AttributeName' => 'time', 'AttributeType' => 'N'}})
+        KeySchema.new(
+          [{ 'AttributeName' => 'id', 'KeyType' => 'HASH'},
+           { 'AttributeName' => 'time', 'KeyType' => 'RANGE'}],
+          [{ 'AttributeName' => 'id', 'AttributeType' => 'S'},
+           { 'AttributeName' => 'time', 'AttributeType' => 'N'}])
       end
 
       it 'should validate the schema' do
-        [[{'HashKeyElement' => { 'N' => '1234' }}, schema, /mismatch/],
-         [{'HashKeyElement' => { 'S' => '1234' }}, schema_with_range, /missing.*range/i],
-         [{'HashKeyElement' => { 'S' => '1234' }, 'RangeKeyElement' => { 'N' => '1234'}}, schema, /not present/],
-         [{'HashKeyElement' => { 'S' => '1234' }, 'RangeKeyElement' => { 'S' => '1234'}}, schema_with_range, /mismatch/]
+        [[{'id' => { 'N' => '1234' }}, schema, /type mismatch/i],
+         [{'id' => { 'S' => '1234' }}, schema_with_range, /not match/i],
+         [{'id' => { 'S' => '1234' }, 'time' => { 'N' => '1234'}}, schema, /not match/i],
+         [{'id' => { 'S' => '1234' }, 'time' => { 'S' => '1234'}}, schema_with_range, /type mismatch/i]
         ].each do |data, schema, message|
           expect do
             subject.validate_key_data(data, schema)
           end.to raise_error(ValidationException, message)
         end
       end
-
-      it 'should allow null comparison operator' do
-        subject.validate_payload('Scan', {
-          'TableName' => 'Table1',
-          'ScanFilter' => {
-            'age' => { 'ComparisonOperator' => 'NULL' }
-          }
-        })
-      end
     end
 
   end

metadata

@@ -1,57 +1,49 @@
 --- !ruby/object:Gem::Specification
 name: fake_dynamo
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
+  prerelease: 
 platform: ruby
 authors:
 - Anantha Kumaran
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-10 00:00:00.000000000 Z
+date: 2013-04-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sinatra
-  requirement: !ruby/object:Gem::Requirement
+  requirement: &70301515417000 !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+  version_requirements: *70301515417000
 - !ruby/object:Gem::Dependency
   name: activesupport
-  requirement: !ruby/object:Gem::Requirement
+  requirement: &70301515416500 !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+  version_requirements: *70301515416500
 - !ruby/object:Gem::Dependency
   name: json
-  requirement: !ruby/object:Gem::Requirement
+  requirement: &70301515416080 !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+  version_requirements: *70301515416080
 description: 
 email:
 - ananthakumaran@gmail.com
@@ -72,6 +64,7 @@ files:
 - fake_dynamo.gemspec
 - lib/fake_dynamo.rb
 - lib/fake_dynamo/api.yml
+- lib/fake_dynamo/api_2012-08-10.yml
 - lib/fake_dynamo/attribute.rb
 - lib/fake_dynamo/db.rb
 - lib/fake_dynamo/exceptions.rb
@@ -79,6 +72,8 @@ files:
 - lib/fake_dynamo/item.rb
 - lib/fake_dynamo/key.rb
 - lib/fake_dynamo/key_schema.rb
+- lib/fake_dynamo/local_secondary_index.rb
+- lib/fake_dynamo/projection.rb
 - lib/fake_dynamo/server.rb
 - lib/fake_dynamo/storage.rb
 - lib/fake_dynamo/table.rb
@@ -94,26 +89,27 @@ 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: 2.0.3
+rubygems_version: 1.8.15
 signing_key: 
-specification_version: 4
+specification_version: 3
 summary: local hosted, inmemory fake dynamodb
 test_files:
 - spec/fake_dynamo/db_spec.rb
@@ -124,3 +120,4 @@ test_files:
 - spec/fake_dynamo/table_spec.rb
 - spec/fake_dynamo/validation_spec.rb
 - spec/spec_helper.rb
+has_rdoc: 

checksums.yaml

@@ -1,7 +0,0 @@
----
-SHA1:
-  metadata.gz: 0f4631cc05b44fc6f658eb3a18c89ba2d4f3599b
-  data.tar.gz: 67d433993da543cb68b6eed85ffae822f981a085
-SHA512:
-  metadata.gz: 9b52c4ef7c46f44efe512dfb8a7ce6ebf9f2cce713d1406d1a603226a298cb2c097b76ea0fe3993815c27f24fc5c39e99d4b84538dc14db7ca69bed8b49588a8
-  data.tar.gz: ee52a997e6aeccc0424313925fcf4d5524cb8d823495289de6670677e1f3046299746711455c1a00a9239e0bc83ab2987b214decf5412f4bb12d2f7b925bd03e