render 0.0.4 → 0.0.5

data/spec/integration/nested_graph_spec.rb

@@ -1,85 +0,0 @@
-require "render"
-
-describe Render do
-  before(:all) do
-    Render.load_definitions!(Helpers::SCHEMA_DIRECTORY)
-  end
-
-  after(:all) do
-    Render.definitions = {}
-  end
-
-  describe "request" do
-    before(:each) do
-      @films_endpoint = "http://films.local/films"
-      @film_endpoint = "http://films.local/films/:id"
-      @aquatic_id = UUID.generate
-      @darjeeling_id = UUID.generate
-      @aquatic_name = "The Life Aquatic with Steve Zissou"
-      @darjeeling_name = "The Darjeeling Limited"
-    end
-
-    it "returns structured data for nested queries" do
-      films_index_response = [{ id: @aquatic_id }, { id: @darjeeling_id }]
-      stub_request(:get, @films_endpoint).to_return({ body: films_index_response.to_json })
-
-      aquatic_name = "The Life Aquatic with Steve Zissou"
-      aquatic_uri = @film_endpoint.gsub(":id", @aquatic_id)
-      stub_request(:get, aquatic_uri).to_return({ body: { name: aquatic_name }.to_json })
-
-      darjeeling_name = "The Darjeeling Limited"
-      darjeeling_uri = @film_endpoint.gsub(":id", @darjeeling_id)
-      stub_request(:get, darjeeling_uri).to_return({ body: { name: darjeeling_name }.to_json })
-
-      options = {
-        graphs: [Render::Graph.new(:films_show, { endpoint: @film_endpoint, relationships: { id: :id }})],
-        endpoint: @films_endpoint
-      }
-      graph = Render::Graph.new(:films_index, options)
-      graph.render.should == {
-        films_index: {
-          films: films_index_response
-        },
-        films_show: [
-          { film: { name: aquatic_name, year: nil } },
-          { film: { name: darjeeling_name, year: nil } }
-        ]
-      }
-      graph.rendered_data.films_show.first.film.name.should == aquatic_name
-    end
-
-    it "makes subsequent calls from archetype array data" do
-      stub_request(:get, @films_endpoint).to_return({ body: [@aquatic_id, @darjeeling_id].to_json })
-
-      aquatic = @film_endpoint.gsub(":id", @aquatic_id)
-      stub_request(:get, aquatic).to_return({ body: { name: @aquatic_name }.to_json })
-
-      darjeeling = @film_endpoint.gsub(":id", @darjeeling_id)
-      stub_request(:get, darjeeling).to_return({ body: { name: @darjeeling_name }.to_json })
-
-      films = Render::Schema.new({
-        title: :films,
-        type: Array,
-        items: {
-          type: UUID
-        }
-      })
-
-      film = Render::Schema.new({
-        title: :film,
-        type: Object,
-        properties: {
-          name: { type: String }
-        }
-      })
-
-      films = Render::Graph.new(films, { endpoint: @films_endpoint })
-      films.graphs << Render::Graph.new(film, { endpoint: @film_endpoint, relationships: { id: :id } })
-      films.render.film.should =~ [
-        { name: @aquatic_name },
-        { name: @darjeeling_name }
-      ]
-    end
-
-  end
-end

data/spec/integration/single_graph_spec.rb

@@ -1,76 +0,0 @@
-require "render"
-
-describe Render do
-  before(:all) do
-    Render.load_definitions!(Helpers::SCHEMA_DIRECTORY)
-  end
-
-  after(:all) do
-    Render.definitions = {}
-  end
-
-  before(:each) do
-    @film_id = UUID.generate
-    @film_name = "The Life Aqautic with Steve Zissou"
-
-    # Typically in environmental config
-    @secret_code = "3892n-2-n2iu1bf1cSdas0dDSAF"
-    @films_endpoint = "http://films.local/films?:secret_code"
-    @film_endpoint = "http://films.local/films/:id?:secret_code"
-  end
-
-  describe "requests" do
-    it "returns structured data" do
-      aquatic_uri = @films_endpoint.gsub(":secret_code", "secret_code=#{@secret_code}")
-      stub_request(:get, aquatic_uri).to_return({ body: [{ id: @film_id }].to_json })
-
-      graph = Render::Graph.new(:films_index, { endpoint: @films_endpoint, secret_code: @secret_code })
-      graph.render.should == { films_index: { films: [{ id: @film_id }] } }
-    end
-
-    it "returns structured data for specific resources" do
-      id = UUID.generate
-      aquatic_uri = @film_endpoint.gsub(":id", id).gsub(":secret_code", "secret_code=#{@secret_code}")
-      stub_request(:get, aquatic_uri).to_return({ body: { name: @film_name }.to_json })
-
-      graph = Render::Graph.new(:films_show, { id: id, endpoint: @film_endpoint, secret_code: @secret_code })
-      graph.render.should == { films_show: { film: { name: @film_name, year: nil } } }
-    end
-  end
-
-  describe "stubbed responses" do
-    before(:each) do
-      Render.stub({ live: false })
-    end
-
-    it "use meaningful values" do
-      response = Render::Graph.new(:films_show).render({ name: @film_name })
-
-      stub_request(:post, "http://films.local/create").to_return({ body: response.to_json })
-      response = post_film(:anything)["films_show"]["film"]
-
-      response["name"].should be_a(String)
-      response["year"].should be_a(Integer)
-    end
-
-    it "allows users to specify specific values" do
-      response = Render::Schema.new(:films_show).render!({ name: @film_name })
-
-      data = { name: @film_name }.to_json
-      request = stub_request(:post, "http://films.local/create").with({ body: data }).to_return({ body: response.to_json })
-
-      response = post_film(data)["films_show"]["film"]
-      request.should have_been_made
-      response["name"].should == @film_name
-    end
-  end
-
-  def post_film(data)
-    response = Net::HTTP.start("films.local", 80) do |http|
-      request = Net::HTTP::Post.new("/create")
-      request.body = data
-      http.request(request)
-    end
-    JSON.parse(response.body)
-  end
-end

data/spec/unit/extensions/boolean_spec.rb

@@ -1,7 +0,0 @@
-require "extensions/boolean"
-
-describe Boolean do
-  it "exists" do
-    expect { Boolean }.to_not raise_error
-  end
-end

data/spec/unit/render/dottable_hash_spec.rb

@@ -1,231 +0,0 @@
-require "render/dottable_hash"
-
-module Render
-  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 "#fetch" do
-      it "returns dottable_hashs in lieu of hashes" do
-        @dottable_hash["nested_hash"] = { "foo" => "bar" }
-        @dottable_hash.fetch("nested_hash").class.should == DottableHash
-      end
-
-      it "returns value of corresponding key object" do
-        @dottable_hash["foo"] = "bar"
-        @dottable_hash.fetch("foo").should == "bar"
-      end
-
-      it "accepts default value" do
-        DottableHash.new({ baz: "buz" }).fetch(:foo, :bar).should == :bar
-      end
-    end
-
-    describe "#fetch_path[!]" do
-      it "returns value of corresponding key object" do
-        @dottable_hash["foo"] = "bar"
-        @dottable_hash.fetch_path("foo").should == "bar"
-      end
-
-      it "returns value of expanded key object" do
-        @dottable_hash["foo"] = { "bar" => "baz" }
-        @dottable_hash.fetch_path("foo.bar").should == "baz"
-      end
-
-      it "raises key errors for nonexistent hashes" do
-        expect {
-          @dottable_hash.fetch_path!("foo")
-        }.to raise_error(KeyError)
-      end
-
-      it "raises key errors when searching into a string" do
-        @dottable_hash["foo"] = "bar"
-        expect {
-          @dottable_hash.fetch_path!("foo.bar")
-        }.to raise_error(KeyError)
-      end
-
-      it "does not raise errors for dottable_hashs with suppressed key errors" do
-        expect {
-          @dottable_hash.fetch_path("foo")
-        }.not_to raise_error
-
-        @dottable_hash["foo"] = "bar"
-        expect {
-          @dottable_hash.fetch_path("foo.bar")
-        }.not_to raise_error
-      end
-    end
-
-    describe "#set_path!" do
-      it "sets key's corresponding value" do
-        @dottable_hash.set_path!("foo", "bar")
-        @dottable_hash[:foo].should == "bar"
-      end
-
-      it "sets values for nested paths" do
-        @dottable_hash.set_path!("foo.bar.baz", "i'm really in here!")
-        {
-          :foo => {
-            :bar => {
-              :baz => "i'm really in here!"
-            }
-          }
-        }.should == @dottable_hash
-      end
-
-      it "does not overwrite the root key" do
-        @dottable_hash.set_path!("foo.bar", "bar")
-        @dottable_hash.set_path!("foo.baz.one", "baz1")
-        @dottable_hash.set_path!("foo.baz.two", "baz2")
-        {
-          :foo => {
-            :bar => "bar",
-            :baz => {
-              :one => "baz1",
-              :two => "baz2"
-            }
-          }
-        }.should == @dottable_hash
-      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