angus-remote 0.0.1 → 0.0.2

data/spec/angus/remote/builder_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+require 'angus/remote/client'
+require 'angus/remote/builder'
+
+describe Angus::Remote::Builder do
+
+  subject(:builder) { Angus::Remote::Builder }
+
+  describe '.build' do
+
+    let(:code_name) { 'vpos' }
+    let(:operation) { double(:operation, :code_name=> 'get_users', :service_name => 'vpos', :path => '/users', :method => :get) }
+    let(:proxy_operation) { double(:proxy_operation, :code_name=> 'get_users_proxy', :service_name => 'vpos', :path => '/users', :method => :get) }
+    let(:glossary) { double(:glossary, :terms_hash_with_long_names => {}) }
+    let(:service_definition) { double(:vpos, :name => 'Vpos', :operations => { 'users' => [operation] },
+                                      :proxy_operations => { 'users' => [proxy_operation] }, :version => '0.1', :glossary => glossary) }
+
+    let(:api_url) { 'http://localhost:8085/vpos/api/0.1/' }
+
+    describe 'the returned class' do
+
+      subject(:client) { builder.build(code_name, service_definition, api_url) }
+
+      it 'is of class Angus::Remote::Client' do
+        should be_kind_of(Angus::Remote::Client)
+      end
+
+      it 'responds to the defined operation' do
+        should respond_to(:get_users)
+      end
+
+      describe 'the generated operation' do
+
+        let(:response) { double(:response, :code => 200, :body => JSON({ :status => 'success' })) }
+
+        let(:service_configuration) {
+          {
+            'v0.1' => { 'doc_url' => 'some_url/doc', 'api_url' => 'some_url/api' }
+          }
+        }
+
+        let(:service_def) {
+          {
+            'service' => { 'service' => 'vpos'  }, 'code_name' => 'vpos', 'version' => '0.1',
+            'operations' => { 'users' => { 'get_users' => { 'name' => 'Obtener usuarios'} } }
+          }
+
+        }
+
+        before do
+          Angus::Remote::ServiceDirectory.stub(:service_configuration => service_configuration)
+          Angus::Remote::ServiceDirectory.stub(:fetch_remote_service_definition => service_def)
+        end
+
+        it 'makes a request to the remote service' do
+          client.should_receive(:make_request).and_return(response)
+
+          client.get_users
+        end
+
+        describe 'the generated proxy operation' do
+
+          before do
+            Angus::Remote::ServiceDirectory.stub(:service_configuration => { 'v0.1' => { 'doc_url' => 'some_url/doc', 'api_url' => 'some_url/api' } })
+            Angus::Remote::ServiceDirectory.stub(:fetch_remote_service_definition => { 'service' => { 'service' => 'vpos'  }, 'code_name' => 'vpos', 'version' => '0.1', 'operations' => { 'users' => { 'get_users_proxy' => { 'name' => 'Obtener usuarios' } } } })
+          end
+
+          it 'makes a request to the remote service' do
+            client.should_receive(:make_request).and_return(response)
+
+            client.get_users_proxy
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+  describe '.build_client_class' do
+
+    let(:name) { 'Foo' }
+    let(:url) { 'http://bar' }
+
+    it 'returns a client class' do
+      client_class = builder.build_client_class(name)
+
+      client = client_class.new(url)
+
+      client.should be_kind_of(Angus::Remote::Client)
+    end
+
+    describe 'the returned class' do
+      subject { builder.build_client_class(name) }
+
+      its(:name) { should include(name) }
+      its(:to_s) { should include(name) }
+    end
+
+  end
+
+end

data/spec/angus/remote/client_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+require 'angus/remote/client'
+
+describe Angus::Remote::Client do
+
+  let(:url) { 'http://bar' }
+  subject(:client) { Angus::Remote::Client.new(url) }
+
+  describe '#to_s' do
+
+    it 'returns the class name and the object id' do
+      client.to_s.should eq("#<#{client.class}:#{client.object_id}>")
+    end
+
+  end
+
+  describe '#make_request' do
+
+    it 'returns the remote service response' do
+      response = double(:response, :code => 200, :body => '[]')
+      PersistentHTTP.any_instance.stub(:request => response)
+
+      client.make_request('/users', 'get', false, [], {}).should eq(response)
+    end
+
+    context 'when an invalid method is used' do
+      it 'raises MethodArgumentError' do
+        expect {
+          client.make_request('/', 'INVALID_METHOD', false, [], {})
+        }.to raise_error(Angus::Remote::MethodArgumentError)
+      end
+    end
+
+    context 'when less path_params that expected' do
+      it 'raises PathArgumentError' do
+        expect {
+          client.make_request('/a/:b/c/:d', 'get', false, [], {})
+        }.to raise_error(Angus::Remote::PathArgumentError)
+      end
+    end
+
+    context 'when more path_params that expected' do
+      it 'raises PathArgumentError' do
+        expect {
+          client.make_request('/a/:b/c/:d', 'get', false, [1, 2, 3], {})
+        }.to raise_error(Angus::Remote::PathArgumentError)
+      end
+    end
+
+    context 'when the remote service returns a severe error response' do
+      let(:error_response) { double(:error_response, :code => 500, :body => '') }
+
+      before { PersistentHTTP.any_instance.stub(:request => error_response) }
+
+      it 'raises RemoteSevereError' do
+        expect {
+          client.make_request('/users', 'get', false, [], {})
+        }.to raise_error(Angus::Remote::RemoteSevereError)
+      end
+    end
+
+    context 'when the remote service rejects the connection' do
+      before { PersistentHTTP.any_instance.stub(:request).and_raise(Errno::ECONNREFUSED) }
+
+      it 'raises RemoteConnectionError' do
+        expect {
+          client.make_request('/users', 'get', false, [], {})
+        }.to raise_error(Angus::Remote::RemoteConnectionError)
+      end
+    end
+
+  end
+
+end

data/spec/angus/remote/http/multipart_methods/multipart_base_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+require 'angus/remote/http/multipart_methods/multipart_base'
+
+describe Http::MultipartMethods::MultipartBase do
+
+  let :request_class do
+    Class.new(Net::HTTP::Post) do
+      include Http::MultipartMethods::MultipartBase
+    end
+  end
+
+  context 'headers set by .body= are retained if .initialize_http_header is called afterwards' do
+    def request_with_headers(headers)
+      request_class.new('/path').tap do |request|
+        request.body = { :some => :var }
+        request.initialize_http_header(headers)
+      end
+    end
+
+    context 'with a header' do
+      subject { request_with_headers({'a' => 'header'}).to_hash }
+
+      it { should include('content-length') }
+      it { should include('a') }
+    end
+
+    context 'without a header' do
+      subject { request_with_headers(nil).to_hash }
+
+      it { should include('content-length') }
+      it { should_not include('a') }
+    end
+  end
+
+end

data/spec/angus/remote/http/multipart_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+
+require 'fakefs/spec_helpers'
+
+require 'angus/remote/http/multipart'
+
+describe Http::Multipart do
+
+  include FakeFS::SpecHelpers
+
+  let(:file_name) { 'some_file.txt' }
+
+  let(:file) { File.new(file_name) }
+  let(:tempfile) { Tempfile.new('tempfile', temp_dir) }
+  let(:temp_dir) { '/tmp' }
+  let(:some_upload_io) { UploadIO.new(file, 'application/octet-stream') }
+
+  before do
+    Dir.mkdir('/tmp')
+
+    File.new(file_name, 'w')
+  end
+
+  describe '.hash_contains_files?' do
+
+    it 'should return true if one of the values in the passed hash is a file' do
+      Http::Multipart.hash_contains_files?({:a => 1, :file => file}).should be_true
+    end
+
+    it 'should return true if one of the values in the passed hash is an upload io' do
+      Http::Multipart.hash_contains_files?({:a => 1, :file => some_upload_io}).should be_true
+    end
+
+    it 'should return true if one of the values in the passed hash is a tempfile' do
+      Http::Multipart.hash_contains_files?({:a => 1, :file => tempfile}).should be_true
+    end
+
+    it 'should return false if none of the values in the passed hash is a file' do
+      Http::Multipart.hash_contains_files?({:a => 1, :b => 'nope'}).should be_false
+    end
+
+    it 'should return true if passed hash includes an a array of files' do
+      Http::Multipart.hash_contains_files?({:files => [file, file]}).should be_true
+    end
+
+  end
+
+
+  describe '.file_to_upload_io' do
+
+    it 'should get the physical name of a file' do
+      Http::Multipart.file_to_upload_io(file).original_filename.should == file_name
+    end
+
+    it 'should get the physical name of a file' do
+      # Let's pretend this is a file upload to a rack app.
+      tempfile.stub(:original_filename => 'stuff.txt')
+
+      Http::Multipart.file_to_upload_io(tempfile).original_filename.should == 'stuff.txt'
+    end
+
+  end
+
+  describe '.flatten_params' do
+
+    it 'should handle complex hashs' do
+      Http::Multipart.flatten_params({
+                                       :foo => 'bar',
+                                       :deep => {
+                                         :deeper  => 1,
+                                         :deeper2 => 2,
+                                         :deeparray => [1,2,3],
+                                         :deephasharray => [
+                                           {:id => 1},
+                                           {:id => 2}
+                                         ]
+                                       }
+                                     }).sort_by(&:join).should == [
+        ['foo',                         'bar'],
+        ['deep[deeper]',                1],
+        ['deep[deeper2]',               2],
+        ['deep[deeparray][]',           1],
+        ['deep[deeparray][]',           2],
+        ['deep[deeparray][]',           3],
+        ['deep[deephasharray][][id]',   1],
+        ['deep[deephasharray][][id]',   2],
+      ].sort_by(&:join)
+    end
+
+  end
+
+  describe '::QUERY_STRING_NORMALIZER' do
+
+    subject { Http::Multipart::QUERY_STRING_NORMALIZER }
+
+    it 'should map a file to UploadIO' do
+      (first_k, first_v) = subject.call({
+                                          :file => file
+                                        }).first
+
+      first_v.should be_an UploadIO
+    end
+
+    it 'should map a Tempfile to UploadIO' do
+      (first_k, first_v) = subject.call({
+                                          :file => tempfile
+                                        }).first
+
+      first_v.should be_an UploadIO
+    end
+
+    it 'should map an array of files to UploadIOs' do
+      subject.call({
+                     :file => [file, tempfile]
+                   }).each { |(k,v)| v.should be_an UploadIO }
+    end
+
+  end
+
+end

data/spec/angus/remote/http/query_params_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+require 'angus/remote/http/query_params'
+
+describe Http::QueryParams do
+
+  describe '.to_params' do
+
+    let(:params) {
+      { :name => 'Bob',
+        :address => {
+          :phones => %w[111-111-1111 222-222-2222],
+          :street => '111 Ruby Ave.',
+          :zone => {
+            :country => 'Ruby',
+            :city => 'Gem Central',
+          }
+        }
+      }
+    }
+
+    it 'returns the expected string' do
+      Http::QueryParams.to_params(params).should eq('name=Bob&address[phones][]=111-111-1111&address[phones][]=222-222-2222&address[street]=111%20Ruby%20Ave.&address[zone][country]=Ruby&address[zone][city]=Gem%20Central')
+    end
+
+  end
+
+end

data/spec/angus/remote/proxy_client_utils_spec.rb

@@ -0,0 +1,102 @@
+require 'net/http'
+
+require 'json'
+
+require 'angus/remote/proxy_client_utils'
+
+describe Angus::Remote::ProxyClientUtils do
+
+  subject(:utils) { Angus::Remote::ProxyClientUtils }
+
+  describe '.build_request' do
+
+    let(:path) { '/' }
+    let(:query) { 'q=listing' }
+
+    shared_examples 'a request builder' do |method, kind_of|
+      context "when #{method}" do
+        it "returns a kind_of #{kind_of}" do
+          res = utils.build_request(method, path, query)
+
+          res.should be_a(kind_of)
+        end
+      end
+    end
+
+    it_behaves_like 'a request builder', :get,     Net::HTTP::Get
+    it_behaves_like 'a request builder', :post,    Net::HTTP::Post
+    it_behaves_like 'a request builder', :put,     Net::HTTP::Put
+    it_behaves_like 'a request builder', :delete,  Net::HTTP::Delete
+
+    context 'with headers' do
+      it 'sets the to the request' do
+        headers = { 'a' => 'A', 'b' => 'B' }
+
+        res = utils.build_request(:get, path, query, headers)
+
+        res['a'].should eq('A')
+        res['b'].should eq('B')
+      end
+    end
+
+    context 'with body' do
+      it 'sets the body to the request' do
+        body = 'BODY'
+
+        res = utils.build_request(:get, path, query, {}, body)
+
+        res.body.should eq(body)
+      end
+    end
+
+    context 'when invalid http method' do
+      it 'raises MethodArgumentError' do
+        expect {
+          utils.build_request(:invalid, path, query)
+        }.to raise_error(Angus::Remote::MethodArgumentError)
+      end
+    end
+  end
+
+  describe '.filter_response_headers' do
+
+    it 'rejects non allowed headers' do
+      headers = {:not_allowed => 'header'}
+
+      res = utils.filter_response_headers(headers)
+
+      res.should_not include(:not_allowed)
+    end
+
+    it 'does not reject allowed headers' do
+      headers = {'content-type' => 'header'}
+
+      res = utils.filter_response_headers(headers)
+
+      res.should include('content-type')
+    end
+  end
+
+  describe '.normalize_headers' do
+    context 'when a header value is an array' do
+      it 'takes the first array element' do
+        headers = {'content-type' => ['application/json', 'image/gif']}
+
+        res = utils.normalize_headers(headers)
+
+        res.should include('content-type' => 'application/json')
+      end
+    end
+
+    context 'when simple headers' do
+      it 'does not affect anything' do
+        headers = {'content-type' => 'application/json'}
+
+        res = utils.normalize_headers(headers)
+
+        res.should include('content-type' => 'application/json')
+      end
+    end
+  end
+
+end