active_type 0.4.4 → 0.4.5

data/spec/integration/sign_up_spec.rb

@@ -40,7 +40,7 @@ describe SignUpSpec::User do
     subject.email = "email"
     subject.password = "password"
 
-    subject.should be_valid
+    expect(subject).to be_valid
   end
 
 end
@@ -52,26 +52,26 @@ describe SignUpSpec::SignUp do
     subject.password = "password"
     subject.terms = true
 
-    subject.should_not be_valid
-    subject.errors['email'].should == ["can't be blank"]
+    expect(subject).not_to be_valid
+    expect(subject.errors['email']).to eq(["can't be blank"])
   end
 
   it 'is invalid without accepted terms' do
     subject.email = "email"
     subject.password = "password"
 
-    subject.should_not be_valid
-    subject.errors['terms'].should == ["must be accepted"]
+    expect(subject).not_to be_valid
+    expect(subject.errors['terms']).to eq(["must be accepted"])
   end
 
   context 'with invalid data' do
 
     it 'does not save' do
-      subject.save.should be_false
+      expect(subject.save).to be_falsey
     end
 
     it 'does not send an email' do
-      subject.should_not_receive :send_welcome_email
+      expect(subject).not_to receive :send_welcome_email
       subject.save
     end
 
@@ -87,11 +87,11 @@ describe SignUpSpec::SignUp do
 
     it 'does save' do
       subject.valid?
-      subject.save.should be_true
+      expect(subject.save).to eq(true)
     end
 
     it 'sends the email' do
-      subject.should_receive :send_welcome_email
+      expect(subject).to receive :send_welcome_email
 
       subject.save
     end

data/spec/shared_examples/accessors.rb

@@ -20,21 +20,21 @@ shared_examples_for "ActiveRecord-like accessors" do |attributes|
   it 'allows to read and write' do
     attributes.each do |key, value|
       subject.send("#{key}=", value)
-      subject.send(key).should == value
+      expect(subject.send(key)).to eq(value)
     end
   end
 
   it 'allows to read via []' do
     attributes.each do |key, value|
       subject.send("#{key}=", value)
-      subject[key].should == value
+      expect(subject[key]).to eq(value)
     end
   end
 
   it 'allows to write via []=' do
     attributes.each do |key, value|
       subject[key] = value
-      subject.send(key).should == value
+      expect(subject.send(key)).to eq(value)
     end
   end
 

data/spec/shared_examples/belongs_to.rb

@@ -5,13 +5,13 @@ shared_examples_for 'a belongs_to association' do |association, klass|
   it 'sets the id when assigning a record' do
     subject.send("#{association}=", record)
 
-    subject.send("#{association}_id").should == record.id
+    expect(subject.send("#{association}_id")).to eq(record.id)
   end
 
   it 'sets the record when assigning an id' do
     subject.send("#{association}_id=", record.id)
 
-    subject.send("#{association}").should == record
+    expect(subject.send("#{association}")).to eq(record)
   end
 
 end

data/spec/shared_examples/coercible_columns.rb

@@ -6,19 +6,19 @@ end
 shared_examples_for 'a coercible string column' do |column|
 
   it 'is nil by default' do
-    subject.send(column).should be_nil
+    expect(subject.send(column)).to be_nil
   end
 
   it 'leaves strings alone' do
     subject.send(:"#{column}=", "string")
 
-    subject.send(column).should == "string"
+    expect(subject.send(column)).to eq("string")
   end
 
   it 'does not convert blank' do
     subject.send(:"#{column}=", "")
 
-    subject.send(column).should == ""
+    expect(subject.send(column)).to eq("")
   end
 
 end
@@ -27,25 +27,25 @@ end
 shared_examples_for 'a coercible integer column' do |column|
 
   it 'is nil by default' do
-    subject.send(column).should be_nil
+    expect(subject.send(column)).to be_nil
   end
 
   it 'leaves integers alone' do
     subject.send(:"#{column}=", 10)
 
-    subject.send(column).should == 10
+    expect(subject.send(column)).to eq(10)
   end
 
   it 'converts strings to integers' do
     subject.send(:"#{column}=", "10")
 
-    subject.send(column).should == 10
+    expect(subject.send(column)).to eq(10)
   end
 
   it 'converts blank to nil' do
     subject.send(:"#{column}=", "")
 
-    subject.send(column).should be_nil
+    expect(subject.send(column)).to be_nil
   end
 
 end
@@ -54,26 +54,26 @@ end
 shared_examples_for 'a coercible date column' do |column|
 
   it 'is nil by default' do
-    subject.send(column).should be_nil
+    expect(subject.send(column)).to be_nil
   end
 
   it 'leaves dates alone' do
     date = Date.today
     subject.send(:"#{column}=", date)
 
-    subject.send(column).should == date
+    expect(subject.send(column)).to eq(date)
   end
 
   it 'converts strings to dates' do
     subject.send(:"#{column}=", "2010-10-01")
 
-    subject.send(column).should == Date.new(2010, 10, 1)
+    expect(subject.send(column)).to eq(Date.new(2010, 10, 1))
   end
 
   it 'converts blank to nil' do
     subject.send(:"#{column}=", "")
 
-    subject.send(column).should be_nil
+    expect(subject.send(column)).to be_nil
   end
 
 end
@@ -105,26 +105,26 @@ shared_examples_for 'a coercible time column' do |column|
     comparison.persisted_time = time
 
     result = subject.send(column)
-    result.should == comparison.persisted_time
-    result.zone.should == comparison.persisted_time.zone
+    expect(result).to eq(comparison.persisted_time)
+    expect(result.zone).to eq(comparison.persisted_time.zone)
   end
 
 
   it 'is nil by default' do
-    subject.send(column).should be_nil
+    expect(subject.send(column)).to be_nil
   end
 
   it 'leaves times alone' do
     time = Time.now
     subject.send(:"#{column}=", time)
 
-    subject.send(column).should == time
+    expect(subject.send(column)).to eq(time)
   end
 
   it 'converts strings to times' do
     subject.send(:"#{column}=", "2010-10-01 12:15")
 
-    subject.send(column).should == Time.local(2010, 10, 1, 12, 15)
+    expect(subject.send(column)).to eq(Time.local(2010, 10, 1, 12, 15))
   end
 
   it 'behaves consistently with ActiveRecord' do
@@ -161,68 +161,68 @@ end
 shared_examples_for 'a coercible boolean column' do |column|
 
   it 'is nil by default' do
-    subject.send(column).should be_nil
+    expect(subject.send(column)).to be_nil
   end
 
   it 'leaves booleans alone' do
     subject.send(:"#{column}=", true)
 
-    subject.send(column).should == true
+    expect(subject.send(column)).to eq(true)
   end
 
   it 'converts 1 to true' do
     subject.send(:"#{column}=", "1")
 
-    subject.send(column).should == true
+    expect(subject.send(column)).to eq(true)
   end
 
   it 'converts 0 to false' do
     subject.send(:"#{column}=", "0")
 
-    subject.send(column).should == false
+    expect(subject.send(column)).to eq(false)
   end
 
   it 'converts "" to nil' do
     subject.send(:"#{column}=", "")
 
-    subject.send(column).should be_nil
+    expect(subject.send(column)).to be_nil
   end
 
   it 'converts "true" to true' do
     subject.send(:"#{column}=", "true")
 
-    subject.send(column).should == true
+    expect(subject.send(column)).to eq(true)
   end
 
   it 'converts "false" to false' do
     subject.send(:"#{column}=", "false")
 
-    subject.send(column).should == false
+    expect(subject.send(column)).to eq(false)
   end
 
 end
 
 shared_examples_for 'an untyped column' do |column|
   it 'is nil by default' do
-    subject.send(column).should be_nil
+    expect(subject.send(column)).to be_nil
   end
 
   it 'leaves strings alone' do
     subject.send(:"#{column}=", "string")
 
-    subject.send(column).should == "string"
+    expect(subject.send(column)).to eq("string")
   end
 
   it 'leaves integers alone' do
     subject.send(:"#{column}=", 17)
 
-    subject.send(column).should == 17
+    expect(subject.send(column)).to eq(17)
   end
 
   it 'leaves objects alone' do
     object = Object.new
     subject.send(:"#{column}=", object)
 
-    subject.send(column).should == object
+    expect(subject.send(column)).to eq(object)
   end
 end

data/spec/shared_examples/constructor.rb

@@ -1,14 +1,14 @@
 shared_examples_for 'ActiveRecord-like constructors' do |attributes|
 
   it 'return a new record' do
-    subject.new.should be_new_record
+    expect(subject.new).to be_new_record
   end
 
   it 'assigns given attributes' do
     record = subject.new(attributes)
 
     attributes.each do |key, value|
-      record.send(key).should == value
+      expect(record.send(key)).to eq(value)
     end
   end
 

data/spec/shared_examples/defaults.rb

@@ -16,45 +16,45 @@ shared_examples_for "a class accepting attribute defaults" do |klass|
   end
 
   it 'can have static defaults' do
-    subject.static_string.should == "static string"
+    expect(subject.static_string).to eq("static string")
   end
 
   it 'can have dynamic defaults' do
-    subject.dynamic_string.should == "dynamic string"
+    expect(subject.dynamic_string).to eq("dynamic string")
   end
 
   it 'can have defaults refering to instance methods' do
-    subject.referential_string.should == "value"
+    expect(subject.referential_string).to eq("value")
   end
 
   it 'typecasts defaults' do
-    subject.number.should == 10
+    expect(subject.number).to eq(10)
   end
 
   it 'computes defaults lazily' do
-    subject.should_receive(:compute).and_return("computed")
-    subject.computed.should == "computed"
+    expect(subject).to receive(:compute).and_return("computed")
+    expect(subject.computed).to eq("computed")
   end
 
   it 'does not compute defaults more than once' do
-    subject.should_receive(:compute).exactly(:once).and_return(nil)
+    expect(subject).to receive(:compute).exactly(:once).and_return(nil)
     subject.computed
     subject.computed
   end
 
   it 'does not compute defaults when overriden' do
     subject.computed = 'not computed'
-    subject.computed.should == 'not computed'
+    expect(subject.computed).to eq('not computed')
   end
 
   it 'does not use defaults when overriden' do
     subject.static_string = "my string"
-    subject.static_string.should == "my string"
+    expect(subject.static_string).to eq("my string")
   end
 
   it 'does not use defaults when overriden with nil' do
     subject.static_string = nil
-    subject.static_string.should == nil
+    expect(subject.static_string).to eq(nil)
   end
 
 end

data/spec/shared_examples/dirty_tracking.rb

@@ -9,7 +9,7 @@ shared_examples_for "a class supporting dirty tracking for virtual attributes" d
   describe '#virtual_attribute_was' do
 
     it 'always returns nil, since there can be no previously saved value' do
-      subject.virtual_attribute_was.should be_nil
+      expect(subject.virtual_attribute_was).to be_nil
     end
 
   end
@@ -18,12 +18,12 @@ shared_examples_for "a class supporting dirty tracking for virtual attributes" d
 
     it 'returns true if the attribute is not nil' do
       subject.virtual_attribute = 'foo'
-      subject.virtual_attribute_changed?.should be_true
+      expect(subject.virtual_attribute_changed?).to eq(true)
     end
 
     it 'returns false if the attribute is nil' do
       subject.virtual_attribute = nil
-      subject.virtual_attribute_changed?.should be_false
+      expect(subject.virtual_attribute_changed?).to be_falsey
     end
 
   end
@@ -31,7 +31,7 @@ shared_examples_for "a class supporting dirty tracking for virtual attributes" d
   describe '#virtual_attribute_will_change!' do
 
     it 'is implemented for compatibility with ActiveModel::Dirty, but does nothing' do
-      subject.should respond_to(:virtual_attribute_will_change!)
+      expect(subject).to respond_to(:virtual_attribute_will_change!)
       expect { subject.virtual_attribute_will_change! }.to_not raise_error
     end
 

data/spec/shared_examples/dupable.rb

@@ -13,8 +13,8 @@ shared_examples_for "a class supporting dup for attributes" do |klass|
       duped = subject.dup
       duped.attribute = "bar"
 
-      subject.attribute.should == "foo"
-      duped.attribute.should == "bar"
+      expect(subject.attribute).to eq("foo")
+      expect(duped.attribute).to eq("bar")
     end
 
     it 'does a deep copy' do
@@ -22,8 +22,8 @@ shared_examples_for "a class supporting dup for attributes" do |klass|
       duped = subject.dup
       duped.attribute.merge!(:foo => "baz")
 
-      subject.attribute.should == { :foo => "bar" }
-      duped.attribute.should == { :foo => "baz" }
+      expect(subject.attribute).to eq({ :foo => "bar" })
+      expect(duped.attribute).to eq({ :foo => "baz" })
     end
 
   end

data/spec/shared_examples/mass_assignment.rb

@@ -4,7 +4,7 @@ shared_examples_for 'ActiveRecord-like mass assignment' do |attributes|
     subject.attributes = attributes
 
     attributes.each do |key, value|
-      subject.send(key).should == value
+      expect(subject.send(key)).to eq(value)
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_type
 version: !ruby/object:Gem::Version
-  version: 0.4.4
+  version: 0.4.5
 platform: ruby
 authors:
 - Tobias Kraze
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-18 00:00:00.000000000 Z
+date: 2016-02-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler