gochat/backend/internal/service/linear_integration_service_test.go

package service

import (
	"bytes"
	"context"
	"io"
	"net/http"
	"strings"
	"testing"

	"github.com/stretchr/testify/require"
	"gorm.io/driver/sqlite"
	"gorm.io/gorm"
	"gorm.io/gorm/logger"

	"github.com/gochat/gochat/internal/model"
	"github.com/gochat/gochat/internal/repository"
)

type linearRoundTripFunc func(*http.Request) (*http.Response, error)

func (f linearRoundTripFunc) RoundTrip(req *http.Request) (*http.Response, error) {
	return f(req)
}

func TestLinearIntegrationService_ChatwootFrontendPayloads(t *testing.T) {
	t.Setenv("FRONTEND_URL", "https://app.example.test")
	svc, db, accountID := setupLinearIntegrationServiceFixture(t)
	svc.client = &linearAPIClient{
		graphqlURL: "https://linear.example/graphql",
		revokeURL:  "https://linear.example/oauth/revoke",
		httpClient: &http.Client{Transport: linearRoundTripFunc(func(req *http.Request) (*http.Response, error) {
			require.Equal(t, "Bearer linear-token", req.Header.Get("Authorization"))
			raw, err := io.ReadAll(req.Body)
			require.NoError(t, err)
			body := string(raw)
			var payload string
			switch {
			case strings.Contains(body, "teams"):
				payload = `{"data":{"teams":{"nodes":[{"id":"team-1","name":"Support"}]}}}`
			case strings.Contains(body, "workflowStates"):
				payload = `{"data":{"users":{"nodes":[{"id":"user-1","name":"Agent"}]},"projects":{"nodes":[{"id":"project-1","name":"Inbox"}]},"workflowStates":{"nodes":[{"id":"state-1","name":"Todo"}]},"issueLabels":{"nodes":[{"id":"label-1","name":"Bug"}]}}}`
			case strings.Contains(body, "issueCreate"):
				payload = `{"data":{"issueCreate":{"success":true,"issue":{"id":"issue-1","title":"Bug","identifier":"ENG-1"}}}}`
			case strings.Contains(body, "attachmentLinkURL"):
				payload = `{"data":{"attachmentLinkURL":{"success":true,"attachment":{"id":"link-1"}}}}`
			case strings.Contains(body, "attachmentDelete"):
				payload = `{"data":{"attachmentDelete":{"success":true}}}`
			case strings.Contains(body, "searchIssues"):
				payload = `{"data":{"searchIssues":{"nodes":[{"id":"issue-1","title":"Bug","identifier":"ENG-1","url":"https://linear.app/ENG-1","state":{"name":"Todo","color":"#eee"}}]}}}`
			case strings.Contains(body, "attachmentsForURL"):
				payload = `{"data":{"attachmentsForURL":{"nodes":[{"id":"link-1","title":"Bug","issue":{"id":"issue-1","identifier":"ENG-1","title":"Bug","url":"https://linear.app/ENG-1","state":{"name":"Todo","color":"#eee"},"labels":{"nodes":[{"id":"label-1","name":"Bug","color":"#f00"}]}}}]}}}`
			default:
				t.Fatalf("unexpected Linear GraphQL request: %s", body)
			}
			return &http.Response{StatusCode: http.StatusOK, Body: io.NopCloser(bytes.NewBufferString(payload)), Header: make(http.Header)}, nil
		})},
	}
	require.NoError(t, db.Create(&model.IntegrationHook{AccountID: accountID, AppID: "linear", HookType: model.HookTypeLinear, Status: model.HookStatusActive, AccessToken: "linear-token"}).Error)

	teams, err := svc.GetTeams(context.Background(), accountID)
	require.NoError(t, err)
	require.Equal(t, "team-1", teams[0]["id"])
	require.Equal(t, "Support", teams[0]["name"])

	entities, err := svc.GetTeamEntities(context.Background(), accountID, "team-1")
	require.NoError(t, err)
	require.Equal(t, "Agent", entities["users"].([]map[string]interface{})[0]["name"])
	require.Equal(t, "Todo", entities["states"].([]map[string]interface{})[0]["name"])

	created, err := svc.CreateIssue(context.Background(), accountID, CreateIssueRequest{Title: "Bug", TeamID: "team-1", ConversationID: 42}, 1)
	require.NoError(t, err)
	require.Equal(t, "issue-1", created["id"])
	require.Equal(t, "ENG-1", created["identifier"])

	linked, err := svc.LinkIssue(context.Background(), accountID, LinkIssueRequest{IssueID: "issue-1", ConversationID: 42, Title: "Bug"}, 1)
	require.NoError(t, err)
	require.Equal(t, "link-1", linked["link_id"])

	unlinked, err := svc.UnlinkIssue(context.Background(), accountID, UnlinkIssueRequest{LinkID: "link-1", IssueID: "issue-1", ConversationID: 42}, 1)
	require.NoError(t, err)
	require.Equal(t, "link-1", unlinked["link_id"])

	search, err := svc.SearchIssue(context.Background(), accountID, "bug")
	require.NoError(t, err)
	require.Equal(t, "ENG-1", search[0]["identifier"])

	linkedIssues, err := svc.GetLinkedIssues(context.Background(), accountID, 42)
	require.NoError(t, err)
	require.Equal(t, "link-1", linkedIssues[0]["id"])
}

func setupLinearIntegrationServiceFixture(t *testing.T) (*LinearIntegrationService, *gorm.DB, uint) {
	t.Helper()
	db, err := gorm.Open(sqlite.Open("file:linear_service_success?mode=memory&cache=shared"), &gorm.Config{Logger: logger.Default.LogMode(logger.Silent)})
	require.NoError(t, err)
	t.Cleanup(func() { sqlDB, _ := db.DB(); _ = sqlDB.Close() })
	require.NoError(t, db.AutoMigrate(&model.Account{}, &model.User{}, &model.Inbox{}, &model.Contact{}, &model.Conversation{}, &model.Message{}, &model.IntegrationHook{}))
	account := &model.Account{Name: "Linear Account", Locale: "en", Status: "active"}
	require.NoError(t, db.Create(account).Error)
	user := &model.User{AccountID: account.ID, Name: "Linear Agent", Email: "linear-agent@example.test", Role: "agent"}
	require.NoError(t, db.Create(user).Error)
	inbox := &model.Inbox{AccountID: account.ID, Name: "Website", ChannelType: "web_widget", Enabled: true}
	require.NoError(t, db.Create(inbox).Error)
	contact := &model.Contact{AccountID: account.ID, Name: "Visitor"}
	require.NoError(t, db.Create(contact).Error)
	displayID := uint(42)
	conversation := &model.Conversation{AccountID: account.ID, InboxID: inbox.ID, ContactID: contact.ID, DisplayID: &displayID, Status: "open", ChannelType: "web_widget", Channel: "web_widget"}
	require.NoError(t, db.Create(conversation).Error)
	return NewLinearIntegrationService(repository.NewIntegrationHookRepo(db)), db, account.ID
}