simple_model 1.2.26 → 1.2.27

data/spec/base_spec.rb

@@ -0,0 +1,176 @@
+require 'spec_helper.rb'
+
+describe SimpleModel::Base do
+  # We need a clean class for each spec
+
+  around(:each) do |example|
+    class BaseTest < SimpleModel::Base; end
+
+    example.run
+
+    Object.send(:remove_const,:BaseTest) if defined?(:BaseTest)
+  end
+
+
+  context 'action methods' do
+    describe '#save' do
+      it "should perform the supplied methods" do
+        BaseTest.save :test
+        BaseTest.has_attribute :foo
+        BaseTest.send(:define_method, :test) do
+          self.foo = "test"
+          return true
+        end
+
+        base_test = BaseTest.new()
+
+        base_test.save
+        base_test.foo.should eql("test")
+      end
+
+      it "should be false if validation fails" do
+        BaseTest.save :test
+        BaseTest.has_attribute :foo
+        BaseTest.validates :foo, :presence => true
+        BaseTest.send(:define_method, :test) do
+          return true
+        end
+
+
+        base_test = BaseTest.new()
+        expect(base_test).to_not be_valid
+        expect(base_test.save).to eql(false)
+      end
+    end
+
+    describe '#save!' do
+      it "should perform the supplied methods" do
+        BaseTest.save :test
+        BaseTest.has_attribute :foo
+        BaseTest.send(:define_method, :test) do
+          self.foo = "test"
+          return true
+        end
+
+        base_test = BaseTest.new()
+
+        base_test.save!
+        base_test.foo.should eql("test")
+      end
+
+      it "should be false if validation fails" do
+        BaseTest.save :test
+        BaseTest.has_attribute :foo
+        BaseTest.validates :foo, :presence => true
+        BaseTest.send(:define_method, :test) do
+          return true
+        end
+
+
+        base_test = BaseTest.new()
+        expect(base_test).to_not be_valid
+        expect{base_test.save!}.to raise_error(SimpleModel::ValidationError)
+      end
+    end
+
+    describe '#destroy' do
+      it "should not preform validation by default" do
+        BaseTest.destroy :test
+        BaseTest.has_attribute :foo
+        BaseTest.validates :foo, :presence => true
+        BaseTest.send(:define_method, :test) do
+          return true
+        end
+
+        base_test = BaseTest.new()
+        expect(base_test.destroy).to eql(true)
+      end
+    end
+  end
+
+
+  context 'Callbacks' do
+    before(:each) do
+      class BaseTest < SimpleModel::Base
+        save :my_save_method
+        before_validation :set_foo
+        after_validation :set_bar
+        attr_accessor :foo,:bar
+        validates :foo, :presence => true
+
+
+        private
+
+        def my_save_method
+          true
+        end
+
+        def set_foo
+          self.foo = "foo"
+        end
+
+        def set_bar
+          self.bar = "bar"
+        end
+      end
+    end
+
+    let(:base_test) { BaseTest.new() }
+
+    it "should implement ActiveModel::Validations::Callbacks" do
+      base_test.valid?
+
+      expect(base_test.foo).to eql('foo')
+      expect(base_test.bar).to eql('bar')
+    end
+
+    it "should implement ActiveModel::Callbacks" do
+      base_test.save
+
+      expect(base_test.foo).to eql('foo')
+      expect(base_test.bar).to eql('bar')
+    end
+  end
+
+
+  context "regression tests" do
+    before(:each) do
+      class TestStuff < SimpleModel::Base
+        has_attribute :bar
+        validates_presence_of :bar
+      end
+
+      class NewTestStuff < TestStuff
+        has_boolean :foo
+      end
+
+      class OtherStuff < NewTestStuff
+        has_attribute :other
+        validates_numericality_of :other
+      end
+
+    end
+    it "should merge defined attributes when class are inherited" do
+      NewTestStuff.attribute_defined?(:bar).blank?.should eql(false)
+      NewTestStuff.attribute_defined?(:foo).blank?.should eql(false)
+    end
+    it "should merge defined attributes when class are inherited" do
+      TestStuff.new.respond_to?(:bar_will_change!).should eql(true)
+      t = OtherStuff.new
+      t.bar = [1,2,4]
+      NewTestStuff.new.respond_to?(:bar_will_change!).should eql(true)
+      NewTestStuff.new.respond_to?(:foo_will_change!).should eql(true)
+    end
+
+    it "should not throw exception method missing" do
+      o = OtherStuff.new
+      lambda { o.valid? }.should_not raise_error
+    end
+
+    after(:each) do
+      [:OtherStuff,:NewTestStuff].each do |con|
+        Object.send(:remove_const,con)
+      end
+    end
+  end
+end

data/spec/error_helpers_spec.rb

@@ -9,7 +9,7 @@ describe SimpleModel::ErrorHelpers do
       f = FooErrorClass.new
       f.errors.add(:foo, "something not great")
       f.errors.add(:bar, "doh")
-      lambda {f.errors_for_flash}.should_not raise_error
+      expect {f.errors_for_flash}.to_not raise_error
     end
   end
 end

data/spec/extend_core_spec.rb

@@ -4,32 +4,32 @@ describe SimpleModel::ExtendCore, 'Float.rb' do
     include SimpleModel::ExtendCore
   end
 
-  describe SimpleModel::ExtendCore, 'round' do
+  describe  '#round_to' do
     it "should return float rounded to specified precision" do
-      0.5122.round_to.should eql(1.0)
-      0.3333.round_to(1).should eql(0.3)
-      0.33335.round_to(2).should eql(0.33)
-      0.33335.round_to(4).should eql(0.3334)
+      expect(0.5122.round_to).to eql(1.0)
+      expect(0.3333.round_to(1)).to eql(0.3)
+      expect(0.33335.round_to(2)).to eql(0.33)
+      expect(0.33335.round_to(4)).to eql(0.3334)
     end
   end
 
-  describe SimpleModel::ExtendCore, 'to_currency_s' do
-    it "should return a string" do
-      0.333.to_currency_s.class.should eql(String)
-    end
+  describe '#to_currency_s' do
+    it { expect(0.333.to_currency_s).to be_a(String) }
+
     it "should prefix string with currency symbol" do
-      5.12.to_currency_s.include?("$").should eql(true)
+      expect(5.12.to_currency_s.include?("$")).to eql(true)
     end
-    it "should padd with zeros for cents" do
-      5.0.to_currency_s.should eql("$5.00")
+
+    it "should pad with zeros for cents" do
+      expect(5.0.to_currency_s).to eql("$5.00")
     end
     it "should round string to nearest tenth" do
-      0.333.to_currency_s.should eql("$0.33")
+      expect(0.333.to_currency_s).to eql("$0.33")
     end
     it "should add commas to long numbers" do
-      500000000000.0.to_currency_s.should eql("$500,000,000,000.00")
-      50000000000.0.to_currency_s.should eql("$50,000,000,000.00")
-      5000000000.0.to_currency_s.should eql("$5,000,000,000.00")
+      expect(500000000000.0.to_currency_s).to eql("$500,000,000,000.00")
+      expect(50000000000.0.to_currency_s).to eql("$50,000,000,000.00")
+      expect(5000000000.0.to_currency_s).to eql("$5,000,000,000.00")
     end
   end
 end
@@ -38,60 +38,61 @@ describe SimpleModel::ExtendCore, 'String.rb' do
   before(:all) do
     include SimpleModel::ExtendCore
   end
-  context '#safe_datetime_string' do
+  describe '#safe_datetime_string' do
     it "should set US formated datetime string to international" do
-      "12/31/2010".safe_datetime_string.should eql("2010-12-31")
-      "12/31/2010T23:31:59".safe_datetime_string.should eql("2010-12-31T23:31:59")
-      "12/31/2010 23:31:59".safe_datetime_string.should eql("2010-12-31 23:31:59")
+      expect("12/31/2010".safe_datetime_string).to eql("2010-12-31")
+      expect("12/31/2010T23:31:59".safe_datetime_string).to eql("2010-12-31T23:31:59")
+      expect("12/31/2010 23:31:59".safe_datetime_string).to eql("2010-12-31 23:31:59")
     end
   end
-  
-  context '#to_b' do
+
+  describe '#to_b' do
     it "should return a Boolean" do
-      "1".to_b.class.should eql(TrueClass)
-      "".to_b.class.should eql(FalseClass)
+      expect("1".to_b.class).to eql(TrueClass)
+      expect("".to_b.class).to eql(FalseClass)
     end
     it "should return true if string is '1' or 't' or 'true'"do
       ['1','t','true'].each do |s|
-        s.to_b.should eql(true)
+        expect(s.to_b).to eql(true)
       end
-    end  
+    end
   end
 
-  context '#to_date' do 
-    it "should handle US formatted date strings" do
-      lambda {"12/31/2010".to_date}.should_not raise_error
-      "12/31/2010".to_date.class.should eql(Date)
-      "12/31/2010".to_date.should eql(Date.parse("2010-12-31"))
-    end
-    it "should handle C# JSON datetime stamp" do
-      lambda {"\/Date(1310669017000)\/".to_date}.should_not raise_error
-      "\/Date(1310669017000)\/".to_date.should be_kind_of(Date)
-      "\/Date(1310669017000)\/".to_date.should eql(Date.parse("2011-07-14"))
+  describe '#to_date' do
+    context "US formatted date strings" do
+    it {expect {"12/31/2010".to_date}.to_not raise_error }
+    it {expect("12/31/2010".to_date).to be_a(Date)}
+    it {expect("12/31/2010".to_date).to eql(Date.parse("2010-12-31"))}
+  end
+    context "C# JSON datetime stamp" do
+      it { expect {"\/Date(1310669017000)\/".to_date}.to_not raise_error }
+      it { expect("\/Date(1310669017000)\/".to_date).to be_a(Date) }
+      it { expect("\/Date(1310669017000)\/".to_date).to eql(Date.parse("2011-07-14")) }
     end
   end
-  
-  context '#to_time' do
-    it "should handle US formatted date strings" do
-      lambda {"12/31/2010 12:00:00".to_time}.should_not raise_error
-      "12/31/2010 12:00:00".to_time.should be_kind_of(Time)
-      "12/31/2010 12:00:00".to_time.should eql(Time.parse("2010-12-31 12:00:00"))
+
+  describe '#to_time' do
+    context "US formatted date strings" do
+      it { expect {"12/31/2010 12:00:00".to_time}.to_not raise_error }
+      it { expect("12/31/2010 12:00:00".to_time).to be_kind_of(Time) }
+      it { expect("12/31/2010 12:00:00".to_time).to eql(Time.parse("2010-12-31 12:00:00")) }
     end
-    it "should handle C# JSON datetime stamp" do
-      lambda {"\/Date(1310669017000)\/".to_time}.should_not raise_error  
-      "\/Date(1310669017000)\/".to_time.should be_kind_of(Time)
+
+    context "C# JSON datetime stamp" do
+      it { expect {"\/Date(1310669017000)\/".to_time}.to_not raise_error }
+      it { expect("\/Date(1310669017000)\/".to_time).to be_kind_of(Time) }
     end
   end
-  
-  context '#to_f' do
-    it "return a Float from a string that may contain non-numeric values" do
-      "$5,000.006".to_f.should eql(5000.006)
+
+  describe '#to_f' do
+    context "contains non-numeric values" do
+      it { expect("$5,000.006".to_f).to eql(5000.006) }
     end
   end
-  
-  context '#to_currency' do
-    it "return a BigDecimal from a string that may contain non-numeric values" do
-      "$5,000.006".to_currency.should eql(BigDecimal("5000.006"))
+
+  describe '#to_currency' do
+    context "contains non-numeric values" do
+      it { expect("$5,000.006".to_currency).to eql(BigDecimal("5000.006")) }
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: simple_model
 version: !ruby/object:Gem::Version
-  version: 1.2.26
+  version: 1.2.27
 platform: ruby
 authors:
 - Joshua T Mckinney
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-15 00:00:00.000000000 Z
+date: 2014-12-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -125,9 +125,9 @@ files:
 - lib/simple_model/version.rb
 - simple_model.gemspec
 - spec/attributes_spec.rb
+- spec/base_spec.rb
 - spec/error_helpers_spec.rb
 - spec/extend_core_spec.rb
-- spec/simple_model_spec.rb
 - spec/spec_helper.rb
 homepage: ''
 licenses: []
@@ -154,7 +154,7 @@ specification_version: 4
 summary: Simpifies building tableless models or models backed by webservices
 test_files:
 - spec/attributes_spec.rb
+- spec/base_spec.rb
 - spec/error_helpers_spec.rb
 - spec/extend_core_spec.rb
-- spec/simple_model_spec.rb
 - spec/spec_helper.rb

data/spec/simple_model_spec.rb

@@ -1,247 +0,0 @@
-require 'spec_helper.rb'
-
-describe SimpleModel do 
-  context 'action methods' do
-    describe "save" do  
-      it "should perform the supplied methods" do
-        class TestStuff < SimpleModel::Base
-          save :test  
-          attr_accessor :foo
-        
-          def test
-            self.foo = "test"
-            return true
-          end
-        end
-      
-        t = TestStuff.new
-        t.save
-        t.foo.should eql("test")
-      end
-      
-      it "should be false if validation fails" do
-        class TestStuff < SimpleModel::Base
-          save :test
-          has_decimal :price
-          validates_inclusion_of :price, :in => 10..25
-          validates :price, :presence => true
-          
-        
-          def test
-            true
-          end
-        end
-      
-        t = TestStuff.new
-        t.save.should eql(false)
-      end
-    end
-  
-    describe "destroy" do
-      it "should not preform validation by default" do
-        class TestStuff < SimpleModel::Base
-          destroy :test
-          attr_accessor :foo
-          validates :foo, :presence => true
-          def test
-            return true
-          end
-        end
-      
-        t = TestStuff.new
-        t.destroy.should eql(true)
-      end
-    end
-    context "action methods that end with '!'" do
-      it 'should raise exception if validation fails' do
-        class TestStuff < SimpleModel::Base
-          save :my_save_method
-          has_attributes :foo
-      
-          def my_save_method
-            false
-          end
-        end
-    
-        t = TestStuff.new
-        lambda {t.save!}.should raise_error(SimpleModel::ActionError)
-      end
-      it 'should raise exception if validation fails' do
-        class TestStuff < SimpleModel::Base
-          save :my_save_method
-          has_attributes :foo
-          validate :validates_bar
-      
-          def my_save_method
-            self.errors.blank?
-          end
-      
-          def validates_bar
-            self.errors.add(:foo, "bar")
-          end
-        end
-    
-        t = TestStuff.new
-        lambda {t.save!}.should raise_error(SimpleModel::ValidationError)
-      end
-      
-    end
-  end
-  
-  
-  it 'Should add a boolean setter' do
-    class TestStuff < SimpleModel::Base
-      has_booleans :test_boolean
-    end
-    TestStuff.new.methods.include?(:test_boolean).should eql(true)
-    #a.test.should eql(false)
-  end
-  it 'Should add a boolean setter' do
-    class TestStuff < SimpleModel::Base
-      has_booleans :test_boolean
-    end
-    t =  TestStuff.new
-    t.methods.include?(:test_boolean).should eql(true)
-    t.test_boolean = true
-    t.test_boolean.should eql(true)
-    #a.test.should eql(false)
-  end
-  it 'Should add a error setter' do
-
-    class TestStuff < SimpleModel::Base
-      has_attributes :test_attr
-    end
-    a = TestStuff.new
-
-    a.errors.add(:test_attr, "test")
-    a.errors?.should eql(true)
-  end
-  
-  it 'Should include validation callbacks' do
-    class TestStuff < SimpleModel::Base
-    end
-    TestStuff.respond_to?(:before_validation).should eql(true)
-    TestStuff.respond_to?(:after_save).should eql(true)
-    
-  end
-  
-  it 'Should perform validation callbacks' do
-    class TestStuff < SimpleModel::Base
-      before_validation :set_foo   
-      after_validation :set_bar
-      attr_accessor :foo,:bar
-      validates :foo, :presence => true
-     
-         
-      private
-      def set_foo
-        self.foo = "foo"
-      end
-      
-      def set_bar
-        self.bar = "bar"
-      end
-    end
-    
-    t = TestStuff.new
-    t.valid?
-    t.foo.should eql('foo') 
-    t.bar.should eql('bar')
-  end
-  
-  it "should run save and validation callbacks on save" do
-    class TestStuff < SimpleModel::Base
-      save :my_save_method
-      before_save :set_foo   
-      after_validation :set_bar
-      attr_accessor :foo,:bar
-      validates :foo, :presence => true
-     
-      
-      private
-      
-      def my_save_method
-        true
-      end
-      
-      def set_foo
-        self.foo = "foo"
-      end
-      
-      def set_bar
-        self.bar = "bar"
-      end
-    end
-    
-    t = TestStuff.new
-    t.save
-    t.foo.should eql('foo') 
-    t.bar.should eql('bar')
-  end
-  
-  it 'Should implement ActiveModel::Dirty' do
-    class TestStuff < SimpleModel::Base
-      save :my_save_method
-      has_attributes :foo,:bar, :default => "def"
-      has_boolean :boo,:bad, :default => true
-      def my_save_method
-        true
-      end
-    end
-    
-    t = TestStuff.new
-    t.foo = "bar"
-    t.foo_changed?.should eql(true)
-    t.respond_to?(:foo_will_change!).should eql(true)
-    t.respond_to?(:boo_will_change!).should eql(true)
-    t.foo_change.should eql(["def","bar"])
-    t.changed?.should eql(true)
-    t.save
-    t.changed?.should eql(false)
-  end 
-  
-  context "regression tests" do
-    before(:each) do
-      class TestStuff < SimpleModel::Base
-        has_attribute :bar
-        validates_presence_of :bar
-      end
-      
-      class NewTestStuff < TestStuff
-        has_boolean :foo
-      end
-      
-      class OtherStuff < NewTestStuff
-        has_attribute :other
-        validates_numericality_of :other
-      end
-           
-    end
-    it "should merge defined attributes when class are inherited" do
-      NewTestStuff.attribute_defined?(:bar).blank?.should eql(false)
-      NewTestStuff.attribute_defined?(:foo).blank?.should eql(false)
-    end
-    it "should merge defined attributes when class are inherited" do
-      TestStuff.new.respond_to?(:bar_will_change!).should eql(true)
-      t = OtherStuff.new
-      t.bar = [1,2,4]
-      NewTestStuff.new.respond_to?(:bar_will_change!).should eql(true)
-      NewTestStuff.new.respond_to?(:foo_will_change!).should eql(true)
-    end
-    
-    it "should not throw exception method missing" do
-      o = OtherStuff.new
-      lambda { o.valid? }.should_not raise_error
-    end
-    
-    after(:each) do
-      [:OtherStuff,:NewTestStuff].each do |con|
-        Object.send(:remove_const,con)
-      end
-    end
-  end
-  
-  after(:each) do
-    Object.send(:remove_const,:TestStuff)
-  end
-end