Como gerar dados de teste falsos com Go

Dados de teste confiáveis ​​e realistas são essenciais para garantir a qualidade e a funcionalidade dos seus aplicativos. A geração de dados falsos que imitam cenários do mundo real é uma habilidade útil para muitas formas de teste.

Não há suporte para geração de dados falsos na biblioteca padrão, mas existem muitos pacotes no ecossistema mais amplo do Go. Um pacote popular para geração de dados falsos é o Gofakeit.

Primeiros passos com Gofakeit

Gofakeit é um pacote para gerar dados falsos em seus programas Go.

Gofakeit oferece recursos abrangentes, incluindo geração aleatória de dados em vários tipos. Ele também oferece opções personalizáveis ​​para aderência a formatos específicos, suporte para localização e geração realista de data e hora.

Execute este comando no diretório de trabalho do seu projeto, depois de inicializar um novo projeto Go, para adicionar Gofakeit como uma dependência de terceiros:

 go get github.com/brianvoe/gofakeit/v6

Depois de adicionar Gofakeit como uma dependência, você pode importar o pacote assim:

 import (
    "github.com/brianvoe/gofakeit/v6"
)

No geral, Gofakeit fornece a maior parte da funcionalidade de um pacote de geração de dados falsos.

Gerando dados falsos básicos com Gofakeit

Gofakeit fornece funcionalidade para gerar diferentes tipos de dados, incluindo nomes, e-mails, telefones, frases comerciais, etc.

Veja como você pode gerar dados falsos básicos com Gofakeit:

 package main
import ( 
    "fmt"
    "github.com/brianvoe/gofakeit/v6"
)
func main() {
    
    name := gofakeit.Name()
    fmt.Println("Name:", name)
    
    email := gofakeit.Email()
    fmt.Println("Email:", email)
    
    phone := gofakeit.Phone()
    fmt.Println("Phone:", phone)
    
    company := gofakeit.Company()
    fmt.Println("Company:", company)
    
    creditCard := gofakeit.CreditCardNumber()
    fmt.Println("Credit Card:", creditCard)
    
    hackerPhrase := gofakeit.HackerPhrase()
    fmt.Println("Hacker Phrase:", hackerPhrase)
    
    jobTitle := gofakeit.JobTitle()
    fmt.Println("Job Title:", jobTitle)
    
    currency := gofakeit.CurrencyShort()
    fmt.Println("Currency:", currency)
}
 

A função principal gera vários valores falsos com Gofakeit e os imprime no console usando a função Println do pacote fmt.

Gofakeit fornece tags struct para gerar dados falsos para vários campos. Quando você usa essas tags struct, o Gofakeit inicializa seus campos com dados falsos.

 import (
    "fmt"
    "time"
    "github.com/brianvoe/gofakeit/v6"
)
type Person struct {
    ID string `fake:"{uuid}"`
    FirstName string `fake:"{firstname}"`
    LastName string `fake:"{lastname}"`
    Age int `fake:"{number:18,60}"`
    Email string `fake:"{email}"`
    Address string `fake:"{address}"`
    CreatedAt time.Time `fake:"{date}"`
}
func main() {
    var person Person
    gofakeit.Struct(&person)
    fmt.Printf("ID: %s\\n", person.ID)
    fmt.Printf("First Name: %s\\n", person.FirstName)
    fmt.Printf("Last Name: %s\\n", person.LastName)
    fmt.Printf("Age: %d\\n", person.Age)
    fmt.Printf("Email: %s\\n", person.Email)
    fmt.Printf("Address: %s\\n", person.Address)
    fmt.Printf("Created At: %s\\n", person.CreatedAt)
}
 

Todos os campos da estrutura Person possuem tags de estrutura falsas. Na função principal, a variável person é uma instância da estrutura Person.

O método gofakeit.Struct preenche os elementos exportados de uma estrutura com dados aleatórios com base no valor da tag falsa dos campos exportados. A função principal então imprime os campos struct no console.

Gerando dados falsos complexos

Você pode gerar dados falsos complexos com Gofakeit, incluindo frases aleatórias, parágrafos e lorem ipsum com as funções Sentença, Parágrafo e LoremIpsumParagraph, respectivamente.

 package main
import (
    "fmt"
    "github.com/brianvoe/gofakeit/v6"
)
func generateRandomSentence() string {
    
    sentence := gofakeit.Sentence(6)
    return sentence
}
func generateRandomParagraph() string {
    
    paragraph := gofakeit.Paragraph(3, 4, 8, "/n")
    return paragraph
}
func generateLoremIpsum() string {
    
    loremIpsum := gofakeit.LoremIpsumParagraph(3, 5, 12, "\\n")
    return loremIpsum
}
func main() {
    
    gofakeit.Seed(0)
    
    fmt.Println("Random Sentence:")
    fmt.Println(generateRandomSentence())
    
    fmt.Println("\\nRandom Paragraph:")
    fmt.Println(generateRandomParagraph())
    
    fmt.Println("\\nLorem Ipsum Text:")
    fmt.Println(generateLoremIpsum())
}
 

A função generateRandomSentence gera uma frase aleatória com a função Sentence do Gofakeit. A função generateRandomParagraph gera um parágrafo aleatório com a função Paragraph.

A função generateLoremIpsum gera um parágrafo lorem ipsum aleatório com a função LoremIpsumParagraph.

A função principal chama as funções generateRandomSentence, generateRandomParagraph e generateLoremIpsum. O programa imprime as saídas da função no console.

Você pode gerar dados falsos para testar seu banco de dados

Gofakeit simplifica os testes com geração dinâmica de dados para garantir compatibilidade com diversos requisitos.

Você pode usar o pacote banco de dados/sql integrado do Go para preencher seu banco de dados SQL com dados falsos para teste. Isso pode ajudá-lo a testar mais casos extremos e melhorar a segurança do banco de dados.

Perguntas frequentes

P: Como posso usar esses dados de teste falsos?

Você deve escrever testes de unidade e fornecer-lhes dados de teste falsos para verificar se pequenas partes combináveis ​​do seu programa funcionam corretamente.

P: Que outros pacotes de testes o Go oferece?

Go tem excelente suporte integrado por meio de seu pacote de testes. Com ele, você pode avaliar o código, usar fuzzing para variar seus dados de teste e estruturar seus testes em uma hierarquia.

P: Qual é a história por trás de Lorem Ipsum?

Lorem ipsum é um tipo comum de texto de espaço reservado que desenvolvedores e designers costumam usar no lugar de texto real. É útil porque é considerado falso, mas ainda se assemelha a um texto genuíno.