datamappify 0.30.0 → 0.40.0

data/spec/repository/persistence_spec.rb

@@ -1,158 +1,80 @@
-require_relative '../spec_helper'
+require 'spec_helper'
 
 shared_examples_for "repository persistence" do |data_provider|
-  let!(:user_repository)     { "UserRepository#{data_provider}".constantize }
-  let(:existing_user)        { user_repository.save(User.new(:first_name => 'Fred', :driver_license => 'FREDWU42')) }
-  let(:new_valid_user)       { User.new(:first_name => 'Batman', :driver_license => 'ARKHAMCITY') }
-  let(:new_valid_user2)      { User.new(:first_name => 'Ironman', :driver_license => 'NEWYORKCITY') }
-  let(:new_invalid_user)     { User.new(:first_name => 'a') }
-  let(:new_invalid_user2)    { User.new(:first_name => 'b') }
-  let(:data_passports)       { "Datamappify::Data::Record::#{data_provider}::UserPassport".constantize }
-  let(:data_driver_licenses) { "Datamappify::Data::Record::#{data_provider}::UserDriverLicense".constantize }
-
-  describe "#find" do
-    describe "resource" do
+  include_context "user repository", data_provider
+
+  context "#{data_provider}" do
+    describe "#find" do
       it "found" do
         user_repository.find(existing_user.id).should == existing_user
-        user_repository.find([existing_user.id]).should == [existing_user]
       end
 
       it "not found" do
-        user_repository.find(42).should == nil
+        user_repository.find(233).should == nil
       end
     end
 
-    describe "collection" do
-      it "found" do
-        user_repository.find([existing_user.id]).should == [existing_user]
-      end
+    [:create, :create!, :update, :update!, :save, :save!].each do |query_method|
+      let(:query_method) { query_method }
 
-      it "partial found" do
-        user_repository.find([existing_user.id, 42]).should == [existing_user]
-      end
+      describe "##{query_method}" do
+        it "success" do
+          new_user = nil
 
-      it "not found" do
-        user_repository.find([42, 255]).should == []
-      end
-    end
-  end
-
-  describe "#save" do
-    it "success" do
-      new_user = nil
+          expect { new_user = user_repository.send(query_method, new_valid_user) }.to change { user_repository.count }.by(1)
 
-      expect { new_user = user_repository.save(new_valid_user) }.to change { user_repository.count }.by(1)
-
-      new_user.should be_kind_of(User)
-      new_user.first_name.should == 'Batman'
-      new_user.driver_license.should == 'ARKHAMCITY'
-    end
-
-    it "failure" do
-      -> { user_repository.save!(new_invalid_user) }.should raise_error(Datamappify::Data::EntityNotSaved)
-    end
-
-    it "transaction" do
-      new_valid_user.passport = 'DEVOPS'
-
-      save_action = Proc.new { -> { user_repository.save(new_valid_user) }.should raise_error }
-
-      expect { save_action.call }.to change { user_repository.count }.by(0)
-      expect { save_action.call }.to change { data_passports.count }.by(0)
-      expect { save_action.call }.to change { data_driver_licenses.count }.by(0)
-    end
-
-    describe "update multiple entities" do
-      describe "#save" do
-        it "all successes" do
-          expect { user_repository.save([new_valid_user, new_valid_user2]) }.to change { user_repository.count }.by(2)
+          new_user.should be_kind_of(User)
+          new_user.first_name.should == 'Batman'
+          new_user.driver_license.should == 'ARKHAMCITY'
         end
 
-        it "successes + failures" do
-          expect { user_repository.save([new_valid_user, new_invalid_user]) }.to change { user_repository.count }.by(1)
+        it "failure" do
+          -> { user_repository.save!(new_invalid_user) }.should raise_error(Datamappify::Data::EntityNotSaved)
         end
 
-        it "all failures" do
-          expect { user_repository.save([new_invalid_user, new_invalid_user2]) }.to change { user_repository.count }.by(0)
-        end
-      end
+        it "updates existing records" do
+          existing_user.first_name = 'Vivian'
+          existing_user.driver_license = 'LOCOMOTE'
 
-      describe "#save!" do
-        it "all successes" do
-          expect { user_repository.save!([new_valid_user, new_valid_user2]) }.to change { user_repository.count }.by(2)
-        end
+          updated_user = nil
 
-        it "successes + failures" do
-          expect { -> { user_repository.save!([new_valid_user, new_invalid_user]) }.should raise_error(Datamappify::Data::EntityNotSaved) }.to change { user_repository.count }.by(1)
-        end
-
-        it "all failures" do
-          expect { -> { user_repository.save!([new_invalid_user, new_invalid_user2]) }.should raise_error(Datamappify::Data::EntityNotSaved) }.to change { user_repository.count }.by(0)
-        end
-      end
-    end
+          expect { updated_user = user_repository.send(query_method, existing_user) }.to change { user_repository.count }.by(0)
 
-    describe "update an existing entity" do
-      it "updates existing records" do
-        existing_user.first_name = 'Vivian'
-        existing_user.driver_license = 'LOCOMOTE'
+          updated_user.first_name.should == 'Vivian'
+          updated_user.driver_license.should == 'LOCOMOTE'
 
-        updated_user = nil
+          persisted_user = user_repository.find(updated_user.id)
 
-        expect { updated_user = user_repository.save(existing_user) }.to change { user_repository.count }.by(0)
-
-        updated_user.first_name.should == 'Vivian'
-        updated_user.driver_license.should == 'LOCOMOTE'
-
-        persisted_user = user_repository.find(updated_user.id)
-
-        persisted_user.first_name.should == 'Vivian'
-        persisted_user.driver_license.should == 'LOCOMOTE'
-      end
+          persisted_user.first_name.should == 'Vivian'
+          persisted_user.driver_license.should == 'LOCOMOTE'
+        end
 
-      it "updates existing and new records" do
-        existing_user.first_name = 'Vivian'
-        existing_user.health_care = 'BATMANCAVE'
+        it "updates existing and new records" do
+          existing_user.first_name = 'Vivian'
+          existing_user.health_care = 'BATMANCAVE'
 
-        updated_user = nil
+          updated_user = nil
 
-        expect { updated_user = user_repository.save(existing_user) }.to change { user_repository.count }.by(0)
+          expect { updated_user = user_repository.send(query_method, existing_user) }.to change { user_repository.count }.by(0)
 
-        updated_user.first_name.should == 'Vivian'
-        updated_user.health_care.should == 'BATMANCAVE'
+          updated_user.first_name.should == 'Vivian'
+          updated_user.health_care.should == 'BATMANCAVE'
 
-        persisted_user = user_repository.find(updated_user.id)
+          persisted_user = user_repository.find(updated_user.id)
 
-        persisted_user.first_name.should == 'Vivian'
-        persisted_user.health_care.should == 'BATMANCAVE'
+          persisted_user.first_name.should == 'Vivian'
+          persisted_user.health_care.should == 'BATMANCAVE'
+        end
       end
     end
-  end
 
-  describe "#destroy" do
-    describe "resource" do
+    describe "#destroy" do
       let!(:user) { user_repository.save(new_valid_user) }
 
-      it "via id" do
-        expect { user_repository.destroy!(user.id) }.to change { user_repository.count }.by(-1)
-      end
-
-      it "via entity" do
+      it "destroys an entity" do
         expect { user_repository.destroy!(user) }.to change { user_repository.count }.by(-1)
       end
     end
-
-    describe "collection" do
-      let!(:users) { user_repository.save([new_valid_user, new_valid_user2]) }
-
-      it "via id" do
-        expect { user_repository.destroy!(users.map(&:id)) }.to change { user_repository.count }.by(-2)
-      end
-
-      it "via entity" do
-        expect { user_repository.destroy!(users) }.to change { user_repository.count }.by(-2)
-      end
-    end
   end
 end
 

data/spec/repository/transactions_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+shared_examples_for "transactions" do |data_provider|
+  include_context "user repository", data_provider
+
+  context "#{data_provider}" do
+    describe "#save" do
+      it "raises error upon transaction failure" do
+        new_valid_user.passport = 'DEVOPS'
+
+        save_action = Proc.new { -> { user_repository.save(new_valid_user) }.should raise_error }
+
+        expect { save_action.call }.to change { user_repository.count }.by(0)
+        expect { save_action.call }.to change { data_passports.count }.by(0)
+        expect { save_action.call }.to change { data_driver_licenses.count }.by(0)
+      end
+    end
+  end
+end
+
+describe Datamappify::Repository do
+  DATA_PROVIDERS.each do |data_provider|
+    it_behaves_like "transactions", data_provider
+  end
+end

data/spec/repository/validation_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+shared_examples_for "repository (in)validation" do |data_provider|
+  include_context "user repository", data_provider
+
+  context "#{data_provider}" do
+    describe "invalid" do
+      let(:invalid_user) { User.new(:first_name => 'F') }
+
+      after do
+        invalid_user.id.should be_nil
+      end
+
+      it "makes sure the entity is invalid" do
+        invalid_user.valid?.should == false
+      end
+
+      it "doesn't persist the entity" do
+        user_repository.save(invalid_user).should == false
+      end
+    end
+
+    describe "valid" do
+      let(:valid_user) { User.new(:first_name => 'Fred', :driver_license => 'MOSDEVOPS') }
+
+      it "makes sure the entity is invalid" do
+        valid_user.valid?.should == true
+      end
+
+      it "does persist the entity" do
+        user_repository.save(valid_user).should be_kind_of(User)
+        valid_user.id.should be_kind_of(Integer)
+      end
+    end
+  end
+end
+
+describe Datamappify::Repository do
+  DATA_PROVIDERS.each do |data_provider|
+    it_behaves_like "repository (in)validation", data_provider
+  end
+end

data/spec/repository_spec.rb

@@ -4,13 +4,15 @@ shared_examples_for "a repository" do |data_provider|
   let(:namespace)       { "Datamappify::Data::Record::#{data_provider}".constantize }
   let(:user_repository) { "UserRepository#{data_provider}".constantize.instance }
 
-  it "defines the data class" do
-    user_repository.data_mapper.default_source_class
-    namespace.const_defined?(:User, false).should == true
-  end
+  context "#{data_provider}" do
+    it "defines the data class" do
+      user_repository.data_mapper.default_source_class
+      namespace.const_defined?(:User, false).should == true
+    end
 
-  it "delegates methods to the instance singleton" do
-    expect { "UserRepository#{data_provider}".constantize.find(1) }.to_not raise_error
+    it "delegates methods to the instance singleton" do
+      expect { "UserRepository#{data_provider}".constantize.find(1) }.to_not raise_error
+    end
   end
 end
 

data/spec/spec_helper.rb

@@ -15,11 +15,11 @@ end
 
 require File.expand_path('../../lib/datamappify', __FILE__)
 
-%w{tables entities repositories}.each do |sub_dir|
+%w{tables entities repositories shared}.each do |sub_dir|
   Dir[File.expand_path("../support/#{sub_dir}/**/*.rb", __FILE__)].each { |f| require f }
 end
 
-DATA_PROVIDERS = %w{ActiveRecord Sequel}
+DATA_PROVIDERS = ENV['DATA_PROVIDER'] ? [ENV['DATA_PROVIDER']] : %w{ActiveRecord Sequel}
 
 RSpec.configure do |config|
   DatabaseCleaner.strategy = :truncation

data/spec/support/entities/hero_user.rb

@@ -1,9 +1,14 @@
 class HeroUser
   include Datamappify::Entity
+  include Datamappify::Lazy
 
   attribute :first_name, String
   attribute :last_name,  String
   attribute :nickname,   String
+  attribute :gender,     String
+
+  validates :first_name, :presence => true,
+                         :length   => { :minimum => 2 }
 
   def full_name
     "#{first_name} #{last_name}"

data/spec/support/repositories/callbacks_chaining_repository.rb

@@ -0,0 +1,92 @@
+class CallbacksChainingRepository
+  include Datamappify::Repository
+
+  for_entity HeroUser
+  default_provider :ActiveRecord
+
+  map_attribute :first_name, 'ActiveRecord::HeroUser#first_name'
+  map_attribute :last_name,  'Sequel::HeroUserLastName#last_name'
+  map_attribute :gender,     'Sequel::HeroUserLastName#gender'
+
+  before_save :before_save_1
+  before_save :before_save_2
+  before_save :before_save_3
+  after_save  :after_save_1
+  after_save  :after_save_2
+  after_save  :after_save_3
+
+  private
+
+  def before_save_1(entity); performed(:before_save_1, entity); true; end
+  def before_save_2(entity); performed(:before_save_2, entity); true; end
+  def before_save_3(entity); performed(:before_save_3, entity); true; end
+  def after_save_1 (entity); performed(:after_save_1,  entity); true; end
+  def after_save_2 (entity); performed(:after_save_2,  entity); true; end
+  def after_save_3 (entity); performed(:after_save_3 , entity); true; end
+
+  def performed(*args)
+    true
+  end
+end
+
+class CallbacksChainingPauseBeforeRepository
+  include Datamappify::Repository
+
+  for_entity HeroUser
+  default_provider :ActiveRecord
+
+  map_attribute :first_name, 'ActiveRecord::HeroUser#first_name'
+  map_attribute :last_name,  'Sequel::HeroUserLastName#last_name'
+  map_attribute :gender,     'Sequel::HeroUserLastName#gender'
+
+  before_save :before_save_1
+  before_save :before_save_2
+  before_save :before_save_3
+  after_save  :after_save_1
+  after_save  :after_save_2
+  after_save  :after_save_3
+
+  private
+
+  def before_save_1(entity); performed(:before_save_1, entity); true;  end
+  def before_save_2(entity); performed(:before_save_2, entity); false; end
+  def before_save_3(entity); performed(:before_save_3, entity); true;  end
+  def after_save_1 (entity); performed(:after_save_1,  entity); true;  end
+  def after_save_2 (entity); performed(:after_save_2,  entity); true;  end
+  def after_save_3 (entity); performed(:after_save_3 , entity); true;  end
+
+  def performed(*args)
+    true
+  end
+end
+
+class CallbacksChainingPauseAfterRepository
+  include Datamappify::Repository
+
+  for_entity HeroUser
+  default_provider :ActiveRecord
+
+  map_attribute :first_name, 'ActiveRecord::HeroUser#first_name'
+  map_attribute :last_name,  'Sequel::HeroUserLastName#last_name'
+  map_attribute :gender,     'Sequel::HeroUserLastName#gender'
+
+  before_save :before_save_1
+  before_save :before_save_2
+  before_save :before_save_3
+  after_save  :after_save_1
+  after_save  :after_save_2
+  after_save  :after_save_3
+
+  private
+
+  def before_save_1(entity); performed(:before_save_1, entity); true;  end
+  def before_save_2(entity); performed(:before_save_2, entity); true;  end
+  def before_save_3(entity); performed(:before_save_3, entity); true;  end
+  def after_save_1 (entity); performed(:after_save_1,  entity); true;  end
+  def after_save_2 (entity); performed(:after_save_2,  entity); false; end
+  def after_save_3 (entity); performed(:after_save_3 , entity); true;  end
+
+  def performed(*args)
+    true
+  end
+end

data/spec/support/repositories/hero_user_repository.rb

@@ -6,4 +6,34 @@ class HeroUserRepository
 
   map_attribute :first_name, 'ActiveRecord::HeroUser#first_name'
   map_attribute :last_name,  'Sequel::HeroUserLastName#last_name'
+  map_attribute :gender,     'Sequel::HeroUserLastName#gender'
+
+  before_create  :action_before_create
+  before_create  :action_before_create_2
+  before_create  { |entity| performed(:before_create_block, entity); true }
+  before_update  :action_before_update
+  before_save    :action_before_save
+  before_destroy :action_before_destroy
+
+  after_create   :action_after_create
+  after_update   :action_after_update
+  after_save     :action_after_save
+  after_destroy  :action_after_destroy
+
+  private
+
+  def action_before_create  (entity); performed(:before_create,   entity); true; end
+  def action_before_create_2(entity); performed(:before_create_2, entity); true; end
+  def action_before_update  (entity); performed(:before_update,   entity); true; end
+  def action_before_save    (entity); performed(:before_save,     entity); true; end
+  def action_before_destroy (entity); performed(:before_destroy,  entity); true; end
+
+  def action_after_create   (entity); performed(:after_create,    entity); true; end
+  def action_after_update   (entity); performed(:after_update,    entity); true; end
+  def action_after_save     (entity); performed(:after_save,      entity); true; end
+  def action_after_destroy  (entity); performed(:after_destroy,   entity); true; end
+
+  def performed(*args)
+    true
+  end
 end

data/spec/support/shared/contexts.rb

@@ -0,0 +1,10 @@
+shared_context "user repository" do |data_provider|
+  let!(:user_repository)     { "UserRepository#{data_provider}".constantize }
+  let!(:existing_user)       { user_repository.save(User.new(:first_name => 'Fred', :driver_license => 'FREDWU42')) }
+  let(:new_valid_user)       { User.new(:first_name => 'Batman', :driver_license => 'ARKHAMCITY') }
+  let(:new_valid_user2)      { User.new(:first_name => 'Ironman', :driver_license => 'NEWYORKCITY') }
+  let(:new_invalid_user)     { User.new(:first_name => 'a') }
+  let(:new_invalid_user2)    { User.new(:first_name => 'b') }
+  let(:data_passports)       { "Datamappify::Data::Record::#{data_provider}::UserPassport".constantize }
+  let(:data_driver_licenses) { "Datamappify::Data::Record::#{data_provider}::UserDriverLicense".constantize }
+end

data/spec/support/tables/sequel.rb

@@ -5,6 +5,7 @@ DB = Sequel.sqlite
 DB.create_table :hero_user_last_names do
   primary_key :id
   String :last_name, :null => false
+  String :gender
   Integer :hero_user_id
   DateTime :created_at
   DateTime :updated_at

data/spec/unit/repository/query_method_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+module Datamappify::Repository::QueryMethod
+  describe Datamappify::Repository::QueryMethod do
+    describe Method do
+      subject { Method }
+
+      it { should_not be_a_reader }
+      it { should_not be_a_writer }
+    end
+
+    describe Exists do
+      subject { Exists }
+
+      it { should     be_a_reader }
+      it { should_not be_a_writer }
+    end
+
+    describe Count do
+      subject { Count }
+
+      it { should     be_a_reader }
+      it { should_not be_a_writer }
+    end
+
+    describe Destroy do
+      subject { Destroy }
+
+      it { should_not be_a_reader }
+      it { should     be_a_writer }
+    end
+
+    describe Find do
+      subject { Find }
+
+      it { should     be_a_reader }
+      it { should_not be_a_writer }
+    end
+
+    describe Save do
+      subject { Save }
+
+      it { should_not be_a_reader }
+      it { should     be_a_writer }
+    end
+
+    RSpec::Matchers.define :be_a_reader do
+      match { |method| method.new({}, {}).reader? == true }
+    end
+
+    RSpec::Matchers.define :be_a_writer do
+      match { |method| method.new({}, {}).writer? == true }
+    end
+  end
+end