Add a unit test for the package-global UUID source.

Author: matthewdale

x/mongo/driver/uuid/uuid.go

@@ -16,17 +16,17 @@ import (
 // UUID represents a UUID.
 type UUID [16]byte
 
-// random is a package-global pseudo-random number generator.
-var random = randutil.NewLockedRand(rand.NewSource(randutil.CryptoSeed()))
+// A source is a UUID generator that reads random values from a randutil.LockedRand.
+// It is safe to use from multiple goroutines.
+type source struct {
+	random *randutil.LockedRand
+}
 
-// New returns a random UUIDv4. It uses a "math/rand" pseudo-random number generator seeded with a
-// cryptographically-secure random number at package initialization.
-//
-// New should not be used to generate cryptographically-secure random UUIDs.
-func New() (UUID, error) {
+// new returns a random UUIDv4 with bytes read from the source's random number generator.
+func (s *source) new() (UUID, error) {
 	var uuid [16]byte
 
-	_, err := io.ReadFull(random, uuid[:])
+	_, err := io.ReadFull(s.random, uuid[:])
 	if err != nil {
 		return [16]byte{}, err
 	}
@@ -36,6 +36,26 @@ func New() (UUID, error) {
 	return uuid, nil
 }
 
+// newGlobalSource returns a source that uses a "math/rand" pseudo-random number generator seeded
+// with a cryptographically-secure random number. It is intended to be used to initialize the
+// package-global UUID generator.
+func newGlobalSource() *source {
+	return &source{
+		random: randutil.NewLockedRand(rand.NewSource(randutil.CryptoSeed())),
+	}
+}
+
+// globalSource is a package-global pseudo-random UUID generator.
+var globalSource = newGlobalSource()
+
+// New returns a random UUIDv4. It uses a "math/rand" pseudo-random number generator seeded with a
+// cryptographically-secure random number at package initialization.
+//
+// New should not be used to generate cryptographically-secure random UUIDs.
+func New() (UUID, error) {
+	return globalSource.new()
+}
+
 // Equal returns true if two UUIDs are equal.
 func Equal(a, b UUID) bool {
 	return a == b

x/mongo/driver/uuid/uuid_test.go

@@ -1,17 +1,50 @@
 package uuid
 
 import (
+	"sync"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestNew(t *testing.T) {
 	m := make(map[UUID]bool)
-	for i := 1; i < 100; i++ {
+	for i := 1; i < 1000000; i++ {
 		uuid, err := New()
-		assert.NoError(t, err, "New error")
-		assert.False(t, m[uuid], "New returned a duplicate UUID %v", uuid)
+		require.NoError(t, err, "New error")
+		require.False(t, m[uuid], "New returned a duplicate UUID %v", uuid)
 		m[uuid] = true
 	}
 }
+
+// GODRIVER-2349
+// Test that initializing many package-global UUID sources concurrently never leads to any duplicate
+// UUIDs being generated.
+func TestGlobalSource(t *testing.T) {
+	// Create a slice of 1,000 sources and initialize them in 1,000 separate goroutines. The goal is
+	// to emulate many separate Go driver processes starting at the same time and initializing the
+	// uuid package at the same time.
+	sources := make([]*source, 1000)
+	var wg sync.WaitGroup
+	for i := range sources {
+		wg.Add(1)
+		go func(i int) {
+			defer wg.Done()
+			sources[i] = newGlobalSource()
+		}(i)
+	}
+	wg.Wait()
+
+	// Read 1,000 UUIDs from each source and assert that there is never a duplicate value, either
+	// from the same source or from separate sources.
+	const iterations = 1000
+	uuids := make(map[UUID]bool, len(sources)*iterations)
+	for i := 0; i < iterations; i++ {
+		for j, s := range sources {
+			uuid, err := s.new()
+			require.NoError(t, err, "new() error")
+			require.Falsef(t, uuids[uuid], "source %d returned a duplicate UUID on iteration %d: %v", j, i, uuid)
+			uuids[uuid] = true
+		}
+	}
+}