http-api-tools 0.1.0

data/spec/hat/sideloading/json_deserializer_spec.rb

@@ -0,0 +1,93 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'hat/sideloading/json_deserializer'
+require 'hat/support/company_deserializer_mapping'
+require 'hat/support/person_deserializer_mapping'
+
+module Hat
+
+  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/hat/sideloading/json_serializer_performance_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+require 'ruby-prof'
+
+module Hat
+  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/hat/sideloading/json_serializer_spec.rb

@@ -0,0 +1,185 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'hat/sideloading/json_serializer'
+
+module Hat
+  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 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[: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
+
+            describe "#includes_for_query" do
+
+              let(:includes_for_query) { serializer.includes_for_query }
+
+              it "expands includes for included relationships and has_many relationships for fetching ids" do
+                expect(includes_for_query.find(:employer)).to eq({ employer: [:employees] })
+                expect(includes_for_query.find(:skills)).to eq({ skills: [{ person: [:skills] }] })
+              end
+
+            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 what is includables in meta" do
+            expect(limited_serialized[:meta][:includable]).to eq 'employer,skills'
+          end
+
+          it "includes what 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

data/spec/hat/sideloading/sideload_map_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+require 'hat/sideloading/sideload_map'
+
+module Hat
+  module Sideloading
+
+    describe SideloadMap do
+
+      let(:json) do
+        {
+          'meta' => {
+            'root_key' => 'posts'
+          },
+          'posts' => [{
+            'id' => 1,
+            'title' => 'Post Title'
+          }],
+          'linked' => {
+            'images' => [
+              {'id' => 10, 'url' => '1.png' },
+              {'id' => 11, 'url' => '2.png' }
+            ],
+            'comments' => [
+              {'id' => 20, 'text' => 'Comment 1'}
+            ]
+          }
+        }
+
+      end
+
+      let(:sideload_map) { SideloadMap.new(json, 'posts') }
+
+      describe 'getting sideloaded json from the map' do
+
+        it 'returns object at root key' do
+          expect(sideload_map.get('post', 1)['id']).to eql 1
+        end
+
+        it 'retrieves by singular type' do
+          expect(sideload_map.get('image', 10)['id']).to eql 10
+        end
+
+        it 'retrieves by plural type' do
+          expect(sideload_map.get('images', 11)['id']).to eql 11
+        end
+
+        it 'retrieves with string type' do
+          expect(sideload_map.get('comment', 20)['id']).to eql 20
+        end
+
+        it 'returns nil if object not present' do
+          expect(sideload_map.get('foo', 100)).to be_nil
+        end
+
+      end
+
+    end
+  end
+end

data/spec/hat/support/company_deserializer_mapping.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+require 'hat/sideloading/json_deserializer_mapping'
+
+class CompanyDeserializerMapping
+
+  include Hat::Sideloading::JsonDeserializerMapping
+
+  map :employees, Person
+
+end

data/spec/hat/support/person_deserializer_mapping.rb

@@ -0,0 +1,9 @@
+require 'hat/sideloading/json_deserializer_mapping'
+
+class PersonDeserializerMapping
+
+  include Hat::Sideloading::JsonDeserializerMapping
+
+  map :employer, Company
+
+end

data/spec/hat/support/spec_models.rb

@@ -0,0 +1,89 @@
+# encoding: utf-8
+
+require 'hat/model'
+require 'ostruct'
+
+
+class Person
+
+  include Hat::Model::Attributes
+
+  attribute :id
+  attribute :first_name
+  attribute :last_name
+  attribute :dob
+  attribute :email
+  belongs_to :employer
+  has_many :skills
+
+  def employer_id
+    employer.try(:id)
+  end
+
+  #Act like active record for reflectively interogating type info
+  def self.reflections
+    {
+      employer: OpenStruct.new(class_name: 'Company'),
+      skills:   OpenStruct.new(class_name: 'Skill')
+    }
+  end
+
+end
+
+class Company
+
+  include Hat::Model::Attributes
+
+  attribute :id
+  attribute :name
+  attribute :brand, read_only: true
+  has_many :employees
+  has_many :suppliers
+  belongs_to :parent_company
+  belongs_to :address
+
+
+  #Act like active record for reflectively interogating type info
+  def self.reflections
+    {
+      employees:      OpenStruct.new(class_name: 'Person'),
+      suppliers:      OpenStruct.new(class_name: 'Company'),
+      parent_company: OpenStruct.new(class_name: 'Company'),
+      address:        OpenStruct.new(class_name: 'Address')
+    }
+  end
+
+end
+
+class Skill
+
+  include Hat::Model::Attributes
+
+  attribute :id
+  attribute :name
+  attribute :description
+  belongs_to :person
+
+  def person_id
+    person.try(:id)
+  end
+
+  #Act like active record for reflectively interogating type info
+  def self.reflections
+    {
+      person: OpenStruct.new(class_name: 'Person')
+    }
+  end
+
+end
+
+class Address
+
+  attr_accessor :id, :street_address
+
+  def initialize(attrs)
+    @id = attrs[:id]
+    @street_address = attrs[:street_address]
+  end
+
+end

data/spec/hat/support/spec_nesting_serializers.rb

@@ -0,0 +1,41 @@
+require 'hat/nesting/json_serializer'
+
+module Hat
+  module Nesting
+    class PersonSerializer
+
+      include Hat::Nesting::JsonSerializer
+
+      serializes Person
+      attributes :id, :first_name, :last_name, :full_name, :dob, :email
+      has_one :employer
+      has_many :skills
+
+      def full_name
+        "#{serializable.first_name} #{serializable.last_name}"
+      end
+
+    end
+
+    class CompanySerializer
+
+      include Hat::Nesting::JsonSerializer
+
+      serializes Company
+      attributes :id, :name
+      has_many :employees
+
+    end
+
+
+    class SkillSerializer
+
+      include Hat::Nesting::JsonSerializer
+
+      serializes Skill
+      attributes :id, :name, :description
+      has_one :person
+
+    end
+  end
+end

data/spec/hat/support/spec_sideloading_serializers.rb

@@ -0,0 +1,41 @@
+require 'hat/sideloading/json_serializer'
+
+module Hat
+  module Sideloading
+    class PersonSerializer
+
+      include Hat::Sideloading::JsonSerializer
+
+      serializes Person
+      attributes :id, :first_name, :last_name, :full_name, :dob, :email
+      has_one :employer
+      has_many :skills
+
+      def full_name
+        "#{serializable.first_name} #{serializable.last_name}"
+      end
+
+    end
+
+    class CompanySerializer
+
+      include Hat::Sideloading::JsonSerializer
+
+      serializes Company
+      attributes :id, :name
+      has_many :employees
+
+    end
+
+
+    class SkillSerializer
+
+      include Hat::Sideloading::JsonSerializer
+
+      serializes Skill
+      attributes :id, :name, :description
+      has_one :person
+
+    end
+  end
+end

data/spec/hat/type_key_resolver_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+require 'hat/type_key_resolver'
+
+module Hat
+
+  describe TypeKeyResolver do
+
+    let(:resolver) { TypeKeyResolver.new }
+
+    describe 'resolving class names' do
+
+      it 'correctly resolves the type key multiple times' do
+        expect(resolver.for_class(String)).to eq 'strings'
+        expect(resolver.for_class(String)).to eq 'strings'
+      end
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+
+require 'hat/support/spec_models'
+require 'hat/support/spec_sideloading_serializers'
+require 'hat/support/spec_nesting_serializers'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'rubygems'
+require 'pry'