render 0.0.2 → 0.0.3

data/spec/unit/render/schema_spec.rb

@@ -2,171 +2,151 @@ 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: {} }
+      describe "#definition" do
+        before(:all) do
+          @original_defs = Render.definitions
         end
 
-        it "is set to hash argument" do
-          Schema.new(@schema).schema.should == @schema
+        after(:all) do
+          Render.definitions = @original_defs
         end
 
-        it "is set to preloaded schema" do
-          Render.stub({ schemas: { film: @schema } })
-          Schema.new(:film).schema.should == @schema
+        it "is set from argument" do
+          schema_definition = { properties: {} }
+          Schema.new(schema_definition).definition.should == schema_definition
         end
 
-        it "raises an error if preloaded schema cannot be found" do
+        it "is set to preloaded definition" do
+          definition_title = :preloaded_schema
+          definition = { title: definition_title, properties: { title: { type: String } } }
+          Render.load_definition!(definition)
+          Schema.new(definition_title).definition.should == definition
+        end
+
+        it "raises an error if definition is not found and argument is not a schema" do
           expect {
-            Schema.new(:unloaded_schema)
-          }.to raise_error(Render::Errors::Schema::NotFound)
+            Schema.new(:does_not_exists)
+          }.to raise_error(Errors::DefinitionNotFound)
         end
       end
 
-      it "sets title from schema" do
-        title = "films"
-        schema = { title: title, attributes: {} }
-        Schema.new(schema).title.should == title
+      it "sets its type from schema" do
+        type = [Array, Object].sample
+        definition = { type: type, properties: {}, items: {} }
+        Schema.new(definition).type.should == type
       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
+      describe "#array_attribute" do
+        it "is set for array schemas" do
+          archetype_schema = {
+            type: Array,
+            items: {
+              type: String
+            }
+          }
 
-        it "is parsed from string" do
-          schema = { type: "string", attributes: {} }
-          Schema.new(schema).type.should == String
+          attribute = Schema.new(archetype_schema).array_attribute
+          attribute.type.should == String
+          attribute.archetype.should == true
         end
       end
 
-      describe "#attributes" do
-        it "is set with simple Attributes" do
+      describe "#hash_attributes" do
+        it "is set for object schemas" do
           simple_schema = {
-            attributes: {
+            properties: {
               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
+          schema.hash_attributes.size.should == 2
+          schema.hash_attributes.any? { |a| a.name == :name && a.type == String }.should == true
+          schema.hash_attributes.any? { |a| a.name == :genre && a.type == String }.should == true
         end
+      end
+    end
 
-        it "is set with array archetypes" do
-          archetype_schema = {
-            elements: {
-              type: String
-            }
+    describe "#serialize!" do
+      it "returns serialized array" do
+        definition = {
+          type: Array,
+          items: {
+            type: UUID
           }
+        }
+        schema = Schema.new(definition)
+        schema.array_attribute.should_receive(:serialize).with(nil).and_return([:data])
+        schema.serialize!.should == [:data]
+      end
 
-          attributes = Schema.new(archetype_schema).attributes
-          attributes.size.should == 1
-          attributes.first.type.should == String
-        end
+      it "returns serialized hash" do
+        definition = {
+          type: Object,
+          properties: {
+            title: { type: String }
+          }
+        }
+        schema = Schema.new(definition)
+        schema.hash_attributes.first.should_receive(:serialize).with(nil).and_return({ title: "foo" })
+        schema.serialize!.should == { title: "foo" }
+      end
+    end
 
-        it "is set with schema-Attributes" do
-          nested_schema = {
-            attributes: {
-              film: {
-                type: Object,
-                attributes: {
-                  name: { type: String }
-                }
-              }
-            }
+    describe "#render!" do
+      before(:all) do
+        @original_defs = Render.definitions
+        Render.load_definition!({
+          title: :film,
+          properties: {
+            genre: { type: String }
           }
+        })
+      end
 
-          schema = Schema.new(nested_schema)
-          schema.attributes.size.should == 1
-          schema.attributes.first.schema.should be
+      after(:all) do
+        Render.definitions = @original_defs
+      end
+
+      describe "#raw_data" do
+        it "is set from endpoint response" do
+          schema = Schema.new(:film)
+          schema.stub({ request: { response: :body } })
+          schema.render!
+          schema.raw_data.should == { response: :body }
         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
+        it "is set to explicit_data when offline" do
+          Render.stub({ live: false })
+          schema = Schema.new(:film)
+          schema.render!({ explicit: :value })
+          schema.raw_data.should == { explicit: :value }
         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)
+        it "is yielded" do
+          Render.stub({ live: false })
+          schema = Schema.new(:film)
+
+          data = { explicit: :value }
+          schema.should_receive(:serialize!).with(data)
+          schema.serialized_data = :serialized_data
 
-          film = Schema.new(@film_schema)
-          film.render({ endpoint: endpoint }).should == response_body
+          expect { |a_block|
+            schema.render!(data, &a_block)
+          }.to yield_with_args(:serialized_data)
         end
+      end
 
-        it "raises error if response is not 2xx" do
+      context "request" do
+        it "raises error if endpoint does not return a 2xx" do
           endpoint = "http://endpoint.local"
-          response = { status: 403, body: "OMGWTFBBQ" }
-          stub_request(:get, endpoint).to_return(response)
+          stub_request(:get, endpoint).to_return({ status: 403 })
 
           expect {
-            film = Schema.new(@film_schema)
-            film.render({ endpoint: endpoint })
+            schema = Schema.new(:film)
+            schema.render!({ endpoint: endpoint })
           }.to raise_error(Errors::Schema::RequestError)
         end
 
@@ -175,74 +155,38 @@ module Render
           stub_request(:get, endpoint).to_return({ body: "Server Error: 500" })
 
           expect {
-            Schema.new(@film_schema).render({ endpoint: endpoint })
+            Schema.new(:film).render!({ 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.render[:film]
-          film[:name].should be_a(String)
-          film[:genre].should be_a(String)
-        end
+        it "uses configured request logic"
       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.render({ endpoint: endpoint }).should == { film: response_body }
-      end
+      context "return value" do
+        it "is serialized data" do
+          endpoint = "http://endpoint.local"
+          genre = "The Shining"
+          data = { genre: genre }
+          response = { status: 200, body: data.to_json }
+          stub_request(:get, endpoint).to_return(response)
 
-      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.render({ endpoint: endpoint }).should == { films: response_body }
-      end
-    end
+          schema = Schema.new(:film)
+          schema.hash_attributes.first.should_receive(:serialize).with(genre).and_return({ genre: genre })
 
-    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
-          }]
-        }
+          schema.render!({ endpoint: endpoint }).should == { film: data }
+        end
 
-        director.serialize(data).should == {
-          films: [{
-            name: first_film,
-            year: year
-          }]
-        }
+        it "is serialized value nested under #universal_title" do
+          Render.stub({ live: false })
+          definition = {
+            title: :film,
+            universal_title: :imdb_films_show,
+            properties: {
+              genre: { type: String }
+            }
+          }
+          Schema.new(definition).render!.should have_key(:imdb_films_show)
+        end
       end
 
     end

data/spec/unit/render_spec.rb

@@ -26,6 +26,12 @@ describe Render do
       end
     end
 
+    describe "logger" do
+      it "exits" do
+        Render.logger.should be
+      end
+    end
+
     describe ".generators" do
       before(:each) do
         @original_value = Render.generators
@@ -41,40 +47,128 @@ describe Render do
       end
     end
 
-    describe ".load_schemas!" do
+    context "schema definitions" do
       before(:each) do
-        @schema_title = "film"
-        @json_schema = <<-JSON
+        @original_defs = Render.definitions
+      end
+
+      after(:each) do
+        Render.definitions = @original_defs
+      end
+
+      describe ".load_defintion!" do
+        it "preferences #universal_title over title" do
+          universal_title = "a_service_films_show"
+          definition = {
+            universal_title: universal_title,
+            title: "film",
+            type: Object,
+            properties: {
+              name: { type: String },
+              year: { type: Integer }
+            }
+          }
+
+          Render.load_definition!(definition)
+          Render.definitions.keys.should include(universal_title.to_sym)
+        end
+      end
+
+      describe ".load_schemas!" do
+        before(:each) do
+          Render.definitions.clear
+          @schema_title = "film"
+          @json_schema = <<-JSON
           {
             "title": "#{@schema_title}",
             "type": "object",
-            "attributes": {
+            "properties": {
               "name": { "type": "string" },
               "year": { "type": "integer" }
             }
           }
-        JSON
+          JSON
+
+          @directory = "/a"
+          @schema_file = "/a/schema.json"
+          Dir.stub(:glob).with(%r{#{@directory}}).and_return([@schema_file])
+          IO.stub(:read).with(@schema_file).and_return(@json_schema)
+        end
+
+        after(:each) do
+          Render.definitions = {}
+        end
+
+        it "stores JSON files" do
+          expect {
+            Render.load_definitions!(@directory)
+          }.to change { Render.definitions.keys.size }.by(1)
+        end
 
-        @directory = "/a"
-        @schema_file = "/a/schema.json"
-        Dir.stub(:glob).with(%r{#{@directory}}).and_return([@schema_file])
-        IO.stub(:read).with(@schema_file).and_return(@json_schema)
+        it "accesses parsed schemas with symbols" do
+          Render.load_definitions!(@directory)
+          parsed_json = JSON.parse(@json_schema).recursive_symbolize_keys!
+          Render.definitions[@schema_title.to_sym].should == parsed_json
+        end
       end
+    end
 
-      after(:each) do
-        Render.schemas = {}
+    describe ".definition" do
+      it "returns definition by its title" do
+        def_title = :the_name
+        definition = { title: def_title, properties: {} }
+        Render.load_definition!(definition)
+
+        Render.definition(def_title).should == definition
       end
 
-      it "stores JSON files" do
+      it "raises meaningful error if definition is not found" do
         expect {
-          Render.load_schemas!(@directory)
-        }.to change { Render.schemas.keys.size }.by(1)
+          Render.definition(:definition_with_this_title_has_not_been_loaded)
+        }.to raise_error(Render::Errors::DefinitionNotFound)
+      end
+    end
+
+    describe ".parse_type" do
+      it "returns constant for string" do
+        Render.parse_type("integer").should == Integer
+      end
+
+      it "returns argument when not a string" do
+        class Foo; end
+        Render.parse_type(Foo).should == Foo
+        Object.__send__(:remove_const, :Foo)
       end
 
-      it "accesses parsed schemas with symbols" do
-        Render.load_schemas!(@directory)
-        parsed_json = JSON.parse(@json_schema).recursive_symbolize_keys!
-        Render.schemas[@schema_title.to_sym].should == parsed_json
+      it "raises meaningful error for unmatched types" do
+        expect {
+          Render.parse_type("NotAClass")
+        }.to raise_error(Render::Errors::InvalidType)
+      end
+
+      describe "non-standard formats" do
+        it "maps regardless of capitalization" do
+          string_representations = %w(uuid UUID)
+          string_representations.each do |name|
+            Render.parse_type(name).should == UUID
+          end
+        end
+
+        it "returns UUID for uuid" do
+          Render.parse_type("uUId").should == UUID
+        end
+
+        it "returns Boolean for boolean" do
+          Render.parse_type("boolean").should == Boolean
+        end
+
+        it "returns Float for number" do
+          Render.parse_type("FloAt").should == Float
+        end
+
+        it "returns Time for date-time" do
+          Render.parse_type("date-time").should == Time
+        end
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: render
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-25 00:00:00.000000000 Z
+date: 2013-12-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -142,17 +142,20 @@ files:
 - lib/extensions/enumerable.rb
 - lib/extensions/hash.rb
 - lib/render.rb
+- lib/render/array_attribute.rb
 - lib/render/attribute.rb
 - lib/render/dottable_hash.rb
 - lib/render/errors.rb
 - lib/render/generator.rb
 - lib/render/graph.rb
+- lib/render/hash_attribute.rb
 - lib/render/schema.rb
 - lib/render/version.rb
 - rakefile.rb
 - readme.md
 - render.gemspec
 - spec/functional/representation/attribute_spec.rb
+- spec/functional/representation/graph_spec.rb
 - spec/functional/representation/nested_schemas_spec.rb
 - spec/functional/representation/schema_spec.rb
 - spec/integration/nested_graph_spec.rb
@@ -161,11 +164,12 @@ files:
 - spec/schemas/films.json
 - spec/support.rb
 - spec/support/helpers.rb
+- spec/unit/array_attribute_spec.rb
 - spec/unit/extensions/boolean_spec.rb
-- spec/unit/render/attribute_spec.rb
 - spec/unit/render/dottable_hash_spec.rb
 - spec/unit/render/generator_spec.rb
 - spec/unit/render/graph_spec.rb
+- spec/unit/render/hash_attribute_spec.rb
 - spec/unit/render/schema_spec.rb
 - spec/unit/render_spec.rb
 homepage: https://github.com/stevenweber/render
@@ -183,7 +187,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1123791212905751399
+      hash: 2584837128307883424
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -192,7 +196,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1123791212905751399
+      hash: 2584837128307883424
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.25
@@ -202,6 +206,7 @@ summary: With a JSON schema, Render will manage requests, dependent request and
   meaningful, extensible sample data for testing.
 test_files:
 - spec/functional/representation/attribute_spec.rb
+- spec/functional/representation/graph_spec.rb
 - spec/functional/representation/nested_schemas_spec.rb
 - spec/functional/representation/schema_spec.rb
 - spec/integration/nested_graph_spec.rb
@@ -210,10 +215,11 @@ test_files:
 - spec/schemas/films.json
 - spec/support.rb
 - spec/support/helpers.rb
+- spec/unit/array_attribute_spec.rb
 - spec/unit/extensions/boolean_spec.rb
-- spec/unit/render/attribute_spec.rb
 - spec/unit/render/dottable_hash_spec.rb
 - spec/unit/render/generator_spec.rb
 - spec/unit/render/graph_spec.rb
+- spec/unit/render/hash_attribute_spec.rb
 - spec/unit/render/schema_spec.rb
 - spec/unit/render_spec.rb