render 0.0.4 → 0.0.5

data/spec/integration/render/nested_graph_spec.rb

@@ -0,0 +1,67 @@
+require "render"
+
+module Render
+  describe Graph do
+    before(:all) do
+      Render::Definition.load_from_directory!(Helpers::SCHEMA_DIRECTORY)
+
+      @host = "films.local"
+      @aquatic_id = UUID.generate
+      @darjeeling_id = UUID.generate
+      @aquatic_name = "The Life Aquatic with Steve Zissou"
+      @darjeeling_name = "The Darjeeling Limited"
+    end
+
+    after(:all) do
+      Render::Definition.instances.clear
+    end
+
+    it "uses first request's data for subsequent requests" do
+      stub_request(:get, "http://films.local").to_return({ body: [{ id: @aquatic_id }, { id: @darjeeling_id }].to_json })
+      stub_request(:get, "http://films.local/films/#{@aquatic_id}").to_return({ body: { name: @aquatic_name }.to_json })
+      stub_request(:get, "http://films.local/films/#{@darjeeling_id}").to_return({ body: { name: @darjeeling_name }.to_json })
+
+      graph = Render::Graph.new(:films_index, { host: "films.local" })
+      graph.graphs << Render::Graph.new(:films_show, { host: "films.local", relationships: { id: :id } })
+      response = graph.render!
+
+      response.should == {
+        films_index: {
+          films: [{ id: @aquatic_id }, { id: @darjeeling_id }]
+        },
+        films_show: [
+          { film: { name: @aquatic_name, year: nil } },
+          { film: { name: @darjeeling_name, year: nil } }
+        ]
+      }
+    end
+
+    it "makes subsequent calls from archetype array data" do
+      stub_request(:get, "http://films.local").to_return({ body: [@aquatic_id, @darjeeling_id].to_json })
+      stub_request(:get, "http://films.local/films/#{@aquatic_id}").to_return({ body: { name: @aquatic_name }.to_json })
+      stub_request(:get, "http://films.local/films/#{@darjeeling_id}").to_return({ body: { name: @darjeeling_name }.to_json })
+
+      schema = Render::Schema.new({
+        title: :films_as_array_of_archetypes,
+        type: Array,
+        endpoint: "http://:host",
+        items: {
+          type: UUID
+        }
+      })
+
+      graph = Render::Graph.new(schema, { host: "films.local" })
+      graph.graphs << Render::Graph.new(:films_show, { host: "films.local", relationships: { id: :id } })
+      response = graph.render!
+
+      response.should == {
+        films_as_array_of_archetypes: [@aquatic_id, @darjeeling_id],
+        films_show: [
+          { film: { name: @aquatic_name, year: nil } },
+          { film: { name: @darjeeling_name, year: nil } }
+        ]
+      }
+    end
+
+  end
+end

data/spec/integration/render/schema_spec.rb

@@ -0,0 +1,90 @@
+require "render"
+
+module Render
+  describe Schema do
+    before(:all) do
+      Render::Definition.load_from_directory!(Helpers::SCHEMA_DIRECTORY)
+      Render.live = false
+
+      module ::TransformerExample
+        class << self
+          def process_name
+            uri = URI("http://films.local")
+            response = JSON.parse(Net::HTTP.get(uri))
+            { transformed_to: response.fetch("name") }
+          end
+        end
+      end
+    end
+
+    after(:all) do
+      Render::Definition.instances.clear
+      Render.live = true
+      Object.send(:remove_const, :TransformerExample)
+    end
+
+    it "stubs data for testing" do
+      name = "am I transforming this right?"
+      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
+    end
+
+    it "enforces schema's definition" do
+      name = "am I transforming this right?"
+      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!
+      stub_request(:get, "http://films.local").to_return({ body: rendered_stub.to_json })
+
+      expect {
+        response = TransformerExample.process_name
+      }.not_to raise_error
+    end
+
+    it "creates fake data for varying types" do
+      schema = {
+        title: :film,
+        type: Object,
+        properties: {
+          id: { type: UUID },
+          title: { type: String },
+          director: {
+            type: Object,
+            properties: {
+              rating: { type: Float }
+            }
+          },
+          genre: {
+            enum: ["horror", "action", "sci-fi"]
+          },
+          tags: {
+            type: Array,
+            required: true,
+            items: {
+              type: Object,
+              properties: {
+                name: { type: String },
+                id: { type: Integer }
+              }
+            }
+          }
+        }
+      }
+
+      response = Render::Schema.new(schema).serialize!
+      UUID.validate(response[:id]).should be_true
+      response[:title].should be_a(String)
+      response[:director][:rating].should be_a(Float)
+      %w(horror action sci-fi).should include(response[:genre])
+      response[:tags].first[:name].should be_a(String)
+      response[:tags].first[:id].should be_a(Integer)
+    end
+  end
+end

data/spec/support/helpers.rb

@@ -1,3 +1,4 @@
 module Helpers
-  SCHEMA_DIRECTORY = File.expand_path("../../schemas", __FILE__)
+  SCHEMA_DIRECTORY = File.expand_path("../schemas", __FILE__)
+  puts SCHEMA_DIRECTORY.inspect
 end

data/spec/{schemas → support/schemas}/film.json

@@ -2,6 +2,7 @@
   "universal_title": "films_show",
   "title": "film",
   "type": "object",
+  "endpoint": "http://:host/films/:id",
   "properties": {
     "name": { "type": "string" },
     "year": { "type": "integer" }

data/spec/{schemas → support/schemas}/films.json

@@ -2,6 +2,7 @@
   "universal_title": "films_index",
   "title": "films",
   "type": "array",
+  "endpoint": "http://:host",
   "items": {
     "title": "film",
     "type" : "object",

data/spec/unit/gemspec_spec.rb

@@ -0,0 +1,8 @@
+describe :gemspec do
+  it "is valid" do
+    spec = Gem::Specification::load("render.gemspec")
+    expect {
+      spec.validate
+    }.not_to raise_error
+  end
+end

data/spec/unit/{array_attribute_spec.rb → render/attributes/array_attribute_spec.rb}

@@ -1,4 +1,4 @@
-require "render/array_attribute"
+require "render/attributes/array_attribute"
 
 module Render
   describe ArrayAttribute do

data/spec/unit/render/{hash_attribute_spec.rb → attributes/hash_attribute_spec.rb}

@@ -126,7 +126,9 @@ module Render
           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
+
+          value = HashAttribute.new({ key: { type: UUID } }).default_value
+          UUID.validate(value).should be_true
         end
 
         it "generates value from enum" do

data/spec/unit/render/definition_spec.rb

@@ -0,0 +1,85 @@
+require "render/definition"
+
+module Render
+  describe Definition do
+    before(:each) do
+      @original_defs = Definition.instances.dup
+    end
+
+    after(:each) do
+      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"
+        @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
+        Definition.instances = {}
+      end
+
+      it "stores JSON files" do
+        expect {
+          Definition.load_from_directory!(@directory)
+        }.to change { Definition.instances.keys.size }.by(1)
+      end
+
+      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
+      end
+    end
+  end
+
+  describe ".definition" do
+    it "returns definition by its title" do
+      def_title = :the_name
+      definition = { title: def_title, properties: {} }
+      Definition.load!(definition)
+
+      Definition.find(def_title).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)
+    end
+  end
+end

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

@@ -0,0 +1,148 @@
+require "render/extensions/dottable_hash"
+
+module Render
+  module Extensions
+    describe DottableHash do
+      before(:each) do
+        @dottable_hash = DottableHash.new
+      end
+
+      describe "new" do
+        it "creates from a hash" do
+          dottable_hash = DottableHash.new({ "foo" => "bar" })
+          dottable_hash.should == { :foo => "bar" }
+        end
+
+        it "initializes new hashes as dottable_hashes" do
+          dottable_hash = DottableHash.new({ :foo => { :bar => "baz" } })
+          dottable_hash[:foo].class.should == DottableHash
+        end
+
+        it "converts all keys to symbols" do
+          dottable_hash = DottableHash.new({ "foo" => { "bar" => "baz" } })
+          dottable_hash.keys.include?(:foo).should be_true
+        end
+      end
+
+      describe "#[]" do
+        it "converts keys to strings" do
+          @dottable_hash[:foo] = "bar"
+          @dottable_hash.keys.include?(:foo).should be_true
+        end
+
+        it "converts hash values to dottable_hashs" do
+          @dottable_hash[:foo] = { bar: { baz: "baz" } }
+          @dottable_hash.foo.bar.class.should == DottableHash
+        end
+
+        it "retrieves values by stringified keys" do
+          @dottable_hash["foo"] = "bar"
+          @dottable_hash[:foo].should == "bar"
+        end
+
+        it "converts hashes in arrays to dottable hashes" do
+          pallet = DottableHash.new
+          pallet.foo = [{ bar: "baz" }]
+          pallet.foo.first.class.should == DottableHash
+        end
+      end
+
+      describe "#delete" do
+        it "symbolizes keys" do
+          @dottable_hash["foo"] = { "bar" => "bar", "baz" => "baz" }
+          @dottable_hash.foo.delete(:bar)
+          @dottable_hash.should == { :foo => { :baz => "baz" } }
+        end
+      end
+
+      describe ".has_key?" do
+        it "converts symbols to strings" do
+          DottableHash.new({ foo: "bar" }).has_key?(:foo).should == true
+        end
+      end
+
+      describe "#method_missing" do
+        it "returns value for key when it exists" do
+          @dottable_hash[:foo] = "bar"
+          @dottable_hash.foo.should == "bar"
+        end
+
+        it "raises an error when no key exists" do
+          lambda {
+            @dottable_hash.foo
+          }.should raise_error(NoMethodError)
+        end
+
+        it "returns the same object as in the hash" do
+          @dottable_hash[:foo] = { bar: "baz" }
+          dottable_hash_object_id = @dottable_hash.foo.object_id
+          @dottable_hash.foo.object_id.should == dottable_hash_object_id
+        end
+
+        it "sets values" do
+          @dottable_hash.foo = "bar"
+          @dottable_hash.foo.should == "bar"
+        end
+      end
+
+      describe "dot access" do
+        it "provides acess to keys as methods" do
+          dottable_hash = DottableHash.new({ "foo" => "bar" })
+          dottable_hash.foo.should == "bar"
+        end
+
+        it "provides acess to nested keys as methods" do
+          dottable_hash = DottableHash.new({ "foo" => {"bar" => {"baz" => "bat"}}})
+          dottable_hash.foo.bar.baz.should == "bat"
+        end
+
+        it "provides indifferent accesss" do
+          dottable_hash = DottableHash.new({ :foo => {:bar => {"baz" => "bat"}}})
+          dottable_hash.foo.bar.baz.should == "bat"
+        end
+
+        it "provides acess to keys with nil values" do
+          dottable_hash = DottableHash.new({ "foo" => {"bar" => nil} })
+          dottable_hash.foo.bar.should == nil
+        end
+
+        it "raises key error when it doesn't exist" do
+          dottable_hash = DottableHash.new({ "foo" => "bar" })
+          expect { dottable_hash.fu }.to raise_error(NoMethodError)
+        end
+
+        it "provides the dot access to a hash inside of an array" do
+          dottable_hash = DottableHash.new({ "foo" => [{"bar" => "baz"}]})
+          dottable_hash.foo.first.bar.should == "baz"
+        end
+
+        it "provides the dot access to to a list of strings inside an array" do
+          dottable_hash = DottableHash.new({ "foo" => ["bar", "baz"]})
+          dottable_hash.foo.should == ["bar", "baz"]
+        end
+
+        it "initializes hashes in nested arrays as dottable_hashs" do
+          dottable_hash = DottableHash.new({ foo: [{ bar: [{ baz: "one" }] }] })
+          dottable_hash.foo.first.bar.first.class.should == DottableHash
+        end
+      end
+
+      describe "#merge!" do
+        it "works with merged keys as symbols" do
+          dottable_hash = DottableHash.new({ stuff: {} })
+          dottable_hash.stuff.merge!({ things: "widgets" })
+          dottable_hash.stuff.things.should == "widgets"
+        end
+      end
+
+      describe "#merge" do
+        it "works with merged keys as symbols" do
+          dottable_hash = DottableHash.new({ stuff: {} })
+          stuff_dottable_hash = dottable_hash.stuff.merge({ things: "widgets" })
+          stuff_dottable_hash.things.should == "widgets"
+        end
+      end
+
+    end
+  end
+end