eac1f2d85d
We have lots of cgo interaction here so better to check things fully. This also requires manually checking for leaks, so add support for this.
754 lines
17 KiB
Go
754 lines
17 KiB
Go
package pam
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"os"
|
|
"os/user"
|
|
"path/filepath"
|
|
"runtime"
|
|
"sync/atomic"
|
|
"testing"
|
|
"time"
|
|
"unsafe"
|
|
)
|
|
|
|
func maybeEndTransaction(t *testing.T, tx *Transaction) {
|
|
t.Helper()
|
|
|
|
if tx == nil {
|
|
return
|
|
}
|
|
err := tx.End()
|
|
if err != nil {
|
|
t.Fatalf("end #error: %v", err)
|
|
}
|
|
}
|
|
|
|
func ensureTransactionEnds(t *testing.T, tx *Transaction) {
|
|
t.Helper()
|
|
|
|
runtime.SetFinalizer(tx, func(tx *Transaction) {
|
|
// #nosec:G103 - the pointer conversion is checked.
|
|
handle := atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(&tx.handle)))
|
|
if handle == nil {
|
|
return
|
|
}
|
|
t.Fatalf("transaction has not been finalized")
|
|
})
|
|
}
|
|
|
|
func TestPAM_001(t *testing.T) {
|
|
t.Cleanup(maybeDoLeakCheck)
|
|
u, _ := user.Current()
|
|
if u.Uid != "0" {
|
|
t.Skip("run this test as root")
|
|
}
|
|
p := "secret"
|
|
tx, err := StartFunc("", "test", func(s Style, msg string) (string, error) {
|
|
return p, nil
|
|
})
|
|
ensureTransactionEnds(t, tx)
|
|
defer maybeEndTransaction(t, tx)
|
|
if err != nil {
|
|
t.Fatalf("start #error: %v", err)
|
|
}
|
|
err = tx.Authenticate(0)
|
|
if err != nil {
|
|
t.Fatalf("authenticate #error: %v", err)
|
|
}
|
|
err = tx.AcctMgmt(Silent)
|
|
if err != nil {
|
|
t.Fatalf("acct_mgmt #error: %v", err)
|
|
}
|
|
err = tx.SetCred(Silent | EstablishCred)
|
|
if err != nil {
|
|
t.Fatalf("setcred #error: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestPAM_002(t *testing.T) {
|
|
t.Cleanup(maybeDoLeakCheck)
|
|
u, _ := user.Current()
|
|
if u.Uid != "0" {
|
|
t.Skip("run this test as root")
|
|
}
|
|
tx, err := StartFunc("", "", func(s Style, msg string) (string, error) {
|
|
switch s {
|
|
case PromptEchoOn:
|
|
return "test", nil
|
|
case PromptEchoOff:
|
|
return "secret", nil
|
|
}
|
|
return "", errors.New("unexpected")
|
|
})
|
|
ensureTransactionEnds(t, tx)
|
|
defer maybeEndTransaction(t, tx)
|
|
if err != nil {
|
|
t.Fatalf("start #error: %v", err)
|
|
}
|
|
err = tx.Authenticate(0)
|
|
if err != nil {
|
|
t.Fatalf("authenticate #error: %v", err)
|
|
}
|
|
}
|
|
|
|
type Credentials struct {
|
|
User string
|
|
Password string
|
|
}
|
|
|
|
func (c Credentials) RespondPAM(s Style, msg string) (string, error) {
|
|
switch s {
|
|
case PromptEchoOn:
|
|
return c.User, nil
|
|
case PromptEchoOff:
|
|
return c.Password, nil
|
|
}
|
|
return "", errors.New("unexpected")
|
|
}
|
|
|
|
func TestPAM_003(t *testing.T) {
|
|
t.Cleanup(maybeDoLeakCheck)
|
|
u, _ := user.Current()
|
|
if u.Uid != "0" {
|
|
t.Skip("run this test as root")
|
|
}
|
|
c := Credentials{
|
|
User: "test",
|
|
Password: "secret",
|
|
}
|
|
tx, err := Start("", "", c)
|
|
ensureTransactionEnds(t, tx)
|
|
defer maybeEndTransaction(t, tx)
|
|
if err != nil {
|
|
t.Fatalf("start #error: %v", err)
|
|
}
|
|
err = tx.Authenticate(0)
|
|
if err != nil {
|
|
t.Fatalf("authenticate #error: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestPAM_004(t *testing.T) {
|
|
t.Cleanup(maybeDoLeakCheck)
|
|
u, _ := user.Current()
|
|
if u.Uid != "0" {
|
|
t.Skip("run this test as root")
|
|
}
|
|
c := Credentials{
|
|
Password: "secret",
|
|
}
|
|
tx, err := Start("", "test", c)
|
|
ensureTransactionEnds(t, tx)
|
|
defer maybeEndTransaction(t, tx)
|
|
if err != nil {
|
|
t.Fatalf("start #error: %v", err)
|
|
}
|
|
err = tx.Authenticate(0)
|
|
if err != nil {
|
|
t.Fatalf("authenticate #error: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestPAM_005(t *testing.T) {
|
|
t.Cleanup(maybeDoLeakCheck)
|
|
u, _ := user.Current()
|
|
if u.Uid != "0" {
|
|
t.Skip("run this test as root")
|
|
}
|
|
if _, found := os.LookupEnv("GO_PAM_TEST_WITH_ASAN"); found {
|
|
t.Skip("test fails under ASAN")
|
|
}
|
|
tx, err := StartFunc("passwd", "test", func(s Style, msg string) (string, error) {
|
|
return "secret", nil
|
|
})
|
|
ensureTransactionEnds(t, tx)
|
|
defer maybeEndTransaction(t, tx)
|
|
if err != nil {
|
|
t.Fatalf("start #error: %v", err)
|
|
}
|
|
service, err := tx.GetItem(Service)
|
|
if err != nil {
|
|
t.Fatalf("GetItem #error: %v", err)
|
|
}
|
|
if service != "passwd" {
|
|
t.Fatalf("Unexpected service: %v", service)
|
|
}
|
|
err = tx.ChangeAuthTok(Silent)
|
|
if err != nil {
|
|
t.Fatalf("chauthtok #error: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestPAM_006(t *testing.T) {
|
|
t.Cleanup(maybeDoLeakCheck)
|
|
u, _ := user.Current()
|
|
if u.Uid != "0" {
|
|
t.Skip("run this test as root")
|
|
}
|
|
tx, err := StartFunc("passwd", u.Username, func(s Style, msg string) (string, error) {
|
|
return "secret", nil
|
|
})
|
|
ensureTransactionEnds(t, tx)
|
|
defer maybeEndTransaction(t, tx)
|
|
if err != nil {
|
|
t.Fatalf("start #error: %v", err)
|
|
}
|
|
err = tx.OpenSession(Silent)
|
|
if err != nil {
|
|
t.Fatalf("open_session #error: %v", err)
|
|
}
|
|
err = tx.CloseSession(Silent)
|
|
if err != nil {
|
|
t.Fatalf("close_session #error: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestPAM_007(t *testing.T) {
|
|
t.Cleanup(maybeDoLeakCheck)
|
|
u, _ := user.Current()
|
|
if u.Uid != "0" {
|
|
t.Skip("run this test as root")
|
|
}
|
|
tx, err := StartFunc("", "test", func(s Style, msg string) (string, error) {
|
|
return "", errors.New("Sorry, it didn't work")
|
|
})
|
|
ensureTransactionEnds(t, tx)
|
|
defer maybeEndTransaction(t, tx)
|
|
if err != nil {
|
|
t.Fatalf("start #error: %v", err)
|
|
}
|
|
err = tx.Authenticate(0)
|
|
if err == nil {
|
|
t.Fatalf("authenticate #expected an error")
|
|
}
|
|
s := err.Error()
|
|
if len(s) == 0 {
|
|
t.Fatalf("error #expected an error message")
|
|
}
|
|
if !errors.Is(err, ErrAuth) {
|
|
t.Fatalf("error #unexpected error %v", err)
|
|
}
|
|
}
|
|
|
|
func TestPAM_ConfDir(t *testing.T) {
|
|
t.Cleanup(maybeDoLeakCheck)
|
|
u, _ := user.Current()
|
|
c := Credentials{
|
|
// the custom service always permits even with wrong password.
|
|
Password: "wrongsecret",
|
|
}
|
|
tx, err := StartConfDir("permit-service", u.Username, c, "test-services")
|
|
defer func() {
|
|
if tx != nil {
|
|
_ = tx.End()
|
|
}
|
|
}()
|
|
if !CheckPamHasStartConfdir() {
|
|
if err == nil {
|
|
t.Fatalf("start should have errored out as pam_start_confdir is not available: %v", err)
|
|
}
|
|
// nothing else we do, we don't support it.
|
|
return
|
|
}
|
|
service, err := tx.GetItem(Service)
|
|
if err != nil {
|
|
t.Fatalf("GetItem #error: %v", err)
|
|
}
|
|
if service != "permit-service" {
|
|
t.Fatalf("Unexpected service: %v", service)
|
|
}
|
|
if err != nil {
|
|
t.Fatalf("start #error: %v", err)
|
|
}
|
|
err = tx.Authenticate(0)
|
|
if err != nil {
|
|
t.Fatalf("authenticate #error: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestPAM_ConfDir_FailNoServiceOrUnsupported(t *testing.T) {
|
|
t.Cleanup(maybeDoLeakCheck)
|
|
if !CheckPamHasStartConfdir() {
|
|
t.Skip("this requires PAM with Conf dir support")
|
|
}
|
|
u, _ := user.Current()
|
|
c := Credentials{
|
|
Password: "secret",
|
|
}
|
|
tx, err := StartConfDir("does-not-exists", u.Username, c, ".")
|
|
if err == nil {
|
|
t.Fatalf("authenticate #expected an error")
|
|
}
|
|
if tx != nil {
|
|
t.Fatalf("authenticate #unexpected transaction")
|
|
}
|
|
s := err.Error()
|
|
if len(s) == 0 {
|
|
t.Fatalf("error #expected an error message")
|
|
}
|
|
var pamErr Error
|
|
if !errors.As(err, &pamErr) {
|
|
t.Fatalf("error #unexpected type: %#v", err)
|
|
}
|
|
if pamErr != ErrAbort {
|
|
t.Fatalf("error #unexpected status: %v", pamErr)
|
|
}
|
|
}
|
|
|
|
func TestPAM_ConfDir_InfoMessage(t *testing.T) {
|
|
t.Cleanup(maybeDoLeakCheck)
|
|
u, _ := user.Current()
|
|
var infoText string
|
|
tx, err := StartConfDir("echo-service", u.Username,
|
|
ConversationFunc(func(s Style, msg string) (string, error) {
|
|
switch s {
|
|
case TextInfo:
|
|
infoText = msg
|
|
return "", nil
|
|
}
|
|
return "", errors.New("unexpected")
|
|
}), "test-services")
|
|
ensureTransactionEnds(t, tx)
|
|
defer maybeEndTransaction(t, tx)
|
|
if err != nil {
|
|
t.Fatalf("start #error: %v", err)
|
|
}
|
|
service, err := tx.GetItem(Service)
|
|
if err != nil {
|
|
t.Fatalf("GetItem #error: %v", err)
|
|
}
|
|
if service != "echo-service" {
|
|
t.Fatalf("Unexpected service: %v", service)
|
|
}
|
|
err = tx.Authenticate(0)
|
|
if err != nil {
|
|
t.Fatalf("authenticate #error: %v", err)
|
|
}
|
|
if infoText != "This is an info message for user "+u.Username+" on echo-service" {
|
|
t.Fatalf("Unexpected info message: %v", infoText)
|
|
}
|
|
}
|
|
|
|
func TestPAM_ConfDir_Deny(t *testing.T) {
|
|
t.Cleanup(maybeDoLeakCheck)
|
|
if !CheckPamHasStartConfdir() {
|
|
t.Skip("this requires PAM with Conf dir support")
|
|
}
|
|
u, _ := user.Current()
|
|
tx, err := StartConfDir("deny-service", u.Username, Credentials{}, "test-services")
|
|
ensureTransactionEnds(t, tx)
|
|
defer maybeEndTransaction(t, tx)
|
|
if err != nil {
|
|
t.Fatalf("start #error: %v", err)
|
|
}
|
|
service, err := tx.GetItem(Service)
|
|
if err != nil {
|
|
t.Fatalf("GetItem #error: %v", err)
|
|
}
|
|
if service != "deny-service" {
|
|
t.Fatalf("Unexpected service: %v", service)
|
|
}
|
|
err = tx.Authenticate(0)
|
|
if err == nil {
|
|
t.Fatalf("authenticate #expected an error")
|
|
}
|
|
s := err.Error()
|
|
if len(s) == 0 {
|
|
t.Fatalf("error #expected an error message")
|
|
}
|
|
if !errors.Is(err, ErrAuth) {
|
|
t.Fatalf("error #unexpected error %v", err)
|
|
}
|
|
}
|
|
|
|
func TestPAM_ConfDir_PromptForUserName(t *testing.T) {
|
|
t.Cleanup(maybeDoLeakCheck)
|
|
c := Credentials{
|
|
User: "testuser",
|
|
// the custom service only cares about correct user name.
|
|
Password: "wrongsecret",
|
|
}
|
|
tx, err := StartConfDir("succeed-if-user-test", "", c, "test-services")
|
|
ensureTransactionEnds(t, tx)
|
|
defer maybeEndTransaction(t, tx)
|
|
if !CheckPamHasStartConfdir() {
|
|
if err == nil {
|
|
t.Fatalf("start should have errored out as pam_start_confdir is not available: %v", err)
|
|
}
|
|
// nothing else we do, we don't support it.
|
|
return
|
|
}
|
|
if err != nil {
|
|
t.Fatalf("start #error: %v", err)
|
|
}
|
|
err = tx.Authenticate(0)
|
|
if err != nil {
|
|
t.Fatalf("authenticate #error: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestPAM_ConfDir_WrongUserName(t *testing.T) {
|
|
t.Cleanup(maybeDoLeakCheck)
|
|
c := Credentials{
|
|
User: "wronguser",
|
|
Password: "wrongsecret",
|
|
}
|
|
tx, err := StartConfDir("succeed-if-user-test", "", c, "test-services")
|
|
ensureTransactionEnds(t, tx)
|
|
defer maybeEndTransaction(t, tx)
|
|
if !CheckPamHasStartConfdir() {
|
|
if err == nil {
|
|
t.Fatalf("start should have errored out as pam_start_confdir is not available: %v", err)
|
|
}
|
|
// nothing else we do, we don't support it.
|
|
return
|
|
}
|
|
err = tx.Authenticate(0)
|
|
if err == nil {
|
|
t.Fatalf("authenticate #expected an error")
|
|
}
|
|
s := err.Error()
|
|
if len(s) == 0 {
|
|
t.Fatalf("error #expected an error message")
|
|
}
|
|
if !errors.Is(err, ErrAuth) {
|
|
t.Fatalf("error #unexpected error %v", err)
|
|
}
|
|
}
|
|
|
|
func TestItem(t *testing.T) {
|
|
t.Cleanup(maybeDoLeakCheck)
|
|
tx, err := StartFunc("passwd", "test", func(s Style, msg string) (string, error) {
|
|
return "", nil
|
|
})
|
|
ensureTransactionEnds(t, tx)
|
|
defer maybeEndTransaction(t, tx)
|
|
if err != nil {
|
|
t.Fatalf("start #error: %v", err)
|
|
}
|
|
|
|
s, err := tx.GetItem(Service)
|
|
if err != nil {
|
|
t.Fatalf("getitem #error: %v", err)
|
|
}
|
|
if s != "passwd" {
|
|
t.Fatalf("getitem #error: expected passwd, got %v", s)
|
|
}
|
|
|
|
s, err = tx.GetItem(User)
|
|
if err != nil {
|
|
t.Fatalf("getitem #error: %v", err)
|
|
}
|
|
if s != "test" {
|
|
t.Fatalf("getitem #error: expected test, got %v", s)
|
|
}
|
|
|
|
err = tx.SetItem(User, "root")
|
|
if err != nil {
|
|
t.Fatalf("setitem #error: %v", err)
|
|
}
|
|
s, err = tx.GetItem(User)
|
|
if err != nil {
|
|
t.Fatalf("getitem #error: %v", err)
|
|
}
|
|
if s != "root" {
|
|
t.Fatalf("getitem #error: expected root, got %v", s)
|
|
}
|
|
}
|
|
|
|
func TestEnv(t *testing.T) {
|
|
t.Cleanup(maybeDoLeakCheck)
|
|
tx, err := StartFunc("", "", func(s Style, msg string) (string, error) {
|
|
return "", nil
|
|
})
|
|
ensureTransactionEnds(t, tx)
|
|
defer maybeEndTransaction(t, tx)
|
|
if err != nil {
|
|
t.Fatalf("start #error: %v", err)
|
|
}
|
|
|
|
m, err := tx.GetEnvList()
|
|
if err != nil {
|
|
t.Fatalf("getenvlist #error: %v", err)
|
|
}
|
|
n := len(m)
|
|
if n != 0 {
|
|
t.Fatalf("putenv #error: expected 0 items, got %v", n)
|
|
}
|
|
|
|
vals := []string{
|
|
"VAL1=1",
|
|
"VAL2=2",
|
|
"VAL3=3",
|
|
}
|
|
for _, s := range vals {
|
|
err = tx.PutEnv(s)
|
|
if err != nil {
|
|
t.Fatalf("putenv #error: %v", err)
|
|
}
|
|
}
|
|
|
|
s := tx.GetEnv("VAL0")
|
|
if s != "" {
|
|
t.Fatalf("getenv #error: expected \"\", got %v", s)
|
|
}
|
|
|
|
s = tx.GetEnv("VAL1")
|
|
if s != "1" {
|
|
t.Fatalf("getenv #error: expected 1, got %v", s)
|
|
}
|
|
s = tx.GetEnv("VAL2")
|
|
if s != "2" {
|
|
t.Fatalf("getenv #error: expected 2, got %v", s)
|
|
}
|
|
s = tx.GetEnv("VAL3")
|
|
if s != "3" {
|
|
t.Fatalf("getenv #error: expected 3, got %v", s)
|
|
}
|
|
|
|
m, err = tx.GetEnvList()
|
|
if err != nil {
|
|
t.Fatalf("getenvlist #error: %v", err)
|
|
}
|
|
n = len(m)
|
|
if n != 3 {
|
|
t.Fatalf("getenvlist #error: expected 3 items, got %v", n)
|
|
}
|
|
if m["VAL1"] != "1" {
|
|
t.Fatalf("getenvlist #error: expected 1, got %v", m["VAL1"])
|
|
}
|
|
if m["VAL2"] != "2" {
|
|
t.Fatalf("getenvlist #error: expected 2, got %v", m["VAL1"])
|
|
}
|
|
if m["VAL3"] != "3" {
|
|
t.Fatalf("getenvlist #error: expected 3, got %v", m["VAL1"])
|
|
}
|
|
}
|
|
|
|
func Test_Error(t *testing.T) {
|
|
t.Parallel()
|
|
t.Cleanup(maybeDoLeakCheck)
|
|
if !CheckPamHasStartConfdir() {
|
|
t.Skip("this requires PAM with Conf dir support")
|
|
}
|
|
|
|
statuses := map[string]error{
|
|
"success": nil,
|
|
"open_err": ErrOpen,
|
|
"symbol_err": ErrSymbol,
|
|
"service_err": ErrService,
|
|
"system_err": ErrSystem,
|
|
"buf_err": ErrBuf,
|
|
"perm_denied": ErrPermDenied,
|
|
"auth_err": ErrAuth,
|
|
"cred_insufficient": ErrCredInsufficient,
|
|
"authinfo_unavail": ErrAuthinfoUnavail,
|
|
"user_unknown": ErrUserUnknown,
|
|
"maxtries": ErrMaxtries,
|
|
"new_authtok_reqd": ErrNewAuthtokReqd,
|
|
"acct_expired": ErrAcctExpired,
|
|
"session_err": ErrSession,
|
|
"cred_unavail": ErrCredUnavail,
|
|
"cred_expired": ErrCredExpired,
|
|
"cred_err": ErrCred,
|
|
"no_module_data": ErrNoModuleData,
|
|
"conv_err": ErrConv,
|
|
"authtok_err": ErrAuthtok,
|
|
"authtok_recover_err": ErrAuthtokRecovery,
|
|
"authtok_lock_busy": ErrAuthtokLockBusy,
|
|
"authtok_disable_aging": ErrAuthtokDisableAging,
|
|
"try_again": ErrTryAgain,
|
|
"ignore": nil, /* Ignore can't be returned */
|
|
"abort": ErrAbort,
|
|
"authtok_expired": ErrAuthtokExpired,
|
|
"module_unknown": ErrModuleUnknown,
|
|
"bad_item": ErrBadItem,
|
|
"conv_again": ErrConvAgain,
|
|
"incomplete": ErrIncomplete,
|
|
}
|
|
|
|
type Action int
|
|
const (
|
|
account Action = iota + 1
|
|
auth
|
|
password
|
|
session
|
|
)
|
|
actions := map[string]Action{
|
|
"account": account,
|
|
"auth": auth,
|
|
"password": password,
|
|
"session": session,
|
|
}
|
|
|
|
c := Credentials{}
|
|
|
|
servicePath := t.TempDir()
|
|
|
|
for ret, expected := range statuses {
|
|
ret := ret
|
|
expected := expected
|
|
for actionName, action := range actions {
|
|
actionName := actionName
|
|
action := action
|
|
t.Run(fmt.Sprintf("%s %s", ret, actionName), func(t *testing.T) {
|
|
t.Parallel()
|
|
serviceName := ret + "-" + actionName
|
|
serviceFile := filepath.Join(servicePath, serviceName)
|
|
contents := fmt.Sprintf("%[1]s requisite pam_debug.so "+
|
|
"auth=%[2]s cred=%[2]s acct=%[2]s prechauthtok=%[2]s "+
|
|
"chauthtok=%[2]s open_session=%[2]s close_session=%[2]s\n"+
|
|
"%[1]s requisite pam_permit.so\n", actionName, ret)
|
|
|
|
if err := os.WriteFile(serviceFile,
|
|
[]byte(contents), 0600); err != nil {
|
|
t.Fatalf("can't create service file %v: %v", serviceFile, err)
|
|
}
|
|
|
|
tx, err := StartConfDir(serviceName, "user", c, servicePath)
|
|
ensureTransactionEnds(t, tx)
|
|
defer maybeEndTransaction(t, tx)
|
|
if err != nil {
|
|
t.Fatalf("start #error: %v", err)
|
|
}
|
|
|
|
switch action {
|
|
case account:
|
|
err = tx.AcctMgmt(0)
|
|
case auth:
|
|
err = tx.Authenticate(0)
|
|
case password:
|
|
err = tx.ChangeAuthTok(0)
|
|
case session:
|
|
err = tx.OpenSession(0)
|
|
}
|
|
|
|
if !errors.Is(err, expected) {
|
|
t.Fatalf("error #unexpected status %#v vs %#v", err,
|
|
expected)
|
|
}
|
|
|
|
if err != nil {
|
|
var status Error
|
|
if !errors.As(err, &status) || err.Error() != status.Error() {
|
|
t.Fatalf("error #unexpected status %#v vs %#v", err.Error(),
|
|
status.Error())
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
func Test_Finalizer(t *testing.T) {
|
|
t.Cleanup(maybeDoLeakCheck)
|
|
if !CheckPamHasStartConfdir() {
|
|
t.Skip("this requires PAM with Conf dir support")
|
|
}
|
|
|
|
func() {
|
|
tx, err := StartConfDir("permit-service", "", nil, "test-services")
|
|
ensureTransactionEnds(t, tx)
|
|
defer maybeEndTransaction(t, tx)
|
|
if err != nil {
|
|
t.Fatalf("start #error: %v", err)
|
|
}
|
|
}()
|
|
|
|
runtime.GC()
|
|
// sleep to switch to finalizer goroutine
|
|
time.Sleep(5 * time.Millisecond)
|
|
}
|
|
|
|
func TestFailure_001(t *testing.T) {
|
|
t.Cleanup(maybeDoLeakCheck)
|
|
tx := Transaction{}
|
|
_, err := tx.GetEnvList()
|
|
if err == nil {
|
|
t.Fatalf("getenvlist #expected an error")
|
|
}
|
|
}
|
|
|
|
func TestFailure_002(t *testing.T) {
|
|
t.Cleanup(maybeDoLeakCheck)
|
|
tx := Transaction{}
|
|
err := tx.PutEnv("")
|
|
if err == nil {
|
|
t.Fatalf("getenvlist #expected an error")
|
|
}
|
|
}
|
|
|
|
func TestFailure_003(t *testing.T) {
|
|
t.Cleanup(maybeDoLeakCheck)
|
|
tx := Transaction{}
|
|
err := tx.CloseSession(0)
|
|
if err == nil {
|
|
t.Fatalf("getenvlist #expected an error")
|
|
}
|
|
}
|
|
|
|
func TestFailure_004(t *testing.T) {
|
|
t.Cleanup(maybeDoLeakCheck)
|
|
tx := Transaction{}
|
|
err := tx.OpenSession(0)
|
|
if err == nil {
|
|
t.Fatalf("getenvlist #expected an error")
|
|
}
|
|
}
|
|
|
|
func TestFailure_005(t *testing.T) {
|
|
t.Cleanup(maybeDoLeakCheck)
|
|
tx := Transaction{}
|
|
err := tx.ChangeAuthTok(0)
|
|
if err == nil {
|
|
t.Fatalf("getenvlist #expected an error")
|
|
}
|
|
}
|
|
|
|
func TestFailure_006(t *testing.T) {
|
|
t.Cleanup(maybeDoLeakCheck)
|
|
tx := Transaction{}
|
|
err := tx.AcctMgmt(0)
|
|
if err == nil {
|
|
t.Fatalf("getenvlist #expected an error")
|
|
}
|
|
}
|
|
|
|
func TestFailure_007(t *testing.T) {
|
|
t.Cleanup(maybeDoLeakCheck)
|
|
tx := Transaction{}
|
|
err := tx.SetCred(0)
|
|
if err == nil {
|
|
t.Fatalf("getenvlist #expected an error")
|
|
}
|
|
}
|
|
|
|
func TestFailure_008(t *testing.T) {
|
|
t.Cleanup(maybeDoLeakCheck)
|
|
tx := Transaction{}
|
|
err := tx.SetItem(User, "test")
|
|
if err == nil {
|
|
t.Fatalf("getenvlist #expected an error")
|
|
}
|
|
}
|
|
|
|
func TestFailure_009(t *testing.T) {
|
|
t.Cleanup(maybeDoLeakCheck)
|
|
tx := Transaction{}
|
|
_, err := tx.GetItem(User)
|
|
if err == nil {
|
|
t.Fatalf("getenvlist #expected an error")
|
|
}
|
|
}
|
|
|
|
func TestFailure_010(t *testing.T) {
|
|
t.Cleanup(maybeDoLeakCheck)
|
|
tx := Transaction{}
|
|
err := tx.End()
|
|
if err != nil {
|
|
t.Fatalf("end #unexpected error %v", err)
|
|
}
|
|
}
|