cobot_client 4.0.0 → 6.0.0

data/spec/cobot_client/api_client_spec.rb

@@ -1,133 +1,96 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe CobotClient::ApiClient do
-  let(:api_client) { CobotClient::ApiClient.new('token-123') }
-  let(:default_response) { double(:default_response, code: 200, body: '{}') }
-
-  before(:each) do
-    CobotClient::ApiClient.user_agent = 'test agent'
-    CobotClient::ApiClient.retry_time = 0
-  end
-
-  context 'listing resources' do
-    it 'calls rest client' do
-      expect(RestClient).to receive(:get).with('https://co-up.cobot.me/api/resources',
-        hash_including('Authorization' => 'Bearer token-123')) { default_response }
-
-      api_client.get_resources 'co-up'
-    end
-
-    it 'returns the json' do
-      allow(RestClient).to receive(:get) { double(:response, body: [{id: 'resource-1'}].to_json) }
-
-      resources = api_client.get_resources 'co-up'
-
-      expect(resources).to eql([{id: 'resource-1'}])
-    end
-  end
-
-  context 'creating a booking' do
-    it 'calls rest client' do
-      expect(RestClient).to receive(:post).with(
-        'https://co-up.cobot.me/api/resources/res-1/bookings',
-        {title: 'meeting'}.to_json,
-        hash_including('Authorization' => 'Bearer token-123')) { default_response }
-
-      api_client.create_booking 'co-up', 'res-1', title: 'meeting'
-    end
-
-    it 'returns the json' do
-      allow(RestClient).to receive(:post) { double(:response,
-        code: 201, body: {title: 'meeting'}.to_json) }
-
-      booking = api_client.create_booking 'co-up', 'res-1', title: 'meeting'
-
-      expect(booking).to eql({title: 'meeting'})
-    end
-  end
-
-  context 'updating a booking' do
-    it 'calls rest client' do
-      expect(RestClient).to receive(:put).with('https://co-up.cobot.me/api/bookings/booking-1',
-        {title: 'meeting'}.to_json,
-        hash_including('Authorization' => 'Bearer token-123')) { default_response }
-
-      api_client.update_booking 'co-up', 'booking-1', title: 'meeting'
-    end
-
-    it 'returns the json' do
-      allow(RestClient).to receive(:put) { double(:response, code: 200,
-        body: {title: 'meeting'}.to_json) }
+  let(:api_client) { described_class.new('token-123') }
+  let(:default_response) { {status: 200, body: '{}'} }
 
-      booking = api_client.update_booking 'co-up', 'booking-1', title: 'meeting'
+  def cobot_client_response(code:, body: '')
+    net_http_response = Net::HTTPResponse.new('1.1', code.to_s, nil)
+    net_http_response.body = body
+    net_http_response.instance_variable_set(:@read, true)
 
-      expect(booking).to eql({title: 'meeting'})
-    end
+    CobotClient::Response.new(net_http_response)
   end
 
-  context 'deleting a booking' do
-    it 'calls rest client' do
-      expect(RestClient).to receive(:delete).with('https://co-up.cobot.me/api/bookings/booking-1',
-        hash_including('Authorization' => 'Bearer token-123')) { default_response }
-
-      api_client.delete_booking 'co-up', 'booking-1'
-    end
+  before do
+    described_class.user_agent = 'test agent'
+    described_class.retry_time = 0
   end
 
-  context '#put' do
-    it 'calls rest client' do
-      expect(RestClient).to receive(:put).with(
-        'https://co-up.cobot.me/api/invoices',
-        {id: '1'}.to_json,
-        'Content-Type' => 'application/json',
-          'User-Agent' => 'test agent',
-          'Authorization' => 'Bearer token-123') { default_response }
+  describe '#put' do
+    it 'accepts a subdomain' do
+      request = stub_request(:put, 'https://co-up.cobot.me/api/invoices')
+                .with(
+                  body: {id: '1'}.to_json,
+                  headers: {
+                    'Content-Type' => 'application/json',
+                    'User-Agent' => 'test agent',
+                    'Authorization' => 'Bearer token-123'
+                  }
+                )
+                .and_return(default_response)
 
       api_client.put 'co-up', '/invoices', {id: '1'}
+
+      expect(request).to have_been_made.once
     end
 
     it 'passes an array as body' do
-      expect(RestClient).to receive(:put).with(
-        'https://co-up.cobot.me/api/invoices',
-        [{id: '1'}].to_json,
-        'Content-Type' => 'application/json',
-          'User-Agent' => 'test agent',
-          'Authorization' => 'Bearer token-123') { default_response }
+      request = stub_request(:put, 'https://co-up.cobot.me/api/invoices')
+                .with(
+                  body: [{id: '1'}].to_json,
+                  headers: {
+                    'Content-Type' => 'application/json',
+                    'User-Agent' => 'test agent',
+                    'Authorization' => 'Bearer token-123'
+                  }
+                )
+                .and_return(default_response)
 
       api_client.put 'co-up', '/invoices', [{id: '1'}]
+
+      expect(request).to have_been_made.once
     end
 
     it 'accepts a url' do
-      expect(RestClient).to receive(:put).with(
-        'https://co-up.cobot.me/api/invoices',
-        {id: '1'}.to_json,
-        'Content-Type' => 'application/json',
-          'User-Agent' => 'test agent',
-          'Authorization' => 'Bearer token-123') { default_response }
+      request = stub_request(:put, 'https://co-up.cobot.me/api/invoices')
+                .with(
+                  body: {id: '1'}.to_json,
+                  headers: {
+                    'Content-Type' => 'application/json',
+                    'User-Agent' => 'test agent',
+                    'Authorization' => 'Bearer token-123'
+                  }
+                )
+                .and_return(default_response)
 
       api_client.put 'https://co-up.cobot.me/api/invoices', {id: '1'}
+
+      expect(request).to have_been_made.once
     end
 
     it 'returns the response json' do
-      allow(RestClient).to receive(:put) { double(:response, code: 200, body: [{number: 1}].to_json) }
+      allow_any_instance_of(CobotClient::Request).to receive(:submit) { cobot_client_response(code: 200, body: [{number: 1}].to_json) }
 
       expect(api_client.put('co-up', '/invoices', {})).to eql([{number: 1}])
     end
 
     it 'returns nil when the status code is 204' do
-      allow(RestClient).to receive(:put) { double(:response, body: '', code: 204) }
+      allow_any_instance_of(CobotClient::Request).to receive(:submit) { cobot_client_response(body: '', code: 204) }
 
       expect(api_client.put('co-up', '/invoices', {})).to be_nil
     end
 
     it 'retries a 502 error' do
-      @times = 0
-      allow(RestClient).to receive(:put) do
-        if @times < 3
-          @times += 1
-          fail RestClient::BadGateway
+      times = 0
+      allow_any_instance_of(CobotClient::Request).to receive(:submit) do
+        if times < 3
+          times += 1
+          cobot_client_response(code: 502)
         else
-          double(code: 200, body: {success: true}.to_json)
+          cobot_client_response(code: 200, body: {success: true}.to_json)
         end
       end
 
@@ -135,49 +98,61 @@ describe CobotClient::ApiClient do
     end
   end
 
-  context '#patch' do
-    it 'calls rest client' do
-      expect(RestClient).to receive(:patch).with(
-        'https://co-up.cobot.me/api/invoices',
-        {id: '1'}.to_json,
-        'Content-Type' => 'application/json',
-          'User-Agent' => 'test agent',
-          'Authorization' => 'Bearer token-123') { default_response }
+  describe '#patch' do
+    it 'accepts a subdomain' do
+      request = stub_request(:patch, 'https://co-up.cobot.me/api/invoices')
+                .with(
+                  body: {id: '1'}.to_json,
+                  headers: {
+                    'Content-Type' => 'application/json',
+                    'User-Agent' => 'test agent',
+                    'Authorization' => 'Bearer token-123'
+                  }
+                )
+                .and_return(default_response)
 
       api_client.patch 'co-up', '/invoices', {id: '1'}
+
+      expect(request).to have_been_made.once
     end
 
     it 'accepts a url' do
-      expect(RestClient).to receive(:patch).with(
-        'https://co-up.cobot.me/api/invoices',
-        {id: '1'}.to_json,
-        'Content-Type' => 'application/json',
-          'User-Agent' => 'test agent',
-          'Authorization' => 'Bearer token-123') { default_response }
+      request = stub_request(:patch, 'https://co-up.cobot.me/api/invoices')
+                .with(
+                  body: {id: '1'}.to_json,
+                  headers: {
+                    'Content-Type' => 'application/json',
+                    'User-Agent' => 'test agent',
+                    'Authorization' => 'Bearer token-123'
+                  }
+                )
+                .and_return(default_response)
 
       api_client.patch 'https://co-up.cobot.me/api/invoices', {id: '1'}
+
+      expect(request).to have_been_made.once
     end
 
     it 'returns the response json' do
-      allow(RestClient).to receive(:patch) { double(:response, code: 200, body: [{number: 1}].to_json) }
+      allow_any_instance_of(CobotClient::Request).to receive(:submit) { cobot_client_response(code: 200, body: [{number: 1}].to_json) }
 
       expect(api_client.patch('co-up', '/invoices', {})).to eql([{number: 1}])
     end
 
     it 'returns nil when the status code is 204' do
-      allow(RestClient).to receive(:patch) { double(:response, body: '', code: 204) }
+      allow_any_instance_of(CobotClient::Request).to receive(:submit) { cobot_client_response(body: '', code: 204) }
 
       expect(api_client.patch('co-up', '/invoices', {})).to be_nil
     end
 
     it 'retries a 502 error' do
-      @times = 0
-      allow(RestClient).to receive(:patch) do
-        if @times < 3
-          @times += 1
-          fail RestClient::BadGateway
+      times = 0
+      allow_any_instance_of(CobotClient::Request).to receive(:submit) do
+        if times < 3
+          times += 1
+          cobot_client_response(code: 502)
         else
-          double(code: 200, body: {success: true}.to_json)
+          cobot_client_response(code: 200, body: {success: true}.to_json)
         end
       end
 
@@ -185,127 +160,162 @@ describe CobotClient::ApiClient do
     end
   end
 
-  context '#post' do
-    it 'calls rest client' do
-      expect(RestClient).to receive(:post).with(
-        'https://co-up.cobot.me/api/invoices',
-        {id: '1'}.to_json,
-        'Content-Type' => 'application/json',
-          'User-Agent' => 'test agent',
-          'Authorization' => 'Bearer token-123') { default_response }
+  describe '#post' do
+    it 'accepts a subdomain' do
+      request = stub_request(:post, 'https://co-up.cobot.me/api/invoices')
+                .with(
+                  body: {id: '1'}.to_json,
+                  headers: {
+                    'Content-Type' => 'application/json',
+                    'User-Agent' => 'test agent',
+                    'Authorization' => 'Bearer token-123'
+                  }
+                )
+                .and_return(default_response)
 
       api_client.post 'co-up', '/invoices', {id: '1'}
+
+      expect(request).to have_been_made.once
     end
 
     it 'accepts a url' do
-      expect(RestClient).to receive(:post).with(
-        'https://co-up.cobot.me/api/invoices',
-        {id: '1'}.to_json,
-        'Content-Type' => 'application/json',
-          'User-Agent' => 'test agent',
-          'Authorization' => 'Bearer token-123') { default_response }
+      request = stub_request(:post, 'https://co-up.cobot.me/api/invoices')
+                .with(
+                  body: {id: '1'}.to_json,
+                  headers: {
+                    'Content-Type' => 'application/json',
+                    'User-Agent' => 'test agent',
+                    'Authorization' => 'Bearer token-123'
+                  }
+                )
+                .and_return(default_response)
 
       api_client.post 'https://co-up.cobot.me/api/invoices', {id: '1'}
+
+      expect(request).to have_been_made.once
     end
 
     it 'returns the response json' do
-      allow(RestClient).to receive(:post) { double(:response,
-        code: 201, body: [{number: 1}].to_json) }
+      allow_any_instance_of(CobotClient::Request).to receive(:submit) {
+        cobot_client_response(code: 201, body: [{number: 1}].to_json)
+      }
 
       expect(api_client.post('co-up', '/invoices', {})).to eql([{number: 1}])
     end
 
     it 'returns nil when the status code is 204' do
-      allow(RestClient).to receive(:post) { double(:response, code: 204,
-        body: '') }
+      allow_any_instance_of(CobotClient::Request).to receive(:submit) {
+        cobot_client_response(code: 204, body: '')
+      }
 
       expect(api_client.post('co-up', '/invoices', {})).to be_nil
     end
   end
 
-  context '#get' do
-    it 'calls rest client' do
-      expect(RestClient).to receive(:get).with('https://co-up.cobot.me/api/invoices?from=2013-10-6&to=2013-10-12',
-        'User-Agent' => 'test agent', 'Authorization' => 'Bearer token-123') { default_response }
+  describe '#get' do
+    it 'accepts a subdomain' do
+      request = stub_request(:get, 'https://co-up.cobot.me/api/invoices?from=2013-10-6&to=2013-10-12')
+                .with(headers:
+                {
+                  'User-Agent' => 'test agent',
+                  'Authorization' => 'Bearer token-123'
+                })
+                .and_return(default_response)
 
       api_client.get 'co-up', '/invoices', {from: '2013-10-6', to: '2013-10-12'}
+
+      expect(request).to have_been_made.once
     end
 
     it 'accepts a url' do
-      expect(RestClient).to receive(:get).with('https://co-up.cobot.me/api/invoices?from=2013-10-6&to=2013-10-12',
-        'User-Agent' => 'test agent', 'Authorization' => 'Bearer token-123') { default_response }
+      request = stub_request(:get, 'https://co-up.cobot.me/api/invoices?from=2013-10-6&to=2013-10-12')
+                .with(headers:
+                {
+                  'User-Agent' => 'test agent',
+                  'Authorization' => 'Bearer token-123'
+                })
+                .and_return(default_response)
 
       api_client.get 'https://co-up.cobot.me/api/invoices', {from: '2013-10-6', to: '2013-10-12'}
+
+      expect(request).to have_been_made.once
     end
 
     it 'returns the response json' do
-      allow(RestClient).to receive(:get) { double(:response, body: [{number: 1}].to_json) }
+      allow_any_instance_of(CobotClient::Request).to receive(:submit) { cobot_client_response(code: 200, body: [{number: 1}].to_json) }
 
       expect(api_client.get('co-up', '/invoices')).to eql([{number: 1}])
     end
 
-    it 'converts a rest-client error into a cobot error' do
-      allow(RestClient).to receive(:get).and_raise(RestClient::NotFound)
+    it 'converts a net/http error into a cobot error' do
+      allow_any_instance_of(CobotClient::Request).to receive(:submit).and_raise(Timeout::Error.new)
 
       expect do
         api_client.get('co-up', '/invoices')
-      end.to raise_error(CobotClient::NotFound)
+      end.to raise_error(CobotClient::ConnectionError)
     end
 
-    it 'retries a RestClient::RequestTimeout' do
-      count = 0
-      allow(RestClient).to receive(:get) do
-        if count == 0
-          count += 1
-          fail RestClient::RequestTimeout
-        else
-          double(:response, body: '{}')
-        end
-      end
-
-      expect(RestClient).to receive(:get).exactly(2).times
+    it 'retries a Net::ReadTimeout' do
+      stub_request(:get, 'https://co-up.cobot.me/api/invoices')
+        .to_raise(Net::ReadTimeout.new)
+        .to_return(status: 200, body: '{}')
 
       api_client.get('co-up', '/invoices')
+
+      expect(a_request(:get, 'https://co-up.cobot.me/api/invoices')).to have_been_made.twice
     end
 
-    it 'converts a RestClient::RequestTimeout into a CobotClient::RequestTimeout' do
-      allow(RestClient).to receive(:get).and_raise(RestClient::RequestTimeout)
+    it 'converts a Net::ReadTimeout into a CobotClient::ConnectionError' do
+      allow_any_instance_of(CobotClient::Request).to receive(:submit).and_raise(Net::ReadTimeout.new)
 
       expect do
         api_client.get('co-up', '/invoices')
-      end.to raise_error(CobotClient::RequestTimeout)
+      end.to raise_error(CobotClient::ConnectionError, /^Net::ReadTimeout: /)
     end
 
     it 'includes the response, http code and http body in the exception' do
-      response = double(:response, code: 404, body: 'boom')
-      error = RestClient::NotFound.new(response)
-      allow(RestClient).to receive(:get).and_raise(error)
+      response = cobot_client_response(code: 404, body: 'boom')
+      error = response.to_error
+      allow_any_instance_of(CobotClient::Request).to receive(:submit).and_raise(error)
 
       begin
         api_client.get('co-up', '/invoices')
-      rescue CobotClient::NotFound => e
+      rescue CobotClient::ResponseError => e
+        expect(e).to be_a(CobotClient::NotFound)
         expect(e.response).to eql(response)
-        expect(e.http_code).to eql(404)
+        expect(e.http_code).to be(404)
         expect(e.http_body).to eql('boom')
       end
     end
   end
 
-  context '#delete' do
-    it 'calls rest client' do
-      expect(RestClient).to receive(:delete).with(
-        'https://co-up.cobot.me/api/invoices/1',
-        'User-Agent' => 'test agent', 'Authorization' => 'Bearer token-123') { default_response }
+  describe '#delete' do
+    it 'accepts a subdomain' do
+      request = stub_request(:delete, 'https://co-up.cobot.me/api/invoices/1')
+                .with(
+                  headers: {
+                    'User-Agent' => 'test agent',
+                    'Authorization' => 'Bearer token-123'
+                  }
+                ).and_return(default_response)
 
       api_client.delete 'co-up', '/invoices/1'
+
+      expect(request).to have_been_made.once
     end
 
     it 'accepts a url' do
-      expect(RestClient).to receive(:delete).with(
-        'https://co-up.cobot.me/api/invoices/1',
-        'User-Agent' => 'test agent', 'Authorization' => 'Bearer token-123') { default_response }
+      request = stub_request(:delete, 'https://co-up.cobot.me/api/invoices/1')
+                .with(
+                  headers: {
+                    'User-Agent' => 'test agent',
+                    'Authorization' => 'Bearer token-123'
+                  }
+                ).and_return(default_response)
 
       api_client.delete 'https://co-up.cobot.me/api/invoices/1'
+
+      expect(request).to have_been_made.once
     end
   end
 end

data/spec/cobot_client/navigation_link_service_spec.rb

@@ -1,36 +1,58 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
-describe CobotClient::NavigationLinkService, '#install_links' do
-  let(:service) { CobotClient::NavigationLinkService.new(api_client, 'co-up') }
-  let(:api_client) { instance_double(CobotClient::ApiClient) }
+describe CobotClient::NavigationLinkService do
+  let(:service) { described_class.new(api_client, 'co-up') }
+  let(:api_client) { CobotClient::ApiClient.new('access_token') }
 
   context 'when there are links already' do
     let(:existing_link) do
-      instance_double(CobotClient::NavigationLink, label: 'existing link',
-        section: 'admin/setup', iframe_url: 'http://example.com/1').as_null_object
+      CobotClient::NavigationLink.new(
+        label: 'existing link',
+        section: 'admin/setup',
+        iframe_url: 'http://example.com/1'
+      )
     end
     let(:new_link) do
-      instance_double(CobotClient::NavigationLink, label: 'new link',
-        section: 'admin/setup', iframe_url: 'http://example.com/2').as_null_object
+      CobotClient::NavigationLink.new(
+        label: 'new link',
+        section: 'admin/setup',
+        iframe_url: 'http://example.com/2'
+      )
     end
 
-    before(:each) do
+    before do
       allow(api_client).to receive(:get)
         .with('co-up', '/navigation_links')
-        .and_return([{label: 'existing link',
-          section: 'admin/setup', iframe_url: 'http://example.com/1'}])
+        .and_return(
+          [
+            {
+              label: 'existing link',
+              section: 'admin/setup',
+              iframe_url: 'http://example.com/1'
+            }
+          ]
+        )
     end
 
     it 'installs the missing links' do
       expect(api_client).to receive(:post)
-        .with('co-up', '/navigation_links', hash_including(label: 'new link',
-          section: 'admin/setup', iframe_url: 'http://example.com/2')) { {} }
+        .with(
+          'co-up',
+          '/navigation_links',
+          hash_including(
+            label: 'new link',
+            section: 'admin/setup',
+            iframe_url: 'http://example.com/2'
+          )
+        ).and_return({})
 
       service.install_links [existing_link, new_link]
     end
 
     it 'returns all the links' do
-      allow(api_client).to receive(:post) { {label: 'new link'} }
+      allow(api_client).to receive(:post).and_return({label: 'new link'})
 
       expect(service.install_links([existing_link, new_link]).map(&:label)).to eql(['existing link', 'new link'])
     end
@@ -38,28 +60,31 @@ describe CobotClient::NavigationLinkService, '#install_links' do
 
   context 'when there are no links installed' do
     let(:link) do
-      instance_double(CobotClient::NavigationLink,
-        section: 'admin/manage', label: 'test link', iframe_url: '/test',
-        user_editable: true)
+      CobotClient::NavigationLink.new(
+        section: 'admin/manage',
+        label: 'test link',
+        iframe_url: '/test',
+        user_editable: true
+      )
     end
 
-    before(:each) do
-      allow(api_client).to receive(:get).with('co-up', '/navigation_links') { [] }
+    before do
+      allow(api_client).to receive(:get).with('co-up', '/navigation_links').and_return([])
     end
 
     it 'installs the links' do
       expect(api_client).to receive(:post)
         .with('co-up', '/navigation_links',
-          section: 'admin/manage',
-          label: 'test link',
-          iframe_url: '/test',
-          user_editable: true) { {} }
+              section: 'admin/manage',
+              label: 'test link',
+              iframe_url: '/test',
+              user_editable: true).and_return({})
 
       service.install_links [link]
     end
 
     it 'returns the links created' do
-      allow(api_client).to receive(:post) { {label: 'test link'} }
+      allow(api_client).to receive(:post).and_return({label: 'test link'})
 
       expect(service.install_links([link]).map(&:label)).to eql(['test link'])
     end

data/spec/cobot_client/url_helper_spec.rb

@@ -1,18 +1,20 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
-describe CobotClient::UrlHelper, 'cobot_url' do
+describe CobotClient::UrlHelper do
   let(:helper) do
     Object.new.tap do |o|
-      o.extend CobotClient::UrlHelper
+      o.extend described_class
     end
   end
 
-  after(:each) do
-    CobotClient::UrlHelper.site = 'https://www.cobot.me'
+  after do
+    described_class.site = 'https://www.cobot.me'
   end
 
   it 'lets me change the site' do
-    CobotClient::UrlHelper.site = 'https://www.cobot.com'
+    described_class.site = 'https://www.cobot.com'
 
     expect(helper.cobot_url).to eql('https://www.cobot.com/')
   end
@@ -21,7 +23,7 @@ describe CobotClient::UrlHelper, 'cobot_url' do
     expect(helper.cobot_url).to eql('https://www.cobot.me/')
   end
 
-  it 'returns a url with a sudomain' do
+  it 'returns a url with a subdomain' do
     expect(helper.cobot_url('co-up')).to eql('https://co-up.cobot.me/')
   end
 

data/spec/spec_helper.rb

@@ -1 +1,11 @@
+# frozen_string_literal: true
+
+ENV['RBS_TEST_LOGLEVEL'] ||= 'error'
+ENV['RBS_TEST_TARGET'] ||= 'CobotClient*'
+
+require 'rbs/test/setup'
+
 require_relative '../lib/cobot_client'
+
+require 'webmock/rspec'
+WebMock.disable_net_connect!