active_type 0.4.4 → 0.4.5

data/spec/active_type/object_spec.rb

@@ -13,6 +13,9 @@ module ObjectSpec
 
   end
 
+  class PlainObject < ActiveType::Object
+  end
+
 
   class ObjectWithValidations < Object
 
@@ -124,7 +127,7 @@ describe ActiveType::Object do
     it 'is possible to override attributes with super' do
       subject.overridable_test = "test"
 
-      subject.overridable_test.should == "testtest"
+      expect(subject.overridable_test).to eq("testtest")
     end
   end
 
@@ -170,31 +173,31 @@ describe ActiveType::Object do
     it 'returns true for true' do
       subject.virtual_attribute = true
 
-      subject.virtual_attribute?.should == true
+      expect(subject.virtual_attribute?).to eq(true)
     end
 
     it 'returns false for false' do
       subject.virtual_attribute = false
 
-      subject.virtual_attribute?.should == false
+      expect(subject.virtual_attribute?).to eq(false)
     end
 
     it 'returns false for nil' do
       subject.virtual_attribute = nil
 
-      subject.virtual_attribute?.should == false
+      expect(subject.virtual_attribute?).to eq(false)
     end
 
     it 'returns true for 1' do
       subject.virtual_attribute = 1
 
-      subject.virtual_attribute?.should == true
+      expect(subject.virtual_attribute?).to eq(true)
     end
 
     it 'returns true for an object' do
       subject.virtual_attribute = Object.new
 
-      subject.virtual_attribute?.should == true
+      expect(subject.virtual_attribute?).to eq(true)
     end
 
   end
@@ -205,14 +208,14 @@ describe ActiveType::Object do
       subject.virtual_string = "string"
       subject.virtual_integer = "17"
 
-      subject.attributes.should == {
+      expect(subject.attributes).to eq({
         "virtual_string" => "string",
         "virtual_integer" => 17,
         "virtual_time" => nil,
         "virtual_date" => nil,
         "virtual_boolean" => nil,
         "virtual_attribute" => nil,
-      }
+      })
     end
 
     it 'also includes inherited attributes' do
@@ -220,7 +223,7 @@ describe ActiveType::Object do
       object.virtual_string = "string"
       object.virtual_integer = "17"
 
-      object.attributes.should == {
+      expect(object.attributes).to eq({
         "virtual_string" => "string",
         "virtual_integer" => 17,
         "virtual_time" => nil,
@@ -228,7 +231,7 @@ describe ActiveType::Object do
         "virtual_boolean" => nil,
         "virtual_attribute" => nil,
         "another_virtual_string" => nil,
-      }
+      })
     end
 
     it 'also includes included attributes' do
@@ -236,7 +239,7 @@ describe ActiveType::Object do
       object.virtual_string = "string"
       object.virtual_integer = "17"
 
-      object.attributes.should == {
+      expect(object.attributes).to eq({
         "virtual_string" => "string",
         "virtual_integer" => 17,
         "virtual_time" => nil,
@@ -244,7 +247,7 @@ describe ActiveType::Object do
         "virtual_boolean" => nil,
         "virtual_attribute" => nil,
         "another_virtual_string" => nil,
-      }
+      })
     end
 
   end
@@ -256,13 +259,13 @@ describe ActiveType::Object do
       object.virtual_string = "string"
       object.another_virtual_string = "another string"
 
-      object.virtual_string.should == "string"
-      object.another_virtual_string.should == "another string"
+      expect(object.virtual_string).to eq("string")
+      expect(object.another_virtual_string).to eq("another string")
     end
 
     it 'does not define the attribute on the parent class' do
       object = ObjectSpec::Object.new
-      object.should_not respond_to(:another_virtual_string)
+      expect(object).not_to respond_to(:another_virtual_string)
     end
 
   end
@@ -273,41 +276,43 @@ describe ActiveType::Object do
       object.virtual_string = "string"
       object.another_virtual_string = "another string"
 
-      object.virtual_string.should == "string"
-      object.another_virtual_string.should == "another string"
+      expect(object.virtual_string).to eq("string")
+      expect(object.another_virtual_string).to eq("another string")
     end
 
     it 'does not define the attribute on the parent class' do
       object = ObjectSpec::Object.new
-      object.should_not respond_to(:another_virtual_string)
+      expect(object).not_to respond_to(:another_virtual_string)
     end
   end
 
   describe 'validations' do
     subject { ObjectSpec::ObjectWithValidations.new }
 
-    it { should have(1).error_on(:virtual_string) }
+    it 'has 1 error_on' do
+      expect(subject.error_on(:virtual_string).size).to eq(1)
+    end
     
     it 'validates the presence of boolean values' do
       subject.virtual_boolean = false
-      subject.should have(1).error_on(:virtual_boolean)
+      expect(subject.error_on(:virtual_boolean).size).to eq(1)
       subject.virtual_boolean = '0'
-      subject.should have(1).error_on(:virtual_boolean)
+      expect(subject.error_on(:virtual_boolean).size).to eq(1)
       subject.virtual_boolean = 0
-      subject.should have(1).error_on(:virtual_boolean)
+      expect(subject.error_on(:virtual_boolean).size).to eq(1)
       subject.virtual_boolean = true
-      subject.should have(0).errors_on(:virtual_boolean)
+      expect(subject.errors_on(:virtual_boolean).size).to eq(0)
     end
 
     it 'has no errors if validations pass' do
       subject.virtual_string = "foo"
       subject.virtual_boolean = true
-      subject.should be_valid
-      subject.should have(:no).errors_on(:virtual_string)
+      expect(subject).to be_valid
+      expect(subject.errors_on(:virtual_string).size).to eq(0)
     end
 
     it 'causes #save to return false' do
-      subject.save.should be_false
+      expect(subject.save).to be_falsey
     end
   end
 
@@ -317,6 +322,12 @@ describe ActiveType::Object do
 
   describe 'duping' do
     it_should_behave_like "a class supporting dup for attributes", ActiveType::Object
+
+    it 'can dup without attributes' do
+      expect {
+        ObjectSpec::PlainObject.new.dup
+      }.not_to raise_error
+    end
   end
 
   describe 'dirty tracking' do
@@ -339,9 +350,9 @@ describe ActiveType::Object do
     %w[before_validation before_save after_save after_commit].each do |callback|
 
       it "calls #{callback}", :rollback => false do
-        subject.should_receive("#{callback}_callback")
+        expect(subject).to receive("#{callback}_callback")
 
-        subject.save.should be_true
+        expect(subject.save).to eq(true)
       end
 
     end
@@ -349,9 +360,9 @@ describe ActiveType::Object do
     %w[before_validation before_save].each do |callback|
 
       it "aborts the chain when #{callback} returns false" do
-        subject.stub("#{callback}_callback" => false)
+        allow(subject).to receive_messages("#{callback}_callback" => false)
 
-        subject.save.should be_false
+        expect(subject.save).to be_falsey
       end
 
     end
@@ -373,7 +384,7 @@ describe ActiveType::Object do
 
   describe '.all' do
     it 'returns []' do
-      ObjectSpec::Object.all.should == []
+      expect(ObjectSpec::Object.all).to eq([])
     end
   end
 
@@ -381,8 +392,8 @@ describe ActiveType::Object do
     it 'returns an object' do
       object = ObjectSpec::Object.create(:virtual_string => "string")
 
-      object.should be_a(ObjectSpec::Object)
-      object.virtual_string.should == "string"
+      expect(object).to be_a(ObjectSpec::Object)
+      expect(object.virtual_string).to eq("string")
     end
   end
 

data/spec/active_type/record_spec.rb

@@ -59,11 +59,11 @@ describe ActiveType::Record do
   subject { RecordSpec::Record.new }
 
   it 'is a ActiveRecord::Base' do
-    subject.should be_a(ActiveRecord::Base)
+    expect(subject).to be_a(ActiveRecord::Base)
   end
 
   it 'is an abstract class' do
-    ActiveType::Record.should be_abstract_class
+    expect(ActiveType::Record).to be_abstract_class
   end
 
   describe 'constructors' do
@@ -94,7 +94,7 @@ describe ActiveType::Record do
     it 'is possible to override attributes with super' do
       subject.overridable_test = "test"
 
-      subject.overridable_test.should == "testtest"
+      expect(subject.overridable_test).to eq("testtest")
     end
   end
 
@@ -158,7 +158,7 @@ describe ActiveType::Record do
       subject.virtual_string = "string"
       subject.virtual_integer = "17"
 
-      subject.attributes.should == {
+      expect(subject.attributes).to eq({
         "virtual_string" => "string",
         "virtual_integer" => 17,
         "virtual_time" => nil,
@@ -171,7 +171,7 @@ describe ActiveType::Record do
         "persisted_time" => nil,
         "persisted_date" => nil,
         "persisted_boolean" => nil
-      }
+      })
     end
 
   end
@@ -179,8 +179,12 @@ describe ActiveType::Record do
   describe 'validations' do
     subject { RecordSpec::RecordWithValidations.new }
 
-    it { should have(1).error_on(:persisted_string) }
-    it { should have(1).error_on(:virtual_string) }
+    it 'has 1 error_on' do
+      expect(subject.error_on(:persisted_string).size).to eq(1)
+    end
+    it 'has 1 error_on' do
+      expect(subject.error_on(:virtual_string).size).to eq(1)
+    end
   end
 
   describe 'undefined columns' do
@@ -207,9 +211,9 @@ describe ActiveType::Record do
 
     it 'persists to the database' do
       subject.persisted_string = "persisted string"
-      subject.save.should be_true
+      expect(subject.save).to eq(true)
 
-      subject.class.find(subject.id).persisted_string.should == "persisted string"
+      expect(subject.class.find(subject.id).persisted_string).to eq("persisted string")
     end
   end
 
@@ -218,8 +222,8 @@ describe ActiveType::Record do
       record = RecordSpec::Record.new
       other_record = RecordSpec::OtherRecord.new
 
-      record.should_not respond_to(:other_string)
-      other_record.should_not respond_to(:persisted_string)
+      expect(record).not_to respond_to(:other_string)
+      expect(other_record).not_to respond_to(:persisted_string)
     end
   end
 

data/spec/active_type/util_spec.rb

@@ -42,10 +42,10 @@ describe ActiveType::Util do
         record = UtilSpec::BaseRecord.create!(:persisted_string => 'foo')
         base_scope = UtilSpec::BaseRecord.where(:persisted_string => 'foo')
         casted_scope = ActiveType::Util.cast(base_scope, UtilSpec::ExtendedRecord)
-        casted_scope.build.should be_a(UtilSpec::ExtendedRecord)
+        expect(casted_scope.build).to be_a(UtilSpec::ExtendedRecord)
         found_record = casted_scope.find(record.id)
-        found_record.persisted_string.should == 'foo'
-        found_record.should be_a(UtilSpec::ExtendedRecord)
+        expect(found_record.persisted_string).to eq('foo')
+        expect(found_record).to be_a(UtilSpec::ExtendedRecord)
       end
 
       it 'preserves existing scope conditions' do
@@ -54,7 +54,7 @@ describe ActiveType::Util do
         base_scope = UtilSpec::BaseRecord.where(:persisted_string => 'foo')
         casted_scope = ActiveType::Util.cast(base_scope, UtilSpec::ExtendedRecord)
         casted_match = UtilSpec::ExtendedRecord.find(match.id)
-        casted_scope.to_a.should == [casted_match]
+        expect(casted_scope.to_a).to eq([casted_match])
       end
 
     end
@@ -64,57 +64,57 @@ describe ActiveType::Util do
       it 'casts a base record to an extended record' do
         base_record = UtilSpec::BaseRecord.create!(:persisted_string => 'foo')
         extended_record = ActiveType::Util.cast(base_record, UtilSpec::ExtendedRecord)
-        extended_record.should be_a(UtilSpec::ExtendedRecord)
-        extended_record.should be_persisted
-        extended_record.id.should be_present
-        extended_record.id.should == base_record.id
-        extended_record.persisted_string.should == 'foo'
+        expect(extended_record).to be_a(UtilSpec::ExtendedRecord)
+        expect(extended_record).to be_persisted
+        expect(extended_record.id).to be_present
+        expect(extended_record.id).to eq(base_record.id)
+        expect(extended_record.persisted_string).to eq('foo')
       end
 
       it 'casts an extended record to a base record' do
         extended_record = UtilSpec::ExtendedRecord.create!(:persisted_string => 'foo')
         base_record = ActiveType::Util.cast(extended_record, UtilSpec::BaseRecord)
-        base_record.should be_a(UtilSpec::BaseRecord)
-        base_record.should be_persisted
-        base_record.id.should be_present
-        base_record.id.should == extended_record.id
-        base_record.persisted_string.should == 'foo'
+        expect(base_record).to be_a(UtilSpec::BaseRecord)
+        expect(base_record).to be_persisted
+        expect(base_record.id).to be_present
+        expect(base_record.id).to eq(extended_record.id)
+        expect(base_record.persisted_string).to eq('foo')
       end
 
       it 'calls after_initialize callbacks of the cast target' do
         base_record = UtilSpec::BaseRecord.create!(:persisted_string => 'foo')
         extended_record = ActiveType::Util.cast(base_record, UtilSpec::ExtendedRecord)
-        extended_record.virtual_string.should be_present
+        expect(extended_record.virtual_string).to be_present
       end
 
       it 'lets after_initialize callbacks access attributes (bug in ActiveRecord#becomes)' do
         base_record = UtilSpec::BaseRecord.create!(:persisted_string => 'foo')
         extended_record = ActiveType::Util.cast(base_record, UtilSpec::ExtendedRecord)
-        extended_record.virtual_string.should == 'persisted_string is foo'
+        expect(extended_record.virtual_string).to eq('persisted_string is foo')
       end
 
       it 'preserves the #type of an STI record that is casted to an ExtendedRecord' do
         child_record = UtilSpec::Child.create!(:persisted_string => 'foo')
         extended_child_record = ActiveType::Util.cast(child_record, UtilSpec::ExtendedChild)
-        extended_child_record.should be_a(UtilSpec::ExtendedChild)
-        extended_child_record.type.should == 'UtilSpec::Child'
+        expect(extended_child_record).to be_a(UtilSpec::ExtendedChild)
+        expect(extended_child_record.type).to eq('UtilSpec::Child')
       end
 
       it 'changes the #type of an STI record when casted to another type in the hierarchy' do
         child_record = UtilSpec::Child.create!(:persisted_string => 'foo')
         child_sibling_record = ActiveType::Util.cast(child_record, UtilSpec::ChildSibling)
-        child_sibling_record.should be_a(UtilSpec::ChildSibling)
-        child_sibling_record.type.should == 'UtilSpec::Child'
+        expect(child_sibling_record).to be_a(UtilSpec::ChildSibling)
+        expect(child_sibling_record.type).to eq('UtilSpec::Child')
       end
 
       it 'preserves dirty tracking flags' do
         base_record = UtilSpec::BaseRecord.create!(:persisted_string => 'foo')
-        base_record.changes.should == {}
+        expect(base_record.changes).to eq({})
         base_record.persisted_string = 'bar'
-        base_record.changes.should == { 'persisted_string' => ['foo', 'bar'] }
+        expect(base_record.changes).to eq({ 'persisted_string' => ['foo', 'bar'] })
         extended_record = ActiveType::Util.cast(base_record, UtilSpec::ExtendedRecord)
-        extended_record.should be_a(UtilSpec::ExtendedRecord)
-        extended_record.changes.should == { 'persisted_string' => ['foo', 'bar'] }
+        expect(extended_record).to be_a(UtilSpec::ExtendedRecord)
+        expect(extended_record.changes).to eq({ 'persisted_string' => ['foo', 'bar'] })
       end
 
     end
@@ -122,7 +122,7 @@ describe ActiveType::Util do
   end
 
   it "exposes all methods through ActiveType's root namespace" do
-    ActiveType.should respond_to(:cast)
+    expect(ActiveType).to respond_to(:cast)
   end
 
 end

data/spec/integration/holidays_spec.rb

@@ -51,15 +51,15 @@ describe HolidaySpec::HolidayForm do
   it 'will return holidays including updated ones' do
     HolidaySpec::Holiday.create!(:name => 'New Year', :date => '2014-01-01')
     form = HolidaySpec::HolidayForm.new(:holidays_attributes => params.slice('2'))
-    form.holidays.collect(&:name).should == ["New Year", "Epiphany"]
+    expect(form.holidays.collect(&:name)).to eq(["New Year", "Epiphany"])
   end
 
   it 'can create a list of holidays' do
-    update(params).should be_true
+    expect(update(params)).to eq(true)
 
     holidays = HolidaySpec::Holiday.order(:date)
-    holidays.collect(&:name).should == ["New Year", "Epiphany"]
-    holidays.collect(&:date).should == [Date.civil(2014, 1, 1), Date.civil(2014, 1, 6)]
+    expect(holidays.collect(&:name)).to eq(["New Year", "Epiphany"])
+    expect(holidays.collect(&:date)).to eq([Date.civil(2014, 1, 1), Date.civil(2014, 1, 6)])
   end
 
   it 'can update holidays' do
@@ -67,22 +67,22 @@ describe HolidaySpec::HolidayForm do
 
     params['1']['name'] += ' 2014'
     params['2']['name'] += ' 2014'
-    update(params).should be_true
+    expect(update(params)).to eq(true)
 
     holidays = HolidaySpec::Holiday.order(:date)
-    holidays.collect(&:name).should == ["New Year 2014", "Epiphany 2014"]
-    holidays.collect(&:date).should == [Date.civil(2014, 1, 1), Date.civil(2014, 1, 6)]
+    expect(holidays.collect(&:name)).to eq(["New Year 2014", "Epiphany 2014"])
+    expect(holidays.collect(&:date)).to eq([Date.civil(2014, 1, 1), Date.civil(2014, 1, 6)])
   end
 
   it 'can destroy holidays' do
     update(params)
 
     params['1']['_destroy'] = '1'
-    update(params).should be_true
+    expect(update(params)).to eq(true)
 
     holidays = HolidaySpec::Holiday.order(:date)
-    holidays.collect(&:name).should == ["Epiphany"]
-    holidays.collect(&:date).should == [Date.civil(2014, 1, 6)]
+    expect(holidays.collect(&:name)).to eq(["Epiphany"])
+    expect(holidays.collect(&:date)).to eq([Date.civil(2014, 1, 6)])
   end
 
   it 'will not save if some fields are invalid' do
@@ -91,11 +91,11 @@ describe HolidaySpec::HolidayForm do
     params['1']['name'] = '-'
     params['1']['_destroy'] = '1'
     params['2']['name'] = ''  # invalid
-    update(params).should be_false
+    expect(update(params)).to be_falsey
 
     holidays = HolidaySpec::Holiday.order(:date)
-    holidays.collect(&:name).should == ["New Year", "Epiphany"]
-    holidays.collect(&:date).should == [Date.civil(2014, 1, 1), Date.civil(2014, 1, 6)]
+    expect(holidays.collect(&:name)).to eq(["New Year", "Epiphany"])
+    expect(holidays.collect(&:date)).to eq([Date.civil(2014, 1, 1), Date.civil(2014, 1, 6)])
   end
 
 

data/spec/integration/shape_spec.rb

@@ -55,9 +55,7 @@ describe ShapeSpec::ShapeForm do
   def update(params)
     form.child_type = params[:type]
     form.child_attributes = params.except(:type)
-    if form.save
-      params['id'] = form.child.id
-    end
+    form.save
   end
 
   it 'can create a circle' do
@@ -66,10 +64,10 @@ describe ShapeSpec::ShapeForm do
       'radius' => '20'
     }.with_indifferent_access
 
-    update(params).should be_true
+    expect(update(params)).to eq(true)
 
-    ShapeSpec::Circle.all.collect(&:radius).should == [20]
-    ShapeSpec::Rectangle.count.should == 0
+    expect(ShapeSpec::Circle.all.collect(&:radius)).to eq([20])
+    expect(ShapeSpec::Rectangle.count).to eq(0)
   end
 
   it 'can create a rectangle' do
@@ -79,11 +77,11 @@ describe ShapeSpec::ShapeForm do
       'width' => '30'
     }.with_indifferent_access
 
-    update(params).should be_true
+    expect(update(params)).to eq(true)
 
-    ShapeSpec::Circle.count.should == 0
-    ShapeSpec::Rectangle.all.collect(&:length).should == [100]
-    ShapeSpec::Rectangle.all.collect(&:width).should == [30]
+    expect(ShapeSpec::Circle.count).to eq(0)
+    expect(ShapeSpec::Rectangle.all.collect(&:length)).to eq([100])
+    expect(ShapeSpec::Rectangle.all.collect(&:width)).to eq([30])
   end
 
   it 'can update' do
@@ -94,9 +92,9 @@ describe ShapeSpec::ShapeForm do
     update(params)
 
     params['radius'] = '30'
-    update(params).should be_true
+    expect(update(params)).to eq(true)
 
-    ShapeSpec::Circle.all.collect(&:radius).should == [30]
+    expect(ShapeSpec::Circle.all.collect(&:radius)).to eq([30])
   end
 
   it 'has validations' do
@@ -104,9 +102,9 @@ describe ShapeSpec::ShapeForm do
       'type' => 'circle'
     }.with_indifferent_access
 
-    update(params).should be_false
+    expect(update(params)).to be_falsey
 
-    form.child.errors['radius'].should == ["can't be blank"]
+    expect(form.child.errors['radius']).to eq(["can't be blank"])
   end
 
 end

data/spec/integration/sign_in_spec.rb

@@ -29,21 +29,21 @@ describe SignInSpec::SignIn do
   describe 'with missing credentials' do
 
     it 'is invalid' do
-      subject.should_not be_valid
+      expect(subject).not_to be_valid
     end
 
     it 'has errors' do
       subject.valid?
-      subject.errors[:email].should == ["can't be blank"]
-      subject.errors[:password].should == ["can't be blank"]
+      expect(subject.errors[:email]).to eq(["can't be blank"])
+      expect(subject.errors[:password]).to eq(["can't be blank"])
     end
 
     it 'does not save' do
-      subject.save.should be_false
+      expect(subject.save).to be_falsey
     end
 
     it 'does not set the session' do
-      subject.should_not_receive :set_session
+      expect(subject).not_to receive :set_session
       subject.save
     end
 
@@ -57,20 +57,20 @@ describe SignInSpec::SignIn do
     end
 
     it 'is invalid' do
-      subject.should_not be_valid
+      expect(subject).not_to be_valid
     end
 
     it 'has errors' do
       subject.valid?
-      subject.errors[:password].should == ["is not correct"]
+      expect(subject.errors[:password]).to eq(["is not correct"])
     end
 
     it 'does not save' do
-      subject.save.should be_false
+      expect(subject.save).to be_falsey
     end
 
     it 'does not set the session' do
-      subject.should_not_receive :set_session
+      expect(subject).not_to receive :set_session
       subject.save
     end
 
@@ -84,15 +84,15 @@ describe SignInSpec::SignIn do
     end
 
     it 'is invalid' do
-      subject.should be_valid
+      expect(subject).to be_valid
     end
 
     it 'does save' do
-      subject.save.should be_true
+      expect(subject.save).to eq(true)
     end
 
     it 'sets the session' do
-      subject.should_receive :set_session
+      expect(subject).to receive :set_session
       subject.save
     end