sbf-dm-core 1.3.0.beta

data/spec/public/property_spec.rb

@@ -0,0 +1,333 @@
+require_relative '../spec_helper'
+
+# instance methods
+describe DataMapper::Property do
+
+  # define the model prior to supported_by
+  before :all do
+    class ::Track
+      include DataMapper::Resource
+
+      property :id,               Serial
+      property :artist,           String, :lazy => false, :index => :artist_album
+      property :title,            String, :field => 'name', :index => true
+      property :album,            String, :index => :artist_album
+      property :musicbrainz_hash, String, :unique => true, :unique_index => true
+    end
+
+    class ::Image
+      include DataMapper::Resource
+
+      property :md5hash,      String, :key => true, :length => 32
+      property :title,        String, :required => true, :unique => true
+      property :description,  Text,   :length => 1..1024, :lazy => [ :detail ]
+      property :width,        Integer, :lazy => [:dimensions]
+      property :height,       Integer, :lazy => [:dimensions]
+      property :format,       String, :default => 'jpeg'
+      property :taken_at,     Time,   :default => proc { Time.now }
+    end
+    DataMapper.finalize
+  end
+
+  supported_by :all do
+    describe '#field' do
+      it 'returns @field value if it is present' do
+        expect(Track.properties[:title].field).to eql('name')
+      end
+
+      it 'returns field for specific repository when it is present'
+
+      it 'sets field value using field naming convention on first reference'
+    end
+
+    describe '#default_for' do
+      it 'returns default value for non-callables' do
+        expect(Image.properties[:format].default_for(Image.new)).to eq 'jpeg'
+      end
+
+      it 'returns result of a call for callable values' do
+        expect(Image.properties[:taken_at].default_for(Image.new).year).to eq Time.now.year
+      end
+    end
+
+    describe '#eql?' do
+      it 'is true for properties with the same model and name' do
+        expect(Track.properties[:title]).to eql(Track.properties[:title])
+      end
+
+      it 'is false for properties of different models' do
+        expect(Track.properties[:title]).not_to eql(Image.properties[:title])
+      end
+
+      it 'is false for properties with different names' do
+        expect(Track.properties[:title]).not_to eql(Track.properties[:id])
+      end
+    end
+
+    describe '#get!' do
+      before :all do
+        @image = Image.new
+
+        # now some dark Ruby magic
+        @image.instance_variable_set(:@description, 'Is set by magic')
+      end
+
+      it 'gets instance variable value from the resource directly' do
+        # if you know a better way to test direct instance variable access,
+        # go ahead and make changes to this example
+        expect(Image.properties[:description].get!(@image)).to eq 'Is set by magic'
+      end
+    end
+
+    describe '#index' do
+      it 'returns true when property has an index' do
+        expect(Track.properties[:title].index).to be(true)
+      end
+
+      it 'returns index name when property has a named index' do
+        expect(Track.properties[:album].index).to eql(:artist_album)
+      end
+
+      it 'returns false when property has no index' do
+        expect(Track.properties[:musicbrainz_hash].index).to be(false)
+      end
+    end
+
+    describe '#initialize' do
+      describe 'when tracking strategy is explicitly given' do
+        it 'uses tracking strategy from options'
+      end
+    end
+
+    describe '#inspect' do
+      before :all do
+        @str = Track.properties[:title].inspect
+      end
+
+      it 'features model name' do
+        expect(@str).to match(/@model=Track/)
+      end
+
+      it 'features property name' do
+        expect(@str).to match(/@name=:title/)
+      end
+    end
+
+    describe '#key?' do
+      describe 'returns true when property is a ' do
+        it 'serial key' do
+          expect(Track.properties[:id].key?).to be(true)
+        end
+        it 'natural key' do
+          expect(Image.properties[:md5hash].key?).to be(true)
+        end
+      end
+
+      it 'returns true when property is a part of composite key'
+
+      it 'returns false when property does not relate to a key' do
+        expect(Track.properties[:title].key?).to be(false)
+      end
+    end
+
+    describe '#lazy?' do
+      it 'returns true when property is lazy loaded' do
+        expect(Image.properties[:description].lazy?).to be(true)
+      end
+
+      it 'returns false when property is not lazy loaded' do
+        expect(Track.properties[:artist].lazy?).to be(false)
+      end
+    end
+
+    describe '#lazy_load_properties' do
+      it 'returns all lazy properties in the same context' do
+        expect(Image.properties[:width].__send__(:lazy_load_properties)).to eq Image.properties.values_at(:width, :height)
+      end
+
+      it 'returns all properties by default' do
+        expect(Track.properties[:artist].__send__(:lazy_load_properties)).to eq Track.properties
+      end
+    end
+
+    describe '#length' do
+      it 'returns upper bound for Range values' do
+        expect(Image.properties[:description].length).to eql(1024)
+      end
+
+      it 'returns value as is for integer values' do
+        expect(Image.properties[:md5hash].length).to eql(32)
+      end
+    end
+
+    describe '#min' do
+      describe 'when :min and :max options not provided to constructor' do
+        before do
+          @property = Image.property(:integer_with_nil_min, Integer)
+        end
+
+        it 'Is nil' do
+          expect(@property.min).to be_nil
+        end
+      end
+
+      describe 'when :min option not provided to constructor, but :max is provided' do
+        before do
+          @property = Image.property(:integer_with_default_min, Integer, :max => 1)
+        end
+
+        it 'is the default value' do
+          expect(@property.min).to eq 0
+        end
+      end
+
+      describe 'when :min and :max options provided to constructor' do
+        before do
+          @min = 1
+          @property = Image.property(:integer_with_explicit_min, Integer, :min => @min, :max => 2)
+        end
+
+        it 'is the expected value' do
+          expect(@property.min).to eq @min
+        end
+      end
+    end
+
+    describe '#max' do
+      describe 'when :min and :max options not provided to constructor' do
+        before do
+          @property = Image.property(:integer_with_nil_max, Integer)
+        end
+
+        it 'Is nil' do
+          expect(@property.max).to be_nil
+        end
+      end
+
+      describe 'when :max option not provided to constructor, but :min is provided' do
+        before do
+          @property = Image.property(:integer_with_default_max, Integer, :min => 1)
+        end
+
+        it 'is the default value' do
+          expect(@property.max).to eq 2**31 - 1
+        end
+      end
+
+      describe 'when :min and :max options provided to constructor' do
+        before do
+          @max = 2
+          @property = Image.property(:integer_with_explicit_max, Integer, min: 1, max: @max)
+        end
+
+        it 'Is the expected value' do
+          expect(@property.max).to eq @max
+        end
+      end
+    end
+
+    describe '#allow_nil?' do
+      it 'returns true when property can accept nil as its value' do
+        expect(Track.properties[:artist].allow_nil?).to be(true)
+      end
+
+      it 'returns false when property nil value is prohibited for this property' do
+        expect(Image.properties[:title].allow_nil?).to be(false)
+      end
+    end
+
+    describe '#serial?' do
+      it 'returns true when property is serial (auto incrementing)' do
+        expect(Track.properties[:id].serial?).to be(true)
+      end
+
+      it 'returns false when property is NOT serial (auto incrementing)' do
+        expect(Image.properties[:md5hash].serial?).to be(false)
+      end
+    end
+
+    describe '#set' do
+      before :all do
+        # keep in mind we must run these examples with a
+        # saved model instance
+        @image = Image.create(
+          :md5hash     => '5268f0f3f452844c79843e820f998869',
+          :title       => 'Rome at the sunset',
+          :description => 'Just wow'
+        )
+
+        @property = Image.properties[:title]
+      end
+
+      it 'triggers lazy loading for given resource'
+
+      it 'sets new property value' do
+        @property.set(@image, 'Updated value')
+        expect(@image.title).to eq 'Updated value'
+      end
+    end
+
+    describe '#set!' do
+      before :all do
+        @image = Image.new(:md5hash      => '5268f0f3f452844c79843e820f998869',
+                           :title       => 'Rome at the sunset',
+                           :description => 'Just wow')
+
+        @property = Image.properties[:title]
+      end
+
+      it 'directly sets instance variable on given resource' do
+        @property.set!(@image, 'Set with dark Ruby magic')
+        expect(@image.title).to eq 'Set with dark Ruby magic'
+      end
+    end
+
+    describe '#unique?' do
+      it 'is true for fields that explicitly given uniq index' do
+        expect(Track.properties[:musicbrainz_hash].unique?).to be(true)
+      end
+
+      it 'is true for serial fields' do
+        pending
+
+        expect(Track.properties[:title].unique?).to be(true)
+      end
+
+      it 'is true for keys' do
+        expect(Image.properties[:md5hash].unique?).to be(true)
+      end
+    end
+
+    describe '#unique_index' do
+      it 'returns true when property has unique index' do
+        expect(Track.properties[:musicbrainz_hash].unique_index).to be(true)
+      end
+
+      it 'returns false when property has no unique index' do
+        expect(Track.properties[:title].unique_index).to be(false)
+      end
+
+      it 'returns true when property is unique' do
+        expect(Image.properties[:title].unique_index).to be(true)
+      end
+
+      it 'returns :key when property is a key' do
+        expect(Track.properties[:id].unique_index).to eq :key
+      end
+    end
+
+    describe 'exception on bad property names' do
+      it "is raised for 'model'" do
+        expect {
+          Track.property :model, String
+        }.to raise_error(ArgumentError)
+      end
+
+      it "is raised for 'repository_name'" do
+        expect {
+          Track.property :repository_name, String
+        }.to raise_error(ArgumentError)
+      end
+    end
+  end
+end # DataMapper::Property

data/spec/public/resource/state_spec.rb

@@ -0,0 +1,72 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+
+describe 'DataMapper::Resource' do
+  before :all do
+    class ::Author
+      include DataMapper::Resource
+
+      property :id,        Serial
+      property :string_,   String
+      property :bool_,     Boolean
+      property :float_,    Float
+      property :integer_,  Integer
+      property :decimal_,  Decimal
+      property :datetime_, DateTime
+      property :date_,     Date
+      property :time_,     Time
+    end
+
+    DataMapper.finalize
+
+    @model = Author
+  end
+
+  supported_by :all do
+    before do
+      @values = {
+        :string_   => Addressable::URI.parse('http://test.example/'),
+        :bool_     => true,
+        :float_    => 2.5,
+        :integer_  => 10,
+        :decimal_  => BigDecimal("999.95"),
+        :datetime_ => DateTime.parse('2010-10-11 12:13:14+0'),
+        :date_     => Date.parse('2010-10-11 12:13:14+0'),
+        :time_     => Time.parse('2010-10-11 12:13:14+0'),
+      }
+      @string_values = {
+        :string_ => 'http://test.example/',
+        :decimal_ => '999.95',
+      }
+
+      @resource = @model.create(@values)
+    end
+
+    describe '.new' do
+      subject { @resource }
+
+      it { is_expected.not_to be_dirty }
+    end
+
+    [:string_, :bool_, :float_, :integer_, :decimal_, :datetime_, :date_, :time_].each do |property|
+      describe "#{property.to_s[0...-1]} property mutator" do
+        before do
+          @resource.send("#{property}=", @string_values[property] || @values[property].to_s)
+        end
+
+        it 'type casts given equal value so resource remains clean' do
+          expect(@resource).not_to be_dirty
+        end
+      end
+
+      describe "#attribute_set for #{property.to_s[0...-1]} property" do
+        before do
+          @resource.attribute_set(property, @string_values[property] || @values[property].to_s)
+        end
+
+        it 'type casts given equal value so resource remains clean' do
+          expect(@resource).not_to be_dirty
+        end
+      end
+    end
+  end
+end

data/spec/public/resource_spec.rb

@@ -0,0 +1,289 @@
+require_relative '../spec_helper'
+
+describe DataMapper::Resource do
+  before :all do
+    module ::Blog
+      class User
+        include DataMapper::Resource
+
+        property :name,        String, :key => true
+        property :age,         Integer
+        property :summary,     Text
+        property :description, Text
+        property :admin,       Boolean, :accessor => :private
+
+        belongs_to :parent, self, :required => false
+        has n, :children, self, :inverse => :parent
+
+        belongs_to :referrer, self, :required => false
+        has n, :comments
+
+        # FIXME: figure out a different approach than stubbing things out
+        def comment=(*)
+          # do nothing with comment
+        end
+      end
+
+      class Author < User; end
+
+      class Comment
+        include DataMapper::Resource
+
+        property :id,   Serial
+        property :body, Text
+
+        belongs_to :user
+      end
+
+      class Article
+        include DataMapper::Resource
+
+        property :id,   Serial
+        property :body, Text
+
+        has n, :paragraphs
+      end
+
+      class Paragraph
+        include DataMapper::Resource
+
+        property :id,   Serial
+        property :text, String
+
+        belongs_to :article
+      end
+    end
+
+    class ::Default
+      include DataMapper::Resource
+
+      property :name, String, :key => true, :default => 'a default value'
+    end
+    DataMapper.finalize
+
+    @user_model      = Blog::User
+    @author_model    = Blog::Author
+    @comment_model   = Blog::Comment
+    @article_model   = Blog::Article
+    @paragraph_model = Blog::Paragraph
+  end
+
+  supported_by :all do
+    before :all do
+      user = @user_model.create(:name => 'dbussink', :age => 25, :description => 'Test')
+
+      @user = @user_model.get!(*user.key)
+    end
+
+    it_behaves_like 'A public Resource'
+    it_behaves_like 'A Resource supporting Strategic Eager Loading'
+
+    it 'A resource responds to raise_on_save_failure' do
+      expect(@user).to respond_to(:raise_on_save_failure)
+    end
+
+    describe '#raise_on_save_failure' do
+      after do
+        # reset to the default value
+        reset_raise_on_save_failure(@user_model)
+        reset_raise_on_save_failure(@user)
+      end
+
+      subject { @user.raise_on_save_failure }
+
+      describe 'when model.raise_on_save_failure has not been set' do
+        it { is_expected.to be(false) }
+      end
+
+      describe 'when model.raise_on_save_failure has been set to true' do
+        before do
+          @user_model.raise_on_save_failure = true
+        end
+
+        it { is_expected.to be(true) }
+      end
+
+      describe 'when resource.raise_on_save_failure has been set to true' do
+        before do
+          @user.raise_on_save_failure = true
+        end
+
+        it { is_expected.to be(true) }
+      end
+    end
+
+    it 'A model responds to raise_on_save_failure=' do
+      expect(@user_model).to respond_to(:raise_on_save_failure=)
+    end
+
+    describe '#raise_on_save_failure=' do
+      after do
+        # reset to the default value
+        @user_model.raise_on_save_failure = false
+      end
+
+      subject { @user_model.raise_on_save_failure = @value }
+
+      describe 'with a true value' do
+        before do
+          @value = true
+        end
+
+        it { is_expected.to be(true) }
+
+        it 'Sets raise_on_save_failure' do
+          expect { method(:subject) }.to change {
+            @user_model.raise_on_save_failure
+          }.from(false).to(true)
+        end
+      end
+
+      describe 'with a false value' do
+        before do
+          @value = false
+        end
+
+        it { is_expected.to be(false) }
+
+        it 'Sets raise_on_save_failure' do
+          expect { method(:subject) }.not_to change {
+            @user_model.raise_on_save_failure
+          }
+        end
+      end
+    end
+
+    [ :save, :save! ].each do |method|
+      describe "##{method}" do
+        subject { @user.__send__(method) }
+
+        describe 'when raise_on_save_failure is true' do
+          before do
+            @user.raise_on_save_failure = true
+          end
+
+          describe 'and it is a savable resource' do
+            it { is_expected.to be(true) }
+          end
+
+          # FIXME: We cannot trigger a failing save with invalid properties anymore.
+          # Invalid properties will result in their own exception.
+          # So Im mocking here, but a better approach is needed.
+
+          describe 'and it is an invalid resource' do
+            before do
+              expect(@user).to receive(:save_self).and_return(false)
+            end
+
+            it 'Raises an exception' do
+              expect { method(:subject) }.to raise_error(DataMapper::SaveFailureError,
+                                                      "Blog::User##{method} returned false, Blog::User was not saved") { |error|
+                                            expect(error.resource).to equal(@user)
+                                          }
+            end
+          end
+        end
+      end
+    end
+
+    [ :update, :update! ].each do |method|
+      describe 'with attributes where one is a foreign key' do
+        before :all do
+          rescue_if @skip do
+            @dkubb = @user.referrer = @user_model.create(:name => 'dkubb', :age => 33)
+            @user.save
+            @user = @user_model.get!(*@user.key)
+            expect(@user.referrer).to
+
+            @solnic = @user_model.create(:name => 'solnic', :age => 28)
+
+            @attributes = {}
+
+            relationship = @user_model.relationships[:referrer]
+            relationship.child_key.to_a.each_with_index do |k, i|
+              @attributes[k.name] = relationship.parent_key.to_a[i].get!(@solnic)
+            end
+
+            @return = @user.__send__(method, @attributes)
+          end
+        end
+
+        it 'Returns true' do
+          expect(@return).to be(true)
+        end
+
+        it 'Updates attributes of Resource' do
+          @attributes.each { |key, value| expect(@user.__send__(key)).to eq value }
+        end
+
+        it 'Persists the changes' do
+          resource = @user_model.get!(*@user.key)
+          @attributes.each { |key, value| expect(resource.__send__(key)).to eq value }
+        end
+
+        it 'Returns correct parent' do
+          resource = @user_model.get!(*@user.key)
+          expect(resource.referrer).to eq @solnic
+        end
+      end
+    end
+
+    describe '#attribute_get' do
+      subject { object.attribute_get(name) }
+
+      let(:object) { @user }
+
+      context 'with a known property' do
+        let(:name) { :name }
+
+        it 'returns the attribute value' do
+          is_expected.to eq 'dbussink'
+        end
+      end
+
+      context 'with an unknown property' do
+        let(:name) { :unknown }
+
+        it 'returns nil' do
+          is_expected.to be_nil
+        end
+      end
+    end
+
+    describe '#attribute_set' do
+      subject { object.attribute_set(name, value) }
+
+      let(:object) { @user.dup }
+
+      context 'with a known property' do
+        let(:name)  { :name   }
+        let(:value) { 'dkubb' }
+
+        it 'sets the attribute' do
+          expect { subject }.to change { object.name }
+            .from('dbussink')
+            .to('dkubb')
+        end
+
+        it 'makes the object dirty' do
+          expect { subject }.to change { object.dirty? }
+            .from(false)
+            .to(true)
+        end
+      end
+
+      context 'with an unknown property' do
+        let(:name)  { :unknown              }
+        let(:value) { mock('Unknown Value') }
+
+        it 'does not set the attribute' do
+          expect { subject }.to_not change { object.attributes.dup }
+        end
+
+        it 'does not make the object dirty' do
+          expect { subject }.to_not change { object.dirty? }
+        end
+      end
+    end
+  end
+end