dirt-core 2.2.3

data/spec/isolations/model_spec.rb

@@ -0,0 +1,91 @@
+#--
+# Copyright (c) 2014 Tenjin Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+require './spec/isolations/spec_helper'
+
+module Dirt
+  describe ModelBehaviour do
+    # Need to give it a attributes for testing
+    class Model
+      include ModelBehaviour
+      attr_accessor :test_variable1, :test_variable2
+    end
+
+    let(:expected_value1) { double('a variable') }
+    let(:expected_value2) { double('something else') }
+
+    subject { Model.new(test_variable1: expected_value1, test_variable2: expected_value2) }
+
+    context '#initialize' do
+      it 'should save the given params from the hash' do
+        subject.test_variable1.should == expected_value1
+        subject.test_variable2.should == expected_value2
+      end
+    end
+
+    context '#update' do
+      subject { Model.new() }
+
+      it 'should save the given params from the hash' do
+        subject.update(test_variable1: expected_value1, test_variable2: expected_value2)
+
+        subject.test_variable1.should == expected_value1
+        subject.test_variable2.should == expected_value2
+      end
+    end
+
+    context '#to_hash' do
+      it 'should return the model data as a hash' do
+        subject.to_hash.should == {test_variable1: expected_value1, test_variable2: expected_value2}
+      end
+    end
+
+    context '#==' do
+      it 'should return false vs nil' do
+        subject.==(nil).should be false
+      end
+
+      it 'should return false vs a different object' do
+        subject.==(double('different thingy')).should be false
+      end
+
+      it 'should return true vs itself' do
+        subject.==(subject).should be true
+      end
+
+      it 'should return true vs another object with equivalent values' do
+        other = double('different thingy')
+
+        other.stub(:instance_variable_get).and_return do |*args|
+          if args.first == :@test_variable1
+            expected_value1
+          elsif   args.first == :@test_variable2
+            expected_value2
+          end
+        end
+
+        subject.==(other).should == true
+      end
+    end
+  end
+end

data/spec/isolations/persister_spec.rb

@@ -0,0 +1,113 @@
+#--
+# Copyright (c) 2014 Tenjin Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+require './spec/isolations/spec_helper'
+
+module Dirt
+  describe Persister do
+    let(:fake_persister) { double 'Fake Persister' }
+
+    describe '#for' do
+      class FooBar
+      end
+
+      module HerpZerp
+        module DerpGerp
+          class FooBar
+
+          end
+        end
+      end
+
+      [FooBar, HerpZerp::DerpGerp::FooBar, :foo_bar].each do |arg|
+        context "#{arg} is passed in" do
+          let(:expected_persister) { double('Peristathingy') }
+
+          it 'should save using the given argument and return the expected persister with the appropriate symbol' do
+            Persister.for(arg, expected_persister)
+            Persister.for(:foo_bar).should be expected_persister
+          end
+
+          after(:each) { Persister.clear }
+        end
+      end
+
+      context 'no persister for type' do
+        it 'should throw an exception' do
+          expect { Persister.for(:bogus_type) }.to raise_error(NoPersisterError, 'There is no persister for "bogus_types".')
+        end
+      end
+    end
+
+    describe '#clear' do
+      it 'should empty the persisters hash' do
+        Persister.clear
+
+        Persister.class_variable_get(:@@persisters).should == nil
+      end
+    end
+
+    describe "#transaction" do
+      it "should return errors when a Transaction error is raised" do
+        Persister.stub(:for).and_return(fake_persister)
+        expect(fake_persister).to receive(:transaction) do |&block|
+          block.call
+        end
+
+        Persister.transaction([fake_persister]) do
+          raise TransactionError, "The Error"
+        end.should == {errors: ["The Error"]}
+      end
+
+      it "should not rescue non-transaction errors" do
+        Persister.stub(:for).and_return(fake_persister)
+        expect(fake_persister).to receive(:transaction) do |&block|
+          block.call
+        end
+
+        expect { Persister.transaction([fake_persister]) do
+          raise StandardError, "Different Error"
+        end }.to raise_error(StandardError, "Different Error")
+      end
+
+      it "should trigger the block within the transactions of all persisters" do
+        p1, p2, p3 = double('persister'), double('persister'), double('persister')
+        p1.stub(:transaction) do |&block|
+          ">#{block.call}<"
+        end
+
+        p2.stub(:transaction) do |&block|
+          ">#{block.call}<"
+        end
+
+        p3.stub(:transaction) do |&block|
+          ">#{block.call}<"
+        end
+
+        Persister.transaction([p1, p2, p3]) do
+          "Trigger Block"
+        end.should == ">>>Trigger Block<<<"
+      end
+    end
+  end
+end

data/spec/isolations/persisting_spec.rb

@@ -0,0 +1,266 @@
+#--
+# Copyright (c) 2014 Tenjin Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+require './spec/isolations/spec_helper'
+
+module Dirt
+
+  describe Persisting do
+    let(:decorated) { double('decorated', to_hash: {some: 'data'}) }
+
+    subject do
+      Persisting.new(decorated)
+    end
+
+    let(:persister) { MemoryPersister.new(:some_type) }
+
+    before(:each) do
+      Persister.for(:mock, persister)
+    end
+
+    after(:each) do
+      Persister.clear
+    end
+
+    describe '#initialize' do
+      it 'should save the given id' do
+        id = 5
+        p = Persisting.new(decorated, id)
+        p.id.should == id
+      end
+    end
+
+    describe '#==' do
+      context 'same id' do
+        let(:decorated) { [5] }
+
+        it 'should be equal with equivalent contents' do
+          clone = [5]
+          decorated.should == clone
+          subject.should == Persisting.new(clone)
+        end
+      end
+
+      context 'different id' do
+        it 'should not be equal' do
+          other = Persisting.new(decorated)
+
+          subject.instance_variable_set(:@id, 1)
+          other.instance_variable_set(:@id, 2)
+
+          subject.should_not == other
+        end
+      end
+    end
+
+    describe '#save' do
+      let(:id) { double('id') }
+
+      context 'persistence completes' do
+        it 'should call persister save with nil id' do
+          persister.should_receive(:save).with(decorated, nil)
+
+          subject.save()
+        end
+
+        it 'should remember the id assinged by persister' do
+          persister.stub(:save).and_return(OpenStruct.new(id: id, data: decorated))
+
+          subject.save()
+
+          subject.id.should == id
+        end
+
+        it 'should return itself' do
+          subject.save().should be subject
+        end
+      end
+
+      context 'persistence fails' do
+        before(:each) do
+          persister.stub(:save).and_return(nil)
+        end
+
+        it 'should call persister save with nil id' do
+          persister.should_receive(:save).with(decorated, nil)
+
+          subject.save()
+        end
+
+        it 'should not remember an id' do
+          subject.save()
+
+          subject.id.should == nil
+        end
+
+        it 'should return nil' do
+          subject.save().should be nil
+        end
+      end
+    end
+
+    context '#load' do
+      context 'there is a record by that id' do
+        let(:id) { persister.save(decorated).id }
+        let(:decorated_hash) { {some: 'data and things'} }
+
+        before(:each) do
+          decorated.stub(:to_hash).and_return(decorated_hash)
+        end
+
+        it 'should load the persisted object into itself' do
+          decorated.should_receive(:update).with(decorated_hash)
+
+          subject.load(id)
+        end
+
+        it 'should keep the id' do
+          decorated.stub(:update)
+
+          subject.load(id).id.should == id
+        end
+
+        it 'should return itself' do
+          decorated.stub(:update)
+
+          subject.load(id).should be subject
+        end
+      end
+
+      context 'no record has that id' do
+        it 'should explode' do
+          expect { subject.load(double('id')) }.to raise_error(MissingRecordError)
+        end
+      end
+    end
+
+    context '#load_by' do
+      let(:attr) { :test_attr }
+      let(:value) { double('test value') }
+
+      let(:record1) { double('record1', to_hash: {some: 'data1'}) }
+      let(:record2) { double('record2', to_hash: {some: 'data2'}) }
+      let(:record3) { double('record3', to_hash: {some: 'data3'}) }
+
+      before(:each) do
+        persister.save(record1)
+        persister.save(record2)
+        persister.save(record3)
+      end
+
+      context 'there is a record by that attribute' do
+        let(:record_hash) { {attr => 'record2\'s hash'} }
+
+        before(:each) do
+          record1.stub(attr).and_return(double('something else'))
+          record2.stub(attr).and_return(double('something else'))
+          record3.stub(attr).and_return(value)
+
+          record3.stub(:to_hash).and_return(record_hash)
+        end
+
+        it 'should load the persisted object into itself' do
+          decorated.should_receive(:update).with(record_hash)
+
+          subject.load_by(attr => value)
+        end
+
+        it 'should return itself' do
+          decorated.stub(:update)
+
+          subject.load_by(attr => value).should be subject
+        end
+
+        it 'should keep the found id' do
+          decorated.stub(:update)
+
+          subject.load_by(attr => value).id.should == 3
+        end
+      end
+
+      context 'multiple records have that attribute' do
+        let(:record_hash) { {record_attr: 'and a value'} }
+
+        before(:each) do
+          record1.stub(attr).and_return(double('something else'))
+          record2.stub(attr).and_return(value)
+          record3.stub(attr).and_return(value)
+
+          record2.stub(:to_hash).and_return(record_hash)
+        end
+
+        it 'should load the first matching persisted object into itself' do
+          decorated.should_receive(:update).with(record_hash)
+
+          subject.load_by(attr => value)
+        end
+
+        it 'should return itself' do
+          decorated.stub(:update)
+
+          subject.load_by(attr => value).should be subject
+        end
+
+        it 'should keep the found id' do
+          decorated.stub(:update)
+
+          subject.load_by(attr => value).id.should == 2
+        end
+      end
+
+      context 'no record has that attribute' do
+        before(:each) do
+          record1.stub(attr).and_return(double('something else'))
+          record2.stub(attr).and_return(double('something else'))
+          record3.stub(attr).and_return(double('something else'))
+        end
+
+        it 'should NOT load the persisted object but explode' do
+          decorated.should_not_receive(:update)
+
+          expect { subject.load_by(attr => value) }.to raise_error(MissingRecordError, "No record matches #{attr} == #{value}.")
+        end
+      end
+    end
+
+    context '#delete' do
+      context 'there is a record by that id' do
+        let(:id) { persister.save(decorated).id }
+        it 'should return the persisting-wrapped deleted object' do
+          deleted = Persisting.new(decorated)
+
+          persister.stub(:delete).and_return(deleted)
+          subject.delete(id).should == deleted
+        end
+      end
+
+      context 'no record has that id' do
+        it 'should return nil' do
+          persister.stub(:delete).and_return(nil)
+
+          expect { subject.delete(double('an_id')) }.to raise_error(MissingRecordError)
+        end
+      end
+    end
+  end
+end