From d576b8292bfce765c89ebb896703e14a53cd60c1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Gabriel=20Brand=C3=A3o?= Date: Mon, 19 Dec 2022 12:31:14 -0300 Subject: [PATCH] feat: minLowercase validation strategy --- README.md | 20 +++++++- src/strategies/validation/min_lowercase.go | 14 ++++++ .../validation/min_lowercase_test.go | 49 +++++++++++++++++++ 3 files changed, 81 insertions(+), 2 deletions(-) create mode 100644 src/strategies/validation/min_lowercase.go create mode 100644 src/strategies/validation/min_lowercase_test.go diff --git a/README.md b/README.md index 81d80ba..18c80d0 100644 --- a/README.md +++ b/README.md @@ -96,11 +96,11 @@ A validação consiste em encontrar todos as ocorrências de um dígito numéric A expressão regular é: `\d` -### MinSpecialChars +### MinSpecialCharsValidationStrategy A lógica do `minSpecialChars` é a mesma do minDigit, mas a expressão regular é: `[!@#$%^&*()\-+\\\/{}\[\]]` -### NoRepeted +### NoRepetedValidationStrategy A regra `noRepeted` foge mais da lógica das outras regras. A solução que eu pensei foi a seguinte, comprimir todos os caracteres repetidos consecutivos da senha em um só e comparar o tamanho da senha comprimida com a senha original. @@ -124,3 +124,19 @@ Com o serviço de validação implementado, eu fiz a injeção no resolver e col Nesse ponto, todos os testes estavam passando (de integração e de unidade) e eu testei alguns casos manualmente pelo playground da aplicação e tudo funcionou. Até o momento apenas as regras **minSize**, **minDigit**, **minSpecialChars** e **noRepeted** haviam sido implementadas, mas a estrutura já estava preparada para receber as regras restantes facilmente. + +### Refatoração das regras com Regex + +Olhando as regras que ainda não estavam implementadas e comparando com as lógicas de validação de `minDigit` e `minSpecialChars`, eu percebi que elas teriam certo nível de duplicação e uma refatoração podia ser feita para todas as validações que usassem Regex. + +Então, antes de escrever mais testes e implementar as regras novas, eu resolvi refatorar as estratégias de Regex existentes para usar o mesmo código, mudando apenas a expressão regular. + +Criei uma struct base com a lógica de validação com base em uma expressão. Depois atualizei as estratégias `minSpecialChars` e `minDigit` para utilizar a implementação, cada uma passando sua própria expressão regular de validação. + +### MinUppercaseStrategy e MinLowercaseStrategy + +As duas estratégias restantes, *minUppercase* e *minLowerCase* se aproveitam da struct base de validação regex, porém cada uma com sua expressão: +- minUppercase: `[A-Z]` +- minLowercase: `[a-z]` + +Então, escrevi mais testes de integração que incluíssem essas regras, depois escrevi testes de unidade para implementar cada estratégia e finalizar as implementações das regras. \ No newline at end of file diff --git a/src/strategies/validation/min_lowercase.go b/src/strategies/validation/min_lowercase.go new file mode 100644 index 0000000..167b08c --- /dev/null +++ b/src/strategies/validation/min_lowercase.go @@ -0,0 +1,14 @@ +package validation + +import "regexp" + +type MinLowercaseValidationStrategy struct { + RegexValidation +} + +func NewMinLowercaseValidationStrategy() MinLowercaseValidationStrategy { + const MIN_LOWERCASE_REGEXP string = "[a-z]" + return MinLowercaseValidationStrategy{RegexValidation: RegexValidation{ + validationExpression: *regexp.MustCompile(MIN_LOWERCASE_REGEXP), + }} +} \ No newline at end of file diff --git a/src/strategies/validation/min_lowercase_test.go b/src/strategies/validation/min_lowercase_test.go new file mode 100644 index 0000000..ea3f6f7 --- /dev/null +++ b/src/strategies/validation/min_lowercase_test.go @@ -0,0 +1,49 @@ +package validation_test + +import ( + . "github.com/onsi/ginkgo/v2" + . "github.com/onsi/gomega" + + "github.com/brandaogabriel7/studio-sol-back-end-test/src/strategies/validation" +) + +var _ = Describe("MinLowercase", func() { + minLowercaseStrategy := validation.NewMinLowercaseValidationStrategy() + + Context("Check that the password follows minLowercase rule", func () { + DescribeTable("When password contains more lower case characters than minLowercase value", + func (password string, minLowercase int) { + isValid := minLowercaseStrategy.IsValid(password, minLowercase) + + Expect(isValid).To(BeTrue()) + }, + Entry("minLowercase 3", "senha123456", 3), + Entry("minLowercase 10", "minhasenhaaaa12", 10), + Entry("minLowercase 23", "eusouumasenhasuperforteesegura", 23), + ) + + DescribeTable("When password contains as many lower case characters as minLowercase value", + func (password string, minLowercase int) { + isValid := minLowercaseStrategy.IsValid(password, minLowercase) + + Expect(isValid).To(BeTrue()) + }, + Entry("minLowercase 5", "senha12345", 5), + Entry("minLowercase 10", "sseenhaaaa12345", 10), + Entry("minLowercase 18", "eusouumasupersenha", 18), + ) + }) + + Context("Check that the password does not follow minLowercase rule", func () { + DescribeTable("When password has less lower case characters than minLowercase value", + func (password string, minLowercase int) { + isValid := minLowercaseStrategy.IsValid(password, minLowercase) + + Expect(isValid).To(BeFalse()) + }, + Entry("minLowercase 5", "opa", 5), + Entry("minLowercase 10", "superSenha321", 10), + Entry("minLowercase 30", "SuperS3nh@Forte", 30), + ) + }) +})