sbf-dm-core 1.3.0.beta

data/lib/dm-core/spec/shared/adapter_spec.rb

@@ -0,0 +1,366 @@
+shared_examples 'An Adapter' do
+
+  def self.adapter_supports?(*methods)
+
+    # FIXME: obviously this needs a real fix!
+    # --------------------------------------
+    # Probably, delaying adapter_supports?
+    # to be executed after DataMapper.setup
+    # has been called will solve our current
+    # problem with described_type() being nil
+    # for as long as DataMapper.setup wasn't
+    # called
+    return true if ENV['ADAPTER_SUPPORTS'] == 'all'
+
+    methods.all? do |method|
+      # TODO: figure out a way to see if the instance method is only inherited
+      # from the Abstract Adapter, and not defined in it's class.  If that is
+      # the case return false
+
+      # CRUD methods can be inherited from parent class
+      described_type.instance_methods.any? { |instance_method| method.to_s == instance_method.to_s }
+    end
+  end
+
+  # Hack to detect cases a let(:heffalump_model) is not present
+  unless instance_methods.map(&:to_s).include?('heffalump_model')
+    # This is the default Heffalump model. You can replace it with your own
+    # (using let/let!) # but # be sure the replacement provides the required
+    # properties.
+    let(:heffalump_model) do
+      model = Class.new do
+        include DataMapper::Resource
+
+        property :id,        DataMapper::Property::Serial
+        property :color,     DataMapper::Property::String
+        property :num_spots, DataMapper::Property::Integer
+        property :striped,   DataMapper::Property::Boolean
+
+        # This is needed for DataMapper.finalize
+        def self.name
+          'Heffalump'
+        end
+      end
+
+      DataMapper.finalize
+
+      model
+    end
+  end
+
+  before :all do
+    raise '+#adapter+ should be defined in a let(:adapter) block' unless respond_to?(:adapter)
+    raise '+#repository+ should be defined in a let(:repository) block' unless respond_to?(:repository)
+
+    DataMapper.finalize
+
+    # create all tables and constraints before each spec
+    if repository.respond_to?(:auto_migrate!)
+      heffalump_model.auto_migrate!
+    end
+  end
+
+  if adapter_supports?(:create)
+    describe '#create' do
+      after do
+        heffalump_model.destroy
+      end
+
+      it 'does not raise any errors' do
+        expect {
+          expect(heffalump_model.new(color: 'peach').save).to be(true)
+        }.not_to raise_error
+      end
+
+      it 'sets the identity field for the resource' do
+        heffalump = heffalump_model.new(color: 'peach')
+        expect(heffalump.id).to be_nil
+        expect(heffalump.save).to be(true)
+        expect(heffalump.id).not_to be_nil
+      end
+    end
+  else
+    it 'needs to support #create'
+  end
+
+  if adapter_supports?(:read)
+    describe '#read' do
+      before :all do
+        @heffalump = heffalump_model.create(color: 'brownish hue')
+        expect(@heffalump).to be_saved
+        @query = heffalump_model.all.query
+      end
+
+      after :all do
+        heffalump_model.destroy
+      end
+
+      it 'does not raise any errors' do
+        expect {
+          heffalump_model.all
+        }.not_to raise_error
+      end
+
+      it 'returns expected results' do
+        expect(heffalump_model.all).to eq [@heffalump]
+      end
+    end
+  else
+    it 'needs to support #read'
+  end
+
+  if adapter_supports?(:update)
+    describe '#update' do
+      before do
+        @heffalump = heffalump_model.create(color: 'peach', num_spots: 1, striped: false)
+        expect(@heffalump).to be_saved
+      end
+
+      after do
+        heffalump_model.destroy
+      end
+
+      it 'does not raise any errors' do
+        expect {
+          @heffalump.num_spots = 0
+          expect(@heffalump.save).to be(true)
+        }.not_to raise_error
+      end
+
+      it 'does not alter the identity field' do
+        key = @heffalump.key
+        @heffalump.num_spots = 0
+        expect(@heffalump.save).to be(true)
+        expect(@heffalump.key).to eq key
+      end
+
+      it 'updates altered fields' do
+        @heffalump.num_spots = 0
+        expect(@heffalump.save).to be(true)
+        expect(heffalump_model.get!(*@heffalump.key).num_spots).to be(0)
+      end
+
+      it 'does not alter other fields' do
+        num_spots = @heffalump.num_spots
+        @heffalump.striped = true
+        expect(@heffalump.save).to be(true)
+        expect(heffalump_model.get!(*@heffalump.key).num_spots).to be(num_spots)
+      end
+    end
+  else
+    it 'needs to support #update'
+  end
+
+  if adapter_supports?(:delete)
+    describe '#delete' do
+      before do
+        @heffalump = heffalump_model.create(color: 'forest green')
+        expect(@heffalump).to be_saved
+      end
+
+      after do
+        heffalump_model.destroy
+      end
+
+      it 'does not raise any errors' do
+        expect {
+          @heffalump.destroy
+        }.not_to raise_error
+      end
+
+      it 'deletes the requested resource' do
+        key = @heffalump.key
+        @heffalump.destroy
+        expect(heffalump_model.get(*key)).to be_nil
+      end
+    end
+  else
+    it 'needs to support #delete'
+  end
+
+  if adapter_supports?(:read, :create)
+    describe 'query matching' do
+      before :all do
+        @red  = heffalump_model.create(color: 'red')
+        @two  = heffalump_model.create(num_spots: 2)
+        @five = heffalump_model.create(num_spots: 5)
+        [@red, @two, @five].each { |resource| expect(resource).to be_saved }
+      end
+
+      after :all do
+        heffalump_model.destroy
+      end
+
+      describe 'conditions' do
+        describe 'eql' do
+          it 'is able to search for objects included in an inclusive range of values' do
+            expect(heffalump_model.all(num_spots: 1..5)).to include(@five)
+          end
+
+          it 'is able to search for objects included in an exclusive range of values' do
+            expect(heffalump_model.all(num_spots: 1...6)).to include(@five)
+          end
+
+          it 'is not able to search for values not included in an inclusive range of values' do
+            expect(heffalump_model.all(num_spots: 1..4)).not_to include(@five)
+          end
+
+          it 'is not able to search for values not included in an exclusive range of values' do
+            expect(heffalump_model.all(num_spots: 1...5)).not_to include(@five)
+          end
+        end
+
+        describe 'not' do
+          it 'is able to search for objects with not equal value' do
+            expect(heffalump_model.all(:color.not => 'red')).not_to include(@red)
+          end
+
+          it 'includes objects that are not like the value' do
+            expect(heffalump_model.all(:color.not => 'black')).to include(@red)
+          end
+
+          it 'is able to search for objects with not nil value' do
+            expect(heffalump_model.all(:color.not => nil)).to include(@red)
+          end
+
+          it 'does not include objects with a nil value' do
+            expect(heffalump_model.all(:color.not => nil)).not_to include(@two)
+          end
+
+          it 'is able to search for object with a nil value using required properties' do
+            expect(heffalump_model.all(:id.not => nil)).to eq [@red, @two, @five]
+          end
+
+          it 'is able to search for objects not in an empty list (match all)' do
+            expect(heffalump_model.all(:color.not => [])).to eq [@red, @two, @five]
+          end
+
+          it 'is able to search for objects in an empty list and another OR condition (match none on the empty list)' do
+            expect(heffalump_model.all(
+              conditions: DataMapper::Query::Conditions::Operation.new(
+                :or,
+                DataMapper::Query::Conditions::Comparison.new(:in, heffalump_model.properties[:color], []),
+                DataMapper::Query::Conditions::Comparison.new(:in, heffalump_model.properties[:num_spots], [5])
+              )
+            )).to eq [@five]
+          end
+
+          it 'is able to search for objects not included in an array of values' do
+            expect(heffalump_model.all(:num_spots.not => [1, 3, 5, 7])).to include(@two)
+          end
+
+          it 'is able to search for objects not included in an array of values' do
+            expect(heffalump_model.all(:num_spots.not => [1, 3, 5, 7])).not_to include(@five)
+          end
+
+          it 'is able to search for objects not included in an inclusive range of values' do
+            expect(heffalump_model.all(:num_spots.not => 1..4)).to include(@five)
+          end
+
+          it 'is able to search for objects not included in an exclusive range of values' do
+            expect(heffalump_model.all(:num_spots.not => 1...5)).to include(@five)
+          end
+
+          it 'is not able to search for values not included in an inclusive range of values' do
+            expect(heffalump_model.all(:num_spots.not => 1..5)).not_to include(@five)
+          end
+
+          it 'is not able to search for values not included in an exclusive range of values' do
+            expect(heffalump_model.all(:num_spots.not => 1...6)).not_to include(@five)
+          end
+        end
+
+        describe 'like' do
+          it 'is able to search for objects that match value' do
+            expect(heffalump_model.all(:color.like => '%ed')).to include(@red)
+          end
+
+          it 'does not search for objects that do not match the value' do
+            expect(heffalump_model.all(:color.like => '%blak%')).not_to include(@red)
+          end
+        end
+
+        describe 'regexp' do
+          before do
+            if (defined?(DataMapper::Adapters::SqliteAdapter) && adapter.is_a?(DataMapper::Adapters::SqliteAdapter)) ||
+               (defined?(DataMapper::Adapters::SqlserverAdapter) && adapter.is_a?(DataMapper::Adapters::SqlserverAdapter))
+              pending 'delegate regexp matches to same system that the InMemory and YAML adapters use'
+            end
+          end
+
+          it 'is able to search for objects that match value' do
+            expect(heffalump_model.all(color: /ed/)).to include(@red)
+          end
+
+          it 'is not able to search for objects that do not match the value' do
+            expect(heffalump_model.all(color: /blak/)).not_to include(@red)
+          end
+
+          it 'is able to do a negated search for objects that match value' do
+            expect(heffalump_model.all(:color.not => /blak/)).to include(@red)
+          end
+
+          it 'is not able to do a negated search for objects that do not match value' do
+            expect(heffalump_model.all(:color.not => /ed/)).not_to include(@red)
+          end
+        end
+
+        describe 'gt' do
+          it 'is able to search for objects with value greater than' do
+            expect(heffalump_model.all(:num_spots.gt => 1)).to include(@two)
+          end
+
+          it 'does not find objects with a value less than' do
+            expect(heffalump_model.all(:num_spots.gt => 3)).not_to include(@two)
+          end
+        end
+
+        describe 'gte' do
+          it 'is able to search for objects with value greater than' do
+            expect(heffalump_model.all(:num_spots.gte => 1)).to include(@two)
+          end
+
+          it 'is able to search for objects with values equal to' do
+            expect(heffalump_model.all(:num_spots.gte => 2)).to include(@two)
+          end
+
+          it 'does not find objects with a value less than' do
+            expect(heffalump_model.all(:num_spots.gte => 3)).not_to include(@two)
+          end
+        end
+
+        describe 'lt' do
+          it 'is able to search for objects with value less than' do
+            expect(heffalump_model.all(:num_spots.lt => 3)).to include(@two)
+          end
+
+          it 'does not find objects with a value less than' do
+            expect(heffalump_model.all(:num_spots.gt => 2)).not_to include(@two)
+          end
+        end
+
+        describe 'lte' do
+          it 'is able to search for objects with value less than' do
+            expect(heffalump_model.all(:num_spots.lte => 3)).to include(@two)
+          end
+
+          it 'is able to search for objects with values equal to' do
+            expect(heffalump_model.all(:num_spots.lte => 2)).to include(@two)
+          end
+
+          it 'does not find objects with a value less than' do
+            expect(heffalump_model.all(:num_spots.lte => 1)).not_to include(@two)
+          end
+        end
+      end
+
+      describe 'limits' do
+        it 'is able to limit the objects' do
+          expect(heffalump_model.all(limit: 2).length).to eq 2
+        end
+      end
+    end
+  else
+    it 'needs to support #read and #create to test query matching'
+  end
+end

data/lib/dm-core/spec/shared/public/property_spec.rb

@@ -0,0 +1,229 @@
+shared_examples 'A public Property' do
+  before :all do
+    %w(@type @load_as @name @value @other_value).each do |ivar|
+      raise "+#{ivar}+ should be defined in before block" unless instance_variable_defined?(ivar)
+    end
+
+    module ::Blog
+      class Article
+        include DataMapper::Resource
+        property :id, Serial
+      end
+    end
+
+    @model     = Blog::Article
+    @options ||= {}
+  end
+
+  describe 'with a sub-type' do
+    before :all do
+      class ::SubType < @type; end
+      @subtype = ::SubType
+      @type.accept_options :foo, :bar
+    end
+
+    before :all do
+      @original = @type.accepted_options.dup
+    end
+
+    after :all do
+      @type.accepted_options.replace(@original - %i(foo bar))
+    end
+
+    describe 'predefined options' do
+      before :all do
+        class ::ChildSubType < @subtype
+          default nil
+        end
+        @child_subtype = ChildSubType
+      end
+
+      describe 'when parent type overrides a default' do
+        before do
+          @subtype.default 'foo'
+        end
+
+        after do
+          DataMapper::Property.descendants.delete(ChildSubType)
+          Object.send(:remove_const, :ChildSubType)
+        end
+
+        it "does not override the child's type setting" do
+          expect(@child_subtype.default).to eql(nil)
+        end
+      end
+    end
+
+    after :all do
+      DataMapper::Property.descendants.delete(SubType)
+      Object.send(:remove_const, :SubType)
+    end
+
+    describe '.accept_options' do
+      describe 'when provided :foo, :bar' do
+        it 'adds new options' do
+          [@type, @subtype].each do |type|
+            expect(type.accepted_options.include?(:foo)).to be(true)
+            expect(type.accepted_options.include?(:bar)).to be(true)
+          end
+        end
+
+        it 'creates predefined option setters' do
+          [@type, @subtype].each do |type|
+            expect(type).to respond_to(:foo)
+            expect(type).to respond_to(:bar)
+          end
+        end
+
+        describe 'auto-generated option setters' do
+          before :all do
+            @type.foo true
+            @type.bar 1
+            @property = @type.new(@model, @name, @options)
+          end
+
+          it 'sets the pre-defined option values' do
+            expect(@property.options[:foo]).to eq true
+            expect(@property.options[:bar]).to eq 1
+          end
+
+          it 'asks the superclass for the value if unknown' do
+            expect(@subtype.foo).to eq true
+            expect(@subtype.bar).to eq 1
+          end
+        end
+      end
+    end
+
+    describe '.descendants' do
+      it 'includes the sub-type' do
+        expect(@type.descendants.include?(SubType)).to be(true)
+      end
+    end
+
+    describe '.load_as' do
+      it 'returns the load_as' do
+        [@type, @subtype].each do |type|
+          expect(type.load_as).to be(@load_as)
+        end
+      end
+
+      it 'changes the load_as class' do
+        @subtype.load_as Object
+        expect(@subtype.load_as).to be(Object)
+      end
+    end
+  end
+
+  %i(allow_blank allow_nil).each do |opt|
+    describe "##{method = "#{opt}?"}" do
+      [true, false].each do |value|
+        describe "when created with :#{opt} => #{value}" do
+          before :all do
+            @property = @type.new(@model, @name, @options.merge(opt => value))
+          end
+
+          it "returns #{value}" do
+            expect(@property.send(method)).to be(value)
+          end
+        end
+      end
+
+      describe "when created with :#{opt} => true and :required => true" do
+        it 'fails with ArgumentError' do
+          expect {
+            @property = @type.new(@model, @name, @options.merge(opt => true, required: true))
+          }.to raise_error(ArgumentError,
+                               'options[:required] cannot be mixed with :allow_nil or :allow_blank')
+        end
+      end
+    end
+  end
+
+  %i(key? required? index unique_index unique?).each do |method|
+    describe "##{method}" do
+      [true, false].each do |value|
+        describe "when created with :#{method} => #{value}" do
+          before :all do
+            opt = method.to_s.chomp('?').to_sym
+            @property = @type.new(@model, @name, @options.merge(opt => value))
+          end
+
+          it "returns #{value}" do
+            expect(@property.send(method)).to be(value)
+          end
+        end
+      end
+    end
+  end
+
+  describe '#lazy?' do
+    describe 'when created with :lazy => true, :key => false' do
+      before :all do
+        @property = @type.new(@model, @name, @options.merge(lazy: true, key: false))
+      end
+
+      it 'returns true' do
+        expect(@property.lazy?).to be(true)
+      end
+    end
+
+    describe 'when created with :lazy => true, :key => true' do
+      before :all do
+        @property = @type.new(@model, @name, @options.merge(lazy: true, key: true))
+      end
+
+      it 'returns false' do
+        expect(@property.lazy?).to be(false)
+      end
+    end
+  end
+
+  describe '#instance_of?' do
+    subject { property.instance_of?(klass) }
+
+    let(:property) { @type.new(@model, @name, @options) }
+
+    context 'when provided the property class' do
+      let(:klass) { @type }
+
+      it { is_expected.to be(true) }
+    end
+
+    context 'when provided the property superclass' do
+      let(:klass) { @type.superclass }
+
+      it { is_expected.to be(false) }
+    end
+
+    context 'when provided the DataMapper::Property class' do
+      let(:klass) { DataMapper::Property }
+
+      it { is_expected.to be(false) }
+    end
+  end
+
+  describe '#kind_of?' do
+    subject { property.is_a?(klass) }
+
+    let(:property) { @type.new(@model, @name, @options) }
+
+    context 'when provided the property class' do
+      let(:klass) { @type }
+
+      it { is_expected.to be(true) }
+    end
+
+    context 'when provided the property superclass' do
+      let(:klass) { @type.superclass }
+
+      it { is_expected.to be(true) }
+    end
+
+    context 'when provided the DataMapper::Property class' do
+      let(:klass) { DataMapper::Property }
+
+      it { is_expected.to be(true) }
+    end
+  end
+end