ardm 0.0.1 → 0.1.0

data/spec/public/property/serial_spec.rb

@@ -15,8 +15,8 @@ describe Ardm::Property::Serial do
   describe '.options' do
     subject { described_class.options }
 
-    it { should be_kind_of(Hash) }
+    it { is_expected.to be_kind_of(Hash) }
 
-    it { should eql(:load_as => @load_as, :dump_as => @load_as, :coercion_method => :to_integer, :min => 1, :serial => true) }
+    it { is_expected.to eql(:load_as => @load_as, :dump_as => @load_as, :coercion_method => :to_integer, :min => 1, :serial => true) }
   end
 end

data/spec/public/property/string_spec.rb

@@ -15,8 +15,8 @@ describe Ardm::Property::String do
   describe '.options' do
     subject { described_class.options }
 
-    it { should be_kind_of(Hash) }
+    it { is_expected.to be_kind_of(Hash) }
 
-    it { should eql(:load_as => @load_as, :dump_as => @load_as, :coercion_method => :to_string, :length => 50) }
+    it { is_expected.to eql(:load_as => @load_as, :dump_as => @load_as, :coercion_method => :to_string, :length => 50) }
   end
 end

data/spec/public/property/text_spec.rb

@@ -15,9 +15,9 @@ describe Ardm::Property::Text do
   describe '.options' do
     subject { described_class.options }
 
-    it { should be_kind_of(Hash) }
+    it { is_expected.to be_kind_of(Hash) }
 
-    it { should eql(:load_as => @load_as, :dump_as => @load_as, :coercion_method => :to_string, :length => 65535, :lazy => true) }
+    it { is_expected.to eql(:load_as => @load_as, :dump_as => @load_as, :coercion_method => :to_string, :length => 65535, :lazy => true) }
   end
 
 end

data/spec/public/property/time_spec.rb

@@ -15,8 +15,8 @@ describe Ardm::Property::Time do
   describe '.options' do
     subject { described_class.options }
 
-    it { should be_kind_of(Hash) }
+    it { is_expected.to be_kind_of(Hash) }
 
-    it { should eql(:load_as => @load_as, :dump_as => @load_as, :coercion_method => :to_time) }
+    it { is_expected.to eql(:load_as => @load_as, :dump_as => @load_as, :coercion_method => :to_time) }
   end
 end

data/spec/public/property_spec.rb

@@ -30,37 +30,37 @@ describe Ardm::Property do
 
   describe '#field' do
     it 'returns @field value if it is present' do
-      Track.properties[:title].field.should eql('name')
+      expect(Track.properties[:title].field).to eql('name')
     end
   end
 
   describe '#default_for' do
     it 'returns default value for non-callables' do
-      Image.properties[:format].default_for(Image.new).should == 'jpeg'
+      expect(Image.properties[:format].default_for(Image.new)).to eq('jpeg')
     end
 
     it 'returns result of a call for callable values' do
-      Image.properties[:taken_at].default_for(Image.new).year.should == Time.now.year
+      expect(Image.properties[:taken_at].default_for(Image.new).year).to eq(Time.now.year)
     end
 
     it "sets the default when the record is created" do
       img = Image.create!(title: 'My Picture')
-      img.format.should == 'jpeg'
+      expect(img.format).to eq('jpeg')
     end
   end
 
   describe '#eql?' do
     it 'is true for properties with the same model and name' do
-      Track.properties[:title].should eql(Track.properties[:title])
+      expect(Track.properties[:title]).to eql(Track.properties[:title])
     end
 
 
     it 'is false for properties of different models' do
-      Track.properties[:title].should_not eql(Image.properties[:title])
+      expect(Track.properties[:title]).not_to eql(Image.properties[:title])
     end
 
     it 'is false for properties with different names' do
-      Track.properties[:title].should_not eql(Track.properties[:id])
+      expect(Track.properties[:title]).not_to eql(Track.properties[:id])
     end
   end
 
@@ -72,26 +72,24 @@ describe Ardm::Property do
       @image.instance_variable_set(:@description, 'Is set by magic')
     end
 
-    it 'gets instance variable value from the resource directly' do
-      pending "support for this in ActiveRecord is questionable" do
-        # if you know a better way to test direct instance variable access,
-        # go ahead and make changes to this example
-        Image.properties[:description].get!(@image).should == 'Is set by magic'
-      end
+    it 'gets instance variable value from the resource directly', pending: true 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
-      Track.properties[:title].index.should be(true)
+      expect(Track.properties[:title].index).to be(true)
     end
 
     it 'returns index name when property has a named index' do
-      Track.properties[:album].index.should eql(:artist_album)
+      expect(Track.properties[:album].index).to eql(:artist_album)
     end
 
     it 'returns false when property has no index' do
-      Track.properties[:musicbrainz_hash].index.should be(false)
+      expect(Track.properties[:musicbrainz_hash].index).to be(false)
     end
   end
 
@@ -107,48 +105,48 @@ describe Ardm::Property do
     end
 
     it 'features model name' do
-      @str.should =~ /@model=Track/
+      expect(@str).to match(/@model=Track/)
     end
 
     it 'features property name' do
-      @str.should =~ /@name=:title/
+      expect(@str).to match(/@name=:title/)
     end
   end
 
   describe '#key?' do
     describe 'returns true when property is a ' do
       it 'serial key' do
-        Track.properties[:id].key?.should be(true)
+        expect(Track.properties[:id].key?).to be(true)
       end
       it 'natural key' do
-        Image.properties[:md5hash].key?.should be(true)
+        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
-      Track.properties[:title].key?.should be(false)
+      expect(Track.properties[:title].key?).to be(false)
     end
   end
 
   describe '#lazy?' do
     it 'returns true when property is lazy loaded' do
-      Image.properties[:description].lazy?.should be(true)
+      expect(Image.properties[:description].lazy?).to be(true)
     end
 
     it 'returns false when property is not lazy loaded' do
-      Track.properties[:artist].lazy?.should be(false)
+      expect(Track.properties[:artist].lazy?).to be(false)
     end
   end
 
   describe '#length' do
     it 'returns upper bound for Range values' do
-      Image.properties[:description].length.should eql(1024)
+      expect(Image.properties[:description].length).to eql(1024)
     end
 
     it 'returns value as is for integer values' do
-      Image.properties[:md5hash].length.should eql(32)
+      expect(Image.properties[:md5hash].length).to eql(32)
     end
   end
 
@@ -159,7 +157,7 @@ describe Ardm::Property do
       end
 
       it 'should be nil' do
-        @property.min.should be_nil
+        expect(@property.min).to be_nil
       end
     end
 
@@ -169,7 +167,7 @@ describe Ardm::Property do
       end
 
       it 'should be the default value' do
-        @property.min.should == 0
+        expect(@property.min).to eq(0)
       end
     end
 
@@ -180,7 +178,7 @@ describe Ardm::Property do
       end
 
       it 'should be the expected value' do
-        @property.min.should == @min
+        expect(@property.min).to eq(@min)
       end
     end
   end
@@ -192,7 +190,7 @@ describe Ardm::Property do
       end
 
       it 'should be nil' do
-        @property.max.should be_nil
+        expect(@property.max).to be_nil
       end
     end
 
@@ -202,7 +200,7 @@ describe Ardm::Property do
       end
 
       it 'should be the default value' do
-        @property.max.should == 2**31-1
+        expect(@property.max).to eq(2**31-1)
       end
     end
 
@@ -213,28 +211,28 @@ describe Ardm::Property do
       end
 
       it 'should be the expected value' do
-        @property.max.should == @max
+        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
-      Track.properties[:artist].allow_nil?.should be(true)
+      expect(Track.properties[:artist].allow_nil?).to be(true)
     end
 
     it 'returns false when property nil value is prohibited for this property' do
-      Image.properties[:title].allow_nil?.should be(false)
+      expect(Image.properties[:title].allow_nil?).to be(false)
     end
   end
 
   describe '#serial?' do
     it 'returns true when property is serial (auto incrementing)' do
-      Track.properties[:id].serial?.should be(true)
+      expect(Track.properties[:id].serial?).to be(true)
     end
 
     it 'returns false when property is NOT serial (auto incrementing)' do
-      Image.properties[:md5hash].serial?.should be(false)
+      expect(Image.properties[:md5hash].serial?).to be(false)
     end
   end
 
@@ -256,12 +254,12 @@ describe Ardm::Property do
     it 'type casts given value' do
       @property.set(@image, Addressable::URI.parse('http://test.example/'))
       # get a string that has been typecasted using #to_str
-      @image.title.should == 'http://test.example/'
+      expect(@image.title).to eq('http://test.example/')
     end
 
     it 'sets new property value' do
       @property.set(@image, 'Updated value')
-      @image.title.should == 'Updated value'
+      expect(@image.title).to eq('Updated value')
     end
   end
 
@@ -276,41 +274,39 @@ describe Ardm::Property do
 
     it 'directly sets instance variable on given resource' do
       @property.set!(@image, 'Set with dark Ruby magic')
-      @image.title.should == '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
-      Track.properties[:musicbrainz_hash].unique?.should be(true)
+      expect(Track.properties[:musicbrainz_hash].unique?).to be(true)
     end
 
-    it 'is true for serial fields' do
-      pending do
-        Track.properties[:title].unique?.should be(true)
-      end
+    it 'is true for serial fields', pending: true do
+      expect(Track.properties[:title].unique?).to be(true)
     end
 
     it 'is true for keys' do
-      Image.properties[:md5hash].unique?.should be(true)
+      expect(Image.properties[:md5hash].unique?).to be(true)
     end
   end
 
   describe '#unique_index' do
     it 'returns true when property has unique index' do
-      Track.properties[:musicbrainz_hash].unique_index.should be(true)
+      expect(Track.properties[:musicbrainz_hash].unique_index).to be(true)
     end
 
     it 'returns false when property has no unique index' do
-      Track.properties[:title].unique_index.should be(false)
+      expect(Track.properties[:title].unique_index).to be(false)
     end
 
     it 'returns true when property is unique' do
-      Image.properties[:title].unique_index.should be(true)
+      expect(Image.properties[:title].unique_index).to be(true)
     end
 
     it 'returns :key when property is a key' do
-      Track.properties[:id].unique_index.should == :key
+      expect(Track.properties[:id].unique_index).to eq(:key)
     end
   end
 end

data/spec/public/resource_spec.rb

@@ -0,0 +1,278 @@
+require 'spec_helper'
+
+module ::ResourceBlog
+  class User < Ardm::Record
+    self.table_name = "users"
+
+    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 < Ardm::Record
+    self.table_name = "comments"
+
+    property :id,   Serial
+    property :body, Text
+
+    belongs_to :user
+  end
+
+  class Article < Ardm::Record
+    self.table_name = "articles"
+
+    property :id,   Serial
+    property :body, Text
+    timestamps :at
+
+    has n, :paragraphs
+  end
+
+  class Paragraph < Ardm::Record
+    self.table_name = "paragraphs"
+
+    property :id,   Serial
+    property :text, String
+
+    belongs_to :article
+  end
+end
+
+Ardm::Record.finalize
+
+# TODO: unused?
+#class ::ResourceDefault < Ardm::Record
+#  property :name, String, :key => true, :default => 'a default value'
+#end
+
+describe Ardm::Record do
+  before do
+    @user_model      = ResourceBlog::User
+    @author_model    = ResourceBlog::Author
+    @comment_model   = ResourceBlog::Comment
+    @article_model   = ResourceBlog::Article
+    @paragraph_model = ResourceBlog::Paragraph
+
+    user = @user_model.create!(:name => 'dbussink', :age => 25, :description => 'Test')
+
+    @user = @user_model.get!(user.key)
+  end
+
+  # FIXME
+  #it_should_behave_like 'A public Resource'
+  #it_should_behave_like 'A Resource supporting Strategic Eager Loading'
+
+  it 'A resource should respond 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 should respond 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
+      reset_raise_on_save_failure(@user_model)
+    end
+
+    describe 'with a true value' do
+      subject { @user_model.raise_on_save_failure = true }
+
+      it { is_expected.to be true }
+
+      it 'should set raise_on_save_failure' do
+        expect { subject }.to change {
+          @user_model.raise_on_save_failure
+        }.from(false).to(true)
+      end
+    end
+
+    describe 'with a false value' do
+      subject { @user_model.raise_on_save_failure = false }
+
+      it { is_expected.to be false }
+
+      it 'should set raise_on_save_failure' do
+        expect { subject }.to_not 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', pending: true do
+          before do
+            expect(@user).to receive(:save_self).and_return(false)
+          end
+
+          it 'should raise an exception' do
+            expect { subject }.to raise_error(Ardm::SaveFailureError, "Blog::User##{method} returned false, Blog::User was not saved")
+          end
+        end
+      end
+    end
+  end
+
+  [ :update, :update! ].each do |method|
+    describe 'with attributes where one is a foreign key' do
+      before do
+        @dkubb = @user_model.create(:name => 'dkubb', :age => 33)
+        @user.referrer = @dkubb
+        @user.save
+        @user = @user_model.get(@user.key)
+        expect(@user.referrer).to eq(@dkubb)
+
+        @solnic = @user_model.create(:name => 'solnic', :age => 28)
+
+        @attributes = {}
+
+        relationship = @user_model.relationships[:referrer]
+
+        # Original datamapper implementation:
+        #relationship.child_key.to_a.each_with_index do |k, i|
+        #  @attributes[k.name] = relationship.parent_key.to_a[i].get(@solnic)
+        #end
+
+        # #key returns an array even though there's only one value.
+        @attributes[relationship.foreign_key] = @solnic.key.first
+
+        @return = @user.__send__(method, @attributes)
+      end
+
+      it 'should return true' do
+        expect(@return).to be true
+      end
+
+      it 'should update attributes of Resource' do
+        @attributes.each { |key, value| expect(@user.__send__(key)).to eq(value) }
+      end
+
+      it 'should persist the changes' do
+        resource = @user_model.get(@user.key)
+        @attributes.each { |key, value| expect(resource.__send__(key)).to eq(value) }
+      end
+
+      it 'should return 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 }
+
+    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) { double('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