rom 0.5.0 → 0.6.0.beta1

data/spec/unit/rom/relation/loaded_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe ROM::Relation::Loaded do
+  include_context 'users and tasks'
+
+  subject(:users) { ROM::Relation::Loaded.new(rom.relations.users) }
+
+  before { setup.relation(:users) }
+
+  describe '#each' do
+    it 'yields tuples from relation' do
+      result = []
+      users.each { |tuple| result << tuple }
+      expect(result).to match_array([
+        { name: 'Jane', email: 'jane@doe.org' },
+        { name: 'Joe', email: 'joe@doe.org' }
+      ])
+    end
+
+    it 'returns enumerator when block is not provided' do
+      expect(users.each.to_a).to eql(users.collection.to_a)
+    end
+  end
+
+  it_behaves_like 'a relation that returns one tuple' do
+    let(:relation) { users }
+  end
+end

data/spec/unit/rom/relation_spec.rb

@@ -1,17 +1,93 @@
 require 'spec_helper'
+require 'rom/memory'
 
 describe ROM::Relation do
-  subject(:relation) { ROM::Relation.new(dataset, dataset.header) }
+  subject(:relation) { Class.new(ROM::Relation).new(dataset) }
 
-  let(:dataset) { ROM::Adapter::Memory::Dataset.new([jane, joe], [:id, :name]) }
+  let(:dataset) { ROM::Memory::Dataset.new([jane, joe]) }
 
   let(:jane) { { id: 1, name: 'Jane' } }
   let(:joe) { { id: 2, name: 'Joe' } }
 
-  describe "#header" do
-    it "return's duplicated and frozen dataset header" do
-      expect(relation.header).to be_frozen
-      expect(relation.header).not_to be(dataset.header)
+  describe '.[]' do
+    before do
+      module Test::TestAdapter
+        class Relation < ROM::Relation
+          def test_relation?
+            true
+          end
+        end
+      end
+
+      ROM.register_adapter(:test, Test::TestAdapter)
+    end
+
+    it 'returns relation subclass from the registered adapter' do
+      relation = ROM::Relation[:test].new([])
+
+      expect(relation).to be_test_relation
+    end
+  end
+
+  describe '#exposed_relations' do
+    it 'returns exposed relation name' do
+      relation_class = Class.new(ROM::Relation[:memory]) {
+        def foo
+        end
+
+        def bar
+        end
+      }
+
+      expect(relation_class.exposed_relations).to include(:foo, :bar)
+    end
+  end
+
+  describe '#name' do
+    before { ROM.setup(:memory) }
+
+    context 'missing dataset' do
+      context 'with Relation inside module' do
+        before do
+          module Test::Test
+            class SuperRelation < ROM::Relation[:memory]; end
+          end
+        end
+
+        it 'returns name based on module and class' do
+          relation = Test::Test::SuperRelation.new([])
+
+          expect(relation.name).to eq(:test_test_super_relation)
+        end
+      end
+
+      context 'with Relation without module' do
+        before do
+          class Test::SuperRelation < ROM::Relation[:memory]; end
+        end
+
+        it 'returns name based only on class' do
+          relation = Test::SuperRelation.new([])
+
+          expect(relation.name).to eq(:test_super_relation)
+        end
+      end
+    end
+
+    context 'manualy set dataset' do
+      before do
+        module Test::TestAdapter
+          class Relation < ROM::Relation[:memory]
+            dataset :foo_bar
+          end
+        end
+      end
+
+      it 'returns name based on dataset' do
+        relation = Test::TestAdapter::Relation.new([])
+
+        expect(relation.name).to eq(:foo_bar)
+      end
     end
   end
 
@@ -30,4 +106,33 @@ describe ROM::Relation do
       expect(relation.each).to be_instance_of(Enumerator)
     end
   end
+
+  describe ".register_as" do
+    before { ROM.setup(:memory) }
+
+    it "defaults to dataset with a generated class" do
+      rel = Class.new(ROM::Relation[:memory]) { dataset :users }
+      expect(rel.register_as).to eq(:users)
+      rel.register_as(:guests)
+      expect(rel.register_as).to eq(:guests)
+    end
+
+    it "defaults to dataset with a defined class that has dataset inferred" do
+      class Test::Users < ROM::Relation[:memory]; end
+      expect(Test::Users.register_as).to eq(:test_users)
+    end
+
+    it "defaults to dataset with a defined class that has dataset set manually" do
+      class Test::Users < ROM::Relation[:memory]
+        dataset :guests
+      end
+      expect(Test::Users.register_as).to eq(:guests)
+    end
+  end
+
+  describe "#to_a" do
+    it "materializes relation to an array" do
+      expect(relation.to_a).to eql([jane, joe])
+    end
+  end
 end

data/spec/unit/rom/repository_spec.rb

@@ -1,21 +1,71 @@
 require 'spec_helper'
 
 describe ROM::Repository do
-  include_context 'users and tasks'
+  describe '.setup' do
+    it 'sets up a repository based on a type' do
+      repository_class = Class.new(ROM::Repository) do
+        attr_reader :args
 
-  subject(:repository) { rom.memory }
+        def initialize(*args)
+          @args = args
+        end
+      end
 
-  before { setup.relation(:users) }
+      allow(ROM::Repository).to receive(:class_from_symbol)
+        .with(:wormhole).and_return(repository_class)
 
-  it 'exposes datasets on method-missing' do
-    expect(repository.users).to be(rom.memory[:users])
+      args = %w(hello world)
+      repository = ROM::Repository.setup(:wormhole, *args)
+
+      expect(repository).to be_instance_of(repository_class)
+      expect(repository.args).to eq(args)
+    end
+
+    it 'raises an exception if the type is not supported' do
+      expect {
+        ROM::Repository.setup(:bogus, "memory://test")
+      }.to raise_error(ROM::AdapterLoadError, /bogus/)
+    end
+
+    it 'accepts a repository instance' do
+      repository = ROM::Repository.new
+      expect(ROM::Repository.setup(repository)).to be(repository)
+    end
+
+    it 'raises an exception if instance and arguments are passed' do
+      repository = ROM::Repository.new
+
+      expect { ROM::Repository.setup(repository, 'foo://bar') }.to raise_error(
+        ArgumentError,
+        "Can't accept arguments when passing an instance"
+      )
+    end
+
+    it 'raises an exception if a URI string is passed' do
+      expect { ROM::Repository.setup('memory://test') }.to raise_error(
+        ArgumentError,
+        /URIs without an explicit scheme are not supported anymore/
+      )
+    end
   end
 
-  it 'responds to methods corresponding to dataset names' do
-    expect(repository).to respond_to(:users)
+  describe '.class_from_symbol' do
+    it 'instantiates a repository based on type' do
+      klass = ROM::Repository.class_from_symbol(:memory)
+      expect(klass).to be(ROM::Memory::Repository)
+    end
+
+    it 'raises an exception if the type is not supported' do
+      expect { ROM::Repository.class_from_symbol(:bogus) }
+        .to raise_error(ROM::AdapterLoadError, /bogus/)
+    end
   end
 
-  it 'raises exception when unknown dataset is referenced' do
-    expect { repository.not_here }.to raise_error(NoMethodError)
+  describe '#disconnect' do
+    it 'does nothing' do
+      repository_class = Class.new(ROM::Repository)
+      repository = repository_class.new
+      expect(repository.disconnect).to be(nil)
+    end
   end
 end

data/spec/unit/rom/setup_spec.rb

@@ -2,23 +2,111 @@ require 'spec_helper'
 
 describe ROM::Setup do
   describe '#finalize' do
-    context 'with an adapter that supports schema inferring' do
+    context 'with repository that supports schema inferring' do
       it 'builds relation from inferred schema' do
-        adapter = double('adapter').as_null_object
-        repo = double('repo', adapter: adapter).as_null_object
+        setup = ROM.setup(:memory)
+        repo = setup.default
         dataset = double('dataset')
 
-        allow(repo).to receive(:schema).and_return([
-          [:users, dataset, [:name, :email]]
-        ])
+        allow(repo).to receive(:schema).and_return([:users])
+        allow(repo).to receive(:dataset).with(:users).and_return(dataset)
 
-        setup = ROM::Setup.new(memory: repo)
-        env = setup.finalize
+        rom = setup.finalize
 
-        users = env.relations.users
+        expect(rom.relations.users.dataset).to be(dataset)
+      end
+
+      it 'skips inferring a relation when there is a defined one already' do
+        setup = ROM.setup(:memory)
+        repo = setup.default
+        dataset = double('dataset')
+
+        allow(repo).to receive(:schema).and_return([:test_users])
+        allow(repo).to receive(:dataset).with(:test_users).and_return(dataset)
+
+        class Test::Users < ROM::Relation[:memory]; end
+
+        expect { setup.finalize }.not_to raise_error
+
+        rom = setup.env
+
+        expect(rom.relations.test_users).to be_instance_of(Test::Users)
+      end
+
+      it 'can register multiple relations with same dataset' do
+        setup = ROM.setup(:memory)
+
+        Class.new(ROM::Relation[:memory]) {
+          dataset :fruits
+          register_as :apples
+
+          def apple?
+            true
+          end
+        }
+
+        Class.new(ROM::Relation[:memory]) {
+          dataset :fruits
+          register_as :oranges
+
+          def orange?
+            true
+          end
+        }
+
+        rom = setup.finalize
+
+        expect(rom.relations.apples).to be_apple
+        expect(rom.relations.oranges).to be_orange
+        expect(rom.relations.apples).to_not eq(rom.relations.oranges)
+      end
+
+      it "raises an error when registering relations with the same `register_as`" do
+        setup = ROM.setup(:memory)
+
+        Class.new(ROM::Relation[:memory]) {
+          dataset :guests
+          register_as :users
+        }
+
+        Class.new(ROM::Relation[:memory]) {
+          dataset :admins
+          register_as :users
+        }
+
+        expect { setup.finalize }.to raise_error(
+          ROM::RelationAlreadyDefinedError, /register_as :users/
+        )
+      end
+
+      it 'resets boot to nil' do
+        setup = ROM.setup(:memory)
+
+        allow(setup).to receive(:env).and_raise(StandardError)
+
+        expect { ROM.finalize }.to raise_error(StandardError)
+        expect(ROM.boot).to be(nil)
+      end
+    end
+
+    context 'empty setup' do
+      let(:setup) { ROM::Setup.new({}) }
+      let(:env) { setup.finalize }
+
+      it 'builds empty repositories' do
+        expect(env.repositories).to eql({})
+      end
+
+      it 'builds empty relations' do
+        expect(env.relations).to eql(ROM::RelationRegistry.new)
+      end
+
+      it 'builds empty readers' do
+        expect(env.readers).to eql(ROM::ReaderRegistry.new)
+      end
 
-        expect(users.dataset).to be(dataset)
-        expect(users.header).to eql([:name, :email])
+      it 'builds empty commands' do
+        expect(env.commands).to eql(ROM::Registry.new)
       end
     end
   end

data/spec/unit/rom/support/array_dataset_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+require 'rom/support/array_dataset'
+
+describe ROM::ArrayDataset do
+  let(:klass) do
+    Class.new do
+      include ROM::ArrayDataset
+
+      def self.row_proc
+        Transproc(:symbolize_keys)
+      end
+    end
+  end
+
+  it_behaves_like 'an enumerable dataset' do
+    describe '#flatten' do
+      let(:data) { [[{ 'name' => 'Jane' }], [{ 'name' => 'Joe' }]] }
+
+      it 'returns a new dataset with flattened data' do
+        result = dataset.flatten
+
+        expect(result).to match_array([{ name: 'Jane' }, { name: 'Joe' }])
+      end
+    end
+
+    describe '#map!' do
+      context 'with a block' do
+        it 'returns a new dataset with mapped data' do
+          dataset.map! { |row| row.merge(age: 21) }
+
+          expect(dataset).to match_array([
+            { name: 'Jane', age: 21 }, { name: 'Joe', age: 21 }
+          ])
+        end
+      end
+
+      context 'without a block' do
+        it 'returns an enumerator' do
+          result = dataset.map!
+
+          expect(result).to be_instance_of(Enumerator)
+
+          expect(result).to match_array([
+            { name: 'Jane' }, { name: 'Joe' }
+          ])
+        end
+      end
+    end
+
+    describe '#values_at' do
+      it 'returns a new dataset with rows at given indices' do
+        result = dataset.values_at(1)
+
+        expect(result).to match_array([{ name: 'Joe' }])
+      end
+    end
+  end
+end

data/spec/unit/rom/support/class_builder_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe ROM::ClassBuilder do
+  subject(:builder) { ROM::ClassBuilder.new(options) }
+
+  let(:klass) { builder.call }
+
+  describe '#call' do
+    let(:options) do
+      { name: 'Test', parent: parent }
+    end
+
+    let(:parent) { Class.new }
+
+    it 'returns a class constant' do
+      expect(klass).to be_instance_of(Class)
+    end
+
+    it 'sets class name based on provided :name option' do
+      expect(klass.name).to eql(options[:name])
+    end
+
+    it 'uses a parent class provided by :parent option' do
+      expect(klass).to be < parent
+    end
+
+    it 'defines to_s and inspect' do
+      expect(klass.to_s).to eql(options[:name])
+      expect(klass.inspect).to eql(options[:name])
+    end
+
+    it 'yields created class' do
+      klass = builder.call do |yielded_class|
+        yielded_class.class_eval do
+          def self.testing; end
+        end
+      end
+
+      expect(klass).to respond_to(:testing)
+    end
+  end
+end