fake_dynamo 0.0.1

data/lib/fake_dynamo/attribute.rb

@@ -0,0 +1,54 @@
+module FakeDynamo
+  class Attribute
+    attr_accessor :name, :value, :type
+
+    def initialize(name, value, type)
+      @name, @value, @type = name, value, type
+    end
+
+    def description
+      {
+        'AttributeName' => name,
+        'AttributeType' => type
+      }
+    end
+
+    def as_hash
+      { @name => { @type => @value } }
+    end
+
+    def ==(attribute)
+      @name == attribute.name &&
+        @value == attribute.value &&
+        @type == attribute.type
+    end
+
+    def <=>(other)
+      if @type == 'N'
+        @value.to_i <=> other.value.to_i
+      else
+        @value <=> other.value
+      end
+    end
+
+    def eql?(attribute)
+      return false unless attribute.kind_of? Attribute
+
+      self == attribute
+    end
+
+    def hash
+      name.hash ^ value.hash ^ type.hash
+    end
+
+    class << self
+      def from_data(data)
+        Attribute.new(data['AttributeName'], nil, data['AttributeType'])
+      end
+
+      def from_hash(name, hash)
+        Attribute.new(name, hash.values.first, hash.keys.first)
+      end
+    end
+  end
+end

data/lib/fake_dynamo/db.rb

@@ -0,0 +1,113 @@
+module FakeDynamo
+  class DB
+
+    include Validation
+
+    attr_reader :tables
+
+    class << self
+      def instance
+        @db ||= DB.new
+      end
+    end
+
+    def initialize
+      @tables = {}
+    end
+
+    def process(operation, data)
+      validate_payload(operation, data)
+      operation = operation.underscore
+      self.send operation, data
+    end
+
+    def create_table(data)
+      table_name = data['TableName']
+      raise ResourceInUseException, "Duplicate table name: #{table_name}" if tables[table_name]
+
+      table = Table.new(data)
+      tables[table_name] = table
+      response = table.description
+      table.activate
+      response
+    end
+
+    def describe_table(data)
+      table = find_table(data['TableName'])
+      table.describe_table
+    end
+
+    def delete_table(data)
+      table_name = data['TableName']
+      table = find_table(table_name)
+      tables.delete(table_name)
+      table.delete
+    end
+
+    def list_tables(data)
+      start_table = data['ExclusiveStartTableName']
+      limit = data['Limit']
+
+      all_tables = tables.keys
+      start = 0
+
+      if start_table
+        if i = all_tables.index(start_table)
+          start = i + 1
+        end
+      end
+
+      limit ||= all_tables.size
+      result_tables = all_tables[start, limit]
+      response = { 'TableNames' => result_tables }
+
+      if (start + limit ) < all_tables.size
+        last_table = all_tables[start + limit -1]
+        response.merge!({ 'LastEvaluatedTableName' => last_table })
+      end
+      response
+    end
+
+    def update_table(data)
+      table = find_table(data['TableName'])
+      table.update(data['ProvisionedThroughput']['ReadCapacityUnits'], data['ProvisionedThroughput']['WriteCapacityUnits'])
+    end
+
+    def self.delegate_to_table(*methods)
+      methods.each do |method|
+        define_method(method) do |data|
+          find_table(data['TableName']).send(method, data)
+        end
+      end
+    end
+
+    delegate_to_table :put_item, :get_item, :delete_item, :update_item, :query, :scan
+
+
+    def batch_get_item(data)
+      response = {}
+
+      data['RequestItems'].each do |table_name, table_data|
+        table = find_table(table_name)
+
+        unless response[table_name]
+          response[table_name] = { 'ConsumedCapacityUnits' => 1, 'Items' => [] }
+        end
+
+        table_data['Keys'].each do |key|
+          if item_hash = table.get_raw_item(key, table_data['AttributesToGet'])
+            response[table_name]['Items'] << item_hash
+          end
+        end
+      end
+
+      { 'Responses' => response, 'UnprocessedKeys' => {}}
+    end
+
+    private
+    def find_table(table_name)
+      tables[table_name] or raise ResourceNotFoundException, "Table : #{table_name} not found"
+    end
+
+  end
+end

data/lib/fake_dynamo/exceptions.rb

@@ -0,0 +1,57 @@
+module FakeDynamo
+  class Error < ::StandardError
+
+    class_attribute :description, :type, :status
+
+    self.type = 'com.amazon.dynamodb.v20111205'
+    self.status = 400
+
+    attr_reader :detail
+
+    def initialize(detail='')
+      @detail = detail
+      super(detail)
+    end
+
+    def response
+      {
+        '__type' => "#{self.class.type}##{class_name}",
+        'message' => "#{self.class.description}: #{@detail}"
+      }
+    end
+
+    def class_name
+      self.class.name.split('::').last
+    end
+
+    def status
+      self.class.status
+    end
+  end
+
+  class UnknownOperationException < Error
+    self.type = 'com.amazon.coral.service'
+    self.description = ''
+  end
+
+  class InvalidParameterValueException < Error
+    self.description = 'invalid parameter'
+  end
+
+  class ResourceNotFoundException < Error
+    self.description = 'Requested resource not found'
+  end
+
+  class ResourceInUseException < Error
+    self.description = 'Attempt to change a resource which is still in use'
+  end
+
+  class ValidationException < Error
+    self.description = 'Validation error detected'
+    self.type = 'com.amazon.coral.validate'
+  end
+
+  class ConditionalCheckFailedException < Error
+    self.description = 'The conditional request failed'
+  end
+end

data/lib/fake_dynamo/filter.rb

@@ -0,0 +1,110 @@
+module FakeDynamo
+  module Filter
+    include Validation
+
+    def comparison_filter(value_list, size, target_attribute, fail_on_type_mismatch, supported_types, comparator)
+
+      validate_size(value_list, size)
+
+      if fail_on_type_mismatch
+        value_list.each do |value|
+          validate_type(value, target_attribute)
+        end
+      end
+
+      value_attribute_list = value_list.map do |value|
+        value_attribute = Attribute.from_hash(target_attribute.name, value)
+        validate_supported_types(value_attribute, supported_types)
+        value_attribute
+      end
+
+      value_attribute_list.each do |value_attribute|
+        return false if target_attribute.type != value_attribute.type
+      end
+
+      if target_attribute.type == 'N'
+        comparator.call(target_attribute.value.to_i, *value_attribute_list.map(&:value).map(&:to_i))
+      else
+        comparator.call(target_attribute.value, *value_attribute_list.map(&:value))
+      end
+    end
+
+    def validate_supported_types(value_attribute, supported_types)
+      unless supported_types.include? value_attribute.type
+        raise ValidationException, "The attempted filter operation is not supported for the provided type"
+      end
+    end
+
+    def validate_size(value_list, size)
+      if (size.kind_of? Range and (not (size.include? value_list.size))) or
+          (size.kind_of? Fixnum and value_list.size != size)
+        raise ValidationException, "The attempted filter operation is not supported for the provided filter argument count"
+      end
+    end
+
+    def self.def_filter(name, size, supported_types, &comparator)
+      define_method "#{name}_filter" do |value_list, target_attribute, fail_on_type_mismatch|
+        comparison_filter(value_list, size, target_attribute, fail_on_type_mismatch, supported_types, comparator)
+      end
+    end
+
+    def_filter(:eq, 1, ['N', 'S'], &:==)
+    def_filter(:le, 1, ['N', 'S'], &:<=)
+    def_filter(:lt, 1, ['N', 'S'], &:<)
+    def_filter(:ge, 1, ['N', 'S'], &:>=)
+    def_filter(:gt, 1, ['N', 'S'], &:>)
+    def_filter(:begins_with, 1, ['S'], &:start_with?)
+    def_filter(:between, 2, ['N', 'S'], &:between?)
+    def_filter(:ne, 1, ['N', 'S'], &:!=)
+
+    def not_null_filter(value_list, target_attribute,  fail_on_type_mismatch)
+      not target_attribute.nil?
+    end
+
+    def null_filter(value_list, target_attribute, fail_on_type_mismatch)
+      target_attribute.nil?
+    end
+
+    def contains_filter(value_list, target_attribute, fail_on_type_mismatch)
+      validate_size(value_list, 1)
+      value_attribute = Attribute.from_hash(target_attribute.name, value_list.first)
+      validate_supported_types(value_attribute, ['N', 'S'])
+
+      if ((value_attribute.type == 'S' and
+           (target_attribute.type == 'S' or target_attribute.type == 'SS')) or
+          (value_attribute.type == 'N' and target_attribute.type == 'NS'))
+        target_attribute.value.include?(value_attribute.value)
+      end
+    end
+
+    def not_contains_filter(value_list, target_attribute, fail_on_type_mismatch)
+      validate_size(value_list, 1)
+      value_attribute = Attribute.from_hash(target_attribute.name, value_list.first)
+      validate_supported_types(value_attribute, ['N', 'S'])
+
+      if ((value_attribute.type == 'S' and
+           (target_attribute.type == 'S' or target_attribute.type == 'SS')) or
+          (value_attribute.type == 'N' and target_attribute.type == 'NS'))
+        !target_attribute.value.include?(value_attribute.value)
+      end
+    end
+
+    INF = 1.0/0.0
+
+    def in_filter(value_list, target_attribute, fail_on_type_mismatch)
+      validate_size(value_list, (1..INF))
+
+      value_attribute_list = value_list.map do |value|
+        value_attribute = Attribute.from_hash(target_attribute.name, value)
+        validate_supported_types(value_attribute, ['N', 'S'])
+        value_attribute
+      end
+
+      value_attribute_list.each do |value_attribute|
+        return true if value_attribute == target_attribute
+      end
+
+      false
+    end
+  end
+end

data/lib/fake_dynamo/item.rb

@@ -0,0 +1,102 @@
+module FakeDynamo
+  class Item
+    include Validation
+    attr_accessor :key, :attributes
+
+    class << self
+      def from_data(data, key_schema)
+        item = Item.new
+        item.key = Key.from_schema(data, key_schema)
+
+        item.attributes = {}
+        data.each do |name, value|
+          unless item.key[name]
+            item.attributes[name] = Attribute.from_hash(name, value)
+          end
+        end
+        item
+      end
+
+      def from_key(key)
+        item = Item.new
+        item.key = key
+        item.attributes = {}
+        item
+      end
+    end
+
+
+    def [](name)
+      attributes[name] or key[name]
+    end
+
+    def as_hash
+      result = {}
+      result.merge!(key.as_hash)
+      @attributes.each do |name, attribute|
+        result.merge!(attribute.as_hash)
+      end
+      result
+    end
+
+    def update(name, data)
+      if key[name]
+        raise ValidationException, "Cannot update attribute #{name}. This attribute is part of the key"
+      end
+
+      new_value = data['Value']
+      action = data['Action'] || 'PUT'
+
+      unless available_actions.include? action
+        raise ValidationException, "Unknown action '#{action}' in AttributeUpdates.#{name}"
+      end
+
+      if (not new_value) and action != 'DELETE'
+        raise ValidationException, "Only DELETE action is allowed when no attribute value is specified"
+      end
+
+      self.send(action.downcase, name, new_value)
+    end
+
+    def available_actions
+      %w[ PUT ADD DELETE ]
+    end
+
+    def put(name, value)
+      attributes[name] = Attribute.from_hash(name, value)
+    end
+
+    def delete(name, value)
+      if not value
+        attributes.delete(name)
+      elsif old_attribute = attributes[name]
+        validate_type(value, old_attribute)
+        unless ["SS", "NS"].include? old_attribute.type
+          raise ValidationException, "Action DELETE is not supported for type #{old_attribute.type}"
+        end
+        attribute = Attribute.from_hash(name, value)
+        old_attribute.value -= attribute.value
+      end
+    end
+
+    def add(name, value)
+      attribute = Attribute.from_hash(name, value)
+
+      unless ["N", "SS", "NS"].include? attribute.type
+        raise ValidationException, "Action ADD is not supported for type #{attribute.type}"
+      end
+
+      if old_attribute = attributes[name]
+        validate_type(value, old_attribute)
+        case attribute.type
+        when "N"
+          old_attribute.value = (old_attribute.value.to_i + attribute.value.to_i).to_s
+        else
+          old_attribute.value += attribute.value
+        end
+      else
+        attributes[name] = attribute
+      end
+    end
+  end
+end

data/lib/fake_dynamo/key.rb

@@ -0,0 +1,71 @@
+module FakeDynamo
+  class Key
+    extend Validation
+
+    attr_accessor :primary, :range
+
+    class << self
+      def from_data(key_data, key_schema)
+        key = Key.new
+        validate_key_data(key_data, key_schema)
+        key.primary = Attribute.from_hash(key_schema.hash_key.name, key_data['HashKeyElement'])
+
+        if key_schema.range_key
+          key.range = Attribute.from_hash(key_schema.range_key.name, key_data['RangeKeyElement'])
+        end
+        key
+      end
+
+      def from_schema(data, key_schema)
+        key = Key.new
+        validate_key_schema(data, key_schema)
+        key.primary = create_attribute(key_schema.hash_key, data)
+
+        if key_schema.range_key
+          key.range = create_attribute(key_schema.range_key, data)
+        end
+        key
+      end
+
+      def create_attribute(key, data)
+        name = key.name
+        attr = Attribute.from_hash(name, data[name])
+        attr
+      end
+    end
+
+    def [](name)
+      return @primary if @primary.name == name
+      return @range if @range and @range.name == name
+      nil
+    end
+
+    def eql?(key)
+      return false unless key.kind_of? Key
+
+      @primary == key.primary &&
+        @range == key.range
+    end
+
+    def hash
+      primary.hash ^ range.hash
+    end
+
+    def as_hash
+      result = @primary.as_hash
+      if @range
+        result.merge!(@range.as_hash)
+      end
+      result
+    end
+
+    def as_key_hash
+      result = { 'HashKeyElement' => { @primary.type => @primary.value }}
+      if @range
+        result.merge!({'RangeKeyElement' => { @range.type => @range.value }})
+      end
+      result
+    end
+
+  end
+end