flexirest 1.2.0

data/spec/lib/lazy_loader_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Flexirest::LazyLoader do
+  let(:request) { double("Request") }
+  let(:response) { double("Response") }
+
+  it "should not #call the passed in request during initialisation" do
+    expect(request).not_to receive(:call)
+    Flexirest::LazyLoader.new(request)
+  end
+
+  it "should #call the passed in request if you check for response to a message" do
+    expect(request).to receive(:call)
+    loader = Flexirest::LazyLoader.new(request)
+    loader.respond_to?(:each)
+  end
+
+  it "should #call the passed in request if you call a method and pass through the method" do
+    expect(request).to receive(:call).and_return(response)
+    expect(response).to receive(:valid).and_return(true)
+    loader = Flexirest::LazyLoader.new(request)
+    expect(loader.valid).to be_truthy
+  end
+
+end

data/spec/lib/logger_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe Flexirest::Instrumentation do
+  before :each do
+    Flexirest::Logger.reset!
+  end
+
+  it "should log things to the Rails logger if available" do
+    class Rails
+      class << self
+        attr_accessor :logger
+      end
+    end
+
+    Rails.logger = double("Logger")
+    expect(Rails.logger).to receive(:debug)
+    expect(Rails.logger).to receive(:info)
+    expect(Rails.logger).to receive(:warn)
+    expect(Rails.logger).to receive(:error)
+    Flexirest::Logger.debug("Hello world")
+    Flexirest::Logger.info("Hello world")
+    Flexirest::Logger.warn("Hello world")
+    Flexirest::Logger.error("Hello world")
+    Object.send(:remove_const, :Rails)
+  end
+
+  it "should write to a logfile if one has been specified" do
+    Flexirest::Logger.logfile = "/dev/null"
+    file = double('file')
+    expect(File).to receive(:open).with("/dev/null", "a").and_yield(file)
+    expect(file).to receive(:<<).with("Hello world\n")
+    Flexirest::Logger.debug("Hello world")
+
+    file = double('file')
+    expect(File).to receive(:open).with("/dev/null", "a").and_yield(file)
+    expect(file).to receive(:<<).with("Hello info\n")
+    Flexirest::Logger.info("Hello info")
+
+    file = double('file')
+    expect(File).to receive(:open).with("/dev/null", "a").and_yield(file)
+    expect(file).to receive(:<<).with("Hello error\n")
+    Flexirest::Logger.error("Hello error")
+
+    file = double('file')
+    expect(File).to receive(:open).with("/dev/null", "a").and_yield(file)
+    expect(file).to receive(:<<).with("Hello warn\n")
+    Flexirest::Logger.warn("Hello warn")
+  end
+
+  it "should append to its own messages list if neither Rails nor a logfile has been specified" do
+    expect(File).not_to receive(:open)
+    Flexirest::Logger.debug("Hello world")
+    Flexirest::Logger.info("Hello info")
+    Flexirest::Logger.warn("Hello warn")
+    Flexirest::Logger.error("Hello error")
+    expect(Flexirest::Logger.messages.size).to eq(4)
+    expect(Flexirest::Logger.messages[0]).to eq("Hello world")
+    expect(Flexirest::Logger.messages[1]).to eq("Hello info")
+    expect(Flexirest::Logger.messages[2]).to eq("Hello warn")
+    expect(Flexirest::Logger.messages[3]).to eq("Hello error")
+  end
+
+end

data/spec/lib/mapping_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+class MappingExampleBase
+  include Flexirest::Mapping
+end
+
+class MappingExample < MappingExampleBase
+  get :test_get, "/get", tag:1, fake:"{result:true}", lazy:[:something]
+  put :test_put, "/put", tag:2
+  post :test_post, "/post", tag:3
+  patch :test_patch, "/patch", tag:4
+  delete :test_delete, "/delete", tag:5
+end
+
+describe Flexirest::Mapping do
+  it "should support methods for get/put/post/delete for mapping" do
+    expect(EmptyExample).to respond_to(:get)
+    expect(EmptyExample).to respond_to(:put)
+    expect(EmptyExample).to respond_to(:post)
+    expect(EmptyExample).to respond_to(:delete)
+  end
+
+  it "should save URL for each mapped call" do
+    expect(MappingExample._calls[:test_get][:url]).to eq("/get")
+    expect(MappingExample._calls[:test_put][:url]).to eq("/put")
+    expect(MappingExample._calls[:test_post][:url]).to eq("/post")
+    expect(MappingExample._calls[:test_patch][:url]).to eq("/patch")
+    expect(MappingExample._calls[:test_delete][:url]).to eq("/delete")
+  end
+
+  it "should save the correct method type for each mapped call" do
+    expect(MappingExample._calls[:test_get][:method]).to eq(:get)
+    expect(MappingExample._calls[:test_put][:method]).to eq(:put)
+    expect(MappingExample._calls[:test_post][:method]).to eq(:post)
+    expect(MappingExample._calls[:test_patch][:method]).to eq(:patch)
+    expect(MappingExample._calls[:test_delete][:method]).to eq(:delete)
+  end
+
+  it "should remember options set for each mapped call" do
+    expect(MappingExample._calls[:test_get][:options][:fake]).to eq("{result:true}")
+    expect(MappingExample._calls[:test_get][:options][:lazy]).to eq([:something])
+    expect(MappingExample._calls[:test_get][:options][:tag]).to eq(1)
+    expect(MappingExample._calls[:test_put][:options][:tag]).to eq(2)
+    expect(MappingExample._calls[:test_post][:options][:tag]).to eq(3)
+    expect(MappingExample._calls[:test_patch][:options][:tag]).to eq(4)
+    expect(MappingExample._calls[:test_delete][:options][:tag]).to eq(5)
+  end
+
+  it "should allow for mapped calls on the class" do
+    expect(MappingExample).to respond_to(:test_get)
+  end
+end

data/spec/lib/proxy_spec.rb

@@ -0,0 +1,189 @@
+require 'spec_helper'
+require 'active_support/core_ext/hash'
+
+class ProxyExample < Flexirest::ProxyBase
+  get "/all" do
+    url.gsub!("/all", "/getAll")
+    passthrough
+  end
+
+  get "/old" do
+    url "/new"
+    passthrough
+  end
+
+  get "/list" do
+    get_params[:first_name] = get_params.delete(:fname)
+    get_params[:age] = 12
+    get_params.delete(:lname)
+    passthrough
+  end
+
+  post "/create" do
+    post_params[:first_name] = post_params.delete(:fname)
+    post_params[:age] = 12
+    post_params.delete(:lname)
+    passthrough
+  end
+
+  put "/update" do
+    body "MY-BODY-CONTENT"
+    passthrough
+  end
+
+  delete '/remove' do
+    passthrough
+  end
+
+  get "/change-format" do
+    response = passthrough
+    translate(response) do |body|
+      body["first_name"] = body.delete("fname")
+      body
+    end
+  end
+
+  get "/change-xml-format" do
+    response = passthrough
+    translate(response) do |body|
+      body["first_name"] = body["object"].delete("fname")
+      body
+    end
+  end
+
+  get "/hal_test/:id" do
+    response = passthrough
+    translate(response) do |body|
+      body["_links"] = {"test" => {href:"/this/is/a/test"}}
+      body
+    end
+  end
+
+  get "/param/:id/:name" do
+    render "{\"id\":\"#{params[:id]}\", \"name\":\"#{params[:name]}\"}"
+  end
+
+  get "/fake" do
+    render "{\"id\":1234}"
+  end
+end
+
+class ProxyClientExample < Flexirest::Base
+  proxy ProxyExample
+  base_url "http://www.example.com"
+
+  get :all, "/all"
+  get :old, "/old"
+  get :list, "/list"
+  get :fake, "/fake"
+  get :param, "/param/:id/:name"
+  get :change_format, "/change-format"
+  get :change_xml_format, "/change-xml-format"
+  post :create, "/create"
+  put :update, "/update"
+  get :not_proxied, "/not_proxied"
+  delete :remove, "/remove"
+  get :hal_test, "/hal_test/:id"
+end
+
+describe Flexirest::Base do
+  it "allows the URL to be changed" do
+    expect_any_instance_of(Flexirest::Connection).to receive(:get).with("/getAll?id=1", instance_of(Hash)).and_return(OpenStruct.new(body:"{\"result\":true}", status:200, headers:{}))
+    ProxyClientExample.all(id:1)
+  end
+
+  it "allows the URL to be replaced" do
+    expect_any_instance_of(Flexirest::Connection).to receive(:get).with("/new", instance_of(Hash)).and_return(OpenStruct.new(body:"{\"result\":true}", status:200, headers:{}))
+    ProxyClientExample.old
+  end
+
+  it "has access to the GET params and allow them to be changed/removed/added" do
+    expect_any_instance_of(Flexirest::Connection).to receive(:get).with("/list?age=12&first_name=John", instance_of(Hash)).and_return(OpenStruct.new(body:"{\"result\":true}", status:200, headers:{}))
+    ProxyClientExample.list(fname:"John", lname:"Smith")
+  end
+
+  it "has access to the POST params and allow them to be changed/removed/added" do
+    expect_any_instance_of(Flexirest::Connection).to receive(:post).with("/create", {age:12, first_name:"John"}.to_query, instance_of(Hash)).and_return(OpenStruct.new(body:"{\"result\":true}", status:200, headers:{}))
+    ProxyClientExample.create(fname:"John", lname:"Smith")
+  end
+
+  it "has access to raw body content for requests" do
+    expect_any_instance_of(Flexirest::Connection).to receive(:put).with("/update", "MY-BODY-CONTENT", instance_of(Hash)).and_return(::FaradayResponseMock.new(OpenStruct.new(body:"{\"result\":true}", status:200, response_headers:{})))
+    ProxyClientExample.update(fname:"John", lname:"Smith")
+  end
+
+  it "handles DELETE requests" do
+    expect_any_instance_of(Flexirest::Connection).to receive(:delete).with("/remove", instance_of(Hash)).and_return(::FaradayResponseMock.new(OpenStruct.new(body:"{\"result\":true}", status:200, response_headers:{})))
+    ProxyClientExample.remove
+  end
+
+  it "can return fake JSON data and have this parsed in the normal way" do
+    expect_any_instance_of(Flexirest::Connection).not_to receive(:get).with("/fake", instance_of(Hash))
+    ret = ProxyClientExample.fake
+    expect(ret.id).to eq(1234)
+  end
+
+  it "can intercept the response and parse the response, alter it and pass it on during the request" do
+    expect_any_instance_of(Flexirest::Connection).to receive(:get).with("/change-format", instance_of(Hash)).and_return(::FaradayResponseMock.new(OpenStruct.new(body:"{\"fname\":\"Billy\"}", status:200, response_headers:{})))
+    ret = ProxyClientExample.change_format
+    expect(ret.first_name).to eq("Billy")
+  end
+
+  it "can intercept XML responses, parse the response, alter it and pass it on during the request" do
+    expect_any_instance_of(Flexirest::Connection).to receive(:get).with("/change-xml-format",
+      instance_of(Hash)).and_return(::FaradayResponseMock.new(OpenStruct.new(
+      body:"<?xml version=\"1.0\" encoding=\"UTF-8\"?><object><fname>Billy</fname></object>",
+      status:200,
+      response_headers:{"Content-Type" => "application/xml"})))
+    ret = ProxyClientExample.change_xml_format
+    expect(ret.first_name).to eq("Billy")
+  end
+
+  it 'skips the altering of the response body when there is none' do
+    allow_any_instance_of(Flexirest::Connection).to receive(:get).with('/change-format', instance_of(Hash))
+      .and_return(double(body: '', status: 200, headers: {}))
+    result = ProxyClientExample.change_format
+    expect(result._attributes).to be_empty
+  end
+
+  it "can continue with the request in the normal way, passing it on to the server" do
+    expect_any_instance_of(Flexirest::Connection).to receive(:get).with("/not_proxied?id=1", instance_of(Hash)).and_return(::FaradayResponseMock.new(OpenStruct.new(body:"{\"result\":true}", status:200, response_headers:{})))
+    ProxyClientExample.not_proxied(id:1)
+  end
+
+  it "caches responses in the standard way" do
+
+     cached_response = Flexirest::CachedResponse.new(
+        status:200,
+        result:@cached_object,
+        etag:@etag)
+
+    cache_store = double("CacheStore")
+    allow(cache_store).to receive(:read).with(any_args).and_return(nil)
+    ProxyClientExample.perform_caching true
+    allow(ProxyClientExample).to receive(:cache_store).and_return(cache_store)
+    expiry = 10.minutes.from_now.rfc2822
+    expect_any_instance_of(Flexirest::Connection).to receive(:put).with("/update", "MY-BODY-CONTENT", instance_of(Hash)).and_return(::FaradayResponseMock.new(OpenStruct.new(body:"{\"result\":true}", status:200, response_headers:{"Expires" => expiry, "ETag" => "123456"})))
+    expect(ProxyClientExample.cache_store).to receive(:write) do |key, object, options|
+      expect(key).to eq("ProxyClientExample:/update")
+      expect(object).to be_an_instance_of(String)
+      unmarshalled = Marshal.load(object)
+      expect(unmarshalled.etag).to eq("123456")
+      expect(unmarshalled.expires).to eq(expiry)
+    end
+    ProxyClientExample.update(id:1)
+  end
+
+  it "can have parameters in the URL" do
+    ret = ProxyClientExample.param(id:1234, name:"Johnny")
+    expect(ret.id).to eq("1234")
+    expect(ret.name).to eq("Johnny")
+  end
+
+  it "can force the URL from a filter without it being passed through URL replacement" do
+    expect_any_instance_of(Flexirest::Connection).to receive(:get).with("/hal_test/1", instance_of(Hash)).and_return(::FaradayResponseMock.new(OpenStruct.new(body:"{\"result\":true}", status:200, response_headers:{})))
+    expect_any_instance_of(Flexirest::Connection).to receive(:get).with("/this/is/a/test", instance_of(Hash)).and_return(::FaradayResponseMock.new(OpenStruct.new(body:"{\"result\":true}", status:200, response_headers:{})))
+    expect(ProxyClientExample.hal_test(id:1).test.result).to eq(true)
+  end
+
+end

data/spec/lib/recording_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Flexirest::Recording do
+  it "can confirm if a recording callback is set" do
+    class MyObject1
+      include Flexirest::Recording
+    end
+    expect(MyObject1.record_response?).to be_falsey
+    MyObject1.record_response do
+      puts "Hello world"
+    end
+    expect(MyObject1.record_response?).to be_truthy
+  end
+
+  it "remembers a block given to it to later be called back" do
+    class MyObject2
+      include Flexirest::Recording
+    end
+    MyObject2.record_response do
+      puts "Hello world"
+    end
+    expect(MyObject2.instance_variable_get(:@record_response)).to_not be_nil
+  end
+
+  it "calls back to the block if record_response is given a url and response" do
+    class MyObject3
+      include Flexirest::Recording
+    end
+    MyObject3.record_response do |url, response|
+      raise Exception.new("#{url}|#{response}")
+    end
+    expect{MyObject3.record_response("http://www.example.com/", "Hello world")}.to raise_error(Exception, 'http://www.example.com/|Hello world')
+  end
+end

data/spec/lib/request_filtering_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+class RequestFilteringExample
+  include Flexirest::RequestFiltering
+
+  before_request do |name, request|
+    request.get_params[:filter1] = "Hello"
+  end
+
+  before_request do |name, request|
+    request.post_params[:post_filter1] = "World"
+  end
+
+  before_request do |name, request|
+    request.headers["X-My-Header"] = "myvalue"
+  end
+
+  before_request :set_to_ssl
+  before_request :set_via_instance
+
+  after_request :change_body
+
+  private
+
+  def self.set_to_ssl(name, request)
+    request.url.gsub!("http://", "https://")
+  end
+
+  def set_via_instance(name, request)
+    request.url.gsub!("//www", "//new")
+  end
+
+  def change_body(name, response)
+    response.body = "{test: 1}"
+  end
+end
+
+class SubClassedRequestFilteringExample < RequestFilteringExample
+  before_request do |name, request|
+    request.get_params[:api_key] = 1234
+  end
+end
+
+describe Flexirest::RequestFiltering do
+  let(:request) { OpenStruct.new(get_params:{}, post_params:{}, url:"http://www.example.com", headers:Flexirest::HeadersList.new) }
+  let(:response) { OpenStruct.new(body:"") }
+
+  it "should call through to adjust the parameters" do
+    RequestFilteringExample._filter_request(:before, :test, request)
+    expect(request.get_params).to have_key(:filter1)
+  end
+
+  it "should call through for more than one filter" do
+    RequestFilteringExample._filter_request(:before, :test, request)
+    expect(request.get_params).to have_key(:filter1)
+    expect(request.post_params).to have_key(:post_filter1)
+  end
+
+  it "should allow adjusting the URL via a named filter" do
+    RequestFilteringExample._filter_request(:before, :test, request)
+    expect(request.url).to match(/https:\/\//)
+  end
+
+  it "should allow adjusting the URL via a named filter as an instance method" do
+    RequestFilteringExample._filter_request(:before, :test, request)
+    expect(request.url).to match(/\/\/new\./)
+  end
+
+  it "should allow filters to be set on the parent or on the child" do
+    SubClassedRequestFilteringExample._filter_request(:before, :test, request)
+    expect(request.url).to match(/\/\/new\./)
+    expect(request.get_params[:api_key]).to eq(1234)
+  end
+
+  it "should allow filters to add custom headers" do
+    RequestFilteringExample._filter_request(:before, :test, request)
+    expect(request.headers["X-My-Header"]).to eq("myvalue")
+  end
+
+  it "should be able to alter the response body" do
+    RequestFilteringExample._filter_request(:after, :test, response)
+    expect(response.body).to eq("{test: 1}")
+  end
+end