jacob-mathison/query-orchestration
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Activity

Merged in feature/shorttestsanddirtidy (pull request #26)

Browse Source 
Add short tests and Tidy internal directories

* complete the tasks
This commit is contained in:
Michael McGuinness
2025-01-17 12:00:32 +00:00
parent b453f6cb23
commit fa95d733ca
84 changed files with 171 additions and 101 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/server/queue/config.go
+17
View File
@@ -0,0 +1,17 @@
package queue
import (
"context"
"github.com/aws/aws-sdk-go-v2/service/sqs"
"github.com/aws/aws-sdk-go-v2/service/sqs/types"
)
type Config struct {
URL string
Client *sqs.Client
}
type Controller interface {
Process(ctx context.Context, config *Config, msg *types.Message) error
}
internal/server/queue/delete.go
+21
View File
@@ -0,0 +1,21 @@
package queue
import (
"context"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/sqs"
"github.com/aws/aws-sdk-go-v2/service/sqs/types"
)
func Delete(ctx context.Context, config *Config, msg *types.Message) error {
_, err := config.Client.DeleteMessage(ctx, &sqs.DeleteMessageInput{
QueueUrl: aws.String(config.URL),
ReceiptHandle: msg.ReceiptHandle,
})
if err != nil {
return err
}
return nil
}
internal/server/queue/delete_test.go
+33
View File
@@ -0,0 +1,33 @@
package queue_test
import (
"context"
"queryorchestration/internal/server/queue"
"queryorchestration/internal/test"
"testing"
"github.com/aws/aws-sdk-go-v2/service/sqs/types"
"github.com/stretchr/testify/assert"
)
func TestDelete(t *testing.T) {
if testing.Short() {
t.Skip("Skipping long test in short mode")
}
ctx := context.Background()
queueConfig, cleanup := test.CreateQueue(t, ctx, &test.CreateQueueConfig{})
defer cleanup()
cfg := &queue.Config{
URL: queueConfig.URL,
Client: queueConfig.Client,
}
err := queue.Send(ctx, cfg, "{}", map[string]types.MessageAttributeValue{})
assert.Nil(t, err)
message := test.AssertMessageWait(t, ctx, cfg, []string{})
err = queue.Delete(ctx, cfg, &message)
assert.Nil(t, err)
}
internal/server/queue/listener.go
+54
View File
@@ -0,0 +1,54 @@
package queue
import (
"context"
"log"
"queryorchestration/internal/server"
"queryorchestration/internal/server/env"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/service/sqs"
)
type ListenerConfig struct {
Controller func(*server.Config) Controller
BasePath string
}
type Server struct {
controller Controller
queueConnection *Config
}
func NewServer(ctx context.Context, lConfig *ListenerConfig) *Server {
serverCfg := server.New(ctx, &server.NewConfig{
BasePath: lConfig.BasePath,
})
cfg, err := config.LoadDefaultConfig(ctx)
if err != nil {
log.Panicf("Unable to load SDK config: %v", err)
}
queueURL := env.GetPanic("QUEUE_URL")
sqsClient := sqs.NewFromConfig(cfg)
return &Server{
controller: lConfig.Controller(serverCfg),
queueConnection: &Config{
URL: queueURL,
Client: sqsClient,
},
}
}
func (s *Server) Listen(ctx context.Context) {
config := &PollConfig{
Controller: s.controller,
Config: s.queueConnection,
}
log.Print("Listening to queue")
PollMessages(ctx, config)
}
internal/server/queue/listener_test.go
+47
View File
@@ -0,0 +1,47 @@
package queue_test
import (
"context"
"os"
"path"
"queryorchestration/internal/server"
"queryorchestration/internal/server/queue"
"queryorchestration/internal/test"
"testing"
"time"
"github.com/stretchr/testify/assert"
)
func TestNew(t *testing.T) {
if testing.Short() {
t.Skip("Skipping long test in short mode")
}
ctx := context.Background()
_, cleanup := test.CreateQueue(t, ctx, &test.CreateQueueConfig{})
defer cleanup()
_, cleanup = test.CreateDB(t, ctx, &test.CreateDatabaseConfig{})
defer cleanup()
ctx, cancel := context.WithTimeout(ctx, time.Second)
defer cancel()
controller := func(cfg *server.Config) queue.Controller {
return MockController{}
}
t.Setenv("QUEUE_URL", "example_url")
queue.NewServer(ctx, &queue.ListenerConfig{
Controller: controller,
BasePath: path.Join(os.Getenv("PWD"), "../.."),
})
}
func TestListen(t *testing.T) {
ctx := context.Background()
queue := queue.Server{}
assert.Panics(t, func() { queue.Listen(ctx) })
}
internal/server/queue/poll.go
+51
View File
@@ -0,0 +1,51 @@
package queue
import (
"context"
"fmt"
"log"
)
type PollConfig struct {
Config *Config
Controller Controller
}
func PollMessages(ctx context.Context, queueConfig *PollConfig) {
for {
select {
case <-ctx.Done():
return
default:
err := PollMessage(ctx, queueConfig)
if err != nil {
log.Print(err)
}
}
}
}
func PollMessage(ctx context.Context, queueConfig *PollConfig) error {
result, err := Receive(ctx, queueConfig.Config, []string{
"type",
})
if err != nil {
return fmt.Errorf("message fetch fail: %v", err)
}
for _, message := range result.Messages {
go func() {
err := queueConfig.Controller.Process(ctx, queueConfig.Config, &message)
if err != nil {
log.Printf("message process fail: %v", err)
}
err = Delete(ctx, queueConfig.Config, &message)
if err != nil {
log.Printf("message delete fail: %v", err)
}
}()
}
return nil
}
internal/server/queue/poll_test.go
+62
View File
@@ -0,0 +1,62 @@
package queue_test
import (
"context"
"queryorchestration/internal/server/queue"
"queryorchestration/internal/test"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/service/sqs/types"
"github.com/stretchr/testify/assert"
)
type MockController struct{}
func (s MockController) Process(ctx context.Context, config *queue.Config, msg *types.Message) error {
return nil
}
func TestPollMessages(t *testing.T) {
if testing.Short() {
t.Skip("Skipping long test in short mode")
}
ctx := context.Background()
queueConfig, cleanup := test.CreateQueue(t, ctx, &test.CreateQueueConfig{})
defer cleanup()
controller := MockController{}
ctx, cancel := context.WithTimeout(ctx, time.Second)
defer cancel()
cfg := &queue.Config{
URL: queueConfig.URL,
Client: queueConfig.Client,
}
queue.PollMessages(ctx, &queue.PollConfig{
Config: cfg,
Controller: controller,
})
}
func TestPollMessage(t *testing.T) {
if testing.Short() {
t.Skip("Skipping long test in short mode")
}
ctx := context.Background()
queueConfig, cleanup := test.CreateQueue(t, ctx, &test.CreateQueueConfig{})
defer cleanup()
controller := MockController{}
cfg := &queue.Config{
URL: queueConfig.URL,
Client: queueConfig.Client,
}
err := queue.PollMessage(ctx, &queue.PollConfig{
Config: cfg,
Controller: controller,
})
assert.Nil(t, err)
}
internal/server/queue/receive.go
+17
View File
@@ -0,0 +1,17 @@
package queue
import (
"context"
"github.com/aws/aws-sdk-go-v2/service/sqs"
)
func Receive(ctx context.Context, config *Config, attributes []string) (*sqs.ReceiveMessageOutput, error) {
return config.Client.ReceiveMessage(ctx, &sqs.ReceiveMessageInput{
QueueUrl: &config.URL,
MaxNumberOfMessages: 1,
WaitTimeSeconds: 2,
VisibilityTimeout: 2,
MessageAttributeNames: attributes,
})
}
internal/server/queue/receive_test.go
+37
View File
@@ -0,0 +1,37 @@
package queue_test
import (
"context"
"queryorchestration/internal/server/queue"
"queryorchestration/internal/test"
"testing"
"github.com/aws/aws-sdk-go-v2/service/sqs/types"
"github.com/stretchr/testify/assert"
)
func TestReceive(t *testing.T) {
if testing.Short() {
t.Skip("Skipping long test in short mode")
}
ctx := context.Background()
queueConfig, cleanup := test.CreateQueue(t, ctx, &test.CreateQueueConfig{})
defer cleanup()
cfg := &queue.Config{
URL: queueConfig.URL,
Client: queueConfig.Client,
}
attributes := map[string]types.MessageAttributeValue{}
err := queue.Send(ctx, cfg, "example_body", attributes)
assert.Nil(t, err)
result, err := queue.Receive(ctx, cfg, []string{})
assert.Nil(t, err)
assert.Len(t, result.Messages, 1)
message := result.Messages[0]
assert.Equal(t, "\"example_body\"", *message.Body)
}
internal/server/queue/send.go
+30
View File
@@ -0,0 +1,30 @@
package queue
import (
"context"
"encoding/json"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/sqs"
"github.com/aws/aws-sdk-go-v2/service/sqs/types"
)
func Send(ctx context.Context, config *Config, body interface{}, attributes map[string]types.MessageAttributeValue) error {
jsonBytes, err := json.Marshal(body)
if err != nil {
return err
}
strBody := string(jsonBytes)
_, err = config.Client.SendMessage(ctx, &sqs.SendMessageInput{
MessageAttributes: attributes,
QueueUrl: aws.String(config.URL),
MessageBody: aws.String(strBody),
})
if err != nil {
return err
}
return nil
}
internal/server/queue/send_test.go
+27
View File
@@ -0,0 +1,27 @@
package queue_test
import (
"context"
"queryorchestration/internal/server/queue"
"queryorchestration/internal/test"
"testing"
"github.com/aws/aws-sdk-go-v2/service/sqs/types"
"github.com/stretchr/testify/assert"
)
func TestSend(t *testing.T) {
if testing.Short() {
t.Skip("Skipping long test in short mode")
}
ctx := context.Background()
queueConfig, cleanup := test.CreateQueue(t, ctx, &test.CreateQueueConfig{})
defer cleanup()
cfg := &queue.Config{
URL: queueConfig.URL,
Client: queueConfig.Client,
}
err := queue.Send(ctx, cfg, "{}", map[string]types.MessageAttributeValue{})
assert.Nil(t, err)
}