rom 0.1.2 → 0.2.0

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/relation/wrap_spec.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation, '#wrap' do
+  let(:users) { Relation.new(user_relation, user_mapper) }
+  let(:tasks) { Relation.new(task_relation, task_mapper) }
+
+  fake(:user_relation) { Axiom::Relation }
+  fake(:user_mapper) { Mapper }
+
+  fake(:task_relation) { Axiom::Relation }
+  fake(:task_header) { Axiom::Relation::Header }
+  fake(:task_mapper) { Mapper }
+
+  fake(:wrapped_relation) { Axiom::Relation }
+  fake(:wrapped_mapper) { Mapper }
+
+  it "wraps relation and mapper" do
+    stub(task_relation).header { task_header }
+    stub(user_relation).wrap(:tasks => task_header) { wrapped_relation }
+    stub(user_mapper).wrap(:tasks => task_mapper) { wrapped_mapper }
+
+    expect(users.wrap(:tasks => tasks)).to eql(Relation.new(wrapped_relation, wrapped_mapper))
+
+    expect(user_relation).to have_received.wrap(:tasks => task_header)
+    expect(user_mapper).to have_received.wrap(:tasks => task_mapper)
+  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::Materialized) }
+end

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

@@ -0,0 +1,103 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Schema::Builder, '.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::Builder.build({}) }
+
+    it { should be_instance_of(Schema::Builder) }
+  end
+end

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

@@ -0,0 +1,15 @@
+require "spec_helper"
+
+describe Schema, "#[]" do
+  subject(:schema) { Schema.new(users: relation) }
+
+  fake(:relation)
+
+  it "returns registered relation" do
+    expect(schema[:users]).to be(relation)
+  end
+
+  it "raises error when relation is missing" do
+    expect { schema[:not_here] }.to raise_error
+  end
+end

data/spec/unit/rom/session/class_methods/start_spec.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Session, '.start' do
+  include_context 'Session::Relation'
+
+  let(:user) { model.new(id: 3, name: 'Piotr') }
+
+  it 'starts a new session' do
+    Session.start(users: relation) do |session|
+      expect(session).to be_clean
+      expect(session).to be_instance_of(Session)
+      expect(session[:users]).to be_instance_of(Session::Relation)
+
+      session[:users].track(user).save(user)
+
+      session.flush
+    end
+
+    expect(relation.to_a).to include(user)
+  end
+end

data/spec/unit/rom/session/clean_predicate_spec.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Session, '#clean?' do
+  subject { session.clean? }
+
+  include_context 'Session::Relation'
+
+  context 'when tracker has no pending state changes' do
+    it { should be_true }
+  end
+
+  context 'when tracker has pending state changes' do
+    before do
+      session[:users].delete(user)
+    end
+
+    it { should be_false }
+  end
+end

data/spec/unit/rom/session/environment/element_reader_spec.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Session::Environment, '#[]' do
+  subject { object[:users] }
+
+  include_context 'Session::Environment'
+
+  it 'returns session relation proxy' do
+    expect(subject).to be_kind_of(Session::Relation)
+  end
+end

data/spec/unit/rom/session/flush_spec.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Session, '#flush' do
+  subject { session.flush }
+
+  include_context 'Session::Relation'
+
+  let(:object) { session }
+
+  let(:john)  { session[:users].to_a.first }
+  let(:jane)  { session[:users].to_a.last }
+  let(:piotr) { session[:users].new(id: 3, name: 'Piotr') }
+
+  before do
+    session[:users].delete(john)
+
+    jane.name = 'Jane Doe'
+    session[:users].save(jane)
+
+    session[:users].save(piotr)
+  end
+
+  it_behaves_like 'a command method'
+
+  it { should be_clean }
+
+  it 'commits all deletes' do
+    expect(subject[:users].to_a).to_not include(john)
+  end
+
+  it 'commits all updates' do
+    expect(subject[:users].to_a.first).to eq(relation.to_a.first)
+  end
+
+  it 'commits all inserts' do
+    expect(subject[:users].to_a).to include(piotr)
+  end
+
+  it 'sets correct state for created objects' do
+    expect(subject[:users].state(piotr)).to be_persisted
+    expect(subject[:users].dirty?(piotr)).to be(false)
+  end
+
+  it 'registers newly created object in the IM' do
+    expect(subject[:users].restrict { |r| r.name.eq('Piotr') }.to_a.first).to be(piotr)
+  end
+
+  it 'sets correct state for updated objects' do
+    expect(subject[:users].state(jane)).to be_persisted
+  end
+
+  it 'sets correct state for deleted objects' do
+    expect(subject[:users].state(john)).to be_frozen
+  end
+
+end

data/spec/unit/rom/session/mapper/load_spec.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Session::Mapper, '#load' do
+  subject { object.load(tuple) }
+
+  let(:object) { described_class.new(mapper, tracker, im) }
+
+  let(:mapper) { fake(:mapper) { ROM::Mapper } }
+
+  let(:tuple)    { Hash[id: identity, name: 'Jane'] }
+  let(:identity) { [1] }
+  let(:user)     { model.new(tuple) }
+  let(:model)    { mock_model(:id, :name) }
+  let(:im)       { Session::IdentityMap.build }
+  let(:tracker)  { Session::Tracker.new }
+
+  before do
+    stub(mapper).identity_from_tuple(tuple) { identity }
+    stub(mapper).identity(user) { identity }
+    stub(mapper).load(tuple) { user }
+  end
+
+  context 'when IM does not include the loaded object' do
+    it 'loads the object' do
+      expect(subject).to be(user)
+      mapper.should have_received.load(tuple)
+    end
+
+    it 'stores persisted state in the tracker' do
+      expect(subject).to be(user)
+      expect(tracker.fetch(identity)).to be_persisted
+    end
+  end
+
+  context 'when IM includes the loaded object' do
+    before do
+      im.store(identity, user, tuple)
+    end
+
+    it 'returns already loaded object' do
+      expect(subject).to be(user)
+      mapper.should_not have_received.load(tuple)
+    end
+  end
+end