chore: add specs

spec/controllers/api/v1/accounts/integrations/linear_controller_spec.rb

@@ -0,0 +1,87 @@
+require 'rails_helper'
+
+RSpec.describe 'Linear Integration API', type: :request do
+  let(:account) { create(:account) }
+  let(:user) { create(:user) }
+  let(:api_key) { 'valid_api_key' }
+  let(:agent) { create(:user, account: account, role: :agent) }
+  let(:processor_service) { instance_double(Integrations::Linear::ProcessorService) }
+
+  before do
+    create(:integrations_hook, :linear, account: account)
+    allow(Integrations::Linear::ProcessorService).to receive(:new).with(account: account).and_return(processor_service)
+  end
+
+  describe 'GET /api/v1/accounts/:account_id/integrations/linear/teams' do
+    let(:path) { teams_api_v1_account_integrations_linear_path(account) }
+
+    context 'when it is an authenticated user' do
+      context 'when data is retrieved successfully' do
+        let(:teams_data) { [{ 'id' => 'team1', 'name' => 'Team One' }] }
+
+        it 'returns team data' do
+          allow(processor_service).to receive(:teams).and_return(teams_data)
+          get "/api/v1/accounts/#{account.id}/integrations/linear/teams",
+              headers: agent.create_new_auth_token,
+              as: :json
+          expect(response).to have_http_status(:ok)
+          expect(response.body).to include('Team One')
+        end
+      end
+
+      context 'when data retrieval fails' do
+        it 'returns error message' do
+          allow(processor_service).to receive(:teams).and_return(error: 'error message')
+          get "/api/v1/accounts/#{account.id}/integrations/linear/teams",
+              headers: agent.create_new_auth_token,
+              as: :json
+          expect(response).to have_http_status(:unprocessable_entity)
+          expect(response.body).to include('error message')
+        end
+      end
+    end
+  end
+
+  describe 'GET /api/v1/accounts/:account_id/integrations/linear/team_entites' do
+    let(:team_id) { 'team1' }
+    let(:path) { team_entites_api_v1_account_integrations_linear_path(account) }
+
+    context 'when it is an authenticated user' do
+      context 'when data is retrieved successfully' do
+        let(:team_entities_data) do
+          {
+            users: [{ 'id' => 'user1', 'name' => 'User One' }],
+            projects: [{ 'id' => 'project1', 'name' => 'Project One' }],
+            states: [{ 'id' => 'state1', 'name' => 'State One' }],
+            labels: [{ 'id' => 'label1', 'name' => 'Label One' }]
+          }
+        end
+
+        it 'returns team entities data' do
+          allow(processor_service).to receive(:team_entites).with(team_id).and_return(team_entities_data)
+          get "/api/v1/accounts/#{account.id}/integrations/linear/team_entites",
+              params: { team_id: team_id },
+              headers: agent.create_new_auth_token,
+              as: :json
+          expect(response).to have_http_status(:ok)
+          expect(response.body).to include('User One')
+          expect(response.body).to include('Project One')
+          expect(response.body).to include('State One')
+          expect(response.body).to include('Label One')
+        end
+      end
+
+      context 'when data retrieval fails' do
+        it 'returns error message' do
+          allow(processor_service).to receive(:team_entites).with(team_id).and_return(error: 'error message')
+          get "/api/v1/accounts/#{account.id}/integrations/linear/team_entites",
+              params: { team_id: team_id },
+              headers: agent.create_new_auth_token,
+              as: :json
+          expect(response).to have_http_status(:unprocessable_entity)
+          expect(response.body).to include('error message')
+        end
+      end
+    end
+  end
+end

spec/lib/integrations/linear/processor_service_spec.rb

@@ -2,31 +2,68 @@ require 'rails_helper'
 
 describe Integrations::Linear::ProcessorService do
   let(:account) { create(:account) }
-  let(:processor) { described_class.new(account: account) }
   let(:api_key) { 'valid_api_key' }
-  let(:url) { 'https://api.linear.app/graphql' }
-  let(:headers) { { 'Content-Type' => 'application/json', 'Authorization' => api_key } }
-
-  let(:schema) { JSON.parse(File.read('spec/fixtures/linear-schema.json')) }
-  let(:linear_client) { Graphlient::Client.new(url, schema: Graphlient::Schema.new({ 'data' => schema }, nil), headers: headers) }
-  let(:linear_instance) { Linear.new(api_key) }
+  let(:linear_client) { instance_double(Linear) }
+  let(:service) { described_class.new(account: account) }
 
   before do
     create(:integrations_hook, :linear, account: account)
+    allow(Linear).to receive(:new).and_return(linear_client)
   end
 
   describe '#teams' do
-    context 'when the API response is success' do
-      before do
-        linear_instance.instance_variable_set(:@client, linear_client)
-        processor.instance_variable_set(:@linear_client, linear_instance)
-        stub_request(:post, url)
-          .to_return(status: 200, body: { data: { teams: { nodes: [{ id: 'team1', name: 'Team One' }] } } }.to_json)
+    context 'when Linear client returns valid data' do
+      let(:teams_response) do
+        { 'teams' => { 'nodes' => [{ 'id' => 'team1', 'name' => 'Team One' }] } }
       end
 
-      it 'returns the list of teams' do
-        result = processor.teams
-        expect(result).to eq([{ 'id' => 'team1', 'name' => 'Team One' }])
+      it 'returns parsed team data' do
+        allow(linear_client).to receive(:teams).and_return(teams_response)
+        result = service.teams
+        expect(result).to contain_exactly({ 'id' => 'team1', 'name' => 'Team One' })
+      end
+    end
+
+    context 'when Linear client returns an error' do
+      let(:error_response) { { error: 'Some error message' } }
+
+      it 'returns the error' do
+        allow(linear_client).to receive(:teams).and_return(error_response)
+        result = service.teams
+        expect(result).to eq(error_response)
+      end
+    end
+  end
+
+  describe '#team_entites' do
+    let(:team_id) { 'team1' }
+    let(:entities_response) do
+      {
+        'users' => { 'nodes' => [{ 'id' => 'user1', 'name' => 'User One' }] },
+        'projects' => { 'nodes' => [{ 'id' => 'project1', 'name' => 'Project One' }] },
+        'workflowStates' => { 'nodes' => [] },
+        'issueLabels' => { 'nodes' => [{ 'id' => 'bug', 'name' => 'Bug' }] }
+      }
+    end
+
+    context 'when Linear client returns valid data' do
+      it 'returns parsed entity data' do
+        allow(linear_client).to receive(:team_entites).with(team_id).and_return(entities_response)
+        result = service.team_entites(team_id)
+        expect(result).to have_key(:users)
+        expect(result).to have_key(:projects)
+        expect(result).to have_key(:states)
+        expect(result).to have_key(:labels)
+      end
+    end
+
+    context 'when Linear client returns an error' do
+      let(:error_response) { { error: 'Some error message' } }
+
+      it 'returns the error' do
+        allow(linear_client).to receive(:team_entites).with(team_id).and_return(error_response)
+        result = service.team_entites(team_id)
+        expect(result).to eq(error_response)
       end
     end
   end