rom 0.2.0 → 0.3.0

data/spec/unit/rom/environment/builder/mapping_spec.rb

@@ -1,24 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Environment::Builder, '#mapping' do
-  subject(:builder) { Environment::Builder.call(test: "memory://test") }
-
-  let!(:schema) do
-    builder.schema do
-      base_relation(:users) do
-        repository :test
-        attribute :name, String
-      end
-    end
-  end
-
-  it 'sets up rom mapper' do
-    builder.mapping do
-      relation(:users) { map :name }
-    end
-
-    expect(builder.mappers[:users]).to be_instance_of(Mapper)
-  end
-end

data/spec/unit/rom/environment/builder/schema_spec.rb

@@ -1,33 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Environment::Builder, '#schema' do
-  let(:repositories) { Hash.new }
-  let(:object)       { Environment::Builder.call(test: "memory://test") }
-  let(:block)        { -> { } }
-
-  fake(:builder) { Schema::Builder }
-
-  before do
-    fake_class(Schema::Builder, build: -> { builder })
-  end
-
-  describe 'with a block' do
-    subject { object.schema(&block) }
-
-    it 'calls the schema' do
-      expect(subject).to be(builder)
-      expect(builder).to have_received.call
-    end
-  end
-
-  describe 'without a block' do
-    subject { object.schema }
-
-    it 'calls the schema' do
-      expect(subject).to be(builder)
-      expect(builder).not_to have_received.call
-    end
-  end
-end

data/spec/unit/rom/environment/class_methods/setup_spec.rb

@@ -1,18 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Environment, '.setup' do
-  subject { described_class.setup(config).finalize }
-
-  context 'when a repository config hash is passed' do
-    let(:config) { { name => uri } }
-    let(:name)   { :test }
-    let(:uri)    { 'memory://test' }
-
-    let(:coerced_config) { Hash[test: Repository.build(name, coerced_uri)] }
-    let(:coerced_uri)    { Addressable::URI.parse(uri) }
-
-    its(:repositories) { should eql(described_class.new(coerced_config, {}, {}, {}).repositories) }
-  end
-end

data/spec/unit/rom/environment/repository_spec.rb

@@ -1,21 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Environment, '#repository' do
-  include_context 'Environment'
-
-  subject { object.repository(name) }
-
-  context 'when repository exists' do
-    let(:name) { :test }
-
-    it { should be_instance_of(Repository) }
-  end
-
-  context 'when is not known' do
-    let(:name) { :not_here }
-
-    it { should be(nil) }
-  end
-end

data/spec/unit/rom/mapper/attribute/embedded_collection/to_ast_spec.rb

@@ -1,18 +0,0 @@
-require "spec_helper"
-
-describe Mapper::Attribute::EmbeddedCollection, '#to_ast' do
-  subject(:attribute) { Mapper::Attribute::EmbeddedCollection.build(:tasks, node: mapper.loader.node) }
-
-  let(:mapper) { Mapper.build([[:id]], model: model) }
-  let(:model) { mock_model(:id) }
-
-  it 'returns a morpher transformer node' do
-    loader = Morpher.compile(attribute.to_ast)
-
-    task1 = model.new(id: 1)
-    task2 = model.new(id: 1)
-    tuple = { tasks: [{ id: 1 }, { id: 1 }] }
-
-    expect(loader.call(tuple)).to eql([:tasks, [task1, task2]])
-  end
-end

data/spec/unit/rom/mapper/attribute/embedded_value/to_ast_spec.rb

@@ -1,16 +0,0 @@
-require "spec_helper"
-
-describe Mapper::Attribute::EmbeddedValue, '#to_ast' do
-  subject(:attribute) { Mapper::Attribute::EmbeddedValue.build(:model, node: mapper.loader.node) }
-
-  let(:mapper) { Mapper.build([[:id]], model: model) }
-  let(:model) { mock_model(:id) }
-
-  it 'returns a morpher transformer node' do
-    loader = Morpher.compile(attribute.to_ast)
-    object = model.new(id: 1)
-    tuple  = { model: { id: 1 } }
-
-    expect(loader.call(tuple)).to eql([:model, object])
-  end
-end

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

@@ -1,9 +0,0 @@
-require "spec_helper"
-
-describe Mapper::Attribute, '#rename' do
-  subject(:attribute) { Mapper::Attribute.build(:title) }
-
-  it 'returns a new attribute with changed name' do
-    expect(attribute.rename(:book_title)).to eql(Mapper::Attribute.build(:book_title))
-  end
-end

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

@@ -1,9 +0,0 @@
-require "spec_helper"
-
-describe Mapper::Attribute, '#to_ast' do
-  subject(:attribute) { Mapper::Attribute.build(:title) }
-
-  it 'returns a morpher transformer node' do
-    expect(Morpher.compile(attribute.to_ast).call(title: 'Title', other: 'Foo')).to eql([:title, 'Title'])
-  end
-end

data/spec/unit/rom/mapper/builder/class_methods/call_spec.rb

@@ -1,61 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mapper::Builder, '.call' 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
-    let(:mapper) { subject.mappers[:users] }
-
-    subject do
-      user_model = model
-
-      Mapper::Builder.call(schema) do
-        relation(:users) do
-          model user_model
-
-          map :id, :email
-          map :name, from: :user_name
-        end
-      end
-    end
-
-    it 'builds rom mapper' do
-      expect(mapper.header.map(&:name)).to eql([:id, :email, :name])
-      expect(mapper.header.map(&:type)).to eql([Integer, String, 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 injected' do
-    subject do
-      custom_mapper = test_mapper
-      Mapper::Builder.call(schema) { relation(:users) { mapper(custom_mapper) } }
-    end
-
-    let(:test_mapper) { TestMapper.new(header, model) }
-
-    it 'sets the custom mapper' do
-      expect(subject.mappers[:users]).to be(test_mapper)
-    end
-  end
-
-  context 'when unknown relation name is used' do
-    subject { described_class.call(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/mapper/class_methods/build_spec.rb

@@ -1,55 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mapper, '.build' do
-  subject { described_class.build(header, model: model) }
-
-  let(:model)      { mock_model(:name) }
-  let(:attributes) { [[:name, type: String, from: :user_name]] }
-
-  describe 'when header is a primitive' do
-    let(:header) { attributes }
-
-    its(:model)  { should be(model) }
-
-    it 'builds correct header' do
-      expect(subject.header.mapping).to eql(user_name: :name)
-    end
-
-    let(:object) { model.new(name: 'Jane') }
-    let(:params) { Hash[user_name: 'Jane'] }
-
-    specify do
-      expect(subject.load(params)).to eq(object)
-    end
-
-    specify do
-      expect(subject.dump(object)).to eq(params.values)
-    end
-  end
-
-  describe 'when header is a mapper header instance' do
-    let(:header)  { Mapper::Header.build(attributes) }
-    let(:options) { Hash.new }
-
-    its(:model)  { should be(model) }
-    its(:header) { should eql(header) }
-  end
-
-  describe 'when options has custom loader' do
-    let(:header)  { Mapper::Header.build(attributes) }
-    let(:options) { Hash[loader: :load_attribute_hash] }
-
-    its(:model)  { should be(model) }
-    its(:header) { should eql(header) }
-  end
-
-  describe 'loader is set to :load_attribute_accessors' do
-    let(:header)  { Mapper::Header.build(attributes) }
-    let(:options) { Hash[loader: :load_attribute_accessors] }
-
-    its(:model)  { should be(model) }
-    its(:header) { should eql(header) }
-  end
-end

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

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

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

@@ -1,35 +0,0 @@
-require "spec_helper"
-
-describe Mapper, "#group" do
-  subject(:mapper) { user.group(tasks: task) }
-
-  let(:user) { Mapper.build([[:name]], model: user_model) }
-  let(:task) { Mapper.build([[:title]], model: task_model) }
-
-  let(:user_model) { mock_model(:name, :tasks) }
-  let(:task_model) { mock_model(:title) }
-
-  let(:loader_transformer) do
-    Morpher.compile(
-      s(:block,
-        s(:hash_transform,
-          s(:block, s(:key_fetch, :name), s(:key_dump, :name)),
-          s(:key_transform, :tasks, :tasks, s(:map, task.loader.node))
-         ),
-        s(:load_instance_variables, s(:param, user_model, :name, :tasks))
-       )
-    )
-  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/mapper/header/each_spec.rb

@@ -1,26 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mapper::Header, '#each' do
-  subject(:header) { Mapper::Header.build([[:id], [:name]]) }
-
-  let(:id) { header[:id] }
-  let(:name) { header[:name] }
-
-  context 'with a block' do
-    it 'yields attributes' do
-      result = []
-
-      header.each { |attribute| result << attribute }
-
-      expect(result).to eql([id, name])
-    end
-  end
-
-  context 'without a block' do
-    subject { header.each }
-
-    it { should be_instance_of(Enumerator) }
-  end
-end

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

@@ -1,21 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mapper::Header, '#[]' do
-  subject(:header) { Mapper::Header.build([[:id]]) }
-
-  context 'when attribute exists' do
-    subject { header[:id] }
-
-    let(:id) { Mapper::Attribute.build(:id) }
-
-    it { should eql(id) }
-  end
-
-  context 'when attribute does not exist' do
-    specify do
-      expect { header[:not_here] }.to raise_error(KeyError)
-    end
-  end
-end

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

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

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

@@ -1,14 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mapper::Header, '#join' do
-  subject(:header) { left.join(right) }
-
-  let(:left) { Mapper::Header.build([[:id], [:name]]) }
-  let(:right) { Mapper::Header.build([[:id], [:title]]) }
-
-  it 'returns a joined header with uniq attributes' do
-    expect(header).to eql(Mapper::Header.build([[:id], [:name], [:title]]))
-  end
-end

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

@@ -1,29 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mapper::Header, '#keys' do
-  subject { object.keys }
-
-  let(:object)  { Mapper::Header.build(attributes) }
-  let(:id)      { object[:id] }
-  let(:name)    { object[:name] }
-
-  context 'without mapping' do
-    let(:attributes) { [[:id], [:name]] }
-
-    it { should eql([]) }
-  end
-
-  context 'with mapping' do
-    let(:attributes) { [[:id, from: :user_id, key: true], [:name]] }
-
-    it { should eql([id]) }
-  end
-
-  context 'with multiple keys' do
-    let(:attributes) { [[:id, key: true], [:name, key: true]] }
-
-    it { should eql([id, name]) }
-  end
-end