dirt-core 2.2.3

data/lib/dirt/roles/validation/existence_validator.rb

@@ -0,0 +1,53 @@
+require 'active_support/all'
+
+# Tests for whether the property referenced by an id is saved in the appropriate persister.
+# This validator is stateful. #error_message returns the errors from the most recent run of #valid?.
+#
+# For more about validation, see Validating
+class ExistenceValidator
+  # Takes the symbol name of the property to validate, and an options hash.
+  #
+  # Options include:
+  # * +as+:: The class of the type to search under
+  # * +list+:: If set, will treat +property+ as an id list, checking existence of all.
+  #
+  def initialize(property, opts)
+    @property = property
+    @type = opts[:as] || raise(ArgumentError.new('ExistenceValidator requires as: be provided with a type.'))
+    @list = opts[:list] || false
+    @bad_ids = []
+  end
+
+  def valid?(validated)
+    return false unless validated
+
+    if @list
+      ids = validated.send(@property) || []
+    else
+      ids = [validated.send(property_id)]
+    end
+
+    persister = Persister.for(@type)
+
+    @bad_ids = ids.select do |id|
+      not persister.exists?(id)
+    end
+
+    @bad_ids.empty?
+  end
+
+  def error_message(validated)
+    unless @bad_ids.empty?
+      if @list
+        "Those #{@type.to_s.demodulize.pluralize} (ids: #{@bad_ids.join(", ")}) do not exist."
+      else
+        "That #{@type.to_s.demodulize} (id: #{@bad_ids.first || "nil"}) does not exist."
+      end
+    end
+  end
+
+  private
+  def property_id
+    "#{@property}_id".to_sym
+  end
+end

data/lib/dirt/roles/validation/presence_validator.rb

@@ -0,0 +1,21 @@
+# Tests whether the given property is set (ie non-nil)
+#
+# For more about validation, see Validating
+class PresenceValidator
+  # Takes the property name as symbol
+  def initialize(property)
+    @property = property
+  end
+
+  def valid?(validated)
+    return false unless validated
+
+    value = validated.send(@property)
+
+    value.present? && !(value =~ /\A\s*\Z/)
+  end
+
+  def error_message(validated)
+    "#{validated.class.to_s.demodulize} #{@property.to_s.gsub('_', ' ').downcase} must be provided."
+  end
+end

data/lib/dirt/roles/validation/self_existence_validator.rb

@@ -0,0 +1,18 @@
+# Tests for the existence of the given id in the persister.
+#
+# For more about validation, see Validating
+class SelfExistenceValidator
+  def initialize(type, id)
+    @type = type
+    @id = id
+  end
+
+  # +true+ if the validated object exists in the persister.
+  def valid?(validated)
+    Persister.for(@type).exists?(@id)
+  end
+
+  def error_message(validated)
+    "That #{@type.to_s.demodulize.downcase} (id: #{ @id || "nil" }) does not exist."
+  end
+end

data/spec/isolations/closure_validator_spec.rb

@@ -0,0 +1,57 @@
+#--
+# 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'
+
+describe ClosureValidator do
+  let(:expected_validity) { double('validity') }
+  let(:expected_error) { double('error') }
+
+  describe 'closure use' do
+    subject do
+      ClosureValidator.new(lambda { |val| expected_validity }, lambda { |err| expected_error })
+    end
+
+    it 'should use the block to determines validity' do
+      subject.valid?(expected_validity).should be expected_validity
+    end
+
+    it 'should use the second block to determine the error' do
+      subject.error_message(expected_error).should be expected_error
+    end
+  end
+
+  describe 'parameters' do
+    subject do
+      ClosureValidator.new(lambda { |val| val }, lambda { |err| err })
+    end
+
+    it 'should pass the validated object into the valid? closure' do
+      subject.valid?(expected_validity).should be expected_validity
+    end
+
+    it 'should pass the validated object into the error closure' do
+      subject.error_message(expected_error).should be expected_error
+    end
+  end
+end

data/spec/isolations/context_spec.rb

@@ -0,0 +1,54 @@
+#--
+# 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'
+
+describe Dirt::Context do
+  describe '#run' do
+    it 'should create an instance and call #call on it' do
+      Dirt::Context.any_instance.should_receive(:call)
+
+      Dirt::Context.run(double('params'))
+    end
+
+    it 'should pass forward params to #new' do
+      args = double('params')
+
+      Dirt::Context.should_receive(:new).with(args).and_call_original
+
+      Dirt::Context.run(args)
+    end
+  end
+
+  describe '#initialize' do
+    it 'should accept no param' do
+      Dirt::Context.new()
+    end
+
+    it 'should accept params' do
+      args = double('params')
+
+      Dirt::Context.new(args)
+    end
+  end
+end

data/spec/isolations/existence_validator_spec.rb

@@ -0,0 +1,151 @@
+#--
+# 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'
+
+describe ExistenceValidator do
+  let(:persister) { double('persister') }
+  let(:decorated) { double('decorated') }
+  let(:is_list) { false }
+
+  subject { ExistenceValidator.new(:some_reference, {as: :some_class, list: is_list}) }
+
+  before(:each) do
+    Persister.for(:some_class, persister)
+  end
+
+  after(:each) do
+    Persister.clear
+  end
+
+  describe '#initialize' do
+    it 'should explode when as: is not supplied' do
+      expect { ExistenceValidator.new(decorated, {}) }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#valid?' do
+    it 'should return false if given nil' do
+      subject.valid?(nil).should be false
+    end
+
+    context 'single' do
+      before(:each) do
+        decorated.stub(:some_reference_id).and_return(double('id'))
+      end
+
+      it 'should return true when persister has something by the id' do
+        persister.stub(:exists?).and_return(true)
+
+        subject.valid?(decorated).should be true
+      end
+
+      it 'should return false when persister has nothing by the id' do
+        persister.stub(:exists?).and_return(false)
+
+        subject.valid?(decorated).should be false
+      end
+    end
+
+    context 'list' do
+      subject { ExistenceValidator.new(:some_reference_ids, {as: :some_class, list: true}) }
+
+      before(:each) do
+        decorated.stub(:some_reference_ids).and_return([double('id1'), double('id2'), double('id3')])
+      end
+
+      it 'should return true when persister has something for every id' do
+        persister.stub(:exists?).and_return(true, true, true)
+
+        subject.valid?(decorated).should be true
+      end
+
+      it 'should return false when persister has nothing for an id' do
+        persister.stub(:exists?).and_return(true, false, true)
+
+        subject.valid?(decorated).should be false
+      end
+    end
+  end
+
+  describe '#errors' do
+    context 'valid? not called previously' do
+      it 'should return nil' do
+        subject.error_message(decorated).should be nil
+      end
+    end
+
+    context 'single' do
+      let(:id) { double('id') }
+      before(:each) do
+        decorated.stub(:some_reference_id).and_return(id)
+      end
+
+      it 'should return nil when persister has something for the id' do
+        persister.stub(:exists?).and_return(true)
+        subject.valid?(decorated)
+
+        subject.error_message(decorated).should be nil
+      end
+
+      it 'should return an error when persister has nothing for the id' do
+        persister.stub(:exists?).and_return(false)
+        subject.valid?(decorated)
+
+        subject.error_message(decorated).should == "That some_class (id: #{id}) does not exist."
+      end
+    end
+
+    context 'list' do
+      subject { ExistenceValidator.new(:some_reference_ids, {as: :some_class, list: true}) }
+      let(:id1) { double('id1') }
+      let(:id2) { double('id2') }
+      let(:id3) { double('id3') }
+
+      before(:each) do
+        decorated.stub(:some_reference_ids).and_return([id1, id2, id3])
+      end
+
+      it 'should return nil when persister has something for every id' do
+        persister.stub(:exists?).and_return(true, true, true)
+        subject.valid?(decorated)
+
+        subject.error_message(decorated).should be nil
+      end
+
+      it 'should return an error when persister has nothing for an id' do
+        persister.stub(:exists?).and_return(false, false, false)
+        subject.valid?(decorated)
+
+        subject.error_message(decorated).should == "Those some_classes (ids: #{[id1, id2, id3].join(", ")}) do not exist."
+      end
+
+      it 'should return include only the failed when persister has nothing for an id' do
+        persister.stub(:exists?).and_return(true, false, false)
+        subject.valid?(decorated)
+
+        subject.error_message(decorated).should == "Those some_classes (ids: #{[id2, id3].join(", ")}) do not exist."
+      end
+    end
+  end
+end

data/spec/isolations/memory_persister_spec.rb

@@ -0,0 +1,175 @@
+#--
+# 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 'dirt/bdd/persister_spec_helper'
+require './spec/isolations/spec_helper'
+
+module Dirt
+  describe MemoryPersister do
+    let(:type) { :test }
+    subject do
+      MemoryPersister.new(:Mock) do |*args|
+        double('Persisting', *args)
+      end
+    end
+
+    it_behaves_like(:persister) do
+      let(:persisted) { double('persisted object', attr1: 5, to_hash: {attr1: 5}) }
+      let(:persisted2) { double('persisted object 2', attr1: 5, to_hash: {attr1: 5}) }
+      let(:different_persisted) { double('different persisted object', attr1: 28, to_hash: {attr1: 28}) }
+
+      let(:where_params) { {attr1: 5} }
+    end
+
+    describe '#new' do
+      it 'should explode when not given a block' do
+        expect { MemoryPersister.new(:some_type).new }.to raise_error(RuntimeError, 'Cannot create a new instance without a block given to init.')
+      end
+
+      it 'should return an object' do
+        subject.new.should_not be_nil
+      end
+
+      context 'called with args' do
+        it 'should populate the new object with args data' do
+          subject.new(arg1: 'val1').arg1.should == 'val1'
+        end
+      end
+    end
+
+    describe '#save' do
+      let(:data) { double('data', to_hash: {some: 'data'}) }
+
+      it 'should return the id + data as struct on success' do
+        result = subject.save(data)
+
+        result.should == OpenStruct.new(data.to_hash.merge(id: result.id))
+      end
+
+      it 'should remember the data by the given id' do
+        id = 3
+
+        fake1 = double('other data', to_hash: {})
+        fake2 = double('another data', to_hash: {})
+
+        subject.save(fake1)
+        subject.save(fake2)
+        subject.save(double('replaced', to_hash: {}))
+        subject.save(data, id)
+
+        subject.instance_variable_get(:@records).should == {1 => fake1, 2 => fake2, id => data}
+      end
+
+      it 'should remember the data by a made up id when none given' do
+        subject.save(data, nil)
+
+        subject.instance_variable_get(:@records).should == {1 => data}
+      end
+    end
+
+    describe '#load' do
+      let(:data) { double('data', to_hash: {some: 'data'}) }
+
+      it 'should return only the appropriate id and data' do
+        id = double('id')
+
+        subject.instance_variable_set(:@records, {id => data, double('id2') => double('data2')})
+
+        subject.load(id).should == OpenStruct.new(data.to_hash.merge(id: id))
+      end
+    end
+
+    describe '#exists?' do
+      it 'should return only the appropriate id and data' do
+        id = double('id')
+        data = double('data')
+
+        subject.instance_variable_set(:@records, {id => data})
+
+        subject.exists?(id).should be true
+      end
+
+      it 'should raise exception when given an invalid id' do
+        id = double('id3')
+
+        subject.instance_variable_set(:@records, {double('id') => double('data'), double('id2') => double('data2')})
+
+        subject.exists?(id).should be false
+      end
+    end
+
+    describe '#all' do
+      it 'should return all of the appropriate id and data' do
+        records = {double('id1') => double('data1', to_hash: {attr1: double}),
+                   double('id2') => double('data2', to_hash: {attr1: double}),
+                   double('id3') => double('data3', to_hash: {attr1: double})}
+
+        subject.instance_variable_set(:@records, records)
+
+        subject.all.should == records.collect { |id, r| OpenStruct.new(r.to_hash.merge(id: id)) }
+      end
+    end
+
+    describe '#delete' do
+      let(:data) { double('data', to_hash: {some: 'data'}) }
+
+      it 'should return the deleted id and data as a struct' do
+        id = double('id')
+
+        subject.instance_variable_set(:@records, {id => data})
+
+        subject.delete(id).should == OpenStruct.new(data.to_hash.merge(id: id))
+      end
+
+      it 'should delete the given id and data' do
+        id = double('id')
+
+        subject.instance_variable_set(:@records, {id => data})
+
+        subject.delete(id)
+
+        subject.instance_variable_get(:@records).should == {}
+      end
+
+      it 'should delete only the appropriate id and data' do
+        id1 = double('id1')
+        id2 = double('id2')
+        data2 = double('data2')
+
+        subject.instance_variable_set(:@records, {id1 => data, id2 => data2})
+
+        subject.delete(id1)
+
+        subject.instance_variable_get(:@records).should == {id2 => data2}
+      end
+
+      it 'should return nil when given an invalid id' do
+        id = double('id3')
+
+        subject.instance_variable_set(:@records, {double('id') => double('data'), double('id2') => double('data2')})
+
+        subject.delete(id).should == nil
+      end
+    end
+  end
+end