rest_model 0.1.0

data/spec/unit/key/relation/builder_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe RestModel::Relation::Builder do
+  describe ".has_one" do
+    before do
+      class Example < RestModel
+        has_one :item, some_option: 'option'
+      end
+    end
+
+    let(:field)   {:item}
+    let(:many)    {false}
+    let(:options) {{some_option: 'option', many: many, has: true}}
+
+    it_behaves_like "an association"
+
+    it "puts a new relation in relation list" do
+      Example.relations.find {|relation| relation.name == field}.name.should == field
+    end
+  end
+
+  describe ".has_many" do
+    before do
+      class Example < RestModel
+        has_many :items, some_option: 'option'
+      end
+    end
+
+    let(:field)   {:items}
+    let(:many)    {true}
+    let(:options) {{some_option: 'option', many: many, has: true}}
+
+    it_behaves_like "an association"
+
+    it "puts a new relation in relation list" do
+      Example.relations.find {|relation| relation.name == field}.name.should == field
+    end
+  end
+
+  describe ".belongs_to" do
+    before do
+      class Example < RestModel
+        belongs_to :item, some_option: 'option'
+      end
+    end
+
+    let(:field)   {:item}
+    let(:many)    {false}
+    let(:options) {{some_option: 'option', many: many, has: false}}
+
+    it_behaves_like "an association"
+  end
+end

data/spec/unit/key/relation/response_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+describe RestModel::Response do
+  shared_examples_for "a relation" do
+    context "#to_relation" do
+      it "returns a pair with property name and value" do
+        subject.to_relation(example).should == result
+      end
+    end
+
+    context "#to_resource" do
+      context "when the key shouldn't be visible on resource" do
+        it "returns an empty hash" do
+          subject.should_receive(:visible?).and_return false
+          subject.to_resource(example).should == {}
+        end
+      end
+
+      context "when the relation instance variable in parent returns nil" do
+        it "returns an empty hash" do
+          subject.to_resource(example).should == {}
+        end
+      end
+
+      context "otherwise" do
+
+      end
+    end
+  end
+
+  context "when has one" do
+    before do
+      class ExampleChild < RestModel
+        id
+        belongs_to :example
+      end
+
+      class Example < RestModel
+        id
+        has_one  :example_child
+      end
+    end
+
+    subject {Example.keys[1]}
+
+    let(:example) {Example.new(id: 100)}
+    let(:result)  {{rel: :example_child, href: "http://example.com/examples/100/example_child"}}
+
+    it_behaves_like "a relation"
+  end
+
+  context "when has many" do
+    before do
+      class ExampleChild < RestModel
+        property   :id
+        belongs_to :example
+      end
+
+      class Example < RestModel
+        property :id
+        has_many :example_children
+      end
+    end
+
+    subject {Example.keys[1]}
+
+    let(:example) {Example.new(id: 200)}
+    let(:result)  {{rel: :example_children, href: "http://example.com/examples/200/example_children"}}
+
+    it_behaves_like "a relation"
+  end
+
+  context "when belongs to one" do
+    before do
+      class ExampleChild < RestModel
+        property   :id
+        belongs_to :example
+      end
+
+      class Example < RestModel
+        property :id
+        has_many :example_children
+      end
+    end
+
+    subject {ExampleChild.keys[1]}
+
+    let(:example) {ExampleChild.new(id: 200)}
+    let(:result)  {{rel: :example, href: "http://example.com/examples/200/example_children"}}
+
+    it_behaves_like "a relation"
+  end
+
+  context "when using forbidden key names" do
+    [:resource_id, :resource].each do |forbidden_name|
+      it "raises an exception for #{forbidden_name}" do
+        expect {
+          class Example < RestModel
+            property forbidden_name
+          end
+        }.to raise_error
+      end
+    end
+  end
+end

data/spec/unit/key/relation_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+describe RestModel::Relation do
+  it "is a relation" do
+    RestModel::Relation.superclass.should == RestModel::Association
+  end
+
+  describe "#has?" do
+    context "when it has one resource" do
+      subject do
+        RestModel::Relation.new(:service, many: false, has: true)
+      end
+
+      it "returns true" do
+        subject.has?.should be_true
+      end
+    end
+
+    context "when it has many resources" do
+      subject do
+        RestModel::Relation.new(:service, many: true, has: true)
+      end
+
+      it "returns true" do
+        subject.has?.should be_true
+      end
+    end
+
+    context "when it belongs to a resource" do
+      subject do
+        RestModel::Relation.new(:service, many: false, has: false)
+      end
+
+      it "returns true" do
+        subject.has?.should be_false
+      end
+    end
+  end
+
+  describe "#belongs?" do
+    context "when it belongs to a resource" do
+      subject do
+        RestModel::Relation.new(:service, many: false, has: false)
+      end
+
+      it "returns true" do
+        subject.belongs?.should be_true
+      end
+    end
+
+    context "when it has one resource" do
+      subject do
+        RestModel::Relation.new(:service, many: false, has: true)
+      end
+
+      it "returns true" do
+        subject.belongs?.should be_false
+      end
+    end
+
+    context "when it has many resources" do
+      subject do
+        RestModel::Relation.new(:service, many: true, has: true)
+      end
+
+      it "returns true" do
+        subject.belongs?.should be_false
+      end
+    end
+  end
+end

data/spec/unit/key_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+describe RestModel::Key do
+  let(:name)    {"key_name"}
+  let(:options) {{any_option: "here"}}
+
+  subject {RestModel::Property.new(name, options)}
+
+  describe "#initialize" do
+    it "sets key name" do
+      subject.name.should == name
+    end
+
+    it "sets options" do
+      subject.options.should == options
+    end
+  end
+
+  describe "#visible?" do
+    context "when :visible option was defined" do
+      context "and :if option was defined with false" do
+        subject {RestModel::Property.new(name, {if: proc {false}, visible: true})}
+        it "return false even when visible is true" do
+          subject.visible?(nil).should be_false
+        end
+      end
+
+      context "and it evaluates to false" do
+        subject {RestModel::Property.new(name, {visible: false})}
+
+        it "returns false" do
+          subject.visible?(nil).should be_false
+        end
+      end
+
+      context "and it evaluates to true" do
+        subject {RestModel::Property.new(name, {visible: true})}
+
+        it "returns true" do
+          subject.visible?(nil).should be_true
+        end
+      end
+
+      context "with a proc" do
+        context "and it evaluates true" do
+          subject {RestModel::Property.new(name, {visible: proc {true}})}
+          it "returns true" do
+            subject.visible?("a").should be_true
+          end
+        end
+
+        context "and it evaluates false" do
+          subject {RestModel::Property.new(name, {visible: proc {false}})}
+          it "returns false" do
+            subject.visible?("a").should be_false
+          end
+        end
+
+        context "and it depends on resource instance" do
+          subject {RestModel::Property.new(name, {visible: proc {show}})}
+
+          it "uses it" do
+            resource = OpenStruct.new
+            resource.show = true
+            subject.visible?(resource).should be_true
+          end
+        end
+      end
+    end
+  end
+
+  describe "#present?" do
+    context "when :if option was defined with a proc" do
+      context "and it evaluates to false" do
+        subject {RestModel::Property.new(name, {if: proc {false}})}
+
+        it "returns false" do
+          subject.present?(nil).should be_false
+        end
+      end
+
+      context "and it evaluates to true" do
+        subject {RestModel::Property.new(name, {if: proc {true}})}
+
+        it "returns true" do
+          subject.present?(nil).should be_true
+        end
+      end
+
+      context "and it depends on resource instance" do
+        subject {RestModel::Property.new(name, {if: proc {show}})}
+
+        it "uses it" do
+          resource = OpenStruct.new
+          resource.show = true
+          subject.present?(resource).should be_true
+        end
+      end
+    end
+  end
+end

data/spec/unit/response_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe RestModel::Response do
+  before do
+    class Example < RestModel
+      id         :login
+      property   :phone
+      embeds_one :address, class_name: :example_child
+    end
+
+    class ExampleChild < RestModel
+      property   :street
+      property   :city
+    end
+  end
+
+  let(:input) do
+    {
+      login: 'jackiechan2010',
+      phone: '32232188',
+      address: {
+        street: 'Aurora St.',
+        city:   'Recife'
+      }
+    }
+  end
+
+  describe "#normalize" do
+    context "when one resource is received" do
+      it "returns a resource" do
+        model = Example.parse(input).first
+        Example.normalize(model).with_indifferent_access.should == input.with_indifferent_access
+      end
+    end
+
+    context "when a list of resources is received" do
+      it "returns some resources in an entries array" do
+        model = 3.times.map {Example.parse(input).first}
+        result = {entries: 3.times.map {input}}
+        Example.normalize(model).with_indifferent_access.should == result.with_indifferent_access
+      end
+    end
+  end
+end

data/spec/unit/rest_model_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe RestModel do
+  describe '#resource' do
+    before do
+      class Example < RestModel
+        property :login
+        property :name
+        property :age, type: Float
+      end
+    end
+
+    it "returns a hash with properties and its values" do
+      example = Example.new(login: 'jackiechan2010', name: 'Jackie Chan', age: 45)
+      example.resource.should == {login: 'jackiechan2010', name: 'Jackie Chan', age: 45}
+    end
+  end
+
+  context "when using not allowed names" do
+    [:resource_id, :resource, :link].each do |unallowed|
+      it "warns when method #{unallowed} is redefined" do
+        output = out do
+          eval <<-RUBY
+            class Example < RestModel
+              def #{unallowed}
+              end
+            end
+          RUBY
+        end
+        output.should =~ /^warning: redefining '#{unallowed}' may cause serious problems/
+      end
+
+      %w(property embeds_one embeds_many has_one has_many belongs_to).each do |kind|
+        it "removes method #{unallowed} created by #{kind}" do
+          expect {
+            eval <<-RUBY
+              class Example < RestModel
+                #{kind} :#{unallowed}
+              end
+            RUBY
+          }.to raise_error "you can't define a key with name '#{unallowed}'"
+        end
+      end
+    end
+  end
+end

data/spec/unit/serialization/boolean_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe RestModel::Serialization::Boolean do
+  [true,  "true",  "TRUE",  "1", 1, 1.0, "x", "X", "t", "T"].each do |true_value|
+    context "when value is #{true_value}" do
+      it "returns true" do
+        subject.class.serialize(true_value).should be_true
+      end
+    end
+  end
+
+  [false, "false", "FALSE", "0", 0, 0.0,  "", " ", "f", "F", nil].each do |false_value|
+    context "when value is #{false_value}" do
+      it "returns false" do
+        subject.class.serialize(false_value).should be_false
+      end
+    end
+  end
+
+  context "when an invalid value is serialized" do
+    it "raises an error" do
+      expect {subject.class.serialize("neither true or false")}.to raise_error
+    end
+  end
+end

data/spec/unit/serialization/date_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe RestModel::Serialization::Date do
+  it "converts to date" do
+    subject.class.serialize('2011-07-01').should == Date.new(2011, 07, 01)
+  end
+
+  context "when an invalid value is serialized" do
+    it "raises an error" do
+      expect {subject.class.serialize("not a date")}.to raise_error
+    end
+  end
+end

data/spec/unit/serialization/float_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe RestModel::Serialization::Float do
+  it "converts to float" do
+    subject.class.serialize('1200.49').should == 1200.49
+  end
+
+  context "when an invalid value is serialized" do
+    it "raises an error" do
+      expect {subject.class.serialize("not a float")}.to raise_error
+    end
+  end
+end

data/spec/unit/serialization/integer_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe RestModel::Serialization::Integer do
+  it "converts to integer" do
+    subject.class.serialize('1200').should == 1200
+  end
+
+  context "when an invalid value is serialized" do
+    it "raises an error" do
+      expect {subject.class.serialize("not an integer")}.to raise_error
+    end
+  end
+end

data/spec/unit/serialization/string_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe RestModel::Serialization::String do
+  it "converts value to string" do
+    subject.class.serialize(:something).should == "something"
+  end
+
+  it "returns nil when value is nil" do
+    subject.class.serialize(nil).should be_nil
+  end
+end

data/spec/unit/source/path_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+module Upcasing
+  def self.call(keys)
+    keys.map {|key| key.to_s.upcase}
+  end
+end
+
+describe RestModel::Source::Path do
+  shared_examples_for "an input path" do
+    it "brings the correct input path" do
+      subject.source_path.should == path
+    end
+  end
+
+  context "when a custom path is not defined" do
+    context "and there is'nt a custom keys input converter" do
+      subject    {RestModel::Key.new(:name)}
+      let(:path) {[:name]}
+      it_behaves_like "an input path"
+    end
+
+    context "and there is a custom keys input converter" do
+      subject {RestModel::Key.new(:name, convert_input_keys: Upcasing)}
+      let(:path) {['NAME']}
+      it_behaves_like "an input path"
+    end
+  end
+
+  context "when a custom path is defined" do
+    context "and it is a simple name" do
+      subject    {RestModel::Key.new(:name, field: :other_name)}
+      let(:path) {[:other_name]}
+      it_behaves_like "an input path"
+    end
+
+    context "and it is a set of names composed by dot" do
+      subject    {RestModel::Key.new(:name, field: 'a.long.way.to.go')}
+      let(:path) {['a', 'long', 'way', 'to', 'go']}
+      it_behaves_like "an input path"
+    end
+
+    context "and it is a set of names composed by dot" do
+      subject    {RestModel::Key.new(:name, field: 'a.long.long.way.to.go')}
+      let(:path) {['a', 'long', 'long', 'way', 'to', 'go']}
+      it_behaves_like "an input path"
+    end
+
+    context "and it is a set of names composed by dot using :start_key instead of :field" do
+      subject    {RestModel::Key.new(:name, start_key: 'a.long.way.to.go')}
+      let(:path) {['a', 'long', 'way', 'to', 'go']}
+      it_behaves_like "an input path"
+    end
+
+    context "and there is a custom keys input converter" do
+      let(:options) {{start_key: 'yay.upcase.path', convert_input_keys: Upcasing}}
+      subject {RestModel::Key.new(:name, options)}
+      let(:path) {['YAY', 'UPCASE', 'PATH']}
+      it_behaves_like "an input path"
+    end
+  end
+end

data/spec/unit/source/retriever_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+describe RestModel::Source::Retriever do
+  describe '.parse' do
+    it 'parses simple properties' do
+      class Example < RestModel
+        property :login
+      end
+
+      models = Example.parse({login: 'jackiechan2010'})
+      models.should be_an(Array)
+      models.first.login.should == 'jackiechan2010'
+    end
+
+    it 'uses different field name if defined' do
+      class Example < RestModel
+        property :login, field: :customer_login
+      end
+
+      models = Example.parse({customer_login: 'jackiechan2010'})
+      models.should be_an(Array)
+      models.first.login.should == 'jackiechan2010'
+    end
+
+    context "uses type defined" do
+      context 'boolean' do
+        before do
+          class Example < RestModel
+            property :can_merge, type: Boolean
+          end
+        end
+
+        it "returns true when value is 'X'" do
+          models = Example.parse({can_merge: 'X'})
+          models.first.can_merge.should be_true
+        end
+
+        it "returns false when value isn't 'X'" do
+          models = Example.parse({can_merge: ''})
+          models.first.can_merge.should be_false
+        end
+      end
+
+      context "date" do
+        it "parse" do
+          class Example < RestModel
+            property :issue_date, type: Date
+          end
+
+          models = Example.parse({issue_date: '2011-01-01'})
+          models.first.issue_date.should == Date.parse('2011-01-01')
+        end
+      end
+
+      context "float" do
+        it "parse" do
+          class Example < RestModel
+            property :amount, type: Float
+          end
+
+          models = Example.parse({amount: '1234.5'})
+          models.first.amount.should == 1234.5
+        end
+      end
+    end
+
+    context "maps values if defined" do
+      before do
+        class Example < RestModel
+          property :status, values: {paid: '01', unpaid: '02'}
+        end
+      end
+
+      it "returns key when value was mapped" do
+        models = Example.parse({status: '02'})
+        models.first.status.should == :unpaid
+      end
+
+      it "returns nil when value wasn't mapped" do
+        models = Example.parse({status: '03'})
+        models.first.status.should be_nil
+      end
+    end
+  end
+end