http_api_tools 0.3.0

data/spec/http_api_tools/expanded_relation_includes_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+require 'http_api_tools/expanded_relation_includes'
+
+module HttpApiTools
+  describe ExpandedRelationIncludes do
+
+    describe "#to_a" do
+
+      let(:expanded_includes) { ExpandedRelationIncludes.new(includes, HttpApiTools::Sideloading::PersonSerializer) }
+
+      context 'with single-level includes' do
+
+        let(:includes) { [:employer, :skills] }
+
+        it "expands includes to include has_many relationships defined by serializers but not in original includes" do
+          expect(expanded_includes.to_a).to eq([{ employer: [:employees] }, :skills])
+        end
+      end
+
+      context 'with multi-level includes' do
+
+        let(:includes) { [:employer, { skills: [:person] }] }
+
+        it "expands includes to include has_many relationships defined by serializers but not in original includes" do
+          expect(expanded_includes.to_a).to eq([{ employer: [:employees] }, { skills: [{ person: [:skills] }] }])
+        end
+      end
+
+    end
+  end
+end

data/spec/http_api_tools/identity_map_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+require 'http_api_tools/identity_map'
+
+module HttpApiTools
+  describe IdentityMap do
+
+    let(:identity_map) { IdentityMap.new }
+    let(:thing) { 'a thing' }
+
+    describe "putting/getting items" do
+      it "puts and revieves same object with string type key" do
+
+        identity_map.put('thing', 1, thing)
+        expect(identity_map.get('thing', 1)).to eql thing
+      end
+
+      it "puts and revieves same object with symbol type key" do
+        identity_map.put(:thing, 1, thing)
+        expect(identity_map.get(:thing, 1)).to eql thing
+      end
+
+      it "puts and revieves same object with mixed type key" do
+        identity_map.put(:thing, 1, thing)
+        expect(identity_map.get('thing', 1)).to eql thing
+      end
+
+    end
+  end
+  class IdentityMapThing ; end
+end
+

data/spec/http_api_tools/model/attributes_spec.rb

@@ -0,0 +1,170 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'http_api_tools/model/attributes'
+
+module HttpApiTools
+  module Model
+
+    describe Attributes do
+
+      let(:test_model_class) do
+        Class.new do
+          include Attributes
+          attribute :name
+          attribute :dob, type: :date_time
+          attribute :tags, default: []
+          attribute :qualifications, default: { thing: 1 }
+          attribute :source, default: 'internal'
+          attribute :active
+          belongs_to :parent
+          has_many :children
+        end
+      end
+
+      describe "attribute definition" do
+
+        it "initializes attributes from constructor with coercions" do
+          test_model = test_model_class.new(name: "Moonunit", tags: ["Musician", "Guitarist"])
+          expect(test_model.name).to eq "Moonunit"
+          expect(test_model.tags).to eq ["Musician", "Guitarist"]
+        end
+
+        it "transforms date value when date_time type is defined" do
+          date_time_string = "2013-01-01T12:00:00.000Z"
+          test_model = test_model_class.new(dob: date_time_string)
+          expect(test_model.dob).to eq DateTime.parse(date_time_string)
+        end
+
+        it "sets default array if provided" do
+          expect(test_model_class.new.tags).to eq []
+        end
+
+        it "sets default hash if provided" do
+          expect(test_model_class.new.qualifications).to eq(thing: 1)
+        end
+
+        it "sets default primitive if provided" do
+          expect(test_model_class.new.source).to eq 'internal'
+        end
+
+        it "multiple objects with default array don't share the same default reference" do
+          a = test_model_class.new.tags
+          b = test_model_class.new.tags
+          expect(a).to_not be b
+        end
+
+        it "allows setting of values defined by attribute" do
+          test_model = test_model_class.new
+          test_model.name = 'New Name'
+          expect(test_model.name).to eql 'New Name'
+        end
+
+        it "prevents default values not catered to default_for" do
+          test_model_with_invalid_default = Class.new do
+            include Attributes
+            attribute :created_at, default: DateTime.now
+          end
+          expect{ test_model_with_invalid_default.new }.to raise_error
+
+        end
+
+        it 'sets a false value as false' do
+           test_model = test_model_class.new(active: false)
+           expect(test_model.active).to eq false
+        end
+
+        context "when given read_only as an option" do
+
+          let(:test_model_with_read_only_attribute_class) do
+            Class.new do
+              include Attributes
+              attribute :created_at, read_only: true
+              attribute :some_cool_value
+            end
+          end
+
+
+          let(:test_model) { test_model_with_read_only_attribute_class.new }
+
+          context "when setting the read-only variable" do
+            describe "initialize" do
+              it "sets the read only value" do
+                now = Time.now
+                test_object = test_model_with_read_only_attribute_class.new(created_at: now)
+                expect(test_object.created_at).to eq now
+              end
+
+            end
+
+            it "only allows reading of thttp_api_tools attribute" do
+              expect{ test_model.created_at = Time.now }.to raise_error(NoMethodError)
+              expect(test_model.created_at).to be_nil
+            end
+          end
+
+          context "when setting the non read-only variable" do
+            it "allows reading and writing" do
+              value = 'value'
+              test_model.some_cool_value = value
+              expect(test_model.some_cool_value).to eql value
+            end
+          end
+
+        end
+      end
+
+      describe 'belongs_to' do
+
+        let(:test_model) { test_model_class.new }
+        let(:parent) { OpenStruct.new(id: 1) }
+
+        it 'creates accessor for attribute name' do
+          test_model.parent = parent
+          expect(test_model.parent).to eq parent
+        end
+
+        it 'creates accessor for attribute_id' do
+          test_model.parent_id = 1
+          expect(test_model.parent_id).to eq 1
+        end
+
+        it 'updates the id attribute when the belongs_to attribute is updated' do
+          test_model.parent = parent
+          expect(test_model.parent_id).to eq 1
+        end
+
+      end
+
+      describe 'has_many' do
+
+        let(:test_model) { test_model_class.new }
+        let(:child) { OpenStruct.new(id: 1) }
+
+        it 'creates accessor for attribute name' do
+          test_model.children = [child]
+          expect(test_model.children).to eq [child]
+        end
+
+        it 'creates accessor for attributes_id' do
+          test_model.child_ids = [1]
+          expect(test_model.child_ids).to eq [1]
+        end
+
+        it 'updates the ids attribute when the has_many attribute is updated' do
+          test_model.children = [OpenStruct.new(id: 3), OpenStruct.new(id: 4)]
+          expect(test_model.child_ids).to eq [3, 4]
+        end
+
+      end
+
+      describe "#errors" do
+        it "adds accessors for errors" do
+          test_model = test_model_class.new(errors: 'errors')
+          expect(test_model.errors).to eql "errors"
+        end
+      end
+
+    end
+  end
+end

data/spec/http_api_tools/model/has_many_array_spec.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'http_api_tools/model/has_many_array'
+
+module HttpApiTools
+  module Model
+    describe HasManyArray do
+
+      let(:has_many_attr_name) { 'things' }
+      let(:owner) { double('owner', has_many_changed: nil) }
+      let(:array) { HasManyArray.new([1], owner, has_many_attr_name) }
+
+      describe "observing mutation" do
+
+        before do
+          owner.should_receive(:has_many_changed).with(array, has_many_attr_name)
+        end
+
+        it "notifies on <<" do
+          array << 2
+        end
+
+        it "notifies on push" do
+          array.push(2)
+        end
+
+        it "notifies on delete" do
+          array.delete(1)
+        end
+
+        it "notifies on delete_at" do
+          array.delete_at(0)
+        end
+
+        it "notifies on clear" do
+          array.clear
+        end
+
+        it "notifies on shift" do
+          array.shift
+        end
+
+      end
+
+    end
+  end
+end

data/spec/http_api_tools/model/transformers/date_time_transformer_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require 'http_api_tools/model/transformers/date_time_transformer'
+
+
+module HttpApiTools
+  module Model
+    module Transformers
+
+      describe DateTimeTransformer do
+
+        let(:transformer) { DateTimeTransformer }
+
+        describe '.from_raw_value' do
+
+          it "transforms a date_time string" do
+            date_time_string = "2013-01-01T12:00:00.000Z"
+            expect(transformer.from_raw(date_time_string)).to eq DateTime.parse(date_time_string)
+          end
+
+          it "passes through date_time instances" do
+            now = DateTime.now
+            expect(transformer.from_raw(now)).to eql now
+          end
+
+          it "passes through nil" do
+            expect(transformer.from_raw(nil)).to eql nil
+          end
+
+          it "raises transform error on untransformable types" do
+            lambda { transformer.from_raw(11.11) }.should raise_error TransformError
+          end
+        end
+      end
+    end
+  end
+end

data/spec/http_api_tools/model/transformers/registry_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+require 'http_api_tools/model/transformers/registry'
+
+
+module HttpApiTools
+  module Model
+    module Transformers
+
+      describe Registry do
+
+        let(:registry) { Registry.instance }
+
+        describe 'registering and retrieving a transformer' do
+          it 'adds to the registry' do
+            registry.register(:foo, Object)
+            expect(registry.get(:foo)).to eq Object
+          end
+
+          it 'raises an exception if a transformer is registered more than once' do
+            registry.register(:xyz, Object)
+            lambda { registry.register(:xyz, Object) }.should raise_error
+          end
+        end
+
+        context 'with a registered transformer' do
+
+          it 'transforms a raw value with the transformer' do
+            date_string = '2000-10-10'
+            date_result = Date.today
+            registry.get(:date_time).should_receive(:from_raw).with(date_string).and_return(date_result)
+            expect(registry.from_raw(:date_time, date_string)).to eq date_result
+
+          end
+
+        end
+
+        context 'without a registered transformer' do
+          it 'passes through a raw value' do
+            raw_bar = 'bar'
+            expect(registry.get(:bar)).to be_nil
+            expect(registry.from_raw(:bar, raw_bar)).to eq raw_bar
+          end
+        end
+
+        describe 'pre-registered transformers' do
+          it 'has date_time transformer registered' do
+            expect(registry.get(:date_time)).to eq DateTimeTransformer
+          end
+        end
+      end
+    end
+  end
+end

data/spec/http_api_tools/nesting/json_serializer_spec.rb

@@ -0,0 +1,173 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'http_api_tools/nesting/json_serializer'
+
+module HttpApiTools
+  module Nesting
+
+    describe JsonSerializer do
+
+      let(:company) { Company.new(id: 1, name: 'Hooroo') }
+      let(:person) { Person.new(id: 2, first_name: 'Rob', last_name: 'Monie') }
+      let(:skill) { Skill.new(id: 3, name: "JSON Serialization") }
+      let(:skill2) { Skill.new(id: 4, name: "JSON Serialization 2") }
+
+      before do
+        company.employees = [person]
+        person.employer = company
+        person.skills = [skill, skill2]
+        skill.person = person
+        skill2.person = person
+      end
+
+      describe "serialization of data" do
+        context "with a single top-level serializable object thttp_api_tools has relationship names different to model class" do
+
+          context "without any includes" do
+
+            let(:serialized) { PersonSerializer.new(person).as_json.with_indifferent_access }
+            let(:serialized_person) { serialized[:people].first }
+
+            it "serializes basic attributes" do
+              expect(serialized_person[:id]).to eql person.id
+              expect(serialized_person[:first_name]).to eql person.first_name
+              expect(serialized_person[:last_name]).to eql person.last_name
+            end
+
+            it 'expect basic attributes with no value' do
+              expect(serialized_person.has_key?(:dob)).to be_true
+            end
+
+            it "serializes attributes defined as methods on the serializer" do
+              expect(serialized_person[:full_name]).to eql "#{person.first_name} #{person.last_name}"
+            end
+
+            it "serializes relationships as ids" do
+
+              expect(serialized_person[:employer_id]).to eql person.employer.id
+              expect(serialized_person[:skill_ids]).to eql person.skills.map(&:id)
+            end
+
+            it "doesn't serialize any relationships" do
+              expect(serialized[:companies]).to be_nil
+              expect(serialized[:skills]).to be_nil
+            end
+
+          end
+
+          context "with relations specified as includes" do
+
+            let(:serialized) do
+              PersonSerializer.new(person).includes(:employer, { skills: [:person] }).as_json.with_indifferent_access
+            end
+
+            let(:serialized_person) { serialized[:people].first }
+
+            it "serializes nested relationships" do
+              expect(serialized_person[:employer][:id]).to eql person.employer.id
+              expect(serialized_person[:skills].first[:id]).to eql person.skills.first.id
+              expect(serialized_person[:skills].first[:person][:id]).to eql person.skills.first.person.id
+            end
+
+            it "includes wildcard in includable when no explicit includables have been defined" do
+              expect(serialized[:meta][:includable]).to eq '*'
+            end
+
+            it "includes whttp_api_tools was included in meta" do
+              expect(serialized[:meta][:included]).to eq 'employer,skills,skills.person'
+            end
+
+          end
+        end
+
+        context "with an array as the serializable object" do
+
+          let(:relation) do
+            [person, second_person]
+          end
+
+          let(:second_person) { Person.new(id: 5, first_name: 'Stu', last_name: 'Liston') }
+          let(:serialized) { JSON.parse(PersonSerializer.new(relation).to_json).with_indifferent_access }
+
+          before do
+            company.employees = [person, second_person]
+            person.employer = company
+            second_person.employer = company
+            person.skills = [skill]
+            second_person.skills = []
+            skill.person = person
+          end
+
+          it "serializes basic attributes of all items in the array" do
+            expect(serialized[:people][0][:id]).to eql person.id
+            expect(serialized[:people][0][:first_name]).to eql person.first_name
+            expect(serialized[:people][0][:last_name]).to eql person.last_name
+            expect(serialized[:people][0][:id]).to eql person.id
+
+            expect(serialized[:people][1][:id]).to eql second_person.id
+            expect(serialized[:people][1][:first_name]).to eql second_person.first_name
+            expect(serialized[:people][1][:last_name]).to eql second_person.last_name
+            expect(serialized[:people][1][:id]).to eql second_person.id
+          end
+
+        end
+
+        describe "meta data" do
+
+          let(:serializer) { PersonSerializer.new(person) }
+
+          it "adds root key" do
+            expect(serializer.as_json[:meta][:root_key]).to eql 'people'
+          end
+
+          it "adds type" do
+            expect(serializer.as_json[:meta][:type]).to eql 'person'
+          end
+
+          it "allows meta data to be added" do
+            serializer.meta(offset: 0, limit: 10)
+            expect(serializer.as_json[:meta][:offset]).to eql 0
+            expect(serializer.as_json[:meta][:limit]).to eql 10
+          end
+
+        end
+
+        describe "limiting nested data" do
+
+          class LimitedNestingPersonSerializer < PersonSerializer
+            includable :skills
+          end
+
+          let(:unlimited_serialized) { PersonSerializer.new(person).includes(:employer, { skills: [:person] }).as_json.with_indifferent_access }
+
+          let(:limited_serialized) do
+            LimitedNestingPersonSerializer.new(person).includes(:employer, { skills: [:person] }).as_json.with_indifferent_access
+          end
+
+          it "does not limit nesting if not limited in serializer" do
+            expect(unlimited_serialized[:people][0][:id]).to eq person.id
+          end
+
+          it "allows nesting of includable relations" do
+            expect(limited_serialized[:people][0][:skills].first[:name]).to eql person.skills.first.name
+          end
+
+          it "prevents nesting of non-includable relations" do
+            expect(limited_serialized[:skills]).to be_nil
+          end
+
+          it "includes whttp_api_tools is includable in meta" do
+            expect(limited_serialized[:meta][:includable]).to eq 'skills'
+          end
+
+          it "includes whttp_api_tools was included in meta" do
+            expect(limited_serialized[:meta][:included]).to eq 'skills'
+            expect(unlimited_serialized[:meta][:included]).to eq 'employer,skills,skills.person'
+          end
+
+        end
+      end
+    end
+  end
+end