rom 0.1.2 → 0.2.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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