ardm 0.0.1 → 0.1.0

data/spec/shared/semipublic_property_spec.rb

@@ -1,27 +1,28 @@
-share_examples_for 'A semipublic Property' do
+shared_examples 'A semipublic Property' do
   module ::Blog
     class Article < Ardm::Record
       self.table_name = "articles"
       property :id, Serial
+      timestamps :at
     end
   end
 
   describe '.new' do
     describe 'when provided no options' do
       it 'should return a Property' do
-        property.should be_kind_of(type)
+        expect(property).to be_kind_of(type)
       end
 
       it 'should set the load_as' do
-        property.load_as.should be(type.load_as)
+        expect(property.load_as).to be(type.load_as)
       end
 
       it 'should set the model' do
-        property.model.should equal(model)
+        expect(property.model).to equal(model)
       end
 
       it 'should set the options to the default' do
-        property.options.should == type.options.merge(options)
+        expect(property.options).to eq(type.options.merge(options))
       end
     end
 
@@ -32,19 +33,19 @@ share_examples_for 'A semipublic Property' do
           let(:property) { type.new(model, name, options.merge(opts)) }
 
           it 'should return a Property' do
-            property.should be_kind_of(type)
+            expect(property).to be_kind_of(type)
           end
 
           it 'should set the model' do
-            property.model.should equal(model)
+            expect(property.model).to equal(model)
           end
 
           it 'should set the load_as' do
-            property.load_as.should be(type.load_as)
+            expect(property.load_as).to be(type.load_as)
           end
 
           it "should set the options to #{opts.inspect}" do
-            property.options.should == type.options.merge(options.merge(opts))
+            expect(property.options).to eq(type.options.merge(options.merge(opts)))
           end
         end
       end
@@ -52,9 +53,9 @@ share_examples_for 'A semipublic Property' do
       [ [], nil ].each do |value|
         describe "when provided #{(invalid_options = { attribute => value }).inspect}" do
           it 'should raise an exception' do
-            lambda {
+            expect {
               type.new(model, name, options.merge(invalid_options))
-            }.should raise_error(ArgumentError, "options[#{attribute.inspect}] must be either true, false, a Symbol or an Array of Symbols")
+            }.to raise_error(ArgumentError, "options[#{attribute.inspect}] must be either true, false, a Symbol or an Array of Symbols")
           end
         end
       end
@@ -65,21 +66,21 @@ share_examples_for 'A semipublic Property' do
     subject { property.load(value) }
 
     before do
-      property.should_receive(:typecast).with(value).and_return(value)
+      expect(property).to receive(:typecast).with(value).and_return(value)
     end
 
-    it { should eql(value) }
+    it { is_expected.to eql(value) }
   end
 
   describe "#typecast" do
     describe 'when value is nil' do
       it 'returns value unchanged' do
-        property.typecast(nil).should be(nil)
+        expect(property.typecast(nil)).to be(nil)
       end
 
       describe 'when value is a Ruby primitive' do
         it 'returns value unchanged' do
-          property.typecast(value).should == value
+          expect(property.typecast(value)).to eq(value)
         end
       end
     end
@@ -88,27 +89,27 @@ share_examples_for 'A semipublic Property' do
   describe '#valid?' do
     describe 'when provided a valid value' do
       it 'should return true' do
-        property.valid?(value).should be(true)
+        expect(property.valid?(value)).to be(true)
       end
     end
 
     describe 'when provide an invalid value' do
       it 'should return false' do
-        property.valid?(invalid_value).should be(false)
+        expect(property.valid?(invalid_value)).to be(false)
       end
     end
 
     describe 'when provide a nil value when required' do
       it 'should return false' do
         property = type.new(model, name, options.merge(:required => true))
-        property.valid?(nil).should be(false)
+        expect(property.valid?(nil)).to be(false)
       end
     end
 
     describe 'when provide a nil value when not required' do
       it 'should return false' do
         property = type.new(model, name, options.merge(:required => false))
-        property.valid?(nil).should be(true)
+        expect(property.valid?(nil)).to be(true)
       end
     end
   end
@@ -121,14 +122,14 @@ share_examples_for 'A semipublic Property' do
     shared_examples_for 'assert_valid_value on invalid value' do
       it 'should raise Ardm::Property::InvalidValueError' do
         expect { subject }.to(raise_error(Ardm::Property::InvalidValueError) do |error|
-          error.property.should == property
+          expect(error.property).to eq(property)
         end)
       end
     end
 
     describe 'when provided a valid value' do
       it 'should return true' do
-        subject.should be(true)
+        expect(subject).to be(true)
       end
     end
 
@@ -152,7 +153,7 @@ share_examples_for 'A semipublic Property' do
       let(:value) { nil }
 
       it 'should return true' do
-        subject.should be(true)
+        expect(subject).to be(true)
       end
     end
   end

data/spec/spec_helper.rb

@@ -38,6 +38,23 @@ RSpec.configure do |config|
   config.after(:each) do
     DatabaseCleaner.clean
   end
+
+  def reset_raise_on_save_failure(object)
+    name = :raise_on_save_failure
+    ivar = "@#{name}"
+
+    if object.respond_to? :singleton_class
+      object.singleton_class.class_eval do
+        remove_possible_method(name)
+      end
+    end
+
+    object.instance_eval do
+      if instance_variable_defined?(ivar)
+        remove_instance_variable(ivar)
+      end
+    end
+  end
 end
 
 DEPENDENCIES = {

data/spec/unit/bcrypt_hash_spec.rb

@@ -30,11 +30,11 @@ try_spec do
         end
 
         it 'returns instance of BCrypt::Password' do
-          @result.should be_an_instance_of(BCrypt::Password)
+          expect(@result).to be_an_instance_of(BCrypt::Password)
         end
 
         it 'returns a string that is 60 characters long' do
-          @result.size.should == 60
+          expect(@result.size).to eq(60)
         end
       end
 
@@ -45,7 +45,7 @@ try_spec do
         end
 
         it 'returns nil' do
-          @result.should be_nil
+          expect(@result).to be_nil
         end
       end
     end
@@ -58,11 +58,11 @@ try_spec do
         end
 
         it 'returns instance of BCrypt::Password' do
-          @result.should be_an_instance_of(BCrypt::Password)
+          expect(@result).to be_an_instance_of(BCrypt::Password)
         end
 
         it 'returns a string that matches original' do
-          @result.should == @clear_password
+          expect(@result).to eq(@clear_password)
         end
       end
 
@@ -73,7 +73,7 @@ try_spec do
         end
 
         it 'returns nil' do
-          @result.should be_nil
+          expect(@result).to be_nil
         end
       end
     end
@@ -86,11 +86,11 @@ try_spec do
         end
 
         it 'casts argument to BCrypt::Password' do
-          @result.should be_an_instance_of(BCrypt::Password)
+          expect(@result).to be_an_instance_of(BCrypt::Password)
         end
 
         it 'casts argument to value that matches input' do
-          @result.should == @input
+          expect(@result).to eq(@input)
         end
       end
 
@@ -101,11 +101,11 @@ try_spec do
         end
 
         it 'casts argument to BCrypt::Password' do
-          @result.should be_an_instance_of(BCrypt::Password)
+          expect(@result).to be_an_instance_of(BCrypt::Password)
         end
 
         it 'casts argument to value that matches input' do
-          @result.should == @input
+          expect(@result).to eq(@input)
         end
       end
 
@@ -116,11 +116,11 @@ try_spec do
         end
 
         it 'casts argument to BCrypt::Password' do
-          @result.should be_an_instance_of(BCrypt::Password)
+          expect(@result).to be_an_instance_of(BCrypt::Password)
         end
 
         it 'casts argument to value that matches input' do
-          @result.should == @input
+          expect(@result).to eq(@input)
         end
       end
 
@@ -131,11 +131,11 @@ try_spec do
         end
 
         it 'casts argument to BCrypt::Password' do
-          @result.should be_an_instance_of(BCrypt::Password)
+          expect(@result).to be_an_instance_of(BCrypt::Password)
         end
 
         it 'casts argument to value that matches input' do
-          @result.should == @input
+          expect(@result).to eq(@input)
         end
       end
 
@@ -146,7 +146,7 @@ try_spec do
         end
 
         it 'returns nil' do
-          @result.should be_nil
+          expect(@result).to be_nil
         end
       end
     end

data/spec/unit/csv_spec.rb

@@ -19,7 +19,7 @@ try_spec do
         end
 
         it 'parses the argument using CVS parser' do
-          @result.should == [ %w[ uno due tre ] ]
+          expect(@result).to eq([ %w[ uno due tre ] ])
         end
       end
 
@@ -30,7 +30,7 @@ try_spec do
         end
 
         it 'does not change the input' do
-          @result.should == @input
+          expect(@result).to eq(@input)
         end
       end
 
@@ -41,7 +41,7 @@ try_spec do
         end
 
         it 'returns nil' do
-          @result.should be_nil
+          expect(@result).to be_nil
         end
       end
 
@@ -52,7 +52,7 @@ try_spec do
         end
 
         it 'returns nil' do
-          @result.should be_nil
+          expect(@result).to be_nil
         end
       end
 
@@ -63,7 +63,7 @@ try_spec do
         end
 
         it 'returns nil' do
-          @result.should be_nil
+          expect(@result).to be_nil
         end
       end
 
@@ -74,7 +74,7 @@ try_spec do
         end
 
         it 'returns nil' do
-          @result.should be_nil
+          expect(@result).to be_nil
         end
       end
 
@@ -85,7 +85,7 @@ try_spec do
         end
 
         it 'returns input as is' do
-          @result.should eql(@input)
+          expect(@result).to eql(@input)
         end
       end
     end
@@ -98,7 +98,7 @@ try_spec do
         end
 
         it 'dumps value to comma separated string' do
-          @result.should == "uno,due,tre\nuno,dos,tres\n"
+          expect(@result).to eq("uno,due,tre\nuno,dos,tres\n")
         end
       end
 
@@ -109,7 +109,7 @@ try_spec do
         end
 
         it 'returns input as is' do
-          @result.should == @input
+          expect(@result).to eq(@input)
         end
       end
 
@@ -120,7 +120,7 @@ try_spec do
         end
 
         it 'returns nil' do
-          @result.should be_nil
+          expect(@result).to be_nil
         end
       end
 
@@ -131,7 +131,7 @@ try_spec do
         end
 
         it 'returns nil' do
-          @result.should be_nil
+          expect(@result).to be_nil
         end
       end
     end

data/spec/unit/dirty_minder_spec.rb

@@ -26,15 +26,13 @@ describe Ardm::Property::DirtyMinder,'set!' do
 
   shared_examples_for 'a non hooked value' do
     it 'should not extend value with hook' do
-      value.should_not be_kind_of(Ardm::Property::DirtyMinder::Hooker)
+      expect(object.get!(resource)).not_to be_kind_of(Ardm::Property::DirtyMinder::Hooker)
     end
   end
 
   shared_examples_for 'a hooked value' do
-    it 'should extend value with hook' do
-      pending "FIXME: This probably should pass" do
-        value.should be_kind_of(Ardm::Property::DirtyMinder::Hooker)
-      end
+    it 'should extend value with hook', pending: true do
+      expect(object.get!(resource)).to be_kind_of(Ardm::Property::DirtyMinder::Hooker)
     end
   end
 

data/spec/unit/enum_spec.rb

@@ -18,14 +18,14 @@ try_spec do
       end
 
       it 'should return the key of the value match from the flag map' do
-        @enum.dump(:first).should == 1
-        @enum.dump(:second).should == 2
-        @enum.dump(:third).should == 3
+        expect(@enum.dump(:first)).to eq(1)
+        expect(@enum.dump(:second)).to eq(2)
+        expect(@enum.dump(:third)).to eq(3)
       end
 
       describe 'when there is no match' do
         it 'should return nil' do
-          @enum.dump(:zero).should be_nil
+          expect(@enum.dump(:zero)).to be_nil
         end
       end
     end
@@ -36,14 +36,14 @@ try_spec do
       end
 
       it 'returns the value of the key match from the flag map' do
-        @enum.load(1).should == :uno
-        @enum.load(2).should == :dos
-        @enum.load(3).should == :tres
+        expect(@enum.load(1)).to eq(:uno)
+        expect(@enum.load(2)).to eq(:dos)
+        expect(@enum.load(3)).to eq(:tres)
       end
 
       describe 'when there is no key' do
         it 'returns nil' do
-          @enum.load(-1).should be_nil
+          expect(@enum.load(-1)).to be_nil
         end
       end
     end
@@ -56,19 +56,19 @@ try_spec do
 
         describe 'when given a symbol' do
           it 'uses Enum type' do
-            @enum.typecast(:uno).should == :uno
+            expect(@enum.typecast(:uno)).to eq(:uno)
           end
         end
 
         describe 'when given a string' do
           it 'uses Enum type' do
-            @enum.typecast('uno').should == :uno
+            expect(@enum.typecast('uno')).to eq(:uno)
           end
         end
 
         describe 'when given nil' do
           it 'returns nil' do
-            @enum.typecast( nil).should == nil
+            expect(@enum.typecast( nil)).to eq(nil)
           end
         end
       end
@@ -80,19 +80,19 @@ try_spec do
 
         describe 'when given an integer' do
           it 'uses Enum type' do
-            @enum.typecast(1).should == 1
+            expect(@enum.typecast(1)).to eq(1)
           end
         end
 
         describe 'when given a float' do
           it 'uses Enum type' do
-            @enum.typecast(1.1).should == 1
+            expect(@enum.typecast(1.1)).to eq(1)
           end
         end
 
         describe 'when given nil' do
           it 'returns nil' do
-            @enum.typecast( nil).should == nil
+            expect(@enum.typecast( nil)).to eq(nil)
           end
         end
       end
@@ -104,19 +104,19 @@ try_spec do
 
         describe 'when given a symbol' do
           it 'uses Enum type' do
-            @enum.typecast(:uno).should == 'uno'
+            expect(@enum.typecast(:uno)).to eq('uno')
           end
         end
 
         describe 'when given a string' do
           it 'uses Enum type' do
-            @enum.typecast('uno').should == 'uno'
+            expect(@enum.typecast('uno')).to eq('uno')
           end
         end
 
         describe 'when given nil' do
           it 'returns nil' do
-            @enum.typecast( nil).should == nil
+            expect(@enum.typecast( nil)).to eq(nil)
           end
         end
       end