spearly-sdk-ruby 0.9.0 → 0.11.0

data/spec/spearly/auth/client_spec.rb

@@ -8,44 +8,15 @@ RSpec.describe Spearly::Auth::Client do
   before do
     stub_const('ENV', { 'SPEARLY_API_URL' => 'https://api.spearly.test' })
 
-    allow(Faraday).to receive(:default_connection).and_return(connection_double)
+    allow(Faraday).to receive(:new).and_return(connection_double)
   end
 
-  describe '.create_team()' do
-    let!(:response_double) { instance_double(Faraday::Response, status: 201, body: { 'data' => { 'id' => '711' } }.to_json) }
-    let!(:params) { { hey: 'jude' } }
-    let!(:client) { described_class.new('token') }
-
-    before do
-      allow(connection_double).to receive(:post).and_return(response_double)
-    end
-
-    it 'makes POST request to /teams' do
-      uri_parsed = Addressable::URI.parse('https://api.spearly.test/teams').normalize.to_s
-
-      expect(connection_double).to receive(:post).with(uri_parsed,
-                                                       params.as_json,
-                                                       'Accept' => 'application/vnd.spearly.v2+json',
-                                                       'Authorization' => 'token')
+  it 'raises ServerError on Faraday::ConnectionFailed' do
+    allow(connection_double).to receive(:run_request).and_raise(Faraday::ConnectionFailed.new('Failed to open TCP connection to :80'))
 
+    expect do
       described_class.new('token')
-                     .create_team(params)
-    end
-
-    it 'returns data object if status is 201' do
-      res = client.create_team(params)
-
-      expect(res).to eq('id' => '711')
-    end
-
-    it 'returns errors object if status is 422' do
-      response_double = instance_double(Faraday::Response, status: 422, body: { 'errors' => { 'owner' => ["can't own more than 2 free teams"] } }.to_json)
-
-      allow(connection_double).to receive(:post).and_return(response_double)
-
-      res = client.create_team(params)
-
-      expect(res['errors']).to eq('owner' => ["can't own more than 2 free teams"])
-    end
+                     .run_request(:method => :get, path: '/connection_failed')
+    end.to raise_error(Spearly::Auth::ServerError, 'Failed to open TCP connection to :80')
   end
 end

data/spec/spearly/auth/team_member_spec.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Spearly::Auth::TeamMember do
+  let!(:connection_double) { instance_double(Faraday::Connection) }
+
+  before do
+    stub_const('ENV', { 'SPEARLY_API_URL' => 'https://api.spearly.test' })
+
+    allow(Faraday).to receive(:new).and_return(connection_double)
+  end
+
+  describe '.invite_user_to_team()' do
+    let!(:response_double) { instance_double(Faraday::Response, status: 201, body: { 'data' => { 'id' => 'team_invitation_1' } }.to_json) }
+    let!(:team_id) { '711' }
+    let!(:client) { Spearly::Auth::Client.new('token') }
+
+    let!(:params) do
+      {
+        email: 'hey@jude.test',
+        roles: {
+          cms: 'admin',
+          cloud: 'developer'
+        }
+      }
+    end
+
+    before do
+      allow(connection_double).to receive(:run_request).and_return(response_double)
+    end
+
+    it 'makes POST request to /teams/:team_id/invite' do
+      uri_parsed = Addressable::URI.parse('/teams/711/invite').normalize.to_s
+
+      expect(connection_double).to receive(:run_request).with(:post,
+                                                              uri_parsed,
+                                                              params,
+                                                              'Accept' => 'application/vnd.spearly.v2+json',
+                                                              'Authorization' => 'token')
+
+      client.invite_user_to_team(team_id, params)
+    end
+
+    it 'returns data array if status is 201' do
+      res = client.invite_user_to_team(team_id, params)
+
+      expect(res).to eq('data' => { 'id' => 'team_invitation_1' })
+    end
+
+    it 'throws AuthorizationError if 401' do
+      response_double = instance_double(Faraday::Response, status: 401)
+
+      allow(connection_double).to receive(:run_request).and_return(response_double)
+
+      expect do
+        client.invite_user_to_team(team_id, params)
+      end.to raise_error(Spearly::Auth::AuthorizationError)
+    end
+
+    it 'throws NotFoundError if 404' do
+      response_double = instance_double(Faraday::Response, status: 404)
+
+      allow(connection_double).to receive(:run_request).and_return(response_double)
+
+      expect do
+        client.invite_user_to_team(team_id, params)
+      end.to raise_error(Spearly::Auth::NotFoundError)
+    end
+
+    it 'throws ServerError if 500' do
+      response_double = instance_double(Faraday::Response, status: 500)
+
+      allow(connection_double).to receive(:run_request).and_return(response_double)
+
+      expect do
+        client.invite_user_to_team(team_id, params)
+      end.to raise_error(Spearly::Auth::ServerError)
+    end
+
+    it 'throws ServiceUnavailableError if 503' do
+      response_double = instance_double(Faraday::Response, status: 503)
+
+      allow(connection_double).to receive(:run_request).and_return(response_double)
+
+      expect do
+        client.invite_user_to_team(team_id, params)
+      end.to raise_error(Spearly::Auth::ServiceUnavailableError)
+    end
+  end
+
+  describe '.get_team_members()' do
+    let!(:response_double) { instance_double(Faraday::Response, status: 200, body: { 'data' => [{ 'id' => 'team_member_1' }] }.to_json) }
+    let!(:team_id) { '711' }
+    let!(:client) { Spearly::Auth::Client.new('token') }
+
+    before do
+      allow(connection_double).to receive(:run_request).and_return(response_double)
+    end
+
+    it 'makes GET request to /teams/:team_id/members' do
+      uri_parsed = Addressable::URI.parse('/teams/711/members').normalize.to_s
+
+      expect(connection_double).to receive(:run_request).with(:get,
+                                                              uri_parsed,
+                                                              nil,
+                                                              'Accept' => 'application/vnd.spearly.v2+json',
+                                                              'Authorization' => 'token')
+
+      client.get_team_members(team_id)
+    end
+
+    it 'returns data array if status is 200' do
+      res = client.get_team_members(team_id)
+
+      expect(res).to eq('data' => [{ 'id' => 'team_member_1' }])
+    end
+
+    it 'throws AuthorizationError if 401' do
+      response_double = instance_double(Faraday::Response, status: 401)
+
+      allow(connection_double).to receive(:run_request).and_return(response_double)
+
+      expect do
+        client.get_team_members(team_id)
+      end.to raise_error(Spearly::Auth::AuthorizationError)
+    end
+
+    it 'throws NotFoundError if 404' do
+      response_double = instance_double(Faraday::Response, status: 404)
+
+      allow(connection_double).to receive(:run_request).and_return(response_double)
+
+      expect do
+        client.get_team_members(team_id)
+      end.to raise_error(Spearly::Auth::NotFoundError)
+    end
+
+    it 'throws ServerError if 500' do
+      response_double = instance_double(Faraday::Response, status: 500)
+
+      allow(connection_double).to receive(:run_request).and_return(response_double)
+
+      expect do
+        client.get_team_members(team_id)
+      end.to raise_error(Spearly::Auth::ServerError)
+    end
+
+    it 'throws ServiceUnavailableError if 503' do
+      response_double = instance_double(Faraday::Response, status: 503)
+
+      allow(connection_double).to receive(:run_request).and_return(response_double)
+
+      expect do
+        client.get_team_members(team_id)
+      end.to raise_error(Spearly::Auth::ServiceUnavailableError)
+    end
+  end
+end

data/spec/spearly/auth/team_spec.rb

@@ -0,0 +1,371 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Spearly::Auth::Team do
+  let!(:connection_double) { instance_double(Faraday::Connection) }
+
+  before do
+    stub_const('ENV', { 'SPEARLY_API_URL' => 'https://api.spearly.test' })
+
+    allow(Faraday).to receive(:new).and_return(connection_double)
+  end
+
+  describe '.create_team()' do
+    let!(:response_double) { instance_double(Faraday::Response, status: 201, body: { 'data' => { 'id' => 'team_1' } }.to_json) }
+    let!(:params) { { hey: 'jude' } }
+    let!(:client) { Spearly::Auth::Client.new('token') }
+
+    before do
+      allow(connection_double).to receive(:run_request).and_return(response_double)
+    end
+
+    it 'makes POST request to /teams' do
+      uri_parsed = Addressable::URI.parse('/teams').normalize.to_s
+
+      expect(connection_double).to receive(:run_request).with(:post,
+                                                              uri_parsed,
+                                                              params,
+                                                              'Accept' => 'application/vnd.spearly.v2+json',
+                                                              'Authorization' => 'token')
+
+      client.create_team(params)
+    end
+
+    it 'returns object if 201' do
+      res = client.create_team(params)
+
+      expect(res).to eq('data' => { 'id' => 'team_1' })
+    end
+
+    it 'returns errors object if 422' do
+      response_double = instance_double(Faraday::Response, status: 422, body: { 'errors' => { 'owner' => ["can't own more than 2 free teams"] } }.to_json)
+
+      allow(connection_double).to receive(:run_request).and_return(response_double)
+
+      res = client.create_team(params)
+
+      expect(res['errors']).to eq('owner' => ["can't own more than 2 free teams"])
+    end
+
+    it 'throws AuthorizationError if 401' do
+      response_double = instance_double(Faraday::Response, status: 401)
+
+      allow(connection_double).to receive(:run_request).and_return(response_double)
+
+      expect do
+        client.create_team(params)
+      end.to raise_error(Spearly::Auth::AuthorizationError)
+    end
+
+    it 'throws NotFoundError if 404' do
+      response_double = instance_double(Faraday::Response, status: 404)
+
+      allow(connection_double).to receive(:run_request).and_return(response_double)
+
+      expect do
+        client.create_team(params)
+      end.to raise_error(Spearly::Auth::NotFoundError)
+    end
+
+    it 'throws ServerError if 500' do
+      response_double = instance_double(Faraday::Response, status: 500)
+
+      allow(connection_double).to receive(:run_request).and_return(response_double)
+
+      expect do
+        client.create_team(params)
+      end.to raise_error(Spearly::Auth::ServerError)
+    end
+
+    it 'throws ServiceUnavailableError if 503' do
+      response_double = instance_double(Faraday::Response, status: 503)
+
+      allow(connection_double).to receive(:run_request).and_return(response_double)
+
+      expect do
+        client.create_team(params)
+      end.to raise_error(Spearly::Auth::ServiceUnavailableError)
+    end
+  end
+
+  describe '.get_team()' do
+    let!(:response_double) { instance_double(Faraday::Response, status: 200, body: { 'data' => { 'id' => 'team_1' } }.to_json) }
+    let!(:team_id) { 'team_1' }
+    let!(:client) { Spearly::Auth::Client.new('token') }
+
+    before do
+      allow(connection_double).to receive(:run_request).and_return(response_double)
+    end
+
+    it 'makes GET request to /teams/:team_id' do
+      uri_parsed = Addressable::URI.parse("/teams/#{team_id}").normalize.to_s
+
+      expect(connection_double).to receive(:run_request).with(:get,
+                                                              uri_parsed,
+                                                              nil,
+                                                              'Accept' => 'application/vnd.spearly.v2+json',
+                                                              'Authorization' => 'token')
+
+      client.get_team(team_id)
+    end
+
+    it 'returns data array if 200' do
+      res = client.get_team(team_id)
+
+      expect(res).to eq('data' => { 'id' => 'team_1' })
+    end
+
+    it 'throws AuthorizationError if 401' do
+      response_double = instance_double(Faraday::Response, status: 401)
+
+      allow(connection_double).to receive(:run_request).and_return(response_double)
+
+      expect do
+        client.get_team(team_id)
+      end.to raise_error(Spearly::Auth::AuthorizationError)
+    end
+
+    it 'throws NotFoundError if 404' do
+      response_double = instance_double(Faraday::Response, status: 404)
+
+      allow(connection_double).to receive(:run_request).and_return(response_double)
+
+      expect do
+        client.get_team(team_id)
+      end.to raise_error(Spearly::Auth::NotFoundError)
+    end
+
+    it 'throws ServerError if 500' do
+      response_double = instance_double(Faraday::Response, status: 500)
+
+      allow(connection_double).to receive(:run_request).and_return(response_double)
+
+      expect do
+        client.get_team(team_id)
+      end.to raise_error(Spearly::Auth::ServerError)
+    end
+
+    it 'throws ServiceUnavailableError if 503' do
+      response_double = instance_double(Faraday::Response, status: 503)
+
+      allow(connection_double).to receive(:run_request).and_return(response_double)
+
+      expect do
+        client.get_team(team_id)
+      end.to raise_error(Spearly::Auth::ServiceUnavailableError)
+    end
+  end
+
+  describe '.get_teams()' do
+    let!(:response_double) { instance_double(Faraday::Response, status: 200, body: { 'data' => [{ 'id' => 'team_1' }] }.to_json) }
+    let!(:params) { { service_name: 'cms' } }
+    let!(:client) { Spearly::Auth::Client.new('token') }
+
+    before do
+      allow(connection_double).to receive(:run_request).and_return(response_double)
+    end
+
+    it 'makes GET request to /teams' do
+      uri_parsed = Addressable::URI.parse('/teams').normalize.to_s
+
+      expect(connection_double).to receive(:run_request).with(:get,
+                                                              uri_parsed,
+                                                              params,
+                                                              'Accept' => 'application/vnd.spearly.v2+json',
+                                                              'Authorization' => 'token')
+
+      client.get_teams(params)
+    end
+
+    it 'returns data array if 200' do
+      res = client.get_teams(params)
+
+      expect(res).to eq('data' => [{ 'id' => 'team_1' }])
+    end
+
+    it 'throws AuthorizationError if 401' do
+      response_double = instance_double(Faraday::Response, status: 401)
+
+      allow(connection_double).to receive(:run_request).and_return(response_double)
+
+      expect do
+        client.get_teams(params)
+      end.to raise_error(Spearly::Auth::AuthorizationError)
+    end
+
+    it 'throws NotFoundError if 404' do
+      response_double = instance_double(Faraday::Response, status: 404)
+
+      allow(connection_double).to receive(:run_request).and_return(response_double)
+
+      expect do
+        client.get_teams(params)
+      end.to raise_error(Spearly::Auth::NotFoundError)
+    end
+
+    it 'throws ServerError if 500' do
+      response_double = instance_double(Faraday::Response, status: 500)
+
+      allow(connection_double).to receive(:run_request).and_return(response_double)
+
+      expect do
+        client.get_teams(params)
+      end.to raise_error(Spearly::Auth::ServerError)
+    end
+
+    it 'throws ServiceUnavailableError if 503' do
+      response_double = instance_double(Faraday::Response, status: 503)
+
+      allow(connection_double).to receive(:run_request).and_return(response_double)
+
+      expect do
+        client.get_teams(params)
+      end.to raise_error(Spearly::Auth::ServiceUnavailableError)
+    end
+  end
+
+  describe '.update_team()' do
+    let!(:response_double) { instance_double(Faraday::Response, status: 200, body: { 'data' => { 'id' => 'team_1' } }.to_json) }
+    let!(:team_id) { 'team_1' }
+    let!(:client) { Spearly::Auth::Client.new('token') }
+
+    let!(:params) do
+      {
+        team: {
+          name: 'new name'
+        }
+      }
+    end
+
+    before do
+      allow(connection_double).to receive(:run_request).and_return(response_double)
+    end
+
+    it 'makes PUT request to /teams/:team_id' do
+      uri_parsed = Addressable::URI.parse("/teams/#{team_id}").normalize.to_s
+
+      expect(connection_double).to receive(:run_request).with(:put,
+                                                              uri_parsed,
+                                                              params,
+                                                              'Accept' => 'application/vnd.spearly.v2+json',
+                                                              'Authorization' => 'token')
+
+      client.update_team(team_id, params)
+    end
+
+    it 'returns data object if 200' do
+      res = client.update_team(team_id, params)
+
+      expect(res).to eq('data' => { 'id' => 'team_1' })
+    end
+
+    it 'throws AuthorizationError if 401' do
+      response_double = instance_double(Faraday::Response, status: 401)
+
+      allow(connection_double).to receive(:run_request).and_return(response_double)
+
+      expect do
+        client.update_team(team_id, params)
+      end.to raise_error(Spearly::Auth::AuthorizationError)
+    end
+
+    it 'throws NotFoundError if 404' do
+      response_double = instance_double(Faraday::Response, status: 404)
+
+      allow(connection_double).to receive(:run_request).and_return(response_double)
+
+      expect do
+        client.update_team(team_id, params)
+      end.to raise_error(Spearly::Auth::NotFoundError)
+    end
+
+    it 'throws ServerError if 500' do
+      response_double = instance_double(Faraday::Response, status: 500)
+
+      allow(connection_double).to receive(:run_request).and_return(response_double)
+
+      expect do
+        client.update_team(team_id, params)
+      end.to raise_error(Spearly::Auth::ServerError)
+    end
+
+    it 'throws ServiceUnavailableError if 503' do
+      response_double = instance_double(Faraday::Response, status: 503)
+
+      allow(connection_double).to receive(:run_request).and_return(response_double)
+
+      expect do
+        client.update_team(team_id, params)
+      end.to raise_error(Spearly::Auth::ServiceUnavailableError)
+    end
+  end
+
+  describe '.regenerate_team_api_access_token()' do
+    let!(:response_double) { instance_double(Faraday::Response, status: 200, body: { 'data' => { 'id' => 'team_1' } }.to_json) }
+    let!(:team_id) { 'team_1' }
+    let!(:client) { Spearly::Auth::Client.new('token') }
+
+    before do
+      allow(connection_double).to receive(:run_request).and_return(response_double)
+    end
+
+    it 'makes GET request to /teams/:team_id/regenerate_api_access_token' do
+      uri_parsed = Addressable::URI.parse("/teams/#{team_id}/regenerate_api_access_token").normalize.to_s
+
+      expect(connection_double).to receive(:run_request).with(:get,
+                                                              uri_parsed,
+                                                              nil,
+                                                              'Accept' => 'application/vnd.spearly.v2+json',
+                                                              'Authorization' => 'token')
+
+      client.regenerate_team_api_access_token(team_id)
+    end
+
+    it 'returns data object if 200' do
+      res = client.regenerate_team_api_access_token(team_id)
+
+      expect(res).to eq('data' => { 'id' => 'team_1' })
+    end
+
+    it 'throws AuthorizationError if 401' do
+      response_double = instance_double(Faraday::Response, status: 401)
+
+      allow(connection_double).to receive(:run_request).and_return(response_double)
+
+      expect do
+        client.regenerate_team_api_access_token(team_id)
+      end.to raise_error(Spearly::Auth::AuthorizationError)
+    end
+
+    it 'throws NotFoundError if 404' do
+      response_double = instance_double(Faraday::Response, status: 404)
+
+      allow(connection_double).to receive(:run_request).and_return(response_double)
+
+      expect do
+        client.regenerate_team_api_access_token(team_id)
+      end.to raise_error(Spearly::Auth::NotFoundError)
+    end
+
+    it 'throws ServerError if 500' do
+      response_double = instance_double(Faraday::Response, status: 500)
+
+      allow(connection_double).to receive(:run_request).and_return(response_double)
+
+      expect do
+        client.regenerate_team_api_access_token(team_id)
+      end.to raise_error(Spearly::Auth::ServerError)
+    end
+
+    it 'throws ServiceUnavailableError if 503' do
+      response_double = instance_double(Faraday::Response, status: 503)
+
+      allow(connection_double).to receive(:run_request).and_return(response_double)
+
+      expect do
+        client.regenerate_team_api_access_token(team_id)
+      end.to raise_error(Spearly::Auth::ServiceUnavailableError)
+    end
+  end
+end

data/spec/spearly/auth/team_subscription_spec.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Spearly::Auth::TeamSubscription do
+  let!(:connection_double) { instance_double(Faraday::Connection) }
+
+  before do
+    stub_const('ENV', { 'SPEARLY_API_URL' => 'https://api.spearly.test' })
+
+    allow(Faraday).to receive(:new).and_return(connection_double)
+  end
+
+  describe '.get_team_subscriptions()' do
+    let!(:response_double) { instance_double(Faraday::Response, status: 200, body: { 'data' => [{ 'id' => 'sub_1' }] }.to_json) }
+    let!(:team_id) { '711' }
+    let!(:params) { { service_name: 'cms' } }
+    let!(:client) { Spearly::Auth::Client.new('token') }
+
+    before do
+      allow(connection_double).to receive(:run_request).and_return(response_double)
+    end
+
+    it 'makes GET request to /teams/:team_id/subscriptions' do
+      uri_parsed = Addressable::URI.parse('/teams/711/subscriptions').normalize.to_s
+
+      expect(connection_double).to receive(:run_request).with(:get,
+                                                              uri_parsed,
+                                                              params,
+                                                              'Accept' => 'application/vnd.spearly.v2+json',
+                                                              'Authorization' => 'token')
+
+      client.get_team_subscriptions(team_id, params)
+    end
+
+    it 'returns data array if status is 200' do
+      res = client.get_team_subscriptions(team_id, params)
+
+      expect(res).to eq('data' => [{ 'id' => 'sub_1' }])
+    end
+
+    it 'throws AuthorizationError if 401' do
+      response_double = instance_double(Faraday::Response, status: 401)
+
+      allow(connection_double).to receive(:run_request).and_return(response_double)
+
+      expect do
+        client.get_team_subscriptions(team_id, params)
+      end.to raise_error(Spearly::Auth::AuthorizationError)
+    end
+
+    it 'throws NotFoundError if 404' do
+      response_double = instance_double(Faraday::Response, status: 404)
+
+      allow(connection_double).to receive(:run_request).and_return(response_double)
+
+      expect do
+        client.get_team_subscriptions(team_id, params)
+      end.to raise_error(Spearly::Auth::NotFoundError)
+    end
+
+    it 'throws ServerError if 500' do
+      response_double = instance_double(Faraday::Response, status: 500)
+
+      allow(connection_double).to receive(:run_request).and_return(response_double)
+
+      expect do
+        client.get_team_subscriptions(team_id, params)
+      end.to raise_error(Spearly::Auth::ServerError)
+    end
+
+    it 'throws ServiceUnavailableError if 503' do
+      response_double = instance_double(Faraday::Response, status: 503)
+
+      allow(connection_double).to receive(:run_request).and_return(response_double)
+
+      expect do
+        client.get_team_subscriptions(team_id, params)
+      end.to raise_error(Spearly::Auth::ServiceUnavailableError)
+    end
+  end
+end