re s/guuid/uuid/g

1 files changed, 187 insertions, 187 deletions

diff --git a/tests/papod.go b/tests/papod.go
index 283017a..3e82d82 100644
--- a/tests/papod.go
+++ b/tests/papod.go
@@ -13,7 +13,7 @@ import (
 	"time"
 
 	"golite"
-	"guuid"
+	"uuid"
 	g "gobang"
 )
 
@@ -25,7 +25,7 @@ type userChangeT struct{
 	user_id   int64
 	attribute string
 	valueStr  *string
-	valueBlob *guuid.UUID
+	valueBlob *uuid.UUID
 	valueBool *bool
 	op        bool
 }
@@ -86,10 +86,10 @@ func userChangesSQL(prefix string) string {
 	)
 }
 
-func makeUserChanges(db *sql.DB, prefix string) func(guuid.UUID) []userChangeT {
+func makeUserChanges(db *sql.DB, prefix string) func(uuid.UUID) []userChangeT {
 	q := userChangesSQL(prefix)
 
-	return func(userID guuid.UUID) []userChangeT {
+	return func(userID uuid.UUID) []userChangeT {
 		userChanges := []userChangeT{}
 		rows, err := db.Query(q, userID[:])
 		g.TErrorIf(err)
@@ -114,7 +114,7 @@ func makeUserChanges(db *sql.DB, prefix string) func(guuid.UUID) []userChangeT {
 			g.TErrorIf(err)
 
 			if value_bytes != nil {
-				valueBlob := guuid.UUID(value_bytes)
+				valueBlob := uuid.UUID(value_bytes)
 				userChange.valueBlob = &valueBlob
 			}
 
@@ -167,10 +167,10 @@ func networkChangesSQL(prefix string) string {
 func makeNetworkChanges(
 	db *sql.DB,
 	prefix string,
-) func(guuid.UUID) []networkChangeT {
+) func(uuid.UUID) []networkChangeT {
 	q := networkChangesSQL(prefix)
 
-	return func(networkID guuid.UUID) []networkChangeT {
+	return func(networkID uuid.UUID) []networkChangeT {
 		networkChanges := []networkChangeT{}
 		rows, err := db.Query(q, networkID[:])
 		g.TErrorIf(err)
@@ -411,7 +411,7 @@ func test_createUserStmt() {
 
 	g.Testing("userID's must be unique", func() {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		_, err1 := createUser(newUser)
@@ -425,7 +425,7 @@ func test_createUserStmt() {
 
 	g.Testing("a new user starts without a pictureID", func() {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		user, err := createUser(newUser)
@@ -435,7 +435,7 @@ func test_createUserStmt() {
 
 	g.Testing("the database fills default and generated values", func() {
 		newUser := newUserT{
-			uuid:        guuid.New(),
+			uuid:        uuid.New(),
 			username:    "the username",
 			displayName: "the display name",
 		}
@@ -455,13 +455,13 @@ func test_createUserStmt() {
 		displayName := mkstring()
 
 		newUser1 := newUserT{
-			uuid:        guuid.New(),
+			uuid:        uuid.New(),
 			username:    username,
 			displayName: displayName,
 		}
 
 		newUser2 := newUserT{
-			uuid:        guuid.New(),
+			uuid:        uuid.New(),
 			username:    username,
 			displayName: displayName,
 		}
@@ -474,7 +474,7 @@ func test_createUserStmt() {
 
 	g.Testing("new user trigger inserts into *_user_changes", func() {
 		newUser := newUserT{
-			uuid:        guuid.New(),
+			uuid:        uuid.New(),
 			username:    mkstring(),
 			displayName: mkstring(),
 		}
@@ -570,13 +570,13 @@ func test_userByUUIDStmt() {
 
 
 	g.Testing("when a user doesn't exist, we get sql.ErrNoRows", func() {
-		_, err := userByUUID(guuid.New())
+		_, err := userByUUID(uuid.New())
 		g.TAssertEqual(err, sql.ErrNoRows)
 	})
 
 	g.Testing("after creating, we can retrieve the user", func() {
 		newUser := newUserT{
-			uuid:        guuid.New(),
+			uuid:        uuid.New(),
 			username:    mkstring(),
 			displayName: mkstring(),
 		}
@@ -597,7 +597,7 @@ func test_userByUUIDStmt() {
 
 	g.Testing("we can't retrieve a user once deleted",func() {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		_, err := createUser(newUser)
@@ -659,7 +659,7 @@ func test_updateUserStmt() {
 
 	create := func() userT {
 		newUser := newUserT{
-			uuid:        guuid.New(),
+			uuid:        uuid.New(),
 			username:    mkstring(),
 			displayName: mkstring(),
 		}
@@ -683,7 +683,7 @@ func test_updateUserStmt() {
 
 	g.Testing("after updating, fetching gives us the newer data", func() {
 		newUser := newUserT{
-			uuid:        guuid.New(),
+			uuid:        uuid.New(),
 			username:    "first username",
 			displayName: "first display name",
 		}
@@ -729,7 +729,7 @@ func test_updateUserStmt() {
 		user1 := create()
 		g.TAssertEqual(user1.pictureID == nil, true)
 
-		pictureID := guuid.New()
+		pictureID := uuid.New()
 		user2 := user1
 		user2.pictureID = &pictureID
 		err = updateUser(user2)
@@ -757,7 +757,7 @@ func test_updateUserStmt() {
 
 		user2 := user1
 		user2.timestamp = user2.timestamp.Add(time.Minute * 1)
-		user2.uuid = guuid.New()
+		user2.uuid = uuid.New()
 		err := updateUser(user2)
 		g.TErrorIf(err)
 
@@ -777,7 +777,7 @@ func test_updateUserStmt() {
 
 	g.Testing("new username end up in *_user_changes when updated", func() {
 		newUser := newUserT{
-			uuid:        guuid.New(),
+			uuid:        uuid.New(),
 			username:    "first username",
 			displayName: "display name",
 		}
@@ -827,7 +827,7 @@ func test_updateUserStmt() {
 
 	g.Testing("displayName end up in *_user_changes when updated", func() {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 			username:    "username",
 			displayName: "first display name",
 		}
@@ -876,11 +876,11 @@ func test_updateUserStmt() {
 
 	g.Testing("pictureID end up in *_user_changes when updated", func() {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 			username:    "username",
 			displayName: "first display name",
 		}
-		pictureID := guuid.New()
+		pictureID := uuid.New()
 
 		user, err := createUser(newUser)
 		g.TErrorIf(err)
@@ -956,13 +956,13 @@ func test_deleteUserStmt() {
 
 
 	g.Testing("a user needs to exist to be deleted", func() {
-		err := deleteUser(guuid.New())
+		err := deleteUser(uuid.New())
 		g.TAssertEqual(err, sql.ErrNoRows)
 	})
 
 	g.Testing("error if deleted more than once", func() {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		_, err := createUser(newUser)
@@ -976,7 +976,7 @@ func test_deleteUserStmt() {
 
 	g.Testing("deletion triggers insertion into *_user_changes", func() {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		user, err := createUser(newUser)
@@ -1066,7 +1066,7 @@ func test_addNetworkStmt() {
 
 	create := func() userT {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		user, err := createUser(newUser)
@@ -1075,7 +1075,7 @@ func test_addNetworkStmt() {
 		return user
 	}
 
-	allMembers := func(actor memberT, networkID guuid.UUID) []memberT {
+	allMembers := func(actor memberT, networkID uuid.UUID) []memberT {
 		rows, err := members(actor)
 		g.TErrorIf(err)
 		defer rows.Close()
@@ -1097,13 +1097,13 @@ func test_addNetworkStmt() {
 		creator := create()
 
 		newNetwork := newNetworkT{
-			uuid:        guuid.New(),
+			uuid:        uuid.New(),
 			name:        "the network name",
 			description: "the network description",
 			type_:       NetworkType_Unlisted,
 		}
 
-		network, err := addNetwork(creator, newNetwork, guuid.New())
+		network, err := addNetwork(creator, newNetwork, uuid.New())
 		g.TErrorIf(err)
 
 		g.TAssertEqual(network.id == 0, false)
@@ -1116,7 +1116,7 @@ func test_addNetworkStmt() {
 
 	g.Testing("the creator needs to exist", func() {
 		newNetwork := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Unlisted,
 		}
 
@@ -1124,7 +1124,7 @@ func test_addNetworkStmt() {
 			id: 1234,
 		}
 
-		_, err := addNetwork(virtualUser, newNetwork, guuid.New())
+		_, err := addNetwork(virtualUser, newNetwork, uuid.New())
 		g.TAssertEqual(
 			err.(golite.Error).ExtendedCode,
 			golite.ErrConstraintNotNull,
@@ -1135,13 +1135,13 @@ func test_addNetworkStmt() {
 		creator := create()
 
 		newNetwork := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			name:  mkstring(),
 			type_: NetworkType_Unlisted,
 		}
 
-		_, err1 := addNetwork(creator, newNetwork, guuid.New())
-		_, err2 := addNetwork(creator, newNetwork, guuid.New())
+		_, err1 := addNetwork(creator, newNetwork, uuid.New())
+		_, err2 := addNetwork(creator, newNetwork, uuid.New())
 		g.TErrorIf(err1)
 		g.TAssertEqual(
 			err2.(golite.Error).ExtendedCode,
@@ -1153,16 +1153,16 @@ func test_addNetworkStmt() {
 		creator := create()
 
 		newNetwork1 := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Unlisted,
 		}
 		newNetwork2 := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Unlisted,
 		}
 
-		_, err1 := addNetwork(creator, newNetwork1, guuid.New())
-		_, err2 := addNetwork(creator, newNetwork2, guuid.New())
+		_, err1 := addNetwork(creator, newNetwork1, uuid.New())
+		_, err2 := addNetwork(creator, newNetwork2, uuid.New())
 		g.TErrorIf(err1)
 		g.TErrorIf(err2)
 	})
@@ -1171,20 +1171,20 @@ func test_addNetworkStmt() {
 		creator := create()
 
 		newNetwork1 := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Unlisted,
 		}
 		newNetwork2 := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Unlisted,
 		}
 
-		_, err := addNetwork(creator, newNetwork1, guuid.New())
+		_, err := addNetwork(creator, newNetwork1, uuid.New())
 		g.TErrorIf(err)
 
 		err = deleteUser(creator.uuid)
 		g.TErrorIf(err)
-		_, err = addNetwork(creator, newNetwork2, guuid.New())
+		_, err = addNetwork(creator, newNetwork2, uuid.New())
 		g.TAssertEqual(
 			err.(golite.Error).ExtendedCode,
 			golite.ErrConstraintNotNull,
@@ -1195,13 +1195,13 @@ func test_addNetworkStmt() {
 		creator := create()
 
 		newNetwork := newNetworkT{
-			uuid:        guuid.New(),
+			uuid:        uuid.New(),
 			name:        "the network name",
 			description: "the network description",
 			type_:       NetworkType_Unlisted,
 		}
 
-		_, err := addNetwork(creator, newNetwork, guuid.New())
+		_, err := addNetwork(creator, newNetwork, uuid.New())
 		g.TErrorIf(err)
 
 		changes := networkChanges(newNetwork.uuid)
@@ -1240,10 +1240,10 @@ func test_addNetworkStmt() {
 
 	g.Testing("the creator is automatically a member", func() {
 		creator  := create()
-		memberID := guuid.New()
+		memberID := uuid.New()
 
 		newNetwork := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Unlisted,
 		}
 
@@ -1261,10 +1261,10 @@ func test_addNetworkStmt() {
 
 	g.Testing(`the creator has "creator" and "admin" roles`, func() {
 		creator  := create()
-		memberID := guuid.New()
+		memberID := uuid.New()
 
 		newNetwork := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Unlisted,
 		}
 
@@ -1332,7 +1332,7 @@ func test_getNetworkStmt() {
 
 	create := func() userT {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		user, err := createUser(newUser)
@@ -1343,11 +1343,11 @@ func test_getNetworkStmt() {
 
 	add := func(user userT, type_ NetworkType) (networkT, memberT) {
 		newNetwork := newNetworkT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 			type_: type_,
 		}
 
-		network, err := addNetwork(user, newNetwork, guuid.New())
+		network, err := addNetwork(user, newNetwork, uuid.New())
 		g.TErrorIf(err)
 
 		member, err := membership(user, network)
@@ -1367,7 +1367,7 @@ func test_getNetworkStmt() {
 	})
 
 	g.Testing("a network needs to exist", func() {
-		_, err := getNetwork(create(), guuid.New())
+		_, err := getNetwork(create(), uuid.New())
 		g.TAssertEqual(err, sql.ErrNoRows)
 	})
 
@@ -1429,7 +1429,7 @@ func test_getNetworkStmt() {
 		network, member := add(creator, NetworkType_Private)
 		newMember := newMemberT{
 			userID:   user.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -1450,7 +1450,7 @@ func test_getNetworkStmt() {
 		network, member := add(creator, NetworkType_Public)
 		newMember := newMemberT{
 			userID:   user.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -1502,7 +1502,7 @@ func test_getNetworkStmt() {
 		network, member := add(creator, NetworkType_Private)
 		newMember := newMemberT{
 			userID:   user.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -1525,7 +1525,7 @@ func test_getNetworkStmt() {
 		network, member := add(creator, NetworkType_Private)
 		newMember := newMemberT{
 			userID:   user.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -1588,7 +1588,7 @@ func test_networkEach() {
 
 	create := func() userT {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		user, err := createUser(newUser)
@@ -1597,13 +1597,13 @@ func test_networkEach() {
 		return user
 	}
 
-	add := func(user userT) guuid.UUID {
+	add := func(user userT) uuid.UUID {
 		newNetwork := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Public,
 		}
 
-		_, err := addNetwork(user, newNetwork, guuid.New())
+		_, err := addNetwork(user, newNetwork, uuid.New())
 		g.TErrorIf(err)
 
 		return newNetwork.uuid
@@ -1623,7 +1623,7 @@ func test_networkEach() {
 
 	g.Testing("the callback is called once for each entry", func() {
 		creator := create()
-		networkIDs := []guuid.UUID{
+		networkIDs := []uuid.UUID{
 			add(creator),
 			add(creator),
 			add(creator),
@@ -1633,7 +1633,7 @@ func test_networkEach() {
 		g.TErrorIf(err)
 		defer rows.Close()
 
-		var collectedIDs[]guuid.UUID
+		var collectedIDs[]uuid.UUID
 		err = networkEach(rows, func(network networkT) error {
 			collectedIDs = append(collectedIDs, network.uuid)
 			return nil
@@ -1766,7 +1766,7 @@ func test_networksStmt() {
 
 	create := func() userT {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		user, err := createUser(newUser)
@@ -1777,11 +1777,11 @@ func test_networksStmt() {
 
 	add := func(user userT, type_ NetworkType) networkT {
 		newNetwork := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: type_,
 		}
 
-		network, err := addNetwork(user, newNetwork, guuid.New())
+		network, err := addNetwork(user, newNetwork, uuid.New())
 		g.TErrorIf(err)
 
 		return network
@@ -1950,7 +1950,7 @@ func test_setNetworkStmt() {
 
 	create := func() userT {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		user, err := createUser(newUser)
@@ -1961,10 +1961,10 @@ func test_setNetworkStmt() {
 
 	add := func(user userT) (networkT, memberT) {
 		newNetwork := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Public,
 		}
-		memberID := guuid.New()
+		memberID := uuid.New()
 
 		network, err := addNetwork(user, newNetwork, memberID)
 		g.TErrorIf(err)
@@ -1998,7 +1998,7 @@ func test_setNetworkStmt() {
 		network, creatorMember := add(creator)
 		newMember := newMemberT{
 			userID:   admin.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -2024,7 +2024,7 @@ func test_setNetworkStmt() {
 		network, creatorMember := add(creator)
 		newMember := newMemberT{
 			userID:   admin.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -2061,7 +2061,7 @@ func test_setNetworkStmt() {
 		network, creatorMember := add(creator)
 		newMember := newMemberT{
 			userID:   admin.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -2092,7 +2092,7 @@ func test_setNetworkStmt() {
 		network, creatorMember := add(creator)
 		newMember := newMemberT{
 			userID:   user.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -2144,7 +2144,7 @@ func test_setNetworkStmt() {
 		network1, member := add(creator)
 
 		network2 := network1
-		network2.uuid      = guuid.New()
+		network2.uuid      = uuid.New()
 		network2.timestamp = time.Time{}
 
 		err := setNetwork(member, network2)
@@ -2200,12 +2200,12 @@ func test_setNetworkStmt() {
 	g.Testing("updates do cause writes to changes table", func() {
 		creator := create()
 		newNetwork := newNetworkT{
-			uuid:        guuid.New(),
+			uuid:        uuid.New(),
 			name:        "first name",
 			description: "first description",
 			type_:       NetworkType_Public,
 		}
-		memberID := guuid.New()
+		memberID := uuid.New()
 
 		network, err := addNetwork(creator, newNetwork, memberID)
 		g.TErrorIf(err)
@@ -2337,7 +2337,7 @@ func test_nipNetworkStmt() {
 
 	create := func() userT {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		user, err := createUser(newUser)
@@ -2348,11 +2348,11 @@ func test_nipNetworkStmt() {
 
 	add := func(user userT) (networkT, memberT) {
 		newNetwork := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Public,
 		}
 
-		network, err := addNetwork(user, newNetwork, guuid.New())
+		network, err := addNetwork(user, newNetwork, uuid.New())
 		g.TErrorIf(err)
 
 		member, err := membership(user, network)
@@ -2438,7 +2438,7 @@ func test_nipNetworkStmt() {
 		_, creatorMember := add(create())
 		newMember := newMemberT{
 			userID:   admin.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -2457,7 +2457,7 @@ func test_nipNetworkStmt() {
 		_, creatorMember := add(create())
 		newMember := newMemberT{
 			userID:   user.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -2476,7 +2476,7 @@ func test_nipNetworkStmt() {
 		_, member := add(create())
 		newMember := newMemberT{
 			userID:   user.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -2584,7 +2584,7 @@ func test_membershipStmt() {
 
 	create := func() userT {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		user, err := createUser(newUser)
@@ -2595,11 +2595,11 @@ func test_membershipStmt() {
 
 	add := func(user userT) networkT {
 		newNetwork := newNetworkT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 			type_: NetworkType_Private,
 		}
 
-		network, err := addNetwork(user, newNetwork, guuid.New())
+		network, err := addNetwork(user, newNetwork, uuid.New())
 		g.TErrorIf(err)
 
 		return network
@@ -2665,7 +2665,7 @@ func test_membershipStmt() {
 		network := add(creator)
 		newMember := newMemberT{
 			userID:   user.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: "a username",
 		}
 
@@ -2687,7 +2687,7 @@ func test_membershipStmt() {
 		network := add(creator)
 		newMember := newMemberT{
 			userID:   admin.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -2766,7 +2766,7 @@ func test_addMemberStmt() {
 
 	create := func() userT {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		user, err := createUser(newUser)
@@ -2777,11 +2777,11 @@ func test_addMemberStmt() {
 
 	add := func(user userT) (networkT, memberT) {
 		newNetwork := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Public,
 		}
 
-		network, err := addNetwork(user, newNetwork, guuid.New())
+		network, err := addNetwork(user, newNetwork, uuid.New())
 		g.TErrorIf(err)
 
 		member, err := membership(user, network)
@@ -2794,8 +2794,8 @@ func test_addMemberStmt() {
 	g.Testing("the user needs to exist", func() {
 		_, member := add(create())
 		newMember := newMemberT{
-			userID:   guuid.New(),
-			memberID: guuid.New(),
+			userID:   uuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -2812,12 +2812,12 @@ func test_addMemberStmt() {
 		_, member0 := add(create())
 		newMember1 := newMemberT{
 			userID:   user1.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 		newMember2 := newMemberT{
 			userID:   user2.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -2837,12 +2837,12 @@ func test_addMemberStmt() {
 		_, member0 := add(create())
 		newMember1 := newMemberT{
 			userID:   user1.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 		newMember2 := newMemberT{
 			userID:   user2.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -2862,12 +2862,12 @@ func test_addMemberStmt() {
 		_, member0 := add(create())
 		newMember1 := newMemberT{
 			userID:   user1.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 		newMember2 := newMemberT{
 			userID:   user2.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -2887,7 +2887,7 @@ func test_addMemberStmt() {
 		_, member := add(creator)
 		newMember := newMemberT{
 			userID:   user.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -2905,7 +2905,7 @@ func test_addMemberStmt() {
 		user1   := create()
 		user2   := create()
 		_, member := add(creator)
-		memberID := guuid.New()
+		memberID := uuid.New()
 		newMember1 := newMemberT{
 			userID:   user1.uuid,
 			memberID: memberID,
@@ -2932,7 +2932,7 @@ func test_addMemberStmt() {
 		_, member := add(creator)
 		newMember := newMemberT{
 			userID:   user.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -2952,7 +2952,7 @@ func test_addMemberStmt() {
 		_, member := add(creator)
 		newMember := newMemberT{
 			userID:   user.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -3025,7 +3025,7 @@ func test_dropRoleStmt() {
 
 	create := func() userT {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		user, err := createUser(newUser)
@@ -3036,11 +3036,11 @@ func test_dropRoleStmt() {
 
 	add := func(user userT) (networkT, memberT) {
 		newNetwork := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Public,
 		}
 
-		network, err := addNetwork(user, newNetwork, guuid.New())
+		network, err := addNetwork(user, newNetwork, uuid.New())
 		g.TErrorIf(err)
 
 		member, err := membership(user, network)
@@ -3151,7 +3151,7 @@ func test_showMemberStmt() {
 
 	create := func() userT {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		user, err := createUser(newUser)
@@ -3162,11 +3162,11 @@ func test_showMemberStmt() {
 
 	add := func(user userT) (networkT, memberT) {
 		newNetwork := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Public,
 		}
 
-		network, err := addNetwork(user, newNetwork, guuid.New())
+		network, err := addNetwork(user, newNetwork, uuid.New())
 		g.TErrorIf(err)
 
 		member, err := membership(user, network)
@@ -3178,7 +3178,7 @@ func test_showMemberStmt() {
 
 	g.Testing("target member must exist", func() {
 		_, member := add(create())
-		_, err := showMember(member, guuid.New())
+		_, err := showMember(member, uuid.New())
 		g.TAssertEqual(err, sql.ErrNoRows)
 	})
 
@@ -3260,7 +3260,7 @@ func test_memberEach() {
 
 	create := func() userT {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		user, err := createUser(newUser)
@@ -3272,11 +3272,11 @@ func test_memberEach() {
 	add := func() memberT {
 		creator := create()
 		newNetwork := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Public,
 		}
 
-		network, err := addNetwork(creator, newNetwork, guuid.New())
+		network, err := addNetwork(creator, newNetwork, uuid.New())
 		g.TErrorIf(err)
 
 		member, err := membership(creator, network)
@@ -3289,7 +3289,7 @@ func test_memberEach() {
 		user := create()
 		newMember := newMemberT{
 			userID:   user.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -3311,7 +3311,7 @@ func test_memberEach() {
 		g.TErrorIf(err)
 		defer rows.Close()
 
-		memberIDs := []guuid.UUID{}
+		memberIDs := []uuid.UUID{}
 		err = memberEach(rows, func(member memberT) error {
 			memberIDs = append(memberIDs, member.uuid)
 			return nil
@@ -3324,7 +3324,7 @@ func test_memberEach() {
 	g.Testing("we halt if the callback returns an error", func() {
 		myErr  := errors.New("callback custom error")
 		member := add()
-		expectedIDs := []guuid.UUID{
+		expectedIDs := []uuid.UUID{
 			member.uuid,
 			addM(member, MemberStatus_Active).uuid,
 			addM(member, MemberStatus_Active).uuid,
@@ -3337,7 +3337,7 @@ func test_memberEach() {
 		g.TErrorIf(err)
 		defer rows.Close()
 
-		memberIDs := []guuid.UUID{}
+		memberIDs := []uuid.UUID{}
 		err = memberEach(rows, func(member memberT) error {
 			if len(memberIDs) == 3 {
 				return myErr
@@ -3405,7 +3405,7 @@ func test_membersStmt() {
 
 	create := func() userT {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		user, err := createUser(newUser)
@@ -3417,11 +3417,11 @@ func test_membersStmt() {
 	add := func() memberT {
 		creator := create()
 		newNetwork := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Public,
 		}
 
-		network, err := addNetwork(creator, newNetwork, guuid.New())
+		network, err := addNetwork(creator, newNetwork, uuid.New())
 		g.TErrorIf(err)
 
 		member, err := membership(creator, network)
@@ -3436,7 +3436,7 @@ func test_membersStmt() {
 		user := create()
 		newMember := newMemberT{
 			userID:   user.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -3549,7 +3549,7 @@ func test_editMemberStmt() {
 
 	create := func() userT {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		user, err := createUser(newUser)
@@ -3561,11 +3561,11 @@ func test_editMemberStmt() {
 	add := func() memberT {
 		user := create()
 		newNetwork := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Public,
 		}
 
-		network, err := addNetwork(user, newNetwork, guuid.New())
+		network, err := addNetwork(user, newNetwork, uuid.New())
 		g.TErrorIf(err)
 
 		member, err := membership(user, network)
@@ -3642,7 +3642,7 @@ func test_addChannelStmt() {
 
 	create := func() userT {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		user, err := createUser(newUser)
@@ -3654,11 +3654,11 @@ func test_addChannelStmt() {
 	add := func() memberT {
 		creator := create()
 		newNetwork := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Public,
 		}
 
-		network, err := addNetwork(creator, newNetwork, guuid.New())
+		network, err := addNetwork(creator, newNetwork, uuid.New())
 		g.TErrorIf(err)
 
 		member, err := membership(creator, network)
@@ -3674,7 +3674,7 @@ func test_addChannelStmt() {
 		member := add()
 		publicName := "a-name"
 		newChannel := newChannelT{
-			uuid:        guuid.New(),
+			uuid:        uuid.New(),
 			publicName:  &publicName,
 			label:       "a-label",
 			description: "the description",
@@ -3697,7 +3697,7 @@ func test_addChannelStmt() {
 		member := add()
 		publicName := "another name"
 		newChannel := newChannelT{
-			uuid:        guuid.New(),
+			uuid:        uuid.New(),
 			publicName:  &publicName,
 			label:       "the label",
 			description: "the description",
@@ -3796,17 +3796,17 @@ func test_channelEach() {
 
 	add := func() memberT {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 		newNetwork := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Public,
 		}
 
 		user, err := createUser(newUser)
 		g.TErrorIf(err)
 
-		network, err := addNetwork(user, newNetwork, guuid.New())
+		network, err := addNetwork(user, newNetwork, uuid.New())
 		g.TErrorIf(err)
 
 		member, err := membership(user, network)
@@ -3818,7 +3818,7 @@ func test_channelEach() {
 	addC := func(member memberT) channelT {
 		publicName := mkstring()
 		newChannel := newChannelT{
-			uuid:        guuid.New(),
+			uuid:        uuid.New(),
 			publicName:  &publicName,
 			label:       mkstring(),
 			description: mkstring(),
@@ -3956,7 +3956,7 @@ func test_channelsStmt() {
 
 	create := func() userT {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		user, err := createUser(newUser)
@@ -3968,11 +3968,11 @@ func test_channelsStmt() {
 	add := func() memberT {
 		user := create()
 		newNetwork := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Public,
 		}
 
-		network, err := addNetwork(user, newNetwork, guuid.New())
+		network, err := addNetwork(user, newNetwork, uuid.New())
 		g.TErrorIf(err)
 
 		member, err := membership(user, network)
@@ -3985,7 +3985,7 @@ func test_channelsStmt() {
 		user := create()
 		newMember := newMemberT{
 			userID:   user.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -4001,7 +4001,7 @@ func test_channelsStmt() {
 		virtual bool,
 	) channelT {
 		newChannel := newChannelT{
-			uuid:        guuid.New(),
+			uuid:        uuid.New(),
 			publicName:  publicName,
 			label:       mkstring(),
 			description: mkstring(),
@@ -4151,7 +4151,7 @@ func test_setChannelStmt() {
 
 	create := func() userT {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		user, err := createUser(newUser)
@@ -4163,11 +4163,11 @@ func test_setChannelStmt() {
 	add := func() memberT {
 		creator := create()
 		newNetwork := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Public,
 		}
 
-		network, err := addNetwork(creator, newNetwork, guuid.New())
+		network, err := addNetwork(creator, newNetwork, uuid.New())
 		g.TErrorIf(err)
 
 		member, err := membership(creator, network)
@@ -4180,7 +4180,7 @@ func test_setChannelStmt() {
 		user := create()
 		newMember := newMemberT{
 			userID:   user.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -4193,7 +4193,7 @@ func test_setChannelStmt() {
 	addC := func(actor memberT, description string) channelT {
 		publicName := mkstring()
 		newChannel := newChannelT{
-			uuid:        guuid.New(),
+			uuid:        uuid.New(),
 			publicName:  &publicName,
 			label:       mkstring(),
 			description: description,
@@ -4328,7 +4328,7 @@ func test_joinStmt() {
 
 	create := func() userT {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		user, err := createUser(newUser)
@@ -4340,11 +4340,11 @@ func test_joinStmt() {
 	add := func() memberT {
 		creator := create()
 		newNetwork := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Public,
 		}
 
-		network, err := addNetwork(creator, newNetwork, guuid.New())
+		network, err := addNetwork(creator, newNetwork, uuid.New())
 		g.TErrorIf(err)
 
 		member, err := membership(creator, network)
@@ -4357,7 +4357,7 @@ func test_joinStmt() {
 		user := create()
 		newMember := newMemberT{
 			userID:   user.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -4369,7 +4369,7 @@ func test_joinStmt() {
 
 	addC := func(actor memberT, publicName *string, virtual bool) channelT {
 		newChannel := newChannelT{
-			uuid:        guuid.New(),
+			uuid:        uuid.New(),
 			publicName:  publicName,
 			label:       mkstring(),
 			description: mkstring(),
@@ -4395,7 +4395,7 @@ func test_joinStmt() {
 	})
 
 	g.Testing("target channel must exist", func() {
-		err := join(add(), guuid.New())
+		err := join(add(), uuid.New())
 		g.TAssertEqual(err, sql.ErrNoRows)
 	})
 
@@ -4535,7 +4535,7 @@ func test_partStmt() {
 
 	create := func() userT{
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		user, err := createUser(newUser)
@@ -4547,11 +4547,11 @@ func test_partStmt() {
 	add := func() memberT {
 		creator := create()
 		newNetwork := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Public,
 		}
 
-		network, err := addNetwork(creator, newNetwork, guuid.New())
+		network, err := addNetwork(creator, newNetwork, uuid.New())
 		g.TErrorIf(err)
 
 		member, err := membership(creator, network)
@@ -4564,7 +4564,7 @@ func test_partStmt() {
 		user := create()
 		newMember := newMemberT{
 			userID:   user.uuid,
-			memberID: guuid.New(),
+			memberID: uuid.New(),
 			username: mkstring(),
 		}
 
@@ -4577,7 +4577,7 @@ func test_partStmt() {
 	addC := func(actor memberT, virtual bool) channelT {
 		publicName := "public name"
 		newChannel := newChannelT{
-			uuid:        guuid.New(),
+			uuid:        uuid.New(),
 			publicName:  &publicName,
 			label:       mkstring(),
 			description: mkstring(),
@@ -4703,7 +4703,7 @@ func test_addEventStmt() {
 
 	create := func() userT {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		user, err := createUser(newUser)
@@ -4715,11 +4715,11 @@ func test_addEventStmt() {
 	add := func() memberT {
 		creator := create()
 		newNetwork := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Public,
 		}
 
-		network, err := addNetwork(creator, newNetwork, guuid.New())
+		network, err := addNetwork(creator, newNetwork, uuid.New())
 		g.TErrorIf(err)
 
 		member, err := membership(creator, network)
@@ -4731,7 +4731,7 @@ func test_addEventStmt() {
 	addC := func(actor memberT) channelT {
 		publicName := mkstring()
 		newChannel := newChannelT{
-			uuid:        guuid.New(),
+			uuid:        uuid.New(),
 			publicName:  &publicName,
 			label:       mkstring(),
 			description: mkstring(),
@@ -4749,7 +4749,7 @@ func test_addEventStmt() {
 		creator  := add()
 		channel  := addC(creator)
 		newEvent := newEventT{
-			eventID:   guuid.New(),
+			eventID:   uuid.New(),
 			channelID: channel.uuid,
 			source: sourceT{
 				uuid:  creator.uuid,
@@ -4776,7 +4776,7 @@ func test_addEventStmt() {
 		creator  := add()
 		channel  := addC(creator)
 		newEvent := newEventT{
-			eventID:   guuid.New(),
+			eventID:   uuid.New(),
 			channelID: channel.uuid,
 			source: sourceT{
 				uuid: creator.uuid,
@@ -4797,18 +4797,18 @@ func test_addEventStmt() {
 
 	g.Testing("multiple messages can have the same source", func() {
 		source := sourceT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: SourceType_Logon,
 		}
 
 		newEvent1 := newEventT{
-			eventID:   guuid.New(),
+			eventID:   uuid.New(),
 			channelID: addC(add()).uuid,
 			source:    source,
 			type_:     EventType_UserMessage,
 		}
 		newEvent2 := newEventT{
-			eventID:   guuid.New(),
+			eventID:   uuid.New(),
 			channelID: addC(add()).uuid,
 			source:    source,
 			type_:     EventType_UserMessage,
@@ -4825,20 +4825,20 @@ func test_addEventStmt() {
 		payload := "a-payload"
 
 		newEvent1 := newEventT{
-			eventID:   guuid.New(),
+			eventID:   uuid.New(),
 			channelID: addC(add()).uuid,
 			source: sourceT{
-				uuid:  guuid.New(),
+				uuid:  uuid.New(),
 				type_: SourceType_Logon,
 			},
 			type_:   type_,
 			payload: payload,
 		}
 		newEvent2 := newEventT{
-			eventID:   guuid.New(),
+			eventID:   uuid.New(),
 			channelID: addC(add()).uuid,
 			source: sourceT{
-				uuid:  guuid.New(),
+				uuid:  uuid.New(),
 				type_: SourceType_Logon,
 			},
 			type_:   type_,
@@ -4903,7 +4903,7 @@ func test_eventEach() {
 
 	create := func() userT {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		user, err := createUser(newUser)
@@ -4915,11 +4915,11 @@ func test_eventEach() {
 	add := func() memberT {
 		creator := create()
 		newNetwork := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Public,
 		}
 
-		network, err := addNetwork(creator, newNetwork, guuid.New())
+		network, err := addNetwork(creator, newNetwork, uuid.New())
 		g.TErrorIf(err)
 
 		member, err := membership(creator, network)
@@ -4931,7 +4931,7 @@ func test_eventEach() {
 	addC := func(actor memberT) channelT {
 		publicName := mkstring()
 		newChannel := newChannelT{
-			uuid:        guuid.New(),
+			uuid:        uuid.New(),
 			publicName:  &publicName,
 			label:       mkstring(),
 			description: mkstring(),
@@ -4945,13 +4945,13 @@ func test_eventEach() {
 	}
 
 	eventCount := 0
-	addE := func(channelID guuid.UUID) eventT {
+	addE := func(channelID uuid.UUID) eventT {
 		eventCount++
 		newEvent := newEventT{
 			// FIXME: missing eventID?
 			channelID: channelID,
 			source: sourceT{
-				uuid:  guuid.New(),
+				uuid:  uuid.New(),
 				type_: SourceType_Logon,
 			},
 			type_: EventType_UserMessage,
@@ -4966,7 +4966,7 @@ func test_eventEach() {
 
 
 	g.Testing("callback is not called when there is no message", func() {
-		eventID := guuid.New()
+		eventID := uuid.New()
 		member  := add()
 		rows, err := allAfter(member, eventID)
 		g.TErrorIf(err)
@@ -4982,7 +4982,7 @@ func test_eventEach() {
 	g.Testing("the callback is called once for each entry", func() {
 		return // FIXME
 
-		eventID := guuid.New()
+		eventID := uuid.New()
 		member  := add()
 		channel := addC(member)
 		expected := []eventT{
@@ -5008,7 +5008,7 @@ func test_eventEach() {
 	g.Testing("it halts if a callback returns an error", func() {
 		return // FIXME
 
-		eventID := guuid.New()
+		eventID := uuid.New()
 		member  := add()
 		channel := addC(member)
 		myErr   := errors.New("callback error early return")
@@ -5099,7 +5099,7 @@ func test_allAfterStmt() {
 
 	create := func() userT {
 		newUser := newUserT{
-			uuid: guuid.New(),
+			uuid: uuid.New(),
 		}
 
 		user, err := createUser(newUser)
@@ -5111,11 +5111,11 @@ func test_allAfterStmt() {
 	add := func() memberT {
 		creator := create()
 		newNetwork := newNetworkT{
-			uuid:  guuid.New(),
+			uuid:  uuid.New(),
 			type_: NetworkType_Public,
 		}
 
-		network, err := addNetwork(creator, newNetwork, guuid.New())
+		network, err := addNetwork(creator, newNetwork, uuid.New())
 		g.TErrorIf(err)
 
 		member, err := membership(creator, network)
@@ -5127,7 +5127,7 @@ func test_allAfterStmt() {
 	addC := func(actor memberT) channelT {
 		publicName := mkstring()
 		newChannel := newChannelT{
-			uuid:        guuid.New(),
+			uuid:        uuid.New(),
 			publicName:  &publicName,
 			label:       mkstring(),
 			description: mkstring(),
@@ -5141,13 +5141,13 @@ func test_allAfterStmt() {
 	}
 
 	eventCount := 0
-	addE := func(channelID guuid.UUID) eventT {
+	addE := func(channelID uuid.UUID) eventT {
 		eventCount++
 		newEvent := newEventT{
-			eventID:   guuid.New(),
+			eventID:   uuid.New(),
 			channelID: channelID,
 			source: sourceT{
-				uuid:  guuid.New(),
+				uuid:  uuid.New(),
 				type_: SourceType_Logon,
 			},
 			type_:   EventType_UserMessage,
@@ -5161,7 +5161,7 @@ func test_allAfterStmt() {
 	}
 
 	// FIXME
-	allEvents := func(eventID guuid.UUID) []eventT {
+	allEvents := func(eventID uuid.UUID) []eventT {
 		rows, err := allAfter(memberT{}, eventID)
 		g.TErrorIf(err)
 		defer rows.Close()
@@ -5180,7 +5180,7 @@ func test_allAfterStmt() {
 	g.Testing("after joining the channel, there are no events", func() {
 		return // FIXME
 
-		eventID := guuid.New()
+		eventID := uuid.New()
 		member  := add()
 		channel := addC(member)
 
@@ -5198,7 +5198,7 @@ func test_allAfterStmt() {
 	g.Testing("we don't get events from other channels", func() {
 		return // FIXME
 
-		eventID  := guuid.New()
+		eventID  := uuid.New()
 		member   := add()
 		channel1 := addC(member)
 		channel2 := addC(member)
@@ -5219,7 +5219,7 @@ func test_allAfterStmt() {
 	g.Testing("as we change the reference point, the list changes", func() {
 		return // FIXME
 
-		eventID := guuid.New()
+		eventID := uuid.New()
 		member  := add()
 		channel := addC(member)