rom 0.3.1 → 0.4.0

data/lib/rom/relation.rb

@@ -43,24 +43,6 @@ module ROM
       dataset.each(&block)
     end
 
-    # @api private
-    def insert(tuple)
-      dataset.insert(tuple)
-      self
-    end
-
-    # @api private
-    def update(tuple)
-      dataset.update(tuple)
-      self
-    end
-
-    # @api private
-    def delete
-      dataset.delete
-      self
-    end
-
   end
 
 end

data/lib/rom/repository.rb

@@ -16,6 +16,24 @@ module ROM
       adapter[name]
     end
 
+    # Set a logger for the adapter
+    #
+    # @param [Object] logger
+    #
+    # @api public
+    def use_logger(logger)
+      adapter.logger = logger
+    end
+
+    # Return logger used by the adapter
+    #
+    # @return [Object] logger
+    #
+    # @api public
+    def logger
+      adapter.logger
+    end
+
     # Return the database connection provided by the adapter
     #
     # @api public
@@ -32,14 +50,18 @@ module ROM
 
     # @api private
     def respond_to_missing?(name, include_private = false)
-      adapter[name]
+      adapter.dataset?(name) || super
     end
 
     private
 
     # @api private
-    def method_missing(name)
-      adapter[name]
+    def method_missing(name, *args, &block)
+      if adapter.dataset?(name)
+        adapter[name]
+      else
+        super
+      end
     end
   end
 

data/lib/rom/version.rb

@@ -1,3 +1,3 @@
 module ROM
-  VERSION = '0.3.1'.freeze
+  VERSION = '0.4.0'.freeze
 end

data/spec/integration/adapters/setting_logger_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+require 'logger'
+
+describe 'Adapters / Setting logger' do
+  let(:logger_class) do
+    Class.new do
+      attr_reader :messages
+
+      def initialize
+        @messages = []
+      end
+
+      def info(msg)
+        @messages << msg
+      end
+    end
+  end
+
+  let(:logger) do
+    logger_class.new
+  end
+
+  it 'sets up a logger for a given adapter' do
+    setup = ROM.setup(memory: 'memory://localhost')
+
+    setup.memory.use_logger(logger)
+
+    rom = setup.finalize
+
+    rom.memory.logger.info("test")
+
+    expect(logger.messages).to eql(["test"])
+  end
+end

data/spec/integration/commands/create_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+describe 'Commands / Create' do
+  include_context 'users and tasks'
+
+  let(:users) { rom.commands.users }
+  let(:tasks) { rom.commands.tasks }
+
+  before do
+    UserValidator = Class.new do
+      ValidationError = Class.new(ROM::CommandError)
+
+      def self.call(params)
+        unless params[:name] && params[:email]
+          raise ValidationError, ":name and :email are required"
+        end
+      end
+    end
+
+    setup.relation(:users)
+    setup.relation(:tasks)
+
+    setup.commands(:users) do
+      define(:create) do
+        validator UserValidator
+      end
+    end
+
+    setup.commands(:tasks) do
+      define(:create)
+    end
+
+  end
+
+  it 'inserts user on successful validation' do
+    result = users.try { create(name: 'Piotr', email: 'piotr@solnic.eu') }
+
+    expect(result).to match_array([{ name: 'Piotr', email: 'piotr@solnic.eu' }])
+  end
+
+  it 'inserts user and associated task when things go well' do
+    result = users.try {
+      create(name: 'Piotr', email: 'piotr@solnic.eu')
+    } >-> users {
+      tasks.try {
+        create(name: users.first[:name], title: 'Finish command-api')
+      }
+    }
+
+    expect(result).to match_array([{ name: 'Piotr', title: 'Finish command-api' }])
+  end
+
+  it 'returns validation object with errors on failed validation' do
+    result = users.try { create(name: 'Piotr') }
+
+    expect(result.error).to be_instance_of(ValidationError)
+    expect(result.error.message).to eql(":name and :email are required")
+    expect(rom.relations.users.count).to be(2)
+  end
+
+  describe '"result" option' do
+
+    it 'returns a single tuple when set to :one' do
+      setup.commands(:users) do
+
+        define(:create_one, type: :create) do
+          result :one
+        end
+
+      end
+
+      tuple = { name: 'Piotr', email: 'piotr@solnic.eu' }
+
+      result = users.try {
+        create_one(tuple)
+      }
+
+      expect(result.value).to eql(tuple)
+    end
+
+    it 'allows only valid result types' do
+      expect {
+
+        setup.commands(:users) do
+          define(:create_one, type: :create) do
+            result :invalid_type
+          end
+        end
+        setup.finalize
+
+      }.to raise_error(ROM::InvalidOptionError)
+    end
+
+  end
+
+end

data/spec/integration/commands/delete_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe 'Commands / Delete' do
+  include_context 'users and tasks'
+
+  subject(:users) { rom.commands.users }
+
+  before do
+    setup.relation(:users) do
+      def by_name(name)
+        restrict(name: name)
+      end
+    end
+
+    setup.commands(:users) do
+      define(:delete)
+    end
+  end
+
+  it 'deletes all tuples when there is no restriction' do
+    result = users.try { delete }
+
+    expect(result).to match_array([
+      { name: 'Jane', email: 'jane@doe.org' },
+      { name: 'Joe', email: 'joe@doe.org' }
+    ])
+  end
+
+  it 'deletes tuples matching restriction' do
+    result = users.try { delete(:by_name, 'Joe').call }
+
+    expect(result).to match_array([{ name: 'Joe', email: 'joe@doe.org' }])
+  end
+
+  it 'returns untouched relation if there are no tuples to delete' do
+    result = users.try { delete(:by_name, 'Not here').call }
+
+    expect(result).to match_array([])
+  end
+
+  it 'returns deleted tuple when result is set to :one' do
+    setup.commands(:users) do
+      define(:delete_one, type: :delete) do
+        result :one
+      end
+    end
+
+    result = users.try { delete_one(:by_name, 'Jane').call }
+
+    expect(result.value).to eql(name: 'Jane', email: 'jane@doe.org')
+  end
+
+  it 'raises error when result is set to :one and relation contains more tuples' do
+    setup.commands(:users) do
+      define(:delete) do
+        result :one
+      end
+    end
+
+    result = users.try { delete }
+
+    expect(result.error).to be_instance_of(ROM::TupleCountMismatchError)
+
+    expect(rom.relations.users.to_a).to match_array([
+      { name: 'Jane', email: 'jane@doe.org' },
+      { name: 'Joe', email: 'joe@doe.org' }
+    ])
+  end
+
+end

data/spec/integration/commands/error_handling_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe 'Commands / Error handling'  do
+  include_context 'users and tasks'
+
+  before do
+    setup.relation(:users)
+    setup.commands(:users) { define(:create) }
+  end
+
+  subject(:users) { rom.commands.users }
+
+  it 'rescues from ROM::CommandError' do
+    result = false
+    expect(users.try { raise ROM::CommandError } >-> test { result = true }).
+      to be_instance_of(ROM::Result::Failure)
+    expect(result).to be(false)
+  end
+
+  it 'raises other errors' do
+    expect { users.try { raise ArgumentError, 'test' } }.to raise_error(ArgumentError, 'test')
+  end
+end

data/spec/integration/commands/try_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe 'Commands / Try api' do
+  include_context 'users and tasks'
+
+  before do
+    setup.relation(:users)
+
+    setup.commands(:users) do
+      define(:create)
+    end
+  end
+
+  let(:user_commands) { rom.command(:users) }
+
+  it 'exposes command functions inside the block' do
+    input = { name: 'Piotr', email: 'piotr@test.com' }
+
+    result = user_commands.try { create(input) }
+
+    expect(result.value).to eql([input])
+  end
+
+  it 'raises on method missing' do
+    expect { users.try { not_here } }.to raise_error(NameError)
+  end
+end

data/spec/integration/commands/update_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+
+require 'ostruct'
+
+describe 'Commands / Update' do
+  include_context 'users and tasks'
+
+  subject(:users) { rom.commands.users }
+
+  before do
+    UserValidator = Class.new do
+      ValidationError = Class.new(ROM::CommandError)
+
+      def self.call(params)
+        raise ValidationError, ":email is required" unless params[:email]
+      end
+    end
+
+    setup.relation(:users) do
+      def all(criteria)
+        restrict(criteria)
+      end
+
+      def by_name(name)
+        restrict(name: name)
+      end
+    end
+
+    setup.commands(:users) do
+      define(:update) do
+        validator UserValidator
+      end
+    end
+
+  end
+
+  it 'update tuples on successful validation' do
+    result = users.try {
+      update(:all, name: 'Jane').set(email: 'jane.doe@test.com')
+    }
+
+    expect(result).to match_array([{ name: 'Jane', email: 'jane.doe@test.com' }])
+  end
+
+  it 'returns validation object with errors on failed validation' do
+    result = users.try { update(:all, name: 'Jane').set(email: nil) }
+
+    expect(result.error).to be_instance_of(ValidationError)
+    expect(result.error.message).to eql(':email is required')
+
+    expect(rom.relations.users.restrict(name: 'Jane')).to match_array([
+      { name: 'Jane', email: 'jane@doe.org' }
+    ])
+  end
+
+  describe '"result" option' do
+
+    it 'returns a single tuple when set to :one' do
+      setup.commands(:users) do
+        define(:update_one, type: :update) do
+          result :one
+        end
+      end
+
+      result = users.try {
+        update_one(:by_name, 'Jane').set(email: 'jane.doe@test.com')
+      }
+
+      expect(result.value).to eql(name: 'Jane', email: 'jane.doe@test.com')
+    end
+
+    it 'raises error when there is more than one tuple and result is set to :one' do
+      setup.commands(:users) do
+        define(:update_one, type: :update) do
+          result :one
+        end
+      end
+
+      result = users.try {
+        update_one.set(email: 'jane.doe@test.com')
+      }
+
+      expect(result.error).to be_instance_of(ROM::TupleCountMismatchError)
+
+      expect(rom.relations.users).to match_array([
+        { name: 'Jane', email: 'jane@doe.org' },
+        { name: 'Joe', email: 'joe@doe.org' }
+      ])
+    end
+
+    it 'allows only valid result types' do
+      expect {
+
+        setup.commands(:users) do
+          define(:create_one, type: :create) do
+            result :invalid_type
+          end
+        end
+        setup.finalize
+
+      }.to raise_error(ROM::InvalidOptionError)
+    end
+
+  end
+
+end

data/spec/integration/setup_spec.rb

@@ -30,4 +30,39 @@ describe 'Setting up ROM' do
       expect(rom.mappers).to eql(ROM::ReaderRegistry.new)
     end
   end
+
+  describe 'quick setup' do
+    it 'exposes boot DSL inside the setup block' do
+      User = Class.new { include Virtus.value_object; values { attribute :name, String } }
+
+      rom = ROM.setup(memory: 'memory://test') do
+        schema do
+          base_relation(:users) do
+            repository :memory
+            attribute :name
+          end
+        end
+
+        relation(:users) do
+          def by_name(name)
+            restrict(name: name)
+          end
+        end
+
+        commands(:users) do
+          define(:create)
+        end
+
+        mappers do
+          define(:users) do
+            model User
+          end
+        end
+      end
+
+      rom.command(:users).create.call(name: 'Jane')
+
+      expect(rom.read(:users).by_name('Jane').to_a).to eql([User.new(name: 'Jane')])
+    end
+  end
 end