http_api_tools 0.3.0

data/spec/http_api_tools/relation_includes_spec.rb

@@ -0,0 +1,196 @@
+require 'spec_helper'
+require 'http_api_tools/relation_includes'
+
+module HttpApiTools
+  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
+
+    describe "#for_query" do
+
+      let(:includes) { RelationIncludes.new(:employer, { skills: [:person] }).for_query(HttpApiTools::Sideloading::PersonSerializer) }
+
+      it "creates includes for included relationships and has_many relationships for fetching ids" do
+        expect(includes.find(:employer)).to eq({ employer: [:employees] })
+        expect(includes.find(:skills)).to eq({ skills: [{ person: [:skills] }] })
+      end
+
+    end
+
+  end
+end

data/spec/http_api_tools/sideloading/json_deserializer_spec.rb

@@ -0,0 +1,93 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'http_api_tools/sideloading/json_deserializer'
+require 'http_api_tools/support/company_deserializer_mapping'
+require 'http_api_tools/support/person_deserializer_mapping'
+
+module HttpApiTools
+
+  module Sideloading
+
+    describe JsonDeserializer do
+
+      let(:json) do
+        {
+          'meta' => {
+            'type' => 'company',
+            'root_key' => 'companies'
+          },
+          'companies' => [{
+            'id' => 1,
+            'name' => "Hooroo",
+            'brand' => "We are travellers or something",
+            'links' => {
+              'employees' => [10, 11, 12],
+              'address' => 20,
+              'suppliers' => [30],
+              'parent_company' => 40
+            }
+          }],
+          'linked' => {
+            'people' => [
+              {'id' => 10, 'first_name' => 'Rob', 'links' => { 'employer' => 1 } },
+              {'id' => 11, 'first_name' => 'Stu', 'links' => { 'employer' => 1 } },
+              {'id' => 12, 'first_name' => 'Dan', 'links' => { 'employer' => 1 } },
+            ],
+            'addresses' => [
+              {'id' => 20, 'street_address' => "1 Burke Street"}
+            ]
+          }
+
+        }
+
+      end
+
+      let(:company) do
+        JsonDeserializer.new(json).deserialize.first
+      end
+
+      describe "basic deserialization" do
+
+        it "creates model from the root object" do
+          expect(company.id).to eq json['companies'][0]['id']
+          expect(company.name).to eq json['companies'][0]['name']
+        end
+
+        it "can set read-only attributes" do
+          expect(company.brand).to eq json['companies'][0]['brand']
+        end
+
+        it "includes sideloaded has many relationships" do
+          expect(company.employees.size).to eql 3
+          expect(company.employees.first.first_name).to eq json['linked']['people'].first['first_name']
+        end
+
+        it "includes sideloaded has_one relationships" do
+          expect(company.address.street_address).to eq json['linked']['addresses'].first['street_address']
+        end
+
+        it "includes circular relationships" do
+          expect(company.employees.first.employer.name).to eq json['companies'][0]['name']
+        end
+
+        it "has_many relationships without sideloaded data are set to an empty array" do
+          expect(company.suppliers).to eql []
+        end
+
+        it "has_many relationships without sideloaded data have relation_ids attribute set to the ids of the relationship" do
+          expect(company.supplier_ids).to eql [30]
+        end
+
+        it "has_one relationships without sideloaded data are set to nil" do
+          expect(company.parent_company).to eql nil
+        end
+
+        it "has_one relationships without sideloaded data sets the relation_id attribute set to the id" do
+          expect(company.parent_company_id).to eql 40
+        end
+
+      end
+    end
+  end
+end

data/spec/http_api_tools/sideloading/json_serializer_performance_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+require 'ruby-prof'
+
+module HttpApiTools
+  module Sideloading
+
+    # Rudimentary performance profiler - uncomment to run on demand for now
+
+
+    # describe JsonSerializer do
+
+    #   let!(:companies) do
+    #     start = Time.now
+    #     companies = (1..100).map do |company_id|
+    #       company = Company.new(id: company_id, name: "Company #{rand(company_id)}")
+    #       people = (1..100).map do |person_id|
+    #         person = Person.new(id: person_id, first_name: "First #{rand(person_id)}", last_name: "Last #{rand(person_id)}", dob: Date.today, email: 'user@example.com', employer: company)
+    #         skills = (1..20).map do |skill_id|
+    #           skill = Skill.new(id: skill_id, name: "Skill #{rand(skill_id)}", description: "abc123" * 500, person: person)
+    #         end
+    #         person.skills = skills
+    #         person
+    #       end
+    #       company.employees = people
+    #       company
+    #     end
+    #     puts "BUILD MODEL: #{(Time.now - start) * 1000} ms"
+    #     companies
+    #   end
+
+    #   it "serializes" do
+    #     RubyProf.start
+    #     serialized = CompanySerializer.new(companies).includes(:employer, {employees: [:skills]}).as_json
+    #     result = RubyProf.stop
+    #     printer = RubyProf::CallStackPrinter.new(result)
+    #     report_file = File.open(File.expand_path("../../../reports/profile_report.html", __FILE__), "w")
+    #     printer.print(report_file)
+
+    #     start = Time.now
+    #     serialized = CompanySerializer.new(companies).includes(:employer, {employees: [:skills]}).as_json
+    #     puts "SERIALIZE: #{(Time.now - start) * 1000} ms"
+
+    #     start = Time.now
+    #     JSON.fast_generate(serialized)
+    #     puts "TO_JSON: #{(Time.now - start) * 1000} ms"
+
+    #   end
+
+    # end
+  end
+end

data/spec/http_api_tools/sideloading/json_serializer_spec.rb

@@ -0,0 +1,174 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'http_api_tools/sideloading/json_serializer'
+
+module HttpApiTools
+  module Sideloading
+
+    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[:links][:employer]).to eql person.employer.id
+              expect(serialized_person[:links][:skills]).to eql person.skills.map(&:id)
+            end
+
+            it "doesn't serialize any relationships" do
+              expect(serialized[:linked][:companies]).to be_nil
+              expect(serialized[:linked][:skills]).to be_nil
+            end
+
+          end
+
+          context "with relations specified as includes" do
+
+            let(:serializer) { PersonSerializer.new(person).includes(:employer, {skills: [:person]}) }
+
+            let(:serialized) do
+              serializer.as_json.with_indifferent_access
+            end
+
+            let(:serialized_person) { serialized[:people].first }
+
+            it "serializes relationships as ids" do
+              expect(serialized_person[:links][:employer]).to eql person.employer.id
+              expect(serialized_person[:links][:skills]).to eql person.skills.map(&:id)
+            end
+
+            it "sideloads has_one relationships" do
+              expect(serialized[:linked][:companies].first[:name]).to eql person.employer.name
+            end
+
+            it "sideloads has_many relationships" do
+              expect(serialized[:linked][:skills].first[:name]).to eql person.skills.first.name
+            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 sideloadable data" do
+
+          class LimitedSideloadingPersonSerializer < PersonSerializer
+            includable :employer, :skills
+          end
+
+          let(:unlimited_serialized) { PersonSerializer.new(person).includes(:employer, {skills: [:person]}).as_json.with_indifferent_access }
+
+          let(:limited_serialized) do
+            LimitedSideloadingPersonSerializer.new(person).includes(:employer, {skills: [:person]}).as_json.with_indifferent_access
+          end
+
+          it "does not limit sideloading if not limited in serializer" do
+            expect(unlimited_serialized[:linked][:people].first[:id]).to eq person.id
+          end
+
+          it "allows sideloading of includable relations" do
+            expect(limited_serialized[:linked][:skills].first[:name]).to eql person.skills.first.name
+          end
+
+          it "prevents sideloading of non-includable relations" do
+            expect(limited_serialized[:linked][:people]).to be_nil
+          end
+
+          it "includes whttp_api_tools is includables in meta" do
+            expect(limited_serialized[:meta][:includable]).to eq 'employer,skills'
+          end
+
+          it "includes whttp_api_tools was included in meta" do
+            expect(limited_serialized[:meta][:included]).to eq 'employer,skills'
+            expect(unlimited_serialized[:meta][:included]).to eq 'employer,skills,skills.person'
+          end
+
+        end
+      end
+    end
+  end
+end