render 0.0.8 → 0.0.9

data/spec/integration/render/schema_spec.rb

@@ -25,7 +25,7 @@ module Render
 
     it "stubs data for testing" do
       name = "am I transforming this right?"
-      rendered_stub = Render::Schema.new(:films_show).serialize!({ name: name })
+      rendered_stub = Render::Schema.new("films_show").serialize!({ name: name })
       stub_request(:get, "http://films.local").to_return({ body: rendered_stub.to_json })
 
       TransformerExample.process_name[:transformed_to].should == name
@@ -33,14 +33,14 @@ module Render
 
     it "enforces schema's definition" do
       name = "am I transforming this right?"
-      rendered_stub = Render::Schema.new(:films_show).serialize!({ wrong_key: name })
+      rendered_stub = Render::Schema.new("films_show").serialize!({ wrong_key: name })
       stub_request(:get, "http://films.local").to_return({ body: rendered_stub.to_json })
 
       TransformerExample.process_name[:transformed_to].should_not == name
     end
 
     it "prevents errors related to code anticipating actual data" do
-      rendered_stub = Render::Schema.new(:films_show).serialize!
+      rendered_stub = Render::Schema.new("films_show").serialize!
       stub_request(:get, "http://films.local").to_return({ body: rendered_stub.to_json })
 
       expect {
@@ -67,7 +67,7 @@ module Render
           },
           tags: {
             type: Array,
-            required: true,
+            minItems: 1,
             items: {
               type: Object,
               properties: {

data/spec/support/schemas/film.json

@@ -1,8 +1,8 @@
 {
-  "universal_title": "films_show",
-  "title": "film",
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "id": "films_show",
   "type": "object",
-  "endpoint": "http://:host/films/:id",
+  "endpoint": "http://{host}/films/{id}",
   "properties": {
     "name": { "type": "string" },
     "year": { "type": "integer" }

data/spec/support/schemas/films.json

@@ -1,8 +1,8 @@
 {
-  "universal_title": "films_index",
-  "title": "films",
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "id": "films_index",
   "type": "array",
-  "endpoint": "http://:host",
+  "endpoint": "http://{host}",
   "items": {
     "title": "film",
     "type" : "object",

data/spec/unit/render/attributes/array_attribute_spec.rb

@@ -18,18 +18,45 @@ module Render
       end
     end
 
-    describe "archetype" do
-      it "returns only a value" do
-        id = UUID.generate
-        attribute = ArrayAttribute.new({ items: { type: UUID } })
-        attribute.serialize([id]).should == [id]
+    describe "#serialize" do
+      describe "simple" do
+        it "only returns a value" do
+          id = UUID.generate
+          attribute = ArrayAttribute.new({ items: { type: UUID } })
+          attribute.serialize([id]).should == [id]
+        end
+
+        it "returns value as defined type" do
+          attribute = ArrayAttribute.new({ items: { type: Float } })
+          attribute.serialize(["2.0"]).should == [2.0]
+        end
+
+        it "returns faux value as defined type" do
+          Render.stub({ live: false })
+
+          attribute = ArrayAttribute.new({ items: { type: Float }, maxItems: 1, minItems: 1 })
+          attribute.stub({ default_value: "2" })
+
+          attribute.serialize.should == [2.0]
+        end
+
+        it "enforces uniqueness" do
+          attribute = ArrayAttribute.new({ items: { type: Integer }, uniqueItems: true })
+          attribute.serialize(["2.0", 2, "2"]).should == [2]
+        end
+
+        it "does not enforce uniqueness" do
+          attribute = ArrayAttribute.new({ items: { type: Integer } })
+          attribute.serialize(["2.0", 2, "2"]).should == [2, 2, 2]
+        end
       end
     end
 
     describe "#faux_data" do
       before(:each) do
         Render.stub({ live: false })
-        @attribute = ArrayAttribute.new({ items: { type: Float, required: true } })
+        @lower_limit = 6
+        @attribute = ArrayAttribute.new({ items: { type: Float }, minItems: @lower_limit })
       end
 
       it "uses explicit value for faux data" do
@@ -38,13 +65,11 @@ module Render
       end
 
       it "generates fake number of elements" do
-        lower_limit = 6
         upper_limit = 9
-        @attribute.stub({ lower_limit: lower_limit })
         stub_const("Render::ArrayAttribute::FAUX_DATA_UPPER_LIMIT", upper_limit)
 
         faux_data = @attribute.serialize
-        faux_data.size.should >= lower_limit
+        faux_data.size.should >= @lower_limit
         faux_data.size.should <= upper_limit
         faux_data.sample.class.should == Float
       end

data/spec/unit/render/attributes/attribute_spec.rb

@@ -12,6 +12,19 @@ module Render
           faux_value.should include(name)
         end
       end
+
+      describe "#bias_type" do
+        it "biases the format" do
+          attribute = HashAttribute.new({ name: { type: String, format: UUID } })
+          attribute.bias_type.should eq(UUID)
+        end
+
+        it "biases the first type" do
+          attribute = HashAttribute.new({ name: { type: [String, Integer] } })
+          attribute.bias_type.should eq(String)
+        end
+      end
+
     end
   end
 end

data/spec/unit/render/attributes/hash_attribute_spec.rb

@@ -12,17 +12,17 @@ module Render
         it "is set from options" do
           type = Integer
           attribute = HashAttribute.new({ key_name: { type: type } })
-          attribute.type.should == type
+          attribute.types.should == [type]
         end
 
         it "is set from name hash" do
           type = String
           attribute = HashAttribute.new({ id: { type: UUID } })
-          attribute.type.should == UUID
+          attribute.types.should == [UUID]
         end
 
         it "determines type from string" do
-          HashAttribute.new({ key_name: { type: "string" } }).type.should == String
+          HashAttribute.new({ key_name: { type: "string" } }).types.should == [String]
         end
       end
 
@@ -58,7 +58,7 @@ module Render
           hash_attributes.size.should == 1
           attribute = hash_attributes.first
           attribute.name.should == :year
-          attribute.type.should == Integer
+          attribute.types.should == [Integer]
         end
       end
 
@@ -86,6 +86,18 @@ module Render
         end
       end
 
+      it "returns value as defined type" do
+        attribute = HashAttribute.new({ year: { type: Integer } })
+        attribute.serialize("2").should == { year: 2 }
+      end
+
+      it "returns faux value as defined type" do
+        attribute = HashAttribute.new({ year: { type: Integer } })
+        attribute.stub({ default_value: "2" })
+
+        attribute.serialize(nil).should == { year: 2 }
+      end
+
       context "offline" do
         before(:each) do
           Render.stub({ live: false })
@@ -97,11 +109,9 @@ module Render
           data[:title].should be_a(type)
         end
 
-        it "maintains falsy-ie values when instructed" do
+        it "maintains nil values when instructed" do
           data = HashAttribute.new({ title: { type: Integer } }).serialize(nil, true)
           data[:title].should == nil
-          data = HashAttribute.new({ title: { type: Integer } }).serialize(false, true)
-          data[:title].should == false
         end
       end
     end

data/spec/unit/render/definition_spec.rb

@@ -10,31 +10,13 @@ module Render
       Definition.instances = @original_defs
     end
 
-    describe ".load!" 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 }
-          }
-        }
-
-        Definition.load!(definition)
-        Definition.instances.keys.should include(universal_title.to_sym)
-      end
-    end
-
     describe ".load_schemas!" do
       before(:each) do
         Definition.instances.clear
-        @schema_title = "film"
+        @schema_id = "films.show"
         @json_schema = <<-JSON
           {
-            "title": "#{@schema_title}",
+            "id": "#{@schema_id}",
             "type": "object",
             "properties": {
               "name": { "type": "string" },
@@ -62,24 +44,24 @@ module Render
       it "accesses parsed schemas with symbols" do
         Definition.load_from_directory!(@directory)
         parsed_json = Render::Extensions::DottableHash.new(JSON.parse(@json_schema)).recursively_symbolize_keys!
-        Definition.instances[@schema_title.to_sym].should == parsed_json
+        Definition.instances[@schema_id].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: {} }
+      def_id = :the_name
+      definition = { id: def_id, properties: {} }
       Definition.load!(definition)
 
-      Definition.find(def_title).should == definition
+      Definition.find(def_id).should == definition
     end
 
     it "raises meaningful error if definition is not found" do
       expect {
         Definition.find(:definition_with_this_title_has_not_been_loaded)
-      }.to raise_error(Render::Errors::DefinitionNotFound)
+      }.to raise_error(Render::Errors::Definition::NotFound)
     end
   end
 end

data/spec/unit/render/generator_spec.rb

@@ -28,9 +28,23 @@ module Render
     end
 
     describe ".trigger" do
+      context "no generator" do
+        it "returns nil" do
+          attribute = double(:attribute, { name: "foo" })
+          Generator.trigger(:foo, "_to_match", attribute).should == nil
+        end
+
+        it "warns" do
+          Render.logger.should_receive(:warn).with(/find.*generator.*foo.*_to_match/i)
+
+          attribute = double(:attribute, { name: "foo" })
+          Generator.trigger(:foo, "_to_match", attribute).should == nil
+        end
+      end
+
       it "triggers matching generator for Render types" do
-        enum_attribute = HashAttribute.new({ attribute_name: { type: String, enum: ["foo"] } })
-        Generator.trigger(:enum, "anything", enum_attribute).should == "foo"
+        enum_attribute = HashAttribute.new({ name: { type: String, enum: ["foo"] } })
+        Generator.trigger(enum_attribute.bias_type, "anything", enum_attribute).should == "foo"
       end
     end
 
@@ -65,5 +79,91 @@ module Render
         Generator.new(UUID, //, algorithm).trigger(x).should == algorithm.call(x)
       end
     end
+
+    describe "default set" do
+      describe String do
+        it "adheres to minLength" do
+          min_length = 100
+          attribute = HashAttribute.new({ name: { type: String, minLength: min_length } })
+          value = Generator.trigger(String, "_to_match", attribute)
+          value.length.should >= min_length
+        end
+
+        it "adheres to maxLength" do
+          max_length = 2
+          attribute = HashAttribute.new({ name: { type: String, maxLength: max_length } })
+          value = Generator.trigger(String, "_to_match", attribute)
+          value.length.should <= max_length
+        end
+      end
+
+      describe Integer do
+        it "adheres to multipleOf" do
+          attribute = HashAttribute.new({ name: { type: "integer", multipleOf: 13 } })
+          value = Generator.trigger(attribute.types.first, "_to_match", attribute)
+          (value % 13).should eq(0)
+        end
+
+        it "adheres to minimum" do
+          attribute = HashAttribute.new({ name: { type: "integer", minimum: 100 } })
+          value = Generator.trigger(attribute.types.first, "_to_match", attribute)
+          value.should > 100
+        end
+
+        it "adheres to maximum" do
+          attribute = HashAttribute.new({ name: { type: "integer", maximum: 100 } })
+          value = Generator.trigger(attribute.types.first, "_to_match", attribute)
+          value.should <= 100
+        end
+
+        it "adherse to exclusiveMinimum" do
+          attribute = HashAttribute.new({ name: { type: "integer", minimum: 4, maximum: 5, exclusiveMinimum: true } })
+          Generator.trigger(attribute.types.first, "_to_match", attribute).should eq(5)
+        end
+
+        it "adherse to exclusiveMaximum" do
+          attribute = HashAttribute.new({ name: { type: "integer", minimum: 4, maximum: 5, exclusiveMaximum: true } })
+          Generator.trigger(attribute.types.first, "_to_match", attribute).should eq(4)
+        end
+
+        it "adheres to minimum and multipleOf" do
+          attribute = HashAttribute.new({ name: { type: "integer", minimum: 60, maximum: 70, multipleOf: 13 } })
+          value = Generator.trigger(attribute.types.first, "_to_match", attribute)
+          (value % 13).should eq(0)
+          value.should eq(65)
+        end
+      end
+
+      describe "Numbers (converted to Float)" do
+        it "adheres to multipleOf" do
+          attribute = HashAttribute.new({ name: { type: "number", multipleOf: 1.3 } })
+          value = Generator.trigger(attribute.types.first, "_to_match", attribute)
+          (value % 1.3).should eq(0)
+        end
+
+        it "adheres to minimum" do
+          attribute = HashAttribute.new({ name: { type: "number", minimum: 100.0 } })
+          value = Generator.trigger(attribute.types.first, "_to_match", attribute)
+          value.should > 100.0
+        end
+
+        it "adheres to maximum" do
+          attribute = HashAttribute.new({ name: { type: "number", maximum: 100 } })
+          value = Generator.trigger(attribute.types.first, "_to_match", attribute)
+          value.should <= 100
+        end
+
+        it "adherse to exclusiveMinimum" do
+          attribute = HashAttribute.new({ name: { type: "number", minimum: 99.49, maximum: 99.50, exclusiveMinimum: true } })
+          Generator.trigger(attribute.types.first, "_to_match", attribute).should eq(99.50)
+        end
+
+        it "adherse to exclusiveMaximum" do
+          attribute = HashAttribute.new({ name: { type: "number", minimum: 99.49, maximum: 99.50, exclusiveMaximum: true } })
+          Generator.trigger(attribute.types.first, "_to_match", attribute).should eq(99.49)
+        end
+      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, { :[] => nil })
-      @schema = double(:schema, { type: Hash, definition: @definition })
+      @definition = { type: Object, properties: { foo: { type: String } } }
+      @schema = Schema.new(@definition)
       Schema.stub(:new).with(@definition).and_return(@schema)
     end
 
@@ -49,34 +49,34 @@ module Render
       end
     end
 
-    describe ".send(:endpoint)" do
+    describe "#endpoint" do
       it "returns #raw_endpoint" do
         simple_endpoint = "http://endpoint.local"
         graph = Graph.new(@definition, { endpoint: simple_endpoint })
         graph.send(:endpoint).should == simple_endpoint
       end
 
-      it "interpolates inherited parameters" do
+      it "expands inherited variables" do
         director_id = UUID.generate
-        endpoint = "http://endpoint.local/directors/:id"
+        endpoint = "http://endpoint.local/directors/{id}"
         relationships = { director_id: :id }
 
         graph = Graph.new(@definition, { endpoint: endpoint, relationships: relationships })
-        graph.inherited_data = { director_id: director_id }
+        graph.relationship_info = { id: director_id }
 
         graph.send(:endpoint).should == "http://endpoint.local/directors/#{director_id}"
       end
 
       it "interpolates config options" do
         client_id = UUID.generate
-        endpoint = "http://endpoint.local/?:client_id"
+        endpoint = "http://endpoint.local/{?client_id}"
 
         graph = Graph.new(@definition, { endpoint: endpoint, 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
-        endpoint = "http://endpoint.com/?:undefined_key"
+        endpoint = "http://endpoint.com/{?undefined_key}"
         graph = Graph.new(@definition, { endpoint: endpoint })
 
         expect {
@@ -88,11 +88,10 @@ module Render
     describe "#render" do
       it "returns its schema's data" do
         serialized_data = { id: UUID.generate }
-        pull = { film: serialized_data }
-        @schema.stub({ render!: pull, serialized_data: serialized_data })
+        @schema.stub({ render!: serialized_data })
 
         graph = Graph.new(@definition)
-        graph.render!.should == pull
+        graph.render!.should == { untitled: serialized_data }
       end
 
       it "returns a dottable hash" do
@@ -104,11 +103,11 @@ module Render
       end
 
       it "sends interpolated endpoint to its schema" do
-        endpoint = "http://endpoint.local/?:client_id"
+        endpoint = "http://endpoint.local/{?client_id}"
         client_id = UUID.generate
         graph = Graph.new(@definition, { endpoint: endpoint, client_id: client_id })
 
-        @schema.should_receive(:render!).with(anything, graph.send(:endpoint)).and_return({})
+        @schema.should_receive(:render!).with(anything, "http://endpoint.local/?client_id=#{client_id}")
         graph.render!
       end
 
@@ -140,11 +139,11 @@ module Render
         it "uses parent data to calculate endpoint" do
           film = Graph.new(@film_schema)
           relationships = { director_id: :id }
-          endpoint = "http://endpoint.local/directors/:id"
+          endpoint = "http://endpoint.local/directors/{id}"
           film.graphs << Graph.new(@director_schema, { endpoint: endpoint, relationships: relationships })
 
           film_data = { director_id: @director_id }
-          @film_schema.should_receive(:render!).and_yield(film_data).and_return(film_data)
+          @film_schema.should_receive(:render!).and_return(film_data)
 
           endpoint = "http://endpoint.local/directors/#{@director_id}"
           @director_schema.should_receive(:render!).with(anything, endpoint).and_return({})
@@ -169,7 +168,7 @@ module Render
           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 })
+          films_schema.should_receive(:render!).and_return(films_response)
 
           response = films.render!
           response.film.should be_a(Array)
@@ -179,12 +178,12 @@ module Render
         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_schema.should_receive(:render!).and_return({ director_id: @director_id })
 
           film.render!.director.id.should == @director_id
         end
 
-        it "uses archetype parental data" do
+        it "uses simple parental data" do
           films_schema = Schema.new({
             title: "films",
             type: Array,
@@ -198,7 +197,7 @@ module Render
 
           film_id = UUID.generate
           films_response = [film_id]
-          films_schema.should_receive(:render!).and_yield(films_response).and_return({ films: films_response })
+          films.schema.stub({ render!: films_response })
 
           response = films.render!
           response.film.should be_a(Array)