render 0.0.1

data/spec/support.rb

@@ -0,0 +1,7 @@
+require File.expand_path("../../initialize", __FILE__)
+require "webmock/rspec"
+require "support/helpers"
+
+RSpec.configure do |config|
+  #
+end

data/spec/unit/extensions/boolean_spec.rb

@@ -0,0 +1,7 @@
+require "extensions/boolean"
+
+describe Boolean do
+  it "exists" do
+    expect { Boolean }.to_not raise_error
+  end
+end

data/spec/unit/render/attribute_spec.rb

@@ -0,0 +1,128 @@
+module Render
+  describe Attribute do
+    describe "#initialize" do
+      describe "#name" do
+        it "is set from options key" do
+          options = { id: { type: UUID } }
+          Attribute.new(options).name.should == :id
+        end
+      end
+
+      describe "#type" do
+        it "is set from options" do
+          type = Integer
+          attribute = Attribute.new({ type: type })
+          attribute.type.should == type
+        end
+
+        it "is set from name hash" do
+          type = String
+          attribute = Attribute.new({ id: { type: UUID } })
+          attribute.type.should == UUID
+        end
+
+        it "determines type from string" do
+          Attribute.new({ type: "string" }).type.should == String
+        end
+      end
+
+      describe "#schema" do
+        it "is set to nil if its a regular attribute" do
+          Attribute.new({ id: { type: UUID } }).schema.should == nil
+        end
+
+        it "is initiazed from options" do
+          options = {
+            film: {
+              type: Object,
+              attributes: {
+                year: { type: Integer }
+              }
+            }
+          }
+
+          schema = Attribute.new(options).schema
+          schema.title.should == :film
+          schema.type.should == Object
+          attributes = schema.attributes
+          attributes.size.should == 1
+          attribute = attributes.first
+          attribute.name.should == :year
+          attribute.type.should == Integer
+        end
+      end
+
+      context "enums" do
+        it "sets enum values" do
+          enum_values = ["foo", "bar", "baz"]
+          attribute = Attribute.new({ type: String, enum: enum_values })
+          attribute.enums.should == enum_values
+        end
+      end
+    end
+
+    describe "#to_hash" do
+      it "converts attributes to hashes" do
+        attributes = { foo: { type: String } }
+        attribute = Attribute.new(attributes)
+        attribute.to_hash.should == { foo: nil }
+      end
+
+      it "converts attributes to hashes with values" do
+        attributes = { foo: { type: String } }
+        attribute = Attribute.new(attributes)
+        attribute.to_hash("bar").should == { foo: "bar" }
+      end
+
+      it "converts schema values to hashes" do
+        schema_name = "foo"
+        attributes = {
+          schema_name => {
+            type: Object,
+            attributes: {
+              attribute: { type: String }
+            }
+          }
+        }
+
+        value = "baz"
+        data = { attribute: value }
+
+        attribute = Attribute.new(attributes)
+        attribute.to_hash(data).should == { foo: { :attribute => value } }
+      end
+    end
+
+    describe "#value" do
+      context "offline mode" do
+        before(:all) do
+          @original_live = Render.live
+          Render.live = false
+        end
+
+        after(:all) do
+          Render.live = @original_live
+        end
+
+        it "generate value based on type" do
+          supported_classes = [
+            String,
+            Integer
+          ]
+
+          supported_classes.each do |klass|
+            Attribute.new({ type: klass }).default_value.should be_a(klass)
+          end
+          UUID.validate(Attribute.new({ type: UUID }).default_value).should be_true
+        end
+
+        it "generates value from enum" do
+          enums = ["horror", "comedy", "drama"]
+          attribute = Attribute.new({ genre: { enum: enums, type: String } })
+          enums.should include(attribute.default_value)
+        end
+      end
+    end
+
+  end
+end

data/spec/unit/render/generator_spec.rb

@@ -0,0 +1,39 @@
+require "render/generator"
+
+module Render
+  describe Generator do
+    it "exists" do
+      expect { Generator }.to_not raise_error
+    end
+
+    describe "attributes" do
+      before(:each) do
+        @mandatory_options = { algorithm: proc {} }
+      end
+
+      it "is a type-specific generator for flexibility" do
+        Generator.new(@mandatory_options.merge({ type: String })).type.should == String
+      end
+
+      it "has a matcher to only be used on specific attributes" do
+        matcher = %r{.*name.*}
+        Generator.new(@mandatory_options.merge({ matcher: matcher })).matcher.should == matcher
+      end
+
+      describe "#algorith" do
+        it "has an algorithm that generates a value to be used" do
+          algorithm = lambda { "The Darjeeling limited" }
+          Generator.new({ algorithm: algorithm }).algorithm.should == algorithm
+        end
+
+        it "raises an error if algorithm does not respond to call" do
+          expect {
+            Generator.new({ algorithm: "want this to be the fake value" })
+          }.to raise_error(Errors::Generator::MalformedAlgorithm)
+        end
+      end
+    end
+
+  end
+
+end

data/spec/unit/render/graph_spec.rb

@@ -0,0 +1,205 @@
+# encoding: utf-8
+require "render/graph"
+require "uuid"
+
+module Render
+  describe Graph do
+    before(:each) do
+      @schema = double(:schema)
+    end
+
+    describe ".initialize" do
+      it "has defaults" do
+        graph = Graph.new(@schema)
+        graph.raw_endpoint.should == ""
+        graph.relationships.should == {}
+        graph.graphs.should == []
+        graph.parental_params.should == {}
+        graph.config.should == {}
+      end
+
+      describe "schema" do
+        it "sets argument" do
+          graph = Graph.new(@schema)
+          graph.schema.should == @schema
+        end
+
+        it "creates new schema from symbol (for loaded schema lookup)" do
+          Schema.should_receive(:new).with(:film).and_return(:new_schema)
+          Graph.new(:film).schema.should == :new_schema
+        end
+      end
+
+      it "sets attributes" do
+        relationships = { director_id: :id }
+        graphs = [double(:graph)]
+        graph = Graph.new(@schema, {
+          relationships: relationships,
+          graphs: graphs,
+        })
+
+        graph.relationships.should == relationships
+        graph.graphs.should == graphs
+      end
+
+      it "treats non-used attributes as config" do
+        relationships = { some: :relationship }
+        graphs = [double(:some_graph)]
+        client_id = UUID.generate
+        graph = Graph.new(@schema, {
+          relationships: relationships,
+          graphs: graphs,
+          client_id: client_id
+        })
+
+        graph.config.should == { client_id: client_id }
+      end
+
+      describe "#raw_endpoint" do
+        it "is set with endpoint" do
+          endpoint = "http://endpoint.local"
+          graph = Graph.new(@schema, { endpoint: endpoint })
+          graph.raw_endpoint.should == endpoint
+        end
+      end
+
+      it "initializes params from endpoint" do
+        endpoint = "http://endpoint.local/:id?client_id=:client_id"
+        graph = Graph.new(@schema, { endpoint: endpoint })
+        graph.params.should == { id: nil, client_id: nil }
+      end
+    end
+
+    describe ".endpoint" do
+      it "returns #raw_endpoint" do
+        simple_endpoint = "http://endpoint.local"
+        graph = Graph.new(@schema, { endpoint: simple_endpoint })
+        graph.endpoint.should == simple_endpoint
+      end
+
+      it "interpolates parental_params" do
+        director_id = UUID.generate
+        endpoint = "http://endpoint.local/directors/:id"
+        interpolated_endpoint = "http://endpoint.local/directors/#{director_id}"
+
+        relationships = { director_id: :id }
+        graph = Graph.new(@schema, { endpoint: endpoint, relationships: relationships })
+        graph.parental_params[:id] = director_id
+
+        graph.endpoint.should == interpolated_endpoint
+      end
+
+      it "interpolates config attributes" do
+        client_id = UUID.generate
+        endpoint = "http://endpoint.local/?:client_id"
+        interpolated_endpoint = "http://endpoint.local/?client_id=#{client_id}"
+
+        graph = Graph.new(@schema, { endpoint: endpoint, client_id: client_id })
+        graph.endpoint.should == interpolated_endpoint
+      end
+
+      it "interpolates multiple path and query values" do
+        the_shinning = UUID.generate
+        kubrick = UUID.generate
+        client_id = UUID.generate
+        client_secret = UUID.generate
+
+        endpoint = "http://endpoint.local/directors/:id/films/:film_id?:client_id&:client_secret"
+        interpolated_endpoint = "http://endpoint.local/directors/#{kubrick}/films/#{the_shinning}?client_id=#{client_id}&client_secret=#{client_secret}"
+
+        graph = Graph.new(@schema, { endpoint: endpoint, client_id: client_id, client_secret: client_secret })
+        graph.parental_params = { id: kubrick, film_id: the_shinning }
+
+        graph.endpoint.should == interpolated_endpoint
+      end
+
+      it "raises an error if no value can be found" do
+        endpoint = "http://endpoint.com/?:undefined_key"
+        graph = Graph.new(@schema, { endpoint: endpoint })
+
+        expect {
+          graph.endpoint
+        }.to raise_error(Errors::Graph::EndpointKeyNotFound)
+      end
+    end
+
+    describe ".pull" do
+      it "returns its schema's data" do
+        pull = { film: { id: UUID.generate } }
+        @schema.stub({ pull: pull })
+
+        graph = Graph.new(@schema)
+        graph.pull.should == pull
+      end
+
+      it "sends interpolated endpoint to its schema" do
+        endpoint = "http://endpoint.local/?:client_id"
+        client_id = UUID.generate
+        graph = Graph.new(@schema, { endpoint: endpoint, client_id: client_id })
+
+        @schema.should_receive(:pull).with({ endpoint: graph.endpoint }).and_return(@pull)
+        graph.pull.should == @pull
+      end
+
+      context "with nested graphs" do
+        before(:each) do
+          Render.stub({ live: false })
+
+          director_schema = {
+            title: "director",
+            type: Object,
+            attributes: { id: { type: UUID } }
+          }
+          @director_schema = Schema.new(director_schema)
+
+          film_schema = {
+            title: "film",
+            type: Object,
+            attributes: { director_id: { type: UUID } }
+          }
+          @film_schema = Schema.new(film_schema)
+        end
+
+        it "merges nested graphs" do
+          pulled_data = { a: "attribute" }
+          @director_schema.stub({ pull: pulled_data })
+
+          director = Graph.new(@director_schema)
+          film = Graph.new(@film_schema, { graphs: [director]})
+
+          film_graph = film.pull[@film_schema.title.to_sym]
+          film_graph.should include(pulled_data)
+        end
+
+        it "uses parent data to calculate endpoint" do
+          director_id = UUID.generate
+          film = Graph.new(@film_schema)
+          film.schema.stub({ pull: { film: { director_id: director_id } } })
+
+          endpoint = "http://endpoint.local/directors/:id"
+          interpolated_endpoint = "http://endpoint.local/directors/#{director_id}"
+          relationships = { director_id: :id }
+          director = Graph.new(@director_schema, { endpoint: endpoint, relationships: relationships })
+
+          film.graphs << director
+          director.schema.should_receive(:pull).with do |args|
+            args[:endpoint].should == interpolated_endpoint
+          end.and_return({})
+
+          film.pull
+        end
+
+        context "offline" do
+          it "uses parent data for childrens attributes" do
+            relationships = { director_id: :id }
+            director = Graph.new(@director_schema, { relationships: relationships })
+            film = Graph.new(@film_schema, { graphs: [director]})
+
+            film_graph = film.pull[@film_schema.title.to_sym]
+            film_graph[@director_schema.title.to_sym][:id].should == film_graph[:director_id]
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/render/schema_spec.rb

@@ -0,0 +1,250 @@
+require "render"
+
+module Render
+  describe Schema do
+    before(:each) do
+      @film_schema = {
+        title: "film",
+        type: Object,
+        attributes: {
+          name: { type: String },
+          genre: { type: String }
+        }
+      }
+
+      @films_schema = {
+        title: "films",
+        type: Array,
+        elements: {
+          title: :film,
+          attributes: {
+            name: { type: String },
+            genre: { type: String }
+          }
+        }
+      }
+
+      @director_schema = {
+        title: "director",
+        type: Object,
+        attributes: {
+          films: {
+            type: Array,
+            elements: {
+              type: Object,
+              attributes: {
+                name: { type: String },
+                year: { type: Integer }
+              }
+            }
+          }
+        }
+      }
+    end
+
+    describe "#initialize" do
+      describe "#schema" do
+        before(:each) do
+          @schema = { attributes: {} }
+        end
+
+        it "is set to hash argument" do
+          Schema.new(@schema).schema.should == @schema
+        end
+
+        it "is set to preloaded schema" do
+          Render.stub({ schemas: { film: @schema } })
+          Schema.new(:film).schema.should == @schema
+        end
+
+        it "raises an error if preloaded schema cannot be found" do
+          expect {
+            Schema.new(:unloaded_schema)
+          }.to raise_error(Render::Errors::Schema::NotFound)
+        end
+      end
+
+      it "sets title from schema" do
+        title = "films"
+        schema = { title: title, attributes: {} }
+        Schema.new(schema).title.should == title
+      end
+
+      describe "#type" do
+        it "is set from schema" do
+          type = [Array, Object].sample
+          schema = { type: type, attributes: {} }
+          Schema.new(schema).type.should == type
+        end
+
+        it "is parsed from string" do
+          schema = { type: "string", attributes: {} }
+          Schema.new(schema).type.should == String
+        end
+      end
+
+      describe "#attributes" do
+        it "is set with simple Attributes" do
+          simple_schema = {
+            attributes: {
+              name: { type: String },
+              genre: { type: String }
+            }
+          }
+
+          schema = Schema.new(simple_schema)
+          schema.attributes.size.should == 2
+          schema.attributes.any? { |a| a.name == :name && a.type == String }.should == true
+          schema.attributes.any? { |a| a.name == :genre && a.type == String }.should == true
+        end
+
+        it "is set with array archetypes" do
+          archetype_schema = {
+            elements: {
+              type: String
+            }
+          }
+
+          attributes = Schema.new(archetype_schema).attributes
+          attributes.size.should == 1
+          attributes.first.type.should == String
+        end
+
+        it "is set with schema-Attributes" do
+          nested_schema = {
+            attributes: {
+              film: {
+                type: Object,
+                attributes: {
+                  name: { type: String }
+                }
+              }
+            }
+          }
+
+          schema = Schema.new(nested_schema)
+          schema.attributes.size.should == 1
+          schema.attributes.first.schema.should be
+        end
+
+        it "is set with array-Attributes" do
+          array_schema = {
+            elements: {
+              film: {
+                type: Object,
+                attributes: {
+                  name: { type: String }
+                }
+              }
+            }
+          }
+          schema = Schema.new(array_schema)
+          schema.attributes.size.should == 1
+          schema.attributes.first.schema.should be
+        end
+      end
+    end
+
+    describe "#pull" do
+      context "live" do
+        it "returns schema with values from endpoint" do
+          endpoint = "http://endpoint.local"
+          name = "The Shining"
+          genre = "Horror"
+          response_body = { film: { name: name, genre: genre } }
+          response = { status: 200, body: response_body.to_json }
+          stub_request(:get, endpoint).to_return(response)
+
+          film = Schema.new(@film_schema)
+          film.pull({ endpoint: endpoint }).should == response_body
+        end
+
+        it "raises error if response is not 2xx" do
+          endpoint = "http://endpoint.local"
+          response = { status: 403, body: "OMGWTFBBQ" }
+          stub_request(:get, endpoint).to_return(response)
+
+          expect {
+            film = Schema.new(@film_schema)
+            film.pull({ endpoint: endpoint })
+          }.to raise_error(Errors::Schema::RequestError)
+        end
+
+        it "returns meaningful error when response contains invalid JSON" do
+          endpoint = "http://enpoint.local"
+          stub_request(:get, endpoint).to_return({ body: "Server Error: 500" })
+
+          expect {
+            Schema.new(@film_schema).pull({ endpoint: endpoint })
+          }.to raise_error(Errors::Schema::InvalidResponse)
+        end
+      end
+
+      context "faked" do
+        before(:each) do
+          Render.stub({ live: false })
+        end
+
+        it "returns schema with fake values" do
+          film = Schema.new(@film_schema)
+          film = film.pull[:film]
+          film[:name].should be_a(String)
+          film[:genre].should be_a(String)
+        end
+      end
+
+      it "handles responses that do not use schema title as root key" do
+        endpoint = "http://endpoint.local"
+        response_body = { name: "the name", genre: "the genre" }
+        response = { status: 200, body: response_body.to_json }
+        stub_request(:get, endpoint).to_return(response)
+
+        film = Schema.new(@film_schema)
+        film.pull({ endpoint: endpoint }).should == { film: response_body }
+      end
+
+      it "handles Array responses" do
+        endpoint = "http://endpoint.local"
+        first_name = "The Shining"
+        second_name = "Eyes Wide Shut"
+        genre = "Horror"
+
+        response_body = [
+          { name: first_name, genre: genre },
+          { name: second_name, genre: genre }
+        ]
+        response = { status: 200, body: response_body.to_json }
+        stub_request(:get, endpoint).to_return(response)
+
+        film = Schema.new(@films_schema)
+        film.pull({ endpoint: endpoint }).should == { films: response_body }
+      end
+    end
+
+    describe "#serialize" do
+      it "returns parsed array elements" do
+        Render.stub({ live: false })
+        director = Schema.new(@director_schema)
+
+        kubrick = "Stanley Kubrick"
+        first_film = "Flying Padre: An RKO-Pathe Screenliner"
+        year = 1951
+        data = {
+          films: [{
+              name: first_film,
+              notInSchema: "experimental",
+              year: year
+          }]
+        }
+
+        director.serialize(data).should == {
+          films: [{
+            name: first_film,
+            year: year
+          }]
+        }
+      end
+
+    end
+  end
+end