So generieren Sie gefälschte Testdaten mit Go

Zuverlässige und realistische Testdaten sind entscheidend für die Sicherstellung der Qualität und Funktionalität Ihrer Apps. Das Generieren gefälschter Daten, die reale Szenarien nachahmen, ist für viele Arten von Tests eine nützliche Fähigkeit.

In der Standardbibliothek gibt es keine Unterstützung für die Generierung gefälschter Daten, aber im weiteren Ökosystem von Go gibt es viele Pakete. Ein beliebtes Paket zur Generierung gefälschter Daten ist Gofakeit.

Erste Schritte mit Gofakeit

Gofakeit ist ein Paket zum Generieren gefälschter Daten in Ihren Go-Programmen.

Gofakeit bietet umfangreiche Funktionen, einschließlich der zufälligen Datengenerierung über verschiedene Typen hinweg. Es bietet außerdem anpassbare Optionen für die Einhaltung bestimmter Formate, Unterstützung für die Lokalisierung und realistische Darstellung Zeit- und Datumsgenerierung.

Führen Sie diesen Befehl im Arbeitsverzeichnis Ihres Projekts aus, nachdem Sie ein neues Go-Projekt initialisiert haben, um Gofakeit als Drittanbieter-Abhängigkeit hinzuzufügen:

go get github.com/brianvoe/gofakeit/v6

Nachdem Sie Gofakeit als Abhängigkeit hinzugefügt haben, können Sie das Paket folgendermaßen importieren:

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

Insgesamt bietet Gofakeit die meisten Funktionen eines Pakets zur Generierung gefälschter Daten.

Generieren grundlegender gefälschter Daten mit Gofakeit

Gofakeit bietet Funktionen zum Generieren verschiedener Arten von Daten, darunter Namen, E-Mails, Telefonnummern, Geschäftsphrasen usw.

So können Sie mit Gofakeit grundlegende Fake-Daten generieren:

package main
import ( 
"fmt"
"github.com/brianvoe/gofakeit/v6"
)
funcmain() {
// Generate a fake name
 name := gofakeit.Name()
 fmt.Println("Name:", name)
// Generate a fake email address
 email := gofakeit.Email()
 fmt.Println("Email:", email)
// Generate a fake phone number
 phone := gofakeit.Phone()
 fmt.Println("Phone:", phone)
// Generate a fake company name
 company := gofakeit.Company()
 fmt.Println("Company:", company)
// Generate a fake credit card number
 creditCard := gofakeit.CreditCardNumber()
 fmt.Println("Credit Card:", creditCard)
// Generate a fake hacker phrase
 hackerPhrase := gofakeit.HackerPhrase()
 fmt.Println("Hacker Phrase:", hackerPhrase)
// Generate a fake job title
 jobTitle := gofakeit.JobTitle()
 fmt.Println("Job Title:", jobTitle)
// Generate a fake currency abbreviation
 currency := gofakeit.CurrencyShort()
 fmt.Println("Currency:", currency)
}

Der hauptsächlich Die Funktion generiert mit Gofakeit mehrere gefälschte Werte und gibt sie mithilfe von auf der Konsole aus Druckenln Funktion aus dem fmt-Paket.

Gofakeit bietet Struktur-Tags zum Generieren gefälschter Daten für verschiedene Felder. Wenn Sie diese Struktur-Tags verwenden, initialisiert Gofakeit seine Felder mit gefälschten Daten.

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}"`
}
funcmain() {
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)
}

Die Felder der Person Struktur haben alle gefälscht Struktur-Tags. Im hauptsächlich Funktion, die Person Variable ist eine Instanz der Person-Struktur.

Der gofakeit. Struktur Die Methode füllt exportierte Elemente einer Struktur mit Zufallsdaten basierend auf dem Wert der gefälscht Tag der exportierten Felder. Der hauptsächlich Die Funktion gibt dann die Strukturfelder auf der Konsole aus.

Generierung komplexer gefälschter Daten

Mit Gofakeit können Sie komplexe gefälschte Daten generieren, einschließlich zufälliger Sätze, Absätze und Lorem Ipsum Satz, Absatz, Und LoremIpsumAbsatz Funktionen bzw.

package main
import (
"fmt"
"github.com/brianvoe/gofakeit/v6"
)
funcgenerateRandomSentence()string {
// Generate a random sentence with 6 words
 sentence := gofakeit.Sentence(6)
return sentence
}
funcgenerateRandomParagraph()string {
// Generate a random paragraph with 3 sentences, each having 4 to 8 words
 paragraph := gofakeit.Paragraph(3, 4, 8, "/n")
return paragraph
}
funcgenerateLoremIpsum()string {
// Generate 2 paragraphs of lorem ipsum text, each having 3 to 5 sentences
 loremIpsum := gofakeit.LoremIpsumParagraph(3, 5, 12, "\\n")
return loremIpsum
}
funcmain() {
// Set up the random seed for consistent results (optional)
 gofakeit.Seed(0)
// Generate and print random sentence
 fmt.Println("Random Sentence:")
 fmt.Println(generateRandomSentence())
// Generate and print random paragraph
 fmt.Println("\\nRandom Paragraph:")
 fmt.Println(generateRandomParagraph())
// Generate and print lorem ipsum text
 fmt.Println("\\nLorem Ipsum Text:")
 fmt.Println(generateLoremIpsum())
}

Der generierenRandomSentence Funktion generiert einen zufälligen Satz mit Gofakeits Satz Funktion. Der GenerateRandomParagraph Funktion generiert einen zufälligen Absatz mit dem Absatz Funktion.

Der generierenLoremIpsum Die Funktion generiert einen zufälligen Lorem-Ipsum-Absatz mit dem LoremIpsumAbsatz Funktion.

Der hauptsächlich Die Funktion ruft die Funktionen „generateRandomSentence“, „generateRandomParagraph“ und „generateLoremIpsum“ auf. Das Programm gibt die Ausgaben der Funktion auf der Konsole aus.

Sie können gefälschte Daten generieren, um Ihre Datenbank zu testen

Gofakeit vereinfacht das Testen durch dynamische Datengenerierung, um die Kompatibilität mit unterschiedlichen Anforderungen sicherzustellen.

Sie können das integrierte Datenbank-/SQL-Paket von Go verwenden, um Ihre SQL-Datenbank zu Testzwecken mit gefälschten Daten zu füllen. Dies kann Ihnen dabei helfen, mehr Randfälle zu testen und die Datenbanksicherheit zu verbessern.