fix ci error with golang 1.22; better tests

Author: jedib0t

.github/workflows/ci.yml

@@ -25,7 +25,7 @@ jobs:
       - name: Set up Go
         uses: actions/setup-go@v5
         with:
-          go-version: 1.21
+          go-version: 1.22
 
       # Download all the tools used in the steps that follow
       - name: Set up Tools

cmd/password-generator/main.go

@@ -17,7 +17,7 @@ var (
 	flagNoAmbiguity = flag.Bool("no-ambiguity", false, "Avoid Ambiguous Characters?")
 	flagNumChars    = flag.Int("num-chars", 12, "Number of characters in Password")
 	flagPrintIndex  = flag.Bool("index", false, "Print Index Value (1-indexed)")
-	flagSeed        = flag.Int64("seed", 0, "Seed value for non-sequenced mode (ignored if zero)")
+	flagSeed        = flag.Uint64("seed", 0, "Seed value for non-sequenced mode (ignored if zero)")
 	flagSequenced   = flag.Bool("sequenced", false, "Generate passwords in a sequence")
 	flagStartIdx    = flag.String("start", "0", "Index to start from in the sequence (1-indexed)")
 
@@ -49,8 +49,8 @@ func main() {
 	}
 	printIndex := *flagPrintIndex
 	seed := *flagSeed
-	if seed <= 0 {
-		seed = time.Now().UnixNano()
+	if seed == 0 {
+		seed = uint64(time.Now().UnixNano())
 	}
 	startIdx, ok := new(big.Int).SetString(*flagStartIdx, 10)
 	if !ok {
@@ -76,7 +76,7 @@ func main() {
 	}
 }
 
-func generateRandomPasswords(charset password.Charset, numChars int, count *big.Int, printIndex bool, seed int64) {
+func generateRandomPasswords(charset password.Charset, numChars int, count *big.Int, printIndex bool, seed uint64) {
 	generator, err := password.NewGenerator(
 		password.WithCharset(charset),
 		password.WithLength(numChars),

password/generator.go

@@ -67,17 +67,29 @@ func (g *generator) Generate() string {
 	password := g.pool.Get().([]rune)
 	defer g.pool.Put(password)
 
+	// init the filler
 	idx := 0
-	fillPassword := func(count int, runes []rune) {
-		for ; count > 0 && idx < len(password); count-- {
+	fillPassword := func(runes []rune, count int) {
+		for ; idx < len(password) && count > 0; count-- {
 			password[idx] = runes[g.rng.IntN(len(runes))]
 			idx++
 		}
 	}
-	fillPassword(g.minLowerCase, g.charsetCaseLower)
-	fillPassword(g.minUpperCase, g.charsetCaseUpper)
-	fillPassword(g.numSymbolsToGenerate(), g.charsetSymbols)
-	fillPassword(len(password)-idx, g.charsetNonSymbols)
+
+	// fill it with minimum requirements first
+	if g.minLowerCase > 0 {
+		fillPassword(g.charsetCaseLower, g.minLowerCase)
+	}
+	if g.minUpperCase > 0 {
+		fillPassword(g.charsetCaseUpper, g.minUpperCase)
+	}
+	if numSymbols := g.numSymbolsToGenerate(); numSymbols > 0 {
+		fillPassword(g.charsetSymbols, numSymbols)
+	}
+	// fill the rest with non-symbols (as symbols has a max)
+	if remainingChars := len(password) - idx; remainingChars > 0 {
+		fillPassword(g.charsetNonSymbols, remainingChars)
+	}
 
 	// shuffle it all
 	g.rng.Shuffle(len(password), func(i, j int) {
@@ -119,15 +131,15 @@ func (g *generator) sanitize() (Generator, error) {
 	if g.minUpperCase > g.numChars {
 		return nil, ErrMinUpperCaseTooLong
 	}
+	if g.minSymbols > 0 && len(g.charsetSymbols) == 0 {
+		return nil, ErrNoSymbolsInCharset
+	}
 	if g.minSymbols > g.numChars {
 		return nil, ErrMinSymbolsTooLong
 	}
 	if g.minLowerCase+g.minUpperCase+g.minSymbols > g.numChars {
 		return nil, ErrRequirementsNotMet
 	}
-	if g.minSymbols > 0 && len(g.charsetSymbols) == 0 {
-		return nil, ErrNoSymbolsInCharset
-	}
 	return g, nil
 }
 

password/generator_test.go

@@ -2,7 +2,7 @@ package password
 
 import (
 	"fmt"
-	"strings"
+	"slices"
 	"testing"
 	"unicode"
 
@@ -42,19 +42,19 @@ func TestGenerator_Generate(t *testing.T) {
 		"uCFmDFDAoLZY",
 		"pMgNoVa9z5Vv",
 	}
-	sb := strings.Builder{}
+	var actualPasswords []string
 	for idx := 0; idx < 100; idx++ {
 		password := g.Generate()
 		assert.NotEmpty(t, password)
 		if idx < len(expectedPasswords) {
+			actualPasswords = append(actualPasswords, password)
 			assert.Equal(t, expectedPasswords[idx], password)
-			if expectedPasswords[idx] != password {
-				sb.WriteString(fmt.Sprintf("%#v,\n", password))
-			}
 		}
 	}
-	if sb.Len() > 0 {
-		fmt.Println(sb.String())
+	if !slices.Equal(expectedPasswords, actualPasswords) {
+		for _, pw := range actualPasswords {
+			fmt.Printf("%#v,\n", pw)
+		}
 	}
 }
 
@@ -81,15 +81,13 @@ func TestGenerator_Generate_WithAMixOfEverything(t *testing.T) {
 		"bVrPjBRC<bqy",
 		"f?orrWDzVYjx",
 	}
-	sb := strings.Builder{}
+	var actualPasswords []string
 	for idx := 0; idx < 100; idx++ {
 		password := g.Generate()
 		assert.NotEmpty(t, password)
 		if idx < len(expectedPasswords) {
+			actualPasswords = append(actualPasswords, password)
 			assert.Equal(t, expectedPasswords[idx], password)
-			if expectedPasswords[idx] != password {
-				sb.WriteString(fmt.Sprintf("%#v,\n", password))
-			}
 		}
 
 		numLowerCase := len(filterRunes([]rune(password), unicode.IsLower))
@@ -99,8 +97,10 @@ func TestGenerator_Generate_WithAMixOfEverything(t *testing.T) {
 		numSymbols := len(filterRunes([]rune(password), Symbols.Contains))
 		assert.True(t, numSymbols == 1, password)
 	}
-	if sb.Len() > 0 {
-		fmt.Println(sb.String())
+	if !slices.Equal(expectedPasswords, actualPasswords) {
+		for _, pw := range actualPasswords {
+			fmt.Printf("%#v,\n", pw)
+		}
 	}
 }
 
@@ -126,22 +126,22 @@ func TestGenerator_Generate_WithSymbols(t *testing.T) {
 			"-e3a6cda4#!1",
 			"162e6bb#ee53",
 		}
-		sb := strings.Builder{}
+		var actualPasswords []string
 		for idx := 0; idx < 100; idx++ {
 			password := g.Generate()
 			assert.NotEmpty(t, password)
 			if idx < len(expectedPasswords) {
+				actualPasswords = append(actualPasswords, password)
 				assert.Equal(t, expectedPasswords[idx], password)
-				if expectedPasswords[idx] != password {
-					sb.WriteString(fmt.Sprintf("%#v,\n", password))
-				}
 			}
 
 			numSymbols := getNumSymbols(password)
 			assert.True(t, numSymbols >= 0 && numSymbols <= 3, password)
 		}
-		if sb.Len() > 0 {
-			fmt.Println(sb.String())
+		if !slices.Equal(expectedPasswords, actualPasswords) {
+			for _, pw := range actualPasswords {
+				fmt.Printf("%#v,\n", pw)
+			}
 		}
 	})