From 962f811e46efc95c6050a6a49b47709603abaeb7 Mon Sep 17 00:00:00 2001 From: EuAndreh Date: Sun, 27 Oct 2024 09:06:04 -0300 Subject: Rename gracha -> cracha --- tests/benchmarks/register-login/cracha.go | 23 + tests/benchmarks/register-login/gracha.go | 9 - tests/cracha.go | 935 ++++++++++++++++++++++++++++++ tests/functional/register-twice/cracha.go | 12 + tests/functional/register-twice/gracha.go | 9 - tests/fuzz/api/cracha.go | 35 ++ tests/fuzz/api/gracha.go | 35 -- tests/gracha.go | 935 ------------------------------ tests/main.go | 4 +- tests/queries.sql | 92 +-- 10 files changed, 1053 insertions(+), 1036 deletions(-) create mode 100644 tests/benchmarks/register-login/cracha.go delete mode 100644 tests/benchmarks/register-login/gracha.go create mode 100644 tests/cracha.go create mode 100644 tests/functional/register-twice/cracha.go delete mode 100644 tests/functional/register-twice/gracha.go create mode 100644 tests/fuzz/api/cracha.go delete mode 100644 tests/fuzz/api/gracha.go delete mode 100644 tests/gracha.go (limited to 'tests') diff --git a/tests/benchmarks/register-login/cracha.go b/tests/benchmarks/register-login/cracha.go new file mode 100644 index 0000000..55f8166 --- /dev/null +++ b/tests/benchmarks/register-login/cracha.go @@ -0,0 +1,23 @@ +package cracha + +import ( + "flag" + "time" +) + + + +var nFlag = flag.Int( + "n", + 1_000, + "The number of iterations to execute", +) + +func MainTest() { + flag.Parse() + n := *nFlag + + for i := 0; i < n; i++ { + time.Sleep(time.Millisecond * 1) + } +} diff --git a/tests/benchmarks/register-login/gracha.go b/tests/benchmarks/register-login/gracha.go deleted file mode 100644 index f363b6b..0000000 --- a/tests/benchmarks/register-login/gracha.go +++ /dev/null @@ -1,9 +0,0 @@ -package gracha - -import ( -) - - - -func MainTest() { -} diff --git a/tests/cracha.go b/tests/cracha.go new file mode 100644 index 0000000..905733c --- /dev/null +++ b/tests/cracha.go @@ -0,0 +1,935 @@ +package cracha + +import ( + "database/sql" + "fmt" + "os" + "time" + + // "q" + "golite" + "guuid" + "scrypt" + g "gobang" +) + + + +type userDataT struct{ + userID guuid.UUID + email string + salt []byte + pwhash []byte + token string +} + + + +func mksalt() []byte { + salt, err := scrypt.Salt() + g.TErrorIf(err) + return salt +} + +func newUser() userDataT { + return userDataT{ + userID: guuid.New(), + email: string(mksalt()), + salt: mksalt(), + pwhash: mksalt(), + token: string(mksalt()), + } +} + + +func test_defaultPrefix() { + g.TestStart("defaultPrefix") + + g.Testing("the defaultPrefix is valid", func() { + g.TErrorIf(g.ValidateSQLTablePrefix(defaultPrefix)) + }) +} + +func test_tryRollback() { + // FIXME +} + +func test_inTx() { + // FIXME +} + +func test_createTables() { + g.TestStart("createTables()") + + db, err := sql.Open(golite.DriverName, ":memory:") + g.TErrorIf(err) + defer db.Close() + + + g.Testing("tables exist afterwards", func() { + const tmpl_read = ` + SELECT id FROM "%s_users" LIMIT 1; + ` + qRead := fmt.Sprintf(tmpl_read, defaultPrefix) + + _, err := db.Exec(qRead) + g.TErrorNil(err) + + err = createTables(db, defaultPrefix) + g.TErrorIf(err) + + _, err = db.Exec(qRead) + g.TErrorIf(err) + }) + + g.Testing("we can do it multiple times", func() { + g.TErrorIf(g.SomeError( + createTables(db, defaultPrefix), + createTables(db, defaultPrefix), + createTables(db, defaultPrefix), + )) + }) +} + +func test_registerStmt() { + g.TestStart("registerStmt()") + + const ( + prefix = defaultPrefix + ) + + db, err := sql.Open(golite.DriverName, ":memory:") + g.TErrorIf(err) + g.TErrorIf(createTables(db, prefix)) + + register, registerClose, registerErr := registerStmt(db, prefix) + g.TErrorIf(registerErr) + defer g.SomeFnError( + registerClose, + db.Close, + ) + + + g.Testing("we can register a user", func() { + u := newUser() + user, err := register(u.userID, u.email, u.salt, u.pwhash) + g.TErrorIf(err) + + g.TAssertEqual(user.timestamp == time.Time{}, false) + g.TAssertEqual(user.id, int64(1)) + g.TAssertEqual(user.uuid, u.userID) + g.TAssertEqual(user.email, u.email) + g.TAssertEqual(user.salt, u.salt) + g.TAssertEqual(user.pwhash, u.pwhash) + }) + + g.Testing("users can't have the same uuid", func() { + u1 := newUser() + u2 := newUser() + userID := guuid.New() + + _, err1 := register(userID, u1.email, u1.salt, u1.pwhash) + _, err2 := register(userID, u2.email, u2.salt, u2.pwhash) + + g.TErrorIf(err1) + g.TAssertEqual( + err2.(golite.Error).ExtendedCode, + golite.ErrConstraintUnique, + ) + }) + + g.Testing("users can't have the same email", func() { + u1 := newUser() + u2 := newUser() + email := string(mksalt()) + + _, err1 := register(u1.userID, email, u1.salt, u1.pwhash) + _, err2 := register(u2.userID, email, u2.salt, u2.pwhash) + + g.TErrorIf(err1) + g.TAssertEqual( + err2.(golite.Error).ExtendedCode, + golite.ErrConstraintUnique, + ) + }) + + g.Testing("users can't have the same salt", func() { + u1 := newUser() + u2 := newUser() + salt := mksalt() + + _, err1 := register(u1.userID, u1.email, salt, u1.pwhash) + _, err2 := register(u2.userID, u2.email, salt, u2.pwhash) + + g.TErrorIf(err1) + g.TAssertEqual( + err2.(golite.Error).ExtendedCode, + golite.ErrConstraintUnique, + ) + }) + + g.Testing("no error when close()ing more than once", func() { + g.TErrorIf(g.SomeError( + registerClose(), + registerClose(), + registerClose(), + )) + }) +} + +func test_sendTokenStmt() { + g.TestStart("sendToken()") + + const ( + prefix = defaultPrefix + ) + + db, err := sql.Open(golite.DriverName, ":memory:") + g.TErrorIf(err) + g.TErrorIf(createTables(db, prefix)) + + register, registerClose, registerErr := registerStmt(db, prefix) + sendToken, sendTokenClose, sendTokenErr := sendTokenStmt(db, prefix) + g.TErrorIf(g.SomeError( + registerErr, + sendTokenErr, + )) + defer g.SomeFnError( + registerClose, + sendTokenClose, + db.Close, + ) + + + g.Testing("can't send a token to a non-existent user", func() { + err := sendToken(guuid.New(), "some token") + g.TAssertEqual( + err.(golite.Error).ExtendedCode, + golite.ErrConstraintNotNull, + ) + }) + + g.Testing("otherwise creates the confirmation attempt", func() { + u := newUser() + + _, err := register(u.userID, u.email, u.salt, u.pwhash) + g.TErrorIf(err) + + err = sendToken(u.userID, u.token) + g.TErrorIf(err) + }) + + g.Testing("token has to be unique globally", func() { + u1 := newUser() + u2 := newUser() + token := string(mksalt()) + + _, err := register(u1.userID, u1.email, u1.salt, u1.pwhash) + g.TErrorIf(err) + _, err = register(u2.userID, u2.email, u2.salt, u2.pwhash) + g.TErrorIf(err) + + err1 := sendToken(u1.userID, token) + err2 := sendToken(u2.userID, token) + g.TErrorIf(err1) + g.TAssertEqual( + err2.(golite.Error).ExtendedCode, + golite.ErrConstraintUnique, + ) + }) + + g.Testing("a user can have multiple", func() { + u := newUser() + token1 := string(mksalt()) + token2 := string(mksalt()) + token3 := string(mksalt()) + + _, err := register(u.userID, u.email, u.salt, u.pwhash) + g.TErrorIf(err) + + g.TErrorIf(g.SomeError( + sendToken(u.userID, token1), + sendToken(u.userID, token2), + sendToken(u.userID, token3), + )) + + tokens := []string{} + const tmpl_read = ` + SELECT token from "%s_confirmation_attempts" + WHERE user_id = ( + SELECT id FROM "%s_users" + WHERE uuid = ? + ) + ORDER BY id ASC; + ` + qRead := fmt.Sprintf(tmpl_read, prefix, prefix) + rows, err := db.Query(qRead, u.userID[:]) + g.TErrorIf(err) + + for rows.Next() { + var token string + err := rows.Scan(&token) + g.TErrorIf(err) + tokens = append(tokens, token) + } + g.TErrorIf(g.SomeFnError(rows.Err, rows.Close)) + + expected := []string{ + token1, + token2, + token3, + } + g.TAssertEqual(tokens, expected) + }) +} + +func test_confirmStmt() { + g.TestStart("confirmStmt()") + + const ( + prefix = defaultPrefix + ) + + db, err := sql.Open(golite.DriverName, ":memory:") + 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) + g.TErrorIf(g.SomeError( + registerErr, + sendTokenErr, + confirmErr, + )) + defer g.SomeFnError( + registerClose, + sendTokenClose, + confirmClose, + db.Close, + ) + + + g.Testing("can't confirm a token that doesn't exist", func() { + _, err := confirm(string(mksalt()), guuid.New()) + g.TAssertEqual(err, sql.ErrNoRows) + }) + + g.Testing("otherwise it creates a confirmation and a session", func() { + u := newUser() + sessionID := guuid.New() + + _, err := register(u.userID, u.email, u.salt, u.pwhash) + g.TErrorIf(err) + + g.TErrorIf(sendToken(u.userID, u.token)) + + session, err := confirm(u.token, sessionID) + g.TErrorIf(err) + + g.TAssertEqual(session.timestamp == time.Time{}, false) + g.TAssertEqual(session.uuid, sessionID) + g.TAssertEqual(session.userID, u.userID) + }) + + g.Testing("can't confirm the same token twice", func() { + u := newUser() + + _, err := register(u.userID, u.email, u.salt, u.pwhash) + g.TErrorIf(err) + + g.TErrorIf(sendToken(u.userID, u.token)) + + _, err1 := confirm(u.token, guuid.New()) + _, err2 := confirm(u.token, guuid.New()) + g.TErrorIf(err1) + g.TAssertEqual( + err2.(golite.Error).ExtendedCode, + golite.ErrConstraintUnique, + ) + }) + + g.Testing("a user can't have 2 confirmations", func() { + u := newUser() + token1 := string(mksalt()) + token2 := string(mksalt()) + + _, err := register(u.userID, u.email, u.salt, u.pwhash) + g.TErrorIf(err) + + g.TErrorIf(g.SomeError( + sendToken(u.userID, token1), + sendToken(u.userID, token2), + )) + + _, err1 := confirm(token1, guuid.New()) + _, err2 := confirm(token2, guuid.New()) + g.TErrorIf(err1) + g.TAssertEqual( + err2.(golite.Error).ExtendedCode, + golite.ErrConstraintUnique, + ) + }) +} + +func test_byEmailStmt() { + g.TestStart("byEmailStmt()") + + const ( + prefix = defaultPrefix + ) + + db, err := sql.Open(golite.DriverName, ":memory:") + 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) + g.TErrorIf(g.SomeError( + registerErr, + sendTokenErr, + confirmErr, + byEmailErr, + )) + defer g.SomeFnError( + registerClose, + sendTokenClose, + confirmClose, + byEmailClose, + db.Close, + ) + + + g.Testing("error when not found", func() { + email := string(mksalt()) + _, err := byEmail(email) + 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 := byEmail(u.email) + g.TErrorIf(err) + + g.TErrorIf(sendToken(u.userID, u.token)) + + user2, err := byEmail(u.email) + g.TErrorIf(err) + + _, err = confirm(u.token, guuid.New()) + g.TErrorIf(err) + + user3, err := byEmail(u.email) + g.TErrorIf(err) + + g.TAssertEqual(user1, user2) + user2.confirmed = true + g.TAssertEqual(user2, user3) + }) +} + +func test_loginStmt() { + g.TestStart("loginStmt()") + + const ( + prefix = defaultPrefix + ) + + db, err := sql.Open(golite.DriverName, ":memory:") + 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) + g.TErrorIf(g.SomeError( + registerErr, + sendTokenErr, + confirmErr, + byEmailErr, + loginErr, + )) + defer g.SomeFnError( + registerClose, + sendTokenClose, + confirmClose, + byEmailClose, + loginClose, + db.Close, + ) + + + g.Testing("a user must exist to login", func() { + _, err := login(guuid.New(), guuid.New()) + g.TAssertEqual( + err.(golite.Error).ExtendedCode, + golite.ErrConstraintNotNull, + ) + }) + + g.Testing("sessionID must be unique globally", func() { + u1 := newUser() + u2 := newUser() + sessionID := guuid.New() + + _, err := register(u1.userID, u1.email, u1.salt, u1.pwhash) + g.TErrorIf(err) + _, err = register(u2.userID, u2.email, u2.salt, u2.pwhash) + g.TErrorIf(err) + + _, err1 := login(u1.userID, sessionID) + _, err2 := login(u1.userID, sessionID) + _, err3 := login(u2.userID, sessionID) + + g.TErrorIf(err1) + g.TAssertEqual( + err2.(golite.Error).ExtendedCode, + golite.ErrConstraintUnique, + ) + g.TAssertEqual( + err3.(golite.Error).ExtendedCode, + golite.ErrConstraintUnique, + ) + }) + + g.Testing("a user can have multiple active sessions", func() { + u := newUser() + sessionID1 := guuid.New() + sessionID2 := guuid.New() + + _, err := register(u.userID, u.email, u.salt, u.pwhash) + g.TErrorIf(err) + + session1, err := login(u.userID, sessionID1) + g.TErrorIf(err) + + session2, err := login(u.userID, sessionID2) + g.TErrorIf(err) + + g.TAssertEqual(session1.uuid, sessionID1) + g.TAssertEqual(session2.uuid, sessionID2) + g.TAssertEqual(session1.userID, u.userID) + g.TAssertEqual(session2.userID, u.userID) + }) + + g.Testing("multiple users can be logged in", func() { + u1 := newUser() + u2 := newUser() + sessionID1 := guuid.New() + sessionID2 := guuid.New() + + _, err := register(u1.userID, u1.email, u1.salt, u1.pwhash) + g.TErrorIf(err) + _, err = register(u2.userID, u2.email, u2.salt, u2.pwhash) + g.TErrorIf(err) + + session1, err := login(u1.userID, sessionID1) + g.TErrorIf(err) + session2, err := login(u2.userID, sessionID2) + g.TErrorIf(err) + + g.TAssertEqual(session1.uuid, sessionID1) + g.TAssertEqual(session2.uuid, sessionID2) + g.TAssertEqual(session1.userID, u1.userID) + g.TAssertEqual(session2.userID, u2.userID) + }) + + g.Testing("an unconfirmed user is allowed to login", func() { + u := newUser() + + _, err := register(u.userID, u.email, u.salt, u.pwhash) + g.TErrorIf(err) + + _, err = login(u.userID, guuid.New()) + g.TErrorIf(err) + }) + + g.Testing("a confirmed user is allowed to login, too", func() { + u := newUser() + + _, err := register(u.userID, u.email, u.salt, u.pwhash) + g.TErrorIf(err) + + g.TErrorIf(sendToken(u.userID, u.token)) + + _, err = confirm(u.token, guuid.New()) + g.TErrorIf(err) + + user, err := byEmail(u.email) + g.TErrorIf(err) + g.TAssertEqual(user.confirmed, true) + + _, err = login(u.userID, guuid.New()) + g.TErrorIf(err) + }) +} + +func test_refreshStmt() { + g.TestStart("refreshStmt()") + + const ( + prefix = defaultPrefix + ) + + db, err := sql.Open(golite.DriverName, ":memory:") + 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) + g.TErrorIf(g.SomeError( + registerErr, + sendTokenErr, + confirmErr, + byEmailErr, + loginErr, + refreshErr, + )) + defer g.SomeFnError( + registerClose, + sendTokenClose, + confirmClose, + byEmailClose, + loginClose, + refreshClose, + db.Close, + ) + + reg := func(u userDataT) userT { + user, err := register(u.userID, u.email, u.salt, u.pwhash) + g.TErrorIf(err) + return user + } + + conf := func(u userDataT) sessionT { + err := sendToken(u.userID, u.token) + g.TErrorIf(err) + + session, err := confirm(u.token, guuid.New()) + g.TErrorIf(err) + return session + } + + + g.Testing("a session needs to exist be be refreshed", func() { + _, err := refresh(guuid.New(), guuid.New()) + g.TAssertEqual( + err.(golite.Error).ExtendedCode, + golite.ErrConstraintNotNull, + ) + }) + + g.Testing("we can refresh the session of an unconfirmed user", func() { + u := newUser() + sessionID1 := guuid.New() + sessionID2 := guuid.New() + + reg(u) + + session1, err := login(u.userID, sessionID1) + g.TErrorIf(err) + + user, err := byEmail(u.email) + g.TErrorIf(err) + g.TAssertEqual(user.confirmed, false) + + session2, err := refresh(sessionID1, sessionID2) + g.TErrorIf(err) + + g.TAssertEqual(session1.userID, u.userID) + g.TAssertEqual(session1.userID, session2.userID) + g.TAssertEqual(session1.uuid, sessionID1) + g.TAssertEqual(session2.uuid, sessionID2) + g.TAssertEqual(session1.timestamp == time.Time{}, false) + g.TAssertEqual(session2.timestamp == time.Time{}, false) + }) + + g.Testing("we can refresh the session of a confirmed user", func() { + u := newUser() + sessionID1 := guuid.New() + sessionID2 := guuid.New() + + reg(u) + session1 := conf(u) + + user, err := byEmail(u.email) + g.TErrorIf(err) + g.TAssertEqual(user.confirmed, true) + + // FIXME + return + + session2, err := refresh(sessionID1, sessionID2) + g.TErrorIf(err) + + g.TAssertEqual(session1.userID, u.userID) + g.TAssertEqual(session1.userID, session2.userID) + g.TAssertEqual(session1.uuid, sessionID1) + g.TAssertEqual(session2.uuid, sessionID2) + }) + + g.Testing("we can't refresh an expired session", func() { + }) + + g.Testing("the sessionID can't be reused, even across users", func() { + }) + // FIXME +} + +func test_resetStmt() { + // FIXME +} + +func test_changeStmt() { + // FIXME +} + +func test_byUUIDStmt() { + // FIXME +} + +func test_logoutStmt() { + // FIXME +} + +func test_outOthersStmt() { + // FIXME +} + +func test_outAllStmt() { + // FIXME +} + +func test_initDB() { + // FIXME +} + +func test_queriesTclose() { + // FIXME +} + +func test_newUserHandler() { + // FIXME +} + +func test_sendConfirmationRequestHandler() { + // FIXME +} + +func test_forgotPasswordRequestHandler() { + // FIXME +} + +func test_registerConsumers() { + // FIXME +} + +func test_unregisterConsumers() { + // FIXME +} + +func test_startRunner() { + // FIXME +} + +func test_makePoolRunner() { + // FIXME +} + +func test_asResult() { + // FIXME +} + +func test_unwrapResult() { + // FIXME +} + +func test_NewWithPrefix() { + // FIXME +} + +func test_New() { + // FIXME +} + +func test_newUserPayload() { + // FIXME +} + +func test_authT_Register() { + // FIXME +} + +func test_sendConfirmationMessage() { + // FIXME +} + +func test_authT_ResentConfirmation() { + // FIXME +} + +func test_authT_ConfirmEmail() { + // FIXME +} + +func test_authT_LoginEmail() { + // FIXME +} + +func test_forgotPasswordMessage() { + // FIXME +} + +func test_authT_ForgotPassword() { + // FIXME +} + +func test_checkSession() { + // FIXME +} + +func test_validateSession() { + // FIXME +} + +func test_authT_Refresh() { + // FIXME +} + +func test_authT_ResetPassword() { + // FIXME +} + +func test_authT_ChangePassword() { + // FIXME +} + +func test_runLogout() { + // FIXME +} + +func test_authT_Logout() { + // FIXME +} + +func test_authT_LogoutOthers() { + // FIXME +} + +func test_authT_LogoutAll() { + // FIXME +} + +func test_authT_Close() { + // FIXME +} + +func test_usage() { + // FIXME +} + +func test_getopt() { + // FIXME +} + +func test_runCommand() { + // FIXME +} + + +func dumpQueries() { + queries := []struct{name string; fn func(string) queryT}{ + { "createTables", createTablesSQL }, + { "byEmail", byEmailSQL }, + { "register", registerSQL }, + { "sendToken", sendTokenSQL }, + { "confirm", confirmSQL }, + { "login", loginSQL }, + { "refresh", refreshSQL }, + { "reset", resetSQL }, + { "change", changeSQL }, + { "byUUID", byUUIDSQL }, + { "logout", logoutSQL }, + { "outOthers", outOthersSQL }, + { "outAll", outAllSQL }, + } + for _, query := range queries { + q := query.fn(defaultPrefix) + fmt.Printf("\n-- %s.sql:", query.name) + fmt.Printf("\n-- write:%s\n", q.write) + fmt.Printf("\n-- read:%s\n", q.read) + } +} + + + +func MainTest() { + if os.Getenv("TESTING_DUMP_SQL_QUERIES") != "" { + dumpQueries() + return + } + + g.Init() + test_defaultPrefix() + test_tryRollback() + test_inTx() + test_createTables() + test_registerStmt() + test_sendTokenStmt() + test_confirmStmt() + test_byEmailStmt() + test_loginStmt() + test_refreshStmt() + test_resetStmt() + test_changeStmt() + test_byUUIDStmt() + test_logoutStmt() + test_outOthersStmt() + test_outAllStmt() + test_initDB() + test_queriesTclose() + test_newUserHandler() + test_sendConfirmationRequestHandler() + test_forgotPasswordRequestHandler() + test_registerConsumers() + test_unregisterConsumers() + test_startRunner() + test_makePoolRunner() + test_asResult() + test_unwrapResult() + test_NewWithPrefix() + test_New() + test_newUserPayload() + test_authT_Register() + test_sendConfirmationMessage() + test_authT_ResentConfirmation() + test_authT_ConfirmEmail() + test_authT_LoginEmail() + test_forgotPasswordMessage() + test_authT_ForgotPassword() + test_checkSession() + test_validateSession() + test_authT_Refresh() + test_authT_ResetPassword() + test_authT_ChangePassword() + test_runLogout() + test_authT_Logout() + test_authT_LogoutOthers() + test_authT_LogoutAll() + test_authT_Close() + test_usage() + test_getopt() + test_runCommand() +} diff --git a/tests/functional/register-twice/cracha.go b/tests/functional/register-twice/cracha.go new file mode 100644 index 0000000..0885c9d --- /dev/null +++ b/tests/functional/register-twice/cracha.go @@ -0,0 +1,12 @@ +package cracha + +import ( + g "gobang" +) + + + +func MainTest() { + g.Testing("with adjusted emails, one can register twice", func() { + }) +} diff --git a/tests/functional/register-twice/gracha.go b/tests/functional/register-twice/gracha.go deleted file mode 100644 index f363b6b..0000000 --- a/tests/functional/register-twice/gracha.go +++ /dev/null @@ -1,9 +0,0 @@ -package gracha - -import ( -) - - - -func MainTest() { -} diff --git a/tests/fuzz/api/cracha.go b/tests/fuzz/api/cracha.go new file mode 100644 index 0000000..8775cd3 --- /dev/null +++ b/tests/fuzz/api/cracha.go @@ -0,0 +1,35 @@ +package cracha + +import ( + "os" + "testing" + "testing/internal/testdeps" +) + + + +func api(f *testing.F) { + f.Fuzz(func(t *testing.T, n int) { + // FIXME + if n > 1 { + if n < 2 { + t.Errorf("Failed n: %v\n", n) + } + } + }) +} + + + +func MainTest() { + fuzzTargets := []testing.InternalFuzzTarget{ + { "api", api }, + } + + deps := testdeps.TestDeps{} + tests := []testing.InternalTest {} + benchmarks := []testing.InternalBenchmark{} + examples := []testing.InternalExample {} + m := testing.MainStart(deps, tests, benchmarks, fuzzTargets, examples) + os.Exit(m.Run()) +} diff --git a/tests/fuzz/api/gracha.go b/tests/fuzz/api/gracha.go deleted file mode 100644 index 6f2981a..0000000 --- a/tests/fuzz/api/gracha.go +++ /dev/null @@ -1,35 +0,0 @@ -package gracha - -import ( - "os" - "testing" - "testing/internal/testdeps" -) - - - -func api(f *testing.F) { - f.Fuzz(func(t *testing.T, n int) { - // FIXME - if n > 1 { - if n < 2 { - t.Errorf("Failed n: %v\n", n) - } - } - }) -} - - - -func MainTest() { - fuzzTargets := []testing.InternalFuzzTarget{ - { "api", api }, - } - - deps := testdeps.TestDeps{} - tests := []testing.InternalTest {} - benchmarks := []testing.InternalBenchmark{} - examples := []testing.InternalExample {} - m := testing.MainStart(deps, tests, benchmarks, fuzzTargets, examples) - os.Exit(m.Run()) -} diff --git a/tests/gracha.go b/tests/gracha.go deleted file mode 100644 index 6991e56..0000000 --- a/tests/gracha.go +++ /dev/null @@ -1,935 +0,0 @@ -package gracha - -import ( - "database/sql" - "fmt" - "os" - "time" - - // "q" - "golite" - "guuid" - "scrypt" - g "gobang" -) - - - -type userDataT struct{ - userID guuid.UUID - email string - salt []byte - pwhash []byte - token string -} - - - -func mksalt() []byte { - salt, err := scrypt.Salt() - g.TErrorIf(err) - return salt -} - -func newUser() userDataT { - return userDataT{ - userID: guuid.New(), - email: string(mksalt()), - salt: mksalt(), - pwhash: mksalt(), - token: string(mksalt()), - } -} - - -func test_defaultPrefix() { - g.TestStart("defaultPrefix") - - g.Testing("the defaultPrefix is valid", func() { - g.TErrorIf(g.ValidateSQLTablePrefix(defaultPrefix)) - }) -} - -func test_tryRollback() { - // FIXME -} - -func test_inTx() { - // FIXME -} - -func test_createTables() { - g.TestStart("createTables()") - - db, err := sql.Open(golite.DriverName, ":memory:") - g.TErrorIf(err) - defer db.Close() - - - g.Testing("tables exist afterwards", func() { - const tmpl_read = ` - SELECT id FROM "%s_users" LIMIT 1; - ` - qRead := fmt.Sprintf(tmpl_read, defaultPrefix) - - _, err := db.Exec(qRead) - g.TErrorNil(err) - - err = createTables(db, defaultPrefix) - g.TErrorIf(err) - - _, err = db.Exec(qRead) - g.TErrorIf(err) - }) - - g.Testing("we can do it multiple times", func() { - g.TErrorIf(g.SomeError( - createTables(db, defaultPrefix), - createTables(db, defaultPrefix), - createTables(db, defaultPrefix), - )) - }) -} - -func test_registerStmt() { - g.TestStart("registerStmt()") - - const ( - prefix = defaultPrefix - ) - - db, err := sql.Open(golite.DriverName, ":memory:") - g.TErrorIf(err) - g.TErrorIf(createTables(db, prefix)) - - register, registerClose, registerErr := registerStmt(db, prefix) - g.TErrorIf(registerErr) - defer g.SomeFnError( - registerClose, - db.Close, - ) - - - g.Testing("we can register a user", func() { - u := newUser() - user, err := register(u.userID, u.email, u.salt, u.pwhash) - g.TErrorIf(err) - - g.TAssertEqual(user.timestamp == time.Time{}, false) - g.TAssertEqual(user.id, int64(1)) - g.TAssertEqual(user.uuid, u.userID) - g.TAssertEqual(user.email, u.email) - g.TAssertEqual(user.salt, u.salt) - g.TAssertEqual(user.pwhash, u.pwhash) - }) - - g.Testing("users can't have the same uuid", func() { - u1 := newUser() - u2 := newUser() - userID := guuid.New() - - _, err1 := register(userID, u1.email, u1.salt, u1.pwhash) - _, err2 := register(userID, u2.email, u2.salt, u2.pwhash) - - g.TErrorIf(err1) - g.TAssertEqual( - err2.(golite.Error).ExtendedCode, - golite.ErrConstraintUnique, - ) - }) - - g.Testing("users can't have the same email", func() { - u1 := newUser() - u2 := newUser() - email := string(mksalt()) - - _, err1 := register(u1.userID, email, u1.salt, u1.pwhash) - _, err2 := register(u2.userID, email, u2.salt, u2.pwhash) - - g.TErrorIf(err1) - g.TAssertEqual( - err2.(golite.Error).ExtendedCode, - golite.ErrConstraintUnique, - ) - }) - - g.Testing("users can't have the same salt", func() { - u1 := newUser() - u2 := newUser() - salt := mksalt() - - _, err1 := register(u1.userID, u1.email, salt, u1.pwhash) - _, err2 := register(u2.userID, u2.email, salt, u2.pwhash) - - g.TErrorIf(err1) - g.TAssertEqual( - err2.(golite.Error).ExtendedCode, - golite.ErrConstraintUnique, - ) - }) - - g.Testing("no error when close()ing more than once", func() { - g.TErrorIf(g.SomeError( - registerClose(), - registerClose(), - registerClose(), - )) - }) -} - -func test_sendTokenStmt() { - g.TestStart("sendToken()") - - const ( - prefix = defaultPrefix - ) - - db, err := sql.Open(golite.DriverName, ":memory:") - g.TErrorIf(err) - g.TErrorIf(createTables(db, prefix)) - - register, registerClose, registerErr := registerStmt(db, prefix) - sendToken, sendTokenClose, sendTokenErr := sendTokenStmt(db, prefix) - g.TErrorIf(g.SomeError( - registerErr, - sendTokenErr, - )) - defer g.SomeFnError( - registerClose, - sendTokenClose, - db.Close, - ) - - - g.Testing("can't send a token to a non-existent user", func() { - err := sendToken(guuid.New(), "some token") - g.TAssertEqual( - err.(golite.Error).ExtendedCode, - golite.ErrConstraintNotNull, - ) - }) - - g.Testing("otherwise creates the confirmation attempt", func() { - u := newUser() - - _, err := register(u.userID, u.email, u.salt, u.pwhash) - g.TErrorIf(err) - - err = sendToken(u.userID, u.token) - g.TErrorIf(err) - }) - - g.Testing("token has to be unique globally", func() { - u1 := newUser() - u2 := newUser() - token := string(mksalt()) - - _, err := register(u1.userID, u1.email, u1.salt, u1.pwhash) - g.TErrorIf(err) - _, err = register(u2.userID, u2.email, u2.salt, u2.pwhash) - g.TErrorIf(err) - - err1 := sendToken(u1.userID, token) - err2 := sendToken(u2.userID, token) - g.TErrorIf(err1) - g.TAssertEqual( - err2.(golite.Error).ExtendedCode, - golite.ErrConstraintUnique, - ) - }) - - g.Testing("a user can have multiple", func() { - u := newUser() - token1 := string(mksalt()) - token2 := string(mksalt()) - token3 := string(mksalt()) - - _, err := register(u.userID, u.email, u.salt, u.pwhash) - g.TErrorIf(err) - - g.TErrorIf(g.SomeError( - sendToken(u.userID, token1), - sendToken(u.userID, token2), - sendToken(u.userID, token3), - )) - - tokens := []string{} - const tmpl_read = ` - SELECT token from "%s_confirmation_attempts" - WHERE user_id = ( - SELECT id FROM "%s_users" - WHERE uuid = ? - ) - ORDER BY id ASC; - ` - qRead := fmt.Sprintf(tmpl_read, prefix, prefix) - rows, err := db.Query(qRead, u.userID[:]) - g.TErrorIf(err) - - for rows.Next() { - var token string - err := rows.Scan(&token) - g.TErrorIf(err) - tokens = append(tokens, token) - } - g.TErrorIf(g.SomeFnError(rows.Err, rows.Close)) - - expected := []string{ - token1, - token2, - token3, - } - g.TAssertEqual(tokens, expected) - }) -} - -func test_confirmStmt() { - g.TestStart("confirmStmt()") - - const ( - prefix = defaultPrefix - ) - - db, err := sql.Open(golite.DriverName, ":memory:") - 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) - g.TErrorIf(g.SomeError( - registerErr, - sendTokenErr, - confirmErr, - )) - defer g.SomeFnError( - registerClose, - sendTokenClose, - confirmClose, - db.Close, - ) - - - g.Testing("can't confirm a token that doesn't exist", func() { - _, err := confirm(string(mksalt()), guuid.New()) - g.TAssertEqual(err, sql.ErrNoRows) - }) - - g.Testing("otherwise it creates a confirmation and a session", func() { - u := newUser() - sessionID := guuid.New() - - _, err := register(u.userID, u.email, u.salt, u.pwhash) - g.TErrorIf(err) - - g.TErrorIf(sendToken(u.userID, u.token)) - - session, err := confirm(u.token, sessionID) - g.TErrorIf(err) - - g.TAssertEqual(session.timestamp == time.Time{}, false) - g.TAssertEqual(session.uuid, sessionID) - g.TAssertEqual(session.userID, u.userID) - }) - - g.Testing("can't confirm the same token twice", func() { - u := newUser() - - _, err := register(u.userID, u.email, u.salt, u.pwhash) - g.TErrorIf(err) - - g.TErrorIf(sendToken(u.userID, u.token)) - - _, err1 := confirm(u.token, guuid.New()) - _, err2 := confirm(u.token, guuid.New()) - g.TErrorIf(err1) - g.TAssertEqual( - err2.(golite.Error).ExtendedCode, - golite.ErrConstraintUnique, - ) - }) - - g.Testing("a user can't have 2 confirmations", func() { - u := newUser() - token1 := string(mksalt()) - token2 := string(mksalt()) - - _, err := register(u.userID, u.email, u.salt, u.pwhash) - g.TErrorIf(err) - - g.TErrorIf(g.SomeError( - sendToken(u.userID, token1), - sendToken(u.userID, token2), - )) - - _, err1 := confirm(token1, guuid.New()) - _, err2 := confirm(token2, guuid.New()) - g.TErrorIf(err1) - g.TAssertEqual( - err2.(golite.Error).ExtendedCode, - golite.ErrConstraintUnique, - ) - }) -} - -func test_byEmailStmt() { - g.TestStart("byEmailStmt()") - - const ( - prefix = defaultPrefix - ) - - db, err := sql.Open(golite.DriverName, ":memory:") - 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) - g.TErrorIf(g.SomeError( - registerErr, - sendTokenErr, - confirmErr, - byEmailErr, - )) - defer g.SomeFnError( - registerClose, - sendTokenClose, - confirmClose, - byEmailClose, - db.Close, - ) - - - g.Testing("error when not found", func() { - email := string(mksalt()) - _, err := byEmail(email) - 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 := byEmail(u.email) - g.TErrorIf(err) - - g.TErrorIf(sendToken(u.userID, u.token)) - - user2, err := byEmail(u.email) - g.TErrorIf(err) - - _, err = confirm(u.token, guuid.New()) - g.TErrorIf(err) - - user3, err := byEmail(u.email) - g.TErrorIf(err) - - g.TAssertEqual(user1, user2) - user2.confirmed = true - g.TAssertEqual(user2, user3) - }) -} - -func test_loginStmt() { - g.TestStart("loginStmt()") - - const ( - prefix = defaultPrefix - ) - - db, err := sql.Open(golite.DriverName, ":memory:") - 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) - g.TErrorIf(g.SomeError( - registerErr, - sendTokenErr, - confirmErr, - byEmailErr, - loginErr, - )) - defer g.SomeFnError( - registerClose, - sendTokenClose, - confirmClose, - byEmailClose, - loginClose, - db.Close, - ) - - - g.Testing("a user must exist to login", func() { - _, err := login(guuid.New(), guuid.New()) - g.TAssertEqual( - err.(golite.Error).ExtendedCode, - golite.ErrConstraintNotNull, - ) - }) - - g.Testing("sessionID must be unique globally", func() { - u1 := newUser() - u2 := newUser() - sessionID := guuid.New() - - _, err := register(u1.userID, u1.email, u1.salt, u1.pwhash) - g.TErrorIf(err) - _, err = register(u2.userID, u2.email, u2.salt, u2.pwhash) - g.TErrorIf(err) - - _, err1 := login(u1.userID, sessionID) - _, err2 := login(u1.userID, sessionID) - _, err3 := login(u2.userID, sessionID) - - g.TErrorIf(err1) - g.TAssertEqual( - err2.(golite.Error).ExtendedCode, - golite.ErrConstraintUnique, - ) - g.TAssertEqual( - err3.(golite.Error).ExtendedCode, - golite.ErrConstraintUnique, - ) - }) - - g.Testing("a user can have multiple active sessions", func() { - u := newUser() - sessionID1 := guuid.New() - sessionID2 := guuid.New() - - _, err := register(u.userID, u.email, u.salt, u.pwhash) - g.TErrorIf(err) - - session1, err := login(u.userID, sessionID1) - g.TErrorIf(err) - - session2, err := login(u.userID, sessionID2) - g.TErrorIf(err) - - g.TAssertEqual(session1.uuid, sessionID1) - g.TAssertEqual(session2.uuid, sessionID2) - g.TAssertEqual(session1.userID, u.userID) - g.TAssertEqual(session2.userID, u.userID) - }) - - g.Testing("multiple users can be logged in", func() { - u1 := newUser() - u2 := newUser() - sessionID1 := guuid.New() - sessionID2 := guuid.New() - - _, err := register(u1.userID, u1.email, u1.salt, u1.pwhash) - g.TErrorIf(err) - _, err = register(u2.userID, u2.email, u2.salt, u2.pwhash) - g.TErrorIf(err) - - session1, err := login(u1.userID, sessionID1) - g.TErrorIf(err) - session2, err := login(u2.userID, sessionID2) - g.TErrorIf(err) - - g.TAssertEqual(session1.uuid, sessionID1) - g.TAssertEqual(session2.uuid, sessionID2) - g.TAssertEqual(session1.userID, u1.userID) - g.TAssertEqual(session2.userID, u2.userID) - }) - - g.Testing("an unconfirmed user is allowed to login", func() { - u := newUser() - - _, err := register(u.userID, u.email, u.salt, u.pwhash) - g.TErrorIf(err) - - _, err = login(u.userID, guuid.New()) - g.TErrorIf(err) - }) - - g.Testing("a confirmed user is allowed to login, too", func() { - u := newUser() - - _, err := register(u.userID, u.email, u.salt, u.pwhash) - g.TErrorIf(err) - - g.TErrorIf(sendToken(u.userID, u.token)) - - _, err = confirm(u.token, guuid.New()) - g.TErrorIf(err) - - user, err := byEmail(u.email) - g.TErrorIf(err) - g.TAssertEqual(user.confirmed, true) - - _, err = login(u.userID, guuid.New()) - g.TErrorIf(err) - }) -} - -func test_refreshStmt() { - g.TestStart("refreshStmt()") - - const ( - prefix = defaultPrefix - ) - - db, err := sql.Open(golite.DriverName, ":memory:") - 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) - g.TErrorIf(g.SomeError( - registerErr, - sendTokenErr, - confirmErr, - byEmailErr, - loginErr, - refreshErr, - )) - defer g.SomeFnError( - registerClose, - sendTokenClose, - confirmClose, - byEmailClose, - loginClose, - refreshClose, - db.Close, - ) - - reg := func(u userDataT) userT { - user, err := register(u.userID, u.email, u.salt, u.pwhash) - g.TErrorIf(err) - return user - } - - conf := func(u userDataT) sessionT { - err := sendToken(u.userID, u.token) - g.TErrorIf(err) - - session, err := confirm(u.token, guuid.New()) - g.TErrorIf(err) - return session - } - - - g.Testing("a session needs to exist be be refreshed", func() { - _, err := refresh(guuid.New(), guuid.New()) - g.TAssertEqual( - err.(golite.Error).ExtendedCode, - golite.ErrConstraintNotNull, - ) - }) - - g.Testing("we can refresh the session of an unconfirmed user", func() { - u := newUser() - sessionID1 := guuid.New() - sessionID2 := guuid.New() - - reg(u) - - session1, err := login(u.userID, sessionID1) - g.TErrorIf(err) - - user, err := byEmail(u.email) - g.TErrorIf(err) - g.TAssertEqual(user.confirmed, false) - - session2, err := refresh(sessionID1, sessionID2) - g.TErrorIf(err) - - g.TAssertEqual(session1.userID, u.userID) - g.TAssertEqual(session1.userID, session2.userID) - g.TAssertEqual(session1.uuid, sessionID1) - g.TAssertEqual(session2.uuid, sessionID2) - g.TAssertEqual(session1.timestamp == time.Time{}, false) - g.TAssertEqual(session2.timestamp == time.Time{}, false) - }) - - g.Testing("we can refresh the session of a confirmed user", func() { - u := newUser() - sessionID1 := guuid.New() - sessionID2 := guuid.New() - - reg(u) - session1 := conf(u) - - user, err := byEmail(u.email) - g.TErrorIf(err) - g.TAssertEqual(user.confirmed, true) - - // FIXME - return - - session2, err := refresh(sessionID1, sessionID2) - g.TErrorIf(err) - - g.TAssertEqual(session1.userID, u.userID) - g.TAssertEqual(session1.userID, session2.userID) - g.TAssertEqual(session1.uuid, sessionID1) - g.TAssertEqual(session2.uuid, sessionID2) - }) - - g.Testing("we can't refresh an expired session", func() { - }) - - g.Testing("the sessionID can't be reused, even across users", func() { - }) - // FIXME -} - -func test_resetStmt() { - // FIXME -} - -func test_changeStmt() { - // FIXME -} - -func test_byUUIDStmt() { - // FIXME -} - -func test_logoutStmt() { - // FIXME -} - -func test_outOthersStmt() { - // FIXME -} - -func test_outAllStmt() { - // FIXME -} - -func test_initDB() { - // FIXME -} - -func test_queriesTclose() { - // FIXME -} - -func test_newUserHandler() { - // FIXME -} - -func test_sendConfirmationRequestHandler() { - // FIXME -} - -func test_forgotPasswordRequestHandler() { - // FIXME -} - -func test_registerConsumers() { - // FIXME -} - -func test_unregisterConsumers() { - // FIXME -} - -func test_startRunner() { - // FIXME -} - -func test_makePoolRunner() { - // FIXME -} - -func test_asResult() { - // FIXME -} - -func test_unwrapResult() { - // FIXME -} - -func test_NewWithPrefix() { - // FIXME -} - -func test_New() { - // FIXME -} - -func test_newUserPayload() { - // FIXME -} - -func test_authT_Register() { - // FIXME -} - -func test_sendConfirmationMessage() { - // FIXME -} - -func test_authT_ResentConfirmation() { - // FIXME -} - -func test_authT_ConfirmEmail() { - // FIXME -} - -func test_authT_LoginEmail() { - // FIXME -} - -func test_forgotPasswordMessage() { - // FIXME -} - -func test_authT_ForgotPassword() { - // FIXME -} - -func test_checkSession() { - // FIXME -} - -func test_validateSession() { - // FIXME -} - -func test_authT_Refresh() { - // FIXME -} - -func test_authT_ResetPassword() { - // FIXME -} - -func test_authT_ChangePassword() { - // FIXME -} - -func test_runLogout() { - // FIXME -} - -func test_authT_Logout() { - // FIXME -} - -func test_authT_LogoutOthers() { - // FIXME -} - -func test_authT_LogoutAll() { - // FIXME -} - -func test_authT_Close() { - // FIXME -} - -func test_usage() { - // FIXME -} - -func test_getopt() { - // FIXME -} - -func test_runCommand() { - // FIXME -} - - -func dumpQueries() { - queries := []struct{name string; fn func(string) queryT}{ - { "createTables", createTablesSQL }, - { "byEmail", byEmailSQL }, - { "register", registerSQL }, - { "sendToken", sendTokenSQL }, - { "confirm", confirmSQL }, - { "login", loginSQL }, - { "refresh", refreshSQL }, - { "reset", resetSQL }, - { "change", changeSQL }, - { "byUUID", byUUIDSQL }, - { "logout", logoutSQL }, - { "outOthers", outOthersSQL }, - { "outAll", outAllSQL }, - } - for _, query := range queries { - q := query.fn(defaultPrefix) - fmt.Printf("\n-- %s.sql:", query.name) - fmt.Printf("\n-- write:%s\n", q.write) - fmt.Printf("\n-- read:%s\n", q.read) - } -} - - - -func MainTest() { - if os.Getenv("TESTING_DUMP_SQL_QUERIES") != "" { - dumpQueries() - return - } - - g.Init() - test_defaultPrefix() - test_tryRollback() - test_inTx() - test_createTables() - test_registerStmt() - test_sendTokenStmt() - test_confirmStmt() - test_byEmailStmt() - test_loginStmt() - test_refreshStmt() - test_resetStmt() - test_changeStmt() - test_byUUIDStmt() - test_logoutStmt() - test_outOthersStmt() - test_outAllStmt() - test_initDB() - test_queriesTclose() - test_newUserHandler() - test_sendConfirmationRequestHandler() - test_forgotPasswordRequestHandler() - test_registerConsumers() - test_unregisterConsumers() - test_startRunner() - test_makePoolRunner() - test_asResult() - test_unwrapResult() - test_NewWithPrefix() - test_New() - test_newUserPayload() - test_authT_Register() - test_sendConfirmationMessage() - test_authT_ResentConfirmation() - test_authT_ConfirmEmail() - test_authT_LoginEmail() - test_forgotPasswordMessage() - test_authT_ForgotPassword() - test_checkSession() - test_validateSession() - test_authT_Refresh() - test_authT_ResetPassword() - test_authT_ChangePassword() - test_runLogout() - test_authT_Logout() - test_authT_LogoutOthers() - test_authT_LogoutAll() - test_authT_Close() - test_usage() - test_getopt() - test_runCommand() -} diff --git a/tests/main.go b/tests/main.go index e22c061..4982a6d 100644 --- a/tests/main.go +++ b/tests/main.go @@ -1,7 +1,7 @@ package main -import "gracha" +import "cracha" func main() { - gracha.MainTest() + cracha.MainTest() } diff --git a/tests/queries.sql b/tests/queries.sql index 7e20ae9..6e68db1 100644 --- a/tests/queries.sql +++ b/tests/queries.sql @@ -1,7 +1,7 @@ -- createTables.sql: -- write: - CREATE TABLE IF NOT EXISTS "gracha_users" ( + CREATE TABLE IF NOT EXISTS "cracha_users" ( id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, timestamp TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%f000000Z', 'now')), uuid BLOB NOT NULL UNIQUE, @@ -9,65 +9,65 @@ salt BLOB NOT NULL UNIQUE, pwhash BLOB NOT NULL ); - CREATE TABLE IF NOT EXISTS "gracha_confirmation_attempts" ( + CREATE TABLE IF NOT EXISTS "cracha_confirmation_attempts" ( id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, timestamp TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%f000000Z', 'now')), -- uuid BLOB NOT NULL UNIQUE, - user_id INTEGER NOT NULL REFERENCES "gracha_users"(id), + user_id INTEGER NOT NULL REFERENCES "cracha_users"(id), token TEXT NOT NULL UNIQUE ); - CREATE TABLE IF NOT EXISTS "gracha_user_confirmations" ( + CREATE TABLE IF NOT EXISTS "cracha_user_confirmations" ( id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%f000000Z', 'now')), user_id INTEGER NOT NULL - REFERENCES "gracha_users"(id) UNIQUE, + REFERENCES "cracha_users"(id) UNIQUE, attempt_id INTEGER NOT NULL - REFERENCES "gracha_confirmation_attempts"(id) UNIQUE + REFERENCES "cracha_confirmation_attempts"(id) UNIQUE ); - CREATE TABLE IF NOT EXISTS "gracha_user_changes" ( + CREATE TABLE IF NOT EXISTS "cracha_user_changes" ( id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, timestamp TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%f000000Z', 'now')), - user_id INTEGER NOT NULL REFERENCES "gracha_users"(id), + user_id INTEGER NOT NULL REFERENCES "cracha_users"(id), attribute TEXT NOT NULL, value TEXT NOT NULL, op BOOLEAN NOT NULL ); - -- CREATE TABLE IF NOT EXISTS "gracha_tokens" ( + -- CREATE TABLE IF NOT EXISTS "cracha_tokens" ( -- id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, -- timestamp TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%f000000Z', 'now')), -- uuid BLOB NOT NULL UNIQUE, -- type TEXT NOT NULL -- ); - CREATE TABLE IF NOT EXISTS "gracha_roles" ( + CREATE TABLE IF NOT EXISTS "cracha_roles" ( id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, - user_id INTEGER NOT NULL REFERENCES "gracha_users"(id), + user_id INTEGER NOT NULL REFERENCES "cracha_users"(id), role TEXT NOT NULL, UNIQUE (user_id, role) ); - CREATE TABLE IF NOT EXISTS "gracha_role_changes" ( + CREATE TABLE IF NOT EXISTS "cracha_role_changes" ( id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, timestamp TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%f000000Z', 'now')), - user_id INTEGER NOT NULL REFERENCES "gracha_roles"(id), + user_id INTEGER NOT NULL REFERENCES "cracha_roles"(id), role TEXT NOT NULL, op BOOLEAN NOT NULL ); - CREATE TABLE IF NOT EXISTS "gracha_sessions" ( + CREATE TABLE IF NOT EXISTS "cracha_sessions" ( id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, timestamp TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%f000000Z', 'now')), uuid BLOB NOT NULL UNIQUE, - user_id INTEGER NOT NULL REFERENCES "gracha_users"(id) + user_id INTEGER NOT NULL REFERENCES "cracha_users"(id) -- type TEXT NOT NULL, -- revoked_at TEXT, - -- revoker_id INTEGER REFERENCES "gracha_users"(id), + -- revoker_id INTEGER REFERENCES "cracha_users"(id), -- FIXME: add provenance: login, refresh, confirmation, etc. ); - CREATE TABLE IF NOT EXISTS "gracha_attempts" ( + CREATE TABLE IF NOT EXISTS "cracha_attempts" ( id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, timestamp TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%f000000Z', 'now')), - user_id INTEGER REFERENCES "gracha_users"(id), - session_id INTEGER REFERENCES "gracha_sessions"(id) + user_id INTEGER REFERENCES "cracha_users"(id), + session_id INTEGER REFERENCES "cracha_sessions"(id) ); - CREATE TABLE IF NOT EXISTS "gracha_audit" ( + CREATE TABLE IF NOT EXISTS "cracha_audit" ( id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, timestamp TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%f000000Z', 'now')), uuid BLOB NOT NULL UNIQUE, @@ -85,34 +85,34 @@ -- read: SELECT id, timestamp, uuid, salt, pwhash, ( CASE WHEN EXISTS ( - SELECT id FROM "gracha_user_confirmations" + SELECT id FROM "cracha_user_confirmations" WHERE user_id = ( - SELECT id FROM "gracha_users" + SELECT id FROM "cracha_users" WHERE email = ? ) ) THEN 1 ELSE 0 END ) as confirmed - FROM "gracha_users" WHERE email = ?; + FROM "cracha_users" WHERE email = ?; -- register.sql: -- write: - INSERT INTO "gracha_users" (uuid, email, salt, pwhash) + INSERT INTO "cracha_users" (uuid, email, salt, pwhash) VALUES (?, ?, ?, ?) RETURNING id, timestamp; -- read: - SELECT id, timestamp from "gracha_users" + SELECT id, timestamp from "cracha_users" WHERE uuid = ?; -- sendToken.sql: -- write: - INSERT INTO "gracha_confirmation_attempts" (user_id, token) + INSERT INTO "cracha_confirmation_attempts" (user_id, token) VALUES ( - (SELECT id FROM "gracha_users" WHERE uuid = ?), + (SELECT id FROM "cracha_users" WHERE uuid = ?), ? ) @@ -121,18 +121,18 @@ -- confirm.sql: -- write: - INSERT INTO "gracha_user_confirmations" (user_id, attempt_id) + INSERT INTO "cracha_user_confirmations" (user_id, attempt_id) VALUES (?, ?); -- read: SELECT - "gracha_confirmation_attempts".id, - "gracha_confirmation_attempts".user_id, - "gracha_users".uuid - FROM "gracha_confirmation_attempts" - JOIN "gracha_users" ON - "gracha_confirmation_attempts".user_id = "gracha_users".id + "cracha_confirmation_attempts".id, + "cracha_confirmation_attempts".user_id, + "cracha_users".uuid + FROM "cracha_confirmation_attempts" + JOIN "cracha_users" ON + "cracha_confirmation_attempts".user_id = "cracha_users".id WHERE token = ?; @@ -143,15 +143,15 @@ -- refresh.sql: -- write: - INSERT INTO "gracha_sessions" (uuid, user_id) + INSERT INTO "cracha_sessions" (uuid, user_id) VALUES ( ?, - (SELECT user_id FROM "gracha_sessions" WHERE uuid = ?) + (SELECT user_id FROM "cracha_sessions" WHERE uuid = ?) ) RETURNING id, timestamp, ( - SELECT "gracha_users".uuid FROM "gracha_users" - JOIN "gracha_sessions" ON - "gracha_users".id = "gracha_sessions".user_id - WHERE "gracha_sessions".uuid = ? + SELECT "cracha_users".uuid FROM "cracha_users" + JOIN "cracha_sessions" ON + "cracha_users".id = "cracha_sessions".user_id + WHERE "cracha_sessions".uuid = ? ) AS userID; @@ -159,14 +159,14 @@ -- reset.sql: -- write: - -- INSERT SOMETHING gracha + -- INSERT SOMETHING cracha -- read: -- change.sql: -- write: - -- INSERT SOMETHING gracha + -- INSERT SOMETHING cracha -- read: @@ -175,26 +175,26 @@ -- write: -- read: - -- INSERT SOMETHING gracha + -- INSERT SOMETHING cracha -- logout.sql: -- write: - -- INSERT SOMETHING gracha + -- INSERT SOMETHING cracha -- read: -- outOthers.sql: -- write: - -- INSERT SOMETHING gracha + -- INSERT SOMETHING cracha -- read: -- outAll.sql: -- write: - -- INSERT SOMETHING gracha + -- INSERT SOMETHING cracha -- read: -- cgit v1.2.3