opium 1.0.0.beta

data/spec/opium/extensions/geo_point_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe GeoPoint do
+  subject { GeoPoint }
+  
+  it { should respond_to(:to_ruby, :to_parse).with(1).argument }
+  
+  it ":to_ruby(object) should create a GeoPoint" do
+    [ "33.33, -117.117", {latitude: 33.33, longitude: -117.117}, [33.33, -117.117], GeoPoint.new( [33.33, -117.117] ) ].each do |value|
+      result = subject.to_ruby( value )
+      result.should be_a_kind_of(GeoPoint)
+      result.latitude.should == 33.33
+      result.longitude.should == -117.117
+    end
+  end
+  
+  it ":to_ruby(bad_data) should raise exception" do
+    [ "malformed", {latitude: 0, bad_key: :unknown}, [0], 1, 1.0, true, false ].each do |value|
+      expect { subject.to_ruby( value ) }.to raise_exception
+    end
+  end
+  
+  it ":to_parse(object) should ensure a geo_point and make into parse object" do
+    [ "33.33, -117.117", {latitude: 33.33, longitude: -117.117}, [33.33, -117.117], GeoPoint.new( [33.33, -117.117] ) ].each do |value|
+      result = subject.to_parse( value )
+      result.should == { "__type" => "GeoPoint", "latitude" => 33.33, "longitude" => -117.117 }
+    end    
+  end
+  
+  describe "instance" do
+    describe "with an array value" do
+      subject { GeoPoint.new [33.33, -117.117] }
+      it { should respond_to(:latitude, :longitude, :to_geo_point, :to_parse).with(0).arguments }
+      it { should respond_to(:latitude=, :longitude=).with(1).argument }
+    
+      its(:latitude) { should == 33.33 }
+      its(:longitude) { should == -117.117 }
+      its(:to_geo_point) { should == subject }
+      its(:to_parse) { should == { "__type" => "GeoPoint", "latitude" => 33.33, "longitude" => -117.117 } }
+      its(:to_s) { should == "33.33,-117.117" }
+    end
+
+    describe "with a hash value" do
+      subject { GeoPoint.new latitude: 33.33, longitude: -117.117 }
+      it { should respond_to(:latitude, :longitude, :to_geo_point, :to_parse).with(0).arguments }
+      it { should respond_to(:latitude=, :longitude=).with(1).argument }
+
+      its(:latitude) { should == 33.33 }
+      its(:longitude) { should == -117.117 }
+      its(:to_geo_point) { should == subject }
+      its(:to_parse) { should == { "__type" => "GeoPoint", "latitude" => 33.33, "longitude" => -117.117 } }
+      its(:to_s) { should == "33.33,-117.117" }
+    end
+  end
+end

data/spec/opium/extensions/hash_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe Hash do
+  subject { Hash }
+  
+  describe "instance" do
+    describe ":to_parse" do
+      subject { { 'foo' => GeoPoint.new( latitude: 33.33, longitude: -117.117 ) } }
+      
+      it 'should return a new hash, with :to_parse called on each value' do
+        subject.to_parse.tap do |result|
+          result.should =~ { 'foo' => { '__type' => 'GeoPoint', 'latitude' => 33.33, 'longitude' => -117.117 } }
+        end
+      end
+    end
+    
+    describe "with latitude and longitude keys" do
+      describe ":to_geo_point" do
+        subject { { latitude: 33.33, longitude: -117.117 } }
+      
+        it { subject.to_geo_point.should be_a_kind_of(GeoPoint) }
+        it "should have the expected latitude and longitude" do
+          subject.to_geo_point.latitude.should == 33.33
+          subject.to_geo_point.longitude.should == -117.117
+        end
+      end
+    end
+    
+    describe "without latitude or longitude keys" do
+      describe ":to_geo_point" do
+        subject { { latitude: 33.33 } }
+        
+        it { expect { subject.to_geo_point }.to raise_exception }
+      end
+    end
+    
+    describe "with __type key" do
+      describe "of Date" do
+        describe "with iso key" do
+          subject { { '__type' => 'Date', 'iso' => DateTime.now.iso8601 } }
+          
+          describe ":to_datetime" do
+            let(:result) { subject.to_datetime }
+            it { result.should be_a_kind_of( DateTime ) }
+          end
+          
+          describe ":to_date" do
+            let(:result) { subject.to_date }
+            it { result.should be_a_kind_of( Date ) }
+          end
+          
+          describe ":to_time" do
+            let(:result) { subject.to_time }
+            it { result.should be_a_kind_of( Time ) }
+          end
+        end
+        
+        describe "without iso key" do
+          subject { { '__type' => 'Date' } }
+
+          describe ":to_datetime" do
+            it { expect { subject.to_datetime }.to raise_exception }
+          end
+          
+          describe ":to_date" do
+            it { expect { subject.to_datetime }.to raise_exception }
+          end
+          
+          describe ":to_time" do
+            it { expect { subject.to_datetime }.to raise_exception }
+          end
+        end
+      end
+    end
+  end
+end

data/spec/opium/extensions/integer_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Integer do
+  subject { Integer }
+  it { should respond_to(:to_ruby).with(1).argument }
+  it { should respond_to(:to_parse).with(1).argument }
+  
+  it ":to_ruby(object) should convert object to a integer" do
+    {nil => nil, :foo => :foo.to_s.to_i}.each do |value, expected|
+      subject.to_ruby(value).should be_a_kind_of(expected.class)
+      subject.to_ruby(value).should == expected
+    end
+    ["foo", 42.0, 42, Time.now].each do |value|
+      subject.to_ruby(value).should be_a_kind_of(Integer)
+      subject.to_ruby(value).should == value.to_i
+    end
+  end
+  
+  it ":to_parse(object) should convert object to a integer" do
+    {nil => nil, :foo => :foo.to_s.to_i}.each do |value, expected|
+      subject.to_parse(value).should be_a_kind_of(expected.class)
+      subject.to_parse(value).should == expected
+    end
+    ["foo", 42.0, 42, Time.now].each do |value|
+      subject.to_parse(value).should be_a_kind_of(Integer)
+      subject.to_parse(value).should == value.to_i
+    end    
+  end
+  
+  describe "instance" do
+    subject { 42 }
+    it { should respond_to(:to_ruby, :to_parse, :to_bool).with(0).arguments }
+    its(:to_ruby) { should == subject }
+    its(:to_parse) { should == subject }
+    
+    it "should convert 1 and 0 to true and false, all others raise" do
+      1.to_bool.should == true
+      0.to_bool.should == false
+      expect { subject.to_bool }.to raise_exception
+    end
+  end
+end

data/spec/opium/extensions/object_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Object do
+  subject { Object }
+  it { should respond_to(:to_parse).with(1).argument }
+  it { should respond_to(:to_ruby).with(1).argument }
+  
+  it ":to_parse(object) should return the object" do
+    object = subject.new
+    subject.to_parse(object).should == object
+  end
+
+  it ":to_ruby(object) should return the object" do
+    object = subject.new
+    subject.to_ruby(object).should == object
+  end
+  
+  describe "instance" do
+    subject { Object.new }
+    it { should respond_to(:to_parse, :to_ruby) }
+    its(:to_parse) { should == subject }
+    its(:to_ruby) { should == subject }
+  end
+end

data/spec/opium/extensions/pointer_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Opium::Pointer do
+  subject { Opium::Pointer }
+  
+  describe 'an instance' do
+    subject { Opium::Pointer.new( model_name: 'Game', id: 'abcd1234' ) }
+    
+    it { should respond_to( :model_name, :class_name, :id, :to_parse ) }
+    
+    describe ':model_name' do
+      it 'should be an alias of :class_name' do
+        subject.method(:model_name).should == subject.method(:class_name)
+      end
+    end
+    
+    describe ':to_parse' do
+      it 'should be a hash' do
+        subject.to_parse.should be_a( Hash )
+      end
+      
+      it 'should have keys for "__type", "objectId", and "className"' do
+        subject.to_parse.keys.should =~ [ '__type', 'objectId', 'className' ]
+        subject.to_parse.should =~ { '__type' => 'Pointer', 'objectId' => 'abcd1234', 'className' => 'Game' }
+      end
+    end
+  end
+end

data/spec/opium/extensions/regexp_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper.rb'
+
+describe /foo/ do
+  
+  it { should respond_to( :to_parse ) }
+  
+  describe ':to_parse' do
+    it 'should create a hash containing a $regex key containing the regexp source' do
+      /foo.?bar/.to_parse.tap do |result|
+        result.should be_a( Hash )
+        result.should have_key( '$regex' )
+        result['$regex'].should == 'foo.?bar'
+      end
+    end
+    
+    it 'should also contain an $options key for any options defined on the regexp' do
+      /foo.?bar/ix.to_parse.tap do |result|
+        result.should have_key( '$options' )
+        result['$options'].should == 'ix'
+      end
+    end
+  end
+end

data/spec/opium/extensions/string_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe String do
+  subject { String }
+  it { should respond_to(:to_ruby).with(1).argument }
+  it { should respond_to(:to_parse).with(1).argument }
+  
+  it ":to_ruby(object) should convert object to a string" do
+    {nil => nil}.each do |value, expected|
+      subject.to_ruby(value).should be_a_kind_of(expected.class)
+      subject.to_ruby(value).should == expected
+    end
+    [:foo, "foo", 42.0, 42, Time.now].each do |value|
+      subject.to_ruby(value).should be_a_kind_of(String)
+      subject.to_ruby(value).should == value.to_s
+    end
+  end
+  
+  it ":to_parse(object) should convert object to a string" do
+    {nil => nil}.each do |value, expected|
+      subject.to_parse(value).should be_a_kind_of(expected.class)
+      subject.to_parse(value).should == expected
+    end
+    [:foo, "foo", 42.0, 42, Time.now].each do |value|
+      subject.to_parse(value).should be_a_kind_of(String)
+      subject.to_parse(value).should == value.to_s
+    end    
+  end
+  
+  describe "instance" do
+    subject { "instance" }
+    it { should respond_to(:to_ruby, :to_parse, :to_bool, :to_geo_point).with(0).arguments }
+    its(:to_ruby) { should == subject }
+    its(:to_parse) { should == subject }
+    
+    it "should be able to convert various values to true" do
+      %w[true t yes y 1].each do |value|
+        value.to_bool.should be_a_kind_of( Boolean )
+        value.to_bool.should == true
+      end
+    end
+    
+    it "should be able to convert various values to false" do
+      [""] + %w[false f no n 0].each do |value|
+        value.to_bool.should be_a_kind_of( Boolean )
+        value.to_bool.should == false
+      end
+    end
+    
+    it "any non-boolean string should raise on :to_bool" do
+      expect { subject.to_bool }.to raise_exception 
+    end
+    
+    it ":to_geo_point should be able to convert a 'lat, lng' value" do
+      result = "33.33, -117.117".to_geo_point
+      result.should be_a_kind_of(GeoPoint)
+      result.latitude.should == 33.33
+      result.longitude.should == -117.117
+    end
+    
+    it ":to_geo_point should raise exception if invalid" do
+      expect { "malformed".to_geo_point }.to raise_exception
+    end
+  end
+end

data/spec/opium/extensions/time_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe Time do
+  subject { Time }
+  it { should respond_to(:to_parse, :to_ruby).with(1).argument }
+  
+  describe ":to_ruby" do
+    describe "with a Hash containing '__type: Date'" do
+      let(:object) { { '__type' => 'Date', 'iso' => Time.now.iso8601 } }
+      it { subject.to_ruby(object).should be_a_kind_of( Time ) }
+    end
+  
+    describe "with a Hash without a '__type' key" do
+      let(:object) { { 'iso' => Time.now.iso8601 } }
+      it { expect { subject.to_ruby(object) }.to raise_exception }
+    end
+  
+    describe "with an object which responds to :to_time" do
+      let(:objects) { [ Time.now.iso8601, DateTime.now, Time.now, Date.today ] }
+      it do
+        objects.each do |object|
+          subject.to_ruby(object).should be_a_kind_of( Time )
+        end
+      end
+    end
+  end
+  
+  describe ":to_parse(object)" do
+    let(:objects) { [ Time.now.iso8601, DateTime.now, Time.now, Date.today ] }
+    it "should ensure that the object is a datetime" do
+      objects.each do |object|
+        object.should_receive :to_time
+        subject.to_parse(object)
+      end
+    end
+    
+    it "should make a parse object hash" do
+      objects.each do |object|
+        result = subject.to_parse(object)
+        result.should be_a_kind_of(Hash)
+        result.keys.should == ['__type', 'iso']
+        result['__type'].should == 'Date'
+      end
+    end
+  end
+  
+  describe "instance" do
+    subject { Time.now }
+    let(:result) { subject.to_parse }
+    it { result.should be_a_kind_of(Hash) }
+    it { result.keys.should == ['__type', 'iso'] }
+    it { result['__type'].should == 'Date' }
+    it { result['iso'].should == subject.iso8601 }
+  end
+end

data/spec/opium/model/attributable_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Opium::Model::Attributable do
+  let( :model ) { Class.new { include Opium::Model::Attributable } }
+  
+  describe 'instance' do
+    subject { model.new }
+    
+    it { should respond_to( :attributes, :attributes= ) }
+    it { should respond_to( :attributes_to_parse ) }
+  end
+  
+  describe 'when included in a model' do
+    before do
+      stub_const( 'Book', Class.new do
+        include Opium::Model
+        field :title, type: String
+      end )
+    end
+    
+    subject { Book.new( title: 'Little Brother', id: 'abc123', created_at: Time.now ) }
+    
+    describe 'attributes_to_parse' do
+      it 'when called with no parameters, should have all fields present, with names and values converted to parse' do
+        subject.attributes_to_parse.should =~ { 'objectId' => 'abc123', 'title' => 'Little Brother', 'createdAt' => subject.created_at.to_parse, 'updatedAt' => nil }
+      end
+      
+      it 'when called with except, should exclude the excepted fields' do
+        subject.attributes_to_parse( except: [:id, :updated_at] ).should =~ { 'title' => 'Little Brother', 'createdAt' => subject.created_at.to_parse }
+      end
+      
+      it 'when called with not_readonly, should exclude all readonly fields' do
+        subject.attributes_to_parse( not_readonly: true ).should =~ { 'title' => 'Little Brother' }
+      end
+    end
+    
+    describe ':attributes=' do
+      it 'should still store unrecognized fields in the attributes hash' do
+        expect { subject.attributes = { unknownField: 42 } }.to_not raise_exception
+        subject.attributes.should have_key('unknownField')
+        subject.attributes['unknownField'].should == 42
+      end
+    end
+  end
+end

data/spec/opium/model/callbacks_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe Opium::Model::Callbacks do
+  let( :model ) { 
+    Class.new do
+      def initialize( a = {} ) end
+      def save( o = {} ) end
+      def destroy; end
+      def touch; end
+      def create; end
+      def update; end
+      def find( id ) end
+      
+      private :create, :update
+      
+      include Opium::Model::Callbacks
+    end
+  }
+  
+  its( :constants ) { should include(:CALLBACKS) }
+  
+  it "should provide a list of its defined CALLBACKS" do
+    subject::CALLBACKS.should_not be_nil
+    subject::CALLBACKS.should_not be_empty
+  end
+  
+  it "should respond to each of its CALLBACKS" do
+    subject::CALLBACKS.each do |callback|
+      model.should respond_to(callback)
+    end
+  end
+  
+  shared_examples_for 'its callbacks should be invoked for' do |method, options = {}|
+    describe method do
+      subject { model.new }
+      
+      it 'should run callbacks' do
+        subject.should receive(:run_callbacks).with(method)
+        subject.send(method, *options[:args])
+      end
+      
+      it 'should not make a private method public' do
+        if options[:private]
+          subject.should_not respond_to(method)
+        else
+          subject.should respond_to(method)
+        end
+      end
+    end
+  end
+  
+  it_should_behave_like 'its callbacks should be invoked for', :initialize, private: true
+  it_should_behave_like 'its callbacks should be invoked for', :save
+  it_should_behave_like 'its callbacks should be invoked for', :create, private: true
+  it_should_behave_like 'its callbacks should be invoked for', :update, private: true
+  it_should_behave_like 'its callbacks should be invoked for', :destroy
+  it_should_behave_like 'its callbacks should be invoked for', :touch
+  it_should_behave_like 'its callbacks should be invoked for', :find, args: ['abcd1234']
+end