rom 0.1.2 → 0.2.0

data/spec/unit/rom/mapper/header/rename_spec.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Mapper::Header, '#rename' do
+  subject(:header) { Mapper::Header.build([[:id], [:name]]) }
+
+  it 'returns a new header with renamed attributes' do
+    expect(header.rename(:id => :user_id)).to eql(Mapper::Header.build([[:user_id], [:name]]))
+  end
+end

data/spec/unit/rom/mapper/header/to_ast_spec.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Mapper::Header, '#to_ast' do
+  subject(:header) { Mapper::Header.build([[:id], [:name]]) }
+
+  it 'returns a morpher transformer node that can load an attribute hash' do
+    expect(Morpher.compile(header.to_ast).call(id: 1, name: 'Jane', other: 'Foo')).to eql(id: 1, name: 'Jane')
+  end
+end

data/spec/unit/rom/mapper/header/wrap_spec.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Mapper::Header, '#wrap' do
+  subject(:header) { left.wrap(model: mapper) }
+
+  let(:left) { Mapper::Header.build([[:id], [:name]]) }
+  let(:mapper) { Mapper.build([[:id], [:title]]) }
+
+  it 'returns a header with embedded value attribute' do
+    expected = Mapper::Header.build([
+      [:id], [:name], mapper.attribute(Mapper::Attribute::EmbeddedValue, :model)
+    ])
+
+    expect(header).to eq(expected)
+  end
+end

data/spec/unit/rom/mapper/identity_from_tuple_spec.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Mapper, '#identity_from_tuple' do
+  subject { mapper.identity_from_tuple(tuple) }
+
+  include_context 'Mapper'
+
+  it { should eq([1]) }
+end

data/spec/unit/rom/mapper/identity_spec.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Mapper, '#identity' do
+  subject { mapper.identity(object) }
+
+  include_context 'Mapper'
+
+  it { should eq([1]) }
+end

data/spec/unit/rom/mapper/join_spec.rb

@@ -0,0 +1,15 @@
+require "spec_helper"
+
+describe Mapper, "#join" do
+  let(:task) { Mapper.build([[:title]], model: task_model) }
+  let(:user) { Mapper.build([[:name]], model: user_model) }
+
+  let(:task_model) { mock_model(:title) }
+  let(:user_model) { mock_model(:name) }
+
+  subject(:mapper) { task.join(user) }
+
+  it "returns a mapper with joined headers" do
+    expect(mapper).to eql(Mapper.build([[:title], [:name]], model: task_model))
+  end
+end

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

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Mapper, '#load' do
+  include_context 'Mapper'
+
+  it 'loads the tuple into model' do
+    expect(mapper.load(tuple)).to eql(object)
+  end
+end

data/spec/unit/rom/mapper/new_object_spec.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Mapper, '#new_object' do
+  subject { mapper.new_object(name: 'Jane', &block) }
+
+  include_context 'Mapper'
+
+  let(:attributes) { Hash[id: 1, name: 'Jane'] }
+  let(:block)      { proc { self.id = 1 } }
+
+  it { should eql(model.new(attributes)) }
+end

data/spec/unit/rom/mapper/project_spec.rb

@@ -0,0 +1,11 @@
+require "spec_helper"
+
+describe Mapper, "#project" do
+  let(:task) { Mapper.build([[:id, from: :user_id], [:name]]) }
+
+  subject(:mapper) { task.project([:user_id]) }
+
+  it "returns a mapper with a projected header" do
+    expect(mapper).to eql(Mapper.build([[:id, from: :user_id]]))
+  end
+end

data/spec/unit/rom/mapper/rename_spec.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Mapper, '#rename' do
+  include_context 'Mapper'
+
+  let(:model) { mock_model(:user_id, :user_name) }
+
+  it 'renames attributes' do
+    tuple = { :user_id => 1, :user_name => 'Jane' }
+    user = model.new(:user_id => 1, :user_name => 'Jane')
+
+    expect(mapper.rename(:id => :user_id, :name => :user_name).load(tuple)).to eql(user)
+  end
+end

data/spec/unit/rom/mapper/wrap_spec.rb

@@ -0,0 +1,35 @@
+require "spec_helper"
+
+describe Mapper, "#wrap" do
+  let(:task) { Mapper.build([[:title]], model: task_model) }
+  let(:user) { Mapper.build([[:id], [:name]], model: user_model) }
+
+  let(:task_model) { mock_model(:title, :user) }
+  let(:user_model) { mock_model(:id, :name) }
+
+  subject(:mapper) { task.wrap(user: user) }
+
+  let(:loader_transformer) do
+    Morpher.compile(
+      s(:block,
+        s(:hash_transform,
+          s(:block, s(:key_fetch, :title), s(:key_dump, :title)),
+          s(:key_transform, :user, :user, user.loader.node)
+         ),
+        s(:load_instance_variables, s(:param, task_model, :title, :user))
+       )
+    )
+  end
+
+  let(:dumper_transformer) do
+    loader_transformer.inverse
+  end
+
+  it "returns a mapper that can load wrapped tuples" do
+    expect(mapper.loader).to eq(loader_transformer)
+  end
+
+  it "returns a mapper that can dump wrapped objects" do
+    expect(mapper.dumper).to eq(dumper_transformer)
+  end
+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/group_spec.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation, '#group' 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(:groupped_relation) { Axiom::Relation }
+  fake(:groupped_mapper) { Mapper }
+
+  it "groups relation and mapper" do
+    stub(task_relation).header { task_header }
+    stub(user_relation).group(:tasks => task_header) { groupped_relation }
+    stub(user_mapper).group(:tasks => task_mapper) { groupped_mapper }
+
+    expect(users.group(:tasks => tasks)).to eql(Relation.new(groupped_relation, groupped_mapper))
+
+    expect(user_relation).to have_received.group(:tasks => task_header)
+    expect(user_mapper).to have_received.group(:tasks => task_mapper)
+  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, '#last' 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/rename_spec.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation, '#rename' do
+  subject(:relation) { users.rename(:user_name => :name) }
+
+  let(:users) do
+    Relation.new(
+      Axiom::Relation.new([[:user_name, String]], [['Jane']]),
+      Mapper.build([[:user_name]], model: model)
+    )
+  end
+
+  let(:model) { mock_model(:name) }
+  let(:user) { model.new(name: 'Jane') }
+
+  it "renames the attributes" do
+    expect(relation.to_a.first).to eql(user)
+  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