rom 0.4.2 → 0.5.0

data/spec/integration/multi_repo_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe 'Using in-memory adapter for cross-repo access' do
+  it 'works' do
+    setup = ROM.setup(
+      left: 'memory://localhost/users',
+      right: 'memory://localhost/tasks',
+      main: 'memory://localhost/main'
+    )
+
+    setup.schema do
+      base_relation :users do
+        repository :left
+        attribute :user_id
+        attribute :name
+      end
+
+      base_relation :tasks do
+        repository :right
+        attribute :user_id
+        attribute :title
+      end
+
+      base_relation :users_and_tasks do
+        repository :main
+
+        attribute :user_id
+        attribute :name
+        attribute :title
+      end
+    end
+
+    setup.relation(:users) do
+      def by_name(name)
+        restrict(name: name)
+      end
+    end
+
+    setup.relation(:tasks)
+
+    setup.relation(:users_and_tasks) do
+      def by_user(name)
+        join(users.by_name(name), tasks)
+      end
+    end
+
+    setup.mappers do
+      define(:users_and_tasks) do
+        group tasks: [:title]
+      end
+    end
+
+    rom = setup.finalize
+
+    rom.left.users << { user_id: 1, name: 'Joe' }
+    rom.left.users << { user_id: 2, name: 'Jane' }
+    rom.right.tasks << { user_id: 1, title: 'Have fun' }
+    rom.right.tasks << { user_id: 2, title: 'Have fun' }
+
+    expect(rom.read(:users_and_tasks).by_user('Jane').to_a).to eql([
+      { user_id: 2, name: 'Jane', tasks: [{ title: 'Have fun' }] }
+    ])
+  end
+end

data/spec/integration/relations/reading_spec.rb

@@ -4,6 +4,8 @@ describe 'Reading relations' do
   include_context 'users and tasks'
 
   it 'exposes a relation reader' do
+    setup.relation(:tasks)
+
     setup.relation(:users) do
       def by_name(name)
         restrict(name: name)
@@ -20,8 +22,6 @@ describe 'Reading relations' do
       end
     end
 
-    rom = setup.finalize
-
     users = rom.read(:users).sorted.by_name('Jane')
     user = users.first
 
@@ -31,9 +31,9 @@ describe 'Reading relations' do
   end
 
   it 'maps grouped relations' do
-    setup.relation(:users) do
-      include ROM::RA
+    setup.relation(:tasks)
 
+    setup.relation(:users) do
       def with_tasks
         join(tasks)
       end
@@ -60,7 +60,8 @@ describe 'Reading relations' do
     User.send(:include, Equalizer.new(:name, :email))
     UserWithTasks.send(:include, Equalizer.new(:name, :email, :tasks))
 
-    expect(rom.read(:users).with_tasks.header.keys).to eql([:name, :email, :tasks])
+    keys = rom.read(:users).with_tasks.header.keys
+    expect(keys).to eql([:name, :email, :tasks])
 
     user = rom.read(:users).sorted.first
 
@@ -68,6 +69,8 @@ describe 'Reading relations' do
       User.new(name: "Jane", email: "jane@doe.org")
     )
 
+    expect(rom.read(:users)).to_not respond_to(:join)
+
     user = rom.read(:users).with_tasks.sorted.first
 
     expect(user).to eql(
@@ -79,9 +82,9 @@ describe 'Reading relations' do
   end
 
   it 'maps wrapped relations' do
-    setup.relation(:users) do
-      include ROM::RA
+    setup.relation(:tasks)
 
+    setup.relation(:users) do
       def with_task
         join(tasks)
       end
@@ -108,7 +111,8 @@ describe 'Reading relations' do
     User.send(:include, Equalizer.new(:name, :email))
     UserWithTask.send(:include, Equalizer.new(:name, :email, :task))
 
-    expect(rom.read(:users).with_task.header.keys).to eql([:name, :email, :task])
+    keys = rom.read(:users).with_task.header.keys
+    expect(keys).to eql([:name, :email, :task])
 
     user = rom.read(:users).sorted.with_task.first
 

data/spec/integration/relations/registry_dsl_spec.rb

@@ -15,8 +15,6 @@ describe 'Relation registration DSL' do
     end
 
     setup.relation(:users) do
-      include ROM::RA
-
       def with_tasks
         join(tasks)
       end
@@ -37,7 +35,7 @@ describe 'Relation registration DSL' do
 
     users = rom.relations.users
 
-    expect(users.with_tasks.to_a).to eql(
+    expect(users.with_tasks).to match_array(
       [{ name: "Joe", email: "joe@doe.org", title: "be nice", priority: 1 },
        { name: "Joe", email: "joe@doe.org", title: "sleep well", priority: 2 },
        { name: "Jane", email: "jane@doe.org", title: "be cool", priority: 2 }]

data/spec/integration/schema_spec.rb

@@ -42,12 +42,22 @@ describe 'Defining schema' do
             attribute :title
           end
         end
+
+        setup.schema do
+          base_relation(:tags) do
+            repository :memory
+            attribute :name
+          end
+        end
       end
 
       it_behaves_like 'valid schema' do
         it 'registers all base relations' do
           expect(schema.tasks.dataset).to be(rom.memory.tasks)
           expect(schema.tasks.header).to eql([:title])
+
+          expect(schema.tags.dataset).to be(rom.memory.tags)
+          expect(schema.tags.header).to eql([:name])
         end
       end
     end

data/spec/integration/setup_spec.rb

@@ -7,10 +7,23 @@ describe 'Setting up ROM' do
     let(:jane) { { name: 'Jane', email: 'jane@doe.org' } }
     let(:joe) { { name: 'Joe', email: 'joe@doe.org' } }
 
-    it 'configures relations' do
+    it 'configures schema relations' do
       expect(rom.memory.users).to match_array([joe, jane])
     end
 
+    it 'configures rom relations' do
+      users = rom.relations.users
+
+      expect(users).to be_kind_of(ROM::Relation)
+      expect(users).to respond_to(:tasks)
+
+      tasks = users.tasks
+
+      expect(tasks).to be_kind_of(ROM::Relation)
+      expect(tasks).to respond_to(:users)
+      expect(tasks.users).to be(users)
+    end
+
     it 'raises on double-finalize' do
       expect {
         2.times { setup.finalize }
@@ -33,7 +46,10 @@ describe 'Setting up ROM' do
 
   describe 'quick setup' do
     it 'exposes boot DSL inside the setup block' do
-      User = Class.new { include Virtus.value_object; values { attribute :name, String } }
+      User = Class.new do
+        include Virtus.value_object
+        values { attribute :name, String }
+      end
 
       rom = ROM.setup(memory: 'memory://test') do
         schema do
@@ -60,15 +76,19 @@ describe 'Setting up ROM' do
         end
       end
 
-      rom.command(:users).create.call(name: 'Jane')
+      rom.command(:users).try { create(name: 'Jane') }
 
-      expect(rom.read(:users).by_name('Jane').to_a).to eql([User.new(name: 'Jane')])
+      expect(rom.read(:users).by_name('Jane').to_a)
+        .to eql([User.new(name: 'Jane')])
     end
   end
 
   describe 'multi-step setup' do
     it 'exposes boot DSL that can be invoked multiple times' do
-      User = Class.new { include Virtus.value_object; values { attribute :name, String } }
+      User = Class.new do
+        include Virtus.value_object
+        values { attribute :name, String }
+      end
 
       ROM.setup(memory: 'memory://test')
 
@@ -99,7 +119,38 @@ describe 'Setting up ROM' do
 
       rom.command(:users).create.call(name: 'Jane')
 
-      expect(rom.read(:users).by_name('Jane').to_a).to eql([User.new(name: 'Jane')])
+      expect(rom.read(:users).by_name('Jane').to_a)
+        .to eql([User.new(name: 'Jane')])
+    end
+  end
+
+  describe 'setup with extra options' do
+    shared_examples 'adapter with extra options' do
+      subject(:adapter) { setup.default.adapter }
+
+      it 'has connection uri' do
+        expect(adapter.uri).to eql(
+          Addressable::URI.parse('memory://localhost/test')
+        )
+      end
+
+      it 'has extra options' do
+        expect(adapter.options).to eql(super: 'option')
+      end
+    end
+
+    context 'with a connection uri and options passed separately' do
+      let(:setup) { ROM.setup('memory://localhost/test', super: 'option') }
+
+      it_behaves_like 'adapter with extra options'
+    end
+
+    context 'with option hash' do
+      let(:setup) do
+        ROM.setup(adapter: 'memory', database: 'test', super: 'option')
+      end
+
+      it_behaves_like 'adapter with extra options'
     end
   end
 end

data/spec/spec_helper.rb

@@ -24,6 +24,7 @@ RSpec.configure do |config|
   end
 
   config.after do
-    (Object.constants - @constants).each { |name| Object.send(:remove_const, name) }
+    added_constants = Object.constants - @constants
+    added_constants.each { |name| Object.send(:remove_const, name) }
   end
 end

data/spec/unit/config_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe ROM::Config do
+  describe '.build' do
+    let(:raw_config) do
+      { adapter: 'memory', hostname: 'localhost', database: 'test' }
+    end
+
+    it 'returns rom repository configuration hash' do
+      config = ROM::Config.build(raw_config)
+
+      expect(config).to eql(default: 'memory://localhost/test')
+    end
+
+    it 'sets additional options' do
+      config = ROM::Config.build(raw_config.update(port: 312, root: '/somewhere'))
+
+      expect(config).to eql(
+        default: { uri: 'memory://localhost/test', options: { port: 312 } }
+      )
+
+      config = ROM::Config.build('memory://localhost/test', super: :option)
+
+      expect(config).to eql(
+        default: { uri: 'memory://localhost/test', options: { super: :option } }
+      )
+    end
+
+    it 'builds absolute path to the database file when database is a file' do
+      expect(ROM::Adapter[:memory]).to receive(:database_file?)
+        .with('memory').and_return(true)
+
+      config = ROM::Config.build(
+        adapter: 'memory', database: 'test', root: '/somewhere'
+      )
+
+      expect(config).to eql(default: 'memory:///somewhere/test')
+    end
+
+    it 'sets default password to an empty string' do
+      config = ROM::Config.build(raw_config.update(username: 'root'))
+      expect(config).to eql(default: 'memory://root:@localhost/test')
+    end
+
+    it 'turns a uri into configuration hash' do
+      config = ROM::Config.build('test://localhost/rom')
+      expect(config).to eql(default: 'test://localhost/rom')
+    end
+
+    it 'returns original config hash if it is already in rom format' do
+      config = ROM::Config.build(test: 'test://localhost/rom')
+      expect(config).to eql(test: 'test://localhost/rom')
+    end
+
+    it 'asks adapters to normalize scheme' do
+      expect(ROM::Adapter[:memory]).to receive(:normalize_scheme).with('memory')
+      ROM::Config.build(raw_config)
+    end
+  end
+end

data/spec/unit/rom/adapter/memory/dataset_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe ROM::Adapter::Memory::Dataset do
+  subject(:dataset) do
+    ROM::Adapter::Memory::Dataset.new(data, [:name, :email, :age])
+  end
+
+  let(:data) do
+    [
+      { name: 'Jane', email: 'jane@doe.org', age: 10 },
+      { name: 'Jade', email: 'jade@doe.org', age: 11 },
+      { name: 'Joe', email: 'joe@doe.org', age: 12 }
+    ]
+  end
+
+  describe '#project' do
+    it 'projects tuples with the provided keys' do
+      expect(dataset.project(:name, :age)).to match_array([
+        { name: 'Jane', age: 10 },
+        { name: 'Jade', age: 11 },
+        { name: 'Joe', age: 12 }
+      ])
+    end
+  end
+
+  describe '#restrict' do
+    it 'restricts data using criteria hash' do
+      expect(dataset.restrict(age: 10)).to match_array([
+        { name: 'Jane', email: 'jane@doe.org', age: 10 }
+      ])
+
+      expect(dataset.restrict(age: 10.0)).to match_array([])
+    end
+
+    it 'restricts data using block' do
+      expect(dataset.restrict { |tuple| tuple[:age] > 10 }).to match_array([
+        { name: 'Jade', email: 'jade@doe.org', age: 11 },
+        { name: 'Joe', email: 'joe@doe.org', age: 12 }
+      ])
+    end
+  end
+
+  describe '#order' do
+    it 'sorts data using provided attribute names' do
+      expect(dataset.order(:name)).to match_array([
+        { name: 'Jade', email: 'jade@doe.org', age: 11 },
+        { name: 'Jane', email: 'jane@doe.org', age: 10 },
+        { name: 'Joe', email: 'joe@doe.org', age: 12 }
+      ])
+    end
+  end
+end

data/spec/unit/rom/adapter_spec.rb

@@ -6,10 +6,6 @@ describe ROM::Adapter do
       def self.schemes
         [:test_scheme]
       end
-
-      def initialize(uri); end
-
-      ROM::Adapter.register(self)
     end
   end
 
@@ -22,8 +18,8 @@ describe ROM::Adapter do
 
     it 'raises an exception if the scheme is not supported' do
       expect {
-        ROM::Adapter.setup("bogus:///non-existent")
-      }.to raise_error(ArgumentError, '"bogus:///non-existent" uri is not supported')
+        ROM::Adapter.setup("bogus://any-host")
+      }.to raise_error(ArgumentError, '"bogus://any-host" uri is not supported')
     end
   end
 
@@ -39,16 +35,12 @@ describe ROM::Adapter do
         def self.schemes
           [:order_test]
         end
-
-        ROM::Adapter.register(self)
       end
 
       adapter = ROM::Adapter.setup("order_test::memory")
       expect(adapter).to be_instance_of(OrderTestFirst)
 
-      class OrderTestSecond < OrderTestFirst
-        ROM::Adapter.register(self)
-      end
+      OrderTestSecond = Class.new(OrderTestFirst)
 
       adapter = ROM::Adapter.setup("order_test::memory")
 
@@ -56,4 +48,32 @@ describe ROM::Adapter do
     end
   end
 
+  describe '#disconnect' do
+    it 'does nothing' do
+      adapter_class = Class.new(ROM::Adapter) {
+        def self.schemes
+          [:bazinga]
+        end
+      }
+
+      adapter = adapter_class.new('bazinga://localhost')
+
+      expect(adapter.disconnect).to be(nil)
+    end
+  end
+
+  describe '.setup' do
+    it 'supports connection uri and additional options' do
+      Class.new(ROM::Adapter) {
+        def self.schemes
+          [:bazinga]
+        end
+      }
+
+      adapter = ROM::Adapter.setup('bazinga://localhost', super: :option)
+
+      expect(adapter.uri).to eql(Addressable::URI.parse('bazinga://localhost'))
+      expect(adapter.options).to eql(super: :option)
+    end
+  end
 end