render 0.0.2 → 0.0.3

data/spec/unit/render/graph_spec.rb

@@ -5,35 +5,30 @@ require "uuid"
 module Render
   describe Graph do
     before(:each) do
+      Render.stub({ live: false })
+      @definition = double(:definition)
       @schema = double(:schema)
+      Schema.stub(:new).with(@definition).and_return(@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
+      describe "#schema" do
+        it "is set from argument" do
+          Schema.unstub(:new)
+          schema = Schema.new({ title: :foo, properties: { name: { type: String } } })
+          Graph.new(schema).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
+        it "is set to new Schema from definition" do
+          Schema.should_receive(:new).with(:title_or_definition).and_return(:schema)
+          Graph.new(:title_or_definition).schema.should == :schema
         end
       end
 
-      it "sets attributes" do
+      it "sets attributes from options" do
         relationships = { director_id: :id }
         graphs = [double(:graph)]
-        graph = Graph.new(@schema, {
+        graph = Graph.new(@definition, {
           relationships: relationships,
           graphs: graphs,
         })
@@ -42,80 +37,47 @@ module Render
         graph.graphs.should == graphs
       end
 
-      it "treats non-used attributes as config" do
+      it "sets config from options that are not attributes" do
         relationships = { some: :relationship }
-        graphs = [double(:some_graph)]
         client_id = UUID.generate
-        graph = Graph.new(@schema, {
+        graph = Graph.new(@definition, {
           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 = Graph.new(@definition, { endpoint: simple_endpoint })
         graph.endpoint.should == simple_endpoint
       end
 
-      it "interpolates parental_params" do
+      it "interpolates inherited parameters" 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(@definition, { endpoint: endpoint, relationships: relationships })
+        graph.inherited_data = { director_id: director_id }
 
-        graph = Graph.new(@schema, { endpoint: endpoint, client_id: client_id })
-        graph.endpoint.should == interpolated_endpoint
+        graph.endpoint.should == "http://endpoint.local/directors/#{director_id}"
       end
 
-      it "interpolates multiple path and query values" do
-        the_shinning = UUID.generate
-        kubrick = UUID.generate
+      it "interpolates config options" do
         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 }
+        endpoint = "http://endpoint.local/?:client_id"
 
-        graph.endpoint.should == interpolated_endpoint
+        graph = Graph.new(@definition, { endpoint: endpoint, client_id: client_id })
+        graph.endpoint.should == "http://endpoint.local/?client_id=#{client_id}"
       end
 
       it "raises an error if no value can be found" do
         endpoint = "http://endpoint.com/?:undefined_key"
-        graph = Graph.new(@schema, { endpoint: endpoint })
+        graph = Graph.new(@definition, { endpoint: endpoint })
 
         expect {
           graph.endpoint
@@ -125,88 +87,122 @@ module Render
 
     describe "#render" do
       it "returns its schema's data" do
-        pull = { film: { id: UUID.generate } }
-        @schema.stub({ render: pull })
+        serialized_data = { id: UUID.generate }
+        pull = { film: serialized_data }
+        @schema.stub({ render!: pull, serialized_data: serialized_data })
 
-        graph = Graph.new(@schema)
+        graph = Graph.new(@definition)
         graph.render.should == pull
       end
 
       it "returns a dottable hash" do
         pull = { film: { id: UUID.generate } }
-        @schema.stub({ render: pull })
+        @schema.stub({ render!: pull })
 
-        graph = Graph.new(@schema)
+        graph = Graph.new(@definition)
         graph.render.should be_a(DottableHash)
       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 })
+        graph = Graph.new(@definition, { endpoint: endpoint, client_id: client_id })
 
-        pull = { foo: "bar" }
-        @schema.should_receive(:render).with({ endpoint: graph.endpoint }).and_return(pull)
-        graph.render.should == pull
+        @schema.should_receive(:render!).with({ endpoint: graph.endpoint }).and_return({})
+        graph.render
       end
 
       context "with nested graphs" do
         before(:each) do
-          Render.stub({ live: false })
-
-          director_schema = {
-            title: "director",
+          Schema.unstub(:new)
+          film_definition = {
+            title: "film",
             type: Object,
-            attributes: { id: { type: UUID } }
+            properties: { director_id: { type: UUID } }
           }
-          @director_schema = Schema.new(director_schema)
+          @film_schema = Schema.new(film_definition)
 
-          film_schema = {
-            title: "film",
+          @director_id = UUID.generate
+          director_definition = {
+            title: "director",
             type: Object,
-            attributes: { director_id: { type: UUID } }
+            properties: { id: { type: UUID } }
           }
-          @film_schema = Schema.new(film_schema)
+          @director_schema = Schema.new(director_definition)
         end
 
-        it "merges nested graphs" do
-          pulled_data = { a: "attribute" }
-          @director_schema.stub({ render: pulled_data })
-
-          director = Graph.new(@director_schema)
-          film = Graph.new(@film_schema, { graphs: [director]})
-
-          film_graph = film.render[@film_schema.title.to_sym]
-          film_graph.should include(pulled_data)
+        it "includes nested graphs" do
+          film = Graph.new(@film_schema, { graphs: [Graph.new(@director_schema)] })
+          film = film.render
+          film.keys.should =~ [:film, :director]
         end
 
         it "uses parent data to calculate endpoint" do
-          director_id = UUID.generate
           film = Graph.new(@film_schema)
-          film.schema.stub({ render: { 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 })
+          endpoint = "http://endpoint.local/directors/:id"
+          film.graphs << Graph.new(@director_schema, { endpoint: endpoint, relationships: relationships })
 
-          film.graphs << director
-          director.schema.should_receive(:render).with do |args|
-            args[:endpoint].should == interpolated_endpoint
-          end.and_return({})
+          film_data = { director_id: @director_id }
+          @film_schema.should_receive(:render!).and_yield(film_data).and_return(film_data)
 
+          @director_schema.should_receive(:render!).with do |args|
+            args[:endpoint].should == "http://endpoint.local/directors/#{@director_id}"
+          end.and_return({})
           film.render
         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]})
+        it "uses parent data to make multiple queries" do
+          films_schema = Schema.new({
+            title: "films",
+            type: Array,
+            items: {
+              properties: {
+                id: { type: UUID }
+              }
+            }
+          })
+
+          film_graph = Graph.new(@film_schema, { relationships: { id: :director_id } })
+          films = Graph.new(films_schema, { graphs: [film_graph] })
+
+          first_film_id = UUID.generate
+          second_film_id = UUID.generate
+          films_response = [{ id: first_film_id }, { id: second_film_id }]
+          films_schema.should_receive(:render!).and_yield(films_response).and_return({ films: films_response })
+
+          response = films.render
+          response.film.should be_a(Array)
+          response.film.should =~ [{ director_id: first_film_id }, { director_id: second_film_id }]
+        end
+
+        it "uses parent data for childrens' properties when explicitly used" do
+          director = Graph.new(@director_schema, { relationships: { director_id: :id } })
+          film = Graph.new(@film_schema, { graphs: [director] })
+          @film_schema.should_receive(:render!).and_yield({ director_id: @director_id }).and_return({})
+
+          film.render.director.id.should == @director_id
+        end
 
-            film_graph = film.render[@film_schema.title.to_sym]
-            film_graph[@director_schema.title.to_sym][:id].should == film_graph[:director_id]
-          end
+        it "uses archetype parental data" do
+          films_schema = Schema.new({
+            title: "films",
+            type: Array,
+            items: {
+              type: UUID
+            }
+          })
+
+          film_graph = Graph.new(@film_schema, { relationships: { anything: :director_id } })
+          films = Graph.new(films_schema, { graphs: [film_graph] })
+
+          film_id = UUID.generate
+          films_response = [film_id]
+          films_schema.should_receive(:render!).and_yield(films_response).and_return({ films: films_response })
+
+          response = films.render
+          response.film.should be_a(Array)
+          response.film.should =~ [{ director_id: film_id }]
         end
       end
     end

data/spec/unit/render/hash_attribute_spec.rb

@@ -0,0 +1,130 @@
+module Render
+  describe HashAttribute do
+    describe "#initialize" do
+      describe "#name" do
+        it "is set from options key" do
+          options = { id: { type: UUID } }
+          HashAttribute.new(options).name.should == :id
+        end
+      end
+
+      describe "#type" do
+        it "is set from options" do
+          type = Integer
+          attribute = HashAttribute.new({ key_name: { type: type } })
+          attribute.type.should == type
+        end
+
+        it "is set from name hash" do
+          type = String
+          attribute = HashAttribute.new({ id: { type: UUID } })
+          attribute.type.should == UUID
+        end
+
+        it "determines type from string" do
+          HashAttribute.new({ key_name: { type: "string" } }).type.should == String
+        end
+      end
+
+      describe "#format" do
+        it "is set from options" do
+          HashAttribute.new({ key_name: { type: String, format: UUID } }).format.should == UUID
+        end
+
+        it "is nil for indeterminable types" do
+          HashAttribute.new({ key_name: { type: String, format: "random-iso-format" } }).format.should == nil
+        end
+      end
+
+      describe "#schema" do
+        it "is set to nil if its a regular attribute" do
+          HashAttribute.new({ id: { type: UUID } }).schema.should == nil
+        end
+
+        it "is initiazed from options" do
+          options = {
+            film: {
+              type: Object,
+              properties: {
+                year: { type: Integer }
+              }
+            }
+          }
+
+          schema = HashAttribute.new(options).schema
+          schema.title.should == :film
+          schema.type.should == Object
+          hash_attributes = schema.hash_attributes
+          hash_attributes.size.should == 1
+          attribute = hash_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 = HashAttribute.new({ key: { type: String, enum: enum_values } })
+          attribute.enums.should == enum_values
+        end
+      end
+    end
+
+    describe "#serialize" do
+      it "returns attribute with its value" do
+        attribute = HashAttribute.new({ title: { type: String } })
+        title = "the title"
+        attribute.serialize(title).should == { title: title }
+      end
+
+      describe "nested schema" do
+        it "returns serialized schema" do
+          attribute = HashAttribute.new({ film: { type: Object, properties: { title: { type: String } } } })
+          title = "the title"
+          attribute.serialize({ title: title }).should == { film: { title: title } }
+        end
+      end
+
+      it "uses faux data when offline" do
+        type = [String, Integer].sample
+        Render.stub({ live: false })
+
+        data = HashAttribute.new({ title: { type: type } }).serialize(nil)
+        data[:title].should be_a(type)
+      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|
+            HashAttribute.new({ key: { type: klass } }).default_value.should be_a(klass)
+          end
+          UUID.validate(HashAttribute.new({ key: { type: UUID } }).default_value).should be_true
+        end
+
+        it "generates value from enum" do
+          enums = ["horror", "comedy", "drama"]
+          attribute = HashAttribute.new({ genre: { enum: enums, type: String } })
+          enums.should include(attribute.default_value)
+        end
+      end
+    end
+
+  end
+end