move unit tests into 'testing' directories
diff --git a/openstack/identity/v3/endpoints/testing/doc.go b/openstack/identity/v3/endpoints/testing/doc.go
new file mode 100644
index 0000000..7603f83
--- /dev/null
+++ b/openstack/identity/v3/endpoints/testing/doc.go
@@ -0,0 +1 @@
+package testing
diff --git a/openstack/identity/v3/endpoints/requests_test.go b/openstack/identity/v3/endpoints/testing/requests_test.go
similarity index 88%
rename from openstack/identity/v3/endpoints/requests_test.go
rename to openstack/identity/v3/endpoints/testing/requests_test.go
index 14bbe6a..53d8488 100644
--- a/openstack/identity/v3/endpoints/requests_test.go
+++ b/openstack/identity/v3/endpoints/testing/requests_test.go
@@ -1,4 +1,4 @@
-package endpoints
+package testing
import (
"fmt"
@@ -6,6 +6,7 @@
"testing"
"github.com/gophercloud/gophercloud"
+ "github.com/gophercloud/gophercloud/openstack/identity/v3/endpoints"
"github.com/gophercloud/gophercloud/pagination"
th "github.com/gophercloud/gophercloud/testhelper"
"github.com/gophercloud/gophercloud/testhelper/client"
@@ -48,7 +49,7 @@
`)
})
- actual, err := Create(client.ServiceClient(), CreateOpts{
+ actual, err := endpoints.Create(client.ServiceClient(), endpoints.CreateOpts{
Availability: gophercloud.AvailabilityPublic,
Name: "the-endiest-of-points",
Region: "underground",
@@ -57,7 +58,7 @@
}).Extract()
th.AssertNoErr(t, err)
- expected := &Endpoint{
+ expected := &endpoints.Endpoint{
ID: "12",
Availability: gophercloud.AvailabilityPublic,
Name: "the-endiest-of-points",
@@ -113,16 +114,16 @@
})
count := 0
- List(client.ServiceClient(), ListOpts{}).EachPage(func(page pagination.Page) (bool, error) {
+ endpoints.List(client.ServiceClient(), endpoints.ListOpts{}).EachPage(func(page pagination.Page) (bool, error) {
count++
- actual, err := ExtractEndpoints(page)
+ actual, err := endpoints.ExtractEndpoints(page)
if err != nil {
t.Errorf("Failed to extract endpoints: %v", err)
return false, err
}
- expected := []Endpoint{
- Endpoint{
+ expected := []endpoints.Endpoint{
+ {
ID: "12",
Availability: gophercloud.AvailabilityPublic,
Name: "the-endiest-of-points",
@@ -130,7 +131,7 @@
ServiceID: "asdfasdfasdfasdf",
URL: "https://1.2.3.4:9000/",
},
- Endpoint{
+ {
ID: "13",
Availability: gophercloud.AvailabilityInternal,
Name: "shhhh",
@@ -178,7 +179,7 @@
`)
})
- actual, err := Update(client.ServiceClient(), "12", UpdateOpts{
+ actual, err := endpoints.Update(client.ServiceClient(), "12", endpoints.UpdateOpts{
Name: "renamed",
Region: "somewhere-else",
}).Extract()
@@ -186,7 +187,7 @@
t.Fatalf("Unexpected error from Update: %v", err)
}
- expected := &Endpoint{
+ expected := &endpoints.Endpoint{
ID: "12",
Availability: gophercloud.AvailabilityPublic,
Name: "renamed",
@@ -208,6 +209,6 @@
w.WriteHeader(http.StatusNoContent)
})
- res := Delete(client.ServiceClient(), "34")
+ res := endpoints.Delete(client.ServiceClient(), "34")
th.AssertNoErr(t, res.Err)
}
diff --git a/openstack/identity/v3/roles/testing/doc.go b/openstack/identity/v3/roles/testing/doc.go
new file mode 100644
index 0000000..7603f83
--- /dev/null
+++ b/openstack/identity/v3/roles/testing/doc.go
@@ -0,0 +1 @@
+package testing
diff --git a/openstack/identity/v3/roles/requests_test.go b/openstack/identity/v3/roles/testing/requests_test.go
similarity index 79%
rename from openstack/identity/v3/roles/requests_test.go
rename to openstack/identity/v3/roles/testing/requests_test.go
index ec6531c..dd9b704 100644
--- a/openstack/identity/v3/roles/requests_test.go
+++ b/openstack/identity/v3/roles/testing/requests_test.go
@@ -1,4 +1,4 @@
-package roles
+package testing
import (
"fmt"
@@ -6,6 +6,7 @@
"reflect"
"testing"
+ "github.com/gophercloud/gophercloud/openstack/identity/v3/roles"
"github.com/gophercloud/gophercloud/pagination"
"github.com/gophercloud/gophercloud/testhelper"
"github.com/gophercloud/gophercloud/testhelper/client"
@@ -67,25 +68,25 @@
})
count := 0
- err := ListAssignments(client.ServiceClient(), ListAssignmentsOpts{}).EachPage(func(page pagination.Page) (bool, error) {
+ err := roles.ListAssignments(client.ServiceClient(), roles.ListAssignmentsOpts{}).EachPage(func(page pagination.Page) (bool, error) {
count++
- actual, err := ExtractRoleAssignments(page)
+ actual, err := roles.ExtractRoleAssignments(page)
if err != nil {
return false, err
}
- expected := []RoleAssignment{
- RoleAssignment{
- Role: Role{ID: "123456"},
- Scope: Scope{Domain: Domain{ID: "161718"}},
- User: User{ID: "313233"},
- Group: Group{},
+ expected := []roles.RoleAssignment{
+ {
+ Role: roles.Role{ID: "123456"},
+ Scope: roles.Scope{Domain: roles.Domain{ID: "161718"}},
+ User: roles.User{ID: "313233"},
+ Group: roles.Group{},
},
- RoleAssignment{
- Role: Role{ID: "123456"},
- Scope: Scope{Project: Project{ID: "456789"}},
- User: User{ID: "313233"},
- Group: Group{},
+ {
+ Role: roles.Role{ID: "123456"},
+ Scope: roles.Scope{Project: roles.Project{ID: "456789"}},
+ User: roles.User{ID: "313233"},
+ Group: roles.Group{},
},
}
diff --git a/openstack/identity/v3/services/testing/doc.go b/openstack/identity/v3/services/testing/doc.go
new file mode 100644
index 0000000..7603f83
--- /dev/null
+++ b/openstack/identity/v3/services/testing/doc.go
@@ -0,0 +1 @@
+package testing
diff --git a/openstack/identity/v3/services/requests_test.go b/openstack/identity/v3/services/testing/requests_test.go
similarity index 84%
rename from openstack/identity/v3/services/requests_test.go
rename to openstack/identity/v3/services/testing/requests_test.go
index aa19bcc..0a065a2 100644
--- a/openstack/identity/v3/services/requests_test.go
+++ b/openstack/identity/v3/services/testing/requests_test.go
@@ -1,10 +1,11 @@
-package services
+package testing
import (
"fmt"
"net/http"
"testing"
+ "github.com/gophercloud/gophercloud/openstack/identity/v3/services"
"github.com/gophercloud/gophercloud/pagination"
th "github.com/gophercloud/gophercloud/testhelper"
"github.com/gophercloud/gophercloud/testhelper/client"
@@ -31,14 +32,14 @@
}`)
})
- expected := &Service{
+ expected := &services.Service{
Description: "Here's your service",
ID: "1234",
Name: "InscrutableOpenStackProjectName",
Type: "compute",
}
- actual, err := Create(client.ServiceClient(), "compute").Extract()
+ actual, err := services.Create(client.ServiceClient(), "compute").Extract()
if err != nil {
t.Fatalf("Unexpected error from Create: %v", err)
}
@@ -79,21 +80,21 @@
})
count := 0
- err := List(client.ServiceClient(), ListOpts{}).EachPage(func(page pagination.Page) (bool, error) {
+ err := services.List(client.ServiceClient(), services.ListOpts{}).EachPage(func(page pagination.Page) (bool, error) {
count++
- actual, err := ExtractServices(page)
+ actual, err := services.ExtractServices(page)
if err != nil {
return false, err
}
- expected := []Service{
- Service{
+ expected := []services.Service{
+ {
Description: "Service One",
ID: "1234",
Name: "service-one",
Type: "identity",
},
- Service{
+ {
Description: "Service Two",
ID: "9876",
Name: "service-two",
@@ -128,10 +129,10 @@
`)
})
- actual, err := Get(client.ServiceClient(), "12345").Extract()
+ actual, err := services.Get(client.ServiceClient(), "12345").Extract()
th.AssertNoErr(t, err)
- expected := &Service{
+ expected := &services.Service{
ID: "12345",
Description: "Service One",
Name: "service-one",
@@ -161,12 +162,12 @@
`)
})
- expected := &Service{
+ expected := &services.Service{
ID: "12345",
Type: "lasermagic",
}
- actual, err := Update(client.ServiceClient(), "12345", "lasermagic").Extract()
+ actual, err := services.Update(client.ServiceClient(), "12345", "lasermagic").Extract()
th.AssertNoErr(t, err)
th.AssertDeepEquals(t, expected, actual)
}
@@ -181,6 +182,6 @@
w.WriteHeader(http.StatusNoContent)
})
- res := Delete(client.ServiceClient(), "12345")
+ res := services.Delete(client.ServiceClient(), "12345")
th.AssertNoErr(t, res.Err)
}
diff --git a/openstack/identity/v3/tokens/testing/doc.go b/openstack/identity/v3/tokens/testing/doc.go
new file mode 100644
index 0000000..7603f83
--- /dev/null
+++ b/openstack/identity/v3/tokens/testing/doc.go
@@ -0,0 +1 @@
+package testing
diff --git a/openstack/identity/v3/tokens/requests_test.go b/openstack/identity/v3/tokens/testing/requests_test.go
similarity index 66%
rename from openstack/identity/v3/tokens/requests_test.go
rename to openstack/identity/v3/tokens/testing/requests_test.go
index faa79e0..cbb675f 100644
--- a/openstack/identity/v3/tokens/requests_test.go
+++ b/openstack/identity/v3/tokens/testing/requests_test.go
@@ -1,4 +1,4 @@
-package tokens
+package testing
import (
"fmt"
@@ -7,11 +7,12 @@
"time"
"github.com/gophercloud/gophercloud"
+ "github.com/gophercloud/gophercloud/openstack/identity/v3/tokens"
"github.com/gophercloud/gophercloud/testhelper"
)
// authTokenPost verifies that providing certain AuthOptions and Scope results in an expected JSON structure.
-func authTokenPost(t *testing.T, options AuthOptions, scope *Scope, requestJSON string) {
+func authTokenPost(t *testing.T, options tokens.AuthOptions, scope *tokens.Scope, requestJSON string) {
testhelper.SetupHTTP()
defer testhelper.TeardownHTTP()
@@ -34,13 +35,13 @@
}`)
})
- _, err := Create(&client, options, scope).Extract()
+ _, err := tokens.Create(&client, options, scope).Extract()
if err != nil {
t.Errorf("Create returned an error: %v", err)
}
}
-func authTokenPostErr(t *testing.T, options AuthOptions, scope *Scope, includeToken bool, expectedErr error) {
+func authTokenPostErr(t *testing.T, options tokens.AuthOptions, scope *tokens.Scope, includeToken bool, expectedErr error) {
testhelper.SetupHTTP()
defer testhelper.TeardownHTTP()
@@ -52,7 +53,7 @@
client.TokenID = "abcdef123456"
}
- _, err := Create(&client, options, scope).Extract()
+ _, err := tokens.Create(&client, options, scope).Extract()
if err == nil {
t.Errorf("Create did NOT return an error")
}
@@ -62,7 +63,7 @@
}
func TestCreateUserIDAndPassword(t *testing.T) {
- authTokenPost(t, AuthOptions{UserID: "me", Password: "squirrel!"}, nil, `
+ authTokenPost(t, tokens.AuthOptions{UserID: "me", Password: "squirrel!"}, nil, `
{
"auth": {
"identity": {
@@ -77,7 +78,7 @@
}
func TestCreateUsernameDomainIDPassword(t *testing.T) {
- authTokenPost(t, AuthOptions{Username: "fakey", Password: "notpassword", DomainID: "abc123"}, nil, `
+ authTokenPost(t, tokens.AuthOptions{Username: "fakey", Password: "notpassword", DomainID: "abc123"}, nil, `
{
"auth": {
"identity": {
@@ -98,7 +99,7 @@
}
func TestCreateUsernameDomainNamePassword(t *testing.T) {
- authTokenPost(t, AuthOptions{Username: "frank", Password: "swordfish", DomainName: "spork.net"}, nil, `
+ authTokenPost(t, tokens.AuthOptions{Username: "frank", Password: "swordfish", DomainName: "spork.net"}, nil, `
{
"auth": {
"identity": {
@@ -119,7 +120,7 @@
}
func TestCreateTokenID(t *testing.T) {
- authTokenPost(t, AuthOptions{TokenID: "12345abcdef"}, nil, `
+ authTokenPost(t, tokens.AuthOptions{TokenID: "12345abcdef"}, nil, `
{
"auth": {
"identity": {
@@ -134,8 +135,8 @@
}
func TestCreateProjectIDScope(t *testing.T) {
- options := AuthOptions{UserID: "fenris", Password: "g0t0h311"}
- scope := &Scope{ProjectID: "123456"}
+ options := tokens.AuthOptions{UserID: "fenris", Password: "g0t0h311"}
+ scope := &tokens.Scope{ProjectID: "123456"}
authTokenPost(t, options, scope, `
{
"auth": {
@@ -159,8 +160,8 @@
}
func TestCreateDomainIDScope(t *testing.T) {
- options := AuthOptions{UserID: "fenris", Password: "g0t0h311"}
- scope := &Scope{DomainID: "1000"}
+ options := tokens.AuthOptions{UserID: "fenris", Password: "g0t0h311"}
+ scope := &tokens.Scope{DomainID: "1000"}
authTokenPost(t, options, scope, `
{
"auth": {
@@ -184,8 +185,8 @@
}
func TestCreateProjectNameAndDomainIDScope(t *testing.T) {
- options := AuthOptions{UserID: "fenris", Password: "g0t0h311"}
- scope := &Scope{ProjectName: "world-domination", DomainID: "1000"}
+ options := tokens.AuthOptions{UserID: "fenris", Password: "g0t0h311"}
+ scope := &tokens.Scope{ProjectName: "world-domination", DomainID: "1000"}
authTokenPost(t, options, scope, `
{
"auth": {
@@ -212,8 +213,8 @@
}
func TestCreateProjectNameAndDomainNameScope(t *testing.T) {
- options := AuthOptions{UserID: "fenris", Password: "g0t0h311"}
- scope := &Scope{ProjectName: "world-domination", DomainName: "evil-plans"}
+ options := tokens.AuthOptions{UserID: "fenris", Password: "g0t0h311"}
+ scope := &tokens.Scope{ProjectName: "world-domination", DomainName: "evil-plans"}
authTokenPost(t, options, scope, `
{
"auth": {
@@ -259,8 +260,8 @@
}`)
})
- options := AuthOptions{UserID: "me", Password: "shhh"}
- token, err := Create(&client, options, nil).Extract()
+ options := tokens.AuthOptions{UserID: "me", Password: "shhh"}
+ token, err := tokens.Create(&client, options, nil).Extract()
if err != nil {
t.Fatalf("Create returned an error: %v", err)
}
@@ -271,123 +272,123 @@
}
func TestCreateFailureEmptyAuth(t *testing.T) {
- authTokenPostErr(t, AuthOptions{}, nil, false, ErrMissingPassword{})
+ authTokenPostErr(t, tokens.AuthOptions{}, nil, false, tokens.ErrMissingPassword{})
}
func TestCreateFailureTenantID(t *testing.T) {
- authTokenPostErr(t, AuthOptions{TenantID: "something"}, nil, false, ErrTenantIDProvided{})
+ authTokenPostErr(t, tokens.AuthOptions{TenantID: "something"}, nil, false, tokens.ErrTenantIDProvided{})
}
func TestCreateFailureTenantName(t *testing.T) {
- authTokenPostErr(t, AuthOptions{TenantName: "something"}, nil, false, ErrTenantNameProvided{})
+ authTokenPostErr(t, tokens.AuthOptions{TenantName: "something"}, nil, false, tokens.ErrTenantNameProvided{})
}
func TestCreateFailureTokenIDUsername(t *testing.T) {
- authTokenPostErr(t, AuthOptions{Username: "something", TokenID: "12345"}, nil, true, ErrUsernameWithToken{})
+ authTokenPostErr(t, tokens.AuthOptions{Username: "something", TokenID: "12345"}, nil, true, tokens.ErrUsernameWithToken{})
}
func TestCreateFailureTokenIDUserID(t *testing.T) {
- authTokenPostErr(t, AuthOptions{UserID: "something", TokenID: "12345"}, nil, true, ErrUserIDWithToken{})
+ authTokenPostErr(t, tokens.AuthOptions{UserID: "something", TokenID: "12345"}, nil, true, tokens.ErrUserIDWithToken{})
}
func TestCreateFailureTokenIDDomainID(t *testing.T) {
- authTokenPostErr(t, AuthOptions{DomainID: "something", TokenID: "12345"}, nil, true, ErrDomainIDWithToken{})
+ authTokenPostErr(t, tokens.AuthOptions{DomainID: "something", TokenID: "12345"}, nil, true, tokens.ErrDomainIDWithToken{})
}
func TestCreateFailureTokenIDDomainName(t *testing.T) {
- authTokenPostErr(t, AuthOptions{DomainName: "something", TokenID: "12345"}, nil, true, ErrDomainNameWithToken{})
+ authTokenPostErr(t, tokens.AuthOptions{DomainName: "something", TokenID: "12345"}, nil, true, tokens.ErrDomainNameWithToken{})
}
func TestCreateFailureMissingUser(t *testing.T) {
- options := AuthOptions{Password: "supersecure"}
- authTokenPostErr(t, options, nil, false, ErrUsernameOrUserID{})
+ options := tokens.AuthOptions{Password: "supersecure"}
+ authTokenPostErr(t, options, nil, false, tokens.ErrUsernameOrUserID{})
}
func TestCreateFailureBothUser(t *testing.T) {
- options := AuthOptions{
+ options := tokens.AuthOptions{
Password: "supersecure",
Username: "oops",
UserID: "redundancy",
}
- authTokenPostErr(t, options, nil, false, ErrUsernameOrUserID{})
+ authTokenPostErr(t, options, nil, false, tokens.ErrUsernameOrUserID{})
}
func TestCreateFailureMissingDomain(t *testing.T) {
- options := AuthOptions{
+ options := tokens.AuthOptions{
Password: "supersecure",
Username: "notuniqueenough",
}
- authTokenPostErr(t, options, nil, false, ErrDomainIDOrDomainName{})
+ authTokenPostErr(t, options, nil, false, tokens.ErrDomainIDOrDomainName{})
}
func TestCreateFailureBothDomain(t *testing.T) {
- options := AuthOptions{
+ options := tokens.AuthOptions{
Password: "supersecure",
Username: "someone",
DomainID: "hurf",
DomainName: "durf",
}
- authTokenPostErr(t, options, nil, false, ErrDomainIDOrDomainName{})
+ authTokenPostErr(t, options, nil, false, tokens.ErrDomainIDOrDomainName{})
}
func TestCreateFailureUserIDDomainID(t *testing.T) {
- options := AuthOptions{
+ options := tokens.AuthOptions{
UserID: "100",
Password: "stuff",
DomainID: "oops",
}
- authTokenPostErr(t, options, nil, false, ErrDomainIDWithUserID{})
+ authTokenPostErr(t, options, nil, false, tokens.ErrDomainIDWithUserID{})
}
func TestCreateFailureUserIDDomainName(t *testing.T) {
- options := AuthOptions{
+ options := tokens.AuthOptions{
UserID: "100",
Password: "sssh",
DomainName: "oops",
}
- authTokenPostErr(t, options, nil, false, ErrDomainNameWithUserID{})
+ authTokenPostErr(t, options, nil, false, tokens.ErrDomainNameWithUserID{})
}
func TestCreateFailureScopeProjectNameAlone(t *testing.T) {
- options := AuthOptions{UserID: "myself", Password: "swordfish"}
- scope := &Scope{ProjectName: "notenough"}
- authTokenPostErr(t, options, scope, false, ErrScopeDomainIDOrDomainName{})
+ options := tokens.AuthOptions{UserID: "myself", Password: "swordfish"}
+ scope := &tokens.Scope{ProjectName: "notenough"}
+ authTokenPostErr(t, options, scope, false, tokens.ErrScopeDomainIDOrDomainName{})
}
func TestCreateFailureScopeProjectNameAndID(t *testing.T) {
- options := AuthOptions{UserID: "myself", Password: "swordfish"}
- scope := &Scope{ProjectName: "whoops", ProjectID: "toomuch", DomainID: "1234"}
- authTokenPostErr(t, options, scope, false, ErrScopeProjectIDOrProjectName{})
+ options := tokens.AuthOptions{UserID: "myself", Password: "swordfish"}
+ scope := &tokens.Scope{ProjectName: "whoops", ProjectID: "toomuch", DomainID: "1234"}
+ authTokenPostErr(t, options, scope, false, tokens.ErrScopeProjectIDOrProjectName{})
}
func TestCreateFailureScopeProjectIDAndDomainID(t *testing.T) {
- options := AuthOptions{UserID: "myself", Password: "swordfish"}
- scope := &Scope{ProjectID: "toomuch", DomainID: "notneeded"}
- authTokenPostErr(t, options, scope, false, ErrScopeProjectIDAlone{})
+ options := tokens.AuthOptions{UserID: "myself", Password: "swordfish"}
+ scope := &tokens.Scope{ProjectID: "toomuch", DomainID: "notneeded"}
+ authTokenPostErr(t, options, scope, false, tokens.ErrScopeProjectIDAlone{})
}
func TestCreateFailureScopeProjectIDAndDomainNAme(t *testing.T) {
- options := AuthOptions{UserID: "myself", Password: "swordfish"}
- scope := &Scope{ProjectID: "toomuch", DomainName: "notneeded"}
- authTokenPostErr(t, options, scope, false, ErrScopeProjectIDAlone{})
+ options := tokens.AuthOptions{UserID: "myself", Password: "swordfish"}
+ scope := &tokens.Scope{ProjectID: "toomuch", DomainName: "notneeded"}
+ authTokenPostErr(t, options, scope, false, tokens.ErrScopeProjectIDAlone{})
}
func TestCreateFailureScopeDomainIDAndDomainName(t *testing.T) {
- options := AuthOptions{UserID: "myself", Password: "swordfish"}
- scope := &Scope{DomainID: "toomuch", DomainName: "notneeded"}
- authTokenPostErr(t, options, scope, false, ErrScopeDomainIDOrDomainName{})
+ options := tokens.AuthOptions{UserID: "myself", Password: "swordfish"}
+ scope := &tokens.Scope{DomainID: "toomuch", DomainName: "notneeded"}
+ authTokenPostErr(t, options, scope, false, tokens.ErrScopeDomainIDOrDomainName{})
}
func TestCreateFailureScopeDomainNameAlone(t *testing.T) {
- options := AuthOptions{UserID: "myself", Password: "swordfish"}
- scope := &Scope{DomainName: "notenough"}
- authTokenPostErr(t, options, scope, false, ErrScopeDomainName{})
+ options := tokens.AuthOptions{UserID: "myself", Password: "swordfish"}
+ scope := &tokens.Scope{DomainName: "notenough"}
+ authTokenPostErr(t, options, scope, false, tokens.ErrScopeDomainName{})
}
func TestCreateFailureEmptyScope(t *testing.T) {
- options := AuthOptions{UserID: "myself", Password: "swordfish"}
- scope := &Scope{}
- authTokenPostErr(t, options, scope, false, ErrScopeEmpty{})
+ options := tokens.AuthOptions{UserID: "myself", Password: "swordfish"}
+ scope := &tokens.Scope{}
+ authTokenPostErr(t, options, scope, false, tokens.ErrScopeEmpty{})
}
func TestGetRequest(t *testing.T) {
@@ -414,7 +415,7 @@
`)
})
- token, err := Get(&client, "abcdef12345").Extract()
+ token, err := tokens.Get(&client, "abcdef12345").Extract()
if err != nil {
t.Errorf("Info returned an error: %v", err)
}
@@ -451,7 +452,7 @@
defer testhelper.TeardownHTTP()
client := prepareAuthTokenHandler(t, "HEAD", http.StatusNoContent)
- ok, err := Validate(&client, "abcdef12345")
+ ok, err := tokens.Validate(&client, "abcdef12345")
if err != nil {
t.Errorf("Unexpected error from Validate: %v", err)
}
@@ -466,7 +467,7 @@
defer testhelper.TeardownHTTP()
client := prepareAuthTokenHandler(t, "HEAD", http.StatusNotFound)
- ok, err := Validate(&client, "abcdef12345")
+ ok, err := tokens.Validate(&client, "abcdef12345")
if err != nil {
t.Errorf("Unexpected error from Validate: %v", err)
}
@@ -481,7 +482,7 @@
defer testhelper.TeardownHTTP()
client := prepareAuthTokenHandler(t, "HEAD", http.StatusUnauthorized)
- _, err := Validate(&client, "abcdef12345")
+ _, err := tokens.Validate(&client, "abcdef12345")
if err == nil {
t.Errorf("Missing expected error from Validate")
}
@@ -492,7 +493,7 @@
defer testhelper.TeardownHTTP()
client := prepareAuthTokenHandler(t, "DELETE", http.StatusNoContent)
- res := Revoke(&client, "abcdef12345")
+ res := tokens.Revoke(&client, "abcdef12345")
testhelper.AssertNoErr(t, res.Err)
}
@@ -501,7 +502,7 @@
defer testhelper.TeardownHTTP()
client := prepareAuthTokenHandler(t, "DELETE", http.StatusNotFound)
- res := Revoke(&client, "abcdef12345")
+ res := tokens.Revoke(&client, "abcdef12345")
if res.Err == nil {
t.Errorf("Missing expected error from Revoke")
}