Add remaining CreateQueueV1 tests

Author: dhumphreys01

app/conf/config_test.go

@@ -106,9 +106,18 @@ func TestConfig_NoQueueAttributeDefaults(t *testing.T) {
 	}
 }
 
-//func TestConfig_invalid_config_resorts_to_default_attributes(t *testing.T) {
-////	TODO
-//}
+func TestConfig_invalid_config_resorts_to_default_queue_attributes(t *testing.T) {
+	env := "missing"
+	port := LoadYamlConfig("./mock-data/mock-config.yaml", env)
+	if port[0] != "4100" {
+		t.Errorf("Expected port number 4100 but got %s\n", port)
+	}
+
+	assert.Equal(t, 262144, app.CurrentEnvironment.QueueAttributeDefaults.MaximumMessageSize)
+	assert.Equal(t, 345600, app.CurrentEnvironment.QueueAttributeDefaults.MessageRetentionPeriod)
+	assert.Equal(t, 0, app.CurrentEnvironment.QueueAttributeDefaults.ReceiveMessageWaitTimeSeconds)
+	assert.Equal(t, 30, app.CurrentEnvironment.QueueAttributeDefaults.VisibilityTimeout)
+}
 
 func TestConfig_LoadYamlConfig_finds_default_config(t *testing.T) {
 	expectedQueues := []string{

app/fixtures/request.go

@@ -0,0 +1,7 @@
+package fixtures
+
+var JSONRequestBody = struct {
+	RequestField string `json:"field"`
+}{
+	RequestField: "mock-value",
+}

app/gosqs/gosqs.go

@@ -1013,7 +1013,7 @@ func createErrorResponseV1(err string) (int, app.ErrorResponse) {
 	er := app.SqsErrors[err]
 	respStruct := app.ErrorResponse{
 		Result:    app.ErrorResult{Type: er.Type, Code: er.Code, Message: er.Message},
-		RequestId: "00000000-0000-0000-0000-000000000000",
+		RequestId: "00000000-0000-0000-0000-000000000000", // TODO - fix
 	}
 	return er.HttpError, respStruct
 }

app/gosqs/gosqs_test.go

@@ -2233,6 +2233,21 @@ func TestGetQueueAttributes_GetSelectedAttributes(t *testing.T) {
 	done <- struct{}{}
 }
 
+func TestCreateErrorResponseV1(t *testing.T) {
+	expectedResponse := app.ErrorResponse{
+		Result: app.ErrorResult{
+			Type:    "Not Found",
+			Code:    "AWS.SimpleQueueService.NonExistentQueue",
+			Message: "The specified queue does not exist for this wsdl version.",
+		},
+		RequestId: "00000000-0000-0000-0000-000000000000",
+	}
+	status, response := createErrorResponseV1("QueueNotFound")
+
+	assert.Equal(t, http.StatusBadRequest, status)
+	assert.Equal(t, expectedResponse, response)
+}
+
 // waitTimeout waits for the waitgroup for the specified max timeout.
 // Returns true if waiting timed out.
 // credits: https://stackoverflow.com/questions/32840687/timeout-for-waitgroup-wait

app/gosqs/queue_attributes_test.go

@@ -1,12 +1,17 @@
 package gosqs
 
 import (
+	"fmt"
 	"net/url"
 	"reflect"
 	"testing"
 
 	"github.com/Admiral-Piett/goaws/app/utils"
 
+	"github.com/stretchr/testify/assert"
+
+	"github.com/Admiral-Piett/goaws/app/models"
+
 	"github.com/Admiral-Piett/goaws/app"
 )
 
@@ -63,19 +68,115 @@ func TestApplyQueueAttributes(t *testing.T) {
 	})
 }
 
-func TestExtractQueueAttributes(t *testing.T) {
-	u := url.Values{}
-	u.Add("Attribute.1.Name", "DelaySeconds")
-	u.Add("Attribute.1.Value", "20")
-	u.Add("Attribute.2.Name", "VisibilityTimeout")
-	u.Add("Attribute.2.Value", "30")
-	u.Add("Attribute.3.Name", "Policy")
-	attr := utils.ExtractQueueAttributes(u)
-	expected := map[string]string{
-		"DelaySeconds":      "20",
-		"VisibilityTimeout": "30",
+func TestSetQueueAttributesV1_success_no_redrive_policy(t *testing.T) {
+	var emptyQueue *app.Queue
+	q := &app.Queue{}
+	attrs := models.Attributes{
+		DelaySeconds:                  1,
+		MaximumMessageSize:            2,
+		MessageRetentionPeriod:        3,
+		ReceiveMessageWaitTimeSeconds: 4,
+		VisibilityTimeout:             5,
+	}
+	err := setQueueAttributesV1(q, attrs)
+
+	assert.Nil(t, err)
+	assert.Equal(t, 1, q.DelaySeconds)
+	assert.Equal(t, 2, q.MaximumMessageSize)
+	assert.Equal(t, 3, q.MessageRetentionPeriod)
+	assert.Equal(t, 4, q.ReceiveMessageWaitTimeSeconds)
+	assert.Equal(t, 5, q.VisibilityTimeout)
+	assert.Equal(t, emptyQueue, q.DeadLetterQueue)
+	assert.Equal(t, 0, q.MaxReceiveCount)
+}
+
+func TestSetQueueAttributesV1_success_no_request_attributes(t *testing.T) {
+	var emptyQueue *app.Queue
+	q := &app.Queue{}
+	attrs := models.Attributes{}
+	err := setQueueAttributesV1(q, attrs)
+
+	assert.Nil(t, err)
+	assert.Equal(t, 0, q.DelaySeconds)
+	assert.Equal(t, 0, q.MaximumMessageSize)
+	assert.Equal(t, 0, q.MessageRetentionPeriod)
+	assert.Equal(t, 0, q.ReceiveMessageWaitTimeSeconds)
+	assert.Equal(t, 0, q.VisibilityTimeout)
+	assert.Equal(t, emptyQueue, q.DeadLetterQueue)
+	assert.Equal(t, 0, q.MaxReceiveCount)
+}
+
+func TestSetQueueAttributesV1_success_can_set_0_values_where_applicable(t *testing.T) {
+	var emptyQueue *app.Queue
+	q := &app.Queue{
+		DelaySeconds:                  1,
+		MaximumMessageSize:            2,
+		MessageRetentionPeriod:        3,
+		ReceiveMessageWaitTimeSeconds: 4,
+		VisibilityTimeout:             5,
+	}
+	attrs := models.Attributes{}
+	err := setQueueAttributesV1(q, attrs)
+
+	assert.Nil(t, err)
+	assert.Equal(t, 0, q.DelaySeconds)
+	assert.Equal(t, 0, q.MaximumMessageSize)
+	assert.Equal(t, 3, q.MessageRetentionPeriod)
+	assert.Equal(t, 4, q.ReceiveMessageWaitTimeSeconds)
+	assert.Equal(t, 0, q.VisibilityTimeout)
+	assert.Equal(t, emptyQueue, q.DeadLetterQueue)
+	assert.Equal(t, 0, q.MaxReceiveCount)
+}
+
+func TestSetQueueAttributesV1_success_with_redrive_policy(t *testing.T) {
+	defer func() {
+		utils.ResetApp()
+	}()
+
+	existingQueueName := "existing-queue"
+	existingQueue := &app.Queue{Name: existingQueueName}
+	app.SyncQueues.Queues[existingQueueName] = existingQueue
+
+	q := &app.Queue{}
+	attrs := models.Attributes{
+		DelaySeconds:                  1,
+		MaximumMessageSize:            2,
+		MessageRetentionPeriod:        3,
+		ReceiveMessageWaitTimeSeconds: 4,
+		VisibilityTimeout:             5,
+		RedrivePolicy: models.RedrivePolicy{
+			MaxReceiveCount:     10,
+			DeadLetterTargetArn: fmt.Sprintf("arn:aws:sqs:region:account-id:%s", existingQueueName),
+		},
 	}
-	if ok := reflect.DeepEqual(attr, expected); !ok {
-		t.Fatalf("expected %+v, got %+v", expected, attr)
+	err := setQueueAttributesV1(q, attrs)
+
+	assert.Nil(t, err)
+	assert.Equal(t, 1, q.DelaySeconds)
+	assert.Equal(t, 2, q.MaximumMessageSize)
+	assert.Equal(t, 3, q.MessageRetentionPeriod)
+	assert.Equal(t, 4, q.ReceiveMessageWaitTimeSeconds)
+	assert.Equal(t, 5, q.VisibilityTimeout)
+	assert.Equal(t, existingQueue, q.DeadLetterQueue)
+	assert.Equal(t, 10, q.MaxReceiveCount)
+}
+
+func TestSetQueueAttributesV1_error_redrive_policy_targets_missing_queue(t *testing.T) {
+	existingQueueName := "existing-queue"
+
+	q := &app.Queue{}
+	attrs := models.Attributes{
+		DelaySeconds:                  1,
+		MaximumMessageSize:            2,
+		MessageRetentionPeriod:        3,
+		ReceiveMessageWaitTimeSeconds: 4,
+		VisibilityTimeout:             5,
+		RedrivePolicy: models.RedrivePolicy{
+			MaxReceiveCount:     10,
+			DeadLetterTargetArn: fmt.Sprintf("arn:aws:sqs:region:account-id:%s", existingQueueName),
+		},
 	}
+	err := setQueueAttributesV1(q, attrs)
+
+	assert.Error(t, err)
 }

app/mocks/mocks.go

@@ -0,0 +1,21 @@
+package mocks
+
+import "net/url"
+
+type MockRequestBody struct {
+	RequestFieldStr string `json:"field" schema:"field"`
+	RequestFieldInt int    `json:"intField" schema:"intField"`
+
+	SetAttributesFromFormCalled     bool
+	SetAttributesFromFormCalledWith []interface{}
+
+	MockSetAttributesFromFormCalledWith func(values url.Values)
+}
+
+func (m *MockRequestBody) SetAttributesFromForm(values url.Values) {
+	m.SetAttributesFromFormCalled = true
+	m.SetAttributesFromFormCalledWith = append(m.SetAttributesFromFormCalledWith, values)
+	if m.MockSetAttributesFromFormCalledWith != nil {
+		m.MockSetAttributesFromFormCalledWith(values)
+	}
+}