render 0.0.4 → 0.0.5

data/spec/unit/render/extensions/symbolizable_array_spec.rb

@@ -0,0 +1,20 @@
+require "render/extensions/symbolizable_array"
+
+module Render
+  module Extensions
+    describe SymbolizableArray do
+      describe "#initialize" do
+        it "recursively casts Hashes as DottableHashes" do
+          result = SymbolizableArray.new([{ "a" => :b }])
+          result.first.should be_a(DottableHash)
+        end
+
+        it "recursively casts Arrays as SymbolizableArrays" do
+          result = SymbolizableArray.new([[1]])
+          result.first.should be_a(SymbolizableArray)
+        end
+
+      end
+    end
+  end
+end

data/spec/unit/render/generator_spec.rb

@@ -2,38 +2,60 @@ require "render/generator"
 
 module Render
   describe Generator do
-    it "exists" do
-      expect { Generator }.to_not raise_error
+    before(:each) do
+      @original_generators = Generator.instances.dup
     end
 
-    describe "properties" do
-      before(:each) do
-        @mandatory_options = { algorithm: proc {} }
+    after(:each) do
+      Generator.instances = @original_generators
+    end
+
+    describe ".create!" do
+      it "adds generator to Render" do
+        expect {
+          Generator.create!(UUID, /id/i, lambda { UUID.generate })
+        }.to change { Generator.instances.size }.by(1)
+      end
+
+      it "preferences newer generators" do
+        Generator.instances.clear
+
+        first_generator = Generator.create!(String, /.*/, proc { "first" })
+        second_generator = Generator.create!(String, /.*/, proc { "second" })
+        Generator.find(String, :anything).trigger.should == second_generator.trigger
       end
+    end
 
-      it "is a type-specific generator for flexibility" do
-        Generator.new(@mandatory_options.merge({ type: String })).type.should == String
+    describe "#initialize" do
+      it "sets the type of data it can be used to generate data for" do
+        type = [UUID, Float].sample
+        Generator.new(type, nil, proc {}).type.should == type
       end
 
-      it "has a matcher to only be used on specific properties" do
-        matcher = %r{.*name.*}
-        Generator.new(@mandatory_options.merge({ matcher: matcher })).matcher.should == matcher
+      it "sets a matcher to classify what attribute-name(s) it should be used for" do
+        matcher = %r{film_title.*}i
+        Generator.new(String, matcher, proc {}).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
+      it "sets an algorithm to be used to generate values" do
+        algorithm = lambda { UUID.generate }
+        Generator.new(UUID, //, algorithm).algorithm.should == algorithm
+      end
+
+      it "guarantees algorithm responds to #call for real-time value generation" do
+        algorithm = UUID.generate
+        expect {
+          Generator.new(UUID, //, algorithm)
+        }.to raise_error(Errors::Generator::MalformedAlgorithm)
       end
     end
 
+    describe "#trigger" do
+      it "calls algorithm" do
+        x = "foo"
+        algorithm = proc { |y| "algorithm called with #{y}" }
+        Generator.new(UUID, //, algorithm).trigger(x).should == algorithm.call(x)
+      end
+    end
   end
-
 end

data/spec/unit/render/graph_spec.rb

@@ -6,8 +6,8 @@ module Render
   describe Graph do
     before(:each) do
       Render.stub({ live: false })
-      @definition = double(:definition)
-      @schema = double(:schema, { type: Hash })
+      @definition = double(:definition, { :[] => nil })
+      @schema = double(:schema, { type: Hash, definition: @definition })
       Schema.stub(:new).with(@definition).and_return(@schema)
     end
 
@@ -20,8 +20,8 @@ module Render
         end
 
         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
+          Schema.should_receive(:new).with(:title_or_definition).and_return(@schema)
+          Graph.new(:title_or_definition).schema.should == @schema
         end
       end
 
@@ -49,11 +49,11 @@ module Render
       end
     end
 
-    describe ".endpoint" do
+    describe ".send(:endpoint)" do
       it "returns #raw_endpoint" do
         simple_endpoint = "http://endpoint.local"
         graph = Graph.new(@definition, { endpoint: simple_endpoint })
-        graph.endpoint.should == simple_endpoint
+        graph.send(:endpoint).should == simple_endpoint
       end
 
       it "interpolates inherited parameters" do
@@ -64,7 +64,7 @@ module Render
         graph = Graph.new(@definition, { endpoint: endpoint, relationships: relationships })
         graph.inherited_data = { director_id: director_id }
 
-        graph.endpoint.should == "http://endpoint.local/directors/#{director_id}"
+        graph.send(:endpoint).should == "http://endpoint.local/directors/#{director_id}"
       end
 
       it "interpolates config options" do
@@ -72,7 +72,7 @@ module Render
         endpoint = "http://endpoint.local/?:client_id"
 
         graph = Graph.new(@definition, { endpoint: endpoint, client_id: client_id })
-        graph.endpoint.should == "http://endpoint.local/?client_id=#{client_id}"
+        graph.send(:endpoint).should == "http://endpoint.local/?client_id=#{client_id}"
       end
 
       it "raises an error if no value can be found" do
@@ -80,7 +80,7 @@ module Render
         graph = Graph.new(@definition, { endpoint: endpoint })
 
         expect {
-          graph.endpoint
+          graph.send(:endpoint)
         }.to raise_error(Errors::Graph::EndpointKeyNotFound)
       end
     end
@@ -92,7 +92,7 @@ module Render
         @schema.stub({ render!: pull, serialized_data: serialized_data })
 
         graph = Graph.new(@definition)
-        graph.render.should == pull
+        graph.render!.should == pull
       end
 
       it "returns a dottable hash" do
@@ -100,7 +100,7 @@ module Render
         @schema.stub({ render!: pull })
 
         graph = Graph.new(@definition)
-        graph.render.should be_a(DottableHash)
+        graph.render!.should be_a(Extensions::DottableHash)
       end
 
       it "sends interpolated endpoint to its schema" do
@@ -108,8 +108,8 @@ module Render
         client_id = UUID.generate
         graph = Graph.new(@definition, { endpoint: endpoint, client_id: client_id })
 
-        @schema.should_receive(:render!).with(anything, graph.endpoint).and_return({})
-        graph.render
+        @schema.should_receive(:render!).with(anything, graph.send(:endpoint)).and_return({})
+        graph.render!
       end
 
       context "with nested graphs" do
@@ -133,7 +133,7 @@ module Render
 
         it "includes nested graphs" do
           film = Graph.new(@film_schema, { graphs: [Graph.new(@director_schema)] })
-          film = film.render
+          film = film.render!
           film.keys.should =~ [:film, :director]
         end
 
@@ -148,7 +148,7 @@ module Render
 
           endpoint = "http://endpoint.local/directors/#{@director_id}"
           @director_schema.should_receive(:render!).with(anything, endpoint).and_return({})
-          film.render
+          film.render!
         end
 
         it "uses parent data to make multiple queries" do
@@ -170,7 +170,7 @@ module Render
           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 = films.render!
           response.film.should be_a(Array)
           response.film.should =~ [{ director_id: first_film_id }, { director_id: second_film_id }]
         end
@@ -180,7 +180,7 @@ module Render
           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
+          film.render!.director.id.should == @director_id
         end
 
         it "uses archetype parental data" do
@@ -199,7 +199,7 @@ module Render
           films_response = [film_id]
           films_schema.should_receive(:render!).and_yield(films_response).and_return({ films: films_response })
 
-          response = films.render
+          response = films.render!
           response.film.should be_a(Array)
           response.film.should =~ [{ director_id: film_id }]
         end

data/spec/unit/render/schema_spec.rb

@@ -2,16 +2,16 @@ require "render"
 
 module Render
   describe Schema do
-    describe "#initialize" do
-      describe "#definition" do
-        before(:all) do
-          @original_defs = Render.definitions
-        end
+    before(:each) do
+      @original_defs = Definition.instances.dup
+    end
 
-        after(:all) do
-          Render.definitions = @original_defs
-        end
+    after(:each) do
+      Definition.instances = @original_defs
+    end
 
+    describe "#initialize" do
+      describe "#definition" do
         it "is set from argument" do
           schema_definition = { properties: {} }
           Schema.new(schema_definition).definition.should == schema_definition
@@ -20,7 +20,7 @@ module Render
         it "is set to preloaded definition" do
           definition_title = :preloaded_schema
           definition = { title: definition_title, properties: { title: { type: String } } }
-          Render.load_definition!(definition)
+          Definition.load!(definition)
           Schema.new(definition_title).definition.should == definition
         end
 
@@ -96,9 +96,8 @@ module Render
     end
 
     describe "#render!" do
-      before(:all) do
-        @original_defs = Render.definitions
-        Render.load_definition!({
+      before(:each) do
+        Definition.load!({
           title: :film,
           properties: {
             genre: { type: String }
@@ -106,10 +105,6 @@ module Render
         })
       end
 
-      after(:all) do
-        Render.definitions = @original_defs
-      end
-
       describe "#raw_data" do
         it "is set from endpoint response" do
           schema = Schema.new(:film)

data/spec/unit/render/type_spec.rb

@@ -0,0 +1,83 @@
+require "render/type"
+
+module Render
+  describe Type do
+    before(:each) do
+      @original_types = Type.instances.dup
+    end
+
+    after(:each) do
+      Type.instances = @original_types
+    end
+
+    describe ".parse" do
+      it "returns constant for string" do
+        Type.parse("integer").should == Integer
+      end
+
+      it "returns argument when not a string" do
+        class ::Foo; end
+        Type.parse(Foo).should == Foo
+        Object.__send__(:remove_const, :Foo)
+      end
+
+      it "raises meaningful error for unmatched types" do
+        expect {
+          Type.parse!("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|
+            Type.parse(name).should == UUID
+          end
+        end
+
+        it "returns UUID for uuid" do
+          Type.parse("uUId").should == UUID
+        end
+
+        it "returns Boolean for boolean" do
+          Type.parse("boolean").should == Render::Type::Boolean
+        end
+
+        it "returns Float for number" do
+          Type.parse("FloAt").should == Float
+        end
+
+        it "returns Time for date-time" do
+          Type.parse("date-time").should == Time
+        end
+      end
+    end
+
+    describe ".find" do
+      it "returns Render's custom types" do
+        Type.find(:boolean).should == Render::Type::Boolean
+      end
+
+      it "returns falsie when no type is found" do
+        Type.find(:foo).should_not be
+      end
+
+      describe "user type" do
+        before(:each) do
+          @original_types = Type.instances.dup
+          module ::Foo; module Boolean; end; end
+          Type.add!(:boolean, Foo::Boolean)
+        end
+
+        after(:each) do
+          Type.instances = @original_types
+          Object.__send__(:remove_const, :Foo)
+        end
+
+        it "is returned instead of Render's" do
+          Type.find(:boolean).should == Foo::Boolean
+        end
+      end
+    end
+  end
+end

data/spec/unit/render_spec.rb

@@ -32,144 +32,5 @@ describe Render do
       end
     end
 
-    describe ".generators" do
-      before(:each) do
-        @original_value = Render.generators
-        Render.generators.clear
-      end
-
-      after(:each) do
-        Render.generators = @original_value
-      end
-
-      it "defaults to an empty array" do
-        Render.generators.should == []
-      end
-    end
-
-    context "schema definitions" do
-      before(:each) do
-        @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",
-            "properties": {
-              "name": { "type": "string" },
-              "year": { "type": "integer" }
-            }
-          }
-          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
-
-        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
-
-    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 "raises meaningful error if definition is not found" do
-        expect {
-          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 "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
 end