restfolia 1.0.0

data/samples/http_behaviour.rb

@@ -0,0 +1,52 @@
+
+# Run this sample from root project:
+# $ ruby samples/http_behaviour.rb
+
+require "rubygems"
+$LOAD_PATH << "lib"
+require "restfolia"
+require "ostruct"
+
+Restfolia::HTTP.behaviours do
+
+  on(200) do |http_response|
+    content_type = (http_response["content-type"] =~ /application\/json/)
+    if !content_type
+      msg_error = "Response \"content-type\" header should be \"application/json\""
+      raise Restfolia::ResponseError.new(msg_error, caller, http_response)
+    end
+
+    http_body = http_response.body.to_s
+    if !http_body.empty?
+      json_parsed = helpers.parse_json(http_response)
+      Restfolia.create_resource(json_parsed)
+    elsif (location = http_response["location"])
+      helpers.follow_url(location)
+    else
+      nil
+    end
+  end
+
+  # 3xx range
+  on(300...400) do
+    raise "3xx error"
+  end
+
+  #on([404, 402]) do
+  #  custom_helper
+  #end
+
+  #helpers do
+  #  def custom_helper
+  #    'lixo'
+  #  end
+  #end
+
+end
+
+SERVICE_URL = "http://localhost:9292/recursos/busca"
+resource = Restfolia.at(SERVICE_URL).get
+puts resource.inspect
+
+Restfolia.at("http://google.com").get
+# => "3xx error"

data/samples/using_custom_factory.rb

@@ -0,0 +1,25 @@
+
+# Run this sample from root project:
+# $ ruby samples/using_custom_factory.rb
+
+require "rubygems"
+$LOAD_PATH << "lib"
+require "restfolia"
+require "ostruct"
+
+SERVICE_URL = "http://localhost:9292/recursos/busca"
+
+resource = Restfolia.at(SERVICE_URL).get
+puts resource.inspect # => #<Restfolia::Resource ...>
+
+# Here you have the "pure" json from response body.
+# You can do anything.
+module Restfolia
+  def self.create_resource(json)
+    OpenStruct.new(json)
+  end
+end
+resource = Restfolia.at(SERVICE_URL).get
+puts resource.inspect # => #<OpenStruct ...>
+
+puts "Done!"

data/samples/using_custom_resource.rb

@@ -0,0 +1,25 @@
+
+# Run this sample from root project:
+# $ ruby samples/using_custom_resource.rb
+
+require "rubygems"
+$LOAD_PATH << "lib"
+require "restfolia"
+require "ostruct"
+
+SERVICE_URL = "http://localhost:9292/recursos/busca"
+
+resource = Restfolia.at(SERVICE_URL).get
+puts resource.inspect # => #<Restfolia::Resource ...>
+
+# Here you have the advantage to use a custom resource
+# and the same time you have the recursive lookup at hash
+class Restfolia::ResourceCreator
+  def resource_class
+    OpenStruct
+  end
+end
+resource = Restfolia.at(SERVICE_URL).get
+puts resource.inspect # => #<OpenStruct ...>
+
+puts "Done!"

data/test/restfolia/entry_point_test.rb

@@ -0,0 +1,123 @@
+require "test_helper"
+
+describe Restfolia::EntryPoint do
+
+  include Restfolia::Test::JsonSamples
+  include Restfolia::Test::StubHelpers
+
+  subject { Restfolia::EntryPoint.new(Restfolia::Test::FAKE_URL) }
+
+  describe "#get" do
+
+    it "create Resource for valid request" do
+      stub_get_request(:status => 200, :body => valid_json)
+
+      resource = subject.get
+      resource.must_be_instance_of(Restfolia::Resource)
+    end
+
+    it "should accept String params" do
+      stub_api = stub_get_request(:status => 200,
+                                  :body => valid_json,
+                                  :query => {:q => "stringtest",
+                                             :p1 => "test"})
+      subject.get("q=stringtest&p1=test")
+    end
+
+    it "should accept Hash params" do
+      stub_api = stub_get_request(:status => 200,
+                                  :body => valid_json,
+                                  :query => {:q => "hashtest"})
+      subject.get(:q => "hashtest")
+    end
+
+    it "should send Custom HTTP header" do
+      stub_api = stub_get_request(:status => 200,
+                                  :body => valid_json,
+                                  :query => {:q => "hashtest"},
+                                  :with_headers => {"X-Custom" => "test"})
+
+      subject.headers["X-Custom"] = "test"
+      subject.get(:q => "hashtest")
+    end
+
+  end
+
+  describe "#post" do
+
+    it "can post Hash params" do
+      headers = {"Content-Type" => "application/json"}
+      stub_method_request(:post,
+                          :status => 201,
+                          :body => "{\"attr_test\":\"test\"}",
+                          :headers => headers)
+
+      subject.post(:attr_test => "test")
+    end
+
+    it "should send Custom HTTP header" do
+      headers = {"Content-Type" => "application/json"}
+      stub_method_request(:post,
+                          :status => 201,
+                          :body => "{\"attr_test\":\"test\"}",
+                          :headers => headers,
+                          :with_headers => {"X-Custom" => "test"})
+
+      subject.headers["X-Custom"] = "test"
+      subject.post(:attr_test => "test")
+    end
+
+  end
+
+  describe "#put" do
+
+    it "can put Hash params" do
+      headers = {"Content-Type" => "application/json"}
+      stub_method_request(:put,
+                          :status => 200,
+                          :body => "{\"attr_test\":\"upd test\"}",
+                          :headers => headers)
+
+      subject.put(:attr_test => "upd test")
+    end
+
+    it "should send Custom HTTP header" do
+      headers = {"Content-Type" => "application/json"}
+      stub_method_request(:put,
+                          :status => 200,
+                          :body => "{\"attr_test\":\"upd test\"}",
+                          :headers => headers,
+                          :with_headers => {"X-Custom" => "test"})
+
+      subject.headers["X-Custom"] = "test"
+      subject.put(:attr_test => "upd test")
+    end
+  end
+
+  describe "#delete" do
+
+    it "can send DELETE request" do
+      headers = {"Content-Type" => "application/json"}
+      stub_method_request(:delete,
+                          :status => 204,
+                          :body => nil,
+                          :headers => headers)
+
+      subject.delete
+    end
+
+    it "should send Custom HTTP header" do
+      headers = {"Content-Type" => "application/json"}
+      stub_method_request(:delete,
+                          :status => 204,
+                          :body => nil,
+                          :headers => headers,
+                          :with_headers => {"X-Custom" => "test"})
+
+      subject.headers["X-Custom"] = "test"
+      subject.delete
+    end
+
+  end
+
+end

data/test/restfolia/http_behaviour_test.rb

@@ -0,0 +1,86 @@
+require "test_helper"
+
+describe Restfolia::HTTP::Behaviour do
+
+  describe "Store" do
+    subject { Restfolia::HTTP::Behaviour::Store.new }
+
+    describe "#execute" do
+      before do
+        @http_mock = MiniTest::Mock.new
+      end
+
+      it "should execute block for Integer code match" do
+        @http_mock.expect(:code, "200")
+        subject.on(200) { 'test' }
+
+        return_value = subject.execute(@http_mock)
+        return_value.must_equal('test')
+      end
+
+      it "should execute block for Range code match" do
+        @http_mock.expect(:code, "300")
+        subject.on(300...400) { 'test' }
+
+        return_value = subject.execute(@http_mock)
+        return_value.must_equal('test')
+      end
+
+      it "should execute block for Array code match" do
+        @http_mock.expect(:code, "404")
+        subject.on([404, 403]) { 'test' }
+
+        return_value = subject.execute(@http_mock)
+        return_value.must_equal('test')
+      end
+
+      it "should call #default_behaviour for non match code" do
+        @http_mock.expect(:code, "666")
+        lambda { subject.execute(@http_mock) }.
+          must_raise(Restfolia::ResponseError)
+      end
+    end
+
+    describe "#behaviours" do
+      it "should be possible to call 'on' method" do
+        subject.behaviours do
+          on(200) { 'test' }
+        end
+      end
+    end
+
+    it "#helpers" do
+      subject.must_respond_to(:helpers)
+      subject.helpers.must_be_instance_of(Restfolia::HTTP::Behaviour::Helpers)
+    end
+
+  end
+
+  describe "Helpers" do
+
+    subject { Restfolia::HTTP::Behaviour::Helpers.new }
+
+    before do
+      @http_mock = MiniTest::Mock.new
+    end
+
+    describe "#parse_json" do
+      it "should returns parsed json" do
+        json_sample = '{"test":"ok"}'
+        @http_mock.expect(:body, json_sample)
+        json = subject.parse_json(@http_mock)
+
+        json.must_be_instance_of(Hash)
+        json[:test].must_equal("ok")
+      end
+      it "should raise error for invalid body" do
+        @http_mock.expect(:body, "<html><body>error</body></html>")
+        lambda do
+          subject.parse_json(@http_mock)
+        end.must_raise(Restfolia::ResponseError)
+      end
+    end
+
+  end
+
+end

data/test/restfolia/http_configuration_test.rb

@@ -0,0 +1,45 @@
+require "test_helper"
+
+describe Restfolia::HTTP::Configuration do
+
+  class TestConfiguration; include Restfolia::HTTP::Configuration; end
+
+  before do
+    @object = TestConfiguration.new
+    @expected_headers = {"Content-Type" => "application/json"}
+  end
+
+  it "#headers" do
+    @object.headers["Content-Type"] = "application/json"
+    @object.headers.must_equal(@expected_headers)
+  end
+
+  it "#with_headers" do
+    return_value = @object.with_headers("Content-Type" => "application/json")
+
+    @object.must_be_same_as(return_value)
+    @object.headers.must_equal(@expected_headers)
+  end
+
+  it "#as" do
+    expected_headers = {"Content-Type" => "application/json",
+                        "Accept" => "application/json"}
+    return_value = @object.as("application/json")
+
+    @object.must_be_same_as(return_value)
+    @object.headers.must_equal(expected_headers)
+  end
+
+  it "#cookies" do
+    @object.must_respond_to(:cookies)
+  end
+
+  it "#set_cookies" do
+    expected_cookies = "key=value;"
+    return_value = @object.set_cookies(expected_cookies)
+
+    @object.must_be_same_as(return_value)
+    @object.cookies.must_equal(expected_cookies)
+  end
+
+end

data/test/restfolia/resource_creator_test.rb

@@ -0,0 +1,54 @@
+require "test_helper"
+require "ostruct"
+
+describe Restfolia::ResourceCreator do
+
+  let(:subject) do
+    creator = Restfolia::ResourceCreator.new
+    def creator.resource_class
+      OpenStruct
+    end
+    creator
+  end
+
+  describe ".create" do
+
+    it "accept only hash object as parameter" do
+      lambda { subject.create(nil) }.must_raise(ArgumentError)
+    end
+
+    it "should create Resource for simple hash" do
+      resource = subject.create(:attr_test => "test")
+      resource.must_be_instance_of(OpenStruct)
+    end
+
+    it "transforms nested hash in Resource" do
+      resource = subject.create(:attr_test => {:nested => "nested"})
+      resource.attr_test.must_be_instance_of(OpenStruct)
+      resource.attr_test.nested.must_equal("nested")
+    end
+
+    it "transforms nested hash from Arrays in Resource" do
+      resource = subject.create(:attr_test => [{:nested_array => "object"}],
+                                :attr_test2 => ["not object"])
+
+      resource.attr_test.must_be_instance_of(Array)
+      resource.attr_test[0].must_be_instance_of(OpenStruct)
+      resource.attr_test[0].nested_array.must_equal("object")
+
+      resource.attr_test2[0].must_be_instance_of(String)
+      resource.attr_test2[0].must_equal("not object")
+    end
+
+    it "transforms nested hash from nested Array from Array in Resource" do
+      resource = subject.create(:attr_test => [[{:nested => "nested2"}]])
+
+      resource.attr_test.must_be_instance_of(Array)
+      resource.attr_test[0].must_be_instance_of(Array)
+      resource.attr_test[0][0].must_be_instance_of(OpenStruct)
+      resource.attr_test[0][0].nested.must_equal("nested2")
+    end
+
+  end
+
+end

data/test/restfolia/resource_test.rb

@@ -0,0 +1,89 @@
+require "test_helper"
+
+describe Restfolia::Resource do
+
+  let(:subject) { Restfolia::Resource }
+
+  describe "#initialize" do
+
+    it "accept only hash object as parameter" do
+      lambda { subject.new(nil) }.must_raise(ArgumentError)
+    end
+
+  end
+
+  describe "#initialize - look_for_resource" do
+
+    it "transforms hash keys in attributes" do
+      resource = subject.new(:attr_test => "test")
+
+      resource.must_respond_to(:attr_test)
+      resource.attr_test.must_equal("test")
+    end
+
+  end
+
+  describe "#links" do
+
+    let(:hash_link) do
+      {:href => "http://service.com", :rel => "rel", :type => "type"}
+    end
+
+    let(:array_links) do
+      link2 = hash_link
+      link2[:rel] = "rel2"
+
+      [hash_link, link2]
+    end
+
+    it "returns empty Array for no links" do
+      resource = subject.new(:attr_test => "test")
+      resource.links.must_be_empty
+    end
+
+    it "returns Array for one link" do
+      resource = subject.new(:links => hash_link)
+      resource.links.must_be_instance_of(Array)
+      resource.links[0].must_be_instance_of(Restfolia::EntryPoint)
+    end
+
+    it "returns Array for many links" do
+      resource = subject.new(:links => array_links)
+      resource.links.must_be_instance_of(Array)
+      resource.links[0].must_be_instance_of(Restfolia::EntryPoint)
+      resource.links.size.must_equal(2)
+    end
+
+    it "understand 'link' node too" do
+      resource = subject.new(:link => array_links)
+      resource.links.must_be_instance_of(Array)
+      resource.links[0].must_be_instance_of(Restfolia::EntryPoint)
+    end
+
+    it "raises Error for invalid link" do
+      resource = subject.new(:links => {:invalid => "invalid"})
+      lambda { resource.links }.must_raise(RuntimeError)
+    end
+
+    describe "rel search" do
+
+      it "returns nil for rel not found (without link)" do
+        resource = subject.new(:attr_test => "test")
+        resource.links("notexist").must_be_nil
+      end
+
+      it "returns nil for rel not found (with links)" do
+        resource = subject.new(:links => array_links)
+        resource.links("notexist").must_be_nil
+      end
+
+      it "returns EntryPoint for rel found" do
+        resource = subject.new(:links => array_links)
+        resource.links("rel2").must_be_instance_of(Restfolia::EntryPoint)
+      end
+
+    end
+
+  end
+
+end

data/test/restfolia_test.rb

@@ -0,0 +1,10 @@
+require "test_helper"
+
+describe Restfolia do
+
+  it ".url" do
+    ep = Restfolia.at("http://fakeurl.com")
+    ep.must_be_instance_of(Restfolia::EntryPoint)
+  end
+
+end

data/test/support/json_samples.rb

@@ -0,0 +1,41 @@
+module Restfolia::Test
+
+  FAKE_URL = "http://fakeurl.com"
+  FAKE_LOCATION_URL = "http://fakeurl.com/resource/666"
+
+  module JsonSamples
+
+
+    def valid_json
+      json_body = <<json_body
+{ "itens_por_pagina" : 10,
+  "links" : { "href" : "http://localhost:9292/recursos/busca",
+      "rel" : "self",
+      "type" : "application/json"
+    },
+  "paginal_atual" : 1,
+  "paginas_totais" : 1,
+  "query" : "",
+  "resultado" : [ { "id" : 1,
+        "links" : [ { "href" : "http://localhost:9292/recursos/id/1",
+              "rel" : "recurso",
+              "type" : "application/json"
+            } ],
+        "name" : "Test1"
+      },
+      { "id" : 2,
+        "links" : [ { "href" : "http://localhost:9292/recursos/id/2",
+              "rel" : "recurso",
+              "type" : "application/json"
+            } ],
+        "name" : "Test2"
+      }
+    ],
+  "total_resultado" : 100
+}
+json_body
+    end
+
+  end
+
+end

data/test/support/stub_helpers.rb

@@ -0,0 +1,36 @@
+module Restfolia::Test
+  module StubHelpers
+
+    def stub_get_request(args = {})
+      status = args[:status]
+      body = args[:body]
+      query = args[:query]
+      headers = args[:headers] || {}
+      headers["Content-Type"] = "application/json"
+      with_headers = args[:with_headers]
+
+      stub = stub_request(:get, Restfolia::Test::FAKE_URL)
+      stub.with(:query => query) unless query.nil?
+      stub.with(:headers => with_headers) unless with_headers.nil?
+
+      stub.to_return(:body => body,
+                     :status => status,
+                     :headers => headers)
+    end
+
+    def stub_method_request(method, args = {})
+      status = args[:status]
+      body = args[:body]
+      headers = args[:headers]
+      with_headers = args[:with_headers] || {'Accept'=>'*/*'}
+
+      stub_request(method, Restfolia::Test::FAKE_URL).
+        with(:body => body,
+             :headers => with_headers).
+             to_return(:status => status,
+                       :body => "",
+                       :headers => headers)
+    end
+
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,13 @@
+require "restfolia"
+
+require "minitest/autorun"
+require "minitest/reporters"
+require "webmock/minitest"
+
+require "support/json_samples"
+require "support/stub_helpers"
+
+WebMock.disable_net_connect!
+
+MiniTest::Unit.runner = MiniTest::SuiteRunner.new
+MiniTest::Unit.runner.reporters << MiniTest::Reporters::SpecReporter.new