Refactor NewService to take a runtime and a courier instance

Author: rowanseymour

cmd/chipserver/main.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"fmt"
 	ulog "log"
 	"log/slog"
 	"os"
@@ -12,7 +13,9 @@ import (
 	"github.com/getsentry/sentry-go"
 	_ "github.com/lib/pq"
 	"github.com/nyaruka/chip"
+	"github.com/nyaruka/chip/core/courier"
 	"github.com/nyaruka/chip/runtime"
+	"github.com/nyaruka/redisx"
 	slogmulti "github.com/samber/slog-multi"
 	slogsentry "github.com/samber/slog-sentry"
 )
@@ -51,15 +54,41 @@ func main() {
 	log := slog.With("comp", "main")
 	log.Info("starting...", "version", version, "released", date)
 
-	svc := chip.NewService(config)
-	if err := svc.Start(); err != nil {
+	svc, err := newService(config, log)
+	if err != nil {
 		log.Error("unable to start", "error", err)
 		os.Exit(1)
 	}
 
 	handleSignals(svc) // handle our signals
 }
 
+func newService(cfg *runtime.Config, log *slog.Logger) (*chip.Service, error) {
+	rt := &runtime.Runtime{Config: cfg}
+	var err error
+
+	rt.DB, err = runtime.OpenDBPool(rt.Config.DB, 16)
+	if err != nil {
+		return nil, fmt.Errorf("error connecting to database: %w", err)
+	} else {
+		log.Info("db ok")
+	}
+
+	rt.RP, err = redisx.NewPool(rt.Config.Redis)
+	if err != nil {
+		return nil, fmt.Errorf("error connecting to redis: %w", err)
+	} else {
+		log.Info("redis ok")
+	}
+
+	svc := chip.NewService(rt, courier.NewCourier(rt.Config))
+	if err := svc.Start(); err != nil {
+		return nil, err
+	}
+
+	return svc, nil
+}
+
 // handleSignals takes care of trapping quit, interrupt or terminate signals and doing the right thing
 func handleSignals(svc *chip.Service) {
 	sigs := make(chan os.Signal, 1)

service.go

@@ -2,7 +2,6 @@ package chip
 
 import (
 	"context"
-	"fmt"
 	"log/slog"
 	"sync"
 	"time"
@@ -13,11 +12,6 @@ import (
 	"github.com/nyaruka/chip/runtime"
 	"github.com/nyaruka/chip/web"
 	"github.com/nyaruka/chip/web/events"
-	"github.com/nyaruka/redisx"
-)
-
-const (
-	outboxTimeLimit = 2 * time.Minute
 )
 
 type Service struct {
@@ -31,14 +25,12 @@ type Service struct {
 	senderWait sync.WaitGroup
 }
 
-func NewService(cfg *runtime.Config) *Service {
-	rt := &runtime.Runtime{Config: cfg}
-
+func NewService(rt *runtime.Runtime, courier courier.Courier) *Service {
 	s := &Service{
 		rt:         rt,
 		store:      models.NewStore(rt),
-		outbox:     &queue.Outbox{KeyBase: "chat", InstanceID: cfg.InstanceID},
-		courier:    courier.NewCourier(rt.Config),
+		outbox:     &queue.Outbox{KeyBase: "chat", InstanceID: rt.Config.InstanceID},
+		courier:    courier,
 		senderStop: make(chan bool),
 	}
 
@@ -49,21 +41,6 @@ func NewService(cfg *runtime.Config) *Service {
 
 func (s *Service) Start() error {
 	log := slog.With("comp", "service")
-	var err error
-
-	s.rt.DB, err = runtime.OpenDBPool(s.rt.Config.DB, 16)
-	if err != nil {
-		return fmt.Errorf("error connecting to database: %w", err)
-	} else {
-		log.Info("db ok")
-	}
-
-	s.rt.RP, err = redisx.NewPool(s.rt.Config.Redis)
-	if err != nil {
-		return fmt.Errorf("error connecting to redis: %w", err)
-	} else {
-		log.Info("redis ok")
-	}
 
 	s.server.Start()
 	s.store.Start()
@@ -114,6 +91,8 @@ func (s *Service) OnChatStarted(ch *models.Channel, chatID models.ChatID) {
 		log.Error("error setting chat ready", "error", err)
 		return
 	}
+
+	log.Info("chat started", "chat_id", chatID)
 }
 
 func (s *Service) OnChatClosed(ch *models.Channel, chatID models.ChatID) {
@@ -125,6 +104,8 @@ func (s *Service) OnChatClosed(ch *models.Channel, chatID models.ChatID) {
 		log.Error("error unsetting chat ready", "error", err)
 		return
 	}
+
+	log.Info("chat closed", "chat_id", chatID)
 }
 
 func (s *Service) sender() {

service_test.go

@@ -6,28 +6,16 @@ import (
 	"time"
 
 	"github.com/gorilla/websocket"
-	"github.com/nyaruka/chip/core/courier"
+	"github.com/nyaruka/chip"
 	"github.com/nyaruka/chip/core/models"
 	"github.com/nyaruka/chip/testsuite"
-	"github.com/nyaruka/chip/web"
 	"github.com/nyaruka/gocommon/dates"
 	"github.com/nyaruka/gocommon/httpx"
 	"github.com/nyaruka/gocommon/random"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
-type MockService struct {
-	store   models.Store
-	courier courier.Courier
-}
-
-func (s *MockService) Store() models.Store                           { return s.store }
-func (s *MockService) Courier() courier.Courier                      { return s.courier }
-func (s *MockService) OnChatStarted(*models.Channel, models.ChatID)  {}
-func (s *MockService) OnChatClosed(*models.Channel, models.ChatID)   {}
-func (s *MockService) OnSendRequest(*models.Channel, *models.MsgOut) {}
-
 func TestServer(t *testing.T) {
 	ctx, rt := testsuite.Runtime()
 
@@ -40,11 +28,11 @@ func TestServer(t *testing.T) {
 	dates.SetNowSource(dates.NewSequentialNowSource(time.Date(2024, 5, 2, 16, 5, 4, 0, time.UTC)))
 
 	mockCourier := testsuite.NewMockCourier(rt)
-	mockSvc := &MockService{store: models.NewStore(rt), courier: mockCourier}
 
-	server := web.NewServer(rt, mockSvc)
-	server.Start()
-	defer server.Stop()
+	svc := chip.NewService(rt, mockCourier)
+	assert.NoError(t, svc.Start())
+
+	defer svc.Stop()
 
 	req, _ := http.NewRequest("GET", "http://localhost:8071/", nil)
 	trace, err := httpx.DoTrace(http.DefaultClient, req, nil, nil, -1)