ormivore 0.0.1

data/spec/adapters/shared_account.rb

@@ -0,0 +1,15 @@
+require_relative 'shared'
+
+shared_examples_for 'an account adapter' do
+  let(:attrs) do
+    v = test_value
+    { firstname: v, lastname: v, email: v, status: :active }
+  end
+
+  let(:test_attr) { :firstname }
+
+  let(:factory_name) { :account }
+  let(:factory_attrs) { {} }
+
+  it_behaves_like 'an adapter'
+end

data/spec/adapters/shared_address.rb

@@ -0,0 +1,21 @@
+require_relative 'shared'
+
+shared_examples_for 'an address adapter' do
+  let(:account_id) { FactoryGirl.create(:account, adapter: account_adapter).id }
+
+  let(:attrs) do
+    v = test_value
+    {
+      street_1: v, city: v, postal_code: v,
+      country_code: v, region_code: v,
+      type: :shipping, account_id: account_id
+    }
+  end
+
+  let(:test_attr) { :street_1 }
+
+  let(:factory_name) { :shipping_address }
+  let(:factory_attrs) { { account_id: account_id } }
+
+  it_behaves_like 'an adapter'
+end

data/spec/converters/account_sql_storage_converter_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe App::AccountSqlStorageConverter do
+  let(:attrs) do
+    v = 'Foo'
+    { firstname: v, lastname: v, email: v }
+  end
+
+  describe '#from_storage' do
+    it 'converts status attribute' do
+      subject.from_storage(attrs.merge(status: 1)).should include(status: :active)
+    end
+
+    it 'passes through other attributes' do
+      subject.from_storage(attrs.merge(status: 1)).should include(attrs)
+    end
+  end
+
+  describe '#to_storage' do
+    it 'converts status attribute' do
+      subject.to_storage(attrs.merge(status: :inactive)).should include(status: 2)
+    end
+
+    it 'passes through other attributes' do
+      subject.to_storage(attrs.merge(status: :inactive)).should include(attrs)
+    end
+  end
+end

data/spec/converters/address_sql_storage_converter_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe App::AddressSqlStorageConverter do
+  let(:attrs) do
+    v = 'Foo'
+    {
+      street_1: v, city: v, postal_code: v,
+      country_code: v, region_code: v
+    }
+  end
+
+  describe '#from_storage' do
+    it 'converts type attribute' do
+      subject.from_storage(attrs.merge(type: 'ShippingAddress')).should include(type: :shipping)
+      subject.from_storage(attrs.merge(type: 'BillingAddress')).should include(type: :billing)
+    end
+
+    it 'converts addressable id/type attributes to account_id' do
+      subject.from_storage(attrs.merge(addressable_type: 'Account', addressable_id: 123)).should include(account_id: 123)
+    end
+
+    it 'raises error converting unknown addressable_type' do
+      expect {
+        subject.from_storage(attrs.merge(addressable_type: 'Foo', addressable_id: 123))
+      }.to raise_error ORMivore::BadAttributesError
+    end
+
+    it 'passes through other attributes' do
+      subject.from_storage(attrs).should == attrs
+    end
+  end
+
+  describe '#to_storage' do
+    it 'converts status attribute' do
+      subject.to_storage(attrs.merge(type: :shipping)).should include(type: 'ShippingAddress')
+      subject.to_storage(attrs.merge(type: :billing)).should include(type: 'BillingAddress')
+    end
+
+    it 'converts account_id to addressable_id/type attributes' do
+      subject.to_storage(attrs.merge(account_id: 123)).should include(addressable_type: 'Account', addressable_id: 123)
+    end
+
+    it 'passes through other attributes' do
+      subject.to_storage(attrs).should == attrs
+    end
+  end
+end
+

data/spec/entities/account_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+require_relative 'shared'
+
+describe App::Account do
+  it_behaves_like 'an entity' do
+    let(:attrs) do
+      v = test_value
+      { firstname: v, lastname: v, email: v, status: :active }
+    end
+
+    let(:test_attr) { :firstname }
+  end
+end

data/spec/entities/address_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+require_relative 'shared'
+
+describe App::Address do
+  it_behaves_like 'an entity' do
+    let(:attrs) do
+      v = test_value
+      {
+        street_1: v, city: v, postal_code: v,
+        country_code: v, region_code: v,
+        type: :shipping, account_id: 1
+      }
+    end
+
+    let(:test_attr) { :street_1 }
+  end
+end

data/spec/entities/shared.rb

@@ -0,0 +1,114 @@
+shared_examples_for 'an entity' do
+  subject { described_class.new(attrs) }
+
+  let(:test_value) { 'Foo' }
+
+  describe '#initialize' do
+    it 'fails if no attributes are provided' do
+      expect {
+        described_class.new
+      }.to raise_error ArgumentError
+    end
+
+    it 'fails if not enough attributes are provided' do
+      expect {
+        described_class.new(test_attr => test_value)
+      }.to raise_error ORMivore::BadAttributesError
+    end
+
+    it 'fails if unknown attributes are specified' do
+       expect {
+        described_class.new(attrs.merge(foo: 'Foo'))
+      }.to raise_error ORMivore::BadAttributesError
+    end
+
+    it 'allows specifying id' do
+      o = described_class.construct(attrs, 123)
+      o.id.should == 123
+    end
+
+    it 'allows string id that is convertable to integer' do
+      o = described_class.construct(attrs, '123')
+      o.id.should == 123
+    end
+
+    it 'refuses non-integer id' do
+      expect {
+        described_class.construct(attrs, '123a')
+      }.to raise_error ORMivore::BadArgumentError
+    end
+
+    context 'when all mandatory attributes are specified' do
+      it 'succeeds' do
+        o = described_class.new(attrs)
+      end
+
+      context 'when some of them are keyed by strings (not symbols)' do
+        it 'succeeds' do
+          attrs.except!(test_attr).merge!(test_attr.to_s => test_value)
+          o = described_class.new(attrs)
+        end
+      end
+    end
+
+    context 'when id is specified' do
+      it 'assumes first param attributes to be "clean" attributes' do
+        o = described_class.construct(attrs, 123)
+        o.changes.should be_empty
+      end
+    end
+  end
+
+  describe '#attributes' do
+    it 'returns hash with all the model attributes keyed as symbols' do
+      subject.attributes.should == attrs
+    end
+
+    it 'combines clean and dirty attributes' do
+      o = described_class.construct(attrs, 123).apply(test_attr => 'dirty')
+      o.attributes.should == attrs.merge(test_attr => 'dirty')
+    end
+  end
+
+  describe 'attribute methods' do
+    it 'return value of attribute' do
+      subject.public_send(test_attr).should == test_value
+    end
+
+    it 'return dirty value of attribute if available' do
+      o = described_class.construct(attrs, 123).apply(test_attr => 'dirty')
+      o.changes.should == { test_attr => 'dirty' }
+      o.public_send(test_attr).should == 'dirty'
+    end
+  end
+
+  describe '#apply' do
+    subject { described_class.construct(attrs, 123) }
+
+    it 'creates copy of this entity' do
+      proto = subject.apply({})
+      proto.should_not == subject
+      proto.attributes.should == subject.attributes
+    end
+
+    it 'adds changes to the copy it makes' do
+      proto = subject.apply(test_attr => 'dirty')
+      proto.attributes.should == attrs.merge(test_attr => 'dirty')
+    end
+  end
+
+  describe '#changes' do
+    it 'returns all attributes on new entity' do
+      subject.changes.should == attrs
+    end
+
+    it 'returns no attributes on "persisted" entity' do
+      described_class.construct(attrs, 123).changes.should be_empty
+    end
+
+    it 'returns incremental changes added by applying attributes' do
+      o = described_class.construct(attrs, 123)
+      o.apply(test_attr => 'dirty').changes.should == { test_attr => 'dirty' }
+    end
+  end
+end

data/spec/factories.rb

@@ -0,0 +1,18 @@
+FactoryGirl.define do
+  factory :account, class: App::Account::Builder do
+    firstname 'John'
+    lastname 'Doe'
+    email 'test@test.com'
+    status :active
+  end
+
+  factory :shipping_address, class: App::Address::Builder do
+    street_1 'Some street 123'
+    street_2 'appartment 1'
+    city 'Test'
+    postal_code '12345'
+    country_code :US
+    region_code :PA
+    type :shipping
+  end
+end

data/spec/integration/account_repo_ar_integration_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+require_relative 'shared_account'
+require_relative '../adapters/ar_helpers'
+
+describe App::AccountRepo, :relational_db do
+  include ArHelpers
+
+  let(:entity_table) { 'accounts' }
+  let(:adapter) { App::AccountStorageArAdapter.new }
+
+  it_behaves_like 'an integrated account repo'
+end

data/spec/integration/account_repo_memory_integration_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+require_relative 'shared_account'
+require_relative '../adapters/memory_helpers'
+
+describe App::AccountRepo do
+  include MemoryHelpers
+
+  let(:adapter) { App::AccountStorageMemoryAdapter.new }
+
+  it_behaves_like 'an integrated account repo'
+end

data/spec/integration/address_repo_ar_integration_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+require_relative 'shared_address'
+require_relative '../adapters/ar_helpers'
+
+describe App::AddressRepo, :relational_db do
+  include ArHelpers
+
+  let(:account_adapter) { App::AccountStorageArAdapter.new }
+  let(:entity_table) { 'addresses' }
+  let(:adapter) { App::AddressStorageArAdapter.new }
+
+  it_behaves_like 'an integrated address repo'
+end

data/spec/integration/address_repo_memory_integration_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+require_relative 'shared_address'
+require_relative '../adapters/memory_helpers'
+
+describe App::AddressRepo do
+  include MemoryHelpers
+
+  let(:account_adapter) { App::AccountStorageMemoryAdapter.new }
+
+  let(:adapter) { App::AddressStorageMemoryAdapter.new }
+
+  it_behaves_like 'an integrated address repo'
+end

data/spec/integration/shared.rb

@@ -0,0 +1,74 @@
+shared_examples_for 'an integrated repo' do
+  let(:test_value) { 'Foo' }
+
+  def create_entity
+    FactoryGirl.create(
+      factory_name, factory_attrs.merge(adapter: adapter, test_attr => test_value)
+    ).attributes.symbolize_keys
+  end
+
+  subject { described_class.new(port) }
+
+  describe '#find_by_id' do
+    it 'loads entity if found' do
+      account = create_entity
+      subject.find_by_id(account[:id]).public_send(test_attr).should == test_value
+    end
+
+    it 'raises error if entity is not found' do
+      expect {
+        subject.find_by_id(123)
+      }.to raise_error ORMivore::RecordNotFound
+    end
+
+    context 'in quiet mode' do
+      it 'returns nil if entity is not found' do
+        subject.find_by_id(123, quiet: true).should be_nil
+      end
+    end
+  end
+
+  describe '#persist' do
+    context 'when entity is new' do
+      it 'creates and returns new entity' do
+        entity = entity_class.new(attrs)
+        saved_entity = subject.persist(entity)
+        saved_entity.should_not be_nil
+        saved_entity.attributes.should == attrs
+        saved_entity.id.should be_kind_of(Integer)
+
+        load_test_value(saved_entity.id).should == attrs[test_attr]
+      end
+
+      it 'creates entity with no "changes" recorded on it' do
+        entity = entity_class.new(attrs)
+        entity.changes.should == attrs
+        saved_entity = subject.persist(entity)
+        saved_entity.changes.should be_empty
+      end
+    end
+
+    context 'when entity is not new' do
+      let(:existing_entity_id) {
+        create_entity[:id]
+      }
+
+      it 'updates record in database' do
+        entity = entity_class.construct(attrs, existing_entity_id).apply(attrs)
+        saved_entity = subject.persist(entity)
+        saved_entity.should_not be_nil
+        saved_entity.attributes.should == attrs
+        saved_entity.id.should == existing_entity_id
+
+        load_test_value(saved_entity.id).should == attrs[test_attr]
+      end
+
+      it 'creates entity with no "changes" recorded on it' do
+        entity = entity_class.construct(attrs, existing_entity_id).apply(attrs)
+        entity.changes.should == attrs
+        saved_entity = subject.persist(entity)
+        saved_entity.changes.should be_empty
+      end
+    end
+  end
+end

data/spec/integration/shared_account.rb

@@ -0,0 +1,17 @@
+require_relative 'shared'
+
+shared_examples_for 'an integrated account repo' do
+  let(:attrs) do
+    v = test_value
+    { firstname: v, lastname: v, email: v, status: :active }
+  end
+
+  let(:test_attr) { :firstname }
+  let(:entity_class) { App::Account }
+  let(:port) { App::AccountStoragePort.new(adapter) }
+
+  let(:factory_name) { :account }
+  let(:factory_attrs) { {} }
+
+  it_behaves_like 'an integrated repo'
+end

data/spec/integration/shared_address.rb

@@ -0,0 +1,23 @@
+require_relative 'shared'
+
+shared_examples_for 'an integrated address repo' do
+  let(:account_id) { FactoryGirl.create(:account, adapter: account_adapter).id }
+
+  let(:attrs) do
+    v = test_value
+    {
+      street_1: v, city: v, postal_code: v,
+      country_code: v, region_code: v,
+      type: :shipping, account_id: account_id
+    }
+  end
+
+  let(:test_attr) { :street_1 }
+  let(:entity_class) { App::Address }
+  let(:port) { App::AddressStoragePort.new(adapter) }
+
+  let(:factory_name) { :shipping_address }
+  let(:factory_attrs) { { account_id: account_id } }
+
+  it_behaves_like 'an integrated repo'
+end