datamappify 0.70.0.beta1 → 0.70.0.beta2

data/spec/repository/associations/has_one_spec.rb

@@ -0,0 +1,185 @@
+require 'spec_helper'
+
+shared_examples_for "has_one records" do
+  subject { saved_group }
+
+  its(:name)   { should == 'People' }
+  its(:leader) { should be_kind_of(SuperUser) }
+
+  context "leader" do
+    subject { saved_group.leader }
+
+    its(:id)             { should == existing_user.id }
+    its(:first_name)     { should == 'Steve' }
+    its(:driver_license) { should == 'APPLECOMPUTER' }
+    its(:group_id)       { should == saved_group.id }
+  end
+end
+
+shared_examples_for "has_one new records created from nested form attributes" do
+  let(:group) do
+    Group.new(
+      :name              => 'People',
+      :leader_attributes => {
+        'first_name' => 'Bill', 'driver_license' => 'NEXTCOMPUTER',  'id' => ''
+      }
+    )
+  end
+
+  subject { saved_group.leader }
+
+  its(:id)             { should_not be_nil }
+  its(:id)             { should_not == existing_user.id }
+  its(:first_name)     { should == 'Bill' }
+  its(:driver_license) { should == 'NEXTCOMPUTER' }
+  its(:group_id)       { should == saved_group.id }
+end
+
+shared_examples_for "has_one records created from nested form attributes" do
+  let(:group) do
+    Group.new(
+      :name              => 'People',
+      :leader            => existing_user,
+      :leader_attributes => {
+        'first_name' => 'Bill', 'driver_license' => 'NEXTCOMPUTER'
+      }
+    )
+  end
+
+  subject { saved_group.leader }
+
+  its(:id)             { should == existing_user.id }
+  its(:first_name)     { should == 'Bill' }
+  its(:driver_license) { should == 'NEXTCOMPUTER' }
+  its(:group_id)       { should == saved_group.id }
+end
+
+shared_examples_for "has_one records from nested form attributes with invalid data" do
+  let(:group) do
+    Group.new(
+      :name   => 'People',
+      :leader => existing_user
+    )
+  end
+
+  let(:new_group) do
+    Group.new(
+      :id                => saved_group.id,
+      :name              => 'New People',
+      :leader            => existing_user,
+      :leader_attributes => {
+        'first_name' => 'Bill', 'driver_license' => 'JEFF'
+      }
+    )
+  end
+
+  context "non-saved dirty new group" do
+    subject { new_group }
+
+    its(:name)   { should == 'New People' }
+    its(:leader) { should be_kind_of(SuperUser) }
+    its(:valid?) { should be_false }
+
+    it "does not save" do
+      -> { group_repository.save!(new_group) }.should raise_error(Datamappify::Data::EntityNotSaved)
+    end
+  end
+
+  context "fresh copy of the non-saved new group" do
+    before do
+      group_repository.save(new_group)
+    end
+
+    subject { group_repository.find(new_group.id) }
+
+    its(:name)   { should == 'People' }
+    its(:leader) { should be_kind_of(SuperUser) }
+    its(:valid?) { should be_true }
+  end
+end
+
+shared_examples_for "has_one records destroy from nested form attributes" do
+  let(:group) do
+    Group.new(
+      :name              => 'People',
+      :leader            => existing_user,
+      :leader_attributes => {
+        'id' => existing_user.id.to_s, 'first_name' => 'Jeff', 'driver_license' => 'NEXTCOMPUTER', '_destroy' => '1'
+      }
+    )
+  end
+
+  subject { saved_group }
+
+  its(:leader) { should be_nil }
+end
+
+shared_examples_for "has_one" do |data_provider|
+  let(:user_repository)  { "SuperUserRepository#{data_provider}".constantize }
+  let(:group_repository) { "GroupRepository#{data_provider}".constantize }
+  let(:new_user)         { SuperUser.new(:first_name => 'Fred', :driver_license => 'MOSDEVOPS') }
+  let(:existing_user)    { user_repository.save! SuperUser.new(:first_name => 'Steve', :driver_license => 'APPLECOMPUTER') }
+  let(:existing_user_2)  { user_repository.save! SuperUser.new(:first_name => 'Bill', :driver_license => 'MICROCOMPUTER') }
+  let(:group) do
+    Group.new(
+      :name   => 'People',
+      :leader => existing_user
+    )
+  end
+
+  it "existing_user" do
+    existing_user.id.should_not be_nil
+  end
+
+  describe "group entity" do
+    subject { group }
+
+    its(:leader) { should be_kind_of(SuperUser) }
+  end
+
+  context "#{data_provider}" do
+    context "immediate return" do
+      let(:saved_group) { group_repository.save!(group) }
+
+      it_behaves_like "has_one records"
+      it_behaves_like "has_one new records created from nested form attributes"
+      it_behaves_like "has_one records created from nested form attributes"
+      it_behaves_like "has_one records from nested form attributes with invalid data"
+      it_behaves_like "association data records", data_provider
+    end
+
+    context "reloaded return" do
+      let(:saved_group) { group_repository.save!(group); group_repository.find(group.id) }
+
+      it_behaves_like "has_one records"
+      it_behaves_like "has_one new records created from nested form attributes"
+      it_behaves_like "has_one records created from nested form attributes"
+      it_behaves_like "has_one records from nested form attributes with invalid data"
+      it_behaves_like "has_one records destroy from nested form attributes"
+      it_behaves_like "association data records", data_provider
+    end
+
+    context "collection return" do
+      let(:saved_group) { group_repository.save!(group); group_repository.all.detect { |g| g.id == group.id } }
+
+      it_behaves_like "has_one records"
+      it_behaves_like "has_one new records created from nested form attributes"
+      it_behaves_like "has_one records created from nested form attributes"
+      it_behaves_like "has_one records from nested form attributes with invalid data"
+      it_behaves_like "has_one records destroy from nested form attributes"
+      it_behaves_like "association data records", data_provider
+    end
+
+    context "criteria return" do
+      let(:saved_group) { group_repository.save!(group); group_repository.criteria(:where => { :id => group.id }).first }
+
+      it_behaves_like "has_one records"
+    end
+  end
+end
+
+describe Datamappify::Repository do
+  DATA_PROVIDERS.each do |data_provider|
+    it_behaves_like "has_one", data_provider
+  end
+end

data/spec/repository/callbacks_spec.rb

@@ -8,6 +8,9 @@ shared_examples_for "callbacks" do |query_method, *performed_callbacks|
   end
 
   all_callbacks = [
+    :before_init,    :after_init,
+    :before_load,    :after_load,
+    :before_find,    :after_find,
     :before_create,  :after_create,
     :before_update,  :after_update,
     :before_save,    :after_save,
@@ -36,21 +39,59 @@ describe Datamappify::Repository do
   it { valid_user.valid?.should == true }
   it { invalid_user.valid?.should == false }
 
+  context "#init" do
+    let(:criteria) { HeroUser }
+    let(:entity)   { HeroUser.new }
+
+    it "returns entity instead of criteria" do
+      HeroUserRepository.instance.should_receive(:performed).with(:before_init, criteria)
+      HeroUserRepository.instance.should_receive(:performed).with(:after_init, entity)
+
+      HeroUserRepository.init(criteria)
+    end
+  end
+
+  context "#find" do
+    context "found" do
+      let(:criteria) { valid_user.id }
+      let(:entity)   { valid_user }
+
+      before do
+        HeroUserRepository.save!(valid_user)
+      end
+
+      it "returns entity instead of criteria" do
+        HeroUserRepository.instance.should_receive(:performed).with(:before_load, criteria)
+        HeroUserRepository.instance.should_receive(:performed).with(:before_find, criteria)
+        HeroUserRepository.instance.should_receive(:performed).with(:after_find, entity)
+        HeroUserRepository.instance.should_receive(:performed).with(:after_load, entity)
+
+        HeroUserRepository.find(criteria)
+      end
+    end
+
+    context "not found" do
+      let(:entity) { 42 }
+
+      it_behaves_like "callbacks", :find,    :before_load, :before_find
+    end
+  end
+
   context "non-persisted" do
     context "on valid entity" do
       let(:entity) { valid_user }
 
-      it_behaves_like "callbacks", :create,  :before_save, :before_create, :before_create_2, :before_create_block, :after_create, :after_save
-      it_behaves_like "callbacks", :update,  :before_save, :before_update, :after_update, :after_save
-      it_behaves_like "callbacks", :save,    :before_save, :before_create, :before_create_2, :before_create_block, :after_create, :after_save
+      it_behaves_like "callbacks", :create,  :before_load, :before_save, :before_create, :before_create_2, :before_create_block, :after_create, :after_save, :after_load
+      it_behaves_like "callbacks", :update,  :before_load, :before_save, :before_update, :after_update, :after_save, :after_load
+      it_behaves_like "callbacks", :save,    :before_load, :before_find, :before_load, :before_save, :before_create, :before_create_2, :before_create_block, :after_create, :after_save, :after_load
     end
 
     context "on invalid entity" do
       let(:entity) { invalid_user }
 
-      it_behaves_like "callbacks", :create,  :before_save, :before_create, :before_create_2, :before_create_block
-      it_behaves_like "callbacks", :update,  :before_save, :before_update
-      it_behaves_like "callbacks", :save,    :before_save, :before_create, :before_create_2, :before_create_block
+      it_behaves_like "callbacks", :create,  :before_load, :before_save, :before_create, :before_create_2, :before_create_block
+      it_behaves_like "callbacks", :update,  :before_load, :before_save, :before_update
+      it_behaves_like "callbacks", :save,    :before_load, :before_find, :before_load, :before_save, :before_create, :before_create_2, :before_create_block
     end
   end
 
@@ -60,19 +101,19 @@ describe Datamappify::Repository do
     context "on valid entity" do
       let(:entity) { persisted_user }
 
-      it_behaves_like "callbacks", :create,  :before_save, :before_create, :before_create_2, :before_create_block, :after_create, :after_save
-      it_behaves_like "callbacks", :update,  :before_save, :before_update, :after_update, :after_save
-      it_behaves_like "callbacks", :save,    :before_save, :before_update, :after_update, :after_save
-      it_behaves_like "callbacks", :destroy, :before_destroy, :after_destroy
+      it_behaves_like "callbacks", :create,  :before_load, :before_save, :before_create, :before_create_2, :before_create_block, :after_create, :after_save, :after_load
+      it_behaves_like "callbacks", :update,  :before_load, :before_save, :before_update, :after_update, :after_save, :after_load
+      it_behaves_like "callbacks", :save,    :before_load, :before_find, :after_find, :after_load, :before_load, :before_save, :before_update, :after_update, :after_save, :after_load
+      it_behaves_like "callbacks", :destroy, :before_load, :before_destroy, :after_destroy, :after_load
     end
 
     context "on invalid entity" do
       let(:entity) { persisted_user.tap { |u| u.first_name = 'f' } }
 
-      it_behaves_like "callbacks", :create,  :before_save, :before_create, :before_create_2, :before_create_block
-      it_behaves_like "callbacks", :update,  :before_save, :before_update
-      it_behaves_like "callbacks", :save,    :before_save, :before_update
-      it_behaves_like "callbacks", :destroy, :before_destroy, :after_destroy
+      it_behaves_like "callbacks", :create,  :before_load, :before_save, :before_create, :before_create_2, :before_create_block
+      it_behaves_like "callbacks", :update,  :before_load, :before_save, :before_update
+      it_behaves_like "callbacks", :save,    :before_load, :before_find, :after_find, :after_load, :before_load, :before_save, :before_update
+      it_behaves_like "callbacks", :destroy, :before_load, :before_destroy, :after_destroy, :after_load
     end
   end
 

data/spec/repository/dirty_tracking_spec.rb

@@ -38,7 +38,6 @@ shared_examples_for "dirty tracking" do |data_provider|
       end
 
       describe "change by mutation" do
-
         it "changed" do
           existing_user.first_name << 'APPEND'
           state = user_repository.states.find(existing_user)

data/spec/repository/finders/criteria_spec.rb

@@ -3,6 +3,7 @@ require 'spec_helper'
 shared_examples_for "finders examples" do |data_provider|
   [
     { :where => { :last_name => 'Superman' }, :limit => 2, :order => { :last_name => :asc, :first_name => :desc, :id => :desc } },
+    { :where => { :last_name => 'Superman' }, :limit => [2, 0], :order => { :last_name => :asc, :first_name => :desc, :id => :desc } },
     { :order => { :last_name => :asc, :first_name => :desc, :id => :desc }, :limit => 2, :where => { :last_name => 'Superman' } },
     { :where => {}, :match => { :last_name => 'Super%' }, :limit => 2, :order => { :last_name => :asc, :first_name => :desc, :id => :desc } }
   ].each_with_index do |criteria, index|

data/spec/repository/persistence_spec.rb

@@ -52,6 +52,27 @@ shared_examples_for "repository persistence" do |data_provider|
           persisted_user.persisted?.should == true
         end
 
+        it "updates existing records with nil values" do
+          existing_user.first_name = 'Vivian'
+          existing_user.last_name = nil
+          existing_user.health_care = nil
+
+          updated_user = nil
+
+          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.last_name.should be_nil
+          updated_user.health_care.should be_nil
+
+          persisted_user = user_repository.find(updated_user.id)
+
+          persisted_user.first_name.should == 'Vivian'
+          persisted_user.last_name.should be_nil
+          persisted_user.health_care.should be_nil
+          persisted_user.persisted?.should == true
+        end
+
         it "updates existing and new records" do
           existing_user.first_name = 'Vivian'
           existing_user.health_care = 'BATMANCAVE'

data/spec/repository_spec.rb

@@ -10,8 +10,24 @@ shared_examples_for "a repository" do |data_provider|
       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
+    describe "delegation" do
+      subject { "UserRepository#{data_provider}".constantize }
+
+      it "delegates methods to the instance singleton" do
+        expect { subject.find(1) }.to_not raise_error
+      end
+
+      describe "catch-all delegation" do
+        before do
+          user_repository.class_eval do
+            attr_reader :dummy_method
+          end
+        end
+
+        it "delegates other methods to the instance singleton" do
+          expect { subject.dummy_method }.to_not raise_error
+        end
+      end
     end
   end
 end

data/spec/spec_helper.rb

@@ -29,8 +29,6 @@ RSpec.configure do |config|
   DatabaseCleaner[:sequel].strategy        = :truncation
   DatabaseCleaner[:active_record].strategy = :truncation
 
-  require File.expand_path('../support/monkey_patches/database_cleaner.rb', __FILE__)
-
   config.before do
     DatabaseCleaner.clean
   end

data/spec/support/entities/group.rb

@@ -5,5 +5,6 @@ class Group
 
   attribute :name, String
 
-  has_many :users, :via => SuperUser
+  has_one  :leader, :via => SuperUser
+  has_many :users,  :via => SuperUser
 end

data/spec/support/repositories/active_record/group_repository.rb

@@ -6,5 +6,6 @@ class GroupRepositoryActiveRecord
   for_entity Group
   default_provider :ActiveRecord
 
-  references :users, :via => SuperUserRepositoryActiveRecord
+  references :leader, :via => SuperUserRepositoryActiveRecord
+  references :users,  :via => SuperUserRepositoryActiveRecord
 end

data/spec/support/repositories/hero_user_repository.rb

@@ -11,6 +11,9 @@ class HeroUserRepository
     map_attribute :gender,    :to => 'HeroUserLastName#gender'
   end
 
+  before_init    :action_before_init
+  before_load    :action_before_load
+  before_find    :action_before_find
   before_create  :action_before_create
   before_create  :action_before_create_2
   before_create  { |entity| performed(:before_create_block, entity); true }
@@ -18,6 +21,9 @@ class HeroUserRepository
   before_save    :action_before_save
   before_destroy :action_before_destroy
 
+  after_init     :action_after_init
+  after_load     :action_after_load
+  after_find     :action_after_find
   after_create   :action_after_create
   after_update   :action_after_update
   after_save     :action_after_save
@@ -25,12 +31,18 @@ class HeroUserRepository
 
   private
 
+  def action_before_init    (entity); performed(:before_init,     entity); true; end
+  def action_before_load    (entity); performed(:before_load,     entity); true; end
+  def action_before_find    (entity); performed(:before_find,     entity); true; end
   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_init     (entity); performed(:after_init,      entity); true; end
+  def action_after_load     (entity); performed(:after_load,      entity); true; end
+  def action_after_find     (entity); performed(:after_find,      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

data/spec/support/repositories/sequel/group_repository.rb

@@ -6,5 +6,6 @@ class GroupRepositorySequel
   for_entity Group
   default_provider :Sequel
 
-  references :users, :via => SuperUserRepositorySequel
+  references :leader, :via => SuperUserRepositorySequel
+  references :users,  :via => SuperUserRepositorySequel
 end

data/spec/support/shared/contexts.rb

@@ -1,6 +1,6 @@
 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!(:existing_user)       { user_repository.save(User.new(:first_name => 'Fred', :last_name => 'Wu', :driver_license => 'FREDWU42', :health_care => 'HEALTHCARE')) }
   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') }