adds generateUUIDByReader (#10)

adds GenerateUUIDWithReader

uuid.go

@@ -4,22 +4,40 @@ import (
 	"crypto/rand"
 	"encoding/hex"
 	"fmt"
+	"io"
 )
 
 // GenerateRandomBytes is used to generate random bytes of given size.
 func GenerateRandomBytes(size int) ([]byte, error) {
+	return GenerateRandomBytesWithReader(size, rand.Reader)
+}
+
+// GenerateRandomBytesWithReader is used to generate random bytes of given size read from a given reader.
+func GenerateRandomBytesWithReader(size int, reader io.Reader) ([]byte, error) {
+	if reader == nil {
+		return nil, fmt.Errorf("provided reader is nil")
+	}
 	buf := make([]byte, size)
-	if _, err := rand.Read(buf); err != nil {
+	if _, err := io.ReadFull(reader, buf); err != nil {
 		return nil, fmt.Errorf("failed to read random bytes: %v", err)
 	}
 	return buf, nil
 }
 
+
 const uuidLen = 16
 
 // GenerateUUID is used to generate a random UUID
 func GenerateUUID() (string, error) {
-	buf, err := GenerateRandomBytes(uuidLen)
+	return GenerateUUIDWithReader(rand.Reader)
+}
+
+// GenerateUUIDWithReader is used to generate a random UUID with a given Reader
+func GenerateUUIDWithReader(reader io.Reader) (string, error) {
+	if reader == nil {
+		return "", fmt.Errorf("provided reader is nil")
+	}
+	buf, err := GenerateRandomBytesWithReader(uuidLen, reader)
 	if err != nil {
 		return "", err
 	}

uuid_test.go

@@ -2,6 +2,7 @@ package uuid
 
 import (
 	"crypto/rand"
+	"io"
 	"reflect"
 	"regexp"
 	"testing"
@@ -29,6 +30,36 @@ func TestGenerateUUID(t *testing.T) {
 	}
 }
 
+func TestGenerateUUIDWithReader(t *testing.T) {
+	var nilReader io.Reader
+	str, err := GenerateUUIDWithReader(nilReader)
+	if err == nil {
+		t.Fatalf("should get an error with a nilReader")
+	}
+	if str != "" {
+		t.Fatalf("should get an empty string")
+	}
+
+	prev, err := GenerateUUIDWithReader(rand.Reader)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	id, err := GenerateUUIDWithReader(rand.Reader)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if prev == id {
+		t.Fatalf("Should get a new ID!")
+	}
+
+	matched, err := regexp.MatchString(
+		"[\\da-f]{8}-[\\da-f]{4}-[\\da-f]{4}-[\\da-f]{4}-[\\da-f]{12}", id)
+	if !matched || err != nil {
+		t.Fatalf("expected match %s %v %s", id, matched, err)
+	}
+}
+
 func TestParseUUID(t *testing.T) {
 	buf := make([]byte, 16)
 	if _, err := rand.Read(buf); err != nil {
@@ -55,3 +86,9 @@ func BenchmarkGenerateUUID(b *testing.B) {
 		_, _ = GenerateUUID()
 	}
 }
+
+func BenchmarkGenerateUUIDWithReader(b *testing.B) {
+	for n := 0; n < b.N; n++ {
+		_, _ = GenerateUUIDWithReader(rand.Reader)
+	}
+}