Atualiza README.md e ajusta testes (#48)

* refatora testes * atualiza README.md * adiciona badge no README.md * atualiza versão * corrige README.md
brenomfviana · Feb 3, 2024 · fdd1af6 · fdd1af6
1 parent dd027b9
commit fdd1af6
Show file tree

Hide file tree

Showing 7 changed files with 154 additions and 101 deletions.
diff --git a/README.md b/README.md
@@ -1,9 +1,62 @@
 # brado
-Bradova (BRAzilian DOcs validator) é um pacote Rust para validação de documentos brasileiros.
+<a href="https://crates.io/crates/brado">
+  <img src="https://img.shields.io/crates/v/brado.svg" alt="latest release" />
+</a>
+
+Brado (BRAzilian DOcs validator) é um pacote Rust para validação de documentos brasileiros.
 
 Este projeto é inspirado no [validate-docbr](https://github.com/alvarofpp/validate-docbr).
 
-# Contribuindo
+Para adicionar o pacote ao projeto:
+
+```bash
+cargo add brado
+```
+
+A documentação pode ser acessada [aqui](https://docs.rs/brado/) (ainda em desenvolvimento).
+
+
+## Testes
+
+Para rodar os testes, basta executar o comando a seguir:
+
+```
+make test
+```
+
+## Documentos
+
+- [x] CPF: Cadastro de Pessoas Físicas;
+- [x] CNH: Carteira Nacional de Habilitação;
+- [x] CNPJ: Cadastro Nacional da Pessoa Jurídica;
+- [ ] CNS: Cartão Nacional de Saúde;
+- [ ] PIS: PIS/NIS/PASEP/NIT;
+- [ ] Título eleitoral: Cadastro que permite cidadãos brasileiros votar;
+- [ ] RENAVAM: Registro Nacional de Veículos Automotores;
+- [ ] Certidão de Nascimento/Casamento/Óbito.
+
+
+## Funções
+
+Todos os documentos possuem as mesmas funções e funcionam da mesma forma.
+
+### validate
+
+```rust
+use brado;
+brado::cpf::validate("639.292.470-11"); // true
+brado::cpf::validate("639.292.470-10"); // false
+```
+
+### mask
+
+```rust
+use brado;
+brado::cpf::mask("63929247011"); // 639.292.470-11
+```
+
+
+# Como Contribuir
 
 1. Instalar nix (com flakes, ou seja, >2.4);
 2. Fazer um fork do projeto;
@@ -12,3 +65,4 @@ Este projeto é inspirado no [validate-docbr](https://github.com/alvarofpp/valid
 nix flake clone github:your-github-user/brado --dest ./brado \
 && cd brado 1>/dev/null 2>/dev/null \
 && direnv allow
+```
diff --git a/brado/Cargo.toml b/brado/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "brado"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 license = "MIT"
 readme = "../README.md"

diff --git a/brado/src/lib.rs b/brado/src/lib.rs
@@ -5,8 +5,7 @@
 //! ## Example
 //! ```
 //! use brado;
-//! let cpf_doc = String::from("639.292.470-11");
-//! brado::cpf::validate(&cpf_doc);
+//! brado::cpf::validate("639.292.470-11");
 //! ```
 pub mod cnh;
 pub mod cnpj;

diff --git a/brado/tests/cnh.rs b/brado/tests/cnh.rs
@@ -4,81 +4,81 @@ mod cnh_tests {
 
     #[test]
     fn cnh_validate_1_valid_bare_cnh() {
-        let bare_cnh: String = String::from("84718735264");
-        assert_eq!(true, brado::cnh::validate(&bare_cnh));
+        let bare_cnh: &str = "84718735264";
+        assert_eq!(true, brado::cnh::validate(bare_cnh));
     }
 
     #[test]
     fn cnh_validate_2_valid_masked_cnh() {
-        let masked_cnh: String = String::from("847 187 352 64");
-        assert_eq!(true, brado::cnh::validate(&masked_cnh));
+        let masked_cnh: &str = "847 187 352 64";
+        assert_eq!(true, brado::cnh::validate(masked_cnh));
     }
 
     #[test]
     fn cnh_validate_3_invalid_mask() {
-        let document = String::from("84 718 735 264");
-        assert_eq!(brado::cnh::validate(&document), false);
+        let document: &str = "84 718 735 264";
+        assert_eq!(brado::cnh::validate(document), false);
     }
 
     #[test]
     fn cnh_validate_4_invalid_other_document_1() {
-        let document = String::from("847187352");
-        assert_eq!(brado::cnh::validate(&document), false);
+        let document: &str = "847187352";
+        assert_eq!(brado::cnh::validate(document), false);
     }
 
     #[test]
     fn cnh_validate_5_invalid_other_document_2() {
-        let document = String::from("084 718 735 264");
-        assert_eq!(brado::cnh::validate(&document), false);
+        let document: &str = "084 718 735 264";
+        assert_eq!(brado::cnh::validate(document), false);
     }
 
     #[test]
     fn cnh_validate_6_invalid_other_document_3() {
-        let document = String::from("847 187 352 6:4");
-        assert_eq!(brado::cnh::validate(&document), false);
+        let document: &str = "847 187 352 6:4";
+        assert_eq!(brado::cnh::validate(document), false);
     }
 
     #[test]
     fn cnh_is_bare_1_bare_cnh() {
-        let bare_cnh = String::from("84718735264");
-        assert_eq!(brado::cnh::is_bare(&bare_cnh), true);
+        let bare_cnh: &str = "84718735264";
+        assert_eq!(brado::cnh::is_bare(bare_cnh), true);
     }
 
     #[test]
     fn cnh_is_bare_2_masked_cnh() {
-        let masked_cnh = String::from("847 187 352 64");
-        assert_eq!(brado::cnh::is_bare(&masked_cnh), false);
+        let masked_cnh: &str = "847 187 352 64";
+        assert_eq!(brado::cnh::is_bare(masked_cnh), false);
     }
 
     #[test]
     fn cnh_is_masked_1_masked_cnh() {
-        let masked_cnh = String::from("847 187 352 64");
-        assert_eq!(brado::cnh::is_masked(&masked_cnh), true);
+        let masked_cnh: &str = "847 187 352 64";
+        assert_eq!(brado::cnh::is_masked(masked_cnh), true);
     }
 
     #[test]
     fn cnh_is_masked_2_bare_cnh() {
-        let bare_cnh = String::from("84718735264");
-        assert_eq!(brado::cnh::is_masked(&bare_cnh), false);
+        let bare_cnh: &str = "84718735264";
+        assert_eq!(brado::cnh::is_masked(bare_cnh), false);
     }
 
     #[test]
     fn cnh_mask_1_bare_cnh() {
-        let bare_cnh = String::from("84718735264");
-        assert_eq!(brado::cnh::mask(&bare_cnh), String::from("847 187 352 64"),);
+        let bare_cnh: &str = "84718735264";
+        assert_eq!(brado::cnh::mask(bare_cnh), String::from("847 187 352 64"),);
     }
 
     #[test]
     #[should_panic(expected = "The given string cannot be masked as CNH")]
     fn cnh_mask_2_masked_cnh() {
-        let masked_cnh = String::from("847 187 352 64");
-        brado::cnh::mask(&masked_cnh);
+        let masked_cnh: &str = "847 187 352 64";
+        brado::cnh::mask(masked_cnh);
     }
 
     #[test]
     #[should_panic(expected = "The given string cannot be masked as CNH")]
     fn cnh_mask_3_invalid_cnh() {
-        let document = String::from("847187352");
-        brado::cnh::mask(&document);
+        let document: &str = "847187352";
+        brado::cnh::mask(document);
     }
 }
diff --git a/brado/tests/cnpj.rs b/brado/tests/cnpj.rs
@@ -4,84 +4,84 @@ mod cnpj_tests {
 
     #[test]
     fn cnpj_validate_1_valid_bare_cnpj() {
-        let bare_cnpj: String = String::from("05200851000100");
-        assert_eq!(true, brado::cnpj::validate(&bare_cnpj));
+        let bare_cnpj: &str = "05200851000100";
+        assert_eq!(true, brado::cnpj::validate(bare_cnpj));
     }
 
     #[test]
     fn cnpj_validate_2_valid_masked_cnpj() {
-        let masked_cnpj: String = String::from("05.200.851/0001-00");
-        assert_eq!(true, brado::cnpj::validate(&masked_cnpj));
+        let masked_cnpj: &str = "05.200.851/0001-00";
+        assert_eq!(true, brado::cnpj::validate(masked_cnpj));
     }
 
     #[test]
     fn cnpj_validate_3_invalid_mask() {
-        let document = String::from("0.520.085/1000-100");
-        assert_eq!(brado::cnpj::validate(&document), false);
+        let document: &str = "0.520.085/1000-100";
+        assert_eq!(brado::cnpj::validate(document), false);
     }
 
     #[test]
     fn cnpj_validate_4_invalid_other_document_1() {
-        let document = String::from("052008510001");
-        assert_eq!(brado::cnpj::validate(&document), false);
+        let document: &str = "052008510001";
+        assert_eq!(brado::cnpj::validate(document), false);
     }
 
     #[test]
     fn cnpj_validate_5_invalid_other_document_2() {
-        let document = String::from("00.520.085/1000-100");
-        assert_eq!(brado::cnpj::validate(&document), false);
+        let document: &str = "00.520.085/1000-100";
+        assert_eq!(brado::cnpj::validate(document), false);
     }
 
     #[test]
     fn cnpj_validate_6_invalid_other_document_3() {
-        let document = String::from("05.200.851/0001-0:0");
-        assert_eq!(brado::cnpj::validate(&document), false);
+        let document: &str = "05.200.851/0001-0:0";
+        assert_eq!(brado::cnpj::validate(document), false);
     }
 
     #[test]
     fn cnpj_is_bare_1_bare_cnpj() {
-        let bare_cnpj = String::from("05200851000100");
-        assert_eq!(brado::cnpj::is_bare(&bare_cnpj), true);
+        let bare_cnpj: &str = "05200851000100";
+        assert_eq!(brado::cnpj::is_bare(bare_cnpj), true);
     }
 
     #[test]
     fn cnpj_is_bare_2_masked_cnpj() {
-        let masked_cnpj = String::from("05.200.851/0001-00");
-        assert_eq!(brado::cnpj::is_bare(&masked_cnpj), false);
+        let masked_cnpj: &str = "05.200.851/0001-00";
+        assert_eq!(brado::cnpj::is_bare(masked_cnpj), false);
     }
 
     #[test]
     fn cnpj_is_masked_1_masked_cnpj() {
-        let masked_cnpj = String::from("05.200.851/0001-00");
-        assert_eq!(brado::cnpj::is_masked(&masked_cnpj), true);
+        let masked_cnpj: &str = "05.200.851/0001-00";
+        assert_eq!(brado::cnpj::is_masked(masked_cnpj), true);
     }
 
     #[test]
     fn cnpj_is_masked_2_bare_cnpj() {
-        let bare_cnpj = String::from("05200851000100");
-        assert_eq!(brado::cnpj::is_masked(&bare_cnpj), false);
+        let bare_cnpj: &str = "05200851000100";
+        assert_eq!(brado::cnpj::is_masked(bare_cnpj), false);
     }
 
     #[test]
     fn cnpj_mask_1_bare_cnpj() {
-        let bare_cnpj = String::from("05200851000100");
+        let bare_cnpj: &str = "05200851000100";
         assert_eq!(
-            brado::cnpj::mask(&bare_cnpj),
+            brado::cnpj::mask(bare_cnpj),
             String::from("05.200.851/0001-00"),
         );
     }
 
     #[test]
     #[should_panic(expected = "The given string cannot be masked as CNPJ")]
     fn cnpj_mask_2_masked_cnpj() {
-        let masked_cnpj = String::from("05.200.851/0001-00");
-        brado::cnpj::mask(&masked_cnpj);
+        let masked_cnpj: &str = "05.200.851/0001-00";
+        brado::cnpj::mask(masked_cnpj);
     }
 
     #[test]
     #[should_panic(expected = "The given string cannot be masked as CNPJ")]
     fn cnpj_mask_3_invalid_cnpj() {
-        let document = String::from("052008510001");
-        brado::cnpj::mask(&document);
+        let document: &str = "052008510001";
+        brado::cnpj::mask(document);
     }
 }