spec/hashme/property_spec.rb in hashme-0.1.2 vs spec/hashme/property_spec.rb in hashme-0.2.0

@@ -1,90 +1,88 @@
 require 'spec_helper'
 
 describe Hashme::Property do
 
+  subject do
+    described_class
+  end
+
   let :owner do
     double()
   end
 
-  let :klass do
-    Hashme::Property
-  end
-
   let :submodel do
     Class.new do
       include Hashme
       property :name, String
     end
   end
 
   describe "#initialize" do
-
     it "should copy name and type" do
-      prop = klass.new("name", String)
-      prop.name.should eql(:name)
-      prop.type.should eql(String)
-      prop.use_casted_array?.should be_false
+      prop = subject.new("name", String)
+      expect(prop.name).to eql(:name)
+      expect(prop.type).to eql(String)
+      expect(prop.array).to be_falsey
     end
 
     it "should convert Array to CastedArray type" do
-      prop = klass.new("names", [String])
-      prop.name.should eql(:names)
-      prop.type.should eql(String)
-      prop.use_casted_array?.should be_true
+      prop = subject.new("names", [String])
+      expect(prop.name).to eql(:names)
+      expect(prop.type).to eql(String)
+      expect(prop.array).to be_truthy
     end
 
     it "should accept a default option" do
-      prop = klass.new(:name, String, :default => "Freddo")
-      prop.default.should eql("Freddo")
+      prop = subject.new(:name, String, :default => "Freddo")
+      expect(prop.default).to eql("Freddo")
     end
-
   end
 
   describe "#to_s" do
     it "should use property's name" do
-      prop = klass.new(:name, String)
-      prop.to_s.should eql("name")
+      prop = subject.new(:name, String)
+      expect(prop.to_s).to eql("name")
     end
   end
 
   describe "#to_sym" do
     it "should return the name" do
-      prop = klass.new(:name, String)
-      prop.to_sym.should eql (:name)
+      prop = subject.new(:name, String)
+      expect(prop.to_sym).to eql (:name)
     end
   end
 
-  describe "#cast" do
+  describe "#build" do
     context "without an array" do
       it "should build a new object" do
-        prop = klass.new(:date, Time)
-        obj = prop.cast(owner, "2013-06-02T12:00:00")
-        obj.class.should eql(Time)
-        obj.should eql(Time.new("2013-06-02T12:00:00"))
+        prop = subject.new(:date, Time)
+        obj = prop.build(owner, "2013-06-02T12:00:00Z")
+        expect(obj.class).to eql(Time)
+        expect(obj).to eql(Time.utc(2013, 6, 2, 12, 0, 0))
       end
 
       it "should assign casted by and property" do
-        prop = klass.new(:item, submodel)
-        obj = prop.cast(owner, {:name => 'test'})
-        obj.casted_by.should eql(owner)
-        obj.casted_by_property.should eql(prop)
+        prop = subject.new(:item, submodel)
+        obj = prop.build(owner, {:name => 'test'})
+        expect(obj.casted_by).to eql(owner)
+        expect(obj.casted_by_property).to eql(prop)
       end
     end
 
     context "with an array" do
       it "should convert regular array to casted array" do
-        prop = klass.new(:dates, [Time])
-        obj = prop.cast(owner, ["2013-06-02T12:00:00"])
-        obj.class.should eql(Hashme::CastedArray)
-        obj.first.class.should eql(Time)
+        prop = subject.new(:dates, [Time])
+        obj = prop.build(owner, ["2013-06-02T12:00:00"])
+        expect(obj.class).to eql(Hashme::CastedArray)
+        expect(obj.first.class).to eql(Time)
       end
       it "should handle complex objects" do
-        prop = klass.new(:items, [submodel])
-        obj = prop.cast(owner, [{:name => 'test'}])
-        obj.class.should eql(Hashme::CastedArray)
-        obj.first.class.should eql(submodel)
-        obj.first.name.should eql('test')
+        prop = subject.new(:items, [submodel])
+        obj = prop.build(owner, [{:name => 'test'}])
+        expect(obj.class).to eql(Hashme::CastedArray)
+        expect(obj.first.class).to eql(submodel)
+        expect(obj.first.name).to eql('test')
       end
     end
   end