lotus-dynamodb 0.1.0

data/lib/lotus/model/adapters/dynamodb_adapter.rb

@@ -0,0 +1,190 @@
+require 'aws-sdk'
+require 'lotus/model/adapters/abstract'
+require 'lotus/model/adapters/implementation'
+require 'lotus/model/adapters/dynamodb/coercer'
+require 'lotus/model/adapters/dynamodb/collection'
+require 'lotus/model/adapters/dynamodb/command'
+require 'lotus/model/adapters/dynamodb/query'
+
+module Lotus
+  module Model
+    module Adapters
+      # Adapter for Amazon DynamoDB.
+      #
+      # @api private
+      # @since 0.1.0
+      class DynamodbAdapter < Abstract
+        include Implementation
+
+        # Initialize the adapter.
+        #
+        # It takes advantage of AWS::DynamoDB::Client to perform all operations.
+        #
+        # @param mapper [Object] the database mapper
+        #
+        # @return [Lotus::Model::Adapters::DynamodbAdapter]
+        #
+        # @see Lotus::Model::Mapper
+        # @see Lotus::Dynamodb::API_VERSION
+        # @see http://docs.aws.amazon.com/AWSRubySDK/latest/AWS/DynamoDB/Client/V20120810.html
+        #
+        # @api private
+        # @since 0.1.0
+        def initialize(mapper)
+          super
+
+          @client = AWS::DynamoDB::Client.new(
+            api_version: Lotus::Dynamodb::API_VERSION
+          )
+          @collections = {}
+        end
+
+        # Creates a record in the database for the given entity.
+        # It assigns the `id` attribute, in case of success.
+        #
+        # @param collection [Symbol] the target collection (it must be mapped)
+        # @param entity [#id=] the entity to create
+        #
+        # @return [Object] the entity
+        #
+        # @api private
+        # @since 0.1.0
+        def create(collection, entity)
+          entity.id = command(collection).create(entity)
+          entity
+        end
+
+        # Updates a record in the database corresponding to the given entity.
+        #
+        # @param collection [Symbol] the target collection (it must be mapped)
+        # @param entity [#id] the entity to update
+        #
+        # @return [Object] the entity
+        #
+        # @api private
+        # @since 0.1.0
+        def update(collection, entity)
+          command(collection).update(entity)
+        end
+
+        # Deletes a record in the database corresponding to the given entity.
+        #
+        # @param collection [Symbol] the target collection (it must be mapped)
+        # @param entity [#id] the entity to delete
+        #
+        # @api private
+        # @since 0.1.0
+        def delete(collection, entity)
+          command(collection).delete(entity)
+        end
+
+        # Deletes all the records from the given collection.
+        #
+        # This works terribly slow at the moment, and this is only useful for
+        # testing small collections. Consider re-creating table from scratch.
+        #
+        # @param collection [Symbol] the target collection (it must be mapped)
+        #
+        # @api private
+        # @since 0.1.0
+        def clear(collection)
+          command(collection).clear
+        end
+
+        # Returns an unique record from the given collection, with the given
+        # id.
+        #
+        # @param collection [Symbol] the target collection (it must be mapped)
+        # @param key [Array] the identity of the object
+        #
+        # @return [Object] the entity
+        #
+        # @api private
+        # @since 0.1.0
+        def find(collection, *key)
+          command(collection).get(key)
+        end
+
+        # This method is not implemented. DynamoDB does not allow
+        # table-wide sorting.
+        #
+        # @see http://stackoverflow.com/a/17495069
+        #
+        # @param collection [Symbol] the target collection (it must be mapped)
+        #
+        # @raise [NotImplementedError]
+        #
+        # @since 0.1.0
+        def first(collection)
+          raise NotImplementedError
+        end
+
+        # This method is not implemented. DynamoDB does not allow
+        # table-wide sorting.
+        #
+        # @see http://stackoverflow.com/a/17495069
+        #
+        # @param collection [Symbol] the target collection (it must be mapped)
+        #
+        # @raise [NotImplementedError]
+        #
+        # @since 0.1.0
+        def last(collection)
+          raise NotImplementedError
+        end
+
+        # Fabricates a command for the given query.
+        #
+        # @param collection [Symbol] the target collection (it must be mapped)
+        #
+        # @return [Lotus::Model::Adapters::Dynamodb::Command]
+        #
+        # @see Lotus::Model::Adapters::Dynamodb::Command
+        #
+        # @api private
+        # @since 0.1.0
+        def command(collection)
+          Dynamodb::Command.new(_collection(collection), _mapped_collection(collection))
+        end
+
+        # Fabricates a query
+        #
+        # @param collection [Symbol] the target collection (it must be mapped)
+        # @param context [Object]
+        # @param blk [Proc] a block of code to be executed in the context of
+        #   the query.
+        #
+        # @return [Lotus::Model::Adapters::Dynamodb::Query]
+        #
+        # @see Lotus::Model::Adapters::Dynamodb::Query
+        #
+        # @api private
+        # @since 0.1.0
+        def query(collection, context = nil, &blk)
+          Dynamodb::Query.new(_collection(collection), _mapped_collection(collection), &blk)
+        end
+
+        private
+
+        # Returns a collection from the given name.
+        #
+        # @param name [Symbol] a name of the collection (it must be mapped)
+        #
+        # @return [Lotus::Model::Adapters::Dynamodb::Collection]
+        #
+        # @see Lotus::Model::Adapters::Dynamodb::Collection
+        #
+        # @api private
+        # @since 0.1.0
+        def _collection(name)
+          @collections[name] ||= Dynamodb::Collection.new(
+            @client,
+            Lotus::Model::Adapters::Dynamodb::Coercer.new(_mapped_collection(name)),
+            name,
+            _identity(name),
+          )
+        end
+      end
+    end
+  end
+end

data/lib/lotus-dynamodb.rb

@@ -0,0 +1,3 @@
+require 'lotus/dynamodb/config'
+require 'lotus/model'
+require 'lotus/model/adapters/dynamodb_adapter'

data/lotus-dynamodb.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'lotus/dynamodb/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lotus-dynamodb'
+  spec.version       = Lotus::Dynamodb::VERSION
+  spec.authors       = ['Dmitry Krasnoukhov']
+  spec.email         = ['dmitry@krasnoukhov.com']
+  spec.summary       = spec.description = %q{Amazon DynamoDB adapter for Lotus::Model}
+  spec.homepage      = 'https://github.com/krasnoukhov/lotus-dynamodb'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'lotus-model', '~> 0.1'
+  spec.add_runtime_dependency 'aws-sdk',     '~> 1.0'
+  spec.add_runtime_dependency 'multi_json',  '~> 1.10'
+
+  spec.add_development_dependency 'bundler',       '~> 1.5'
+  spec.add_development_dependency 'minitest',      '~> 5'
+  spec.add_development_dependency 'minitest-line', '~> 0.6'
+  spec.add_development_dependency 'rake',          '~> 10'
+  spec.add_development_dependency 'fake_dynamo',   '~> 0.2'
+  spec.add_development_dependency 'foreman',       '~> 0.67'
+end

data/test/fixtures.rb

@@ -0,0 +1,75 @@
+DB = AWS::DynamoDB::Client.new(api_version: Lotus::Dynamodb::API_VERSION)
+
+begin
+  DB.create_table(
+    table_name: "test_users",
+    attribute_definitions: [
+      { attribute_name: "id", attribute_type: "S" },
+    ],
+    key_schema: [
+      { attribute_name: "id", key_type: "HASH" },
+    ],
+    provisioned_throughput: {
+      read_capacity_units: 10,
+      write_capacity_units: 10,
+    },
+  )
+
+  DB.create_table(
+    table_name: "test_devices",
+    attribute_definitions: [
+      { attribute_name: "uuid",       attribute_type: "S" },
+      { attribute_name: "created_at", attribute_type: "N" },
+    ],
+    key_schema: [
+      { attribute_name: "uuid",       key_type: "HASH" },
+      { attribute_name: "created_at", key_type: "RANGE" },
+    ],
+    provisioned_throughput: {
+      read_capacity_units: 10,
+      write_capacity_units: 10,
+    },
+  )
+
+  DB.create_table(
+    table_name: "test_purchases",
+    attribute_definitions: [
+      { attribute_name: "region",       attribute_type: "S" },
+      { attribute_name: "created_at",   attribute_type: "N" },
+      { attribute_name: "subtotal",     attribute_type: "N" },
+      { attribute_name: "uuid",         attribute_type: "S" },
+    ],
+    key_schema: [
+      { attribute_name: "region",       key_type: "HASH" },
+      { attribute_name: "created_at",   key_type: "RANGE" },
+    ],
+    local_secondary_indexes: [{
+      index_name: "by_subtotal",
+      key_schema: [
+        { attribute_name: "region",     key_type: "HASH" },
+        { attribute_name: "subtotal",   key_type: "RANGE" },
+      ],
+      projection: {
+        projection_type: "ALL",
+      },
+    }],
+    global_secondary_indexes: [{
+      index_name: "by_uuid",
+      key_schema: [
+        { attribute_name: "uuid",       key_type: "HASH" },
+      ],
+      projection: {
+        projection_type: "ALL",
+      },
+      provisioned_throughput: {
+        read_capacity_units: 10,
+        write_capacity_units: 10,
+      },
+    }],
+    provisioned_throughput: {
+      read_capacity_units: 10,
+      write_capacity_units: 10,
+    },
+  )
+rescue AWS::DynamoDB::Errors::ResourceInUseException
+end

data/test/model/adapters/dynamodb/coercer_test.rb

@@ -0,0 +1,269 @@
+require 'test_helper'
+require 'multi_json'
+
+describe Lotus::Model::Adapters::Dynamodb::Coercer do
+  before do
+    MockEntity = Struct.new(:id) do
+      include Lotus::Entity
+    end
+
+    class MockCollection
+      def attributes
+        { id: [Time, :id] }
+      end
+
+      def identity
+        :id
+      end
+
+      def entity
+        MockEntity
+      end
+    end
+
+    @coercer = Lotus::Model::Adapters::Dynamodb::Coercer.new(MockCollection.new)
+  end
+
+  after do
+    Object.send(:remove_const, :MockEntity)
+  end
+
+  describe '#from_*' do
+    describe 'skipped' do
+      describe 'Float' do
+        let(:subject) { 1.5 }
+
+        it 'remains unchanged' do
+          @coercer.from_float(subject).class.must_equal Float
+          @coercer.from_float(subject).must_equal subject
+        end
+      end
+
+      describe 'Integer' do
+        let(:subject) { 2 }
+
+        it 'remains unchanged' do
+          @coercer.from_integer(subject).class.must_equal Fixnum
+          @coercer.from_integer(subject).must_equal subject
+        end
+      end
+
+      describe 'Set' do
+        let(:subject) { Set.new([1, 2, 3]) }
+
+        it 'remains unchanged' do
+          @coercer.from_set(subject).class.must_equal Set
+          @coercer.from_set(subject).must_equal subject
+        end
+      end
+
+      describe 'String' do
+        let(:subject) { "omg" }
+
+        it 'remains unchanged' do
+          @coercer.from_string(subject).class.must_equal String
+          @coercer.from_string(subject).must_equal subject
+        end
+      end
+    end
+
+    describe 'supported' do
+      describe 'AWS::DynamoDB::Binary' do
+        let(:subject) { AWS::DynamoDB::Binary.new("HUUUGE") }
+
+        it 'coerces' do
+          @coercer.from_aws_dynamodb_binary(subject).class.must_equal \
+            AWS::DynamoDB::Binary
+          @coercer.from_aws_dynamodb_binary(subject).must_equal \
+            AWS::DynamoDB::Binary.new(subject)
+        end
+      end
+
+      describe 'Array' do
+        let(:subject) { ["omg"] }
+
+        it 'coerces' do
+          @coercer.from_array(subject).class.must_equal String
+          @coercer.from_array(subject).must_equal MultiJson.dump(subject)
+        end
+      end
+
+      describe 'Boolean' do
+        it 'coerces' do
+          @coercer.from_boolean(true).class.must_equal Fixnum
+          @coercer.from_boolean(true).must_equal 1
+          @coercer.from_boolean(false).class.must_equal Fixnum
+          @coercer.from_boolean(false).must_equal 0
+        end
+      end
+
+      describe 'Date' do
+        let(:subject) { Date.new(2014) }
+
+        it 'coerces' do
+          @coercer.from_date(subject).class.must_equal Fixnum
+          @coercer.from_date(subject).must_equal subject.to_time.to_i
+        end
+      end
+
+      describe 'DateTime' do
+        let(:subject) { DateTime.new(2014) }
+
+        it 'coerces' do
+          @coercer.from_datetime(subject).class.must_equal Float
+          @coercer.from_datetime(subject).must_equal subject.to_time.to_f
+        end
+      end
+
+      describe 'Hash' do
+        let(:subject) { { omg: "lol" } }
+
+        it 'coerces' do
+          @coercer.from_hash(subject).class.must_equal String
+          @coercer.from_hash(subject).must_equal MultiJson.dump(subject)
+        end
+      end
+
+      describe 'Time' do
+        let(:subject) { Time.at(0) }
+
+        it 'coerces' do
+          @coercer.from_time(subject).class.must_equal Float
+          @coercer.from_time(subject).must_equal subject.to_f
+        end
+      end
+    end
+  end
+
+  describe '#to_*' do
+    describe 'skipped' do
+      describe 'Float' do
+        let(:subject) { 1.5 }
+
+        it 'remains unchanged' do
+          @coercer.to_float(subject).must_equal subject
+        end
+      end
+
+      describe 'Integer' do
+        let(:subject) { 2 }
+
+        it 'remains unchanged' do
+          @coercer.to_integer(subject).must_equal subject
+        end
+      end
+
+      describe 'Set' do
+        let(:subject) { Set.new([1, 2, 3]) }
+
+        it 'remains unchanged' do
+          @coercer.to_set(subject).class.must_equal Set
+          @coercer.to_set(subject).must_equal subject
+        end
+      end
+
+      describe 'String' do
+        let(:subject) { "omg" }
+
+        it 'remains unchanged' do
+          @coercer.to_string(subject).must_equal subject
+        end
+      end
+    end
+
+    describe 'supported' do
+      describe 'AWS::DynamoDB::Binary' do
+        let(:subject) { "HUUUGE" }
+
+        it 'coerces' do
+          @coercer.to_aws_dynamodb_binary(subject).class.must_equal \
+            AWS::DynamoDB::Binary
+          @coercer.to_aws_dynamodb_binary(subject).must_equal \
+            AWS::DynamoDB::Binary.new(subject)
+        end
+      end
+
+      describe 'Array' do
+        let(:subject) { MultiJson.dump(["omg"]) }
+
+        it 'coerces' do
+          @coercer.to_array(subject).class.must_equal Array
+          @coercer.to_array(subject).must_equal MultiJson.load(subject)
+        end
+      end
+
+      describe 'Boolean' do
+        it 'coerces' do
+          @coercer.to_boolean(1).class.must_equal TrueClass
+          @coercer.to_boolean(1).must_equal true
+          @coercer.to_boolean(0).class.must_equal FalseClass
+          @coercer.to_boolean(0).must_equal false
+        end
+      end
+
+      describe 'Date' do
+        let(:subject) { Date.new(2014) }
+
+        it 'coerces' do
+          @coercer.to_date(subject.to_time.to_i).class.must_equal Date
+          @coercer.to_date(subject.to_time.to_i).must_equal subject
+        end
+      end
+
+      describe 'DateTime' do
+        let(:subject) { DateTime.new(2014) }
+
+        it 'coerces' do
+          @coercer.to_datetime(subject.to_time.to_f).class.must_equal DateTime
+          @coercer.to_datetime(subject.to_time.to_f).must_equal subject
+        end
+      end
+
+      describe 'Hash' do
+        let(:subject) { MultiJson.dump({ omg: "lol" }) }
+
+        it 'coerces' do
+          @coercer.to_hash(subject).class.must_equal Hash
+          @coercer.to_hash(subject).must_equal MultiJson.load(subject)
+        end
+      end
+
+      describe 'Time' do
+        let(:subject) { Time.at(0) }
+
+        it 'coerces' do
+          @coercer.to_time(subject.to_f).class.must_equal Time
+          @coercer.to_time(subject.to_f).must_equal subject
+        end
+      end
+    end
+  end
+
+  describe '#deserialize_*' do
+    it 'deserializes id' do
+      @coercer.deserialize_id(0.0).must_equal Time.at(0)
+    end
+  end
+
+  describe '#serialize_*' do
+    it 'serializes id' do
+      @coercer.serialize_id(Time.at(0)).must_equal 0.0
+    end
+  end
+
+  describe '#to_record' do
+    let(:subject) { MockEntity.new(id: Time.at(0)) }
+
+    it 'serializes entity' do
+      @coercer.to_record(subject).must_equal ({ id: 0.0 })
+    end
+  end
+
+  describe '#from_record' do
+    let(:subject) { { id: 1.0 } }
+
+    it 'deserializes entity' do
+      @coercer.from_record(subject).must_equal MockEntity.new(id: Time.at(1))
+    end
+  end
+end