src/cracha.go: Add userByUUID() and refactor *Stmt() arguments

1 files changed, 201 insertions, 36 deletions

diff --git a/tests/cracha.go b/tests/cracha.go
index 905733c..eda3fea 100644
--- a/tests/cracha.go
+++ b/tests/cracha.go
@@ -2,8 +2,10 @@ package cracha
 
 import (
 	"database/sql"
+	"errors"
 	"fmt"
 	"os"
+	"reflect"
 	"time"
 
 	// "q"
@@ -51,17 +53,77 @@ func test_defaultPrefix() {
 }
 
 func test_tryRollback() {
-	// FIXME
+	g.TestStart("tryRollback()")
+
+	myErr := errors.New("bottom error")
+
+	db, err := sql.Open(golite.DriverName, golite.InMemory)
+	g.TErrorIf(err)
+	defer db.Close()
+
+
+	g.Testing("the error is propagated if rollback doesn't fail", func() {
+		tx, err := db.Begin()
+		g.TErrorIf(err)
+
+		err = tryRollback(tx, myErr)
+		g.TAssertEqual(err, myErr)
+	})
+
+	g.Testing("a wrapped error when rollback fails", func() {
+		tx, err := db.Begin()
+		g.TErrorIf(err)
+
+		err = tx.Commit()
+		g.TErrorIf(err)
+
+		err = tryRollback(tx, myErr)
+		g.TAssertEqual(reflect.DeepEqual(err, myErr), false)
+		g.TAssertEqual(errors.Is(err, myErr), true)
+	})
 }
 
 func test_inTx() {
+	g.TestStart("inTx()")
+
+	db, err := sql.Open(golite.DriverName, golite.InMemory)
+	g.TErrorIf(err)
+	defer db.Close()
+
+
+	g.Testing("when fn() errors, we propagate it", func() {
+		myErr := errors.New("to be propagated")
+		err := inTx(db, func(tx *sql.Tx) error {
+			return myErr
+		})
+		g.TAssertEqual(err, myErr)
+	})
+
+	g.Testing("no nil error we get nil", func() {
+		err := inTx(db, func(tx *sql.Tx) error {
+			return nil
+		})
+		g.TErrorIf(err)
+	})
+}
+
+func test_serialized() {
+	// FIXME
+}
+
+func test_execSerialized() {
 	// FIXME
 }
 
 func test_createTables() {
 	g.TestStart("createTables()")
 
-	db, err := sql.Open(golite.DriverName, ":memory:")
+	const (
+		prefix = defaultPrefix
+		dbpath = golite.InMemory
+	)
+
+	db, err := sql.Open(golite.DriverName, dbpath)
 	g.TErrorIf(err)
 	defer db.Close()
 
@@ -70,12 +132,12 @@ func test_createTables() {
 		const tmpl_read = `
 			SELECT id FROM "%s_users" LIMIT 1;
 		`
-		qRead := fmt.Sprintf(tmpl_read, defaultPrefix)
+		qRead := fmt.Sprintf(tmpl_read, prefix)
 
 		_, err := db.Exec(qRead)
 		g.TErrorNil(err)
 
-		err = createTables(db, defaultPrefix)
+		err = createTables(db, prefix)
 		g.TErrorIf(err)
 
 		_, err = db.Exec(qRead)
@@ -84,9 +146,9 @@ func test_createTables() {
 
 	g.Testing("we can do it multiple times", func() {
 		g.TErrorIf(g.SomeError(
-			createTables(db, defaultPrefix),
-			createTables(db, defaultPrefix),
-			createTables(db, defaultPrefix),
+			createTables(db, prefix),
+			createTables(db, prefix),
+			createTables(db, prefix),
 		))
 	})
 }
@@ -96,13 +158,19 @@ func test_registerStmt() {
 
 	const (
 		prefix = defaultPrefix
+		dbpath = golite.InMemory
 	)
 
-	db, err := sql.Open(golite.DriverName, ":memory:")
+	db, err := sql.Open(golite.DriverName, dbpath)
 	g.TErrorIf(err)
 	g.TErrorIf(createTables(db, prefix))
 
-	register, registerClose, registerErr := registerStmt(db, prefix)
+	cfg := dbconfigT{
+		shared: db,
+		dbpath: dbpath,
+		prefix: prefix,
+	}
+	register, registerClose, registerErr := registerStmt(cfg)
 	g.TErrorIf(registerErr)
 	defer g.SomeFnError(
 		registerClose,
@@ -182,14 +250,20 @@ func test_sendTokenStmt() {
 
 	const (
 		prefix = defaultPrefix
+		dbpath = golite.InMemory
 	)
 
-	db, err := sql.Open(golite.DriverName, ":memory:")
+	db, err := sql.Open(golite.DriverName, dbpath)
 	g.TErrorIf(err)
 	g.TErrorIf(createTables(db, prefix))
 
-	 register,  registerClose,  registerErr :=  registerStmt(db, prefix)
-	sendToken, sendTokenClose, sendTokenErr := sendTokenStmt(db, prefix)
+	cfg := dbconfigT{
+		shared: db,
+		dbpath: dbpath,
+		prefix: prefix,
+	}
+	 register,  registerClose,  registerErr :=  registerStmt(cfg)
+	sendToken, sendTokenClose, sendTokenErr := sendTokenStmt(cfg)
 	g.TErrorIf(g.SomeError(
 		 registerErr,
 		sendTokenErr,
@@ -288,15 +362,21 @@ func test_confirmStmt() {
 
 	const (
 		prefix = defaultPrefix
+		dbpath = golite.InMemory
 	)
 
-	db, err := sql.Open(golite.DriverName, ":memory:")
+	db, err := sql.Open(golite.DriverName, dbpath)
 	g.TErrorIf(err)
 	g.TErrorIf(createTables(db, prefix))
 
-	 register,  registerClose,  registerErr :=  registerStmt(db, prefix)
-	sendToken, sendTokenClose, sendTokenErr := sendTokenStmt(db, prefix)
-	  confirm,   confirmClose,   confirmErr :=   confirmStmt(db, prefix)
+	cfg := dbconfigT{
+		shared: db,
+		dbpath: dbpath,
+		prefix: prefix,
+	}
+	 register,  registerClose,  registerErr :=  registerStmt(cfg)
+	sendToken, sendTokenClose, sendTokenErr := sendTokenStmt(cfg)
+	  confirm,   confirmClose,   confirmErr :=   confirmStmt(cfg)
 	g.TErrorIf(g.SomeError(
 		 registerErr,
 		sendTokenErr,
@@ -377,16 +457,22 @@ func test_byEmailStmt() {
 
 	const (
 		prefix = defaultPrefix
+		dbpath = golite.InMemory
 	)
 
-	db, err := sql.Open(golite.DriverName, ":memory:")
+	db, err := sql.Open(golite.DriverName, dbpath)
 	g.TErrorIf(err)
 	g.TErrorIf(createTables(db, prefix))
 
-	 register,  registerClose,  registerErr :=  registerStmt(db, prefix)
-	sendToken, sendTokenClose, sendTokenErr := sendTokenStmt(db, prefix)
-	  confirm,   confirmClose,   confirmErr :=   confirmStmt(db, prefix)
-	  byEmail,   byEmailClose,   byEmailErr :=   byEmailStmt(db, prefix)
+	cfg := dbconfigT{
+		shared: db,
+		dbpath: dbpath,
+		prefix: prefix,
+	}
+	 register,  registerClose,  registerErr :=  registerStmt(cfg)
+	sendToken, sendTokenClose, sendTokenErr := sendTokenStmt(cfg)
+	  confirm,   confirmClose,   confirmErr :=   confirmStmt(cfg)
+	  byEmail,   byEmailClose,   byEmailErr :=   byEmailStmt(cfg)
 	g.TErrorIf(g.SomeError(
 		 registerErr,
 		sendTokenErr,
@@ -403,8 +489,7 @@ func test_byEmailStmt() {
 
 
 	g.Testing("error when not found", func() {
-		email := string(mksalt())
-		_, err := byEmail(email)
+		_, err := byEmail(string(mksalt()))
 		g.TAssertEqual(err, sql.ErrNoRows)
 	})
 
@@ -434,22 +519,95 @@ func test_byEmailStmt() {
 	})
 }
 
+func test_userByUUIDStmt() {
+	g.TestStart("userByUUIDStmt()")
+
+	const (
+		prefix = defaultPrefix
+		dbpath = golite.InMemory
+	)
+
+	db, err := sql.Open(golite.DriverName, dbpath)
+	g.TErrorIf(err)
+	g.TErrorIf(createTables(db, prefix))
+
+	cfg := dbconfigT{
+		shared: db,
+		dbpath: dbpath,
+		prefix: prefix,
+	}
+	  register,   registerClose,   registerErr :=   registerStmt(cfg)
+	 sendToken,  sendTokenClose,  sendTokenErr :=  sendTokenStmt(cfg)
+	   confirm,    confirmClose,    confirmErr :=    confirmStmt(cfg)
+	userByUUID, userByUUIDClose, userByUUIDErr := userByUUIDStmt(cfg)
+	g.TErrorIf(g.SomeError(
+		  registerErr,
+		 sendTokenErr,
+		   confirmErr,
+		userByUUIDErr,
+	))
+	defer g.SomeFnError(
+		  registerClose,
+		 sendTokenClose,
+		   confirmClose,
+		userByUUIDClose,
+		       db.Close,
+	)
+
+
+	g.Testing("error when not found", func() {
+		_, err := userByUUID(guuid.New())
+		g.TAssertEqual(err, sql.ErrNoRows)
+	})
+
+	g.Testing("full user otherwise, confirmed or not", func() {
+		u := newUser()
+
+		_, err := register(u.userID, u.email, u.salt, u.pwhash)
+		g.TErrorIf(err)
+
+		user1, err := userByUUID(u.userID)
+		g.TErrorIf(err)
+
+		g.TErrorIf(sendToken(u.userID, u.token))
+
+		user2, err := userByUUID(u.userID)
+		g.TErrorIf(err)
+
+		_, err = confirm(u.token, guuid.New())
+		g.TErrorIf(err)
+
+		user3, err := userByUUID(u.userID)
+		g.TErrorIf(err)
+
+		g.TAssertEqual(user1, user2)
+		user2.confirmed = true
+		g.TAssertEqual(user2, user3)
+	})
+}
+
 func test_loginStmt() {
 	g.TestStart("loginStmt()")
 
 	const (
 		prefix = defaultPrefix
+		dbpath = golite.InMemory
 	)
 
-	db, err := sql.Open(golite.DriverName, ":memory:")
+	db, err := sql.Open(golite.DriverName, dbpath)
 	g.TErrorIf(err)
 	g.TErrorIf(createTables(db, prefix))
 
-	 register,  registerClose,  registerErr :=  registerStmt(db, prefix)
-	sendToken, sendTokenClose, sendTokenErr := sendTokenStmt(db, prefix)
-	  confirm,   confirmClose,   confirmErr :=   confirmStmt(db, prefix)
-	  byEmail,   byEmailClose,   byEmailErr :=   byEmailStmt(db, prefix)
-	    login,     loginClose,     loginErr :=     loginStmt(db, prefix)
+	cfg := dbconfigT{
+		shared: db,
+		dbpath: dbpath,
+		prefix: prefix,
+	}
+	 register,  registerClose,  registerErr :=  registerStmt(cfg)
+	sendToken, sendTokenClose, sendTokenErr := sendTokenStmt(cfg)
+	  confirm,   confirmClose,   confirmErr :=   confirmStmt(cfg)
+	  byEmail,   byEmailClose,   byEmailErr :=   byEmailStmt(cfg)
+	    login,     loginClose,     loginErr :=     loginStmt(cfg)
 	g.TErrorIf(g.SomeError(
 		 registerErr,
 		sendTokenErr,
@@ -577,18 +735,24 @@ func test_refreshStmt() {
 
 	const (
 		prefix = defaultPrefix
+		dbpath = golite.InMemory
 	)
 
-	db, err := sql.Open(golite.DriverName, ":memory:")
+	db, err := sql.Open(golite.DriverName, dbpath)
 	g.TErrorIf(err)
 	g.TErrorIf(createTables(db, prefix))
 
-	 register,  registerClose,  registerErr :=  registerStmt(db, prefix)
-	sendToken, sendTokenClose, sendTokenErr := sendTokenStmt(db, prefix)
-	  confirm,   confirmClose,   confirmErr :=   confirmStmt(db, prefix)
-	  byEmail,   byEmailClose,   byEmailErr :=   byEmailStmt(db, prefix)
-	    login,     loginClose,     loginErr :=     loginStmt(db, prefix)
-	  refresh,   refreshClose,   refreshErr :=   refreshStmt(db, prefix)
+	cfg := dbconfigT{
+		shared: db,
+		dbpath: dbpath,
+		prefix: prefix,
+	}
+	 register,  registerClose,  registerErr :=  registerStmt(cfg)
+	sendToken, sendTokenClose, sendTokenErr := sendTokenStmt(cfg)
+	  confirm,   confirmClose,   confirmErr :=   confirmStmt(cfg)
+	  byEmail,   byEmailClose,   byEmailErr :=   byEmailStmt(cfg)
+	    login,     loginClose,     loginErr :=     loginStmt(cfg)
+	  refresh,   refreshClose,   refreshErr :=   refreshStmt(cfg)
 	g.TErrorIf(g.SomeError(
 		 registerErr,
 		sendTokenErr,
@@ -890,6 +1054,7 @@ func MainTest() {
 	test_sendTokenStmt()
 	test_confirmStmt()
 	test_byEmailStmt()
+	test_userByUUIDStmt()
 	test_loginStmt()
 	test_refreshStmt()
 	test_resetStmt()