rom-relation 0.1.0

data/spec/unit/rom/mapping/class_methods/build_spec.rb

@@ -0,0 +1,77 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Mapping, '.build' do
+  let(:header)   { [[:id, Integer], [:user_name, String], [:age, Integer], [:email, String]] }
+  let(:relation) { Axiom::Relation::Base.new(:users, header) }
+  let(:model)    { mock_model(:id, :name, :email) }
+  let(:env)      { Environment.setup(test: 'memory://test') }
+  let(:schema)   { Hash[users: relation] }
+
+  context 'when attribute mapping is used' do
+    subject { env }
+
+    let(:mapper) { subject[:users].mapper }
+
+    before do
+      user_model = model
+
+      Mapping.build(env, schema) do
+        users do
+          model user_model
+
+          map :id, :email
+          map :user_name, to: :name
+        end
+      end
+    end
+
+    it 'registers rom relation' do
+      expect(subject[:users]).to be_instance_of(Relation)
+    end
+
+    it 'builds rom mapper' do
+      expect(mapper.header.map(&:name)).to eql([:id, :email, :name])
+
+      # TODO: introduce new interface in rom-mapper to make this simpler
+      expect(mapper.header.map { |a| a.field.type }).to eql([
+        Axiom::Types::Integer, Axiom::Types::String, Axiom::Types::String
+      ])
+    end
+
+    it 'sets up the model' do
+      object = mapper.new_object(id: 1, name: 'Jane', email: 'jane@rom.org')
+      expect(object).to be_instance_of(model)
+    end
+  end
+
+  context 'when custom mapper is inject' do
+    subject { env }
+
+    fake(:test_mapper) { TestMapper }
+
+    before do
+      custom_mapper = test_mapper
+      Mapping.build(env, schema) { users { mapper(custom_mapper) } }
+    end
+
+    it 'sets the custom mapper' do
+      stub(test_mapper).call(relation) { relation }
+
+      expect(subject[:users].mapper).to be(test_mapper)
+
+      expect(test_mapper).to have_received.call(relation)
+    end
+  end
+
+  context 'when unknown relation name is used' do
+    subject { described_class.build(env, schema) { not_here(1, 'a') {} } }
+
+    it 'raises error' do
+      expect { subject }.to raise_error(
+        NoMethodError, /undefined method `not_here'/
+      )
+    end
+  end
+end

data/spec/unit/rom/relation/class_methods/build_spec.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation, '.build' do
+  subject { described_class.build(relation, mapper) }
+
+  fake(:relation) { Axiom::Relation }
+  fake(:mapper)   { Mapper }
+
+  let(:mapped_relation) { mock('mapped_relation') }
+
+  before do
+    stub(mapper).call(relation) { mapped_relation }
+  end
+
+  its(:relation) { should be(mapped_relation) }
+  its(:mapper)   { should be(mapper) }
+end

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

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation, '#delete' do
+  include_context 'Relation'
+
+  subject { relation.delete(john) }
+
+  it { should be_instance_of(Relation) }
+
+  it 'deletes tuples from the relation' do
+    should_not include(john)
+  end
+end

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

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation, '#drop' do
+  include_context 'Relation'
+
+  it 'drops the relation by the given offset' do
+    expect(relation.drop(1).to_a).to eql([jane, jack, jade])
+  end
+end

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

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation, '#each' do
+  include_context 'Relation'
+
+  context 'with a block' do
+    it 'yields objects' do
+      retval = relation.each do |tuple|
+        expect(tuple).to be_instance_of(model)
+      end
+
+      expect(retval).to be(relation)
+    end
+  end
+
+  context 'without a block' do
+    it 'returns enumerator' do
+      expect(relation.each).to be_instance_of(Enumerator)
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation, '#first' do
+  include_context 'Relation'
+
+  context 'when limit is not provided' do
+    it 'returns first object' do
+      expect(relation.first.to_a).to eql([john])
+    end
+  end
+
+  context 'when limit is provided' do
+    it 'returns first n-objects' do
+      expect(relation.first(2).to_a).to eql([john, jane])
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation, '#inject_mapper' do
+  subject(:relation) { described_class.new([], mapper) }
+
+  fake(:mapper)
+  fake(:other_mapper) { Mapper }
+
+  it 'returns new relation with injected new mapper' do
+    other_relation = relation.inject_mapper(other_mapper)
+
+    expect(other_relation.relation).to be(relation.relation)
+    expect(other_relation.mapper).to be(other_mapper)
+  end
+end

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

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation, '#insert' do
+  include_context 'Relation'
+
+  let(:user) { model.new(name: 'Piotr') }
+
+  it 'inserts object into relation' do
+    expect(relation.insert(user).to_a).to include(user)
+  end
+end

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

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation, '#first' do
+  include_context 'Relation'
+
+  context 'when limit is not provided' do
+    it 'returns last object' do
+      expect(relation.last.to_a).to eql([jade])
+    end
+  end
+
+  context 'when limit is provided' do
+    it 'returns last n-objects' do
+      expect(relation.last(2).to_a).to eql([jack, jade])
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation, '#one' do
+  include_context 'Relation'
+
+  it 'limits the underlying relation' do
+    stub(relation).take(2) { [john] }
+    expect(relation.one).to eql(john)
+    relation.should have_received.take(2)
+  end
+
+  context 'when no block is given' do
+    context 'when one tuple is returned' do
+      it 'returns one object' do
+        expect(relation.restrict(name: 'John').one).to eql(john)
+      end
+    end
+
+    context 'when no tuple is returned' do
+      it 'raises NoTuplesError' do
+        expect { relation.restrict(name: 'unknown').one }.to raise_error(NoTuplesError)
+      end
+    end
+
+    context 'when more than one tuple is returned' do
+      let(:header) { [[:id, Integer], [:name, String]] }
+      let(:users)  { Axiom::Relation.new(header, [[1, 'Jane'], [2, 'Jane']]) }
+      let(:model)  { mock_model(:id, :name) }
+
+      it 'raises ManyTuplesError' do
+        expect { relation.restrict(name: 'Jane').one }.to raise_error(ManyTuplesError)
+      end
+    end
+  end
+
+  context 'when a block is given' do
+    let(:block) { ->() { raise error } }
+
+    context 'when no tuple is returned' do
+      let(:error) { Class.new(StandardError) }
+
+      it 'invokes the block' do
+        expect { relation.restrict(name: 'unknown').one(&block) }.to raise_error(error)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation, '#replace' do
+  subject(:relation) { described_class.new(users, mapper) }
+
+  include_context 'Relation'
+
+  it 'replaces the relation with a new one' do
+    expect(relation.replace([jane]).to_a).to eq([jane])
+  end
+end

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

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation, '#restrict' do
+  include_context 'Relation'
+
+  share_examples_for 'restricted relation' do
+    specify do
+      should eq([jane])
+    end
+  end
+
+  context 'with condition hash' do
+    subject { relation.restrict(name: 'Jane').to_a }
+
+    it_behaves_like 'restricted relation'
+  end
+
+  context 'with a block' do
+    subject { relation.restrict { |r| r.name.eq('Jane') }.to_a }
+
+    it_behaves_like 'restricted relation'
+  end
+end

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

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation, '#sort_by' do
+  include_context 'Relation'
+
+  share_examples_for 'sorted relation' do
+    specify do
+      should eql([jack, jade, jane, john])
+    end
+  end
+
+  context 'with a list of attribute names' do
+    subject { relation.sort_by([:name]).to_a }
+
+    it_behaves_like 'sorted relation'
+  end
+
+  context 'with a block' do
+    subject { relation.sort_by { |r| [r.name] }.to_a }
+
+    it_behaves_like 'sorted relation'
+  end
+end

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

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation, '#take' do
+  include_context 'Relation'
+
+  it 'returns first n-tuples' do
+    expect(relation.take(2).to_a).to eql([john, jane])
+  end
+end

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

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation, '#to_a' do
+  subject(:relation) { described_class.new(axiom_relation, mapper) }
+
+  let(:axiom_relation) { [1, 2] }
+  let(:loaded_objects) { %w(1 2) }
+  fake(:mapper)
+
+  before do
+    stub(mapper).load(1) { '1' }
+    stub(mapper).load(2) { '2' }
+  end
+
+  it 'gets all tuples and loads them via mapper' do
+    expect(relation.to_a).to eql(loaded_objects)
+  end
+end

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

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation, '#update' do
+  include_context 'Relation'
+
+  subject { relation.update(john, old_tuple) }
+
+  let!(:old_tuple) { relation.mapper.dump(john) }
+
+  it { should be_instance_of(Relation) }
+
+  before do
+    john.name = 'John Doe'
+  end
+
+  it 'replaces old object with the new one' do
+    expect(subject.restrict(name: 'John Doe').one).to eq(john)
+  end
+
+  it 'removes old object' do
+    expect(subject.restrict(name: 'John').count).to be(0)
+  end
+end

data/spec/unit/rom/repository/class_methods/build_spec.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Repository, '.build' do
+  subject { described_class.build(name, uri) }
+
+  let(:name) { :test }
+
+  context 'with a registered uri scheme' do
+    let(:uri) { Addressable::URI.parse('memory://test') }
+
+    it { should be_instance_of(described_class) }
+
+    its(:name)    { should be(name) }
+    its(:adapter) { should eq(Axiom::Adapter.build(uri)) }
+  end
+
+  context 'with an unregistered uri scheme' do
+    let(:uri) { Addressable::URI.parse('unregistered://test') }
+    let(:msg) { "#{uri.scheme.inspect} is no registered uri scheme" }
+
+    specify do
+      expect { subject }.to raise_error(Axiom::UnknownAdapterError, msg)
+    end
+  end
+end

data/spec/unit/rom/repository/element_reader_spec.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Repository, '#[]' do
+  subject { object[relation_name] }
+
+  let(:object) { described_class.build(name, uri) }
+  let(:name)   { :bigdata }
+  let(:uri)    { Addressable::URI.parse('memory://test') }
+
+  let(:relation)      { Axiom::Relation::Base.new(relation_name, header) }
+  let(:relation_name) { :test }
+  let(:header)        { [] }
+
+  before do
+    object[relation_name] = relation
+  end
+
+  it { should eq(relation) }
+end

data/spec/unit/rom/repository/element_writer_spec.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Repository, '#[]=' do
+  subject { object[:users] }
+
+  before do
+    object[:users] = relation
+  end
+
+  let(:object)   { Repository.build(:test, Addressable::URI.parse('memory://test')) }
+  let(:relation) { Axiom::Relation::Base.new(:users, []) }
+
+  it { should eq(relation) }
+
+  it { should be_instance_of(Axiom::Relation::Variable) }
+end

data/spec/unit/rom/schema/class_methods/build_spec.rb

@@ -0,0 +1,103 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Schema, '.build' do
+  include_context 'Environment'
+
+  let(:registry) { Hash[test: repository] }
+
+  let(:keys) { [:id] }
+
+  let(:schema) {
+    key_args = keys
+
+    described_class.build(registry) do
+      base_relation :users do
+        repository :test
+
+        attribute :id,   Integer
+        attribute :name, String
+
+        key(*key_args)
+      end
+    end
+  }
+
+  let(:header) {
+    Axiom::Relation::Header.coerce([[:id, Integer], [:name, String]], keys: keys)
+  }
+
+  let(:relation) {
+    Axiom::Relation::Base.new(:users, header)
+  }
+
+  fake(:repository)
+  fake(:gateway) { Axiom::Relation }
+
+  before do
+    stub(repository).[]=(:users, relation) { gateway }
+    stub(repository).[](:users) { gateway }
+  end
+
+  def self.it_registers_relation
+    it 'registers base relation in the repository' do
+      expect(subject[:users]).to be(gateway)
+      expect(repository).to have_received.[]=(:users, relation)
+    end
+  end
+
+  context 'defining base relations' do
+    subject { schema }
+
+    context 'with a single key' do
+      it_registers_relation
+    end
+
+    context 'with multiple keys' do
+      let(:keys) { [:id, :name] }
+
+      it_registers_relation
+    end
+  end
+
+  context 'defining relations' do
+    subject do
+      schema.call do
+        relation :restricted_users do
+          users.restrict(name: 'Jane')
+        end
+      end
+    end
+
+    it 'registers restricted relation' do
+      stub(gateway).restrict(name: 'Jane') { gateway }
+
+      expect(subject[:restricted_users]).to be(gateway)
+
+      expect(gateway).to have_received.restrict(name: 'Jane')
+    end
+
+    context 'when invalid relation name is used' do
+      subject do
+        schema.call do
+          relation :restricted_users do
+            not_here.restrict
+          end
+        end
+      end
+
+      it 'raises error' do
+        expect { subject }.to raise_error(
+          NameError, /method `not_here'/
+        )
+      end
+    end
+  end
+
+  context 'without block' do
+    subject { Schema.build({}) }
+
+    it { should be_instance_of(Schema) }
+  end
+end