cobot_client 5.0.0 → 6.0.0

data/rbs_collection.yaml

@@ -0,0 +1,20 @@
+# Download sources
+sources:
+  - type: git
+    name: ruby/gem_rbs_collection
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    revision: main
+    repo_dir: gems
+
+# You can specify local directories as sources also.
+# - type: local
+#   path: path/to/your/local/repository
+
+# A directory to install the downloaded RBSs
+path: .gem_rbs_collection
+
+gems:
+  - name: auth-sanitizer
+    ignore: true # See: https://github.com/ruby-oauth/auth-sanitizer/pull/5
+  - name: snaky_hash
+    ignore: true # See: https://github.com/ruby-oauth/snaky_hash/pull/11

data/sig/cobot_client/api_client.rbs

@@ -0,0 +1,51 @@
+module CobotClient
+  class ApiClient
+    type headers = Hash[String, String]
+    type path = String
+    type request_params = parsed_json_object
+    type request_payload = (request_params | Array[request_params])
+    type parsed_json_object = Hash[Symbol, untyped]
+    type parsed_response_body = (parsed_json_object | Array[parsed_json_object])?
+    type subdomain = String
+    type url = String
+
+    @access_token: String
+
+    attr_accessor self.retry_time: Integer
+    attr_accessor self.user_agent: String
+
+    def initialize: (String) -> void
+
+    def delete:
+      (subdomain, path) -> Response |
+      (url) -> Response
+
+    def get:
+      (subdomain, path, ?request_payload) -> parsed_response_body |
+      (url, ?request_payload) -> parsed_response_body
+
+    def patch:
+      (subdomain, path, ?request_payload) -> parsed_response_body |
+      (url, ?request_payload) -> parsed_response_body
+
+    def post:
+      (subdomain, path, ?request_payload) -> parsed_response_body |
+      (url, ?request_payload) -> parsed_response_body
+
+    def put:
+      (subdomain, path, ?request_payload) -> parsed_response_body |
+      (url, ?request_payload) -> parsed_response_body
+
+    private
+
+    def headers: -> headers
+
+    def request:
+      (Request::verb, subdomain, path, ?request_payload) -> Response |
+      (Request::verb, url, ?request_payload) -> Response
+
+    def retry_errors: [R] () { () -> R } -> R
+
+    def rewrap_errors: () { () -> Response } -> Response
+  end
+end

data/sig/cobot_client/errors.rbs

@@ -0,0 +1,23 @@
+module CobotClient
+  class Error < StandardError
+  end
+
+  class ConnectionError < StandardError
+  end
+
+  class ResponseError < Error
+    HTTP_CODE: Integer?
+
+    def self.build: (String?, response: Response) -> ResponseError
+
+    attr_reader response: Response?
+
+    def initialize: (String?, ?response: Response?) -> void
+
+    def http_body: -> String?
+
+    def http_code: -> Integer?
+  end
+
+  RESPONSE_CODE_TO_ERROR_CLASS: Hash[Integer, singleton(ResponseError)]
+end

data/sig/cobot_client/navigation_link.rbs

@@ -0,0 +1,11 @@
+module CobotClient
+  class NavigationLink
+    attr_accessor section: String
+    attr_accessor label: String
+    attr_accessor iframe_url: String
+    attr_accessor user_url: String
+    attr_accessor user_editable: bool
+
+    def initialize: (Hash[Symbol, untyped]) -> void
+  end
+end

data/sig/cobot_client/navigation_link_service.rbs

@@ -0,0 +1,17 @@
+module CobotClient
+  class NavigationLinkService
+    @api_client: ApiClient
+
+    @subdomain: String
+
+    def initialize: (ApiClient, String) -> void
+
+    def install_links: (Array[NavigationLink]) -> Array[NavigationLink]
+
+    private
+
+    def create_link: (NavigationLink) -> NavigationLink
+
+    def fetch_links: -> Array[NavigationLink]
+  end
+end

data/sig/cobot_client/request.rbs

@@ -0,0 +1,39 @@
+module CobotClient
+  class Request
+    type verb = Symbol
+
+    CONTENT_TYPE_HEADER: ApiClient::headers
+    VERBS: Array[verb]
+
+    @http: Net::HTTP
+
+    attr_reader body: String?
+    attr_reader headers: ApiClient::headers
+    attr_reader uri: URI::Generic
+    attr_reader verb: verb
+
+    def initialize:
+      (verb, ApiClient::subdomain, ApiClient::path, ?ApiClient::request_payload) -> void |
+      (verb, ApiClient::url, ?ApiClient::request_payload) -> void
+
+    def headers=: (ApiClient::headers) -> ApiClient::headers
+
+    def submit: -> Response
+
+    private
+
+    def build_uri: (ApiClient::subdomain | ApiClient::url, ApiClient::path?, **untyped) -> URI::Generic
+
+    def http: -> Net::HTTP
+
+    def net_http_request: -> Net::HTTPRequest
+
+    def parse_args:
+      (ApiClient::url) -> [ApiClient::url, nil, nil, ApiClient::request_payload] |
+      (ApiClient::url, ApiClient::request_payload) -> [ApiClient::url, nil, nil, ApiClient::request_payload] |
+      (ApiClient::subdomain, ApiClient::path) -> [nil, ApiClient::subdomain, ApiClient::path, ApiClient::request_payload] |
+      (ApiClient::subdomain, ApiClient::path, ApiClient::request_payload) -> [nil, ApiClient::subdomain, ApiClient::path, ApiClient::request_payload]
+
+    def request_class: -> singleton(Net::HTTPRequest)
+  end
+end

data/sig/cobot_client/response.rbs

@@ -0,0 +1,23 @@
+module CobotClient
+  class Response
+    @net_http_response: Net::HTTPResponse
+
+    def initialize: (Net::HTTPResponse) -> void
+
+    def body: -> String
+
+    def client_error?: -> bool
+
+    def code: -> Integer
+
+    def headers: -> ApiClient::headers
+
+    def parsed_body: -> ApiClient::parsed_response_body
+
+    def server_error?: -> bool
+
+    def success?: -> bool
+
+    def to_error: -> ResponseError?
+  end
+end

data/sig/cobot_client/url_helper.rbs

@@ -0,0 +1,25 @@
+module CobotClient
+  module UrlHelper
+    DEFAULT_SITE: String
+
+    self.@site: String
+
+    def self.site: -> String
+
+    def self.site=: (String) -> String
+
+    def cobot_uri:
+      () -> URI::Generic |
+      (ApiClient::subdomain) -> URI::Generic |
+      (ApiClient::subdomain, params: ApiClient::request_payload) -> URI::Generic |
+      (ApiClient::subdomain, ApiClient::path) -> URI::Generic |
+      (ApiClient::subdomain, ApiClient::path, params: ApiClient::request_payload) -> URI::Generic
+
+    def cobot_url:
+      () -> String |
+      (ApiClient::subdomain) -> String |
+      (ApiClient::subdomain, params: ApiClient::request_payload) -> String |
+      (ApiClient::subdomain, ApiClient::path) -> String |
+      (ApiClient::subdomain, ApiClient::path, params: ApiClient::request_payload) -> String
+  end
+end

data/sig/cobot_client/version.rbs

@@ -0,0 +1,3 @@
+module CobotClient
+  VERSION: String
+end

data/sig/manifests.yaml

@@ -0,0 +1,4 @@
+dependencies:
+  - name: json
+  - name: net/http
+  - name: uri

data/spec/cobot_client/api_client_spec.rb

@@ -1,68 +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: '{}') }
+  let(:api_client) { described_class.new('token-123') }
+  let(:default_response) { {status: 200, body: '{}'} }
+
+  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)
 
-  before(:each) do
-    CobotClient::ApiClient.user_agent = 'test agent'
-    CobotClient::ApiClient.retry_time = 0
+    CobotClient::Response.new(net_http_response)
   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 }
+  before do
+    described_class.user_agent = 'test agent'
+    described_class.retry_time = 0
+  end
+
+  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
 
@@ -70,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
 
@@ -120,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