Viktigheten av realistiske testdata og hvordan generere dem i Go
For å sikre at applikasjonene dine holder høy kvalitet og fungerer som forventet, er det essensielt å ha tilgang til pålitelige og realistiske testdata. Evnen til å produsere falske data som gjenspeiler reelle scenarioer, er en verdifull ferdighet i mange former for testing.
Selv om standardbiblioteket i Go ikke tilbyr funksjoner for generering av falske data, finnes det et bredt utvalg av tredjepartspakker i økosystemet. En populær løsning for dette formålet er Gofakeit.
Kom i gang med Gofakeit
Gofakeit er en pakke designet for å generere falske data i Go-prosjektene dine.
Denne pakken gir et bredt spekter av funksjoner, inkludert tilfeldig datagenerering for ulike datatyper. Den tilbyr også fleksible tilpasningsmuligheter for å overholde spesifikke formater, støtte for lokalisering, samt realistisk generering av dato- og tidsinformasjon.
For å inkludere Gofakeit som en tredjepartsavhengighet, kan du kjøre følgende kommando i prosjektmappen din etter å ha initialisert et nytt Go-prosjekt:
go get github.com/brianvoe/gofakeit/v6
Når Gofakeit er lagt til som en avhengighet, kan du importere pakken på denne måten:
import (
"github.com/brianvoe/gofakeit/v6"
)
Samlet sett tilbyr Gofakeit det meste av funksjonaliteten man kan forvente fra en pakke for falsk datagenerering.
Generering av grunnleggende falske data
Gofakeit har funksjoner for å lage forskjellige typer data, inkludert navn, e-postadresser, telefonnumre, slagord og mye mer.
Her er et eksempel på hvordan du kan generere grunnleggende falske data ved hjelp av 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)
}
`main`-funksjonen genererer diverse falske verdier ved hjelp av Gofakeit og viser dem i konsollen via `Println`-funksjonen fra `fmt`-pakken.
Gofakeit bruker struct-tagger for å generere falske data for ulike felt. Når du bruker disse struct-taggene, vil Gofakeit initialisere feltene med passende falske verdier.
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)
}
Feltene i `Person`-structen er alle annotert med «fake» struct-tagger. I `main`-funksjonen er `person`-variabelen en instans av `Person`-structen.
`Gofakeit.Struct`-metoden fyller ut eksponerte felt i en struct med tilfeldige data basert på verdien av den tilhørende «fake»-taggen. Til slutt skriver `main`-funksjonen ut verdiene til structens felter i konsollen.
Generering av kompleks falsk data
Du kan bruke Gofakeit til å lage komplekse falske data, inkludert tilfeldige setninger, avsnitt og lorem ipsum, ved hjelp av henholdsvis `Sentence`, `Paragraph` og `LoremIpsumParagraph`-funksjonene.
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())
}
`generateRandomSentence`-funksjonen genererer en tilfeldig setning ved hjelp av `Sentence`-funksjonen i Gofakeit. `generateRandomParagraph`-funksjonen genererer et tilfeldig avsnitt ved hjelp av `Paragraph`-funksjonen.
`generateLoremIpsum`-funksjonen genererer et tilfeldig lorem ipsum-avsnitt med `LoremIpsumParagraph`-funksjonen.
`main`-funksjonen kaller funksjonene `generateRandomSentence`, `generateRandomParagraph` og `generateLoremIpsum`. Programmet viser resultatet av disse funksjonene i konsollen.
Bruksområder for falske data: Testing av databaser
Gofakeit forenkler testing ved å generere data dynamisk, slik at du kan sjekke om applikasjonen din oppfyller ulike krav.
Du kan bruke Gos innebygde `database/sql`-pakke for å fylle SQL-databasen din med falske testdata. Dette kan hjelpe deg med å teste forskjellige grensetilfeller og øke databasens robusthet.
Ofte stilte spørsmål (FAQ)
Spørsmål: Hvordan kan jeg bruke disse falske testdataene?
Du bør skrive enhetstester og bruke falske testdata for å validere at små, uavhengige komponenter av programmet ditt fungerer som de skal.
Spørsmål: Hvilke andre testpakker tilbyr Go?
Go har en utmerket innebygd støtte for testing gjennom sin `testing`-pakke. Denne pakken gir deg mulighet til å benchmarke kode, bruke fuzzing for å variere testdataene dine, og strukturere testene dine hierarkisk.
Spørsmål: Hva er historien bak Lorem Ipsum?
Lorem ipsum er en vanlig type plassholdertekst som utviklere og designere ofte bruker i stedet for reell tekst. Det er nyttig fordi det ser ut som ekte tekst, men det oppfattes ikke som meningsfullt.