rom 0.2.0 → 0.3.0

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

@@ -1,25 +0,0 @@
-# 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

@@ -1,25 +0,0 @@
-# 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

@@ -1,11 +0,0 @@
-# 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

@@ -1,20 +0,0 @@
-# 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

@@ -1,25 +0,0 @@
-# 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

@@ -1,29 +0,0 @@
-# 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

@@ -1,27 +0,0 @@
-# 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

@@ -1,21 +0,0 @@
-# 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

@@ -1,18 +0,0 @@
-# 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

@@ -1,103 +0,0 @@
-# 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

@@ -1,15 +0,0 @@
-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

@@ -1,23 +0,0 @@
-# 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

@@ -1,21 +0,0 @@
-# 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

@@ -1,13 +0,0 @@
-# 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

@@ -1,58 +0,0 @@
-# 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