rom 0.2.0 → 0.3.0

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

@@ -1,13 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mapper::Header, '#project' do
-  subject(:header) { other.project([:id]) }
-
-  let(:other) { Mapper::Header.build([[:id], [:name]]) }
-
-  it 'returns a header with projected attributes' do
-    expect(header).to eql(Mapper::Header.build([[:id]]))
-  end
-end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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