github.com/mundipagg/boleto-api@v0.0.0-20230620145841-3f9ec742599f/api/errors_test.go (about)

     1  package api
     2  
     3  import (
     4  	"bytes"
     5  	"net/http"
     6  	"net/http/httptest"
     7  	"testing"
     8  
     9  	"github.com/gin-gonic/gin"
    10  	"github.com/mundipagg/boleto-api/bank"
    11  	"github.com/mundipagg/boleto-api/models"
    12  	"github.com/mundipagg/boleto-api/test"
    13  	"github.com/stretchr/testify/assert"
    14  )
    15  
    16  var handleStoneErrorsParameters = []test.Parameter{
    17  	{Input: models.GetBoletoResponseError("srn:error:validation", "erro de validação"), Expected: http.StatusBadRequest},
    18  	{Input: models.GetBoletoResponseError("srn:error:unauthenticated", "erro de validação do token"), Expected: http.StatusInternalServerError},
    19  	{Input: models.GetBoletoResponseError("srn:error:unauthorized", "erro de clientId"), Expected: http.StatusBadGateway},
    20  	{Input: models.GetBoletoResponseError("srn:error:not_found", "recusro não encontrado"), Expected: http.StatusBadGateway},
    21  	{Input: models.GetBoletoResponseError("srn:error:conflict", "conflito"), Expected: http.StatusBadGateway},
    22  	{Input: models.GetBoletoResponseError("srn:error:product_not_enabled", "produto não disponível"), Expected: http.StatusBadRequest},
    23  	{Input: models.GetBoletoResponseError("unexpect_error", "erro inesperado"), Expected: http.StatusInternalServerError},
    24  }
    25  
    26  var handleInternalErrorsParameters = []test.Parameter{
    27  	{Input: models.GetBoletoResponseError("MP400", "falha de validação"), Expected: http.StatusBadRequest},
    28  	{Input: models.GetBoletoResponseError("MPAmountInCents", "valor invalido"), Expected: http.StatusBadRequest},
    29  	{Input: models.GetBoletoResponseError("MPExpireDate", "data de expiração invalida"), Expected: http.StatusBadRequest},
    30  	{Input: models.GetBoletoResponseError("MPBuyerDocumentType", "tipo de documento invalido"), Expected: http.StatusBadRequest},
    31  	{Input: models.GetBoletoResponseError("MPDocumentNumber", "documento invalido"), Expected: http.StatusBadRequest},
    32  	{Input: models.GetBoletoResponseError("MPRecipientDocumentType", "tipo de documento invalido"), Expected: http.StatusBadRequest},
    33  	{Input: models.GetBoletoResponseError("MPTimeout", "timeout"), Expected: http.StatusGatewayTimeout},
    34  	{Input: models.GetBoletoResponseError("MPOurNumberFail", "resposta sem nosso numero"), Expected: http.StatusBadGateway},
    35  }
    36  
    37  func Test_GetErrorCodeToLog_WhenHasError_ReturnErrorCode(t *testing.T) {
    38  	expectedErrorCode := "CODE"
    39  	c, _ := gin.CreateTestContext(httptest.NewRecorder())
    40  	err := models.GetBoletoResponseError(expectedErrorCode, "error")
    41  	c.Set(responseKey, err)
    42  
    43  	result := getErrorCodeToLog(c)
    44  
    45  	assert.Equal(t, expectedErrorCode, result)
    46  }
    47  
    48  func Test_GetErrorCodeToLog_WhitoutError_ReturnEmptyString(t *testing.T) {
    49  	expectedErrorCode := ""
    50  	c, _ := gin.CreateTestContext(httptest.NewRecorder())
    51  	c.Set(responseKey, models.BoletoResponse{})
    52  
    53  	result := getErrorCodeToLog(c)
    54  
    55  	assert.Equal(t, expectedErrorCode, result)
    56  }
    57  
    58  func Test_HandleErrors_WhenNotQualifiedForNewHandleError(t *testing.T) {
    59  	expectStatusCode := 200
    60  	c := arrangeContextWithBankAndResponse(models.BancoDoBrasil, models.BoletoResponse{})
    61  
    62  	handleErrors(c)
    63  
    64  	assert.Equal(t, expectStatusCode, c.Writer.Status())
    65  }
    66  
    67  func Test_HandleErrors_WhenStoneBankResponse(t *testing.T) {
    68  	for _, fact := range handleStoneErrorsParameters {
    69  		c := arrangeContextWithBankAndResponse(models.Stone, fact.Input.(models.BoletoResponse))
    70  		handleErrors(c)
    71  		assert.Equal(t, fact.Expected.(int), c.Writer.Status())
    72  	}
    73  }
    74  
    75  func Test_HandleErrors_WhenInternalErrorResponse(t *testing.T) {
    76  	for _, fact := range handleInternalErrorsParameters {
    77  		c := arrangeContextWithBankAndResponse(models.Stone, fact.Input.(models.BoletoResponse))
    78  		handleErrors(c)
    79  		assert.Equal(t, fact.Expected.(int), c.Writer.Status())
    80  	}
    81  }
    82  
    83  func arrangeContextWithBankAndResponse(bankNumber int, response models.BoletoResponse) *gin.Context {
    84  	c, _ := gin.CreateTestContext(httptest.NewRecorder())
    85  	b, _ := bank.Get(models.BoletoRequest{BankNumber: models.Stone})
    86  	c.Set(bankKey, b)
    87  	c.Set(responseKey, response)
    88  	return c
    89  }
    90  
    91  func Test_RotaRegisterV1_WhenPanicOccurred_RunsPanicRecovery(t *testing.T) {
    92  	router, w := arrangeMiddlewareRoute("/boleto/register", parseBoleto, registerBoletoLogger, errorResponseToClient, panicRecoveryHandler, mockPanicRegistration)
    93  	req, _ := http.NewRequest("POST", "/boleto/register", bytes.NewBuffer([]byte(mockPanicRegistrationRequestJSON)))
    94  
    95  	router.ServeHTTP(w, req)
    96  
    97  	assert.Equal(t, 500, w.Code)
    98  	assert.Equal(t, mockPanicRegistrationResponseJSON, w.Body.String())
    99  }
   100  
   101  func Test_RotaRegisterV2_WhenPanicOccurred_RunsPanicRecovery(t *testing.T) {
   102  	router, w := arrangeMiddlewareRoute("/boleto/register", parseBoleto, registerBoletoLogger, handleErrors, panicRecoveryHandler, mockPanicRegistration)
   103  	req, _ := http.NewRequest("POST", "/boleto/register", bytes.NewBuffer([]byte(mockPanicRegistrationRequestJSON)))
   104  
   105  	router.ServeHTTP(w, req)
   106  
   107  	assert.Equal(t, 500, w.Code)
   108  	assert.Equal(t, mockPanicRegistrationResponseJSON, w.Body.String())
   109  }
   110  
   111  func Test_QualifiedForNewErrorHandling_WhenBankStoneWithError_ReturnTrue(t *testing.T) {
   112  	request := models.BoletoRequest{BankNumber: models.Stone}
   113  	response := models.GetBoletoResponseError("MP000", "error")
   114  	bank, _ := bank.Get(request)
   115  
   116  	c, _ := gin.CreateTestContext(httptest.NewRecorder())
   117  	c.Set(boletoKey, request)
   118  	c.Set(bankKey, bank)
   119  
   120  	result := qualifiedForNewErrorHandling(c, response)
   121  
   122  	assert.True(t, result)
   123  }
   124  
   125  func Test_QualifiedForNewErrorHandling_WhenBankStoneWithoutError_ReturnFalse(t *testing.T) {
   126  	request := models.BoletoRequest{BankNumber: models.Stone}
   127  	response := models.BoletoResponse{}
   128  	bank, _ := bank.Get(request)
   129  
   130  	c, _ := gin.CreateTestContext(httptest.NewRecorder())
   131  	c.Set(boletoKey, request)
   132  	c.Set(bankKey, bank)
   133  
   134  	result := qualifiedForNewErrorHandling(c, response)
   135  
   136  	assert.False(t, result)
   137  }
   138  
   139  func Test_QualifiedForNewErrorHandling_WhenAnotherBankWithError_ReturnFalse(t *testing.T) {
   140  	request := models.BoletoRequest{BankNumber: models.Caixa}
   141  	response := models.GetBoletoResponseError("MP000", "error")
   142  	bank, _ := bank.Get(request)
   143  
   144  	c, _ := gin.CreateTestContext(httptest.NewRecorder())
   145  	c.Set(boletoKey, request)
   146  	c.Set(bankKey, bank)
   147  
   148  	result := qualifiedForNewErrorHandling(c, response)
   149  
   150  	assert.False(t, result)
   151  }
   152  
   153  func Test_QualifiedForNewErrorHandling_WhenAnotherBankWithoutError_ReturnFalse(t *testing.T) {
   154  	request := models.BoletoRequest{BankNumber: models.Caixa}
   155  	response := models.BoletoResponse{}
   156  	bank, _ := bank.Get(request)
   157  
   158  	c, _ := gin.CreateTestContext(httptest.NewRecorder())
   159  	c.Set(boletoKey, request)
   160  	c.Set(bankKey, bank)
   161  
   162  	result := qualifiedForNewErrorHandling(c, response)
   163  
   164  	assert.False(t, result)
   165  }