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

     1  package bradescoShopFacil
     2  
     3  import (
     4  	"fmt"
     5  	"github.com/mundipagg/boleto-api/models"
     6  	"github.com/mundipagg/boleto-api/test"
     7  	"github.com/mundipagg/boleto-api/validations"
     8  	"github.com/stretchr/testify/assert"
     9  	"testing"
    10  	"time"
    11  )
    12  
    13  var agencyNumberParameters = []test.Parameter{
    14  	{Input: "1", Expected: true},
    15  	{Input: "12", Expected: true},
    16  	{Input: "123", Expected: true},
    17  	{Input: "1234", Expected: true},
    18  	{Input: "123A", Expected: true},
    19  	{Input: "", Expected: false},
    20  	{Input: "  ", Expected: false},
    21  	{Input: "123456789", Expected: false},
    22  }
    23  
    24  var accountNumberParameters = []test.Parameter{
    25  	{Input: "1", Expected: true},
    26  	{Input: "12", Expected: true},
    27  	{Input: "123", Expected: true},
    28  	{Input: "1234", Expected: true},
    29  	{Input: "123A", Expected: true},
    30  	{Input: "123456789", Expected: true},
    31  	{Input: "  ", Expected: true},
    32  	{Input: "", Expected: false},
    33  }
    34  
    35  var walletParameters = []test.Parameter{
    36  	{Input: uint16(25), Expected: true},
    37  	{Input: uint16(26), Expected: true},
    38  	{Input: uint16(10), Expected: false},
    39  	{Input: uint16(20), Expected: false},
    40  	{Input: uint16(40), Expected: false},
    41  	{Input: uint16(50), Expected: false},
    42  }
    43  
    44  var authenticationParameters = []test.Parameter{
    45  	{Input: models.Authentication{Username: "Usuario", Password: "Senha"}, Expected: true},
    46  	{Input: models.Authentication{Username: "   ", Password: "Senha"}, Expected: false},
    47  	{Input: models.Authentication{Username: "", Password: "Senha"}, Expected: false},
    48  	{Input: models.Authentication{Username: "Usuario", Password: "   "}, Expected: false},
    49  	{Input: models.Authentication{Username: "Usuario", Password: ""}, Expected: false},
    50  	{Input: models.Authentication{Username: "", Password: ""}, Expected: false},
    51  }
    52  
    53  var agreementNumberParameters = []test.Parameter{
    54  	{Input: uint(1), Expected: true},
    55  	{Input: uint(4), Expected: true},
    56  	{Input: uint(0), Expected: false},
    57  }
    58  
    59  var boletoTypeKeyParameters = []test.Parameter{
    60  	{Input: models.Title{BoletoType: ""}, Expected: true},
    61  	{Input: models.Title{BoletoType: "DM"}, Expected: true},
    62  	{Input: models.Title{BoletoType: "NP"}, Expected: true},
    63  	{Input: models.Title{BoletoType: "RC"}, Expected: true},
    64  	{Input: models.Title{BoletoType: "DS"}, Expected: true},
    65  	{Input: models.Title{BoletoType: "OUT"}, Expected: true},
    66  	{Input: models.Title{BoletoType: "A"}, Expected: false},
    67  	{Input: models.Title{BoletoType: "ABC"}, Expected: false},
    68  }
    69  
    70  var expirationDateParameters = []test.Parameter{
    71  	{Input: "2025-01-01", Expected: true},
    72  	{Input: "2025-02-20", Expected: true},
    73  	{Input: "2025-02-21", Expected: true},
    74  	{Input: "2025-02-22", Expected: false},
    75  	{Input: "2025-12-31", Expected: false},
    76  }
    77  
    78  func Test_AgencyValidation_WhenTypeIsBoletoRequest(t *testing.T) {
    79  
    80  	for _, fact := range agencyNumberParameters {
    81  		request := newStubBoletoRequestBradescoShopFacil().WithAgreementAgency(fact.Input.(string)).Build()
    82  		result := bradescoShopFacilValidateAgency(request)
    83  		assert.Equal(t, fact.Expected, result == nil, fmt.Sprintf("O resultado: %d não condiz com o esperado: %d, utilizando o input: %d", result, fact.Expected, fact.Input))
    84  	}
    85  }
    86  
    87  func Test_AgencyValidation_WhenTypeIsInvalid(t *testing.T) {
    88  
    89  	request := "Não é um boleto request"
    90  	result := bradescoShopFacilValidateAgency(request)
    91  	assert.IsType(t, models.ErrorResponse{}, result, fmt.Sprintf("O tipo do resultado: %T não condiz com o tipo esperado: %T", result, models.ErrorResponse{}))
    92  }
    93  
    94  func Test_AccountValidation_WhenTypeIsBoletoRequest(t *testing.T) {
    95  
    96  	for _, fact := range accountNumberParameters {
    97  		request := newStubBoletoRequestBradescoShopFacil().WithAgreementAccount(fact.Input.(string)).Build()
    98  		result := bradescoShopFacilValidateAccount(request)
    99  		assert.Equal(t, fact.Expected, result == nil, fmt.Sprintf("O resultado: %d não condiz com o esperado: %d, utilizando o input: %d", result, fact.Expected, fact.Input))
   100  	}
   101  }
   102  
   103  func Test_AccountValidation_WhenTypeIsInvalid(t *testing.T) {
   104  
   105  	request := "Não é um boleto request"
   106  	result := bradescoShopFacilValidateAccount(request)
   107  	assert.IsType(t, models.ErrorResponse{}, result, fmt.Sprintf("O tipo do resultado: %T não condiz com o tipo esperado: %T", result, models.ErrorResponse{}))
   108  }
   109  
   110  func Test_WalletValidation_WhenTypeIsBoletoRequest(t *testing.T) {
   111  
   112  	for _, fact := range walletParameters {
   113  		request := newStubBoletoRequestBradescoShopFacil().WithWallet(fact.Input.(uint16)).Build()
   114  		result := bradescoShopFacilValidateWallet(request)
   115  		assert.Equal(t, fact.Expected, result == nil, fmt.Sprintf("O resultado: %d não condiz com o esperado: %d, utilizando o input: %d", result, fact.Expected, fact.Input))
   116  	}
   117  }
   118  
   119  func Test_WalletValidation_WhenTypeIsInvalid(t *testing.T) {
   120  
   121  	request := "Não é um boleto request"
   122  	result := bradescoShopFacilValidateWallet(request)
   123  	assert.IsType(t, models.ErrorResponse{}, result, fmt.Sprintf("O tipo do resultado: %T não condiz com o tipo esperado: %T", result, models.ErrorResponse{}))
   124  }
   125  
   126  func Test_AuthenticationValidation_WhenTypeIsBoletoRequest(t *testing.T) {
   127  	for _, fact := range authenticationParameters {
   128  		request := newStubBoletoRequestBradescoShopFacil().WithAuthentication(fact.Input.(models.Authentication)).Build()
   129  		result := bradescoShopFacilValidateAuth(request)
   130  		assert.Equal(t, fact.Expected, result == nil, fmt.Sprintf("O resultado: %d não condiz com o esperado: %d, utilizando o input: %d", result, fact.Expected, fact.Input))
   131  	}
   132  }
   133  
   134  func Test_AuthenticationValidation_WhenTypeIsInvalid(t *testing.T) {
   135  
   136  	request := "Não é um boleto request"
   137  	result := bradescoShopFacilValidateAuth(request)
   138  	assert.IsType(t, models.ErrorResponse{}, result, fmt.Sprintf("O tipo do resultado: %T não condiz com o tipo esperado: %T", result, models.ErrorResponse{}))
   139  }
   140  
   141  func Test_AgreementNumberValidation_WhenTypeIsBoletoRequest(t *testing.T) {
   142  	for _, fact := range agreementNumberParameters {
   143  		request := newStubBoletoRequestBradescoShopFacil().WithAgreementNumber(fact.Input.(uint)).Build()
   144  		result := bradescoShopFacilValidateAgreement(request)
   145  		assert.Equal(t, fact.Expected, result == nil, fmt.Sprintf("O resultado: %d não condiz com o esperado: %d, utilizando o input: %d", result, fact.Expected, fact.Input))
   146  	}
   147  }
   148  
   149  func Test_AgreementNumberValidation_WhenTypeIsInvalid(t *testing.T) {
   150  
   151  	request := "Não é um boleto request"
   152  	result := bradescoShopFacilValidateAgreement(request)
   153  	assert.IsType(t, models.ErrorResponse{}, result, fmt.Sprintf("O tipo do resultado: %T não condiz com o tipo esperado: %T", result, models.ErrorResponse{}))
   154  }
   155  
   156  func Test_BoletoTypeValidation_WhenTypeIsBoletoRequest(t *testing.T) {
   157  
   158  	for _, fact := range boletoTypeKeyParameters {
   159  		request := newStubBoletoRequestBradescoShopFacil().WithBoletoType(fact.Input.(models.Title)).Build()
   160  		result := bradescoShopFacilBoletoTypeValidate(request)
   161  		assert.Equal(t, fact.Expected, result == nil, fmt.Sprintf("O resultado: %d não condiz com o esperado: %d, utilizando o input: %d", result, fact.Expected, fact.Input))
   162  	}
   163  }
   164  
   165  func Test_BoletoTypeValidation_WhenTypeIsInvalid(t *testing.T) {
   166  
   167  	request := "Não é um boleto request"
   168  	result := bradescoShopFacilBoletoTypeValidate(request)
   169  	assert.IsType(t, models.ErrorResponse{}, result, fmt.Sprintf("O tipo do resultado: %T não condiz com o tipo esperado: %T", result, models.ErrorResponse{}))
   170  }
   171  
   172  func Test_MaxDateExpirationBlockValidation_WhenTypeIsBoletoRequest(t *testing.T) {
   173  
   174  	for _, fact := range expirationDateParameters {
   175  		expDate, _ := time.Parse("2006-01-02", fact.Input.(string))
   176  		request := newStubBoletoRequestBradescoShopFacil().WithExpirationDate(expDate).Build()
   177  		result := validations.ValidateMaxExpirationDate(request)
   178  		assert.Equal(t, fact.Expected, result == nil, fmt.Sprintf("O resultado: %d não condiz com o esperado: %d, utilizando o input: %d", result, fact.Expected, fact.Input))
   179  	}
   180  }
   181  
   182  func Test_MaxDateExpirationBlockValidation_WhenTypeIsInvalid(t *testing.T) {
   183  
   184  	request := "Não é um boleto request"
   185  	result := validations.ValidateMaxExpirationDate(request)
   186  	assert.IsType(t, models.ErrorResponse{}, result, fmt.Sprintf("O tipo do resultado: %T não condiz com o tipo esperado: %T", result, models.ErrorResponse{}))
   187  }