fake: Utilize rnd.Pick instead of NumberInRange (#186)

Some minor refactoring

Co-authored-by: Kashif Khan <[email protected]>

Author: addvanced

fake/fake.go

@@ -4,7 +4,8 @@ Package fake provides utilities for generating fake data.
 package fake
 
 import (
-	"crypto/rand"
+	cryptrnd "crypto/rand"
+	"encoding/hex"
 	"fmt"
 	"io"
 	"time"
@@ -32,87 +33,80 @@ var postalCodes = []string{"12345", "23456", "34567", "45678", "56789", "67890",
 // RandomUUID generates a fake UUIDv4.
 func RandomUUID() (string, error) {
 	uuid := make([]byte, 16)
-	_, err := io.ReadFull(rand.Reader, uuid)
+	_, err := io.ReadFull(cryptrnd.Reader, uuid)
 	if err != nil {
-		return "", err
+		return "", fmt.Errorf("failed to generate random UUID: %w", err)
 	}
 
 	// Set the version to 4
 	uuid[6] = (uuid[6] & 0x0f) | 0x40
 	// Set the variant to 2 (RFC 4122)
 	uuid[8] = (uuid[8] & 0x3f) | 0x80
 
-	return fmt.Sprintf("%08x-%04x-%04x-%04x-%12x", uuid[:4], uuid[4:6], uuid[6:8], uuid[8:10], uuid[10:]), nil
+	uuidStr := hex.EncodeToString(uuid)
+
+	return uuidStr[0:8] + "-" + uuidStr[8:12] + "-" + uuidStr[12:16] + "-" + uuidStr[16:20] + "-" + uuidStr[20:32], nil
 }
 
 // RandomDate generates a random date.
 func RandomDate() (time.Time, error) {
-	start := time.Date(EpochYear, time.Month(EpochMonth), EpochDay, EpochHour, EpochMinute, EpochSecond, EpochNano, time.UTC).Unix()
-	end := time.Now().Unix()
-
-	sec, err := rnd.NumberInRange(start, end)
-	if err != nil {
-		return time.Time{}, err
-	}
+	start := time.Date(EpochYear, time.Month(EpochMonth), EpochDay, EpochHour, EpochMinute, EpochSecond, EpochNano, time.UTC).UnixNano()
+	end := time.Now().UnixNano()
 
-	nsec, err := rnd.NumberInRange(0, 1e9)
+	nanos, err := rnd.NumberInRange(start, end)
 	if err != nil {
-		return time.Time{}, err
+		return time.Time{}, fmt.Errorf("failed to generate random time: %w", err)
 	}
 
-	return time.Unix(sec, nsec), nil
+	return time.Unix(0, nanos), nil
 }
 
 // RandomPhoneNumber generates a random phone number.
 func RandomPhoneNumber() (string, error) {
 	areaCode, err := rnd.NumberInRange(100, 999)
 	if err != nil {
-		return "", err
+		return "", fmt.Errorf("failed to generate areaCode: %w", err)
 	}
 
 	firstPart, err := rnd.NumberInRange(100, 999)
 	if err != nil {
-		return "", err
+		return "", fmt.Errorf("failed to generate firstPart: %w", err)
 	}
 
 	secondPart, err := rnd.NumberInRange(1000, 9999)
 	if err != nil {
-		return "", err
+		return "", fmt.Errorf("failed to generate secondPart: %w", err)
 	}
 
-	return fmt.Sprintf("+1 (%d) %d-%d", areaCode, firstPart, secondPart), nil
+	return fmt.Sprintf("+1 (%03d) %03d-%04d", areaCode, firstPart, secondPart), nil
 }
 
 // RandomAddress generates a random address.
 func RandomAddress() (string, error) {
-	streetNumber, err := rnd.NumberInRange(0, MaxStreetNumber)
+	streetNumber, err := rnd.NumberInRange(1, MaxStreetNumber)
 	if err != nil {
-		return "", err
+		return "", fmt.Errorf("failed to generate street number: %w", err)
 	}
 
-	idx, err := rnd.NumberInRange(0, int64(len(streetNames)-1))
+	streetName, err := rnd.Pick(streetNames)
 	if err != nil {
-		return "", err
+		return "", fmt.Errorf("failed to pick street name: %w", err)
 	}
-	streetName := streetNames[idx]
 
-	idx, err = rnd.NumberInRange(0, int64(len(streetNames)-1))
+	city, err := rnd.Pick(cities)
 	if err != nil {
-		return "", err
+		return "", fmt.Errorf("failed to pick city: %w", err)
 	}
-	city := cities[idx]
 
-	idx, err = rnd.NumberInRange(0, int64(len(states)-1))
+	state, err := rnd.Pick(states)
 	if err != nil {
-		return "", err
+		return "", fmt.Errorf("failed to pick state: %w", err)
 	}
-	state := states[idx]
 
-	idx, err = rnd.NumberInRange(0, int64(len(postalCodes)-1))
+	postalCode, err := rnd.Pick(postalCodes)
 	if err != nil {
-		return "", err
+		return "", fmt.Errorf("failed to pick postal code: %w", err)
 	}
-	postalCode := postalCodes[idx]
 
 	return fmt.Sprintf("%d %s, %s, %s %s, USA", streetNumber, streetName, city, state, postalCode), nil
 }

fake/fake_test.go

@@ -1,78 +1,98 @@
 package fake
 
 import (
-	"fmt"
 	"regexp"
 	"testing"
+	"testing/quick"
 	"time"
 )
 
-func TestGenerateUUID(t *testing.T) {
-	uuidSet := make(map[string]struct{})
-	for i := range 1000 {
-		t.Run(fmt.Sprintf("UUIDTest-%d", i), func(t *testing.T) {
-			uuid, err := RandomUUID()
-			if err != nil {
-				t.Fatalf("Expected no error, got %v", err)
-			}
-
-			// Test if UUID is of correct length
-			if len(uuid) != 36 {
-				t.Errorf("Expected length 36, got %d", len(uuid))
-			}
-
-			// Test if UUID matches the correct format
-			isValidUUID := regexp.MustCompile(`^[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$`).MatchString
-			if !isValidUUID(uuid) {
-				t.Errorf("UUID %s does not match the required format", uuid)
-			}
-
-			// Test for uniqueness
-			if _, exists := uuidSet[uuid]; exists {
-				t.Errorf("Duplicate UUID found: %s", uuid)
-			}
-			uuidSet[uuid] = struct{}{}
-		})
+func TestRandomUUID(t *testing.T) {
+	t.Parallel()
+
+	re := regexp.MustCompile(`^[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$`)
+	seen := make(map[string]struct{})
+
+	prop := func() bool {
+		u, err := RandomUUID()
+		if err != nil || len(u) != 36 || !re.MatchString(u) {
+			return false
+		}
+		// simple uniqueness check across trials
+		if _, dup := seen[u]; dup {
+			return false
+		}
+		seen[u] = struct{}{}
+		return true
+	}
+
+	if err := quick.Check(prop, &quick.Config{MaxCount: 1_000}); err != nil {
+		t.Fatalf("RandomUUID property failed: %v", err)
 	}
 }
 
 func TestRandomDate(t *testing.T) {
+	t.Parallel()
+
 	start := time.Date(EpochYear, time.Month(EpochMonth), EpochDay, EpochHour, EpochMinute, EpochSecond, EpochNano, time.UTC)
-	end := time.Now()
 
-	randomDate, err := RandomDate()
-	if err != nil {
-		t.Fatalf("Expected no error, but got %v", err)
+	prop := func() bool {
+		d, err := RandomDate()
+		if err != nil {
+			return false
+		}
+		end := time.Now()
+		return !d.Before(start) && !d.After(end)
 	}
 
-	if randomDate.Before(start) || randomDate.After(end) {
-		t.Fatalf("Random date %v is outside the expected range [%v, %v]", randomDate, start, end)
+	if err := quick.Check(prop, &quick.Config{MaxCount: 1_000}); err != nil {
+		t.Fatalf("RandomDate property failed: %v", err)
 	}
 }
 
-func TestGenerateRandomPhoneNumber(t *testing.T) {
-	phoneNumber, err := RandomPhoneNumber()
-	if err != nil {
-		t.Fatalf("Expected no error, but got %v", err)
+// Sanity property: RandomDate never returns the zero time.
+func TestRandomDate_NonZero_Property(t *testing.T) {
+	t.Parallel()
+
+	prop := func() bool {
+		d, err := RandomDate()
+		return err == nil && !d.IsZero()
 	}
 
+	if err := quick.Check(prop, &quick.Config{MaxCount: 1_000}); err != nil {
+		t.Fatalf("RandomDate_NonZero property failed: %v", err)
+	}
+}
+
+func TestRandomPhoneNumber(t *testing.T) {
+	t.Parallel()
+
 	re := regexp.MustCompile(`^\+1 \(\d{3}\) \d{3}-\d{4}$`)
 
-	if !re.MatchString(phoneNumber) {
-		t.Errorf("Generated phone number %v does not match the expected format", phoneNumber)
+	prop := func() bool {
+		phoneNumber, err := RandomPhoneNumber()
+
+		return err == nil && re.MatchString(phoneNumber)
+	}
+
+	if err := quick.Check(prop, &quick.Config{MaxCount: 1_000}); err != nil {
+		t.Fatalf("RandomPhoneNumber property failed: %v", err)
 	}
 }
 
 func TestRandomAddress(t *testing.T) {
-	address, err := RandomAddress()
-	if err != nil {
-		t.Fatalf("Expected no error, but got %v", err)
-	}
+	t.Parallel()
 
 	re := regexp.MustCompile(`^\d+ [A-Za-z ]+, [A-Za-z ]+, [A-Z]{2} \d{5}, USA$`)
 
-	if !re.MatchString(address) {
-		t.Errorf("Generated address %v does not match the expected format", address)
+	prop := func() bool {
+		address, err := RandomAddress()
+
+		return err == nil && re.MatchString(address)
+	}
+
+	if err := quick.Check(prop, &quick.Config{MaxCount: 1_000}); err != nil {
+		t.Fatalf("RandomAddress property failed: %v", err)
 	}
 }