chore: удалить мёртвые унаследованные тесты gosqs (несовместимы с мультитенантным форком)
13 файлов *_test.go требовали отсутствующие в git пакеты app/fixtures и
app/test, и даже с ними падали бы: написаны под дофорковый GoAws, где не было
тенанта в контексте и tenant-scoped ключей {accessKey}:{queueName}.
Причина зафиксирована в doc/thinking/tests-inherited-broken-2026-10-06.md.
This commit is contained in:
Repinoid
@@ -1,254 +0,0 @@
|
||||
package gosqs
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"net/http"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"shared-sqs/app/test"
|
||||
|
||||
"shared-sqs/app/fixtures"
|
||||
"shared-sqs/app/interfaces"
|
||||
"shared-sqs/app/models"
|
||||
"shared-sqs/app/utils"
|
||||
"github.com/mitchellh/copystructure"
|
||||
"github.com/stretchr/testify/assert"
|
||||
)
|
||||
|
||||
func TestCreateQueueV1_success(t *testing.T) {
|
||||
models.CurrentEnvironment = fixtures.LOCAL_ENVIRONMENT
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
v := resultingStruct.(*models.CreateQueueRequest)
|
||||
*v = fixtures.CreateQueueRequest
|
||||
return true
|
||||
}
|
||||
|
||||
_, r := test.GenerateRequestInfo("POST", "/", nil, true)
|
||||
code, response := CreateQueueV1(r)
|
||||
|
||||
assert.Equal(t, http.StatusOK, code)
|
||||
assert.Equal(t, fixtures.CreateQueueResponse, response)
|
||||
|
||||
actualQueue := models.SyncQueues.Queues[fixtures.QueueName]
|
||||
assert.Equal(t, fixtures.FullyPopulatedQueue, actualQueue)
|
||||
}
|
||||
|
||||
func TestCreateQueueV1_success_with_redrive_policy(t *testing.T) {
|
||||
models.CurrentEnvironment = fixtures.LOCAL_ENVIRONMENT
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
dupe, _ := copystructure.Copy(fixtures.CreateQueueRequest)
|
||||
c, _ := dupe.(models.CreateQueueRequest)
|
||||
c.Attributes.RedrivePolicy = models.RedrivePolicy{
|
||||
MaxReceiveCount: 100,
|
||||
DeadLetterTargetArn: fmt.Sprintf("arn:aws:sqs:us-east-1:100010001000:%s", fixtures.DeadLetterQueueName),
|
||||
}
|
||||
|
||||
v := resultingStruct.(*models.CreateQueueRequest)
|
||||
*v = c
|
||||
return true
|
||||
}
|
||||
|
||||
dlq := &models.Queue{
|
||||
Name: fixtures.DeadLetterQueueName,
|
||||
}
|
||||
models.SyncQueues.Queues[fixtures.DeadLetterQueueName] = dlq
|
||||
|
||||
expectedQueue := &models.Queue{
|
||||
Name: fixtures.QueueName,
|
||||
URL: fmt.Sprintf("http://%s.%s:%s/%s/%s",
|
||||
fixtures.LOCAL_ENVIRONMENT.Region,
|
||||
fixtures.LOCAL_ENVIRONMENT.Host,
|
||||
fixtures.LOCAL_ENVIRONMENT.Port,
|
||||
fixtures.LOCAL_ENVIRONMENT.AccountID,
|
||||
fixtures.QueueName,
|
||||
),
|
||||
Arn: fmt.Sprintf("arn:aws:sqs:%s:%s:%s",
|
||||
fixtures.LOCAL_ENVIRONMENT.Region,
|
||||
fixtures.LOCAL_ENVIRONMENT.AccountID,
|
||||
fixtures.QueueName,
|
||||
),
|
||||
VisibilityTimeout: 5,
|
||||
ReceiveMessageWaitTimeSeconds: 4,
|
||||
DelaySeconds: 1,
|
||||
MaximumMessageSize: 2,
|
||||
MessageRetentionPeriod: 3,
|
||||
DeadLetterQueue: dlq,
|
||||
MaxReceiveCount: 100,
|
||||
Duplicates: make(map[string]time.Time),
|
||||
}
|
||||
|
||||
_, r := test.GenerateRequestInfo("POST", "/", nil, true)
|
||||
code, response := CreateQueueV1(r)
|
||||
|
||||
assert.Equal(t, http.StatusOK, code)
|
||||
assert.Equal(t, fixtures.CreateQueueResponse, response)
|
||||
|
||||
actualQueue := models.SyncQueues.Queues[fixtures.QueueName]
|
||||
assert.Equal(t, expectedQueue, actualQueue)
|
||||
}
|
||||
|
||||
func TestCreateQueueV1_success_with_existing_queue(t *testing.T) {
|
||||
models.CurrentEnvironment = fixtures.LOCAL_ENVIRONMENT
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
v := resultingStruct.(*models.CreateQueueRequest)
|
||||
*v = fixtures.CreateQueueRequest
|
||||
return true
|
||||
}
|
||||
|
||||
q := &models.Queue{
|
||||
Name: fixtures.QueueName,
|
||||
}
|
||||
models.SyncQueues.Queues[fixtures.QueueName] = q
|
||||
|
||||
_, r := test.GenerateRequestInfo("POST", "/", nil, true)
|
||||
code, response := CreateQueueV1(r)
|
||||
|
||||
assert.Equal(t, http.StatusOK, code)
|
||||
assert.Equal(t, fixtures.CreateQueueResponse, response)
|
||||
|
||||
actualQueue := models.SyncQueues.Queues[fixtures.QueueName]
|
||||
assert.Equal(t, q, actualQueue)
|
||||
}
|
||||
|
||||
func TestCreateQueueV1_success_with_no_request_attributes_falls_back_to_default(t *testing.T) {
|
||||
models.CurrentEnvironment = fixtures.LOCAL_ENVIRONMENT
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
dupe, _ := copystructure.Copy(fixtures.CreateQueueRequest)
|
||||
c, _ := dupe.(models.CreateQueueRequest)
|
||||
c.Attributes = models.QueueAttributes{}
|
||||
|
||||
v := resultingStruct.(*models.CreateQueueRequest)
|
||||
*v = c
|
||||
return true
|
||||
}
|
||||
|
||||
expectedQueue := &models.Queue{
|
||||
Name: fixtures.QueueName,
|
||||
URL: fmt.Sprintf("http://%s.%s:%s/%s/%s",
|
||||
fixtures.LOCAL_ENVIRONMENT.Region,
|
||||
fixtures.LOCAL_ENVIRONMENT.Host,
|
||||
fixtures.LOCAL_ENVIRONMENT.Port,
|
||||
fixtures.LOCAL_ENVIRONMENT.AccountID,
|
||||
fixtures.QueueName,
|
||||
),
|
||||
Arn: fmt.Sprintf("arn:aws:sqs:%s:%s:%s",
|
||||
fixtures.LOCAL_ENVIRONMENT.Region,
|
||||
fixtures.LOCAL_ENVIRONMENT.AccountID,
|
||||
fixtures.QueueName,
|
||||
),
|
||||
VisibilityTimeout: 0,
|
||||
ReceiveMessageWaitTimeSeconds: 0,
|
||||
DelaySeconds: 0,
|
||||
MaximumMessageSize: 0,
|
||||
MessageRetentionPeriod: 0,
|
||||
Duplicates: make(map[string]time.Time),
|
||||
}
|
||||
|
||||
_, r := test.GenerateRequestInfo("POST", "/", nil, true)
|
||||
code, response := CreateQueueV1(r)
|
||||
|
||||
assert.Equal(t, http.StatusOK, code)
|
||||
assert.Equal(t, fixtures.CreateQueueResponse, response)
|
||||
|
||||
actualQueue := models.SyncQueues.Queues[fixtures.QueueName]
|
||||
assert.Equal(t, expectedQueue, actualQueue)
|
||||
}
|
||||
|
||||
func TestCreateQueueV1_success_no_configured_region_for_queue_url(t *testing.T) {
|
||||
models.CurrentEnvironment = fixtures.LOCAL_ENVIRONMENT
|
||||
models.CurrentEnvironment.Region = ""
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
dupe, _ := copystructure.Copy(fixtures.CreateQueueRequest)
|
||||
c, _ := dupe.(models.CreateQueueRequest)
|
||||
c.Attributes = models.QueueAttributes{}
|
||||
|
||||
v := resultingStruct.(*models.CreateQueueRequest)
|
||||
*v = c
|
||||
return true
|
||||
}
|
||||
|
||||
_, r := test.GenerateRequestInfo("POST", "/", nil, true)
|
||||
code, _ := CreateQueueV1(r)
|
||||
|
||||
assert.Equal(t, http.StatusOK, code)
|
||||
|
||||
actualQueue := models.SyncQueues.Queues[fixtures.QueueName]
|
||||
assert.Equal(t,
|
||||
fmt.Sprintf("http://%s:%s/%s/%s",
|
||||
fixtures.LOCAL_ENVIRONMENT.Host,
|
||||
fixtures.LOCAL_ENVIRONMENT.Port,
|
||||
fixtures.LOCAL_ENVIRONMENT.AccountID,
|
||||
fixtures.QueueName,
|
||||
),
|
||||
actualQueue.URL,
|
||||
)
|
||||
}
|
||||
|
||||
func TestCreateQueueV1_request_transformer_error(t *testing.T) {
|
||||
models.CurrentEnvironment = fixtures.LOCAL_ENVIRONMENT
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
return false
|
||||
}
|
||||
|
||||
_, r := test.GenerateRequestInfo("POST", "/", nil, true)
|
||||
code, _ := CreateQueueV1(r)
|
||||
|
||||
assert.Equal(t, http.StatusBadRequest, code)
|
||||
}
|
||||
|
||||
func TestCreateQueueV1_invalid_dead_letter_queue_error(t *testing.T) {
|
||||
models.CurrentEnvironment = fixtures.LOCAL_ENVIRONMENT
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
dupe, _ := copystructure.Copy(fixtures.CreateQueueRequest)
|
||||
c, _ := dupe.(models.CreateQueueRequest)
|
||||
c.Attributes.RedrivePolicy = models.RedrivePolicy{
|
||||
MaxReceiveCount: 100,
|
||||
DeadLetterTargetArn: fmt.Sprintf("arn:aws:sqs:us-east-1:100010001000:%s", "garbage"),
|
||||
}
|
||||
|
||||
v := resultingStruct.(*models.CreateQueueRequest)
|
||||
*v = c
|
||||
return true
|
||||
}
|
||||
|
||||
_, r := test.GenerateRequestInfo("POST", "/", nil, true)
|
||||
code, _ := CreateQueueV1(r)
|
||||
|
||||
assert.Equal(t, http.StatusBadRequest, code)
|
||||
}
|
||||
@@ -1,329 +0,0 @@
|
||||
package gosqs
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"net/http"
|
||||
"testing"
|
||||
|
||||
"shared-sqs/app/conf"
|
||||
"shared-sqs/app/fixtures"
|
||||
"shared-sqs/app/interfaces"
|
||||
"shared-sqs/app/models"
|
||||
"shared-sqs/app/test"
|
||||
"shared-sqs/app/utils"
|
||||
"github.com/stretchr/testify/assert"
|
||||
)
|
||||
|
||||
func TestDeleteMessageBatchV1_success_all_message(t *testing.T) {
|
||||
models.CurrentEnvironment = fixtures.LOCAL_ENVIRONMENT
|
||||
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
q := &models.Queue{
|
||||
Name: "testing",
|
||||
Messages: []models.SqsMessage{
|
||||
{
|
||||
MessageBody: "test%20message%20body%201",
|
||||
ReceiptHandle: "test1",
|
||||
},
|
||||
{
|
||||
MessageBody: "test%20message%20body%202",
|
||||
ReceiptHandle: "test2",
|
||||
},
|
||||
{
|
||||
MessageBody: "test%20message%20body%203",
|
||||
ReceiptHandle: "test3",
|
||||
},
|
||||
},
|
||||
}
|
||||
models.SyncQueues.Queues["testing"] = q
|
||||
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
v := resultingStruct.(*models.DeleteMessageBatchRequest)
|
||||
*v = models.DeleteMessageBatchRequest{
|
||||
Entries: []models.DeleteMessageBatchRequestEntry{
|
||||
{
|
||||
Id: "delete-test-1",
|
||||
ReceiptHandle: "test1",
|
||||
},
|
||||
{
|
||||
Id: "delete-test-2",
|
||||
ReceiptHandle: "test2",
|
||||
},
|
||||
{
|
||||
Id: "delete-test-3",
|
||||
ReceiptHandle: "test3",
|
||||
},
|
||||
},
|
||||
QueueUrl: fmt.Sprintf("%s/%s", fixtures.BASE_URL, "testing"),
|
||||
}
|
||||
return true
|
||||
}
|
||||
_, request2 := test.GenerateRequestInfo(
|
||||
"POST",
|
||||
"/",
|
||||
nil,
|
||||
true)
|
||||
|
||||
status, response2 := DeleteMessageBatchV1(request2)
|
||||
deleteMessageBatchResponse := response2.(models.DeleteMessageBatchResponse)
|
||||
assert.Equal(t, status, http.StatusOK)
|
||||
assert.Equal(t, "delete-test-1", deleteMessageBatchResponse.Result.Successful[0].Id)
|
||||
assert.Equal(t, "delete-test-2", deleteMessageBatchResponse.Result.Successful[1].Id)
|
||||
assert.Equal(t, "delete-test-3", deleteMessageBatchResponse.Result.Successful[2].Id)
|
||||
assert.Empty(t, deleteMessageBatchResponse.Result.Failed)
|
||||
assert.Empty(t, models.SyncQueues.Queues["testing"].Messages)
|
||||
}
|
||||
func TestDeleteMessageBatchV1_success_not_found_message(t *testing.T) {
|
||||
models.CurrentEnvironment = fixtures.LOCAL_ENVIRONMENT
|
||||
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
q := &models.Queue{
|
||||
Name: "testing",
|
||||
Messages: []models.SqsMessage{
|
||||
{
|
||||
MessageBody: "test%20message%20body%201",
|
||||
ReceiptHandle: "test1",
|
||||
},
|
||||
{
|
||||
MessageBody: "test%20message%20body%203",
|
||||
ReceiptHandle: "test3",
|
||||
},
|
||||
},
|
||||
}
|
||||
models.SyncQueues.Queues["testing"] = q
|
||||
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
v := resultingStruct.(*models.DeleteMessageBatchRequest)
|
||||
*v = models.DeleteMessageBatchRequest{
|
||||
Entries: []models.DeleteMessageBatchRequestEntry{
|
||||
{
|
||||
Id: "delete-test-1",
|
||||
ReceiptHandle: "test1",
|
||||
},
|
||||
{
|
||||
Id: "delete-test-2",
|
||||
ReceiptHandle: "test2",
|
||||
},
|
||||
{
|
||||
Id: "delete-test-3",
|
||||
ReceiptHandle: "test3",
|
||||
},
|
||||
},
|
||||
QueueUrl: fmt.Sprintf("%s/%s", fixtures.BASE_URL, "testing"),
|
||||
}
|
||||
return true
|
||||
}
|
||||
_, request := test.GenerateRequestInfo(
|
||||
"POST",
|
||||
"/",
|
||||
nil,
|
||||
true)
|
||||
|
||||
status, response := DeleteMessageBatchV1(request)
|
||||
deleteMessageBatchResponse := response.(models.DeleteMessageBatchResponse)
|
||||
assert.Equal(t, status, http.StatusOK)
|
||||
assert.Equal(t, "delete-test-1", deleteMessageBatchResponse.Result.Successful[0].Id)
|
||||
assert.Equal(t, "delete-test-3", deleteMessageBatchResponse.Result.Successful[1].Id)
|
||||
assert.Equal(t, "1", deleteMessageBatchResponse.Result.Failed[0].Code)
|
||||
assert.Equal(t, "delete-test-2", deleteMessageBatchResponse.Result.Failed[0].Id)
|
||||
assert.Equal(t, "Message not found", deleteMessageBatchResponse.Result.Failed[0].Message)
|
||||
assert.True(t, deleteMessageBatchResponse.Result.Failed[0].SenderFault)
|
||||
assert.Empty(t, models.SyncQueues.Queues["testing"].Messages)
|
||||
}
|
||||
|
||||
func TestDeleteMessageBatchV1_error_not_found_queue(t *testing.T) {
|
||||
models.CurrentEnvironment = fixtures.LOCAL_ENVIRONMENT
|
||||
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
v := resultingStruct.(*models.DeleteMessageBatchRequest)
|
||||
*v = models.DeleteMessageBatchRequest{
|
||||
Entries: []models.DeleteMessageBatchRequestEntry{
|
||||
{
|
||||
Id: "delete-test-1",
|
||||
ReceiptHandle: "test1",
|
||||
},
|
||||
{
|
||||
Id: "delete-test-2",
|
||||
ReceiptHandle: "test2",
|
||||
},
|
||||
{
|
||||
Id: "delete-test-3",
|
||||
ReceiptHandle: "test3",
|
||||
},
|
||||
},
|
||||
QueueUrl: fmt.Sprintf("%s/%s", fixtures.BASE_URL, "not-exist-queue"),
|
||||
}
|
||||
return true
|
||||
}
|
||||
_, r := test.GenerateRequestInfo(
|
||||
"POST",
|
||||
"/",
|
||||
nil,
|
||||
true)
|
||||
|
||||
status, _ := DeleteMessageBatchV1(r)
|
||||
assert.Equal(t, status, http.StatusBadRequest)
|
||||
|
||||
}
|
||||
|
||||
func TestDeleteMessageBatchV1_error_no_entry(t *testing.T) {
|
||||
conf.LoadYamlConfig("../conf/mock-data/mock-config.yaml", "BaseUnitTests")
|
||||
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
v := resultingStruct.(*models.DeleteMessageBatchRequest)
|
||||
*v = models.DeleteMessageBatchRequest{
|
||||
Entries: make([]models.DeleteMessageBatchRequestEntry, 0),
|
||||
QueueUrl: fmt.Sprintf("%s/%s", fixtures.BASE_URL, "unit-queue1"),
|
||||
}
|
||||
return true
|
||||
}
|
||||
_, r := test.GenerateRequestInfo(
|
||||
"POST",
|
||||
"/",
|
||||
nil,
|
||||
true)
|
||||
|
||||
status, _ := DeleteMessageBatchV1(r)
|
||||
assert.Equal(t, status, http.StatusBadRequest)
|
||||
}
|
||||
|
||||
func TestDeleteMessageBatchV1_error_too_many_entries(t *testing.T) {
|
||||
conf.LoadYamlConfig("../conf/mock-data/mock-config.yaml", "BaseUnitTests")
|
||||
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
v := resultingStruct.(*models.DeleteMessageBatchRequest)
|
||||
*v = models.DeleteMessageBatchRequest{
|
||||
Entries: []models.DeleteMessageBatchRequestEntry{
|
||||
{
|
||||
Id: "test-1",
|
||||
ReceiptHandle: "test-1",
|
||||
},
|
||||
{
|
||||
Id: "test-2",
|
||||
ReceiptHandle: "test-2",
|
||||
},
|
||||
{
|
||||
Id: "test-3",
|
||||
ReceiptHandle: "test-3",
|
||||
},
|
||||
{
|
||||
Id: "test-4",
|
||||
ReceiptHandle: "test-4",
|
||||
},
|
||||
{
|
||||
Id: "test-5",
|
||||
ReceiptHandle: "test-5",
|
||||
},
|
||||
{
|
||||
Id: "test-6",
|
||||
ReceiptHandle: "test-6",
|
||||
},
|
||||
{
|
||||
Id: "test-7",
|
||||
ReceiptHandle: "test-7",
|
||||
},
|
||||
{
|
||||
Id: "test-8",
|
||||
ReceiptHandle: "test-8",
|
||||
},
|
||||
{
|
||||
Id: "test-9",
|
||||
ReceiptHandle: "test-9",
|
||||
},
|
||||
{
|
||||
Id: "test-10",
|
||||
ReceiptHandle: "test-10",
|
||||
},
|
||||
{
|
||||
Id: "test-11",
|
||||
ReceiptHandle: "test-11",
|
||||
},
|
||||
},
|
||||
QueueUrl: fmt.Sprintf("%s/%s", fixtures.BASE_URL, "unit-queue1"),
|
||||
}
|
||||
return true
|
||||
}
|
||||
_, r := test.GenerateRequestInfo(
|
||||
"POST",
|
||||
"/",
|
||||
nil,
|
||||
true)
|
||||
|
||||
status, _ := DeleteMessageBatchV1(r)
|
||||
assert.Equal(t, status, http.StatusBadRequest)
|
||||
}
|
||||
|
||||
func TestDeleteMessageBatchV1_Error_IdNotDistinct(t *testing.T) {
|
||||
conf.LoadYamlConfig("../conf/mock-data/mock-config.yaml", "BaseUnitTests")
|
||||
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
v := resultingStruct.(*models.DeleteMessageBatchRequest)
|
||||
*v = models.DeleteMessageBatchRequest{
|
||||
Entries: []models.DeleteMessageBatchRequestEntry{
|
||||
{
|
||||
Id: "delete-test-1",
|
||||
ReceiptHandle: "test1",
|
||||
},
|
||||
{
|
||||
Id: "delete-test-1",
|
||||
ReceiptHandle: "test2",
|
||||
},
|
||||
},
|
||||
QueueUrl: fmt.Sprintf("%s/%s", fixtures.BASE_URL, "unit-queue1"),
|
||||
}
|
||||
return true
|
||||
}
|
||||
_, r := test.GenerateRequestInfo(
|
||||
"POST",
|
||||
"/",
|
||||
nil,
|
||||
true)
|
||||
|
||||
status, _ := DeleteMessageBatchV1(r)
|
||||
assert.Equal(t, http.StatusBadRequest, status)
|
||||
}
|
||||
|
||||
func TestDeleteMessageBatchV1_Error_transformer(t *testing.T) {
|
||||
conf.LoadYamlConfig("../conf/mock-data/mock-config.yaml", "BaseUnitTests")
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
return false
|
||||
}
|
||||
|
||||
_, r := test.GenerateRequestInfo("POST", "/", nil, true)
|
||||
status, _ := DeleteMessageBatchV1(r)
|
||||
|
||||
assert.Equal(t, http.StatusBadRequest, status)
|
||||
|
||||
}
|
||||
@@ -1,38 +0,0 @@
|
||||
package gosqs
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
"testing"
|
||||
|
||||
"shared-sqs/app/test"
|
||||
|
||||
"shared-sqs/app/fixtures"
|
||||
"shared-sqs/app/models"
|
||||
"github.com/stretchr/testify/assert"
|
||||
)
|
||||
|
||||
func TestDeleteMessage(t *testing.T) {
|
||||
models.CurrentEnvironment = fixtures.LOCAL_ENVIRONMENT
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
}()
|
||||
|
||||
q := &models.Queue{
|
||||
Name: "testing",
|
||||
Messages: []models.SqsMessage{{
|
||||
MessageBody: "test1",
|
||||
ReceiptHandle: "123",
|
||||
}},
|
||||
}
|
||||
|
||||
models.SyncQueues.Queues["testing"] = q
|
||||
|
||||
_, r := test.GenerateRequestInfo("POST", "/", models.DeleteMessageRequest{
|
||||
QueueUrl: "http://localhost:4100/queue/testing",
|
||||
ReceiptHandle: "123",
|
||||
}, true)
|
||||
status, _ := DeleteMessageV1(r)
|
||||
|
||||
assert.Equal(t, status, http.StatusOK)
|
||||
assert.Empty(t, q.Messages)
|
||||
}
|
||||
@@ -1,91 +0,0 @@
|
||||
package gosqs
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"net/http"
|
||||
"testing"
|
||||
|
||||
"shared-sqs/app/test"
|
||||
|
||||
"github.com/stretchr/testify/assert"
|
||||
|
||||
"shared-sqs/app/conf"
|
||||
"shared-sqs/app/fixtures"
|
||||
"shared-sqs/app/interfaces"
|
||||
"shared-sqs/app/models"
|
||||
"shared-sqs/app/utils"
|
||||
)
|
||||
|
||||
func TestDeleteQueueV1_success(t *testing.T) {
|
||||
conf.LoadYamlConfig("../conf/mock-data/mock-config.yaml", "BaseUnitTests")
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
v := resultingStruct.(*models.DeleteQueueRequest)
|
||||
*v = models.DeleteQueueRequest{
|
||||
QueueUrl: fmt.Sprintf("%s/%s", fixtures.BASE_URL, "unit-queue1"),
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
expectedResponse := models.DeleteQueueResponse{
|
||||
Xmlns: models.BaseXmlns,
|
||||
Metadata: models.BaseResponseMetadata,
|
||||
}
|
||||
|
||||
_, r := test.GenerateRequestInfo("POST", "/", nil, true)
|
||||
code, response := DeleteQueueV1(r)
|
||||
|
||||
assert.Equal(t, http.StatusOK, code)
|
||||
assert.Equal(t, expectedResponse, response)
|
||||
|
||||
_, ok := models.SyncQueues.Queues["unit-queue1"]
|
||||
assert.False(t, ok)
|
||||
}
|
||||
|
||||
func TestDeleteQueueV1_success_unknown_queue(t *testing.T) {
|
||||
conf.LoadYamlConfig("../conf/mock-data/mock-config.yaml", "BaseUnitTests")
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
v := resultingStruct.(*models.DeleteQueueRequest)
|
||||
*v = models.DeleteQueueRequest{
|
||||
QueueUrl: fmt.Sprintf("%s/%s", fixtures.BASE_URL, "unknown-queue1"),
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
expectedResponse := models.DeleteQueueResponse{
|
||||
Xmlns: models.BaseXmlns,
|
||||
Metadata: models.BaseResponseMetadata,
|
||||
}
|
||||
|
||||
_, r := test.GenerateRequestInfo("POST", "/", nil, true)
|
||||
code, response := DeleteQueueV1(r)
|
||||
|
||||
assert.Equal(t, http.StatusOK, code)
|
||||
assert.Equal(t, expectedResponse, response)
|
||||
}
|
||||
|
||||
func TestDeleteQueueV1_error_invalid_request(t *testing.T) {
|
||||
conf.LoadYamlConfig("../conf/mock-data/mock-config.yaml", "BaseUnitTests")
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
return false
|
||||
}
|
||||
|
||||
_, r := test.GenerateRequestInfo("POST", "/", nil, true)
|
||||
code, _ := DeleteQueueV1(r)
|
||||
|
||||
assert.Equal(t, http.StatusBadRequest, code)
|
||||
}
|
||||
@@ -1,180 +0,0 @@
|
||||
package gosqs
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"net/http"
|
||||
"testing"
|
||||
|
||||
"shared-sqs/app/test"
|
||||
|
||||
"github.com/mitchellh/copystructure"
|
||||
|
||||
"shared-sqs/app/conf"
|
||||
|
||||
"shared-sqs/app/fixtures"
|
||||
"shared-sqs/app/interfaces"
|
||||
"shared-sqs/app/models"
|
||||
"shared-sqs/app/utils"
|
||||
"github.com/stretchr/testify/assert"
|
||||
)
|
||||
|
||||
func TestGetQueueAttributesV1_success_all(t *testing.T) {
|
||||
conf.LoadYamlConfig("../conf/mock-data/mock-config.yaml", "BaseUnitTests")
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
v := resultingStruct.(*models.GetQueueAttributesRequest)
|
||||
*v = fixtures.GetQueueAttributesRequest
|
||||
return true
|
||||
}
|
||||
|
||||
_, r := test.GenerateRequestInfo("POST", "/", nil, true)
|
||||
code, response := GetQueueAttributesV1(r)
|
||||
|
||||
assert.Equal(t, http.StatusOK, code)
|
||||
assert.Equal(t, fixtures.GetQueueAttributesResponse, response)
|
||||
}
|
||||
|
||||
func TestGetQueueAttributesV1_success_no_request_attrs_returns_all(t *testing.T) {
|
||||
conf.LoadYamlConfig("../conf/mock-data/mock-config.yaml", "BaseUnitTests")
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
v := resultingStruct.(*models.GetQueueAttributesRequest)
|
||||
*v = models.GetQueueAttributesRequest{
|
||||
QueueUrl: "unit-queue1",
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
_, r := test.GenerateRequestInfo("POST", "/", nil, true)
|
||||
code, response := GetQueueAttributesV1(r)
|
||||
|
||||
assert.Equal(t, http.StatusOK, code)
|
||||
assert.Equal(t, fixtures.GetQueueAttributesResponse, response)
|
||||
}
|
||||
|
||||
func TestGetQueueAttributesV1_success_all_with_redrive_queue(t *testing.T) {
|
||||
conf.LoadYamlConfig("../conf/mock-data/mock-config.yaml", "BaseUnitTests")
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
v := resultingStruct.(*models.GetQueueAttributesRequest)
|
||||
*v = models.GetQueueAttributesRequest{
|
||||
QueueUrl: "unit-queue2",
|
||||
AttributeNames: []string{"All"},
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
_, r := test.GenerateRequestInfo("POST", "/", nil, true)
|
||||
code, response := GetQueueAttributesV1(r)
|
||||
|
||||
dupe, _ := copystructure.Copy(fixtures.GetQueueAttributesResponse)
|
||||
expectedResponse, _ := dupe.(models.GetQueueAttributesResponse)
|
||||
expectedResponse.Result.Attrs[9].Value = fmt.Sprintf("%s:%s", fixtures.BASE_SQS_ARN, "unit-queue2")
|
||||
expectedResponse.Result.Attrs = append(expectedResponse.Result.Attrs,
|
||||
models.Attribute{
|
||||
Name: "RedrivePolicy",
|
||||
Value: fmt.Sprintf(`{"maxReceiveCount":"1", "deadLetterTargetArn":"%s:%s"}`, fixtures.BASE_SQS_ARN, "dead-letter-queue1"),
|
||||
},
|
||||
)
|
||||
|
||||
assert.Equal(t, http.StatusOK, code)
|
||||
assert.Equal(t, expectedResponse, response)
|
||||
}
|
||||
|
||||
func TestGetQueueAttributesV1_success_specific_fields(t *testing.T) {
|
||||
conf.LoadYamlConfig("../conf/mock-data/mock-config.yaml", "BaseUnitTests")
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
v := resultingStruct.(*models.GetQueueAttributesRequest)
|
||||
*v = models.GetQueueAttributesRequest{
|
||||
QueueUrl: fmt.Sprintf("%s/unit-queue1", fixtures.BASE_URL),
|
||||
AttributeNames: []string{"DelaySeconds"},
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
_, r := test.GenerateRequestInfo("POST", "/", nil, true)
|
||||
code, response := GetQueueAttributesV1(r)
|
||||
|
||||
expectedResponse := models.GetQueueAttributesResponse{
|
||||
Xmlns: models.BaseXmlns,
|
||||
Result: models.GetQueueAttributesResult{Attrs: []models.Attribute{
|
||||
models.Attribute{
|
||||
Name: "DelaySeconds",
|
||||
Value: "0",
|
||||
},
|
||||
}},
|
||||
Metadata: models.BaseResponseMetadata,
|
||||
}
|
||||
|
||||
assert.Equal(t, http.StatusOK, code)
|
||||
assert.Equal(t, expectedResponse, response)
|
||||
}
|
||||
|
||||
func TestGetQueueAttributesV1_request_transformer_error(t *testing.T) {
|
||||
defer func() {
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
return false
|
||||
}
|
||||
|
||||
_, r := test.GenerateRequestInfo("POST", "/", nil, true)
|
||||
code, _ := GetQueueAttributesV1(r)
|
||||
|
||||
assert.Equal(t, http.StatusBadRequest, code)
|
||||
}
|
||||
|
||||
func TestGetQueueAttributesV1_missing_queue_url_in_request_returns_error(t *testing.T) {
|
||||
defer func() {
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
v := resultingStruct.(*models.GetQueueAttributesRequest)
|
||||
*v = models.GetQueueAttributesRequest{
|
||||
QueueUrl: "",
|
||||
AttributeNames: []string{},
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
_, r := test.GenerateRequestInfo("POST", "/", nil, true)
|
||||
code, _ := GetQueueAttributesV1(r)
|
||||
|
||||
assert.Equal(t, http.StatusBadRequest, code)
|
||||
}
|
||||
|
||||
func TestGetQueueAttributesV1_missing_queue_returns_error(t *testing.T) {
|
||||
defer func() {
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
v := resultingStruct.(*models.GetQueueAttributesRequest)
|
||||
*v = fixtures.GetQueueAttributesRequest
|
||||
return true
|
||||
}
|
||||
|
||||
_, r := test.GenerateRequestInfo("POST", "/", nil, true)
|
||||
code, _ := GetQueueAttributesV1(r)
|
||||
|
||||
assert.Equal(t, http.StatusBadRequest, code)
|
||||
}
|
||||
@@ -1,104 +0,0 @@
|
||||
package gosqs
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"net/http"
|
||||
"testing"
|
||||
|
||||
"shared-sqs/app/test"
|
||||
|
||||
"shared-sqs/app/conf"
|
||||
"shared-sqs/app/fixtures"
|
||||
"shared-sqs/app/interfaces"
|
||||
"shared-sqs/app/models"
|
||||
"shared-sqs/app/utils"
|
||||
"github.com/stretchr/testify/assert"
|
||||
)
|
||||
|
||||
func TestGetQueueUrlV1_success(t *testing.T) {
|
||||
conf.LoadYamlConfig("../conf/mock-data/mock-config.yaml", "BaseUnitTests")
|
||||
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
v := resultingStruct.(*models.GetQueueUrlRequest)
|
||||
*v = models.GetQueueUrlRequest{
|
||||
QueueName: "unit-queue1",
|
||||
QueueOwnerAWSAccountId: "fugafuga",
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
_, r := test.GenerateRequestInfo(
|
||||
"POST",
|
||||
"/",
|
||||
nil,
|
||||
true)
|
||||
code, response := GetQueueUrlV1(r)
|
||||
|
||||
get_queue_url_response := response.(models.GetQueueUrlResponse)
|
||||
|
||||
assert.Equal(t, http.StatusOK, code)
|
||||
assert.Contains(t, get_queue_url_response.Result.QueueUrl, fmt.Sprintf("%s/%s", fixtures.BASE_URL, "unit-queue1"))
|
||||
|
||||
}
|
||||
|
||||
func TestGetQueueUrlV1_error_no_queue(t *testing.T) {
|
||||
|
||||
conf.LoadYamlConfig("../conf/mock-data/mock-config.yaml", "BaseUnitTests")
|
||||
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
v := resultingStruct.(*models.GetQueueUrlRequest)
|
||||
*v = models.GetQueueUrlRequest{
|
||||
QueueName: "not-exist-unit-queue1",
|
||||
QueueOwnerAWSAccountId: "fugafuga",
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
_, r := test.GenerateRequestInfo(
|
||||
"POST",
|
||||
"/",
|
||||
nil,
|
||||
true)
|
||||
code, response := GetQueueUrlV1(r)
|
||||
|
||||
expected := models.ErrorResult{
|
||||
Type: "Not Found",
|
||||
Code: "AWS.SimpleQueueService.NonExistentQueue",
|
||||
Message: "The specified queue does not exist for this wsdl version.",
|
||||
}
|
||||
|
||||
assert.Equal(t, http.StatusBadRequest, code)
|
||||
assert.Equal(t, response.GetResult().(models.ErrorResult), expected)
|
||||
}
|
||||
|
||||
func TestGetQueueUrlV1_error_request_transformer(t *testing.T) {
|
||||
|
||||
conf.LoadYamlConfig("../conf/mock-data/mock-config.yaml", "BaseUnitTests")
|
||||
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
return false
|
||||
}
|
||||
|
||||
_, r := test.GenerateRequestInfo(
|
||||
"POST",
|
||||
"/",
|
||||
nil,
|
||||
true)
|
||||
code, _ := GetQueueUrlV1(r)
|
||||
assert.Equal(t, http.StatusBadRequest, code)
|
||||
}
|
||||
@@ -1,668 +0,0 @@
|
||||
package gosqs
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"sync"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"shared-sqs/app/conf"
|
||||
|
||||
"shared-sqs/app/fixtures"
|
||||
|
||||
"shared-sqs/app/models"
|
||||
"shared-sqs/app/utils"
|
||||
"github.com/stretchr/testify/assert"
|
||||
)
|
||||
|
||||
// TODO - Admiral-Piett these are better but still screwy. It's easy to have race conditions in here, so
|
||||
// we have to name all the queues uniquely and leave them around so we're not resetting ourselves.
|
||||
// Stupid. Handle the global memory issues and this can be easily resolved.
|
||||
func Test_PeriodicTasks_deletes_deduplication_period_upon_expiration(t *testing.T) {
|
||||
models.DeduplicationPeriod = 20 * time.Millisecond
|
||||
quit := make(chan bool)
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
quit <- true
|
||||
models.DeduplicationPeriod = 5 * time.Minute
|
||||
}()
|
||||
|
||||
qName := "gosqs-dedupe-queue1"
|
||||
mainQueue := &models.Queue{
|
||||
Name: qName,
|
||||
URL: fmt.Sprintf("%s/%s", fixtures.BASE_URL, qName),
|
||||
Arn: fmt.Sprintf("%s:%s", fixtures.BASE_SQS_ARN, qName),
|
||||
Duplicates: map[string]time.Time{
|
||||
"12345": time.Now(),
|
||||
},
|
||||
}
|
||||
models.SyncQueues.Lock()
|
||||
models.SyncQueues.Queues[qName] = mainQueue
|
||||
models.SyncQueues.Unlock()
|
||||
|
||||
go PeriodicTasks(10*time.Millisecond, quit)
|
||||
|
||||
assertions := func() bool {
|
||||
models.SyncQueues.Lock()
|
||||
defer models.SyncQueues.Unlock()
|
||||
|
||||
ok := 0 == len(mainQueue.Duplicates)
|
||||
if !ok {
|
||||
return false
|
||||
}
|
||||
return true
|
||||
}
|
||||
assert.Eventually(t, assertions, 10*time.Second, 10*time.Millisecond)
|
||||
}
|
||||
|
||||
func Test_PeriodicTasks_VisibilityTimeout_expires(t *testing.T) {
|
||||
quit := make(chan bool)
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
quit <- true
|
||||
}()
|
||||
qName := "gosqs-visibility-queue1"
|
||||
mainQueue := &models.Queue{
|
||||
Name: qName,
|
||||
URL: fmt.Sprintf("%s/%s", fixtures.BASE_URL, qName),
|
||||
Arn: fmt.Sprintf("%s:%s", fixtures.BASE_SQS_ARN, qName),
|
||||
}
|
||||
mainQueue.Messages = append(mainQueue.Messages, models.SqsMessage{
|
||||
MessageBody: "1",
|
||||
ReceiptHandle: "12345",
|
||||
VisibilityTimeout: time.Now().Add(30 * time.Millisecond),
|
||||
})
|
||||
|
||||
models.SyncQueues.Lock()
|
||||
models.SyncQueues.Queues[qName] = mainQueue
|
||||
models.SyncQueues.Unlock()
|
||||
|
||||
go PeriodicTasks(10*time.Millisecond, quit)
|
||||
|
||||
assertions := func() bool {
|
||||
models.SyncQueues.Lock()
|
||||
defer models.SyncQueues.Unlock()
|
||||
|
||||
ok := !mainQueue.Messages[0].ReceiptTime.IsZero()
|
||||
if !ok {
|
||||
return false
|
||||
}
|
||||
ok = "1" == mainQueue.Messages[0].MessageBody
|
||||
if !ok {
|
||||
return false
|
||||
}
|
||||
ok = "" == mainQueue.Messages[0].ReceiptHandle
|
||||
if !ok {
|
||||
return false
|
||||
}
|
||||
ok = 1 == mainQueue.Messages[0].Retry
|
||||
if !ok {
|
||||
return false
|
||||
}
|
||||
return true
|
||||
}
|
||||
assert.Eventually(t, assertions, 10*time.Second, 10*time.Millisecond)
|
||||
}
|
||||
|
||||
func Test_PeriodicTasks_moves_single_message_to_dead_letter_queue_upon_passing_receive_count(t *testing.T) {
|
||||
quit := make(chan bool)
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
quit <- true
|
||||
}()
|
||||
|
||||
qName := "gosqs-main-queue1"
|
||||
dlqName := "gosqs-dead-letter-queue1"
|
||||
dlqQueue := &models.Queue{
|
||||
Arn: fmt.Sprintf("%s/%s", fixtures.BASE_SQS_ARN, dlqName),
|
||||
Name: dlqName,
|
||||
URL: fmt.Sprintf("%s/%s", fixtures.BASE_URL, dlqName),
|
||||
}
|
||||
mainQueue := &models.Queue{
|
||||
Arn: fmt.Sprintf("%s/%s", fixtures.BASE_SQS_ARN, qName),
|
||||
DeadLetterQueue: dlqQueue,
|
||||
MaxReceiveCount: 1,
|
||||
Name: qName,
|
||||
URL: fmt.Sprintf("%s/%s", fixtures.BASE_URL, qName),
|
||||
}
|
||||
|
||||
go PeriodicTasks(10*time.Millisecond, quit)
|
||||
|
||||
models.SyncQueues.Lock()
|
||||
mainQueue.Messages = append(mainQueue.Messages, models.SqsMessage{
|
||||
MessageBody: "1",
|
||||
Retry: 100,
|
||||
ReceiptHandle: "12345",
|
||||
VisibilityTimeout: time.Now().Add(10 * time.Millisecond),
|
||||
})
|
||||
models.SyncQueues.Queues[qName] = mainQueue
|
||||
models.SyncQueues.Queues[dlqName] = dlqQueue
|
||||
models.SyncQueues.Unlock()
|
||||
|
||||
assertions := func() bool {
|
||||
models.SyncQueues.Lock()
|
||||
defer models.SyncQueues.Unlock()
|
||||
|
||||
ok := len(dlqQueue.Messages) == 1
|
||||
if !ok {
|
||||
return false
|
||||
}
|
||||
ok = "1" == dlqQueue.Messages[0].MessageBody
|
||||
if !ok {
|
||||
return false
|
||||
}
|
||||
return true
|
||||
}
|
||||
assert.Eventually(t, assertions, 10*time.Second, 10*time.Millisecond)
|
||||
}
|
||||
|
||||
func Test_PeriodicTasks_moves_multiple_messages_to_dead_letter_queue_upon_passing_receive_count(t *testing.T) {
|
||||
quit := make(chan bool)
|
||||
conf.LoadYamlConfig("../conf/mock-data/mock-config.yaml", "BaseUnitTests")
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
quit <- true
|
||||
}()
|
||||
|
||||
mainQueue := models.SyncQueues.Queues["unit-queue2"]
|
||||
dlqQueue := models.SyncQueues.Queues["dead-letter-queue1"]
|
||||
|
||||
assert.Len(t, dlqQueue.Messages, 0)
|
||||
|
||||
go PeriodicTasks(10*time.Millisecond, quit)
|
||||
|
||||
models.SyncQueues.Lock()
|
||||
mainQueue.Messages = append(mainQueue.Messages, models.SqsMessage{
|
||||
MessageBody: "1",
|
||||
Retry: 100,
|
||||
ReceiptHandle: "12345",
|
||||
})
|
||||
mainQueue.Messages = append(mainQueue.Messages, models.SqsMessage{
|
||||
MessageBody: "2",
|
||||
Retry: 100,
|
||||
ReceiptHandle: "23456",
|
||||
})
|
||||
models.SyncQueues.Unlock()
|
||||
|
||||
assertions := func() bool {
|
||||
models.SyncQueues.Lock()
|
||||
defer models.SyncQueues.Unlock()
|
||||
|
||||
ok := len(dlqQueue.Messages) == 2
|
||||
if !ok {
|
||||
return false
|
||||
}
|
||||
ok = "1" == dlqQueue.Messages[0].MessageBody
|
||||
if !ok {
|
||||
return false
|
||||
}
|
||||
ok = "2" == dlqQueue.Messages[1].MessageBody
|
||||
if !ok {
|
||||
return false
|
||||
}
|
||||
return true
|
||||
}
|
||||
assert.Eventually(t, assertions, 10*time.Second, 10*time.Millisecond)
|
||||
}
|
||||
|
||||
// TODO - I think all these below belong in handler tests, not in here. Double check the relevant
|
||||
// handlers for coverage and delete.
|
||||
func TestSendingAndReceivingFromFIFOQueueReturnsSameMessageOnError(t *testing.T) {
|
||||
done := make(chan bool)
|
||||
go PeriodicTasks(1*time.Second, done)
|
||||
|
||||
// create a queue
|
||||
req, err := http.NewRequest("POST", "/", nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
form := url.Values{}
|
||||
form.Add("Action", "CreateQueue")
|
||||
form.Add("QueueName", "requeue-reset.fifo")
|
||||
form.Add("Attribute.1.Name", "VisibilityTimeout")
|
||||
form.Add("Attribute.1.Value", "2")
|
||||
form.Add("Version", "2012-11-05")
|
||||
req.PostForm = form
|
||||
|
||||
status, _ := CreateQueueV1(req)
|
||||
assert.Equal(t, status, http.StatusOK)
|
||||
|
||||
// send a message
|
||||
req, err = http.NewRequest("POST", "/", nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
form = url.Values{}
|
||||
form.Add("Action", "SendMessage")
|
||||
form.Add("QueueUrl", "http://localhost:4100/queue/requeue-reset.fifo")
|
||||
form.Add("MessageBody", "1")
|
||||
form.Add("MessageGroupId", "GROUP-X")
|
||||
form.Add("Version", "2012-11-05")
|
||||
req.PostForm = form
|
||||
|
||||
status, _ = SendMessageV1(req)
|
||||
if status != http.StatusOK {
|
||||
t.Errorf("handler returned wrong status code: got \n%v want %v",
|
||||
status, http.StatusOK)
|
||||
}
|
||||
|
||||
// send a message
|
||||
req, err = http.NewRequest("POST", "/", nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
form = url.Values{}
|
||||
form.Add("Action", "SendMessage")
|
||||
form.Add("QueueUrl", "http://localhost:4100/queue/requeue-reset.fifo")
|
||||
form.Add("MessageBody", "2")
|
||||
form.Add("MessageGroupId", "GROUP-X")
|
||||
form.Add("Version", "2012-11-05")
|
||||
req.PostForm = form
|
||||
|
||||
status, _ = SendMessageV1(req)
|
||||
if status != http.StatusOK {
|
||||
t.Errorf("handler returned wrong status code: got \n%v want %v",
|
||||
status, http.StatusOK)
|
||||
}
|
||||
|
||||
// receive message
|
||||
req, err = http.NewRequest("POST", "/", nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
form = url.Values{}
|
||||
form.Add("Action", "ReceiveMessage")
|
||||
form.Add("QueueUrl", "http://localhost:4100/queue/requeue-reset.fifo")
|
||||
form.Add("Version", "2012-11-05")
|
||||
req.PostForm = form
|
||||
|
||||
status, resp := ReceiveMessageV1(req)
|
||||
assert.Equal(t, status, http.StatusOK)
|
||||
|
||||
result := resp.GetResult().(models.ReceiveMessageResult)
|
||||
receiptHandleFirst := result.Messages[0].ReceiptHandle
|
||||
if string(result.Messages[0].Body) != "1" {
|
||||
t.Fatalf("should have received body 1: %s", err)
|
||||
}
|
||||
|
||||
// try to receive another message and we should get none
|
||||
req, err = http.NewRequest("POST", "/", nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
form = url.Values{}
|
||||
form.Add("Action", "ReceiveMessage")
|
||||
form.Add("QueueUrl", "http://localhost:4100/queue/requeue-reset.fifo")
|
||||
form.Add("Version", "2012-11-05")
|
||||
req.PostForm = form
|
||||
|
||||
status, _ = ReceiveMessageV1(req)
|
||||
assert.Equal(t, status, http.StatusOK)
|
||||
|
||||
if len(models.SyncQueues.Queues["requeue-reset.fifo"].FIFOMessages) != 1 {
|
||||
t.Fatal("there should be only 1 group locked")
|
||||
}
|
||||
|
||||
if models.SyncQueues.Queues["requeue-reset.fifo"].FIFOMessages["GROUP-X"] != 0 {
|
||||
t.Fatal("there should be GROUP-X locked")
|
||||
}
|
||||
|
||||
// remove message
|
||||
req, err = http.NewRequest("POST", "/", nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
form = url.Values{}
|
||||
form.Add("Action", "DeleteMessage")
|
||||
form.Add("QueueUrl", "http://localhost:4100/queue/requeue-reset.fifo")
|
||||
form.Add("ReceiptHandle", receiptHandleFirst)
|
||||
form.Add("Version", "2012-11-05")
|
||||
req.PostForm = form
|
||||
|
||||
status, _ = DeleteMessageV1(req)
|
||||
assert.Equal(t, status, http.StatusOK)
|
||||
|
||||
if len(models.SyncQueues.Queues["requeue-reset.fifo"].Messages) != 1 {
|
||||
t.Fatal("there should be only 1 message in queue")
|
||||
}
|
||||
|
||||
// receive message - loop until visibility timeouts
|
||||
for {
|
||||
req, err = http.NewRequest("POST", "/", nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
form = url.Values{}
|
||||
form.Add("Action", "ReceiveMessage")
|
||||
form.Add("QueueUrl", "http://localhost:4100/queue/requeue-reset.fifo")
|
||||
form.Add("Version", "2012-11-05")
|
||||
req.PostForm = form
|
||||
|
||||
status, resp := ReceiveMessageV1(req)
|
||||
assert.Equal(t, status, http.StatusOK)
|
||||
|
||||
result := resp.GetResult().(models.ReceiveMessageResult)
|
||||
if len(result.Messages) == 0 {
|
||||
continue
|
||||
}
|
||||
|
||||
if string(result.Messages[0].Body) != "2" {
|
||||
t.Fatalf("should have received body 2: %s", err)
|
||||
}
|
||||
break
|
||||
}
|
||||
|
||||
done <- true
|
||||
}
|
||||
|
||||
func TestSendMessage_POST_DuplicatationNotAppliedToStandardQueue(t *testing.T) {
|
||||
done := make(chan bool)
|
||||
go PeriodicTasks(1*time.Second, done)
|
||||
|
||||
// create a queue
|
||||
req, err := http.NewRequest("POST", "/", nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
form := url.Values{}
|
||||
form.Add("Action", "CreateQueue")
|
||||
form.Add("QueueName", "stantdard-testing")
|
||||
form.Add("Version", "2012-11-05")
|
||||
req.PostForm = form
|
||||
|
||||
status, _ := CreateQueueV1(req)
|
||||
|
||||
assert.Equal(t, status, http.StatusOK)
|
||||
|
||||
req, err = http.NewRequest("POST", "/", nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
form = url.Values{}
|
||||
form.Add("Action", "SendMessage")
|
||||
form.Add("QueueUrl", "http://localhost:4100/queue/stantdard-testing")
|
||||
form.Add("MessageBody", "Test1")
|
||||
form.Add("MessageDeduplicationId", "123")
|
||||
form.Add("Version", "2012-11-05")
|
||||
req.PostForm = form
|
||||
|
||||
status, _ = SendMessageV1(req)
|
||||
|
||||
// Check the status code is what we expect.
|
||||
if status != http.StatusOK {
|
||||
t.Errorf("handler returned wrong status code: got \n%v want %v",
|
||||
status, http.StatusOK)
|
||||
}
|
||||
if len(models.SyncQueues.Queues["stantdard-testing"].Messages) == 0 {
|
||||
t.Fatal("there should be 1 message in queue")
|
||||
}
|
||||
|
||||
form = url.Values{}
|
||||
form.Add("Action", "SendMessage")
|
||||
form.Add("QueueUrl", "http://localhost:4100/queue/stantdard-testing")
|
||||
form.Add("MessageBody", "Test2")
|
||||
form.Add("MessageDeduplicationId", "123")
|
||||
form.Add("Version", "2012-11-05")
|
||||
req.PostForm = form
|
||||
|
||||
status, _ = SendMessageV1(req)
|
||||
|
||||
// Check the status code is what we expect.
|
||||
if status != http.StatusOK {
|
||||
t.Errorf("handler returned wrong status code: got \n%v want %v",
|
||||
status, http.StatusOK)
|
||||
}
|
||||
if len(models.SyncQueues.Queues["stantdard-testing"].Messages) == 1 {
|
||||
t.Fatal("there should be 2 messages in queue")
|
||||
}
|
||||
done <- true
|
||||
}
|
||||
|
||||
func TestSendMessage_POST_DuplicatationDisabledOnFifoQueue(t *testing.T) {
|
||||
done := make(chan bool)
|
||||
go PeriodicTasks(1*time.Second, done)
|
||||
|
||||
// create a queue
|
||||
req, err := http.NewRequest("POST", "/", nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
form := url.Values{}
|
||||
form.Add("Action", "CreateQueue")
|
||||
form.Add("QueueName", "no-dup-testing.fifo")
|
||||
form.Add("Version", "2012-11-05")
|
||||
req.PostForm = form
|
||||
|
||||
status, _ := CreateQueueV1(req)
|
||||
|
||||
assert.Equal(t, status, http.StatusOK)
|
||||
|
||||
req, err = http.NewRequest("POST", "/", nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
form = url.Values{}
|
||||
form.Add("Action", "SendMessage")
|
||||
form.Add("QueueUrl", "http://localhost:4100/queue/no-dup-testing.fifo")
|
||||
form.Add("MessageBody", "Test1")
|
||||
form.Add("MessageDeduplicationId", "123")
|
||||
form.Add("Version", "2012-11-05")
|
||||
req.PostForm = form
|
||||
|
||||
status, _ = SendMessageV1(req)
|
||||
|
||||
// Check the status code is what we expect.
|
||||
if status != http.StatusOK {
|
||||
t.Errorf("handler returned wrong status code: got \n%v want %v",
|
||||
status, http.StatusOK)
|
||||
}
|
||||
if len(models.SyncQueues.Queues["no-dup-testing.fifo"].Messages) == 0 {
|
||||
t.Fatal("there should be 1 message in queue")
|
||||
}
|
||||
|
||||
form = url.Values{}
|
||||
form.Add("Action", "SendMessage")
|
||||
form.Add("QueueUrl", "http://localhost:4100/queue/no-dup-testing.fifo")
|
||||
form.Add("MessageBody", "Test2")
|
||||
form.Add("MessageDeduplicationId", "123")
|
||||
form.Add("Version", "2012-11-05")
|
||||
req.PostForm = form
|
||||
|
||||
status, _ = SendMessageV1(req)
|
||||
|
||||
// Check the status code is what we expect.
|
||||
if status != http.StatusOK {
|
||||
t.Errorf("handler returned wrong status code: got \n%v want %v",
|
||||
status, http.StatusOK)
|
||||
}
|
||||
if len(models.SyncQueues.Queues["no-dup-testing.fifo"].Messages) != 2 {
|
||||
t.Fatal("there should be 2 message in queue")
|
||||
}
|
||||
done <- true
|
||||
}
|
||||
|
||||
func TestSendMessage_POST_DuplicatationEnabledOnFifoQueue(t *testing.T) {
|
||||
done := make(chan bool)
|
||||
go PeriodicTasks(1*time.Second, done)
|
||||
|
||||
// create a queue
|
||||
req, err := http.NewRequest("POST", "/", nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
form := url.Values{}
|
||||
form.Add("Action", "CreateQueue")
|
||||
form.Add("QueueName", "dup-testing.fifo")
|
||||
form.Add("Version", "2012-11-05")
|
||||
req.PostForm = form
|
||||
|
||||
status, _ := CreateQueueV1(req)
|
||||
|
||||
assert.Equal(t, status, http.StatusOK)
|
||||
|
||||
req, err = http.NewRequest("POST", "/", nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
models.SyncQueues.Queues["dup-testing.fifo"].EnableDuplicates = true
|
||||
|
||||
form = url.Values{}
|
||||
form.Add("Action", "SendMessage")
|
||||
form.Add("QueueUrl", "http://localhost:4100/queue/dup-testing.fifo")
|
||||
form.Add("MessageBody", "Test1")
|
||||
form.Add("MessageDeduplicationId", "123")
|
||||
form.Add("Version", "2012-11-05")
|
||||
req.PostForm = form
|
||||
|
||||
status, _ = SendMessageV1(req)
|
||||
|
||||
// Check the status code is what we expect.
|
||||
if status != http.StatusOK {
|
||||
t.Errorf("handler returned wrong status code: got \n%v want %v",
|
||||
status, http.StatusOK)
|
||||
}
|
||||
if len(models.SyncQueues.Queues["dup-testing.fifo"].Messages) == 0 {
|
||||
t.Fatal("there should be 1 message in queue")
|
||||
}
|
||||
|
||||
form = url.Values{}
|
||||
form.Add("Action", "SendMessage")
|
||||
form.Add("QueueUrl", "http://localhost:4100/queue/dup-testing.fifo")
|
||||
form.Add("MessageBody", "Test2")
|
||||
form.Add("MessageDeduplicationId", "123")
|
||||
form.Add("Version", "2012-11-05")
|
||||
req.PostForm = form
|
||||
|
||||
status, _ = SendMessageV1(req)
|
||||
|
||||
// Check the status code is what we expect.
|
||||
if status != http.StatusOK {
|
||||
t.Errorf("handler returned wrong status code: got \n%v want %v",
|
||||
status, http.StatusOK)
|
||||
}
|
||||
if len(models.SyncQueues.Queues["dup-testing.fifo"].Messages) != 1 {
|
||||
t.Fatal("there should be 1 message in queue")
|
||||
}
|
||||
if body := models.SyncQueues.Queues["dup-testing.fifo"].Messages[0].MessageBody; string(body) == "Test2" {
|
||||
t.Fatal("duplicate message should not be added to queue")
|
||||
}
|
||||
done <- true
|
||||
}
|
||||
|
||||
func TestSendMessage_POST_DelaySeconds(t *testing.T) {
|
||||
// create a queue
|
||||
req, err := http.NewRequest("POST", "/", nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
form := url.Values{}
|
||||
form.Add("Action", "CreateQueue")
|
||||
form.Add("QueueName", "sendmessage-delay")
|
||||
form.Add("Version", "2012-11-05")
|
||||
req.PostForm = form
|
||||
|
||||
status, _ := CreateQueueV1(req)
|
||||
|
||||
assert.Equal(t, status, http.StatusOK)
|
||||
|
||||
// send a message
|
||||
req, err = http.NewRequest("POST", "/", nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
form = url.Values{}
|
||||
form.Add("Action", "SendMessage")
|
||||
form.Add("QueueUrl", "http://localhost:4100/queue/sendmessage-delay")
|
||||
form.Add("MessageBody", "1")
|
||||
form.Add("DelaySeconds", "2")
|
||||
form.Add("Version", "2012-11-05")
|
||||
req.PostForm = form
|
||||
|
||||
status, _ = SendMessageV1(req)
|
||||
if status != http.StatusOK {
|
||||
t.Errorf("handler returned wrong status code: got \n%v want %v",
|
||||
status, http.StatusOK)
|
||||
}
|
||||
|
||||
// receive message before delay is up
|
||||
req, err = http.NewRequest("POST", "/", nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
form = url.Values{}
|
||||
form.Add("Action", "ReceiveMessage")
|
||||
form.Add("QueueUrl", "http://localhost:4100/queue/sendmessage-delay")
|
||||
form.Add("Version", "2012-11-05")
|
||||
req.PostForm = form
|
||||
status, _ = ReceiveMessageV1(req)
|
||||
assert.Equal(t, status, http.StatusOK)
|
||||
|
||||
// receive message with wait should return after delay
|
||||
req, err = http.NewRequest("POST", "/", nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
form = url.Values{}
|
||||
form.Add("Action", "ReceiveMessage")
|
||||
form.Add("QueueUrl", "http://localhost:4100/queue/sendmessage-delay")
|
||||
form.Add("WaitTimeSeconds", "10")
|
||||
form.Add("Version", "2012-11-05")
|
||||
req.PostForm = form
|
||||
start := time.Now()
|
||||
status, _ = ReceiveMessageV1(req)
|
||||
elapsed := time.Since(start)
|
||||
assert.Equal(t, status, http.StatusOK)
|
||||
if elapsed < 1*time.Second {
|
||||
t.Errorf("handler didn't wait at all")
|
||||
}
|
||||
if elapsed > 4*time.Second {
|
||||
t.Errorf("handler didn't need to wait all WaitTimeSeconds=10, only DelaySeconds=2")
|
||||
}
|
||||
}
|
||||
|
||||
func TestCreateErrorResponseV1(t *testing.T) {
|
||||
expectedResponse := models.ErrorResponse{
|
||||
Result: models.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 := utils.CreateErrorResponseV1("QueueNotFound", true)
|
||||
|
||||
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
|
||||
func waitTimeout(wg *sync.WaitGroup, timeout time.Duration) bool {
|
||||
c := make(chan struct{})
|
||||
go func() {
|
||||
defer close(c)
|
||||
wg.Wait()
|
||||
}()
|
||||
select {
|
||||
case <-c:
|
||||
return false // completed normally
|
||||
case <-time.After(timeout):
|
||||
return true // timed out
|
||||
}
|
||||
}
|
||||
@@ -1,116 +0,0 @@
|
||||
package gosqs
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"net/http"
|
||||
"testing"
|
||||
|
||||
"shared-sqs/app/test"
|
||||
|
||||
"shared-sqs/app/conf"
|
||||
"shared-sqs/app/fixtures"
|
||||
"shared-sqs/app/interfaces"
|
||||
"shared-sqs/app/models"
|
||||
"shared-sqs/app/utils"
|
||||
"github.com/stretchr/testify/assert"
|
||||
)
|
||||
|
||||
func TestListQueuesV1_success(t *testing.T) {
|
||||
conf.LoadYamlConfig("../conf/mock-data/mock-config.yaml", "BaseUnitTests")
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
v := resultingStruct.(*models.ListQueueRequest)
|
||||
*v = models.ListQueueRequest{}
|
||||
return true
|
||||
}
|
||||
|
||||
_, r := test.GenerateRequestInfo("POST", "/", nil, true)
|
||||
code, response := ListQueuesV1(r)
|
||||
r1 := response.(models.ListQueuesResponse)
|
||||
|
||||
assert.Equal(t, http.StatusOK, code)
|
||||
assert.Contains(t, r1.Result.QueueUrls, fmt.Sprintf("%s/%s", fixtures.BASE_URL, "unit-queue1"))
|
||||
assert.Contains(t, r1.Result.QueueUrls, fmt.Sprintf("%s/%s", fixtures.BASE_URL, "unit-queue2"))
|
||||
assert.Contains(t, r1.Result.QueueUrls, fmt.Sprintf("%s/%s", fixtures.BASE_URL, "dead-letter-queue1"))
|
||||
}
|
||||
|
||||
func TestListQueuesV1_success_no_queues(t *testing.T) {
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
v := resultingStruct.(*models.ListQueueRequest)
|
||||
*v = models.ListQueueRequest{}
|
||||
return true
|
||||
}
|
||||
|
||||
_, r := test.GenerateRequestInfo("POST", "/", nil, true)
|
||||
code, response := ListQueuesV1(r)
|
||||
r1 := response.(models.ListQueuesResponse)
|
||||
|
||||
assert.Equal(t, http.StatusOK, code)
|
||||
assert.Equal(t, r1.Result.QueueUrls, []string{})
|
||||
}
|
||||
|
||||
func TestListQueuesV1_success_with_queue_name_prefix(t *testing.T) {
|
||||
conf.LoadYamlConfig("../conf/mock-data/mock-config.yaml", "BaseUnitTests")
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
v := resultingStruct.(*models.ListQueueRequest)
|
||||
*v = models.ListQueueRequest{QueueNamePrefix: "dead-letter"}
|
||||
return true
|
||||
}
|
||||
|
||||
_, r := test.GenerateRequestInfo("POST", "/", nil, true)
|
||||
code, response := ListQueuesV1(r)
|
||||
r1 := response.(models.ListQueuesResponse)
|
||||
|
||||
assert.Equal(t, http.StatusOK, code)
|
||||
assert.Equal(t, []string{fmt.Sprintf("%s/%s", fixtures.BASE_URL, "dead-letter-queue1")}, r1.Result.QueueUrls)
|
||||
}
|
||||
|
||||
func TestListQueuesV1_success_with_queue_name_prefix_no_matching_queues(t *testing.T) {
|
||||
conf.LoadYamlConfig("../conf/mock-data/mock-config.yaml", "BaseUnitTests")
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
v := resultingStruct.(*models.ListQueueRequest)
|
||||
*v = models.ListQueueRequest{QueueNamePrefix: "garbage"}
|
||||
return true
|
||||
}
|
||||
|
||||
_, r := test.GenerateRequestInfo("POST", "/", nil, true)
|
||||
code, response := ListQueuesV1(r)
|
||||
r1 := response.(models.ListQueuesResponse)
|
||||
|
||||
assert.Equal(t, http.StatusOK, code)
|
||||
assert.Equal(t, []string{}, r1.Result.QueueUrls)
|
||||
}
|
||||
|
||||
func TestListQueuesV1_request_transformer_error(t *testing.T) {
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
return false
|
||||
}
|
||||
|
||||
_, r := test.GenerateRequestInfo("POST", "/", nil, true)
|
||||
code, _ := ListQueuesV1(r)
|
||||
|
||||
assert.Equal(t, http.StatusBadRequest, code)
|
||||
}
|
||||
@@ -1,126 +0,0 @@
|
||||
package gosqs
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"net/http"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"shared-sqs/app/test"
|
||||
|
||||
"shared-sqs/app/conf"
|
||||
|
||||
"shared-sqs/app/fixtures"
|
||||
"shared-sqs/app/interfaces"
|
||||
"shared-sqs/app/models"
|
||||
"shared-sqs/app/utils"
|
||||
"github.com/stretchr/testify/assert"
|
||||
)
|
||||
|
||||
func TestPurgeQueueV1_success(t *testing.T) {
|
||||
conf.LoadYamlConfig("../conf/mock-data/mock-config.yaml", "BaseUnitTests")
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
v := resultingStruct.(*models.PurgeQueueRequest)
|
||||
*v = models.PurgeQueueRequest{
|
||||
QueueUrl: fmt.Sprintf("%s/%s", fixtures.BASE_URL, "unit-queue1"),
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// Put a message on the queue
|
||||
targetQueue := models.SyncQueues.Queues["unit-queue1"]
|
||||
models.SyncQueues.Lock()
|
||||
targetQueue.Messages = []models.SqsMessage{models.SqsMessage{}}
|
||||
targetQueue.Duplicates = map[string]time.Time{
|
||||
"dedupe-id": time.Now(),
|
||||
}
|
||||
models.SyncQueues.Unlock()
|
||||
|
||||
expectedResponse := models.PurgeQueueResponse{
|
||||
Xmlns: models.BaseXmlns,
|
||||
Metadata: models.BaseResponseMetadata,
|
||||
}
|
||||
|
||||
_, r := test.GenerateRequestInfo("POST", "/", nil, true)
|
||||
code, response := PurgeQueueV1(r)
|
||||
|
||||
assert.Equal(t, http.StatusOK, code)
|
||||
assert.Equal(t, expectedResponse, response)
|
||||
|
||||
assert.Nil(t, targetQueue.Messages)
|
||||
assert.Equal(t, map[string]time.Time{}, targetQueue.Duplicates)
|
||||
}
|
||||
|
||||
func TestPurgeQueueV1_success_no_messages_on_queue(t *testing.T) {
|
||||
conf.LoadYamlConfig("../conf/mock-data/mock-config.yaml", "BaseUnitTests")
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
v := resultingStruct.(*models.PurgeQueueRequest)
|
||||
*v = models.PurgeQueueRequest{
|
||||
QueueUrl: fmt.Sprintf("%s/%s", fixtures.BASE_URL, "unit-queue1"),
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
expectedResponse := models.PurgeQueueResponse{
|
||||
Xmlns: models.BaseXmlns,
|
||||
Metadata: models.BaseResponseMetadata,
|
||||
}
|
||||
|
||||
_, r := test.GenerateRequestInfo("POST", "/", nil, true)
|
||||
code, response := PurgeQueueV1(r)
|
||||
|
||||
assert.Equal(t, http.StatusOK, code)
|
||||
assert.Equal(t, expectedResponse, response)
|
||||
|
||||
targetQueue := models.SyncQueues.Queues["unit-queue1"]
|
||||
assert.Nil(t, targetQueue.Messages)
|
||||
assert.Equal(t, map[string]time.Time{}, targetQueue.Duplicates)
|
||||
}
|
||||
|
||||
func TestPurgeQueueV1_request_transformer_error(t *testing.T) {
|
||||
conf.LoadYamlConfig("../conf/mock-data/mock-config.yaml", "BaseUnitTests")
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
return false
|
||||
}
|
||||
|
||||
_, r := test.GenerateRequestInfo("POST", "/", nil, true)
|
||||
code, _ := PurgeQueueV1(r)
|
||||
|
||||
assert.Equal(t, http.StatusBadRequest, code)
|
||||
}
|
||||
|
||||
func TestPurgeQueueV1_requested_queue_does_not_exist(t *testing.T) {
|
||||
conf.LoadYamlConfig("../conf/mock-data/mock-config.yaml", "BaseUnitTests")
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
v := resultingStruct.(*models.PurgeQueueRequest)
|
||||
*v = models.PurgeQueueRequest{
|
||||
QueueUrl: fmt.Sprintf("%s/%s", fixtures.BASE_URL, "garbage"),
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
_, r := test.GenerateRequestInfo("POST", "/", nil, true)
|
||||
code, _ := PurgeQueueV1(r)
|
||||
|
||||
assert.Equal(t, http.StatusBadRequest, code)
|
||||
}
|
||||
@@ -1,123 +0,0 @@
|
||||
package gosqs
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"testing"
|
||||
|
||||
"github.com/stretchr/testify/assert"
|
||||
|
||||
"shared-sqs/app/models"
|
||||
)
|
||||
|
||||
func TestSetQueueAttributesV1_success_no_redrive_policy(t *testing.T) {
|
||||
var emptyQueue *models.Queue
|
||||
q := &models.Queue{}
|
||||
attrs := models.QueueAttributes{
|
||||
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 *models.Queue
|
||||
q := &models.Queue{}
|
||||
attrs := models.QueueAttributes{}
|
||||
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 *models.Queue
|
||||
q := &models.Queue{
|
||||
DelaySeconds: 1,
|
||||
MaximumMessageSize: 2,
|
||||
MessageRetentionPeriod: 3,
|
||||
ReceiveMessageWaitTimeSeconds: 4,
|
||||
VisibilityTimeout: 5,
|
||||
}
|
||||
attrs := models.QueueAttributes{}
|
||||
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() {
|
||||
models.ResetApp()
|
||||
}()
|
||||
|
||||
existingQueueName := "existing-queue"
|
||||
existingQueue := &models.Queue{Name: existingQueueName}
|
||||
models.SyncQueues.Queues[existingQueueName] = existingQueue
|
||||
|
||||
q := &models.Queue{}
|
||||
attrs := models.QueueAttributes{
|
||||
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.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 := &models.Queue{}
|
||||
attrs := models.QueueAttributes{
|
||||
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)
|
||||
}
|
||||
@@ -1,404 +0,0 @@
|
||||
package gosqs
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"sync"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"shared-sqs/app/test"
|
||||
|
||||
"shared-sqs/app/fixtures"
|
||||
"shared-sqs/app/models"
|
||||
"github.com/stretchr/testify/assert"
|
||||
)
|
||||
|
||||
// TODO Admiral-Piett - fix all these tests, we don't want to be waiting for 5 seconds plus like this.
|
||||
func TestReceiveMessageV1_with_WaitTimeEnforced(t *testing.T) {
|
||||
models.CurrentEnvironment = fixtures.LOCAL_ENVIRONMENT
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
}()
|
||||
|
||||
q := &models.Queue{
|
||||
Name: "waiting-queue",
|
||||
ReceiveMessageWaitTimeSeconds: 2,
|
||||
//MaximumMessageSize: 262144,
|
||||
}
|
||||
models.SyncQueues.Queues["waiting-queue"] = q
|
||||
|
||||
// receive message ensure delay
|
||||
_, r := test.GenerateRequestInfo("POST", "/", models.ReceiveMessageRequest{
|
||||
QueueUrl: "http://localhost:4100/queue/waiting-queue",
|
||||
}, true)
|
||||
|
||||
start := time.Now()
|
||||
status, response := ReceiveMessageV1(r)
|
||||
elapsed := time.Since(start)
|
||||
|
||||
assert.Equal(t, http.StatusOK, status)
|
||||
if elapsed < 2*time.Second {
|
||||
t.Fatalf("handler didn't wait ReceiveMessageWaitTimeSeconds %s", response)
|
||||
}
|
||||
|
||||
// mock sending a message
|
||||
q.Messages = append(q.Messages, models.SqsMessage{MessageBody: "1"})
|
||||
|
||||
// receive message
|
||||
_, r = test.GenerateRequestInfo("POST", "/", models.ReceiveMessageRequest{
|
||||
QueueUrl: "http://localhost:4100/queue/waiting-queue",
|
||||
}, true)
|
||||
start = time.Now()
|
||||
status, resp := ReceiveMessageV1(r)
|
||||
elapsed = time.Since(start)
|
||||
|
||||
assert.Equal(t, http.StatusOK, status)
|
||||
if elapsed > 1*time.Second {
|
||||
t.Fatal("handler waited when message was available, expected not to wait")
|
||||
}
|
||||
|
||||
assert.Equal(t, "1", string(resp.GetResult().(models.ReceiveMessageResult).Messages[0].Body))
|
||||
}
|
||||
|
||||
func TestReceiveMessageV1_CanceledByClient(t *testing.T) {
|
||||
// create a queue
|
||||
models.CurrentEnvironment = fixtures.LOCAL_ENVIRONMENT
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
}()
|
||||
|
||||
q := &models.Queue{
|
||||
Name: "cancel-queue",
|
||||
ReceiveMessageWaitTimeSeconds: 20,
|
||||
}
|
||||
models.SyncQueues.Queues["cancel-queue"] = q
|
||||
|
||||
var wg sync.WaitGroup
|
||||
ctx, cancelReceive := context.WithCancel(context.Background())
|
||||
|
||||
wg.Add(1)
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
// receive message (that will be canceled)
|
||||
_, r := test.GenerateRequestInfo("POST", "/", models.ReceiveMessageRequest{
|
||||
QueueUrl: "http://localhost:4100/queue/cancel-queue",
|
||||
}, true)
|
||||
r = r.WithContext(ctx)
|
||||
|
||||
status, resp := ReceiveMessageV1(r)
|
||||
assert.Equal(t, http.StatusOK, status)
|
||||
|
||||
if len(resp.GetResult().(models.ReceiveMessageResult).Messages) != 0 {
|
||||
t.Fatal("expecting this ReceiveMessage() to not pickup this message as it should canceled before the Send()")
|
||||
}
|
||||
}()
|
||||
time.Sleep(100 * time.Millisecond) // let enought time for the Receive go to wait mode
|
||||
cancelReceive() // cancel the first ReceiveMessage(), make sure it will not pickup the sent message below
|
||||
time.Sleep(5 * time.Millisecond)
|
||||
|
||||
// send a message
|
||||
_, r := test.GenerateRequestInfo("POST", "/", models.SendMessageRequest{
|
||||
QueueUrl: "http://localhost:4100/queue/cancel-queue",
|
||||
MessageBody: "12345",
|
||||
}, true)
|
||||
status, _ := SendMessageV1(r)
|
||||
if status != http.StatusOK {
|
||||
t.Errorf("handler returned wrong status code: got \n%v want %v", status, http.StatusOK)
|
||||
}
|
||||
|
||||
// receive message
|
||||
_, r = test.GenerateRequestInfo("POST", "/", models.ReceiveMessageRequest{
|
||||
QueueUrl: "http://localhost:4100/queue/cancel-queue",
|
||||
}, true)
|
||||
start := time.Now()
|
||||
status, resp := ReceiveMessageV1(r)
|
||||
assert.Equal(t, http.StatusOK, status)
|
||||
elapsed := time.Since(start)
|
||||
|
||||
result, ok := resp.GetResult().(models.ReceiveMessageResult)
|
||||
if !ok {
|
||||
t.Fatal("handler should return a message")
|
||||
}
|
||||
|
||||
if len(result.Messages) == 0 || string(result.Messages[0].Body) == "12345\n" {
|
||||
t.Fatal("handler should return a message")
|
||||
}
|
||||
if elapsed > 1*time.Second {
|
||||
t.Fatal("handler waited when message was available, expected not to wait")
|
||||
}
|
||||
|
||||
if timedout := waitTimeout(&wg, 2*time.Second); timedout {
|
||||
t.Errorf("expected ReceiveMessage() in goroutine to exit quickly due to cancelReceive() called")
|
||||
}
|
||||
}
|
||||
|
||||
func TestReceiveMessageV1_with_DelaySeconds(t *testing.T) {
|
||||
// create a queue
|
||||
models.CurrentEnvironment = fixtures.LOCAL_ENVIRONMENT
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
}()
|
||||
|
||||
q := &models.Queue{
|
||||
Name: "delay-seconds-queue",
|
||||
DelaySeconds: 2,
|
||||
}
|
||||
models.SyncQueues.Queues["delay-seconds-queue"] = q
|
||||
|
||||
// send a message
|
||||
_, r := test.GenerateRequestInfo("POST", "/", models.SendMessageRequest{
|
||||
QueueUrl: "http://localhost:4100/queue/delay-seconds-queue",
|
||||
MessageBody: "1",
|
||||
}, true)
|
||||
status, _ := SendMessageV1(r)
|
||||
if status != http.StatusOK {
|
||||
t.Errorf("handler returned wrong status code: got \n%v want %v", status, http.StatusOK)
|
||||
}
|
||||
|
||||
// receive message before delay is up
|
||||
_, r = test.GenerateRequestInfo("POST", "/", models.ReceiveMessageRequest{QueueUrl: "http://localhost:4100/queue/delay-seconds-queue"}, true)
|
||||
status, _ = ReceiveMessageV1(r)
|
||||
assert.Equal(t, http.StatusOK, status)
|
||||
|
||||
// receive message with wait should return after delay
|
||||
_, r = test.GenerateRequestInfo("POST", "/", models.ReceiveMessageRequest{
|
||||
QueueUrl: "http://localhost:4100/queue/delay-seconds-queue",
|
||||
WaitTimeSeconds: 10,
|
||||
}, true)
|
||||
start := time.Now()
|
||||
status, _ = ReceiveMessageV1(r)
|
||||
elapsed := time.Since(start)
|
||||
assert.Equal(t, http.StatusOK, status)
|
||||
if elapsed < 1*time.Second {
|
||||
t.Errorf("handler didn't wait at all")
|
||||
}
|
||||
if elapsed > 4*time.Second {
|
||||
t.Errorf("handler didn't need to wait all WaitTimeSeconds=10, only DelaySeconds=2")
|
||||
}
|
||||
}
|
||||
|
||||
func TestReceiveMessageV1_with_MessageAttributes(t *testing.T) {
|
||||
// create a queue
|
||||
models.CurrentEnvironment = fixtures.LOCAL_ENVIRONMENT
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
}()
|
||||
|
||||
q := &models.Queue{Name: "waiting-queue"}
|
||||
models.SyncQueues.Queues["waiting-queue"] = q
|
||||
|
||||
// send a message
|
||||
q.Messages = append(q.Messages, models.SqsMessage{
|
||||
MessageBody: "1",
|
||||
MessageAttributes: map[string]models.MessageAttribute{
|
||||
"TestMessageAttrName": {
|
||||
DataType: "String",
|
||||
StringValue: "TestMessageAttrValue",
|
||||
},
|
||||
},
|
||||
})
|
||||
|
||||
// receive message
|
||||
_, r := test.GenerateRequestInfo("POST", "/", models.ReceiveMessageRequest{QueueUrl: "http://localhost:4100/queue/waiting-queue"}, true)
|
||||
status, resp := ReceiveMessageV1(r)
|
||||
result := resp.GetResult().(models.ReceiveMessageResult)
|
||||
|
||||
assert.NotEmpty(t, result.Messages[0].Attributes["ApproximateFirstReceiveTimestamp"])
|
||||
assert.NotEmpty(t, result.Messages[0].Attributes["SenderId"])
|
||||
assert.NotEmpty(t, result.Messages[0].Attributes["ApproximateReceiveCount"])
|
||||
assert.NotEmpty(t, result.Messages[0].Attributes["SentTimestamp"])
|
||||
|
||||
assert.Equal(t, http.StatusOK, status)
|
||||
assert.Equal(t, "1", string(result.Messages[0].Body))
|
||||
assert.Equal(t, 1, len(result.Messages[0].MessageAttributes))
|
||||
assert.Equal(t, "String", result.Messages[0].MessageAttributes["TestMessageAttrName"].DataType)
|
||||
assert.Equal(t, "TestMessageAttrValue", result.Messages[0].MessageAttributes["TestMessageAttrName"].StringValue)
|
||||
}
|
||||
|
||||
func TestReceiveMessageV1_request_transformer_error(t *testing.T) {
|
||||
// TODO
|
||||
}
|
||||
|
||||
func TestReceiveMessageV1_with_CustomVisibilityTimeout(t *testing.T) {
|
||||
// create a queue
|
||||
models.CurrentEnvironment = fixtures.LOCAL_ENVIRONMENT
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
}()
|
||||
|
||||
// Create a queue with a default visibility timeout of 30 seconds
|
||||
q := &models.Queue{
|
||||
Name: "custom-visibility-queue",
|
||||
VisibilityTimeout: 30,
|
||||
}
|
||||
models.SyncQueues.Queues["custom-visibility-queue"] = q
|
||||
|
||||
// Add a message to the queue
|
||||
q.Messages = append(q.Messages, models.SqsMessage{
|
||||
MessageBody: "test-message",
|
||||
Uuid: "test-uuid",
|
||||
})
|
||||
|
||||
// Test 1: Receive message with custom visibility timeout
|
||||
customTimeout := 60 // 60 seconds
|
||||
_, r := test.GenerateRequestInfo("POST", "/", models.ReceiveMessageRequest{
|
||||
QueueUrl: "http://localhost:4100/queue/custom-visibility-queue",
|
||||
VisibilityTimeout: customTimeout,
|
||||
}, true)
|
||||
|
||||
status, resp := ReceiveMessageV1(r)
|
||||
assert.Equal(t, http.StatusOK, status)
|
||||
|
||||
result := resp.GetResult().(models.ReceiveMessageResult)
|
||||
assert.Equal(t, 1, len(result.Messages))
|
||||
assert.Equal(t, "test-message", string(result.Messages[0].Body))
|
||||
|
||||
// Verify the message in the queue has the custom visibility timeout
|
||||
// We can't directly check the exact time, but we can verify it's not using the queue's default
|
||||
// by checking that the visibility timeout is greater than now + default timeout - 1 second
|
||||
// and less than now + custom timeout + 1 second
|
||||
now := time.Now()
|
||||
defaultExpiry := now.Add(time.Duration(q.VisibilityTimeout) * time.Second)
|
||||
customExpiry := now.Add(time.Duration(customTimeout) * time.Second)
|
||||
|
||||
// The first message should have the custom visibility timeout
|
||||
msgVisibilityTimeout := q.Messages[0].VisibilityTimeout
|
||||
assert.True(t, msgVisibilityTimeout.After(defaultExpiry.Add(-1*time.Second)),
|
||||
"Message visibility timeout should be greater than default timeout")
|
||||
assert.True(t, msgVisibilityTimeout.Before(customExpiry.Add(1*time.Second)),
|
||||
"Message visibility timeout should be less than custom timeout + 1 second")
|
||||
|
||||
// Test 2: Reset the queue and test with zero visibility timeout (should use queue default)
|
||||
models.SyncQueues.Queues["custom-visibility-queue"] = &models.Queue{
|
||||
Name: "custom-visibility-queue",
|
||||
VisibilityTimeout: 30,
|
||||
}
|
||||
q = models.SyncQueues.Queues["custom-visibility-queue"]
|
||||
q.Messages = append(q.Messages, models.SqsMessage{
|
||||
MessageBody: "test-message-2",
|
||||
Uuid: "test-uuid-2",
|
||||
})
|
||||
|
||||
// Receive message with zero visibility timeout (should use queue default)
|
||||
_, r = test.GenerateRequestInfo("POST", "/", models.ReceiveMessageRequest{
|
||||
QueueUrl: "http://localhost:4100/queue/custom-visibility-queue",
|
||||
VisibilityTimeout: 0, // Zero should use queue default
|
||||
}, true)
|
||||
|
||||
status, resp = ReceiveMessageV1(r)
|
||||
assert.Equal(t, http.StatusOK, status)
|
||||
|
||||
// Verify the message in the queue has the default visibility timeout
|
||||
now = time.Now()
|
||||
defaultExpiry = now.Add(time.Duration(q.VisibilityTimeout) * time.Second)
|
||||
|
||||
// The message should have the default visibility timeout
|
||||
msgVisibilityTimeout = q.Messages[0].VisibilityTimeout
|
||||
assert.True(t, msgVisibilityTimeout.After(defaultExpiry.Add(-1*time.Second)),
|
||||
"Message visibility timeout should be greater than default timeout - 1 second")
|
||||
assert.True(t, msgVisibilityTimeout.Before(defaultExpiry.Add(1*time.Second)),
|
||||
"Message visibility timeout should be less than default timeout + 1 second")
|
||||
}
|
||||
|
||||
func TestReceiveMessageV1_FIFOSecondMessageAvailableAfterDelete(t *testing.T) {
|
||||
models.CurrentEnvironment = fixtures.LOCAL_ENVIRONMENT
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
}()
|
||||
|
||||
queueName := "fifo-delay-queue"
|
||||
queueURL := fmt.Sprintf("http://localhost:4100/queue/%s", queueName)
|
||||
now := time.Now().Add(-1 * time.Minute)
|
||||
|
||||
// create a queue with a visibility timeout of 10 seconds
|
||||
q := &models.Queue{
|
||||
Name: queueName,
|
||||
VisibilityTimeout: 10,
|
||||
IsFIFO: true,
|
||||
FIFOMessages: map[string]int{},
|
||||
FIFOSequenceNumbers: map[string]int{},
|
||||
Duplicates: map[string]time.Time{},
|
||||
Messages: []models.SqsMessage{
|
||||
{
|
||||
MessageBody: "first",
|
||||
Uuid: "first-uuid",
|
||||
GroupID: "company#worker",
|
||||
SentTime: now,
|
||||
},
|
||||
{
|
||||
MessageBody: "second",
|
||||
Uuid: "second-uuid",
|
||||
GroupID: "company#worker",
|
||||
SentTime: now,
|
||||
},
|
||||
},
|
||||
}
|
||||
models.SyncQueues.Queues[queueName] = q
|
||||
|
||||
// receive the first FIFO message only
|
||||
_, r := test.GenerateRequestInfo("POST", "/", models.ReceiveMessageRequest{
|
||||
QueueUrl: queueURL,
|
||||
MaxNumberOfMessages: 1,
|
||||
}, true)
|
||||
status, resp := ReceiveMessageV1(r)
|
||||
assert.Equal(t, http.StatusOK, status)
|
||||
result := resp.GetResult().(models.ReceiveMessageResult)
|
||||
if len(result.Messages) != 1 {
|
||||
t.Fatalf("expected to receive the first FIFO message, got %d", len(result.Messages))
|
||||
}
|
||||
assert.Equal(t, "first", result.Messages[0].Body)
|
||||
|
||||
firstReceipt := result.Messages[0].ReceiptHandle
|
||||
|
||||
// verify the second FIFO message is blocked while the first is in flight
|
||||
_, r = test.GenerateRequestInfo("POST", "/", models.ReceiveMessageRequest{
|
||||
QueueUrl: queueURL,
|
||||
}, true)
|
||||
status, resp = ReceiveMessageV1(r)
|
||||
assert.Equal(t, http.StatusOK, status)
|
||||
result = resp.GetResult().(models.ReceiveMessageResult)
|
||||
if len(result.Messages) != 0 {
|
||||
t.Fatalf("expected no FIFO message while the first is outstanding, got %d", len(result.Messages))
|
||||
}
|
||||
|
||||
// delete the first FIFO message
|
||||
_, deleteReq := test.GenerateRequestInfo("POST", "/", models.DeleteMessageRequest{
|
||||
QueueUrl: queueURL,
|
||||
ReceiptHandle: firstReceipt,
|
||||
}, true)
|
||||
deleteStatus, _ := DeleteMessageV1(deleteReq)
|
||||
assert.Equal(t, http.StatusOK, deleteStatus)
|
||||
|
||||
// receive the second FIFO message and ensure it does not wait for full 10 second visibility timeout
|
||||
_, r = test.GenerateRequestInfo("POST", "/", models.ReceiveMessageRequest{
|
||||
QueueUrl: queueURL,
|
||||
}, true)
|
||||
start := time.Now()
|
||||
status, resp = ReceiveMessageV1(r)
|
||||
elapsed := time.Since(start)
|
||||
assert.Equal(t, http.StatusOK, status)
|
||||
result = resp.GetResult().(models.ReceiveMessageResult)
|
||||
if len(result.Messages) != 1 {
|
||||
t.Fatalf("expected second FIFO message to be available immediately, got %d", len(result.Messages))
|
||||
}
|
||||
if elapsed > time.Second {
|
||||
t.Fatalf("expected second FIFO message without waiting on visibility timeout, took %s", elapsed)
|
||||
}
|
||||
assert.Equal(t, "second", result.Messages[0].Body)
|
||||
|
||||
// delete the second FIFO message
|
||||
_, deleteReq = test.GenerateRequestInfo("POST", "/", models.DeleteMessageRequest{
|
||||
QueueUrl: queueURL,
|
||||
ReceiptHandle: result.Messages[0].ReceiptHandle,
|
||||
}, true)
|
||||
deleteStatus, _ = DeleteMessageV1(deleteReq)
|
||||
assert.Equal(t, http.StatusOK, deleteStatus)
|
||||
|
||||
if len(q.Messages) != 0 {
|
||||
t.Fatalf("expected all FIFO messages to be deleted, remaining %d", len(q.Messages))
|
||||
}
|
||||
}
|
||||
|
||||
// TODO - other tests
|
||||
@@ -1,346 +0,0 @@
|
||||
package gosqs
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"net/http"
|
||||
"testing"
|
||||
|
||||
"shared-sqs/app/conf"
|
||||
"shared-sqs/app/fixtures"
|
||||
"shared-sqs/app/interfaces"
|
||||
"shared-sqs/app/models"
|
||||
"shared-sqs/app/test"
|
||||
"shared-sqs/app/utils"
|
||||
"github.com/stretchr/testify/assert"
|
||||
)
|
||||
|
||||
func TestSendMessageBatchV1_Success(t *testing.T) {
|
||||
conf.LoadYamlConfig("../conf/mock-data/mock-config.yaml", "BaseUnitTests")
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
sendMessageRequest_success := models.SendMessageBatchRequest{
|
||||
Entries: []models.SendMessageBatchRequestEntry{
|
||||
{
|
||||
Id: "test-msg-with-non-attribute",
|
||||
MessageBody: "test%20message%20body%201",
|
||||
},
|
||||
{
|
||||
Id: "test-msg-with-single-attirbute",
|
||||
MessageBody: "test%20message%20body%202",
|
||||
MessageAttributes: map[string]models.MessageAttribute{
|
||||
"my-attribute-name": {
|
||||
DataType: "String",
|
||||
StringValue: "my-attribute-string-value",
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
Id: "test-msg-with-multi-attirbute",
|
||||
MessageBody: "test%20message%20body%203",
|
||||
MessageAttributes: map[string]models.MessageAttribute{
|
||||
"my-attribute-name-1": {
|
||||
BinaryValue: "binary-value-1",
|
||||
DataType: "Binary",
|
||||
},
|
||||
"my-attribute-name-2": {
|
||||
DataType: "String",
|
||||
StringValue: "my-attribute-string-value-2",
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
QueueUrl: fmt.Sprintf("%s/%s", fixtures.BASE_URL, "unit-queue1"),
|
||||
}
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
v := resultingStruct.(*models.SendMessageBatchRequest)
|
||||
*v = sendMessageRequest_success
|
||||
return true
|
||||
}
|
||||
|
||||
_, r := test.GenerateRequestInfo("POST", "/", nil, true)
|
||||
status, response := SendMessageBatchV1(r)
|
||||
sendMessageBatchResponse, ok := response.(models.SendMessageBatchResponse)
|
||||
|
||||
assert.Equal(t, http.StatusOK, status)
|
||||
assert.True(t, ok)
|
||||
|
||||
resultEntry := sendMessageBatchResponse.Result.Entry
|
||||
assert.Equal(t, 3, len(resultEntry))
|
||||
assert.Contains(t, resultEntry[0].Id, "test-msg-with-non-attribute")
|
||||
assert.Contains(t, resultEntry[1].Id, "test-msg-with-single-attirbute")
|
||||
assert.Contains(t, resultEntry[2].Id, "test-msg-with-multi-attirbute")
|
||||
assert.Empty(t, resultEntry[0].SequenceNumber)
|
||||
assert.Empty(t, resultEntry[1].SequenceNumber)
|
||||
assert.Empty(t, resultEntry[2].SequenceNumber)
|
||||
|
||||
}
|
||||
|
||||
func TestSendMessageBatchV1_Success_Fifo_Queue(t *testing.T) {
|
||||
conf.LoadYamlConfig("../conf/mock-data/mock-config.yaml", "BaseUnitTests")
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
sendMessageRequest_success := models.SendMessageBatchRequest{
|
||||
Entries: []models.SendMessageBatchRequestEntry{
|
||||
{
|
||||
Id: "test_msg_001",
|
||||
MessageBody: "test%20message%20body%201",
|
||||
},
|
||||
{
|
||||
Id: "test_msg_002",
|
||||
MessageBody: "test%20message%20body%202",
|
||||
},
|
||||
{
|
||||
Id: "test_msg_003",
|
||||
MessageBody: "test%20message%20body%203",
|
||||
},
|
||||
},
|
||||
QueueUrl: fmt.Sprintf("%s/%s", fixtures.BASE_URL, "fifo-queue-1"),
|
||||
}
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
v := resultingStruct.(*models.SendMessageBatchRequest)
|
||||
*v = sendMessageRequest_success
|
||||
return true
|
||||
}
|
||||
|
||||
q := &models.Queue{
|
||||
Name: "fifo-queue-1",
|
||||
MaximumMessageSize: 1024,
|
||||
IsFIFO: true,
|
||||
}
|
||||
models.SyncQueues.Queues["fifo-queue-1"] = q
|
||||
|
||||
_, r := test.GenerateRequestInfo("POST", "/", nil, true)
|
||||
status, response := SendMessageBatchV1(r)
|
||||
sendMessageBatchResponse, ok := response.(models.SendMessageBatchResponse)
|
||||
|
||||
assert.Equal(t, http.StatusOK, status)
|
||||
assert.True(t, ok)
|
||||
|
||||
resultEntry := sendMessageBatchResponse.Result.Entry
|
||||
assert.Equal(t, 3, len(resultEntry))
|
||||
assert.Contains(t, resultEntry[0].Id, "test_msg_001")
|
||||
assert.NotEmpty(t, resultEntry[0].SequenceNumber)
|
||||
assert.Contains(t, resultEntry[1].Id, "test_msg_002")
|
||||
assert.NotEmpty(t, resultEntry[1].SequenceNumber)
|
||||
assert.Contains(t, resultEntry[2].Id, "test_msg_003")
|
||||
assert.NotEmpty(t, resultEntry[2].SequenceNumber)
|
||||
}
|
||||
|
||||
func TestSendMessageBatchV1_Error_QueueNotFound(t *testing.T) {
|
||||
conf.LoadYamlConfig("../conf/mock-data/mock-config.yaml", "BaseUnitTests")
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
sendMessageRequest_not_found_queue := models.SendMessageBatchRequest{
|
||||
Entries: []models.SendMessageBatchRequestEntry{
|
||||
{
|
||||
Id: "test_msg_001",
|
||||
MessageBody: "test%20message%20body%201",
|
||||
},
|
||||
{
|
||||
Id: "test_msg_002",
|
||||
MessageBody: "test%20message%20body%202",
|
||||
},
|
||||
{
|
||||
Id: "test_msg_003",
|
||||
MessageBody: "test%20message%20body%203",
|
||||
},
|
||||
},
|
||||
QueueUrl: fmt.Sprintf("%s/%s", fixtures.BASE_URL, "not-exist-queue1"),
|
||||
}
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
v := resultingStruct.(*models.SendMessageBatchRequest)
|
||||
*v = sendMessageRequest_not_found_queue
|
||||
return true
|
||||
}
|
||||
|
||||
expected := models.ErrorResult{
|
||||
Type: "Not Found",
|
||||
Code: "AWS.SimpleQueueService.NonExistentQueue",
|
||||
Message: "The specified queue does not exist for this wsdl version.",
|
||||
}
|
||||
|
||||
_, r := test.GenerateRequestInfo("POST", "/", nil, true)
|
||||
status, response := SendMessageBatchV1(r)
|
||||
errorResult := response.GetResult().(models.ErrorResult)
|
||||
|
||||
assert.Equal(t, http.StatusBadRequest, status)
|
||||
assert.Equal(t, expected, errorResult)
|
||||
}
|
||||
|
||||
func TestSendMessageBatchV1_Error_NoEntry(t *testing.T) {
|
||||
conf.LoadYamlConfig("../conf/mock-data/mock-config.yaml", "BaseUnitTests")
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
sendMessageRequest_no_entry := models.SendMessageBatchRequest{
|
||||
QueueUrl: fmt.Sprintf("%s/%s", fixtures.BASE_URL, "unit-queue1"),
|
||||
}
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
v := resultingStruct.(*models.SendMessageBatchRequest)
|
||||
*v = sendMessageRequest_no_entry
|
||||
return true
|
||||
}
|
||||
|
||||
expected := models.ErrorResult{
|
||||
Type: "EmptyBatchRequest",
|
||||
Code: "AWS.SimpleQueueService.EmptyBatchRequest",
|
||||
Message: "The batch request doesn't contain any entries.",
|
||||
}
|
||||
|
||||
_, r := test.GenerateRequestInfo("POST", "/", nil, true)
|
||||
status, response := SendMessageBatchV1(r)
|
||||
errorResult := response.GetResult().(models.ErrorResult)
|
||||
|
||||
assert.Equal(t, http.StatusBadRequest, status)
|
||||
assert.Equal(t, expected, errorResult)
|
||||
}
|
||||
|
||||
func TestSendMessageBatchV1_Error_IdNotDistinct(t *testing.T) {
|
||||
conf.LoadYamlConfig("../conf/mock-data/mock-config.yaml", "BaseUnitTests")
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
sendMessageRequest_no_entry := models.SendMessageBatchRequest{
|
||||
Entries: []models.SendMessageBatchRequestEntry{
|
||||
{
|
||||
Id: "test_msg_001",
|
||||
MessageBody: "test%20message%20body%201",
|
||||
},
|
||||
{
|
||||
Id: "test_msg_001",
|
||||
MessageBody: "test%20message%20body%202",
|
||||
},
|
||||
{
|
||||
Id: "test_msg_001",
|
||||
MessageBody: "test%20message%20body%203",
|
||||
},
|
||||
},
|
||||
QueueUrl: fmt.Sprintf("%s/%s", fixtures.BASE_URL, "unit-queue1"),
|
||||
}
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
v := resultingStruct.(*models.SendMessageBatchRequest)
|
||||
*v = sendMessageRequest_no_entry
|
||||
return true
|
||||
}
|
||||
|
||||
expected := models.ErrorResult{
|
||||
Type: "BatchEntryIdsNotDistinct",
|
||||
Code: "AWS.SimpleQueueService.BatchEntryIdsNotDistinct",
|
||||
Message: "Two or more batch entries in the request have the same Id.",
|
||||
}
|
||||
|
||||
_, r := test.GenerateRequestInfo("POST", "/", nil, true)
|
||||
status, response := SendMessageBatchV1(r)
|
||||
errorResult := response.GetResult().(models.ErrorResult)
|
||||
|
||||
assert.Equal(t, http.StatusBadRequest, status)
|
||||
assert.Equal(t, expected, errorResult)
|
||||
}
|
||||
|
||||
func TestSendMessageBatchV1_Error_TooManyEntries(t *testing.T) {
|
||||
conf.LoadYamlConfig("../conf/mock-data/mock-config.yaml", "BaseUnitTests")
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
sendMessageRequest_success := models.SendMessageBatchRequest{
|
||||
Entries: []models.SendMessageBatchRequestEntry{
|
||||
{
|
||||
Id: "test_msg_001",
|
||||
MessageBody: "test%20message%20body%201",
|
||||
},
|
||||
{
|
||||
Id: "test_msg_002",
|
||||
MessageBody: "test%20message%20body%202",
|
||||
},
|
||||
{
|
||||
Id: "test_msg_003",
|
||||
MessageBody: "test%20message%20body%203",
|
||||
},
|
||||
{
|
||||
Id: "test_msg_004",
|
||||
MessageBody: "test%20message%20body%204",
|
||||
},
|
||||
{
|
||||
Id: "test_msg_005",
|
||||
MessageBody: "test%20message%20body%205",
|
||||
},
|
||||
{
|
||||
Id: "test_msg_006",
|
||||
MessageBody: "test%20message%20body%206",
|
||||
},
|
||||
{
|
||||
Id: "test_msg_007",
|
||||
MessageBody: "test%20message%20body%207",
|
||||
},
|
||||
{
|
||||
Id: "test_msg_008",
|
||||
MessageBody: "test%20message%20body%208",
|
||||
},
|
||||
{
|
||||
Id: "test_msg_009",
|
||||
MessageBody: "test%20message%20body%209",
|
||||
},
|
||||
{
|
||||
Id: "test_msg_010",
|
||||
MessageBody: "test%20message%20body%210",
|
||||
},
|
||||
{
|
||||
Id: "test_msg_011",
|
||||
MessageBody: "test%20message%20body%211",
|
||||
},
|
||||
},
|
||||
QueueUrl: fmt.Sprintf("%s/%s", fixtures.BASE_URL, "unit-queue1"),
|
||||
}
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
v := resultingStruct.(*models.SendMessageBatchRequest)
|
||||
*v = sendMessageRequest_success
|
||||
return true
|
||||
}
|
||||
|
||||
expected := models.ErrorResult{
|
||||
Type: "TooManyEntriesInBatchRequest",
|
||||
Code: "AWS.SimpleQueueService.TooManyEntriesInBatchRequest",
|
||||
Message: "Maximum number of entries per request are 10.",
|
||||
}
|
||||
|
||||
_, r := test.GenerateRequestInfo("POST", "/", nil, true)
|
||||
status, response := SendMessageBatchV1(r)
|
||||
errorResult := response.GetResult().(models.ErrorResult)
|
||||
|
||||
assert.Equal(t, http.StatusBadRequest, status)
|
||||
assert.Equal(t, expected, errorResult)
|
||||
|
||||
}
|
||||
|
||||
func TestSendMessageBatchV1_Error_transformer(t *testing.T) {
|
||||
conf.LoadYamlConfig("../conf/mock-data/mock-config.yaml", "BaseUnitTests")
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
return false
|
||||
}
|
||||
|
||||
_, r := test.GenerateRequestInfo("POST", "/", nil, true)
|
||||
code, _ := SendMessageBatchV1(r)
|
||||
|
||||
assert.Equal(t, http.StatusBadRequest, code)
|
||||
|
||||
}
|
||||
@@ -1,220 +0,0 @@
|
||||
package gosqs
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"shared-sqs/app/test"
|
||||
|
||||
"shared-sqs/app/fixtures"
|
||||
"shared-sqs/app/interfaces"
|
||||
"shared-sqs/app/models"
|
||||
"shared-sqs/app/utils"
|
||||
"github.com/stretchr/testify/assert"
|
||||
)
|
||||
|
||||
func TestSendMessageV1_Success(t *testing.T) {
|
||||
models.CurrentEnvironment = fixtures.LOCAL_ENVIRONMENT
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
sendMessageRequest_success := models.SendMessageRequest{
|
||||
QueueUrl: "http://localhost:4200/new-queue-1",
|
||||
MessageBody: "Test Message",
|
||||
}
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
v := resultingStruct.(*models.SendMessageRequest)
|
||||
*v = sendMessageRequest_success
|
||||
return true
|
||||
}
|
||||
|
||||
q := &models.Queue{
|
||||
Name: "new-queue-1",
|
||||
MaximumMessageSize: 1024,
|
||||
}
|
||||
models.SyncQueues.Queues["new-queue-1"] = q
|
||||
|
||||
_, r := test.GenerateRequestInfo("POST", "/", nil, true)
|
||||
status, response := SendMessageV1(r)
|
||||
|
||||
// Check the queue
|
||||
assert.Equal(t, 1, len(q.Messages))
|
||||
msg := q.Messages[0]
|
||||
assert.Equal(t, "Test Message", string(msg.MessageBody))
|
||||
|
||||
// Check the response
|
||||
assert.Equal(t, http.StatusOK, status)
|
||||
sendMessageResponse, ok := response.(models.SendMessageResponse)
|
||||
assert.True(t, ok)
|
||||
assert.NotEmpty(t, sendMessageResponse.Result.MD5OfMessageBody)
|
||||
// No FIFO Sequence
|
||||
assert.Empty(t, sendMessageResponse.Result.SequenceNumber)
|
||||
}
|
||||
|
||||
func TestSendMessageV1_Success_FIFOQueue(t *testing.T) {
|
||||
models.CurrentEnvironment = fixtures.LOCAL_ENVIRONMENT
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
sendMessageRequest_success := models.SendMessageRequest{
|
||||
QueueUrl: "http://localhost:4200/new-queue-1",
|
||||
MessageBody: "Test Message",
|
||||
}
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
v := resultingStruct.(*models.SendMessageRequest)
|
||||
*v = sendMessageRequest_success
|
||||
return true
|
||||
}
|
||||
|
||||
q := &models.Queue{
|
||||
Name: "new-queue-1",
|
||||
MaximumMessageSize: 1024,
|
||||
IsFIFO: true,
|
||||
}
|
||||
models.SyncQueues.Queues["new-queue-1"] = q
|
||||
|
||||
_, r := test.GenerateRequestInfo("POST", "/", nil, true)
|
||||
status, response := SendMessageV1(r)
|
||||
|
||||
// Check the queue
|
||||
assert.Equal(t, 1, len(q.Messages))
|
||||
msg := q.Messages[0]
|
||||
assert.Equal(t, "Test Message", string(msg.MessageBody))
|
||||
|
||||
// Check the response
|
||||
assert.Equal(t, http.StatusOK, status)
|
||||
sendMessageResponse, ok := response.(models.SendMessageResponse)
|
||||
assert.True(t, ok)
|
||||
assert.NotEmpty(t, sendMessageResponse.Result.MD5OfMessageBody)
|
||||
// Should have FIFO Sequence
|
||||
assert.NotEmpty(t, sendMessageResponse.Result.SequenceNumber)
|
||||
}
|
||||
|
||||
func TestSendMessageV1_Success_Deduplication(t *testing.T) {
|
||||
models.CurrentEnvironment = fixtures.LOCAL_ENVIRONMENT
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
sendMessageRequest_success := models.SendMessageRequest{
|
||||
QueueUrl: "http://localhost:4200/new-queue-1",
|
||||
MessageBody: "Test Message",
|
||||
MessageDeduplicationId: "1",
|
||||
}
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
v := resultingStruct.(*models.SendMessageRequest)
|
||||
*v = sendMessageRequest_success
|
||||
return true
|
||||
}
|
||||
|
||||
q := &models.Queue{
|
||||
Name: "new-queue-1",
|
||||
MaximumMessageSize: 1024,
|
||||
IsFIFO: true,
|
||||
EnableDuplicates: true,
|
||||
Duplicates: make(map[string]time.Time),
|
||||
}
|
||||
models.SyncQueues.Queues["new-queue-1"] = q
|
||||
|
||||
_, r := test.GenerateRequestInfo("POST", "/", nil, true)
|
||||
status, _ := SendMessageV1(r)
|
||||
|
||||
// Check the queue
|
||||
assert.Equal(t, 1, len(q.Messages))
|
||||
// Check the response
|
||||
assert.Equal(t, http.StatusOK, status)
|
||||
|
||||
// Send the same message (have DeduplicationId)
|
||||
status, _ = SendMessageV1(r)
|
||||
// Response is "success"
|
||||
assert.Equal(t, http.StatusOK, status)
|
||||
// Only 1 message should be in the queue
|
||||
assert.Equal(t, 1, len(q.Messages))
|
||||
}
|
||||
|
||||
func TestSendMessageV1_request_transformer_error(t *testing.T) {
|
||||
models.CurrentEnvironment = fixtures.LOCAL_ENVIRONMENT
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
return false
|
||||
}
|
||||
|
||||
_, r := test.GenerateRequestInfo("POST", "/", nil, true)
|
||||
code, _ := SendMessageV1(r)
|
||||
|
||||
assert.Equal(t, http.StatusBadRequest, code)
|
||||
}
|
||||
|
||||
func TestSendMessageV1_MaximumMessageSize_MessageTooBig(t *testing.T) {
|
||||
models.CurrentEnvironment = fixtures.LOCAL_ENVIRONMENT
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
sendMessageRequest_success := models.SendMessageRequest{
|
||||
QueueUrl: "http://localhost:4200/new-queue-1",
|
||||
MessageBody: "Test Message",
|
||||
}
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
v := resultingStruct.(*models.SendMessageRequest)
|
||||
*v = sendMessageRequest_success
|
||||
return true
|
||||
}
|
||||
|
||||
q := &models.Queue{
|
||||
Name: "new-queue-1",
|
||||
MaximumMessageSize: 1,
|
||||
}
|
||||
models.SyncQueues.Queues["new-queue-1"] = q
|
||||
|
||||
_, r := test.GenerateRequestInfo("POST", "/", nil, true)
|
||||
status, response := SendMessageV1(r)
|
||||
|
||||
// Check the response
|
||||
assert.Equal(t, http.StatusBadRequest, status)
|
||||
errorResponse, ok := response.(models.ErrorResponse)
|
||||
assert.True(t, ok)
|
||||
assert.Equal(t, "MessageTooBig", errorResponse.Result.Type)
|
||||
}
|
||||
|
||||
func TestSendMessageV1_POST_QueueNonExistant(t *testing.T) {
|
||||
models.CurrentEnvironment = fixtures.LOCAL_ENVIRONMENT
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
sendMessageRequest_success := models.SendMessageRequest{
|
||||
QueueUrl: "http://localhost:4200/new-queue-1",
|
||||
MessageBody: "Test Message",
|
||||
}
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
v := resultingStruct.(*models.SendMessageRequest)
|
||||
*v = sendMessageRequest_success
|
||||
return true
|
||||
}
|
||||
|
||||
// No test queue is added to app.SyncQueues
|
||||
|
||||
_, r := test.GenerateRequestInfo("POST", "/", nil, true)
|
||||
status, response := SendMessageV1(r)
|
||||
|
||||
// Check the status code is what we expect.
|
||||
assert.Equal(t, http.StatusBadRequest, status)
|
||||
|
||||
// Check the response body is what we expect.
|
||||
errorResponse, ok := response.(models.ErrorResponse)
|
||||
assert.True(t, ok)
|
||||
assert.Equal(t, "Not Found", errorResponse.Result.Type)
|
||||
}
|
||||
@@ -1,169 +0,0 @@
|
||||
package gosqs
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"net/http"
|
||||
"testing"
|
||||
|
||||
"shared-sqs/app/test"
|
||||
|
||||
"shared-sqs/app/conf"
|
||||
"shared-sqs/app/fixtures"
|
||||
"shared-sqs/app/interfaces"
|
||||
"shared-sqs/app/models"
|
||||
"shared-sqs/app/utils"
|
||||
"github.com/stretchr/testify/assert"
|
||||
)
|
||||
|
||||
func TestSetQueueAttributesV1_success_multiple_attributes(t *testing.T) {
|
||||
conf.LoadYamlConfig("../conf/mock-data/mock-config.yaml", "BaseUnitTests")
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
v := resultingStruct.(*models.SetQueueAttributesRequest)
|
||||
*v = fixtures.SetQueueAttributesRequest
|
||||
return true
|
||||
}
|
||||
|
||||
_, r := test.GenerateRequestInfo("POST", "/", nil, true)
|
||||
code, response := SetQueueAttributesV1(r)
|
||||
|
||||
expectedResponse := models.SetQueueAttributesResponse{
|
||||
Xmlns: models.BaseXmlns,
|
||||
Metadata: models.BaseResponseMetadata,
|
||||
}
|
||||
assert.Equal(t, http.StatusOK, code)
|
||||
assert.Equal(t, expectedResponse, response)
|
||||
|
||||
actualQueue := models.SyncQueues.Queues["unit-queue1"]
|
||||
assert.Equal(t, 5, actualQueue.VisibilityTimeout)
|
||||
assert.Equal(t, 4, actualQueue.ReceiveMessageWaitTimeSeconds)
|
||||
assert.Equal(t, 1, actualQueue.DelaySeconds)
|
||||
assert.Equal(t, 2, actualQueue.MaximumMessageSize)
|
||||
assert.Equal(t, 3, actualQueue.MessageRetentionPeriod)
|
||||
}
|
||||
|
||||
func TestSetQueueAttributesV1_success_single_attribute(t *testing.T) {
|
||||
conf.LoadYamlConfig("../conf/mock-data/mock-config.yaml", "BaseUnitTests")
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
v := resultingStruct.(*models.SetQueueAttributesRequest)
|
||||
*v = models.SetQueueAttributesRequest{
|
||||
QueueUrl: fmt.Sprintf("%s/%s", fixtures.BASE_URL, "unit-queue1"),
|
||||
Attributes: models.QueueAttributes{
|
||||
VisibilityTimeout: 5,
|
||||
},
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
_, r := test.GenerateRequestInfo("POST", "/", nil, true)
|
||||
code, response := SetQueueAttributesV1(r)
|
||||
|
||||
expectedResponse := models.SetQueueAttributesResponse{
|
||||
Xmlns: models.BaseXmlns,
|
||||
Metadata: models.BaseResponseMetadata,
|
||||
}
|
||||
assert.Equal(t, http.StatusOK, code)
|
||||
assert.Equal(t, expectedResponse, response)
|
||||
|
||||
actualQueue := models.SyncQueues.Queues["unit-queue1"]
|
||||
assert.Equal(t, 5, actualQueue.VisibilityTimeout)
|
||||
assert.Equal(t, 0, actualQueue.ReceiveMessageWaitTimeSeconds)
|
||||
assert.Equal(t, 0, actualQueue.DelaySeconds)
|
||||
assert.Equal(t, 0, actualQueue.MaximumMessageSize)
|
||||
assert.Equal(t, 345600, actualQueue.MessageRetentionPeriod)
|
||||
}
|
||||
|
||||
func TestSetQueueAttributesV1_invalid_request_body(t *testing.T) {
|
||||
conf.LoadYamlConfig("../conf/mock-data/mock-config.yaml", "BaseUnitTests")
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
return false
|
||||
}
|
||||
|
||||
_, r := test.GenerateRequestInfo("POST", "/", nil, true)
|
||||
code, _ := SetQueueAttributesV1(r)
|
||||
|
||||
assert.Equal(t, http.StatusBadRequest, code)
|
||||
}
|
||||
|
||||
func TestSetQueueAttributesV1_missing_queue_url(t *testing.T) {
|
||||
conf.LoadYamlConfig("../conf/mock-data/mock-config.yaml", "BaseUnitTests")
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
v := resultingStruct.(*models.SetQueueAttributesRequest)
|
||||
*v = models.SetQueueAttributesRequest{
|
||||
Attributes: models.QueueAttributes{},
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
_, r := test.GenerateRequestInfo("POST", "/", nil, true)
|
||||
code, _ := SetQueueAttributesV1(r)
|
||||
|
||||
assert.Equal(t, http.StatusBadRequest, code)
|
||||
}
|
||||
|
||||
func TestSetQueueAttributesV1_missing_expected_queue(t *testing.T) {
|
||||
conf.LoadYamlConfig("../conf/mock-data/mock-config.yaml", "BaseUnitTests")
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
v := resultingStruct.(*models.SetQueueAttributesRequest)
|
||||
*v = models.SetQueueAttributesRequest{
|
||||
QueueUrl: "garbage",
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
_, r := test.GenerateRequestInfo("POST", "/", nil, true)
|
||||
code, _ := SetQueueAttributesV1(r)
|
||||
|
||||
assert.Equal(t, http.StatusBadRequest, code)
|
||||
}
|
||||
|
||||
func TestSetQueueAttributesV1_invalid_redrive_queue(t *testing.T) {
|
||||
conf.LoadYamlConfig("../conf/mock-data/mock-config.yaml", "BaseUnitTests")
|
||||
defer func() {
|
||||
models.ResetApp()
|
||||
utils.REQUEST_TRANSFORMER = utils.TransformRequest
|
||||
}()
|
||||
|
||||
utils.REQUEST_TRANSFORMER = func(resultingStruct interfaces.AbstractRequestBody, req *http.Request, emptyRequestValid bool) (success bool) {
|
||||
v := resultingStruct.(*models.SetQueueAttributesRequest)
|
||||
*v = models.SetQueueAttributesRequest{
|
||||
QueueUrl: fmt.Sprintf("%s/%s", fixtures.BASE_URL, "unit-queue1"),
|
||||
Attributes: models.QueueAttributes{
|
||||
RedrivePolicy: models.RedrivePolicy{
|
||||
MaxReceiveCount: 100,
|
||||
DeadLetterTargetArn: fmt.Sprintf("arn:aws:sqs:us-east-1:100010001000:%s", "garbage"),
|
||||
},
|
||||
},
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
_, r := test.GenerateRequestInfo("POST", "/", nil, true)
|
||||
code, _ := SetQueueAttributesV1(r)
|
||||
|
||||
assert.Equal(t, http.StatusBadRequest, code)
|
||||
}
|
||||
Reference in New Issue
Block a user