* Add LDAP Key Synchronization feature Signed-off-by: Magnus Lindvall <magnus@dnmgns.com> * Add migration: add login source id column for public_key table * Only update keys if needed * Add function to only list pubkey synchronized from ldap * Only list pub ssh keys synchronized from ldap. Do not sort strings as ExistsInSlice does it. * Only get keys belonging to current login source id * Set default login source id to 0 * Some minor cleanup. Add integration tests (updete dep testify)tags/v1.5.0-dev
@@ -167,7 +167,8 @@ | |||
[[projects]] | |||
name = "github.com/davecgh/go-spew" | |||
packages = ["spew"] | |||
revision = "ecdeabc65495df2dec95d7c4a4c3e021903035e5" | |||
revision = "346938d642f2ec3594ed81d874461961cd0faa76" | |||
version = "v1.1.0" | |||
[[projects]] | |||
name = "github.com/denisenkom/go-mssqldb" | |||
@@ -669,7 +670,8 @@ | |||
[[projects]] | |||
name = "github.com/stretchr/testify" | |||
packages = ["assert"] | |||
revision = "2aa2c176b9dab406a6970f6a55f513e8a8c8b18f" | |||
revision = "12b6f73e6084dad08a7c6e575284b177ecafbc71" | |||
version = "v1.2.1" | |||
[[projects]] | |||
name = "github.com/syndtr/goleveldb" |
@@ -40,7 +40,11 @@ var gitLDAPUsers = []ldapUser{ | |||
Password: "hermes", | |||
FullName: "Conrad Hermes", | |||
Email: "hermes@planetexpress.com", | |||
IsAdmin: true, | |||
SSHKeys: []string{ | |||
"SHA256:qLY06smKfHoW/92yXySpnxFR10QFrLdRjf/GNPvwcW8", | |||
"SHA256:QlVTuM5OssDatqidn2ffY+Lc4YA5Fs78U+0KOHI51jQ", | |||
}, | |||
IsAdmin: true, | |||
}, | |||
{ | |||
UserName: "fry", | |||
@@ -89,26 +93,27 @@ func getLDAPServerHost() string { | |||
return host | |||
} | |||
func addAuthSourceLDAP(t *testing.T) { | |||
func addAuthSourceLDAP(t *testing.T, sshKeyAttribute string) { | |||
session := loginUser(t, "user1") | |||
csrf := GetCSRF(t, session, "/admin/auths/new") | |||
req := NewRequestWithValues(t, "POST", "/admin/auths/new", map[string]string{ | |||
"_csrf": csrf, | |||
"type": "2", | |||
"name": "ldap", | |||
"host": getLDAPServerHost(), | |||
"port": "389", | |||
"bind_dn": "uid=gitea,ou=service,dc=planetexpress,dc=com", | |||
"bind_password": "password", | |||
"user_base": "ou=people,dc=planetexpress,dc=com", | |||
"filter": "(&(objectClass=inetOrgPerson)(memberOf=cn=git,ou=people,dc=planetexpress,dc=com)(uid=%s))", | |||
"admin_filter": "(memberOf=cn=admin_staff,ou=people,dc=planetexpress,dc=com)", | |||
"attribute_username": "uid", | |||
"attribute_name": "givenName", | |||
"attribute_surname": "sn", | |||
"attribute_mail": "mail", | |||
"is_sync_enabled": "on", | |||
"is_active": "on", | |||
"_csrf": csrf, | |||
"type": "2", | |||
"name": "ldap", | |||
"host": getLDAPServerHost(), | |||
"port": "389", | |||
"bind_dn": "uid=gitea,ou=service,dc=planetexpress,dc=com", | |||
"bind_password": "password", | |||
"user_base": "ou=people,dc=planetexpress,dc=com", | |||
"filter": "(&(objectClass=inetOrgPerson)(memberOf=cn=git,ou=people,dc=planetexpress,dc=com)(uid=%s))", | |||
"admin_filter": "(memberOf=cn=admin_staff,ou=people,dc=planetexpress,dc=com)", | |||
"attribute_username": "uid", | |||
"attribute_name": "givenName", | |||
"attribute_surname": "sn", | |||
"attribute_mail": "mail", | |||
"attribute_ssh_public_key": sshKeyAttribute, | |||
"is_sync_enabled": "on", | |||
"is_active": "on", | |||
}) | |||
session.MakeRequest(t, req, http.StatusFound) | |||
} | |||
@@ -119,7 +124,7 @@ func TestLDAPUserSignin(t *testing.T) { | |||
return | |||
} | |||
prepareTestEnv(t) | |||
addAuthSourceLDAP(t) | |||
addAuthSourceLDAP(t, "") | |||
u := gitLDAPUsers[0] | |||
@@ -140,7 +145,7 @@ func TestLDAPUserSync(t *testing.T) { | |||
return | |||
} | |||
prepareTestEnv(t) | |||
addAuthSourceLDAP(t) | |||
addAuthSourceLDAP(t, "") | |||
models.SyncExternalUsers() | |||
session := loginUser(t, "user1") | |||
@@ -186,9 +191,41 @@ func TestLDAPUserSigninFailed(t *testing.T) { | |||
return | |||
} | |||
prepareTestEnv(t) | |||
addAuthSourceLDAP(t) | |||
addAuthSourceLDAP(t, "") | |||
u := otherLDAPUsers[0] | |||
testLoginFailed(t, u.UserName, u.Password, i18n.Tr("en", "form.username_password_incorrect")) | |||
} | |||
func TestLDAPUserSSHKeySync(t *testing.T) { | |||
if skipLDAPTests() { | |||
t.Skip() | |||
return | |||
} | |||
prepareTestEnv(t) | |||
addAuthSourceLDAP(t, "sshPublicKey") | |||
models.SyncExternalUsers() | |||
// Check if users has SSH keys synced | |||
for _, u := range gitLDAPUsers { | |||
if len(u.SSHKeys) == 0 { | |||
continue | |||
} | |||
session := loginUserWithPassword(t, u.UserName, u.Password) | |||
req := NewRequest(t, "GET", "/user/settings/keys") | |||
resp := session.MakeRequest(t, req, http.StatusOK) | |||
htmlDoc := NewHTMLParser(t, resp.Body) | |||
divs := htmlDoc.doc.Find(".key.list .print.meta") | |||
syncedKeys := make([]string, divs.Length()) | |||
for i := 0; i < divs.Length(); i++ { | |||
syncedKeys[i] = strings.TrimSpace(divs.Eq(i).Text()) | |||
} | |||
assert.ElementsMatch(t, u.SSHKeys, syncedKeys) | |||
} | |||
} |
@@ -184,6 +184,8 @@ var migrations = []Migration{ | |||
NewMigration("add multiple assignees", addMultipleAssignees), | |||
// v65 -> v66 | |||
NewMigration("add u2f", addU2FReg), | |||
// v66 -> v67 | |||
NewMigration("add login source id column for public_key table", addLoginSourceIDToPublicKeyTable), | |||
} | |||
// Migrate database to current version |
@@ -0,0 +1,22 @@ | |||
// Copyright 2017 The Gitea Authors. All rights reserved. | |||
// Use of this source code is governed by a MIT-style | |||
// license that can be found in the LICENSE file. | |||
package migrations | |||
import ( | |||
"fmt" | |||
"github.com/go-xorm/xorm" | |||
) | |||
func addLoginSourceIDToPublicKeyTable(x *xorm.Engine) error { | |||
type PublicKey struct { | |||
LoginSourceID int64 `xorm:"NOT NULL DEFAULT 0"` | |||
} | |||
if err := x.Sync2(new(PublicKey)); err != nil { | |||
return fmt.Errorf("Sync2: %v", err) | |||
} | |||
return nil | |||
} |
@@ -47,13 +47,14 @@ const ( | |||
// PublicKey represents a user or deploy SSH public key. | |||
type PublicKey struct { | |||
ID int64 `xorm:"pk autoincr"` | |||
OwnerID int64 `xorm:"INDEX NOT NULL"` | |||
Name string `xorm:"NOT NULL"` | |||
Fingerprint string `xorm:"NOT NULL"` | |||
Content string `xorm:"TEXT NOT NULL"` | |||
Mode AccessMode `xorm:"NOT NULL DEFAULT 2"` | |||
Type KeyType `xorm:"NOT NULL DEFAULT 1"` | |||
ID int64 `xorm:"pk autoincr"` | |||
OwnerID int64 `xorm:"INDEX NOT NULL"` | |||
Name string `xorm:"NOT NULL"` | |||
Fingerprint string `xorm:"NOT NULL"` | |||
Content string `xorm:"TEXT NOT NULL"` | |||
Mode AccessMode `xorm:"NOT NULL DEFAULT 2"` | |||
Type KeyType `xorm:"NOT NULL DEFAULT 1"` | |||
LoginSourceID int64 `xorm:"NOT NULL DEFAULT 0"` | |||
CreatedUnix util.TimeStamp `xorm:"created"` | |||
UpdatedUnix util.TimeStamp `xorm:"updated"` | |||
@@ -391,7 +392,7 @@ func addKey(e Engine, key *PublicKey) (err error) { | |||
} | |||
// AddPublicKey adds new public key to database and authorized_keys file. | |||
func AddPublicKey(ownerID int64, name, content string) (*PublicKey, error) { | |||
func AddPublicKey(ownerID int64, name, content string, LoginSourceID int64) (*PublicKey, error) { | |||
log.Trace(content) | |||
fingerprint, err := calcFingerprint(content) | |||
@@ -420,12 +421,13 @@ func AddPublicKey(ownerID int64, name, content string) (*PublicKey, error) { | |||
} | |||
key := &PublicKey{ | |||
OwnerID: ownerID, | |||
Name: name, | |||
Fingerprint: fingerprint, | |||
Content: content, | |||
Mode: AccessModeWrite, | |||
Type: KeyTypeUser, | |||
OwnerID: ownerID, | |||
Name: name, | |||
Fingerprint: fingerprint, | |||
Content: content, | |||
Mode: AccessModeWrite, | |||
Type: KeyTypeUser, | |||
LoginSourceID: LoginSourceID, | |||
} | |||
if err = addKey(sess, key); err != nil { | |||
return nil, fmt.Errorf("addKey: %v", err) | |||
@@ -471,6 +473,14 @@ func ListPublicKeys(uid int64) ([]*PublicKey, error) { | |||
Find(&keys) | |||
} | |||
// ListPublicLdapSSHKeys returns a list of synchronized public ldap ssh keys belongs to given user and login source. | |||
func ListPublicLdapSSHKeys(uid int64, LoginSourceID int64) ([]*PublicKey, error) { | |||
keys := make([]*PublicKey, 0, 5) | |||
return keys, x. | |||
Where("owner_id = ? AND login_source_id = ?", uid, LoginSourceID). | |||
Find(&keys) | |||
} | |||
// UpdatePublicKeyUpdated updates public key use time. | |||
func UpdatePublicKeyUpdated(id int64) error { | |||
// Check if key exists before update as affected rows count is unreliable |
@@ -1356,6 +1356,119 @@ func GetWatchedRepos(userID int64, private bool) ([]*Repository, error) { | |||
return repos, nil | |||
} | |||
// deleteKeysMarkedForDeletion returns true if ssh keys needs update | |||
func deleteKeysMarkedForDeletion(keys []string) (bool, error) { | |||
// Start session | |||
sess := x.NewSession() | |||
defer sess.Close() | |||
if err := sess.Begin(); err != nil { | |||
return false, err | |||
} | |||
// Delete keys marked for deletion | |||
var sshKeysNeedUpdate bool | |||
for _, KeyToDelete := range keys { | |||
key, err := SearchPublicKeyByContent(KeyToDelete) | |||
if err != nil { | |||
log.Error(4, "SearchPublicKeyByContent: %v", err) | |||
continue | |||
} | |||
if err = deletePublicKeys(sess, key.ID); err != nil { | |||
log.Error(4, "deletePublicKeys: %v", err) | |||
continue | |||
} | |||
sshKeysNeedUpdate = true | |||
} | |||
if err := sess.Commit(); err != nil { | |||
return false, err | |||
} | |||
return sshKeysNeedUpdate, nil | |||
} | |||
func addLdapSSHPublicKeys(s *LoginSource, usr *User, SSHPublicKeys []string) bool { | |||
var sshKeysNeedUpdate bool | |||
for _, sshKey := range SSHPublicKeys { | |||
if strings.HasPrefix(strings.ToLower(sshKey), "ssh") { | |||
sshKeyName := fmt.Sprintf("%s-%s", s.Name, sshKey[0:40]) | |||
if _, err := AddPublicKey(usr.ID, sshKeyName, sshKey, s.ID); err != nil { | |||
log.Error(4, "addLdapSSHPublicKeys[%s]: Error adding LDAP Public SSH Key for user %s: %v", s.Name, usr.Name, err) | |||
} else { | |||
log.Trace("addLdapSSHPublicKeys[%s]: Added LDAP Public SSH Key for user %s", s.Name, usr.Name) | |||
sshKeysNeedUpdate = true | |||
} | |||
} else { | |||
log.Warn("addLdapSSHPublicKeys[%s]: Skipping invalid LDAP Public SSH Key for user %s: %v", s.Name, usr.Name, sshKey) | |||
} | |||
} | |||
return sshKeysNeedUpdate | |||
} | |||
func synchronizeLdapSSHPublicKeys(s *LoginSource, SSHPublicKeys []string, usr *User) bool { | |||
var sshKeysNeedUpdate bool | |||
log.Trace("synchronizeLdapSSHPublicKeys[%s]: Handling LDAP Public SSH Key synchronization for user %s", s.Name, usr.Name) | |||
// Get Public Keys from DB with current LDAP source | |||
var giteaKeys []string | |||
keys, err := ListPublicLdapSSHKeys(usr.ID, s.ID) | |||
if err != nil { | |||
log.Error(4, "synchronizeLdapSSHPublicKeys[%s]: Error listing LDAP Public SSH Keys for user %s: %v", s.Name, usr.Name, err) | |||
} | |||
for _, v := range keys { | |||
giteaKeys = append(giteaKeys, v.OmitEmail()) | |||
} | |||
// Get Public Keys from LDAP and skip duplicate keys | |||
var ldapKeys []string | |||
for _, v := range SSHPublicKeys { | |||
ldapKey := strings.Join(strings.Split(v, " ")[:2], " ") | |||
if !util.ExistsInSlice(ldapKey, ldapKeys) { | |||
ldapKeys = append(ldapKeys, ldapKey) | |||
} | |||
} | |||
// Check if Public Key sync is needed | |||
if util.IsEqualSlice(giteaKeys, ldapKeys) { | |||
log.Trace("synchronizeLdapSSHPublicKeys[%s]: LDAP Public Keys are already in sync for %s (LDAP:%v/DB:%v)", s.Name, usr.Name, len(ldapKeys), len(giteaKeys)) | |||
return false | |||
} | |||
log.Trace("synchronizeLdapSSHPublicKeys[%s]: LDAP Public Key needs update for user %s (LDAP:%v/DB:%v)", s.Name, usr.Name, len(ldapKeys), len(giteaKeys)) | |||
// Add LDAP Public SSH Keys that doesn't already exist in DB | |||
var newLdapSSHKeys []string | |||
for _, LDAPPublicSSHKey := range ldapKeys { | |||
if !util.ExistsInSlice(LDAPPublicSSHKey, giteaKeys) { | |||
newLdapSSHKeys = append(newLdapSSHKeys, LDAPPublicSSHKey) | |||
} | |||
} | |||
if addLdapSSHPublicKeys(s, usr, newLdapSSHKeys) { | |||
sshKeysNeedUpdate = true | |||
} | |||
// Mark LDAP keys from DB that doesn't exist in LDAP for deletion | |||
var giteaKeysToDelete []string | |||
for _, giteaKey := range giteaKeys { | |||
if !util.ExistsInSlice(giteaKey, ldapKeys) { | |||
log.Trace("synchronizeLdapSSHPublicKeys[%s]: Marking LDAP Public SSH Key for deletion for user %s: %v", s.Name, usr.Name, giteaKey) | |||
giteaKeysToDelete = append(giteaKeysToDelete, giteaKey) | |||
} | |||
} | |||
// Delete LDAP keys from DB that doesn't exist in LDAP | |||
needUpd, err := deleteKeysMarkedForDeletion(giteaKeysToDelete) | |||
if err != nil { | |||
log.Error(4, "synchronizeLdapSSHPublicKeys[%s]: Error deleting LDAP Public SSH Keys marked for deletion for user %s: %v", s.Name, usr.Name, err) | |||
} | |||
if needUpd { | |||
sshKeysNeedUpdate = true | |||
} | |||
return sshKeysNeedUpdate | |||
} | |||
// SyncExternalUsers is used to synchronize users with external authorization source | |||
func SyncExternalUsers() { | |||
if !taskStatusTable.StartIfNotRunning(syncExternalUsers) { | |||
@@ -1377,10 +1490,13 @@ func SyncExternalUsers() { | |||
if !s.IsActived || !s.IsSyncEnabled { | |||
continue | |||
} | |||
if s.IsLDAP() { | |||
log.Trace("Doing: SyncExternalUsers[%s]", s.Name) | |||
var existingUsers []int64 | |||
var isAttributeSSHPublicKeySet = len(strings.TrimSpace(s.LDAP().AttributeSSHPublicKey)) > 0 | |||
var sshKeysNeedUpdate bool | |||
// Find all users with this login type | |||
var users []User | |||
@@ -1389,7 +1505,6 @@ func SyncExternalUsers() { | |||
Find(&users) | |||
sr := s.LDAP().SearchEntries() | |||
for _, su := range sr { | |||
if len(su.Username) == 0 { | |||
continue | |||
@@ -1426,11 +1541,23 @@ func SyncExternalUsers() { | |||
} | |||
err = CreateUser(usr) | |||
if err != nil { | |||
log.Error(4, "SyncExternalUsers[%s]: Error creating user %s: %v", s.Name, su.Username, err) | |||
} else if isAttributeSSHPublicKeySet { | |||
log.Trace("SyncExternalUsers[%s]: Adding LDAP Public SSH Keys for user %s", s.Name, usr.Name) | |||
if addLdapSSHPublicKeys(s, usr, su.SSHPublicKey) { | |||
sshKeysNeedUpdate = true | |||
} | |||
} | |||
} else if updateExisting { | |||
existingUsers = append(existingUsers, usr.ID) | |||
// Synchronize SSH Public Key if that attribute is set | |||
if isAttributeSSHPublicKeySet && synchronizeLdapSSHPublicKeys(s, su.SSHPublicKey, usr) { | |||
sshKeysNeedUpdate = true | |||
} | |||
// Check if user data has changed | |||
if (len(s.LDAP().AdminFilter) > 0 && usr.IsAdmin != su.IsAdmin) || | |||
strings.ToLower(usr.Email) != strings.ToLower(su.Mail) || | |||
@@ -1455,6 +1582,11 @@ func SyncExternalUsers() { | |||
} | |||
} | |||
// Rewrite authorized_keys file if LDAP Public SSH Key attribute is set and any key was added or removed | |||
if sshKeysNeedUpdate { | |||
RewriteAllPublicKeys() | |||
} | |||
// Deactivate users not present in LDAP | |||
if updateExisting { | |||
for _, usr := range users { |
@@ -24,6 +24,7 @@ type AuthenticationForm struct { | |||
AttributeName string | |||
AttributeSurname string | |||
AttributeMail string | |||
AttributeSSHPublicKey string | |||
AttributesInBind bool | |||
UsePagedSearch bool | |||
SearchPageSize int |
@@ -28,33 +28,35 @@ const ( | |||
// Source Basic LDAP authentication service | |||
type Source struct { | |||
Name string // canonical name (ie. corporate.ad) | |||
Host string // LDAP host | |||
Port int // port number | |||
SecurityProtocol SecurityProtocol | |||
SkipVerify bool | |||
BindDN string // DN to bind with | |||
BindPassword string // Bind DN password | |||
UserBase string // Base search path for users | |||
UserDN string // Template for the DN of the user for simple auth | |||
AttributeUsername string // Username attribute | |||
AttributeName string // First name attribute | |||
AttributeSurname string // Surname attribute | |||
AttributeMail string // E-mail attribute | |||
AttributesInBind bool // fetch attributes in bind context (not user) | |||
SearchPageSize uint32 // Search with paging page size | |||
Filter string // Query filter to validate entry | |||
AdminFilter string // Query filter to check if user is admin | |||
Enabled bool // if this source is disabled | |||
Name string // canonical name (ie. corporate.ad) | |||
Host string // LDAP host | |||
Port int // port number | |||
SecurityProtocol SecurityProtocol | |||
SkipVerify bool | |||
BindDN string // DN to bind with | |||
BindPassword string // Bind DN password | |||
UserBase string // Base search path for users | |||
UserDN string // Template for the DN of the user for simple auth | |||
AttributeUsername string // Username attribute | |||
AttributeName string // First name attribute | |||
AttributeSurname string // Surname attribute | |||
AttributeMail string // E-mail attribute | |||
AttributesInBind bool // fetch attributes in bind context (not user) | |||
AttributeSSHPublicKey string // LDAP SSH Public Key attribute | |||
SearchPageSize uint32 // Search with paging page size | |||
Filter string // Query filter to validate entry | |||
AdminFilter string // Query filter to check if user is admin | |||
Enabled bool // if this source is disabled | |||
} | |||
// SearchResult : user data | |||
type SearchResult struct { | |||
Username string // Username | |||
Name string // Name | |||
Surname string // Surname | |||
Mail string // E-mail address | |||
IsAdmin bool // if user is administrator | |||
Username string // Username | |||
Name string // Name | |||
Surname string // Surname | |||
Mail string // E-mail address | |||
SSHPublicKey []string // SSH Public Key | |||
IsAdmin bool // if user is administrator | |||
} | |||
func (ls *Source) sanitizedUserQuery(username string) (string, bool) { | |||
@@ -298,10 +300,10 @@ func (ls *Source) SearchEntries() []*SearchResult { | |||
userFilter := fmt.Sprintf(ls.Filter, "*") | |||
log.Trace("Fetching attributes '%v', '%v', '%v', '%v' with filter %s and base %s", ls.AttributeUsername, ls.AttributeName, ls.AttributeSurname, ls.AttributeMail, userFilter, ls.UserBase) | |||
log.Trace("Fetching attributes '%v', '%v', '%v', '%v', '%v' with filter %s and base %s", ls.AttributeUsername, ls.AttributeName, ls.AttributeSurname, ls.AttributeMail, ls.AttributeSSHPublicKey, userFilter, ls.UserBase) | |||
search := ldap.NewSearchRequest( | |||
ls.UserBase, ldap.ScopeWholeSubtree, ldap.NeverDerefAliases, 0, 0, false, userFilter, | |||
[]string{ls.AttributeUsername, ls.AttributeName, ls.AttributeSurname, ls.AttributeMail}, | |||
[]string{ls.AttributeUsername, ls.AttributeName, ls.AttributeSurname, ls.AttributeMail, ls.AttributeSSHPublicKey}, | |||
nil) | |||
var sr *ldap.SearchResult | |||
@@ -319,11 +321,12 @@ func (ls *Source) SearchEntries() []*SearchResult { | |||
for i, v := range sr.Entries { | |||
result[i] = &SearchResult{ | |||
Username: v.GetAttributeValue(ls.AttributeUsername), | |||
Name: v.GetAttributeValue(ls.AttributeName), | |||
Surname: v.GetAttributeValue(ls.AttributeSurname), | |||
Mail: v.GetAttributeValue(ls.AttributeMail), | |||
IsAdmin: checkAdmin(l, ls, v.DN), | |||
Username: v.GetAttributeValue(ls.AttributeUsername), | |||
Name: v.GetAttributeValue(ls.AttributeName), | |||
Surname: v.GetAttributeValue(ls.AttributeSurname), | |||
Mail: v.GetAttributeValue(ls.AttributeMail), | |||
SSHPublicKey: v.GetAttributeValues(ls.AttributeSSHPublicKey), | |||
IsAdmin: checkAdmin(l, ls, v.DN), | |||
} | |||
} | |||
@@ -27,3 +27,32 @@ func IsSliceInt64Eq(a, b []int64) bool { | |||
} | |||
return true | |||
} | |||
// ExistsInSlice returns true if string exists in slice. | |||
func ExistsInSlice(target string, slice []string) bool { | |||
i := sort.Search(len(slice), | |||
func(i int) bool { return slice[i] == target }) | |||
return i < len(slice) | |||
} | |||
// IsEqualSlice returns true if slices are equal. | |||
func IsEqualSlice(target []string, source []string) bool { | |||
if len(target) != len(source) { | |||
return false | |||
} | |||
if (target == nil) != (source == nil) { | |||
return false | |||
} | |||
sort.Strings(target) | |||
sort.Strings(source) | |||
for i, v := range target { | |||
if v != source[i] { | |||
return false | |||
} | |||
} | |||
return true | |||
} |
@@ -1390,6 +1390,7 @@ auths.attribute_username_placeholder = Leave empty to use the username entered i | |||
auths.attribute_name = First Name Attribute | |||
auths.attribute_surname = Surname Attribute | |||
auths.attribute_mail = Email Attribute | |||
auths.attribute_ssh_public_key = Public SSH Key Attribute | |||
auths.attributes_in_bind = Fetch Attributes in Bind DN Context | |||
auths.use_paged_search = Use Paged Search | |||
auths.search_page_size = Page Size |
@@ -97,24 +97,25 @@ func parseLDAPConfig(form auth.AuthenticationForm) *models.LDAPConfig { | |||
} | |||
return &models.LDAPConfig{ | |||
Source: &ldap.Source{ | |||
Name: form.Name, | |||
Host: form.Host, | |||
Port: form.Port, | |||
SecurityProtocol: ldap.SecurityProtocol(form.SecurityProtocol), | |||
SkipVerify: form.SkipVerify, | |||
BindDN: form.BindDN, | |||
UserDN: form.UserDN, | |||
BindPassword: form.BindPassword, | |||
UserBase: form.UserBase, | |||
AttributeUsername: form.AttributeUsername, | |||
AttributeName: form.AttributeName, | |||
AttributeSurname: form.AttributeSurname, | |||
AttributeMail: form.AttributeMail, | |||
AttributesInBind: form.AttributesInBind, | |||
SearchPageSize: pageSize, | |||
Filter: form.Filter, | |||
AdminFilter: form.AdminFilter, | |||
Enabled: true, | |||
Name: form.Name, | |||
Host: form.Host, | |||
Port: form.Port, | |||
SecurityProtocol: ldap.SecurityProtocol(form.SecurityProtocol), | |||
SkipVerify: form.SkipVerify, | |||
BindDN: form.BindDN, | |||
UserDN: form.UserDN, | |||
BindPassword: form.BindPassword, | |||
UserBase: form.UserBase, | |||
AttributeUsername: form.AttributeUsername, | |||
AttributeName: form.AttributeName, | |||
AttributeSurname: form.AttributeSurname, | |||
AttributeMail: form.AttributeMail, | |||
AttributesInBind: form.AttributesInBind, | |||
AttributeSSHPublicKey: form.AttributeSSHPublicKey, | |||
SearchPageSize: pageSize, | |||
Filter: form.Filter, | |||
AdminFilter: form.AdminFilter, | |||
Enabled: true, | |||
}, | |||
} | |||
} |
@@ -129,7 +129,7 @@ func CreateUserPublicKey(ctx *context.APIContext, form api.CreateKeyOption, uid | |||
return | |||
} | |||
key, err := models.AddPublicKey(uid, form.Title, content) | |||
key, err := models.AddPublicKey(uid, form.Title, content, 0) | |||
if err != nil { | |||
repo.HandleAddKeyError(ctx, err) | |||
return |
@@ -99,7 +99,7 @@ func KeysPost(ctx *context.Context, form auth.AddKeyForm) { | |||
return | |||
} | |||
if _, err = models.AddPublicKey(ctx.User.ID, form.Title, content); err != nil { | |||
if _, err = models.AddPublicKey(ctx.User.ID, form.Title, content, 0); err != nil { | |||
ctx.Data["HasSSHError"] = true | |||
switch { | |||
case models.IsErrKeyAlreadyExist(err): |
@@ -90,6 +90,10 @@ | |||
<label for="attribute_mail">{{.i18n.Tr "admin.auths.attribute_mail"}}</label> | |||
<input id="attribute_mail" name="attribute_mail" value="{{$cfg.AttributeMail}}" placeholder="e.g. mail" required> | |||
</div> | |||
<div class="field"> | |||
<label for="attribute_ssh_public_key">{{.i18n.Tr "admin.auths.attribute_ssh_public_key"}}</label> | |||
<input id="attribute_ssh_public_key" name="attribute_ssh_public_key" value="{{$cfg.AttributeSSHPublicKey}}" placeholder="e.g. SshPublicKey"> | |||
</div> | |||
{{if .Source.IsLDAP}} | |||
<div class="inline field"> | |||
<div class="ui checkbox"> |
@@ -62,6 +62,10 @@ | |||
<label for="attribute_mail">{{.i18n.Tr "admin.auths.attribute_mail"}}</label> | |||
<input id="attribute_mail" name="attribute_mail" value="{{.attribute_mail}}" placeholder="e.g. mail"> | |||
</div> | |||
<div class="field"> | |||
<label for="attribute_ssh_public_key">{{.i18n.Tr "admin.auths.attribute_ssh_public_key"}}</label> | |||
<input id="attribute_ssh_public_key" name="attribute_ssh_public_key" value="{{.attribute_ssh_public_key}}" placeholder="e.g. SshPublicKey"> | |||
</div> | |||
<div class="ldap inline field {{if not (eq .type 2)}}hide{{end}}"> | |||
<div class="ui checkbox"> | |||
<label for="use_paged_search"><strong>{{.i18n.Tr "admin.auths.use_paged_search"}}</strong></label> |
@@ -2,7 +2,7 @@ ISC License | |||
Copyright (c) 2012-2016 Dave Collins <dave@davec.name> | |||
Permission to use, copy, modify, and/or distribute this software for any | |||
Permission to use, copy, modify, and distribute this software for any | |||
purpose with or without fee is hereby granted, provided that the above | |||
copyright notice and this permission notice appear in all copies. | |||
@@ -41,9 +41,9 @@ var ( | |||
// after commit 82f48826c6c7 which changed the format again to mirror | |||
// the original format. Code in the init function updates these offsets | |||
// as necessary. | |||
offsetPtr = ptrSize | |||
offsetPtr = uintptr(ptrSize) | |||
offsetScalar = uintptr(0) | |||
offsetFlag = ptrSize * 2 | |||
offsetFlag = uintptr(ptrSize * 2) | |||
// flagKindWidth and flagKindShift indicate various bits that the | |||
// reflect package uses internally to track kind information. | |||
@@ -58,7 +58,7 @@ var ( | |||
// changed their positions. Code in the init function updates these | |||
// flags as necessary. | |||
flagKindWidth = uintptr(5) | |||
flagKindShift = flagKindWidth - 1 | |||
flagKindShift = uintptr(flagKindWidth - 1) | |||
flagRO = uintptr(1 << 0) | |||
flagIndir = uintptr(1 << 1) | |||
) |
@@ -180,7 +180,7 @@ func printComplex(w io.Writer, c complex128, floatPrecision int) { | |||
w.Write(closeParenBytes) | |||
} | |||
// printHexPtr outputs a uintptr formatted as hexadecimal with a leading '0x' | |||
// printHexPtr outputs a uintptr formatted as hexidecimal with a leading '0x' | |||
// prefix to Writer w. | |||
func printHexPtr(w io.Writer, p uintptr) { | |||
// Null pointer. |
@@ -35,16 +35,16 @@ var ( | |||
// cCharRE is a regular expression that matches a cgo char. | |||
// It is used to detect character arrays to hexdump them. | |||
cCharRE = regexp.MustCompile(`^.*\._Ctype_char$`) | |||
cCharRE = regexp.MustCompile("^.*\\._Ctype_char$") | |||
// cUnsignedCharRE is a regular expression that matches a cgo unsigned | |||
// char. It is used to detect unsigned character arrays to hexdump | |||
// them. | |||
cUnsignedCharRE = regexp.MustCompile(`^.*\._Ctype_unsignedchar$`) | |||
cUnsignedCharRE = regexp.MustCompile("^.*\\._Ctype_unsignedchar$") | |||
// cUint8tCharRE is a regular expression that matches a cgo uint8_t. | |||
// It is used to detect uint8_t arrays to hexdump them. | |||
cUint8tCharRE = regexp.MustCompile(`^.*\._Ctype_uint8_t$`) | |||
cUint8tCharRE = regexp.MustCompile("^.*\\._Ctype_uint8_t$") | |||
) | |||
// dumpState contains information about the state of a dump operation. | |||
@@ -143,10 +143,10 @@ func (d *dumpState) dumpPtr(v reflect.Value) { | |||
// Display dereferenced value. | |||
d.w.Write(openParenBytes) | |||
switch { | |||
case nilFound: | |||
case nilFound == true: | |||
d.w.Write(nilAngleBytes) | |||
case cycleFound: | |||
case cycleFound == true: | |||
d.w.Write(circularBytes) | |||
default: |
@@ -182,10 +182,10 @@ func (f *formatState) formatPtr(v reflect.Value) { | |||
// Display dereferenced value. | |||
switch { | |||
case nilFound: | |||
case nilFound == true: | |||
f.fs.Write(nilAngleBytes) | |||
case cycleFound: | |||
case cycleFound == true: | |||
f.fs.Write(circularShortBytes) | |||
default: |
@@ -1,22 +0,0 @@ | |||
Copyright (c) 2012 - 2013 Mat Ryer and Tyler Bunnell | |||
Please consider promoting this project if you find it useful. | |||
Permission is hereby granted, free of charge, to any person | |||
obtaining a copy of this software and associated documentation | |||
files (the "Software"), to deal in the Software without restriction, | |||
including without limitation the rights to use, copy, modify, merge, | |||
publish, distribute, sublicense, and/or sell copies of the Software, | |||
and to permit persons to whom the Software is furnished to do so, | |||
subject to the following conditions: | |||
The above copyright notice and this permission notice shall be included | |||
in all copies or substantial portions of the Software. | |||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, | |||
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES | |||
OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. | |||
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, | |||
DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT | |||
OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE | |||
OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
@@ -22,18 +22,28 @@ func Conditionf(t TestingT, comp Comparison, msg string, args ...interface{}) bo | |||
// assert.Containsf(t, "Hello World", "World", "error message %s", "formatted") | |||
// assert.Containsf(t, ["Hello", "World"], "World", "error message %s", "formatted") | |||
// assert.Containsf(t, {"Hello": "World"}, "Hello", "error message %s", "formatted") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func Containsf(t TestingT, s interface{}, contains interface{}, msg string, args ...interface{}) bool { | |||
return Contains(t, s, contains, append([]interface{}{msg}, args...)...) | |||
} | |||
// DirExistsf checks whether a directory exists in the given path. It also fails if the path is a file rather a directory or there is an error checking whether it exists. | |||
func DirExistsf(t TestingT, path string, msg string, args ...interface{}) bool { | |||
return DirExists(t, path, append([]interface{}{msg}, args...)...) | |||
} | |||
// ElementsMatchf asserts that the specified listA(array, slice...) is equal to specified | |||
// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements, | |||
// the number of appearances of each of them in both lists should match. | |||
// | |||
// assert.ElementsMatchf(t, [1, 3, 2, 3], [1, 3, 3, 2], "error message %s", "formatted") | |||
func ElementsMatchf(t TestingT, listA interface{}, listB interface{}, msg string, args ...interface{}) bool { | |||
return ElementsMatch(t, listA, listB, append([]interface{}{msg}, args...)...) | |||
} | |||
// Emptyf asserts that the specified object is empty. I.e. nil, "", false, 0 or either | |||
// a slice or a channel with len == 0. | |||
// | |||
// assert.Emptyf(t, obj, "error message %s", "formatted") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func Emptyf(t TestingT, object interface{}, msg string, args ...interface{}) bool { | |||
return Empty(t, object, append([]interface{}{msg}, args...)...) | |||
} | |||
@@ -42,8 +52,6 @@ func Emptyf(t TestingT, object interface{}, msg string, args ...interface{}) boo | |||
// | |||
// assert.Equalf(t, 123, 123, "error message %s", "formatted") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
// | |||
// Pointer variable equality is determined based on the equality of the | |||
// referenced values (as opposed to the memory addresses). Function equality | |||
// cannot be determined and will always fail. | |||
@@ -56,8 +64,6 @@ func Equalf(t TestingT, expected interface{}, actual interface{}, msg string, ar | |||
// | |||
// actualObj, err := SomeFunction() | |||
// assert.EqualErrorf(t, err, expectedErrorString, "error message %s", "formatted") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func EqualErrorf(t TestingT, theError error, errString string, msg string, args ...interface{}) bool { | |||
return EqualError(t, theError, errString, append([]interface{}{msg}, args...)...) | |||
} | |||
@@ -66,8 +72,6 @@ func EqualErrorf(t TestingT, theError error, errString string, msg string, args | |||
// and equal. | |||
// | |||
// assert.EqualValuesf(t, uint32(123, "error message %s", "formatted"), int32(123)) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func EqualValuesf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool { | |||
return EqualValues(t, expected, actual, append([]interface{}{msg}, args...)...) | |||
} | |||
@@ -78,17 +82,13 @@ func EqualValuesf(t TestingT, expected interface{}, actual interface{}, msg stri | |||
// if assert.Errorf(t, err, "error message %s", "formatted") { | |||
// assert.Equal(t, expectedErrorf, err) | |||
// } | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func Errorf(t TestingT, err error, msg string, args ...interface{}) bool { | |||
return Error(t, err, append([]interface{}{msg}, args...)...) | |||
} | |||
// Exactlyf asserts that two objects are equal is value and type. | |||
// Exactlyf asserts that two objects are equal in value and type. | |||
// | |||
// assert.Exactlyf(t, int32(123, "error message %s", "formatted"), int64(123)) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func Exactlyf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool { | |||
return Exactly(t, expected, actual, append([]interface{}{msg}, args...)...) | |||
} | |||
@@ -106,20 +106,23 @@ func FailNowf(t TestingT, failureMessage string, msg string, args ...interface{} | |||
// Falsef asserts that the specified value is false. | |||
// | |||
// assert.Falsef(t, myBool, "error message %s", "formatted") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func Falsef(t TestingT, value bool, msg string, args ...interface{}) bool { | |||
return False(t, value, append([]interface{}{msg}, args...)...) | |||
} | |||
// FileExistsf checks whether a file exists in the given path. It also fails if the path points to a directory or there is an error when trying to check the file. | |||
func FileExistsf(t TestingT, path string, msg string, args ...interface{}) bool { | |||
return FileExists(t, path, append([]interface{}{msg}, args...)...) | |||
} | |||
// HTTPBodyContainsf asserts that a specified handler returns a | |||
// body that contains a string. | |||
// | |||
// assert.HTTPBodyContainsf(t, myHandler, "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func HTTPBodyContainsf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}) bool { | |||
return HTTPBodyContains(t, handler, method, url, values, str) | |||
func HTTPBodyContainsf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) bool { | |||
return HTTPBodyContains(t, handler, method, url, values, str, append([]interface{}{msg}, args...)...) | |||
} | |||
// HTTPBodyNotContainsf asserts that a specified handler returns a | |||
@@ -128,8 +131,8 @@ func HTTPBodyContainsf(t TestingT, handler http.HandlerFunc, method string, url | |||
// assert.HTTPBodyNotContainsf(t, myHandler, "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func HTTPBodyNotContainsf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}) bool { | |||
return HTTPBodyNotContains(t, handler, method, url, values, str) | |||
func HTTPBodyNotContainsf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) bool { | |||
return HTTPBodyNotContains(t, handler, method, url, values, str, append([]interface{}{msg}, args...)...) | |||
} | |||
// HTTPErrorf asserts that a specified handler returns an error status code. | |||
@@ -137,8 +140,8 @@ func HTTPBodyNotContainsf(t TestingT, handler http.HandlerFunc, method string, u | |||
// assert.HTTPErrorf(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}} | |||
// | |||
// Returns whether the assertion was successful (true, "error message %s", "formatted") or not (false). | |||
func HTTPErrorf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values) bool { | |||
return HTTPError(t, handler, method, url, values) | |||
func HTTPErrorf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool { | |||
return HTTPError(t, handler, method, url, values, append([]interface{}{msg}, args...)...) | |||
} | |||
// HTTPRedirectf asserts that a specified handler returns a redirect status code. | |||
@@ -146,8 +149,8 @@ func HTTPErrorf(t TestingT, handler http.HandlerFunc, method string, url string, | |||
// assert.HTTPRedirectf(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}} | |||
// | |||
// Returns whether the assertion was successful (true, "error message %s", "formatted") or not (false). | |||
func HTTPRedirectf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values) bool { | |||
return HTTPRedirect(t, handler, method, url, values) | |||
func HTTPRedirectf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool { | |||
return HTTPRedirect(t, handler, method, url, values, append([]interface{}{msg}, args...)...) | |||
} | |||
// HTTPSuccessf asserts that a specified handler returns a success status code. | |||
@@ -155,8 +158,8 @@ func HTTPRedirectf(t TestingT, handler http.HandlerFunc, method string, url stri | |||
// assert.HTTPSuccessf(t, myHandler, "POST", "http://www.google.com", nil, "error message %s", "formatted") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func HTTPSuccessf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values) bool { | |||
return HTTPSuccess(t, handler, method, url, values) | |||
func HTTPSuccessf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool { | |||
return HTTPSuccess(t, handler, method, url, values, append([]interface{}{msg}, args...)...) | |||
} | |||
// Implementsf asserts that an object is implemented by the specified interface. | |||
@@ -169,20 +172,21 @@ func Implementsf(t TestingT, interfaceObject interface{}, object interface{}, ms | |||
// InDeltaf asserts that the two numerals are within delta of each other. | |||
// | |||
// assert.InDeltaf(t, math.Pi, (22 / 7.0, "error message %s", "formatted"), 0.01) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func InDeltaf(t TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool { | |||
return InDelta(t, expected, actual, delta, append([]interface{}{msg}, args...)...) | |||
} | |||
// InDeltaMapValuesf is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys. | |||
func InDeltaMapValuesf(t TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool { | |||
return InDeltaMapValues(t, expected, actual, delta, append([]interface{}{msg}, args...)...) | |||
} | |||
// InDeltaSlicef is the same as InDelta, except it compares two slices. | |||
func InDeltaSlicef(t TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool { | |||
return InDeltaSlice(t, expected, actual, delta, append([]interface{}{msg}, args...)...) | |||
} | |||
// InEpsilonf asserts that expected and actual have a relative error less than epsilon | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func InEpsilonf(t TestingT, expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) bool { | |||
return InEpsilon(t, expected, actual, epsilon, append([]interface{}{msg}, args...)...) | |||
} | |||
@@ -200,8 +204,6 @@ func IsTypef(t TestingT, expectedType interface{}, object interface{}, msg strin | |||
// JSONEqf asserts that two JSON strings are equivalent. | |||
// | |||
// assert.JSONEqf(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`, "error message %s", "formatted") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func JSONEqf(t TestingT, expected string, actual string, msg string, args ...interface{}) bool { | |||
return JSONEq(t, expected, actual, append([]interface{}{msg}, args...)...) | |||
} | |||
@@ -210,8 +212,6 @@ func JSONEqf(t TestingT, expected string, actual string, msg string, args ...int | |||
// Lenf also fails if the object has a type that len() not accept. | |||
// | |||
// assert.Lenf(t, mySlice, 3, "error message %s", "formatted") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func Lenf(t TestingT, object interface{}, length int, msg string, args ...interface{}) bool { | |||
return Len(t, object, length, append([]interface{}{msg}, args...)...) | |||
} | |||
@@ -219,8 +219,6 @@ func Lenf(t TestingT, object interface{}, length int, msg string, args ...interf | |||
// Nilf asserts that the specified object is nil. | |||
// | |||
// assert.Nilf(t, err, "error message %s", "formatted") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func Nilf(t TestingT, object interface{}, msg string, args ...interface{}) bool { | |||
return Nil(t, object, append([]interface{}{msg}, args...)...) | |||
} | |||
@@ -231,8 +229,6 @@ func Nilf(t TestingT, object interface{}, msg string, args ...interface{}) bool | |||
// if assert.NoErrorf(t, err, "error message %s", "formatted") { | |||
// assert.Equal(t, expectedObj, actualObj) | |||
// } | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func NoErrorf(t TestingT, err error, msg string, args ...interface{}) bool { | |||
return NoError(t, err, append([]interface{}{msg}, args...)...) | |||
} | |||
@@ -243,8 +239,6 @@ func NoErrorf(t TestingT, err error, msg string, args ...interface{}) bool { | |||
// assert.NotContainsf(t, "Hello World", "Earth", "error message %s", "formatted") | |||
// assert.NotContainsf(t, ["Hello", "World"], "Earth", "error message %s", "formatted") | |||
// assert.NotContainsf(t, {"Hello": "World"}, "Earth", "error message %s", "formatted") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func NotContainsf(t TestingT, s interface{}, contains interface{}, msg string, args ...interface{}) bool { | |||
return NotContains(t, s, contains, append([]interface{}{msg}, args...)...) | |||
} | |||
@@ -255,8 +249,6 @@ func NotContainsf(t TestingT, s interface{}, contains interface{}, msg string, a | |||
// if assert.NotEmptyf(t, obj, "error message %s", "formatted") { | |||
// assert.Equal(t, "two", obj[1]) | |||
// } | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func NotEmptyf(t TestingT, object interface{}, msg string, args ...interface{}) bool { | |||
return NotEmpty(t, object, append([]interface{}{msg}, args...)...) | |||
} | |||
@@ -265,8 +257,6 @@ func NotEmptyf(t TestingT, object interface{}, msg string, args ...interface{}) | |||
// | |||
// assert.NotEqualf(t, obj1, obj2, "error message %s", "formatted") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
// | |||
// Pointer variable equality is determined based on the equality of the | |||
// referenced values (as opposed to the memory addresses). | |||
func NotEqualf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool { | |||
@@ -276,8 +266,6 @@ func NotEqualf(t TestingT, expected interface{}, actual interface{}, msg string, | |||
// NotNilf asserts that the specified object is not nil. | |||
// | |||
// assert.NotNilf(t, err, "error message %s", "formatted") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func NotNilf(t TestingT, object interface{}, msg string, args ...interface{}) bool { | |||
return NotNil(t, object, append([]interface{}{msg}, args...)...) | |||
} | |||
@@ -285,8 +273,6 @@ func NotNilf(t TestingT, object interface{}, msg string, args ...interface{}) bo | |||
// NotPanicsf asserts that the code inside the specified PanicTestFunc does NOT panic. | |||
// | |||
// assert.NotPanicsf(t, func(){ RemainCalm() }, "error message %s", "formatted") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func NotPanicsf(t TestingT, f PanicTestFunc, msg string, args ...interface{}) bool { | |||
return NotPanics(t, f, append([]interface{}{msg}, args...)...) | |||
} | |||
@@ -295,8 +281,6 @@ func NotPanicsf(t TestingT, f PanicTestFunc, msg string, args ...interface{}) bo | |||
// | |||
// assert.NotRegexpf(t, regexp.MustCompile("starts", "error message %s", "formatted"), "it's starting") | |||
// assert.NotRegexpf(t, "^start", "it's not starting", "error message %s", "formatted") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func NotRegexpf(t TestingT, rx interface{}, str interface{}, msg string, args ...interface{}) bool { | |||
return NotRegexp(t, rx, str, append([]interface{}{msg}, args...)...) | |||
} | |||
@@ -305,13 +289,11 @@ func NotRegexpf(t TestingT, rx interface{}, str interface{}, msg string, args .. | |||
// elements given in the specified subset(array, slice...). | |||
// | |||
// assert.NotSubsetf(t, [1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]", "error message %s", "formatted") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func NotSubsetf(t TestingT, list interface{}, subset interface{}, msg string, args ...interface{}) bool { | |||
return NotSubset(t, list, subset, append([]interface{}{msg}, args...)...) | |||
} | |||
// NotZerof asserts that i is not the zero value for its type and returns the truth. | |||
// NotZerof asserts that i is not the zero value for its type. | |||
func NotZerof(t TestingT, i interface{}, msg string, args ...interface{}) bool { | |||
return NotZero(t, i, append([]interface{}{msg}, args...)...) | |||
} | |||
@@ -319,8 +301,6 @@ func NotZerof(t TestingT, i interface{}, msg string, args ...interface{}) bool { | |||
// Panicsf asserts that the code inside the specified PanicTestFunc panics. | |||
// | |||
// assert.Panicsf(t, func(){ GoCrazy() }, "error message %s", "formatted") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func Panicsf(t TestingT, f PanicTestFunc, msg string, args ...interface{}) bool { | |||
return Panics(t, f, append([]interface{}{msg}, args...)...) | |||
} | |||
@@ -329,8 +309,6 @@ func Panicsf(t TestingT, f PanicTestFunc, msg string, args ...interface{}) bool | |||
// the recovered panic value equals the expected panic value. | |||
// | |||
// assert.PanicsWithValuef(t, "crazy error", func(){ GoCrazy() }, "error message %s", "formatted") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func PanicsWithValuef(t TestingT, expected interface{}, f PanicTestFunc, msg string, args ...interface{}) bool { | |||
return PanicsWithValue(t, expected, f, append([]interface{}{msg}, args...)...) | |||
} | |||
@@ -339,8 +317,6 @@ func PanicsWithValuef(t TestingT, expected interface{}, f PanicTestFunc, msg str | |||
// | |||
// assert.Regexpf(t, regexp.MustCompile("start", "error message %s", "formatted"), "it's starting") | |||
// assert.Regexpf(t, "start...$", "it's not starting", "error message %s", "formatted") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func Regexpf(t TestingT, rx interface{}, str interface{}, msg string, args ...interface{}) bool { | |||
return Regexp(t, rx, str, append([]interface{}{msg}, args...)...) | |||
} | |||
@@ -349,8 +325,6 @@ func Regexpf(t TestingT, rx interface{}, str interface{}, msg string, args ...in | |||
// elements given in the specified subset(array, slice...). | |||
// | |||
// assert.Subsetf(t, [1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]", "error message %s", "formatted") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func Subsetf(t TestingT, list interface{}, subset interface{}, msg string, args ...interface{}) bool { | |||
return Subset(t, list, subset, append([]interface{}{msg}, args...)...) | |||
} | |||
@@ -358,8 +332,6 @@ func Subsetf(t TestingT, list interface{}, subset interface{}, msg string, args | |||
// Truef asserts that the specified value is true. | |||
// | |||
// assert.Truef(t, myBool, "error message %s", "formatted") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func Truef(t TestingT, value bool, msg string, args ...interface{}) bool { | |||
return True(t, value, append([]interface{}{msg}, args...)...) | |||
} | |||
@@ -367,13 +339,11 @@ func Truef(t TestingT, value bool, msg string, args ...interface{}) bool { | |||
// WithinDurationf asserts that the two times are within duration delta of each other. | |||
// | |||
// assert.WithinDurationf(t, time.Now(), time.Now(), 10*time.Second, "error message %s", "formatted") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func WithinDurationf(t TestingT, expected time.Time, actual time.Time, delta time.Duration, msg string, args ...interface{}) bool { | |||
return WithinDuration(t, expected, actual, delta, append([]interface{}{msg}, args...)...) | |||
} | |||
// Zerof asserts that i is the zero value for its type and returns the truth. | |||
// Zerof asserts that i is the zero value for its type. | |||
func Zerof(t TestingT, i interface{}, msg string, args ...interface{}) bool { | |||
return Zero(t, i, append([]interface{}{msg}, args...)...) | |||
} |
@@ -27,8 +27,6 @@ func (a *Assertions) Conditionf(comp Comparison, msg string, args ...interface{} | |||
// a.Contains("Hello World", "World") | |||
// a.Contains(["Hello", "World"], "World") | |||
// a.Contains({"Hello": "World"}, "Hello") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) Contains(s interface{}, contains interface{}, msgAndArgs ...interface{}) bool { | |||
return Contains(a.t, s, contains, msgAndArgs...) | |||
} | |||
@@ -39,18 +37,42 @@ func (a *Assertions) Contains(s interface{}, contains interface{}, msgAndArgs .. | |||
// a.Containsf("Hello World", "World", "error message %s", "formatted") | |||
// a.Containsf(["Hello", "World"], "World", "error message %s", "formatted") | |||
// a.Containsf({"Hello": "World"}, "Hello", "error message %s", "formatted") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) Containsf(s interface{}, contains interface{}, msg string, args ...interface{}) bool { | |||
return Containsf(a.t, s, contains, msg, args...) | |||
} | |||
// DirExists checks whether a directory exists in the given path. It also fails if the path is a file rather a directory or there is an error checking whether it exists. | |||
func (a *Assertions) DirExists(path string, msgAndArgs ...interface{}) bool { | |||
return DirExists(a.t, path, msgAndArgs...) | |||
} | |||
// DirExistsf checks whether a directory exists in the given path. It also fails if the path is a file rather a directory or there is an error checking whether it exists. | |||
func (a *Assertions) DirExistsf(path string, msg string, args ...interface{}) bool { | |||
return DirExistsf(a.t, path, msg, args...) | |||
} | |||
// ElementsMatch asserts that the specified listA(array, slice...) is equal to specified | |||
// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements, | |||
// the number of appearances of each of them in both lists should match. | |||
// | |||
// a.ElementsMatch([1, 3, 2, 3], [1, 3, 3, 2]) | |||
func (a *Assertions) ElementsMatch(listA interface{}, listB interface{}, msgAndArgs ...interface{}) bool { | |||
return ElementsMatch(a.t, listA, listB, msgAndArgs...) | |||
} | |||
// ElementsMatchf asserts that the specified listA(array, slice...) is equal to specified | |||
// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements, | |||
// the number of appearances of each of them in both lists should match. | |||
// | |||
// a.ElementsMatchf([1, 3, 2, 3], [1, 3, 3, 2], "error message %s", "formatted") | |||
func (a *Assertions) ElementsMatchf(listA interface{}, listB interface{}, msg string, args ...interface{}) bool { | |||
return ElementsMatchf(a.t, listA, listB, msg, args...) | |||
} | |||
// Empty asserts that the specified object is empty. I.e. nil, "", false, 0 or either | |||
// a slice or a channel with len == 0. | |||
// | |||
// a.Empty(obj) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) Empty(object interface{}, msgAndArgs ...interface{}) bool { | |||
return Empty(a.t, object, msgAndArgs...) | |||
} | |||
@@ -59,8 +81,6 @@ func (a *Assertions) Empty(object interface{}, msgAndArgs ...interface{}) bool { | |||
// a slice or a channel with len == 0. | |||
// | |||
// a.Emptyf(obj, "error message %s", "formatted") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) Emptyf(object interface{}, msg string, args ...interface{}) bool { | |||
return Emptyf(a.t, object, msg, args...) | |||
} | |||
@@ -69,8 +89,6 @@ func (a *Assertions) Emptyf(object interface{}, msg string, args ...interface{}) | |||
// | |||
// a.Equal(123, 123) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
// | |||
// Pointer variable equality is determined based on the equality of the | |||
// referenced values (as opposed to the memory addresses). Function equality | |||
// cannot be determined and will always fail. | |||
@@ -83,8 +101,6 @@ func (a *Assertions) Equal(expected interface{}, actual interface{}, msgAndArgs | |||
// | |||
// actualObj, err := SomeFunction() | |||
// a.EqualError(err, expectedErrorString) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) EqualError(theError error, errString string, msgAndArgs ...interface{}) bool { | |||
return EqualError(a.t, theError, errString, msgAndArgs...) | |||
} | |||
@@ -94,8 +110,6 @@ func (a *Assertions) EqualError(theError error, errString string, msgAndArgs ... | |||
// | |||
// actualObj, err := SomeFunction() | |||
// a.EqualErrorf(err, expectedErrorString, "error message %s", "formatted") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) EqualErrorf(theError error, errString string, msg string, args ...interface{}) bool { | |||
return EqualErrorf(a.t, theError, errString, msg, args...) | |||
} | |||
@@ -104,8 +118,6 @@ func (a *Assertions) EqualErrorf(theError error, errString string, msg string, a | |||
// and equal. | |||
// | |||
// a.EqualValues(uint32(123), int32(123)) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) EqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool { | |||
return EqualValues(a.t, expected, actual, msgAndArgs...) | |||
} | |||
@@ -114,8 +126,6 @@ func (a *Assertions) EqualValues(expected interface{}, actual interface{}, msgAn | |||
// and equal. | |||
// | |||
// a.EqualValuesf(uint32(123, "error message %s", "formatted"), int32(123)) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) EqualValuesf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool { | |||
return EqualValuesf(a.t, expected, actual, msg, args...) | |||
} | |||
@@ -124,8 +134,6 @@ func (a *Assertions) EqualValuesf(expected interface{}, actual interface{}, msg | |||
// | |||
// a.Equalf(123, 123, "error message %s", "formatted") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
// | |||
// Pointer variable equality is determined based on the equality of the | |||
// referenced values (as opposed to the memory addresses). Function equality | |||
// cannot be determined and will always fail. | |||
@@ -139,8 +147,6 @@ func (a *Assertions) Equalf(expected interface{}, actual interface{}, msg string | |||
// if a.Error(err) { | |||
// assert.Equal(t, expectedError, err) | |||
// } | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) Error(err error, msgAndArgs ...interface{}) bool { | |||
return Error(a.t, err, msgAndArgs...) | |||
} | |||
@@ -151,26 +157,20 @@ func (a *Assertions) Error(err error, msgAndArgs ...interface{}) bool { | |||
// if a.Errorf(err, "error message %s", "formatted") { | |||
// assert.Equal(t, expectedErrorf, err) | |||
// } | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) Errorf(err error, msg string, args ...interface{}) bool { | |||
return Errorf(a.t, err, msg, args...) | |||
} | |||
// Exactly asserts that two objects are equal is value and type. | |||
// Exactly asserts that two objects are equal in value and type. | |||
// | |||
// a.Exactly(int32(123), int64(123)) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) Exactly(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool { | |||
return Exactly(a.t, expected, actual, msgAndArgs...) | |||
} | |||
// Exactlyf asserts that two objects are equal is value and type. | |||
// Exactlyf asserts that two objects are equal in value and type. | |||
// | |||
// a.Exactlyf(int32(123, "error message %s", "formatted"), int64(123)) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) Exactlyf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool { | |||
return Exactlyf(a.t, expected, actual, msg, args...) | |||
} | |||
@@ -198,8 +198,6 @@ func (a *Assertions) Failf(failureMessage string, msg string, args ...interface{ | |||
// False asserts that the specified value is false. | |||
// | |||
// a.False(myBool) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) False(value bool, msgAndArgs ...interface{}) bool { | |||
return False(a.t, value, msgAndArgs...) | |||
} | |||
@@ -207,20 +205,28 @@ func (a *Assertions) False(value bool, msgAndArgs ...interface{}) bool { | |||
// Falsef asserts that the specified value is false. | |||
// | |||
// a.Falsef(myBool, "error message %s", "formatted") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) Falsef(value bool, msg string, args ...interface{}) bool { | |||
return Falsef(a.t, value, msg, args...) | |||
} | |||
// FileExists checks whether a file exists in the given path. It also fails if the path points to a directory or there is an error when trying to check the file. | |||
func (a *Assertions) FileExists(path string, msgAndArgs ...interface{}) bool { | |||
return FileExists(a.t, path, msgAndArgs...) | |||
} | |||
// FileExistsf checks whether a file exists in the given path. It also fails if the path points to a directory or there is an error when trying to check the file. | |||
func (a *Assertions) FileExistsf(path string, msg string, args ...interface{}) bool { | |||
return FileExistsf(a.t, path, msg, args...) | |||
} | |||
// HTTPBodyContains asserts that a specified handler returns a | |||
// body that contains a string. | |||
// | |||
// a.HTTPBodyContains(myHandler, "www.google.com", nil, "I'm Feeling Lucky") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) HTTPBodyContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}) bool { | |||
return HTTPBodyContains(a.t, handler, method, url, values, str) | |||
func (a *Assertions) HTTPBodyContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) bool { | |||
return HTTPBodyContains(a.t, handler, method, url, values, str, msgAndArgs...) | |||
} | |||
// HTTPBodyContainsf asserts that a specified handler returns a | |||
@@ -229,8 +235,8 @@ func (a *Assertions) HTTPBodyContains(handler http.HandlerFunc, method string, u | |||
// a.HTTPBodyContainsf(myHandler, "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) HTTPBodyContainsf(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}) bool { | |||
return HTTPBodyContainsf(a.t, handler, method, url, values, str) | |||
func (a *Assertions) HTTPBodyContainsf(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) bool { | |||
return HTTPBodyContainsf(a.t, handler, method, url, values, str, msg, args...) | |||
} | |||
// HTTPBodyNotContains asserts that a specified handler returns a | |||
@@ -239,8 +245,8 @@ func (a *Assertions) HTTPBodyContainsf(handler http.HandlerFunc, method string, | |||
// a.HTTPBodyNotContains(myHandler, "www.google.com", nil, "I'm Feeling Lucky") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) HTTPBodyNotContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}) bool { | |||
return HTTPBodyNotContains(a.t, handler, method, url, values, str) | |||
func (a *Assertions) HTTPBodyNotContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) bool { | |||
return HTTPBodyNotContains(a.t, handler, method, url, values, str, msgAndArgs...) | |||
} | |||
// HTTPBodyNotContainsf asserts that a specified handler returns a | |||
@@ -249,8 +255,8 @@ func (a *Assertions) HTTPBodyNotContains(handler http.HandlerFunc, method string | |||
// a.HTTPBodyNotContainsf(myHandler, "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) HTTPBodyNotContainsf(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}) bool { | |||
return HTTPBodyNotContainsf(a.t, handler, method, url, values, str) | |||
func (a *Assertions) HTTPBodyNotContainsf(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) bool { | |||
return HTTPBodyNotContainsf(a.t, handler, method, url, values, str, msg, args...) | |||
} | |||
// HTTPError asserts that a specified handler returns an error status code. | |||
@@ -258,8 +264,8 @@ func (a *Assertions) HTTPBodyNotContainsf(handler http.HandlerFunc, method strin | |||
// a.HTTPError(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}} | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) HTTPError(handler http.HandlerFunc, method string, url string, values url.Values) bool { | |||
return HTTPError(a.t, handler, method, url, values) | |||
func (a *Assertions) HTTPError(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) bool { | |||
return HTTPError(a.t, handler, method, url, values, msgAndArgs...) | |||
} | |||
// HTTPErrorf asserts that a specified handler returns an error status code. | |||
@@ -267,8 +273,8 @@ func (a *Assertions) HTTPError(handler http.HandlerFunc, method string, url stri | |||
// a.HTTPErrorf(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}} | |||
// | |||
// Returns whether the assertion was successful (true, "error message %s", "formatted") or not (false). | |||
func (a *Assertions) HTTPErrorf(handler http.HandlerFunc, method string, url string, values url.Values) bool { | |||
return HTTPErrorf(a.t, handler, method, url, values) | |||
func (a *Assertions) HTTPErrorf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool { | |||
return HTTPErrorf(a.t, handler, method, url, values, msg, args...) | |||
} | |||
// HTTPRedirect asserts that a specified handler returns a redirect status code. | |||
@@ -276,8 +282,8 @@ func (a *Assertions) HTTPErrorf(handler http.HandlerFunc, method string, url str | |||
// a.HTTPRedirect(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}} | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) HTTPRedirect(handler http.HandlerFunc, method string, url string, values url.Values) bool { | |||
return HTTPRedirect(a.t, handler, method, url, values) | |||
func (a *Assertions) HTTPRedirect(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) bool { | |||
return HTTPRedirect(a.t, handler, method, url, values, msgAndArgs...) | |||
} | |||
// HTTPRedirectf asserts that a specified handler returns a redirect status code. | |||
@@ -285,8 +291,8 @@ func (a *Assertions) HTTPRedirect(handler http.HandlerFunc, method string, url s | |||
// a.HTTPRedirectf(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}} | |||
// | |||
// Returns whether the assertion was successful (true, "error message %s", "formatted") or not (false). | |||
func (a *Assertions) HTTPRedirectf(handler http.HandlerFunc, method string, url string, values url.Values) bool { | |||
return HTTPRedirectf(a.t, handler, method, url, values) | |||
func (a *Assertions) HTTPRedirectf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool { | |||
return HTTPRedirectf(a.t, handler, method, url, values, msg, args...) | |||
} | |||
// HTTPSuccess asserts that a specified handler returns a success status code. | |||
@@ -294,8 +300,8 @@ func (a *Assertions) HTTPRedirectf(handler http.HandlerFunc, method string, url | |||
// a.HTTPSuccess(myHandler, "POST", "http://www.google.com", nil) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) HTTPSuccess(handler http.HandlerFunc, method string, url string, values url.Values) bool { | |||
return HTTPSuccess(a.t, handler, method, url, values) | |||
func (a *Assertions) HTTPSuccess(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) bool { | |||
return HTTPSuccess(a.t, handler, method, url, values, msgAndArgs...) | |||
} | |||
// HTTPSuccessf asserts that a specified handler returns a success status code. | |||
@@ -303,8 +309,8 @@ func (a *Assertions) HTTPSuccess(handler http.HandlerFunc, method string, url st | |||
// a.HTTPSuccessf(myHandler, "POST", "http://www.google.com", nil, "error message %s", "formatted") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) HTTPSuccessf(handler http.HandlerFunc, method string, url string, values url.Values) bool { | |||
return HTTPSuccessf(a.t, handler, method, url, values) | |||
func (a *Assertions) HTTPSuccessf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool { | |||
return HTTPSuccessf(a.t, handler, method, url, values, msg, args...) | |||
} | |||
// Implements asserts that an object is implemented by the specified interface. | |||
@@ -324,12 +330,20 @@ func (a *Assertions) Implementsf(interfaceObject interface{}, object interface{} | |||
// InDelta asserts that the two numerals are within delta of each other. | |||
// | |||
// a.InDelta(math.Pi, (22 / 7.0), 0.01) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) InDelta(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) bool { | |||
return InDelta(a.t, expected, actual, delta, msgAndArgs...) | |||
} | |||
// InDeltaMapValues is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys. | |||
func (a *Assertions) InDeltaMapValues(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) bool { | |||
return InDeltaMapValues(a.t, expected, actual, delta, msgAndArgs...) | |||
} | |||
// InDeltaMapValuesf is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys. | |||
func (a *Assertions) InDeltaMapValuesf(expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool { | |||
return InDeltaMapValuesf(a.t, expected, actual, delta, msg, args...) | |||
} | |||
// InDeltaSlice is the same as InDelta, except it compares two slices. | |||
func (a *Assertions) InDeltaSlice(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) bool { | |||
return InDeltaSlice(a.t, expected, actual, delta, msgAndArgs...) | |||
@@ -343,15 +357,11 @@ func (a *Assertions) InDeltaSlicef(expected interface{}, actual interface{}, del | |||
// InDeltaf asserts that the two numerals are within delta of each other. | |||
// | |||
// a.InDeltaf(math.Pi, (22 / 7.0, "error message %s", "formatted"), 0.01) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) InDeltaf(expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool { | |||
return InDeltaf(a.t, expected, actual, delta, msg, args...) | |||
} | |||
// InEpsilon asserts that expected and actual have a relative error less than epsilon | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) InEpsilon(expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool { | |||
return InEpsilon(a.t, expected, actual, epsilon, msgAndArgs...) | |||
} | |||
@@ -367,8 +377,6 @@ func (a *Assertions) InEpsilonSlicef(expected interface{}, actual interface{}, e | |||
} | |||
// InEpsilonf asserts that expected and actual have a relative error less than epsilon | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) InEpsilonf(expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) bool { | |||
return InEpsilonf(a.t, expected, actual, epsilon, msg, args...) | |||
} | |||
@@ -386,8 +394,6 @@ func (a *Assertions) IsTypef(expectedType interface{}, object interface{}, msg s | |||
// JSONEq asserts that two JSON strings are equivalent. | |||
// | |||
// a.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) JSONEq(expected string, actual string, msgAndArgs ...interface{}) bool { | |||
return JSONEq(a.t, expected, actual, msgAndArgs...) | |||
} | |||
@@ -395,8 +401,6 @@ func (a *Assertions) JSONEq(expected string, actual string, msgAndArgs ...interf | |||
// JSONEqf asserts that two JSON strings are equivalent. | |||
// | |||
// a.JSONEqf(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`, "error message %s", "formatted") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) JSONEqf(expected string, actual string, msg string, args ...interface{}) bool { | |||
return JSONEqf(a.t, expected, actual, msg, args...) | |||
} | |||
@@ -405,8 +409,6 @@ func (a *Assertions) JSONEqf(expected string, actual string, msg string, args .. | |||
// Len also fails if the object has a type that len() not accept. | |||
// | |||
// a.Len(mySlice, 3) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) Len(object interface{}, length int, msgAndArgs ...interface{}) bool { | |||
return Len(a.t, object, length, msgAndArgs...) | |||
} | |||
@@ -415,8 +417,6 @@ func (a *Assertions) Len(object interface{}, length int, msgAndArgs ...interface | |||
// Lenf also fails if the object has a type that len() not accept. | |||
// | |||
// a.Lenf(mySlice, 3, "error message %s", "formatted") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) Lenf(object interface{}, length int, msg string, args ...interface{}) bool { | |||
return Lenf(a.t, object, length, msg, args...) | |||
} | |||
@@ -424,8 +424,6 @@ func (a *Assertions) Lenf(object interface{}, length int, msg string, args ...in | |||
// Nil asserts that the specified object is nil. | |||
// | |||
// a.Nil(err) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) Nil(object interface{}, msgAndArgs ...interface{}) bool { | |||
return Nil(a.t, object, msgAndArgs...) | |||
} | |||
@@ -433,8 +431,6 @@ func (a *Assertions) Nil(object interface{}, msgAndArgs ...interface{}) bool { | |||
// Nilf asserts that the specified object is nil. | |||
// | |||
// a.Nilf(err, "error message %s", "formatted") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) Nilf(object interface{}, msg string, args ...interface{}) bool { | |||
return Nilf(a.t, object, msg, args...) | |||
} | |||
@@ -445,8 +441,6 @@ func (a *Assertions) Nilf(object interface{}, msg string, args ...interface{}) b | |||
// if a.NoError(err) { | |||
// assert.Equal(t, expectedObj, actualObj) | |||
// } | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) NoError(err error, msgAndArgs ...interface{}) bool { | |||
return NoError(a.t, err, msgAndArgs...) | |||
} | |||
@@ -457,8 +451,6 @@ func (a *Assertions) NoError(err error, msgAndArgs ...interface{}) bool { | |||
// if a.NoErrorf(err, "error message %s", "formatted") { | |||
// assert.Equal(t, expectedObj, actualObj) | |||
// } | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) NoErrorf(err error, msg string, args ...interface{}) bool { | |||
return NoErrorf(a.t, err, msg, args...) | |||
} | |||
@@ -469,8 +461,6 @@ func (a *Assertions) NoErrorf(err error, msg string, args ...interface{}) bool { | |||
// a.NotContains("Hello World", "Earth") | |||
// a.NotContains(["Hello", "World"], "Earth") | |||
// a.NotContains({"Hello": "World"}, "Earth") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) NotContains(s interface{}, contains interface{}, msgAndArgs ...interface{}) bool { | |||
return NotContains(a.t, s, contains, msgAndArgs...) | |||
} | |||
@@ -481,8 +471,6 @@ func (a *Assertions) NotContains(s interface{}, contains interface{}, msgAndArgs | |||
// a.NotContainsf("Hello World", "Earth", "error message %s", "formatted") | |||
// a.NotContainsf(["Hello", "World"], "Earth", "error message %s", "formatted") | |||
// a.NotContainsf({"Hello": "World"}, "Earth", "error message %s", "formatted") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) NotContainsf(s interface{}, contains interface{}, msg string, args ...interface{}) bool { | |||
return NotContainsf(a.t, s, contains, msg, args...) | |||
} | |||
@@ -493,8 +481,6 @@ func (a *Assertions) NotContainsf(s interface{}, contains interface{}, msg strin | |||
// if a.NotEmpty(obj) { | |||
// assert.Equal(t, "two", obj[1]) | |||
// } | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) NotEmpty(object interface{}, msgAndArgs ...interface{}) bool { | |||
return NotEmpty(a.t, object, msgAndArgs...) | |||
} | |||
@@ -505,8 +491,6 @@ func (a *Assertions) NotEmpty(object interface{}, msgAndArgs ...interface{}) boo | |||
// if a.NotEmptyf(obj, "error message %s", "formatted") { | |||
// assert.Equal(t, "two", obj[1]) | |||
// } | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) NotEmptyf(object interface{}, msg string, args ...interface{}) bool { | |||
return NotEmptyf(a.t, object, msg, args...) | |||
} | |||
@@ -515,8 +499,6 @@ func (a *Assertions) NotEmptyf(object interface{}, msg string, args ...interface | |||
// | |||
// a.NotEqual(obj1, obj2) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
// | |||
// Pointer variable equality is determined based on the equality of the | |||
// referenced values (as opposed to the memory addresses). | |||
func (a *Assertions) NotEqual(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool { | |||
@@ -527,8 +509,6 @@ func (a *Assertions) NotEqual(expected interface{}, actual interface{}, msgAndAr | |||
// | |||
// a.NotEqualf(obj1, obj2, "error message %s", "formatted") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
// | |||
// Pointer variable equality is determined based on the equality of the | |||
// referenced values (as opposed to the memory addresses). | |||
func (a *Assertions) NotEqualf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool { | |||
@@ -538,8 +518,6 @@ func (a *Assertions) NotEqualf(expected interface{}, actual interface{}, msg str | |||
// NotNil asserts that the specified object is not nil. | |||
// | |||
// a.NotNil(err) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) NotNil(object interface{}, msgAndArgs ...interface{}) bool { | |||
return NotNil(a.t, object, msgAndArgs...) | |||
} | |||
@@ -547,8 +525,6 @@ func (a *Assertions) NotNil(object interface{}, msgAndArgs ...interface{}) bool | |||
// NotNilf asserts that the specified object is not nil. | |||
// | |||
// a.NotNilf(err, "error message %s", "formatted") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) NotNilf(object interface{}, msg string, args ...interface{}) bool { | |||
return NotNilf(a.t, object, msg, args...) | |||
} | |||
@@ -556,8 +532,6 @@ func (a *Assertions) NotNilf(object interface{}, msg string, args ...interface{} | |||
// NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic. | |||
// | |||
// a.NotPanics(func(){ RemainCalm() }) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) NotPanics(f PanicTestFunc, msgAndArgs ...interface{}) bool { | |||
return NotPanics(a.t, f, msgAndArgs...) | |||
} | |||
@@ -565,8 +539,6 @@ func (a *Assertions) NotPanics(f PanicTestFunc, msgAndArgs ...interface{}) bool | |||
// NotPanicsf asserts that the code inside the specified PanicTestFunc does NOT panic. | |||
// | |||
// a.NotPanicsf(func(){ RemainCalm() }, "error message %s", "formatted") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) NotPanicsf(f PanicTestFunc, msg string, args ...interface{}) bool { | |||
return NotPanicsf(a.t, f, msg, args...) | |||
} | |||
@@ -575,8 +547,6 @@ func (a *Assertions) NotPanicsf(f PanicTestFunc, msg string, args ...interface{} | |||
// | |||
// a.NotRegexp(regexp.MustCompile("starts"), "it's starting") | |||
// a.NotRegexp("^start", "it's not starting") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) NotRegexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) bool { | |||
return NotRegexp(a.t, rx, str, msgAndArgs...) | |||
} | |||
@@ -585,8 +555,6 @@ func (a *Assertions) NotRegexp(rx interface{}, str interface{}, msgAndArgs ...in | |||
// | |||
// a.NotRegexpf(regexp.MustCompile("starts", "error message %s", "formatted"), "it's starting") | |||
// a.NotRegexpf("^start", "it's not starting", "error message %s", "formatted") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) NotRegexpf(rx interface{}, str interface{}, msg string, args ...interface{}) bool { | |||
return NotRegexpf(a.t, rx, str, msg, args...) | |||
} | |||
@@ -595,8 +563,6 @@ func (a *Assertions) NotRegexpf(rx interface{}, str interface{}, msg string, arg | |||
// elements given in the specified subset(array, slice...). | |||
// | |||
// a.NotSubset([1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) NotSubset(list interface{}, subset interface{}, msgAndArgs ...interface{}) bool { | |||
return NotSubset(a.t, list, subset, msgAndArgs...) | |||
} | |||
@@ -605,18 +571,16 @@ func (a *Assertions) NotSubset(list interface{}, subset interface{}, msgAndArgs | |||
// elements given in the specified subset(array, slice...). | |||
// | |||
// a.NotSubsetf([1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]", "error message %s", "formatted") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) NotSubsetf(list interface{}, subset interface{}, msg string, args ...interface{}) bool { | |||
return NotSubsetf(a.t, list, subset, msg, args...) | |||
} | |||
// NotZero asserts that i is not the zero value for its type and returns the truth. | |||
// NotZero asserts that i is not the zero value for its type. | |||
func (a *Assertions) NotZero(i interface{}, msgAndArgs ...interface{}) bool { | |||
return NotZero(a.t, i, msgAndArgs...) | |||
} | |||
// NotZerof asserts that i is not the zero value for its type and returns the truth. | |||
// NotZerof asserts that i is not the zero value for its type. | |||
func (a *Assertions) NotZerof(i interface{}, msg string, args ...interface{}) bool { | |||
return NotZerof(a.t, i, msg, args...) | |||
} | |||
@@ -624,8 +588,6 @@ func (a *Assertions) NotZerof(i interface{}, msg string, args ...interface{}) bo | |||
// Panics asserts that the code inside the specified PanicTestFunc panics. | |||
// | |||
// a.Panics(func(){ GoCrazy() }) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) Panics(f PanicTestFunc, msgAndArgs ...interface{}) bool { | |||
return Panics(a.t, f, msgAndArgs...) | |||
} | |||
@@ -634,8 +596,6 @@ func (a *Assertions) Panics(f PanicTestFunc, msgAndArgs ...interface{}) bool { | |||
// the recovered panic value equals the expected panic value. | |||
// | |||
// a.PanicsWithValue("crazy error", func(){ GoCrazy() }) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) PanicsWithValue(expected interface{}, f PanicTestFunc, msgAndArgs ...interface{}) bool { | |||
return PanicsWithValue(a.t, expected, f, msgAndArgs...) | |||
} | |||
@@ -644,8 +604,6 @@ func (a *Assertions) PanicsWithValue(expected interface{}, f PanicTestFunc, msgA | |||
// the recovered panic value equals the expected panic value. | |||
// | |||
// a.PanicsWithValuef("crazy error", func(){ GoCrazy() }, "error message %s", "formatted") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) PanicsWithValuef(expected interface{}, f PanicTestFunc, msg string, args ...interface{}) bool { | |||
return PanicsWithValuef(a.t, expected, f, msg, args...) | |||
} | |||
@@ -653,8 +611,6 @@ func (a *Assertions) PanicsWithValuef(expected interface{}, f PanicTestFunc, msg | |||
// Panicsf asserts that the code inside the specified PanicTestFunc panics. | |||
// | |||
// a.Panicsf(func(){ GoCrazy() }, "error message %s", "formatted") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) Panicsf(f PanicTestFunc, msg string, args ...interface{}) bool { | |||
return Panicsf(a.t, f, msg, args...) | |||
} | |||
@@ -663,8 +619,6 @@ func (a *Assertions) Panicsf(f PanicTestFunc, msg string, args ...interface{}) b | |||
// | |||
// a.Regexp(regexp.MustCompile("start"), "it's starting") | |||
// a.Regexp("start...$", "it's not starting") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) Regexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) bool { | |||
return Regexp(a.t, rx, str, msgAndArgs...) | |||
} | |||
@@ -673,8 +627,6 @@ func (a *Assertions) Regexp(rx interface{}, str interface{}, msgAndArgs ...inter | |||
// | |||
// a.Regexpf(regexp.MustCompile("start", "error message %s", "formatted"), "it's starting") | |||
// a.Regexpf("start...$", "it's not starting", "error message %s", "formatted") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) Regexpf(rx interface{}, str interface{}, msg string, args ...interface{}) bool { | |||
return Regexpf(a.t, rx, str, msg, args...) | |||
} | |||
@@ -683,8 +635,6 @@ func (a *Assertions) Regexpf(rx interface{}, str interface{}, msg string, args . | |||
// elements given in the specified subset(array, slice...). | |||
// | |||
// a.Subset([1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) Subset(list interface{}, subset interface{}, msgAndArgs ...interface{}) bool { | |||
return Subset(a.t, list, subset, msgAndArgs...) | |||
} | |||
@@ -693,8 +643,6 @@ func (a *Assertions) Subset(list interface{}, subset interface{}, msgAndArgs ... | |||
// elements given in the specified subset(array, slice...). | |||
// | |||
// a.Subsetf([1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]", "error message %s", "formatted") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) Subsetf(list interface{}, subset interface{}, msg string, args ...interface{}) bool { | |||
return Subsetf(a.t, list, subset, msg, args...) | |||
} | |||
@@ -702,8 +650,6 @@ func (a *Assertions) Subsetf(list interface{}, subset interface{}, msg string, a | |||
// True asserts that the specified value is true. | |||
// | |||
// a.True(myBool) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) True(value bool, msgAndArgs ...interface{}) bool { | |||
return True(a.t, value, msgAndArgs...) | |||
} | |||
@@ -711,8 +657,6 @@ func (a *Assertions) True(value bool, msgAndArgs ...interface{}) bool { | |||
// Truef asserts that the specified value is true. | |||
// | |||
// a.Truef(myBool, "error message %s", "formatted") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) Truef(value bool, msg string, args ...interface{}) bool { | |||
return Truef(a.t, value, msg, args...) | |||
} | |||
@@ -720,8 +664,6 @@ func (a *Assertions) Truef(value bool, msg string, args ...interface{}) bool { | |||
// WithinDuration asserts that the two times are within duration delta of each other. | |||
// | |||
// a.WithinDuration(time.Now(), time.Now(), 10*time.Second) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) WithinDuration(expected time.Time, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) bool { | |||
return WithinDuration(a.t, expected, actual, delta, msgAndArgs...) | |||
} | |||
@@ -729,18 +671,16 @@ func (a *Assertions) WithinDuration(expected time.Time, actual time.Time, delta | |||
// WithinDurationf asserts that the two times are within duration delta of each other. | |||
// | |||
// a.WithinDurationf(time.Now(), time.Now(), 10*time.Second, "error message %s", "formatted") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func (a *Assertions) WithinDurationf(expected time.Time, actual time.Time, delta time.Duration, msg string, args ...interface{}) bool { | |||
return WithinDurationf(a.t, expected, actual, delta, msg, args...) | |||
} | |||
// Zero asserts that i is the zero value for its type and returns the truth. | |||
// Zero asserts that i is the zero value for its type. | |||
func (a *Assertions) Zero(i interface{}, msgAndArgs ...interface{}) bool { | |||
return Zero(a.t, i, msgAndArgs...) | |||
} | |||
// Zerof asserts that i is the zero value for its type and returns the truth. | |||
// Zerof asserts that i is the zero value for its type. | |||
func (a *Assertions) Zerof(i interface{}, msg string, args ...interface{}) bool { | |||
return Zerof(a.t, i, msg, args...) | |||
} |
@@ -7,6 +7,7 @@ import ( | |||
"errors" | |||
"fmt" | |||
"math" | |||
"os" | |||
"reflect" | |||
"regexp" | |||
"runtime" | |||
@@ -231,6 +232,13 @@ func Fail(t TestingT, failureMessage string, msgAndArgs ...interface{}) bool { | |||
{"Error", failureMessage}, | |||
} | |||
// Add test name if the Go version supports it | |||
if n, ok := t.(interface { | |||
Name() string | |||
}); ok { | |||
content = append(content, labeledContent{"Test", n.Name()}) | |||
} | |||
message := messageFromMsgAndArgs(msgAndArgs...) | |||
if len(message) > 0 { | |||
content = append(content, labeledContent{"Messages", message}) | |||
@@ -273,15 +281,16 @@ func labeledOutput(content ...labeledContent) string { | |||
// | |||
// assert.Implements(t, (*MyInterface)(nil), new(MyObject)) | |||
func Implements(t TestingT, interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) bool { | |||
interfaceType := reflect.TypeOf(interfaceObject).Elem() | |||
if object == nil { | |||
return Fail(t, fmt.Sprintf("Cannot check if nil implements %v", interfaceType), msgAndArgs...) | |||
} | |||
if !reflect.TypeOf(object).Implements(interfaceType) { | |||
return Fail(t, fmt.Sprintf("%T must implement %v", object, interfaceType), msgAndArgs...) | |||
} | |||
return true | |||
} | |||
// IsType asserts that the specified objects are of the same type. | |||
@@ -298,8 +307,6 @@ func IsType(t TestingT, expectedType interface{}, object interface{}, msgAndArgs | |||
// | |||
// assert.Equal(t, 123, 123) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
// | |||
// Pointer variable equality is determined based on the equality of the | |||
// referenced values (as opposed to the memory addresses). Function equality | |||
// cannot be determined and will always fail. | |||
@@ -314,7 +321,7 @@ func Equal(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) | |||
expected, actual = formatUnequalValues(expected, actual) | |||
return Fail(t, fmt.Sprintf("Not equal: \n"+ | |||
"expected: %s\n"+ | |||
"actual: %s%s", expected, actual, diff), msgAndArgs...) | |||
"actual : %s%s", expected, actual, diff), msgAndArgs...) | |||
} | |||
return true | |||
@@ -341,8 +348,6 @@ func formatUnequalValues(expected, actual interface{}) (e string, a string) { | |||
// and equal. | |||
// | |||
// assert.EqualValues(t, uint32(123), int32(123)) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func EqualValues(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool { | |||
if !ObjectsAreEqualValues(expected, actual) { | |||
@@ -350,18 +355,16 @@ func EqualValues(t TestingT, expected, actual interface{}, msgAndArgs ...interfa | |||
expected, actual = formatUnequalValues(expected, actual) | |||
return Fail(t, fmt.Sprintf("Not equal: \n"+ | |||
"expected: %s\n"+ | |||
"actual: %s%s", expected, actual, diff), msgAndArgs...) | |||
"actual : %s%s", expected, actual, diff), msgAndArgs...) | |||
} | |||
return true | |||
} | |||
// Exactly asserts that two objects are equal is value and type. | |||
// Exactly asserts that two objects are equal in value and type. | |||
// | |||
// assert.Exactly(t, int32(123), int64(123)) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func Exactly(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool { | |||
aType := reflect.TypeOf(expected) | |||
@@ -378,8 +381,6 @@ func Exactly(t TestingT, expected, actual interface{}, msgAndArgs ...interface{} | |||
// NotNil asserts that the specified object is not nil. | |||
// | |||
// assert.NotNil(t, err) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func NotNil(t TestingT, object interface{}, msgAndArgs ...interface{}) bool { | |||
if !isNil(object) { | |||
return true | |||
@@ -405,8 +406,6 @@ func isNil(object interface{}) bool { | |||
// Nil asserts that the specified object is nil. | |||
// | |||
// assert.Nil(t, err) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func Nil(t TestingT, object interface{}, msgAndArgs ...interface{}) bool { | |||
if isNil(object) { | |||
return true | |||
@@ -414,72 +413,38 @@ func Nil(t TestingT, object interface{}, msgAndArgs ...interface{}) bool { | |||
return Fail(t, fmt.Sprintf("Expected nil, but got: %#v", object), msgAndArgs...) | |||
} | |||
var numericZeros = []interface{}{ | |||
int(0), | |||
int8(0), | |||
int16(0), | |||
int32(0), | |||
int64(0), | |||
uint(0), | |||
uint8(0), | |||
uint16(0), | |||
uint32(0), | |||
uint64(0), | |||
float32(0), | |||
float64(0), | |||
} | |||
// isEmpty gets whether the specified object is considered empty or not. | |||
func isEmpty(object interface{}) bool { | |||
// get nil case out of the way | |||
if object == nil { | |||
return true | |||
} else if object == "" { | |||
return true | |||
} else if object == false { | |||
return true | |||
} | |||
for _, v := range numericZeros { | |||
if object == v { | |||
return true | |||
} | |||
} | |||
objValue := reflect.ValueOf(object) | |||
switch objValue.Kind() { | |||
case reflect.Array, reflect.Chan, reflect.Map, reflect.Slice, reflect.String: | |||
{ | |||
return (objValue.Len() == 0) | |||
} | |||
case reflect.Struct: | |||
switch object.(type) { | |||
case time.Time: | |||
return object.(time.Time).IsZero() | |||
} | |||
// collection types are empty when they have no element | |||
case reflect.Array, reflect.Chan, reflect.Map, reflect.Slice: | |||
return objValue.Len() == 0 | |||
// pointers are empty if nil or if the value they point to is empty | |||
case reflect.Ptr: | |||
{ | |||
if objValue.IsNil() { | |||
return true | |||
} | |||
switch object.(type) { | |||
case *time.Time: | |||
return object.(*time.Time).IsZero() | |||
default: | |||
return false | |||
} | |||
if objValue.IsNil() { | |||
return true | |||
} | |||
deref := objValue.Elem().Interface() | |||
return isEmpty(deref) | |||
// for all other types, compare against the zero value | |||
default: | |||
zero := reflect.Zero(objValue.Type()) | |||
return reflect.DeepEqual(object, zero.Interface()) | |||
} | |||
return false | |||
} | |||
// Empty asserts that the specified object is empty. I.e. nil, "", false, 0 or either | |||
// a slice or a channel with len == 0. | |||
// | |||
// assert.Empty(t, obj) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func Empty(t TestingT, object interface{}, msgAndArgs ...interface{}) bool { | |||
pass := isEmpty(object) | |||
@@ -497,8 +462,6 @@ func Empty(t TestingT, object interface{}, msgAndArgs ...interface{}) bool { | |||
// if assert.NotEmpty(t, obj) { | |||
// assert.Equal(t, "two", obj[1]) | |||
// } | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func NotEmpty(t TestingT, object interface{}, msgAndArgs ...interface{}) bool { | |||
pass := !isEmpty(object) | |||
@@ -526,8 +489,6 @@ func getLen(x interface{}) (ok bool, length int) { | |||
// Len also fails if the object has a type that len() not accept. | |||
// | |||
// assert.Len(t, mySlice, 3) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func Len(t TestingT, object interface{}, length int, msgAndArgs ...interface{}) bool { | |||
ok, l := getLen(object) | |||
if !ok { | |||
@@ -543,8 +504,6 @@ func Len(t TestingT, object interface{}, length int, msgAndArgs ...interface{}) | |||
// True asserts that the specified value is true. | |||
// | |||
// assert.True(t, myBool) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func True(t TestingT, value bool, msgAndArgs ...interface{}) bool { | |||
if value != true { | |||
@@ -558,8 +517,6 @@ func True(t TestingT, value bool, msgAndArgs ...interface{}) bool { | |||
// False asserts that the specified value is false. | |||
// | |||
// assert.False(t, myBool) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func False(t TestingT, value bool, msgAndArgs ...interface{}) bool { | |||
if value != false { | |||
@@ -574,8 +531,6 @@ func False(t TestingT, value bool, msgAndArgs ...interface{}) bool { | |||
// | |||
// assert.NotEqual(t, obj1, obj2) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
// | |||
// Pointer variable equality is determined based on the equality of the | |||
// referenced values (as opposed to the memory addresses). | |||
func NotEqual(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool { | |||
@@ -636,8 +591,6 @@ func includeElement(list interface{}, element interface{}) (ok, found bool) { | |||
// assert.Contains(t, "Hello World", "World") | |||
// assert.Contains(t, ["Hello", "World"], "World") | |||
// assert.Contains(t, {"Hello": "World"}, "Hello") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func Contains(t TestingT, s, contains interface{}, msgAndArgs ...interface{}) bool { | |||
ok, found := includeElement(s, contains) | |||
@@ -658,8 +611,6 @@ func Contains(t TestingT, s, contains interface{}, msgAndArgs ...interface{}) bo | |||
// assert.NotContains(t, "Hello World", "Earth") | |||
// assert.NotContains(t, ["Hello", "World"], "Earth") | |||
// assert.NotContains(t, {"Hello": "World"}, "Earth") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func NotContains(t TestingT, s, contains interface{}, msgAndArgs ...interface{}) bool { | |||
ok, found := includeElement(s, contains) | |||
@@ -678,8 +629,6 @@ func NotContains(t TestingT, s, contains interface{}, msgAndArgs ...interface{}) | |||
// elements given in the specified subset(array, slice...). | |||
// | |||
// assert.Subset(t, [1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func Subset(t TestingT, list, subset interface{}, msgAndArgs ...interface{}) (ok bool) { | |||
if subset == nil { | |||
return true // we consider nil to be equal to the nil set | |||
@@ -721,11 +670,9 @@ func Subset(t TestingT, list, subset interface{}, msgAndArgs ...interface{}) (ok | |||
// elements given in the specified subset(array, slice...). | |||
// | |||
// assert.NotSubset(t, [1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func NotSubset(t TestingT, list, subset interface{}, msgAndArgs ...interface{}) (ok bool) { | |||
if subset == nil { | |||
return false // we consider nil to be equal to the nil set | |||
return Fail(t, fmt.Sprintf("nil is the empty set which is a subset of every set"), msgAndArgs...) | |||
} | |||
subsetValue := reflect.ValueOf(subset) | |||
@@ -760,6 +707,60 @@ func NotSubset(t TestingT, list, subset interface{}, msgAndArgs ...interface{}) | |||
return Fail(t, fmt.Sprintf("%q is a subset of %q", subset, list), msgAndArgs...) | |||
} | |||
// ElementsMatch asserts that the specified listA(array, slice...) is equal to specified | |||
// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements, | |||
// the number of appearances of each of them in both lists should match. | |||
// | |||
// assert.ElementsMatch(t, [1, 3, 2, 3], [1, 3, 3, 2]) | |||
func ElementsMatch(t TestingT, listA, listB interface{}, msgAndArgs ...interface{}) (ok bool) { | |||
if isEmpty(listA) && isEmpty(listB) { | |||
return true | |||
} | |||
aKind := reflect.TypeOf(listA).Kind() | |||
bKind := reflect.TypeOf(listB).Kind() | |||
if aKind != reflect.Array && aKind != reflect.Slice { | |||
return Fail(t, fmt.Sprintf("%q has an unsupported type %s", listA, aKind), msgAndArgs...) | |||
} | |||
if bKind != reflect.Array && bKind != reflect.Slice { | |||
return Fail(t, fmt.Sprintf("%q has an unsupported type %s", listB, bKind), msgAndArgs...) | |||
} | |||
aValue := reflect.ValueOf(listA) | |||
bValue := reflect.ValueOf(listB) | |||
aLen := aValue.Len() | |||
bLen := bValue.Len() | |||
if aLen != bLen { | |||
return Fail(t, fmt.Sprintf("lengths don't match: %d != %d", aLen, bLen), msgAndArgs...) | |||
} | |||
// Mark indexes in bValue that we already used | |||
visited := make([]bool, bLen) | |||
for i := 0; i < aLen; i++ { | |||
element := aValue.Index(i).Interface() | |||
found := false | |||
for j := 0; j < bLen; j++ { | |||
if visited[j] { | |||
continue | |||
} | |||
if ObjectsAreEqual(bValue.Index(j).Interface(), element) { | |||
visited[j] = true | |||
found = true | |||
break | |||
} | |||
} | |||
if !found { | |||
return Fail(t, fmt.Sprintf("element %s appears more times in %s than in %s", element, aValue, bValue), msgAndArgs...) | |||
} | |||
} | |||
return true | |||
} | |||
// Condition uses a Comparison to assert a complex condition. | |||
func Condition(t TestingT, comp Comparison, msgAndArgs ...interface{}) bool { | |||
result := comp() | |||
@@ -798,8 +799,6 @@ func didPanic(f PanicTestFunc) (bool, interface{}) { | |||
// Panics asserts that the code inside the specified PanicTestFunc panics. | |||
// | |||
// assert.Panics(t, func(){ GoCrazy() }) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func Panics(t TestingT, f PanicTestFunc, msgAndArgs ...interface{}) bool { | |||
if funcDidPanic, panicValue := didPanic(f); !funcDidPanic { | |||
@@ -813,8 +812,6 @@ func Panics(t TestingT, f PanicTestFunc, msgAndArgs ...interface{}) bool { | |||
// the recovered panic value equals the expected panic value. | |||
// | |||
// assert.PanicsWithValue(t, "crazy error", func(){ GoCrazy() }) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func PanicsWithValue(t TestingT, expected interface{}, f PanicTestFunc, msgAndArgs ...interface{}) bool { | |||
funcDidPanic, panicValue := didPanic(f) | |||
@@ -831,8 +828,6 @@ func PanicsWithValue(t TestingT, expected interface{}, f PanicTestFunc, msgAndAr | |||
// NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic. | |||
// | |||
// assert.NotPanics(t, func(){ RemainCalm() }) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func NotPanics(t TestingT, f PanicTestFunc, msgAndArgs ...interface{}) bool { | |||
if funcDidPanic, panicValue := didPanic(f); funcDidPanic { | |||
@@ -845,8 +840,6 @@ func NotPanics(t TestingT, f PanicTestFunc, msgAndArgs ...interface{}) bool { | |||
// WithinDuration asserts that the two times are within duration delta of each other. | |||
// | |||
// assert.WithinDuration(t, time.Now(), time.Now(), 10*time.Second) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func WithinDuration(t TestingT, expected, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) bool { | |||
dt := expected.Sub(actual) | |||
@@ -896,8 +889,6 @@ func toFloat(x interface{}) (float64, bool) { | |||
// InDelta asserts that the two numerals are within delta of each other. | |||
// | |||
// assert.InDelta(t, math.Pi, (22 / 7.0), 0.01) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func InDelta(t TestingT, expected, actual interface{}, delta float64, msgAndArgs ...interface{}) bool { | |||
af, aok := toFloat(expected) | |||
@@ -944,6 +935,47 @@ func InDeltaSlice(t TestingT, expected, actual interface{}, delta float64, msgAn | |||
return true | |||
} | |||
// InDeltaMapValues is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys. | |||
func InDeltaMapValues(t TestingT, expected, actual interface{}, delta float64, msgAndArgs ...interface{}) bool { | |||
if expected == nil || actual == nil || | |||
reflect.TypeOf(actual).Kind() != reflect.Map || | |||
reflect.TypeOf(expected).Kind() != reflect.Map { | |||
return Fail(t, "Arguments must be maps", msgAndArgs...) | |||
} | |||
expectedMap := reflect.ValueOf(expected) | |||
actualMap := reflect.ValueOf(actual) | |||
if expectedMap.Len() != actualMap.Len() { | |||
return Fail(t, "Arguments must have the same number of keys", msgAndArgs...) | |||
} | |||
for _, k := range expectedMap.MapKeys() { | |||
ev := expectedMap.MapIndex(k) | |||
av := actualMap.MapIndex(k) | |||
if !ev.IsValid() { | |||
return Fail(t, fmt.Sprintf("missing key %q in expected map", k), msgAndArgs...) | |||
} | |||
if !av.IsValid() { | |||
return Fail(t, fmt.Sprintf("missing key %q in actual map", k), msgAndArgs...) | |||
} | |||
if !InDelta( | |||
t, | |||
ev.Interface(), | |||
av.Interface(), | |||
delta, | |||
msgAndArgs..., | |||
) { | |||
return false | |||
} | |||
} | |||
return true | |||
} | |||
func calcRelativeError(expected, actual interface{}) (float64, error) { | |||
af, aok := toFloat(expected) | |||
if !aok { | |||
@@ -961,8 +993,6 @@ func calcRelativeError(expected, actual interface{}) (float64, error) { | |||
} | |||
// InEpsilon asserts that expected and actual have a relative error less than epsilon | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func InEpsilon(t TestingT, expected, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool { | |||
actualEpsilon, err := calcRelativeError(expected, actual) | |||
if err != nil { | |||
@@ -1007,8 +1037,6 @@ func InEpsilonSlice(t TestingT, expected, actual interface{}, epsilon float64, m | |||
// if assert.NoError(t, err) { | |||
// assert.Equal(t, expectedObj, actualObj) | |||
// } | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func NoError(t TestingT, err error, msgAndArgs ...interface{}) bool { | |||
if err != nil { | |||
return Fail(t, fmt.Sprintf("Received unexpected error:\n%+v", err), msgAndArgs...) | |||
@@ -1023,8 +1051,6 @@ func NoError(t TestingT, err error, msgAndArgs ...interface{}) bool { | |||
// if assert.Error(t, err) { | |||
// assert.Equal(t, expectedError, err) | |||
// } | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func Error(t TestingT, err error, msgAndArgs ...interface{}) bool { | |||
if err == nil { | |||
@@ -1039,8 +1065,6 @@ func Error(t TestingT, err error, msgAndArgs ...interface{}) bool { | |||
// | |||
// actualObj, err := SomeFunction() | |||
// assert.EqualError(t, err, expectedErrorString) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func EqualError(t TestingT, theError error, errString string, msgAndArgs ...interface{}) bool { | |||
if !Error(t, theError, msgAndArgs...) { | |||
return false | |||
@@ -1051,7 +1075,7 @@ func EqualError(t TestingT, theError error, errString string, msgAndArgs ...inte | |||
if expected != actual { | |||
return Fail(t, fmt.Sprintf("Error message not equal:\n"+ | |||
"expected: %q\n"+ | |||
"actual: %q", expected, actual), msgAndArgs...) | |||
"actual : %q", expected, actual), msgAndArgs...) | |||
} | |||
return true | |||
} | |||
@@ -1074,8 +1098,6 @@ func matchRegexp(rx interface{}, str interface{}) bool { | |||
// | |||
// assert.Regexp(t, regexp.MustCompile("start"), "it's starting") | |||
// assert.Regexp(t, "start...$", "it's not starting") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func Regexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) bool { | |||
match := matchRegexp(rx, str) | |||
@@ -1091,8 +1113,6 @@ func Regexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface | |||
// | |||
// assert.NotRegexp(t, regexp.MustCompile("starts"), "it's starting") | |||
// assert.NotRegexp(t, "^start", "it's not starting") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func NotRegexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) bool { | |||
match := matchRegexp(rx, str) | |||
@@ -1104,7 +1124,7 @@ func NotRegexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interf | |||
} | |||
// Zero asserts that i is the zero value for its type and returns the truth. | |||
// Zero asserts that i is the zero value for its type. | |||
func Zero(t TestingT, i interface{}, msgAndArgs ...interface{}) bool { | |||
if i != nil && !reflect.DeepEqual(i, reflect.Zero(reflect.TypeOf(i)).Interface()) { | |||
return Fail(t, fmt.Sprintf("Should be zero, but was %v", i), msgAndArgs...) | |||
@@ -1112,7 +1132,7 @@ func Zero(t TestingT, i interface{}, msgAndArgs ...interface{}) bool { | |||
return true | |||
} | |||
// NotZero asserts that i is not the zero value for its type and returns the truth. | |||
// NotZero asserts that i is not the zero value for its type. | |||
func NotZero(t TestingT, i interface{}, msgAndArgs ...interface{}) bool { | |||
if i == nil || reflect.DeepEqual(i, reflect.Zero(reflect.TypeOf(i)).Interface()) { | |||
return Fail(t, fmt.Sprintf("Should not be zero, but was %v", i), msgAndArgs...) | |||
@@ -1120,11 +1140,39 @@ func NotZero(t TestingT, i interface{}, msgAndArgs ...interface{}) bool { | |||
return true | |||
} | |||
// FileExists checks whether a file exists in the given path. It also fails if the path points to a directory or there is an error when trying to check the file. | |||
func FileExists(t TestingT, path string, msgAndArgs ...interface{}) bool { | |||
info, err := os.Lstat(path) | |||
if err != nil { | |||
if os.IsNotExist(err) { | |||
return Fail(t, fmt.Sprintf("unable to find file %q", path), msgAndArgs...) | |||
} | |||
return Fail(t, fmt.Sprintf("error when running os.Lstat(%q): %s", path, err), msgAndArgs...) | |||
} | |||
if info.IsDir() { | |||
return Fail(t, fmt.Sprintf("%q is a directory", path), msgAndArgs...) | |||
} | |||
return true | |||
} | |||
// DirExists checks whether a directory exists in the given path. It also fails if the path is a file rather a directory or there is an error checking whether it exists. | |||
func DirExists(t TestingT, path string, msgAndArgs ...interface{}) bool { | |||
info, err := os.Lstat(path) | |||
if err != nil { | |||
if os.IsNotExist(err) { | |||
return Fail(t, fmt.Sprintf("unable to find file %q", path), msgAndArgs...) | |||
} | |||
return Fail(t, fmt.Sprintf("error when running os.Lstat(%q): %s", path, err), msgAndArgs...) | |||
} | |||
if !info.IsDir() { | |||
return Fail(t, fmt.Sprintf("%q is a file", path), msgAndArgs...) | |||
} | |||
return true | |||
} | |||
// JSONEq asserts that two JSON strings are equivalent. | |||
// | |||
// assert.JSONEq(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func JSONEq(t TestingT, expected string, actual string, msgAndArgs ...interface{}) bool { | |||
var expectedJSONAsInterface, actualJSONAsInterface interface{} | |||
@@ -25,7 +25,7 @@ func httpCode(handler http.HandlerFunc, method, url string, values url.Values) ( | |||
// assert.HTTPSuccess(t, myHandler, "POST", "http://www.google.com", nil) | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func HTTPSuccess(t TestingT, handler http.HandlerFunc, method, url string, values url.Values) bool { | |||
func HTTPSuccess(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, msgAndArgs ...interface{}) bool { | |||
code, err := httpCode(handler, method, url, values) | |||
if err != nil { | |||
Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err)) | |||
@@ -45,7 +45,7 @@ func HTTPSuccess(t TestingT, handler http.HandlerFunc, method, url string, value | |||
// assert.HTTPRedirect(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}} | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func HTTPRedirect(t TestingT, handler http.HandlerFunc, method, url string, values url.Values) bool { | |||
func HTTPRedirect(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, msgAndArgs ...interface{}) bool { | |||
code, err := httpCode(handler, method, url, values) | |||
if err != nil { | |||
Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err)) | |||
@@ -65,7 +65,7 @@ func HTTPRedirect(t TestingT, handler http.HandlerFunc, method, url string, valu | |||
// assert.HTTPError(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}} | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func HTTPError(t TestingT, handler http.HandlerFunc, method, url string, values url.Values) bool { | |||
func HTTPError(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, msgAndArgs ...interface{}) bool { | |||
code, err := httpCode(handler, method, url, values) | |||
if err != nil { | |||
Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err)) | |||
@@ -98,7 +98,7 @@ func HTTPBody(handler http.HandlerFunc, method, url string, values url.Values) s | |||
// assert.HTTPBodyContains(t, myHandler, "www.google.com", nil, "I'm Feeling Lucky") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func HTTPBodyContains(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, str interface{}) bool { | |||
func HTTPBodyContains(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) bool { | |||
body := HTTPBody(handler, method, url, values) | |||
contains := strings.Contains(body, fmt.Sprint(str)) | |||
@@ -115,7 +115,7 @@ func HTTPBodyContains(t TestingT, handler http.HandlerFunc, method, url string, | |||
// assert.HTTPBodyNotContains(t, myHandler, "www.google.com", nil, "I'm Feeling Lucky") | |||
// | |||
// Returns whether the assertion was successful (true) or not (false). | |||
func HTTPBodyNotContains(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, str interface{}) bool { | |||
func HTTPBodyNotContains(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) bool { | |||
body := HTTPBody(handler, method, url, values) | |||
contains := strings.Contains(body, fmt.Sprint(str)) |