http-api-tools 0.1.0

data/spec/hat/model/attributes_spec.rb

@@ -0,0 +1,170 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'hat/model/attributes'
+
+module Hat
+  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 that 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/hat/model/has_many_array_spec.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'hat/model/has_many_array'
+
+module Hat
+  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/hat/model/transformers/date_time_transformer_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require 'hat/model/transformers/date_time_transformer'
+
+
+module Hat
+  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/hat/model/transformers/registry_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+require 'hat/model/transformers/registry'
+
+
+module Hat
+  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/hat/nesting/json_serializer_spec.rb

@@ -0,0 +1,173 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'hat/nesting/json_serializer'
+
+module Hat
+  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 that 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 what 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 what is includable in meta" do
+            expect(limited_serialized[:meta][:includable]).to eq 'skills'
+          end
+
+          it "includes what 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

data/spec/hat/relation_includes_spec.rb

@@ -0,0 +1,185 @@
+require 'spec_helper'
+require 'hat/relation_includes'
+
+module Hat
+  describe RelationIncludes do
+
+    context 'when constructed with no value' do
+      let(:includes) { RelationIncludes.new }
+
+      it 'is empty, not present and blank' do
+        expect(includes).to be_empty
+        expect(includes).to be_blank
+        expect(includes).to_not be_present
+      end
+    end
+
+    describe 'equality' do
+
+      it 'works as expected' do
+        one = [ :tags, { images: [:comments] }, { reviews: [:author] } ]
+        two = [ :tags, { images: [:comments] }, { reviews: [:author] } ]
+        expect(RelationIncludes.new(*one)).to eq RelationIncludes.new(*two)
+
+        one = [ { reviews: [:author] }, :tags, { images: [:comments] } ]
+        two = [ :tags, { images: [:comments] }, { reviews: [:author] } ]
+        expect(RelationIncludes.new(*one)).to eq RelationIncludes.new(*two)
+
+        one = [ :tags, { images: [:comments] }, { reviews: [:author] } ]
+        two = [ :tags, { images: [:comments] }, :reviews ]
+        expect(RelationIncludes.new(*one)).to_not eq RelationIncludes.new(*two)
+      end
+    end
+
+    describe '.from_string' do
+
+      let(:string)   { 'a,a.b,a.b.c,b,c' }
+      let(:includes) { RelationIncludes.from_string(string) }
+
+      it 'creates single level includes' do
+        expect(includes).to include :b
+        expect(includes).to include :c
+      end
+
+      it 'creates nested includes' do
+        expect(includes).to include({ a: [{ b: [:c] }] })
+      end
+
+      it 'creates same structure when implicit parts of the path are removed' do
+        simplified_params = 'a.b.c,b,c'
+        simplified_includes =  RelationIncludes.from_string(simplified_params)
+        expect(includes).to eq simplified_includes
+      end
+
+      context 'when a nil or empty string is provided' do
+
+        it 'returns a new includes' do
+          expect(RelationIncludes.from_string(nil)).to eq RelationIncludes.new
+          expect(RelationIncludes.from_string('')).to eq RelationIncludes.new
+        end
+      end
+    end
+
+    describe "#to_s" do
+
+      it "converts to dot-notation specified by the JSON API spec, sorted alphabetically" do
+        includes = RelationIncludes.new(:reviews, { images: [{ comments: [:author] }] }, :hashtags)
+        expect(includes.to_s).to eq 'hashtags,images,images.comments,images.comments.author,reviews'
+
+        includes = RelationIncludes.new(:hashtags, { images: [{ comments: [:author, :rating] }] }, :reviews)
+        expect(includes.to_s).to eq 'hashtags,images,images.comments,images.comments.author,images.comments.rating,reviews'
+      end
+    end
+
+    describe '#&' do
+
+      let(:relations) { [ :tags, { images: [:comments] }, { reviews: [:author] } ] }
+      let(:includes)  { RelationIncludes.new(*relations) }
+
+      let(:scenarios) do
+        [
+          {
+            includes: [ { images: [:comments] } ],
+            other:    [ { images: [:comments] } ],
+            expected: [ { images: [:comments] } ]
+          },
+          {
+            includes: [ { images: [:comments, :hashtags]} ],
+            other:    [ { images: [:comments] } ],
+            expected: [ { images: [:comments] } ]
+          },
+          {
+            includes: [ { images: [:comments] } ],
+            other:    [ { images: [:comments, :hashtags] } ],
+            expected: [ { images: [:comments] } ]
+          },
+          {
+            includes: [ :reviews, { images: [{ comments: [:author] }] }, :hashtags ],
+            other:    [ :reviews, { images: [{ comments: [:author] }] }, :hashtags ],
+            expected: [ :reviews, { images: [{ comments: [:author] }] }, :hashtags ]
+          },
+          {
+            includes: [ :reviews, { images: [{ comments: [:author] }] } ],
+            other:    [ :reviews, { images: [ :comments ]} ],
+            expected: [ :reviews, { images: [ :comments ]} ]
+          },
+          {
+            includes: [ :reviews, { images: [ :comments ]} ],
+            other:    [ :reviews, { images: [{ comments: [:author] }] } ],
+            expected: [ :reviews, { images: [ :comments ]} ]
+          },
+          {
+            includes: [ :reviews, { images: [{ comments: [:author] }] } ],
+            other:    [ :reviews, :images ],
+            expected: [ :reviews, :images ]
+          },
+          {
+            includes: [ :reviews, {images: [{ comments: [:author] }] } ],
+            other:    [ :reviews, :images, :hashtags ],
+            expected: [ :reviews, :images ]
+          }
+        ]
+      end
+
+      it 'reuturns a new RelationIncludes as a deep intersection between two RelationIncludes' do
+        scenarios.each do |scenario|
+          includes = scenario[:includes]
+          other    = scenario[:other]
+          expected = scenario[:expected]
+
+          intersection = RelationIncludes.new(*includes) & RelationIncludes.new(*other)
+          expect(intersection).to eq RelationIncludes.new(*expected)
+        end
+      end
+
+    end
+
+    describe "#includes_relation?" do
+
+      let(:includes) { RelationIncludes.new(:a, { b: [:c] }) }
+
+      it "includes correct relations when a symbol" do
+        expect(includes.includes_relation?(:a)).to be_true
+      end
+
+      it "includes relations when key of object" do
+        expect(includes.includes_relation?(:b)).to be_true
+      end
+
+      it "does not include unspecified relations" do
+        expect(includes.includes_relation?(:x)).to be_false
+      end
+
+    end
+
+    describe "#include" do
+
+      let(:includes) { RelationIncludes.new(:a, { b: [:c] }) }
+
+      it "includes new relations" do
+        includes.include([:y, :z])
+        expect(includes).to include :y
+        expect(includes).to include :z
+      end
+    end
+
+    describe "#find"  do
+
+      let(:includes) { RelationIncludes.new(:a, { b: [:c] }) }
+
+      it "finds include by key" do
+        expect(includes.find(:b)).to eq({ b: [:c] })
+      end
+    end
+
+    describe "#nested_includes_for"  do
+
+      let(:includes) { RelationIncludes.new(:a, { b: [:c] }) }
+
+      it "returns nested includes" do
+        expect(includes.nested_includes_for(:b)).to eq([:c])
+      end
+    end
+
+  end
+end