opensource/supermq
1
0
Fork 0
mirror of https://github.com/absmach/supermq.git synced 2026-06-23 07:20:19 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

NOISSUE - Remove domain from token (#2468)

Browse Source 
Signed-off-by: nyagamunene <stevenyaga2014@gmail.com>
This commit is contained in:
Steve Munene
2024-10-25 15:41:51 +03:00
committed by GitHub
parent ca8ed3b006
commit f88e11bdb2
76 changed files with 1619 additions and 1831 deletions
Download Patch File Download Diff File Expand all files Collapse all files
pkg/sdk/go/bootstrap.go
+2 -2
View File
@@ -113,8 +113,8 @@ func (sdk mgSDK) AddBootstrap(cfg BootstrapConfig, domainID, token string) (stri
return id, nil
}
func (sdk mgSDK) Bootstraps(pm PageMetadata, token string) (BootstrapPage, errors.SDKError) {
endpoint := fmt.Sprintf("%s/%s", pm.DomainID, configsEndpoint)
func (sdk mgSDK) Bootstraps(pm PageMetadata, domainID, token string) (BootstrapPage, errors.SDKError) {
endpoint := fmt.Sprintf("%s/%s", domainID, configsEndpoint)
url, err := sdk.withQueryParams(sdk.bootstrapURL, endpoint, pm)
if err != nil {
return BootstrapPage{}, errors.NewSDKError(err)
pkg/sdk/go/bootstrap_test.go
+60 -57
View File
@@ -175,14 +175,14 @@ func TestAddBootstrap(t *testing.T) {
err: nil,
},
{
desc: "add with invalid token",
domainID: domainID,
token: invalidToken,
cfg: sdkBootstrapConfig,
svcReq: bootstrapConfig,
svcRes: bootstrap.Config{},
svcErr: svcerr.ErrAuthentication,
err: errors.NewSDKErrorWithStatus(svcerr.ErrAuthentication, http.StatusUnauthorized),
desc: "add with invalid token",
domainID: domainID,
token: invalidToken,
cfg: sdkBootstrapConfig,
svcReq: bootstrapConfig,
svcRes: bootstrap.Config{},
authenticateErr: svcerr.ErrAuthentication,
err: errors.NewSDKErrorWithStatus(svcerr.ErrAuthentication, http.StatusUnauthorized),
},
{
desc: "add with config that cannot be marshalled",
@@ -242,7 +242,7 @@ func TestAddBootstrap(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
svcCall := bsvc.On("Add", mock.Anything, tc.session, tc.token, tc.svcReq).Return(tc.svcRes, tc.svcErr)
@@ -295,6 +295,7 @@ func TestListBootstraps(t *testing.T) {
cases := []struct {
desc string
domainID string
token string
session mgauthn.Session
pageMeta sdk.PageMetadata
@@ -305,12 +306,12 @@ func TestListBootstraps(t *testing.T) {
err errors.SDKError
}{
{
desc: "list successfully",
token: validToken,
desc: "list successfully",
domainID: domainID,
token: validToken,
pageMeta: sdk.PageMetadata{
Offset: 0,
Limit: 10,
DomainID: domainID,
Offset: 0,
Limit: 10,
},
svcResp: bootstrap.ConfigsPage{
Total: 1,
@@ -326,25 +327,25 @@ func TestListBootstraps(t *testing.T) {
err: nil,
},
{
desc: "list with invalid token",
token: invalidToken,
desc: "list with invalid token",
domainID: domainID,
token: invalidToken,
pageMeta: sdk.PageMetadata{
Offset: 0,
Limit: 10,
DomainID: domainID,
Offset: 0,
Limit: 10,
},
svcResp: bootstrap.ConfigsPage{},
svcErr: svcerr.ErrAuthentication,
response: sdk.BootstrapPage{},
err: errors.NewSDKErrorWithStatus(svcerr.ErrAuthentication, http.StatusUnauthorized),
svcResp: bootstrap.ConfigsPage{},
authenticateErr: svcerr.ErrAuthentication,
response: sdk.BootstrapPage{},
err: errors.NewSDKErrorWithStatus(svcerr.ErrAuthentication, http.StatusUnauthorized),
},
{
desc: "list with empty token",
token: "",
desc: "list with empty token",
domainID: domainID,
token: "",
pageMeta: sdk.PageMetadata{
Offset: 0,
Limit: 10,
DomainID: domainID,
Offset: 0,
Limit: 10,
},
svcResp: bootstrap.ConfigsPage{},
svcErr: nil,
@@ -352,12 +353,12 @@ func TestListBootstraps(t *testing.T) {
err: errors.NewSDKErrorWithStatus(apiutil.ErrBearerToken, http.StatusUnauthorized),
},
{
desc: "list with invalid query params",
token: validToken,
desc: "list with invalid query params",
domainID: domainID,
token: validToken,
pageMeta: sdk.PageMetadata{
Offset: 1,
Limit: 10,
DomainID: domainID,
Offset: 1,
Limit: 10,
Metadata: map[string]interface{}{
"test": make(chan int),
},
@@ -368,12 +369,12 @@ func TestListBootstraps(t *testing.T) {
err: errors.NewSDKError(errMarshalChan),
},
{
desc: "list with response that cannot be unmarshalled",
token: validToken,
desc: "list with response that cannot be unmarshalled",
domainID: domainID,
token: validToken,
pageMeta: sdk.PageMetadata{
Offset: 0,
Limit: 10,
DomainID: domainID,
Offset: 0,
Limit: 10,
},
svcResp: bootstrap.ConfigsPage{
Total: 1,
@@ -388,11 +389,11 @@ func TestListBootstraps(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
svcCall := bsvc.On("List", mock.Anything, tc.session, mock.Anything, tc.pageMeta.Offset, tc.pageMeta.Limit).Return(tc.svcResp, tc.svcErr)
resp, err := mgsdk.Bootstraps(tc.pageMeta, tc.token)
resp, err := mgsdk.Bootstraps(tc.pageMeta, tc.domainID, tc.token)
assert.Equal(t, tc.err, err)
assert.Equal(t, tc.response, resp)
if err == nil {
@@ -493,7 +494,7 @@ func TestWhiteList(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
svcCall := bsvc.On("ChangeState", mock.Anything, tc.session, tc.token, tc.thingID, tc.svcReq).Return(tc.svcErr)
@@ -614,7 +615,7 @@ func TestViewBootstrap(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
svcCall := bsvc.On("View", mock.Anything, tc.session, tc.id).Return(tc.svcResp, tc.svcErr)
@@ -777,7 +778,7 @@ func TestUpdateBootstrap(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticationErr)
svcCall := bsvc.On("Update", mock.Anything, tc.session, tc.svcReq).Return(tc.svcErr)
@@ -899,18 +900,20 @@ func TestUpdateBootstrapCerts(t *testing.T) {
},
}
for _, tc := range cases {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
svcCall := bsvc.On("UpdateCert", mock.Anything, tc.session, tc.id, tc.clientCert, tc.clientKey, tc.caCert).Return(tc.svcResp, tc.svcErr)
resp, err := mgsdk.UpdateBootstrapCerts(tc.id, tc.clientCert, tc.clientKey, tc.caCert, tc.domainID, tc.token)
assert.Equal(t, tc.err, err)
if err == nil {
assert.Equal(t, tc.response, resp)
}
svcCall.Unset()
authCall.Unset()
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
svcCall := bsvc.On("UpdateCert", mock.Anything, tc.session, tc.id, tc.clientCert, tc.clientKey, tc.caCert).Return(tc.svcResp, tc.svcErr)
resp, err := mgsdk.UpdateBootstrapCerts(tc.id, tc.clientCert, tc.clientKey, tc.caCert, tc.domainID, tc.token)
assert.Equal(t, tc.err, err)
if err == nil {
assert.Equal(t, tc.response, resp)
}
svcCall.Unset()
authCall.Unset()
})
}
}
@@ -1002,7 +1005,7 @@ func TestUpdateBootstrapConnection(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
svcCall := bsvc.On("UpdateConnections", mock.Anything, tc.session, tc.token, tc.id, tc.channels).Return(tc.svcErr)
@@ -1089,7 +1092,7 @@ func TestRemoveBootstrap(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
svcCall := bsvc.On("Remove", mock.Anything, tc.session, tc.id).Return(tc.svcErr)
pkg/sdk/go/channels.go
+6 -6
View File
@@ -52,8 +52,8 @@ func (sdk mgSDK) CreateChannel(c Channel, domainID, token string) (Channel, erro
return c, nil
}
func (sdk mgSDK) Channels(pm PageMetadata, token string) (ChannelsPage, errors.SDKError) {
endpoint := fmt.Sprintf("%s/%s", pm.DomainID, channelsEndpoint)
func (sdk mgSDK) Channels(pm PageMetadata, domainID, token string) (ChannelsPage, errors.SDKError) {
endpoint := fmt.Sprintf("%s/%s", domainID, channelsEndpoint)
url, err := sdk.withQueryParams(sdk.thingsURL, endpoint, pm)
if err != nil {
return ChannelsPage{}, errors.NewSDKError(err)
@@ -174,8 +174,8 @@ func (sdk mgSDK) RemoveUserFromChannel(channelID string, req UsersRelationReques
return sdkerr
}
func (sdk mgSDK) ListChannelUsers(channelID string, pm PageMetadata, token string) (UsersPage, errors.SDKError) {
url, err := sdk.withQueryParams(sdk.usersURL, fmt.Sprintf("%s/%s/%s/%s", pm.DomainID, channelsEndpoint, channelID, usersEndpoint), pm)
func (sdk mgSDK) ListChannelUsers(channelID string, pm PageMetadata, domainID, token string) (UsersPage, errors.SDKError) {
url, err := sdk.withQueryParams(sdk.usersURL, fmt.Sprintf("%s/%s/%s/%s", domainID, channelsEndpoint, channelID, usersEndpoint), pm)
if err != nil {
return UsersPage{}, errors.NewSDKError(err)
}
@@ -215,8 +215,8 @@ func (sdk mgSDK) RemoveUserGroupFromChannel(channelID string, req UserGroupsRequ
return sdkerr
}
func (sdk mgSDK) ListChannelUserGroups(channelID string, pm PageMetadata, token string) (GroupsPage, errors.SDKError) {
url, err := sdk.withQueryParams(sdk.usersURL, fmt.Sprintf("%s/%s/%s/%s", pm.DomainID, channelsEndpoint, channelID, groupsEndpoint), pm)
func (sdk mgSDK) ListChannelUserGroups(channelID string, pm PageMetadata, domainID, token string) (GroupsPage, errors.SDKError) {
url, err := sdk.withQueryParams(sdk.usersURL, fmt.Sprintf("%s/%s/%s/%s", domainID, channelsEndpoint, channelID, groupsEndpoint), pm)
if err != nil {
return GroupsPage{}, errors.NewSDKError(err)
}
pkg/sdk/go/channels_test.go
+76 -78
View File
@@ -238,7 +238,7 @@ func TestCreateChannel(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
svcCall := gsvc.On("CreateGroup", mock.Anything, tc.session, channelKind, tc.createGroupReq).Return(tc.svcRes, tc.svcErr)
@@ -511,14 +511,13 @@ func TestListChannels(t *testing.T) {
Limit: tc.limit,
Level: uint64(tc.level),
Metadata: tc.metadata,
DomainID: tc.domainID,
}
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
svcCall := gsvc.On("ListGroups", mock.Anything, tc.session, policies.UsersKind, "", tc.groupsPageMeta).Return(tc.svcRes, tc.svcErr)
resp, err := mgsdk.Channels(pm, tc.token)
resp, err := mgsdk.Channels(pm, tc.domainID, tc.token)
assert.Equal(t, tc.err, err)
assert.Equal(t, tc.response, resp)
if tc.err == nil {
@@ -623,7 +622,7 @@ func TestViewChannel(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
svcCall := gsvc.On("ViewGroup", mock.Anything, tc.session, tc.channelID).Return(tc.svcRes, tc.svcErr)
@@ -922,7 +921,7 @@ func TestUpdateChannel(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
svcCall := gsvc.On("UpdateGroup", mock.Anything, tc.session, tc.updateGroupReq).Return(tc.svcRes, tc.svcErr)
@@ -1167,7 +1166,7 @@ func TestListChannelsByThing(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
svcCall := gsvc.On("ListGroups", mock.Anything, tc.session, policies.ThingsKind, tc.thingID, tc.listGroupsReq).Return(tc.svcRes, tc.svcErr)
@@ -1275,7 +1274,7 @@ func TestEnableChannel(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
svcCall := gsvc.On("EnableGroup", mock.Anything, tc.session, tc.channelID).Return(tc.svcRes, tc.svcErr)
@@ -1388,7 +1387,7 @@ func TestDisableChannel(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
svcCall := gsvc.On("DisableGroup", mock.Anything, tc.session, tc.channelID).Return(tc.svcRes, tc.svcErr)
@@ -1468,7 +1467,7 @@ func TestDeleteChannel(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
svcCall := gsvc.On("DeleteGroup", mock.Anything, tc.session, tc.channelID).Return(tc.svcErr)
@@ -1562,7 +1561,7 @@ func TestChannelPermissions(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
svcCall := gsvc.On("ViewGroupPerms", mock.Anything, tc.session, tc.channelID).Return(tc.svcRes, tc.svcErr)
@@ -1687,7 +1686,7 @@ func TestAddUserToChannel(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
svcCall := gsvc.On("Assign", mock.Anything, tc.session, tc.channelID, tc.addUserReq.Relation, policies.UsersKind, tc.addUserReq.UserIDs).Return(tc.svcErr)
@@ -1799,7 +1798,7 @@ func TestRemoveUserFromChannel(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
svcCall := gsvc.On("Unassign", mock.Anything, tc.session, tc.channelID, tc.removeUserReq.Relation, policies.UsersKind, tc.removeUserReq.UserIDs).Return(tc.svcErr)
@@ -1909,7 +1908,7 @@ func TestAddUserGroupToChannel(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
svcCall := gsvc.On("Assign", mock.Anything, tc.session, tc.channelID, relation, policies.ChannelsKind, tc.addUserGroupReq.UserGroupIDs).Return(tc.svcErr)
@@ -2019,7 +2018,7 @@ func TestRemoveUserGroupFromChannel(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
svcCall := gsvc.On("Unassign", mock.Anything, tc.session, tc.channelID, relation, policies.ChannelsKind, tc.removeUserGroupReq.UserGroupIDs).Return(tc.svcErr)
@@ -2060,6 +2059,7 @@ func TestListChannelUserGroups(t *testing.T) {
cases := []struct {
desc string
token string
domainID string
session mgauthn.Session
channelID string
pageMeta sdk.PageMetadata
@@ -2072,11 +2072,10 @@ func TestListChannelUserGroups(t *testing.T) {
}{
{
desc: "list user groups successfully",
domainID: domainID,
token: validToken,
channelID: channel.ID,
pageMeta: sdk.PageMetadata{
DomainID: domainID,
},
pageMeta: sdk.PageMetadata{},
listGroupsReq: groups.Page{
PageMeta: groups.PageMeta{
Offset: 0,
@@ -2102,12 +2101,12 @@ func TestListChannelUserGroups(t *testing.T) {
},
{
desc: "list user groups with offset and limit",
domainID: domainID,
token: validToken,
channelID: channel.ID,
pageMeta: sdk.PageMetadata{
Offset: 6,
Limit: nGroups,
DomainID: domainID,
Offset: 6,
Limit: nGroups,
},
listGroupsReq: groups.Page{
PageMeta: groups.PageMeta{
@@ -2134,11 +2133,10 @@ func TestListChannelUserGroups(t *testing.T) {
},
{
desc: "list user groups with invalid token",
domainID: domainID,
token: invalidToken,
channelID: channel.ID,
pageMeta: sdk.PageMetadata{
DomainID: domainID,
},
pageMeta: sdk.PageMetadata{},
listGroupsReq: groups.Page{
PageMeta: groups.PageMeta{
Offset: 0,
@@ -2154,11 +2152,10 @@ func TestListChannelUserGroups(t *testing.T) {
},
{
desc: "list user groups with empty token",
domainID: domainID,
token: "",
channelID: channel.ID,
pageMeta: sdk.PageMetadata{
DomainID: domainID,
},
pageMeta: sdk.PageMetadata{},
listGroupsReq: groups.Page{
PageMeta: groups.PageMeta{
Offset: 0,
@@ -2174,11 +2171,11 @@ func TestListChannelUserGroups(t *testing.T) {
},
{
desc: "list user groups with limit greater than max",
domainID: domainID,
token: validToken,
channelID: channel.ID,
pageMeta: sdk.PageMetadata{
Limit: 110,
DomainID: domainID,
Limit: 110,
},
listGroupsReq: groups.Page{},
svcRes: groups.Page{},
@@ -2188,6 +2185,7 @@ func TestListChannelUserGroups(t *testing.T) {
},
{
desc: "list user groups with invalid channel id",
domainID: domainID,
token: validToken,
channelID: wrongID,
pageMeta: sdk.PageMetadata{
@@ -2208,11 +2206,11 @@ func TestListChannelUserGroups(t *testing.T) {
},
{
desc: "list users groups with level exceeding max",
domainID: domainID,
token: validToken,
channelID: channel.ID,
pageMeta: sdk.PageMetadata{
Level: 10,
DomainID: domainID,
Level: 10,
},
listGroupsReq: groups.Page{},
svcRes: groups.Page{},
@@ -2240,11 +2238,10 @@ func TestListChannelUserGroups(t *testing.T) {
},
{
desc: "list user groups with service response that can't be unmarshalled",
domainID: domainID,
token: validToken,
channelID: channel.ID,
pageMeta: sdk.PageMetadata{
DomainID: domainID,
},
pageMeta: sdk.PageMetadata{},
listGroupsReq: groups.Page{
PageMeta: groups.PageMeta{
Offset: 0,
@@ -2272,11 +2269,11 @@ func TestListChannelUserGroups(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
svcCall := gsvc.On("ListGroups", mock.Anything, tc.session, policies.ChannelsKind, tc.channelID, tc.listGroupsReq).Return(tc.svcRes, tc.svcErr)
resp, err := mgsdk.ListChannelUserGroups(tc.channelID, tc.pageMeta, tc.token)
resp, err := mgsdk.ListChannelUserGroups(tc.channelID, tc.pageMeta, tc.domainID, tc.token)
assert.Equal(t, tc.err, err)
assert.Equal(t, tc.response, resp)
if tc.err == nil {
@@ -2380,7 +2377,7 @@ func TestConnect(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
svcCall := gsvc.On("Assign", mock.Anything, tc.session, tc.connection.ChannelID, policies.GroupRelation, policies.ThingsKind, []string{tc.connection.ThingID}).Return(tc.svcErr)
@@ -2487,7 +2484,7 @@ func TestDisconnect(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
svcCall := gsvc.On("Unassign", mock.Anything, tc.session, tc.disconnect.ChannelID, policies.GroupRelation, policies.ThingsKind, []string{tc.disconnect.ThingID}).Return(tc.svcErr)
@@ -2583,7 +2580,7 @@ func TestConnectThing(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
svcCall := gsvc.On("Assign", mock.Anything, tc.session, tc.channelID, policies.GroupRelation, policies.ThingsKind, []string{tc.thingID}).Return(tc.svcErr)
@@ -2678,7 +2675,7 @@ func TestDisconnectThing(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
svcCall := gsvc.On("Unassign", mock.Anything, tc.session, tc.channelID, policies.GroupRelation, policies.ThingsKind, []string{tc.thingID}).Return(tc.svcErr)
@@ -2712,6 +2709,7 @@ func TestListGroupChannels(t *testing.T) {
cases := []struct {
desc string
domainID string
token string
session mgauthn.Session
groupID string
@@ -2724,13 +2722,13 @@ func TestListGroupChannels(t *testing.T) {
err errors.SDKError
}{
{
desc: "list group channels successfully",
token: validToken,
groupID: group.ID,
desc: "list group channels successfully",
domainID: domainID,
token: validToken,
groupID: group.ID,
pageMeta: sdk.PageMetadata{
Offset: 0,
Limit: 10,
DomainID: domainID,
Offset: 0,
Limit: 10,
},
svcReq: groups.Page{
PageMeta: groups.PageMeta{
@@ -2756,13 +2754,13 @@ func TestListGroupChannels(t *testing.T) {
err: nil,
},
{
desc: "list group channels with invalid token",
token: invalidToken,
groupID: group.ID,
desc: "list group channels with invalid token",
domainID: domainID,
token: invalidToken,
groupID: group.ID,
pageMeta: sdk.PageMetadata{
Offset: 0,
Limit: 10,
DomainID: domainID,
Offset: 0,
Limit: 10,
},
svcReq: groups.Page{
PageMeta: groups.PageMeta{
@@ -2778,13 +2776,13 @@ func TestListGroupChannels(t *testing.T) {
err: errors.NewSDKErrorWithStatus(svcerr.ErrAuthentication, http.StatusUnauthorized),
},
{
desc: "list group channels with empty token",
token: "",
groupID: group.ID,
desc: "list group channels with empty token",
domainID: domainID,
token: "",
groupID: group.ID,
pageMeta: sdk.PageMetadata{
Offset: 0,
Limit: 10,
DomainID: domainID,
Offset: 0,
Limit: 10,
},
svcReq: groups.Page{},
svcRes: groups.Page{},
@@ -2793,13 +2791,13 @@ func TestListGroupChannels(t *testing.T) {
err: errors.NewSDKErrorWithStatus(apiutil.ErrBearerToken, http.StatusUnauthorized),
},
{
desc: "list group channels with invalid group id",
token: validToken,
groupID: wrongID,
desc: "list group channels with invalid group id",
domainID: domainID,
token: validToken,
groupID: wrongID,
pageMeta: sdk.PageMetadata{
Offset: 0,
Limit: 10,
DomainID: domainID,
Offset: 0,
Limit: 10,
},
svcReq: groups.Page{
PageMeta: groups.PageMeta{
@@ -2815,13 +2813,13 @@ func TestListGroupChannels(t *testing.T) {
err: errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
},
{
desc: "list group channels with invalid page metadata",
token: validToken,
groupID: group.ID,
desc: "list group channels with invalid page metadata",
domainID: domainID,
token: validToken,
groupID: group.ID,
pageMeta: sdk.PageMetadata{
Offset: 0,
Limit: 10,
DomainID: domainID,
Offset: 0,
Limit: 10,
Metadata: sdk.Metadata{
"test": make(chan int),
},
@@ -2833,13 +2831,13 @@ func TestListGroupChannels(t *testing.T) {
err: errors.NewSDKError(errors.New("json: unsupported type: chan int")),
},
{
desc: "list group channels with service response that can't be unmarshalled",
token: validToken,
groupID: group.ID,
desc: "list group channels with service response that can't be unmarshalled",
domainID: domainID,
token: validToken,
groupID: group.ID,
pageMeta: sdk.PageMetadata{
Offset: 0,
Limit: 10,
DomainID: domainID,
Offset: 0,
Limit: 10,
},
svcReq: groups.Page{
PageMeta: groups.PageMeta{
@@ -2868,11 +2866,11 @@ func TestListGroupChannels(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
svcCall := gsvc.On("ListGroups", mock.Anything, tc.session, policies.GroupsKind, tc.groupID, tc.svcReq).Return(tc.svcRes, tc.svcErr)
resp, err := mgsdk.ListGroupChannels(tc.groupID, tc.pageMeta, tc.token)
resp, err := mgsdk.ListGroupChannels(tc.groupID, tc.pageMeta, tc.domainID, tc.token)
assert.Equal(t, tc.err, err)
assert.Equal(t, tc.response, resp)
if tc.err == nil {
pkg/sdk/go/groups.go
+10 -10
View File
@@ -59,8 +59,8 @@ func (sdk mgSDK) CreateGroup(g Group, domainID, token string) (Group, errors.SDK
return g, nil
}
func (sdk mgSDK) Groups(pm PageMetadata, token string) (GroupsPage, errors.SDKError) {
endpoint := fmt.Sprintf("%s/%s", pm.DomainID, groupsEndpoint)
func (sdk mgSDK) Groups(pm PageMetadata, domainID, token string) (GroupsPage, errors.SDKError) {
endpoint := fmt.Sprintf("%s/%s", domainID, groupsEndpoint)
url, err := sdk.withQueryParams(sdk.usersURL, endpoint, pm)
if err != nil {
return GroupsPage{}, errors.NewSDKError(err)
@@ -69,9 +69,9 @@ func (sdk mgSDK) Groups(pm PageMetadata, token string) (GroupsPage, errors.SDKEr
return sdk.getGroups(url, token)
}
func (sdk mgSDK) Parents(id string, pm PageMetadata, token string) (GroupsPage, errors.SDKError) {
func (sdk mgSDK) Parents(id string, pm PageMetadata, domainID, token string) (GroupsPage, errors.SDKError) {
pm.Level = MaxLevel
endpoint := fmt.Sprintf("%s/%s", pm.DomainID, groupsEndpoint)
endpoint := fmt.Sprintf("%s/%s", domainID, groupsEndpoint)
url, err := sdk.withQueryParams(fmt.Sprintf("%s/%s/%s", sdk.usersURL, endpoint, id), "parents", pm)
if err != nil {
return GroupsPage{}, errors.NewSDKError(err)
@@ -80,9 +80,9 @@ func (sdk mgSDK) Parents(id string, pm PageMetadata, token string) (GroupsPage,
return sdk.getGroups(url, token)
}
func (sdk mgSDK) Children(id string, pm PageMetadata, token string) (GroupsPage, errors.SDKError) {
func (sdk mgSDK) Children(id string, pm PageMetadata, domainID, token string) (GroupsPage, errors.SDKError) {
pm.Level = MaxLevel
endpoint := fmt.Sprintf("%s/%s", pm.DomainID, groupsEndpoint)
endpoint := fmt.Sprintf("%s/%s", domainID, groupsEndpoint)
url, err := sdk.withQueryParams(fmt.Sprintf("%s/%s/%s", sdk.usersURL, endpoint, id), "children", pm)
if err != nil {
return GroupsPage{}, errors.NewSDKError(err)
@@ -197,8 +197,8 @@ func (sdk mgSDK) RemoveUserFromGroup(groupID string, req UsersRelationRequest, d
return sdkerr
}
func (sdk mgSDK) ListGroupUsers(groupID string, pm PageMetadata, token string) (UsersPage, errors.SDKError) {
url, err := sdk.withQueryParams(sdk.usersURL, fmt.Sprintf("%s/%s/%s/%s", pm.DomainID, groupsEndpoint, groupID, usersEndpoint), pm)
func (sdk mgSDK) ListGroupUsers(groupID string, pm PageMetadata, domainID, token string) (UsersPage, errors.SDKError) {
url, err := sdk.withQueryParams(sdk.usersURL, fmt.Sprintf("%s/%s/%s/%s", domainID, groupsEndpoint, groupID, usersEndpoint), pm)
if err != nil {
return UsersPage{}, errors.NewSDKError(err)
}
@@ -214,8 +214,8 @@ func (sdk mgSDK) ListGroupUsers(groupID string, pm PageMetadata, token string) (
return up, nil
}
func (sdk mgSDK) ListGroupChannels(groupID string, pm PageMetadata, token string) (ChannelsPage, errors.SDKError) {
url, err := sdk.withQueryParams(sdk.thingsURL, fmt.Sprintf("%s/%s/%s/%s", pm.DomainID, groupsEndpoint, groupID, channelsEndpoint), pm)
func (sdk mgSDK) ListGroupChannels(groupID string, pm PageMetadata, domainID, token string) (ChannelsPage, errors.SDKError) {
url, err := sdk.withQueryParams(sdk.thingsURL, fmt.Sprintf("%s/%s/%s/%s", domainID, groupsEndpoint, groupID, channelsEndpoint), pm)
if err != nil {
return ChannelsPage{}, errors.NewSDKError(err)
}
pkg/sdk/go/groups_test.go
+137 -132
View File
@@ -265,7 +265,7 @@ func TestCreateGroup(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
svcCall := gsvc.On("CreateGroup", mock.Anything, tc.session, policies.NewGroupKind, tc.svcReq).Return(tc.svcRes, tc.svcErr)
@@ -305,6 +305,7 @@ func TestListGroups(t *testing.T) {
cases := []struct {
desc string
token string
domainID string
session mgauthn.Session
pageMeta sdk.PageMetadata
svcReq groups.Page
@@ -315,12 +316,12 @@ func TestListGroups(t *testing.T) {
err errors.SDKError
}{
{
desc: "list groups successfully",
token: validToken,
desc: "list groups successfully",
domainID: domainID,
token: validToken,
pageMeta: sdk.PageMetadata{
Offset: offset,
Limit: 100,
DomainID: domainID,
Offset: offset,
Limit: 100,
},
svcReq: groups.Page{
PageMeta: groups.PageMeta{
@@ -345,12 +346,12 @@ func TestListGroups(t *testing.T) {
err: nil,
},
{
desc: "list groups with invalid token",
token: invalidToken,
desc: "list groups with invalid token",
token: invalidToken,
domainID: domainID,
pageMeta: sdk.PageMetadata{
Offset: offset,
Limit: 100,
DomainID: domainID,
Offset: offset,
Limit: 100,
},
svcReq: groups.Page{
PageMeta: groups.PageMeta{
@@ -365,26 +366,27 @@ func TestListGroups(t *testing.T) {
err: errors.NewSDKErrorWithStatus(svcerr.ErrAuthentication, http.StatusUnauthorized),
},
{
desc: "list groups with empty token",
token: "",
desc: "list groups with empty token",
domainID: domainID,
token: "",
pageMeta: sdk.PageMetadata{
Offset: offset,
Limit: 100,
DomainID: domainID,
Offset: offset,
Limit: 100,
},
svcReq: groups.Page{},
svcRes: groups.Page{},
svcErr: nil,
response: sdk.GroupsPage{},
err: errors.NewSDKErrorWithStatus(apiutil.ErrBearerToken, http.StatusUnauthorized),
svcReq: groups.Page{},
svcRes: groups.Page{},
svcErr: nil,
response: sdk.GroupsPage{},
authenticateErr: svcerr.ErrAuthentication,
err: errors.NewSDKErrorWithStatus(apiutil.ErrBearerToken, http.StatusUnauthorized),
},
{
desc: "list groups with zero limit",
token: validToken,
desc: "list groups with zero limit",
domainID: domainID,
token: validToken,
pageMeta: sdk.PageMetadata{
Offset: offset,
Limit: 0,
DomainID: domainID,
Offset: offset,
Limit: 0,
},
svcReq: groups.Page{
PageMeta: groups.PageMeta{
@@ -410,12 +412,12 @@ func TestListGroups(t *testing.T) {
err: nil,
},
{
desc: "list groups with limit greater than max",
token: validToken,
desc: "list groups with limit greater than max",
domainID: domainID,
token: validToken,
pageMeta: sdk.PageMetadata{
Offset: offset,
Limit: 110,
DomainID: domainID,
Offset: offset,
Limit: 110,
},
svcReq: groups.Page{},
svcRes: groups.Page{},
@@ -424,12 +426,12 @@ func TestListGroups(t *testing.T) {
err: errors.NewSDKErrorWithStatus(errors.Wrap(apiutil.ErrValidation, apiutil.ErrLimitSize), http.StatusBadRequest),
},
{
desc: "list groups with given name",
token: validToken,
desc: "list groups with given name",
domainID: domainID,
token: validToken,
pageMeta: sdk.PageMetadata{
Offset: 0,
Limit: 10,
DomainID: domainID,
Offset: 0,
Limit: 10,
Metadata: sdk.Metadata{
"name": "user_89",
},
@@ -461,13 +463,13 @@ func TestListGroups(t *testing.T) {
err: nil,
},
{
desc: "list groups with invalid level",
token: validToken,
desc: "list groups with invalid level",
token: validToken,
domainID: domainID,
pageMeta: sdk.PageMetadata{
Offset: offset,
Limit: 100,
Level: 6,
DomainID: domainID,
Offset: offset,
Limit: 100,
Level: 6,
},
svcReq: groups.Page{},
svcRes: groups.Page{},
@@ -476,15 +478,15 @@ func TestListGroups(t *testing.T) {
err: errors.NewSDKErrorWithStatus(errors.Wrap(apiutil.ErrValidation, apiutil.ErrInvalidLevel), http.StatusBadRequest),
},
{
desc: "list groups with invalid page metadata",
token: validToken,
desc: "list groups with invalid page metadata",
domainID: domainID,
token: validToken,
pageMeta: sdk.PageMetadata{
Offset: offset,
Limit: limit,
Metadata: sdk.Metadata{
"key": make(chan int),
},
DomainID: domainID,
},
svcReq: groups.Page{},
svcRes: groups.Page{},
@@ -493,12 +495,12 @@ func TestListGroups(t *testing.T) {
err: errors.NewSDKError(errors.New("json: unsupported type: chan int")),
},
{
desc: "list groups with service response that cannot be unmarshalled",
token: validToken,
desc: "list groups with service response that cannot be unmarshalled",
domainID: domainID,
token: validToken,
pageMeta: sdk.PageMetadata{
Offset: offset,
Limit: limit,
DomainID: domainID,
Offset: offset,
Limit: limit,
},
svcReq: groups.Page{
PageMeta: groups.PageMeta{
@@ -528,11 +530,11 @@ func TestListGroups(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
svcCall := gsvc.On("ListGroups", mock.Anything, tc.session, policies.UsersKind, "", tc.svcReq).Return(tc.svcRes, tc.svcErr)
resp, err := mgsdk.Groups(tc.pageMeta, tc.token)
resp, err := mgsdk.Groups(tc.pageMeta, tc.domainID, tc.token)
assert.Equal(t, tc.err, err)
assert.Equal(t, tc.response, resp)
if tc.err == nil {
@@ -572,6 +574,7 @@ func TestListParentGroups(t *testing.T) {
cases := []struct {
desc string
token string
domainID string
session mgauthn.Session
pageMeta sdk.PageMetadata
parentID string
@@ -584,12 +587,12 @@ func TestListParentGroups(t *testing.T) {
}{
{
desc: "list parent groups successfully",
domainID: domainID,
token: validToken,
parentID: parentID,
pageMeta: sdk.PageMetadata{
Offset: offset,
Limit: limit,
DomainID: domainID,
Offset: offset,
Limit: limit,
},
svcReq: groups.Page{
PageMeta: groups.PageMeta{
@@ -617,12 +620,12 @@ func TestListParentGroups(t *testing.T) {
},
{
desc: "list parent groups with invalid token",
domainID: domainID,
token: invalidToken,
parentID: parentID,
pageMeta: sdk.PageMetadata{
Offset: offset,
Limit: limit,
DomainID: domainID,
Offset: offset,
Limit: limit,
},
svcReq: groups.Page{
PageMeta: groups.PageMeta{
@@ -641,12 +644,12 @@ func TestListParentGroups(t *testing.T) {
},
{
desc: "list parent groups with empty token",
domainID: domainID,
token: "",
parentID: parentID,
pageMeta: sdk.PageMetadata{
Offset: offset,
Limit: limit,
DomainID: domainID,
Offset: offset,
Limit: limit,
},
svcReq: groups.Page{},
svcRes: groups.Page{},
@@ -656,12 +659,12 @@ func TestListParentGroups(t *testing.T) {
},
{
desc: "list parent groups with zero limit",
domainID: domainID,
token: validToken,
parentID: parentID,
pageMeta: sdk.PageMetadata{
Offset: offset,
Limit: 0,
DomainID: domainID,
Offset: offset,
Limit: 0,
},
svcReq: groups.Page{
PageMeta: groups.PageMeta{
@@ -689,12 +692,12 @@ func TestListParentGroups(t *testing.T) {
},
{
desc: "list parent groups with limit greater than max",
domainID: domainID,
token: validToken,
parentID: parentID,
pageMeta: sdk.PageMetadata{
Offset: offset,
Limit: 110,
DomainID: domainID,
Offset: offset,
Limit: 110,
},
svcReq: groups.Page{},
svcRes: groups.Page{},
@@ -704,12 +707,12 @@ func TestListParentGroups(t *testing.T) {
},
{
desc: "list parent groups with given metadata",
domainID: domainID,
token: validToken,
parentID: parentID,
pageMeta: sdk.PageMetadata{
Offset: offset,
Limit: limit,
DomainID: domainID,
Offset: offset,
Limit: limit,
Metadata: sdk.Metadata{
"name": "user_89",
},
@@ -743,12 +746,12 @@ func TestListParentGroups(t *testing.T) {
},
{
desc: "list parent groups with invalid page metadata",
domainID: domainID,
token: validToken,
parentID: parentID,
pageMeta: sdk.PageMetadata{
Offset: offset,
Limit: limit,
DomainID: domainID,
Offset: offset,
Limit: limit,
Metadata: sdk.Metadata{
"key": make(chan int),
},
@@ -761,6 +764,7 @@ func TestListParentGroups(t *testing.T) {
},
{
desc: "list parent groups with service response that cannot be unmarshalled",
domainID: domainID,
token: validToken,
parentID: parentID,
pageMeta: sdk.PageMetadata{
@@ -799,11 +803,11 @@ func TestListParentGroups(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
svcCall := gsvc.On("ListGroups", mock.Anything, tc.session, policies.UsersKind, "", tc.svcReq).Return(tc.svcRes, tc.svcErr)
resp, err := mgsdk.Parents(tc.parentID, tc.pageMeta, tc.token)
resp, err := mgsdk.Parents(tc.parentID, tc.pageMeta, tc.domainID, tc.token)
assert.Equal(t, tc.err, err)
assert.Equal(t, tc.response, resp)
if tc.err == nil {
@@ -844,6 +848,7 @@ func TestListChildrenGroups(t *testing.T) {
cases := []struct {
desc string
token string
domainID string
session mgauthn.Session
childID string
pageMeta sdk.PageMetadata
@@ -855,13 +860,13 @@ func TestListChildrenGroups(t *testing.T) {
err errors.SDKError
}{
{
desc: "list children groups successfully",
token: validToken,
childID: childID,
desc: "list children groups successfully",
domainID: domainID,
token: validToken,
childID: childID,
pageMeta: sdk.PageMetadata{
Offset: offset,
Limit: limit,
DomainID: domainID,
Offset: offset,
Limit: limit,
},
svcReq: groups.Page{
PageMeta: groups.PageMeta{
@@ -888,13 +893,13 @@ func TestListChildrenGroups(t *testing.T) {
err: nil,
},
{
desc: "list children groups with invalid token",
token: invalidToken,
childID: childID,
desc: "list children groups with invalid token",
domainID: domainID,
token: invalidToken,
childID: childID,
pageMeta: sdk.PageMetadata{
Offset: offset,
Limit: limit,
DomainID: domainID,
Offset: offset,
Limit: limit,
},
svcReq: groups.Page{
PageMeta: groups.PageMeta{
@@ -912,13 +917,13 @@ func TestListChildrenGroups(t *testing.T) {
err: errors.NewSDKErrorWithStatus(svcerr.ErrAuthentication, http.StatusUnauthorized),
},
{
desc: "list children groups with empty token",
token: "",
childID: childID,
desc: "list children groups with empty token",
domainID: domainID,
token: "",
childID: childID,
pageMeta: sdk.PageMetadata{
Offset: offset,
Limit: limit,
DomainID: domainID,
Offset: offset,
Limit: limit,
},
svcReq: groups.Page{},
svcRes: groups.Page{},
@@ -927,13 +932,13 @@ func TestListChildrenGroups(t *testing.T) {
err: errors.NewSDKErrorWithStatus(apiutil.ErrBearerToken, http.StatusUnauthorized),
},
{
desc: "list children groups with zero limit",
token: validToken,
childID: childID,
desc: "list children groups with zero limit",
domainID: domainID,
token: validToken,
childID: childID,
pageMeta: sdk.PageMetadata{
Offset: offset,
Limit: 0,
DomainID: domainID,
Offset: offset,
Limit: 0,
},
svcReq: groups.Page{
PageMeta: groups.PageMeta{
@@ -960,12 +965,12 @@ func TestListChildrenGroups(t *testing.T) {
err: nil,
},
{
desc: "list children groups with limit greater than max",
token: validToken,
desc: "list children groups with limit greater than max",
domainID: domainID,
token: validToken,
pageMeta: sdk.PageMetadata{
Offset: offset,
Limit: 110,
DomainID: domainID,
Offset: offset,
Limit: 110,
},
svcReq: groups.Page{},
svcRes: groups.Page{},
@@ -974,13 +979,13 @@ func TestListChildrenGroups(t *testing.T) {
err: errors.NewSDKErrorWithStatus(errors.Wrap(apiutil.ErrValidation, apiutil.ErrLimitSize), http.StatusBadRequest),
},
{
desc: "list children groups with given metadata",
token: validToken,
childID: childID,
desc: "list children groups with given metadata",
domainID: domainID,
token: validToken,
childID: childID,
pageMeta: sdk.PageMetadata{
Offset: offset,
Limit: limit,
DomainID: domainID,
Offset: offset,
Limit: limit,
Metadata: sdk.Metadata{
"name": "user_89",
},
@@ -1013,13 +1018,13 @@ func TestListChildrenGroups(t *testing.T) {
err: nil,
},
{
desc: "list children groups with invalid page metadata",
token: validToken,
childID: childID,
desc: "list children groups with invalid page metadata",
domainID: domainID,
token: validToken,
childID: childID,
pageMeta: sdk.PageMetadata{
Offset: offset,
Limit: limit,
DomainID: domainID,
Offset: offset,
Limit: limit,
Metadata: sdk.Metadata{
"key": make(chan int),
},
@@ -1031,13 +1036,13 @@ func TestListChildrenGroups(t *testing.T) {
err: errors.NewSDKError(errors.New("json: unsupported type: chan int")),
},
{
desc: "list children groups with service response that cannot be unmarshalled",
token: validToken,
childID: childID,
desc: "list children groups with service response that cannot be unmarshalled",
domainID: domainID,
token: validToken,
childID: childID,
pageMeta: sdk.PageMetadata{
Offset: offset,
Limit: limit,
DomainID: domainID,
Offset: offset,
Limit: limit,
},
svcReq: groups.Page{
PageMeta: groups.PageMeta{
@@ -1070,11 +1075,11 @@ func TestListChildrenGroups(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
svcCall := gsvc.On("ListGroups", mock.Anything, tc.session, policies.UsersKind, "", tc.svcReq).Return(tc.svcRes, tc.svcErr)
resp, err := mgsdk.Children(tc.childID, tc.pageMeta, tc.token)
resp, err := mgsdk.Children(tc.childID, tc.pageMeta, tc.domainID, tc.token)
assert.Equal(t, tc.err, err)
assert.Equal(t, tc.response, resp)
if tc.err == nil {
@@ -1179,7 +1184,7 @@ func TestViewGroup(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
svcCall := gsvc.On("ViewGroup", mock.Anything, tc.session, tc.groupID).Return(tc.svcRes, tc.svcErr)
@@ -1273,7 +1278,7 @@ func TestViewGroupPermissions(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
svcCall := gsvc.On("ViewGroupPerms", mock.Anything, tc.session, tc.groupID).Return(tc.svcRes, tc.svcErr)
@@ -1462,7 +1467,7 @@ func TestUpdateGroup(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
svcCall := gsvc.On("UpdateGroup", mock.Anything, tc.session, tc.svcReq).Return(tc.svcRes, tc.svcErr)
@@ -1573,7 +1578,7 @@ func TestEnableGroup(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
svcCall := gsvc.On("EnableGroup", mock.Anything, tc.session, tc.groupID).Return(tc.svcRes, tc.svcErr)
@@ -1684,7 +1689,7 @@ func TestDisableGroup(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
svcCall := gsvc.On("DisableGroup", mock.Anything, tc.session, tc.groupID).Return(tc.svcRes, tc.svcErr)
@@ -1764,7 +1769,7 @@ func TestDeleteGroup(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
svcCall := gsvc.On("DeleteGroup", mock.Anything, tc.session, tc.groupID).Return(tc.svcErr)
@@ -1888,7 +1893,7 @@ func TestAddUserToGroup(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
svcCall := gsvc.On("Assign", mock.Anything, tc.session, tc.groupID, tc.addUserReq.Relation, policies.UsersKind, tc.addUserReq.UserIDs).Return(tc.svcErr)
@@ -2000,7 +2005,7 @@ func TestRemoveUserFromGroup(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
svcCall := gsvc.On("Unassign", mock.Anything, tc.session, tc.groupID, tc.removeUserReq.Relation, policies.UsersKind, tc.removeUserReq.UserIDs).Return(tc.svcErr)
pkg/sdk/go/invitations.go
+2 -2
View File
@@ -66,8 +66,8 @@ func (sdk mgSDK) Invitation(userID, domainID, token string) (invitation Invitati
return invitation, nil
}
func (sdk mgSDK) Invitations(pm PageMetadata, token string) (invitations InvitationPage, err error) {
endpoint := fmt.Sprintf("%s/%s", pm.DomainID, invitationsEndpoint)
func (sdk mgSDK) Invitations(pm PageMetadata, domainID, token string) (invitations InvitationPage, err error) {
endpoint := fmt.Sprintf("%s/%s", domainID, invitationsEndpoint)
url, err := sdk.withQueryParams(sdk.invitationsURL, endpoint, pm)
if err != nil {
pkg/sdk/go/invitations_test.go
+64 -63
View File
@@ -131,14 +131,14 @@ func TestSendInvitation(t *testing.T) {
Relation: invitation.Relation,
Resend: invitation.Resend,
},
svcErr: svcerr.ErrCreateEntity,
err: errors.NewSDKErrorWithStatus(svcerr.ErrCreateEntity, http.StatusUnprocessableEntity),
authenticateErr: svcerr.ErrCreateEntity,
err: errors.NewSDKErrorWithStatus(svcerr.ErrCreateEntity, http.StatusUnprocessableEntity),
},
}
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == valid {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: validID}
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: invitation.DomainID + "_" + validID, UserID: validID, DomainID: invitation.DomainID}
}
authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
svcCall := svc.On("SendInvitation", mock.Anything, tc.session, tc.svcReq).Return(tc.svcErr)
@@ -206,20 +206,20 @@ func TestViewInvitation(t *testing.T) {
err: errors.NewSDKErrorWithStatus(apiutil.ErrBearerToken, http.StatusUnauthorized),
},
{
desc: "view invitation with invalid domainID",
token: validToken,
userID: invitation.UserID,
domainID: wrongID,
svcRes: invitations.Invitation{},
svcErr: svcerr.ErrNotFound,
response: sdk.Invitation{},
err: errors.NewSDKErrorWithStatus(svcerr.ErrNotFound, http.StatusNotFound),
desc: "view invitation with invalid domainID",
token: validToken,
userID: invitation.UserID,
domainID: wrongID,
svcRes: invitations.Invitation{},
authenticateErr: svcerr.ErrNotFound,
response: sdk.Invitation{},
err: errors.NewSDKErrorWithStatus(svcerr.ErrNotFound, http.StatusNotFound),
},
}
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == valid {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: invitation.DomainID + "_" + validID, UserID: validID, DomainID: invitation.DomainID}
}
authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
svcCall := svc.On("ViewInvitation", mock.Anything, tc.session, tc.userID, tc.domainID).Return(tc.svcRes, tc.svcErr)
@@ -248,6 +248,7 @@ func TestListInvitation(t *testing.T) {
cases := []struct {
desc string
token string
domainID string
session mgauthn.Session
pageMeta sdk.PageMetadata
svcReq invitations.Page
@@ -258,17 +259,17 @@ func TestListInvitation(t *testing.T) {
err error
}{
{
desc: "list invitations successfully",
token: validToken,
desc: "list invitations successfully",
domainID: invitation.DomainID,
token: validToken,
pageMeta: sdk.PageMetadata{
Offset: 0,
Limit: 10,
DomainID: domainID,
Offset: 0,
Limit: 10,
},
svcReq: invitations.Page{
Offset: 0,
Limit: 10,
DomainID: domainID,
DomainID: invitation.DomainID,
},
svcRes: invitations.InvitationPage{
Total: 1,
@@ -282,28 +283,28 @@ func TestListInvitation(t *testing.T) {
err: nil,
},
{
desc: "list invitations with invalid token",
token: invalidToken,
desc: "list invitations with invalid token",
domainID: invitation.DomainID,
token: invalidToken,
pageMeta: sdk.PageMetadata{
Offset: 0,
Limit: 10,
DomainID: domainID,
},
svcReq: invitations.Page{
Offset: 0,
Limit: 10,
},
svcReq: invitations.Page{
Offset: 0,
Limit: 10,
DomainID: invitation.DomainID,
},
svcRes: invitations.InvitationPage{},
authenticateErr: svcerr.ErrAuthentication,
response: sdk.InvitationPage{},
err: errors.NewSDKErrorWithStatus(svcerr.ErrAuthentication, http.StatusUnauthorized),
},
{
desc: "list invitations with empty token",
token: "",
pageMeta: sdk.PageMetadata{
DomainID: domainID,
},
desc: "list invitations with empty token",
domainID: invitation.DomainID,
token: "",
pageMeta: sdk.PageMetadata{},
svcRes: invitations.InvitationPage{},
svcErr: nil,
response: sdk.InvitationPage{},
@@ -316,15 +317,15 @@ func TestListInvitation(t *testing.T) {
svcRes: invitations.InvitationPage{},
svcErr: nil,
response: sdk.InvitationPage{},
err: errors.NewSDKErrorWithStatus(errors.Wrap(apiutil.ErrValidation, apiutil.ErrMissingDomainID), http.StatusBadRequest),
err: errors.NewSDKErrorWithStatus(apiutil.ErrMissingDomainID, http.StatusBadRequest),
},
{
desc: "list invitations with limit greater than max limit",
token: validToken,
desc: "list invitations with limit greater than max limit",
token: validToken,
domainID: invitation.DomainID,
pageMeta: sdk.PageMetadata{
Offset: 0,
Limit: 101,
DomainID: domainID,
Offset: 0,
Limit: 101,
},
svcReq: invitations.Page{},
svcRes: invitations.InvitationPage{},
@@ -335,12 +336,12 @@ func TestListInvitation(t *testing.T) {
}
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == valid {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: validID}
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: invitation.DomainID + "_" + validID, UserID: validID, DomainID: invitation.DomainID}
}
authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
svcCall := svc.On("ListInvitations", mock.Anything, tc.session, tc.svcReq).Return(tc.svcRes, tc.svcErr)
resp, err := mgsdk.Invitations(tc.pageMeta, tc.token)
resp, err := mgsdk.Invitations(tc.pageMeta, tc.domainID, tc.token)
assert.Equal(t, tc.err, err)
assert.Equal(t, tc.response, resp)
if tc.err == nil {
@@ -393,17 +394,17 @@ func TestAcceptInvitation(t *testing.T) {
err: errors.NewSDKErrorWithStatus(apiutil.ErrBearerToken, http.StatusUnauthorized),
},
{
desc: "accept invitation with invalid domainID",
token: validToken,
domainID: wrongID,
svcErr: svcerr.ErrNotFound,
err: errors.NewSDKErrorWithStatus(svcerr.ErrNotFound, http.StatusNotFound),
desc: "accept invitation with invalid domainID",
token: validToken,
domainID: wrongID,
authenticateErr: svcerr.ErrNotFound,
err: errors.NewSDKErrorWithStatus(svcerr.ErrNotFound, http.StatusNotFound),
},
}
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == valid {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: validID}
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: invitation.DomainID + "_" + validID, UserID: validID, DomainID: invitation.DomainID}
}
authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
svcCall := svc.On("AcceptInvitation", mock.Anything, tc.session, tc.domainID).Return(tc.svcErr)
@@ -459,17 +460,17 @@ func TestRejectInvitation(t *testing.T) {
err: errors.NewSDKErrorWithStatus(apiutil.ErrBearerToken, http.StatusUnauthorized),
},
{
desc: "reject invitation with invalid domainID",
token: validToken,
domainID: wrongID,
svcErr: svcerr.ErrNotFound,
err: errors.NewSDKErrorWithStatus(svcerr.ErrNotFound, http.StatusNotFound),
desc: "reject invitation with invalid domainID",
token: validToken,
domainID: wrongID,
authenticateErr: svcerr.ErrNotFound,
err: errors.NewSDKErrorWithStatus(svcerr.ErrNotFound, http.StatusNotFound),
},
}
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == valid {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: validID}
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: invitation.DomainID + "_" + validID, UserID: validID, DomainID: invitation.DomainID}
}
authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
svcCall := svc.On("RejectInvitation", mock.Anything, tc.session, tc.domainID).Return(tc.svcErr)
@@ -529,18 +530,18 @@ func TestDeleteInvitation(t *testing.T) {
err: errors.NewSDKErrorWithStatus(apiutil.ErrBearerToken, http.StatusUnauthorized),
},
{
desc: "delete invitation with invalid domainID",
token: validToken,
userID: invitation.UserID,
domainID: wrongID,
svcErr: svcerr.ErrNotFound,
err: errors.NewSDKErrorWithStatus(svcerr.ErrNotFound, http.StatusNotFound),
desc: "delete invitation with invalid domainID",
token: validToken,
userID: invitation.UserID,
domainID: wrongID,
authenticateErr: svcerr.ErrNotFound,
err: errors.NewSDKErrorWithStatus(svcerr.ErrNotFound, http.StatusNotFound),
},
}
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == valid {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: validID}
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: invitation.DomainID + "_" + validID, UserID: validID, DomainID: invitation.DomainID}
}
authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
svcCall := svc.On("DeleteInvitation", mock.Anything, tc.session, tc.userID, tc.domainID).Return(tc.svcErr)
pkg/sdk/go/sdk.go
+28 -34
View File
@@ -293,13 +293,9 @@ type SDK interface {
// RefreshToken receives credentials and returns user token.
//
// example:
// lt := sdk.Login{
// DomainID: "domain_id",
// }
// example:
// token, _ := sdk.RefreshToken(lt,"refresh_token")
// token, _ := sdk.RefreshToken("refresh_token")
// fmt.Println(token)
RefreshToken(lt Login, token string) (Token, errors.SDKError)
RefreshToken(token string) (Token, errors.SDKError)
// ListUserChannels list all channels belongs a particular user id.
//
@@ -391,9 +387,9 @@ type SDK interface {
// Limit: 10,
// Name: "My Thing",
// }
// things, _ := sdk.Things(pm, "token")
// things, _ := sdk.Things(pm, "domainID", "token")
// fmt.Println(things)
Things(pm PageMetadata, token string) (ThingsPage, errors.SDKError)
Things(pm PageMetadata, domainID, token string) (ThingsPage, errors.SDKError)
// ThingsByChannel returns page of things that are connected to specified channel.
//
@@ -403,9 +399,9 @@ type SDK interface {
// Limit: 10,
// Name: "My Thing",
// }
// things, _ := sdk.ThingsByChannel("channelID", pm, "token")
// things, _ := sdk.ThingsByChannel("channelID", pm, "domainID", "token")
// fmt.Println(things)
ThingsByChannel(chanID string, pm PageMetadata, token string) (ThingsPage, errors.SDKError)
ThingsByChannel(chanID string, pm PageMetadata, domainID, token string) (ThingsPage, errors.SDKError)
// Thing returns thing object by id.
//
@@ -497,9 +493,9 @@ type SDK interface {
// Limit: 10,
// Permission: "edit", // available Options: "administrator", "administrator", "delete", edit", "view", "share", "owner", "owner", "admin", "editor", "contributor", "editor", "viewer", "guest", "create"
// }
// users, _ := sdk.ListThingUsers("thing_id", pm, "token")
// users, _ := sdk.ListThingUsers("thing_id", pm, "domainID", "token")
// fmt.Println(users)
ListThingUsers(thingID string, pm PageMetadata, token string) (UsersPage, errors.SDKError)
ListThingUsers(thingID string, pm PageMetadata, domainID, token string) (UsersPage, errors.SDKError)
// DeleteThing deletes a thing with the given id.
//
@@ -529,9 +525,9 @@ type SDK interface {
// Limit: 10,
// Name: "My Group",
// }
// groups, _ := sdk.Groups(pm, "token")
// groups, _ := sdk.Groups(pm, "domainID", "token")
// fmt.Println(groups)
Groups(pm PageMetadata, token string) (GroupsPage, errors.SDKError)
Groups(pm PageMetadata, domainID, token string) (GroupsPage, errors.SDKError)
// Parents returns page of users groups.
//
@@ -541,9 +537,9 @@ type SDK interface {
// Limit: 10,
// Name: "My Group",
// }
// groups, _ := sdk.Parents("groupID", pm, "token")
// groups, _ := sdk.Parents("groupID", pm, "domainID", "token")
// fmt.Println(groups)
Parents(id string, pm PageMetadata, token string) (GroupsPage, errors.SDKError)
Parents(id string, pm PageMetadata, domainID, token string) (GroupsPage, errors.SDKError)
// Children returns page of users groups.
//
@@ -553,9 +549,9 @@ type SDK interface {
// Limit: 10,
// Name: "My Group",
// }
// groups, _ := sdk.Children("groupID", pm, "token")
// groups, _ := sdk.Children("groupID", pm, "domainID", "token")
// fmt.Println(groups)
Children(id string, pm PageMetadata, token string) (GroupsPage, errors.SDKError)
Children(id string, pm PageMetadata, domainID, token string) (GroupsPage, errors.SDKError)
// Group returns users group object by id.
//
@@ -629,9 +625,9 @@ type SDK interface {
// Limit: 10,
// Permission: "edit", // available Options: "administrator", "administrator", "delete", edit", "view", "share", "owner", "owner", "admin", "editor", "contributor", "editor", "viewer", "guest", "create"
// }
// groups, _ := sdk.ListGroupUsers("groupID", pm, "token")
// groups, _ := sdk.ListGroupUsers("groupID", pm, "domainID", "token")
// fmt.Println(groups)
ListGroupUsers(groupID string, pm PageMetadata, token string) (UsersPage, errors.SDKError)
ListGroupUsers(groupID string, pm PageMetadata, domainID, token string) (UsersPage, errors.SDKError)
// ListGroupChannels list all channels in the group id .
//
@@ -639,12 +635,11 @@ type SDK interface {
// pm := sdk.PageMetadata{
// Offset: 0,
// Limit: 10,
// DomainID: "domain"
// Permission: "edit", // available Options: "administrator", "administrator", "delete", edit", "view", "share", "owner", "owner", "admin", "editor", "contributor", "editor", "viewer", "guest", "create"
// }
// groups, _ := sdk.ListGroupChannels("groupID", pm, "token")
// groups, _ := sdk.ListGroupChannels("groupID", pm, "domainID", "token")
// fmt.Println(groups)
ListGroupChannels(groupID string, pm PageMetadata, token string) (ChannelsPage, errors.SDKError)
ListGroupChannels(groupID string, pm PageMetadata, domainID, token string) (ChannelsPage, errors.SDKError)
// DeleteGroup delete given group id.
//
@@ -673,11 +668,10 @@ type SDK interface {
// Offset: 0,
// Limit: 10,
// Name: "My Channel",
// Domain: "domainID"
// }
// channels, _ := sdk.Channels(pm, "token")
// channels, _ := sdk.Channels(pm, "domainID", "token")
// fmt.Println(channels)
Channels(pm PageMetadata, token string) (ChannelsPage, errors.SDKError)
Channels(pm PageMetadata, domainID, token string) (ChannelsPage, errors.SDKError)
// ChannelsByThing returns page of channels that are connected to specified thing.
//
@@ -763,9 +757,9 @@ type SDK interface {
// Limit: 10,
// Permission: "edit", // available Options: "administrator", "administrator", "delete", edit", "view", "share", "owner", "owner", "admin", "editor", "contributor", "editor", "viewer", "guest", "create"
// }
// users, _ := sdk.ListChannelUsers("channel_id", pm, "token")
// users, _ := sdk.ListChannelUsers("channel_id", pm, "domainID", "token")
// fmt.Println(users)
ListChannelUsers(channelID string, pm PageMetadata, token string) (UsersPage, errors.SDKError)
ListChannelUsers(channelID string, pm PageMetadata, domainID, token string) (UsersPage, errors.SDKError)
// AddUserGroupToChannel add user group to a channel.
//
@@ -795,9 +789,9 @@ type SDK interface {
// Limit: 10,
// Permission: "view",
// }
// groups, _ := sdk.ListChannelUserGroups("channel_id_1", pm, "token")
// groups, _ := sdk.ListChannelUserGroups("channel_id_1", pm, "domainID", "token")
// fmt.Println(groups)
ListChannelUserGroups(channelID string, pm PageMetadata, token string) (GroupsPage, errors.SDKError)
ListChannelUserGroups(channelID string, pm PageMetadata, domainID, token string) (GroupsPage, errors.SDKError)
// DeleteChannel delete given group id.
//
@@ -956,9 +950,9 @@ type SDK interface {
// Offset: 0,
// Limit: 10,
// }
// bootstraps, _ := sdk.Bootstraps(pm, "token")
// bootstraps, _ := sdk.Bootstraps(pm, "domainID", "token")
// fmt.Println(bootstraps)
Bootstraps(pm PageMetadata, token string) (BootstrapPage, errors.SDKError)
Bootstraps(pm PageMetadata, domainID, token string) (BootstrapPage, errors.SDKError)
// Whitelist updates Thing state Config with given ID belonging to the user identified by the given token.
//
@@ -1159,9 +1153,9 @@ type SDK interface {
// Invitations returns a list of invitations.
//
// For example:
// invitations, _ := sdk.Invitations(PageMetadata{Offset: 0, Limit: 10, Domain: "domainID"}, "token")
// invitations, _ := sdk.Invitations(PageMetadata{Offset: 0, Limit: 10}, "domainID", "token")
// fmt.Println(invitations)
Invitations(pm PageMetadata, token string) (invitations InvitationPage, err error)
Invitations(pm PageMetadata, domainID, token string) (invitations InvitationPage, err error)
// AcceptInvitation accepts an invitation by adding the user to the domain that they were invited to.
//
pkg/sdk/go/things.go
+6 -6
View File
@@ -79,8 +79,8 @@ func (sdk mgSDK) CreateThings(things []Thing, domainID, token string) ([]Thing,
return ctr.Things, nil
}
func (sdk mgSDK) Things(pm PageMetadata, token string) (ThingsPage, errors.SDKError) {
endpoint := fmt.Sprintf("%s/%s", pm.DomainID, thingsEndpoint)
func (sdk mgSDK) Things(pm PageMetadata, domainID, token string) (ThingsPage, errors.SDKError) {
endpoint := fmt.Sprintf("%s/%s", domainID, thingsEndpoint)
url, err := sdk.withQueryParams(sdk.thingsURL, endpoint, pm)
if err != nil {
return ThingsPage{}, errors.NewSDKError(err)
@@ -99,8 +99,8 @@ func (sdk mgSDK) Things(pm PageMetadata, token string) (ThingsPage, errors.SDKEr
return cp, nil
}
func (sdk mgSDK) ThingsByChannel(chanID string, pm PageMetadata, token string) (ThingsPage, errors.SDKError) {
url, err := sdk.withQueryParams(sdk.thingsURL, fmt.Sprintf("%s/channels/%s/%s", pm.DomainID, chanID, thingsEndpoint), pm)
func (sdk mgSDK) ThingsByChannel(chanID string, pm PageMetadata, domainID, token string) (ThingsPage, errors.SDKError) {
url, err := sdk.withQueryParams(sdk.thingsURL, fmt.Sprintf("%s/channels/%s/%s", domainID, chanID, thingsEndpoint), pm)
if err != nil {
return ThingsPage{}, errors.NewSDKError(err)
}
@@ -269,8 +269,8 @@ func (sdk mgSDK) UnshareThing(thingID string, req UsersRelationRequest, domainID
return sdkerr
}
func (sdk mgSDK) ListThingUsers(thingID string, pm PageMetadata, token string) (UsersPage, errors.SDKError) {
url, err := sdk.withQueryParams(sdk.usersURL, fmt.Sprintf("%s/%s/%s/%s", pm.DomainID, thingsEndpoint, thingID, usersEndpoint), pm)
func (sdk mgSDK) ListThingUsers(thingID string, pm PageMetadata, domainID, token string) (UsersPage, errors.SDKError) {
url, err := sdk.withQueryParams(sdk.usersURL, fmt.Sprintf("%s/%s/%s/%s", domainID, thingsEndpoint, thingID, usersEndpoint), pm)
if err != nil {
return UsersPage{}, errors.NewSDKError(err)
}
pkg/sdk/go/things_test.go
+80 -78
View File
@@ -190,7 +190,7 @@ func TestCreateThing(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, mock.Anything).Return(tc.session, tc.authenticateErr)
svcCall := tsvc.On("CreateThings", mock.Anything, tc.session, tc.svcReq).Return(tc.svcRes, tc.svcErr)
@@ -301,7 +301,7 @@ func TestCreateThings(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, mock.Anything).Return(tc.session, tc.authenticateErr)
svcCall := tsvc.On("CreateThings", mock.Anything, tc.session, tc.svcReq[0], tc.svcReq[1], tc.svcReq[2]).Return(tc.svcRes, tc.svcErr)
@@ -340,6 +340,7 @@ func TestListThings(t *testing.T) {
cases := []struct {
desc string
token string
domainID string
session mgauthn.Session
pageMeta sdk.PageMetadata
svcReq mgclients.Page
@@ -350,12 +351,12 @@ func TestListThings(t *testing.T) {
err errors.SDKError
}{
{
desc: "list all things successfully",
token: validToken,
desc: "list all things successfully",
domainID: domainID,
token: validToken,
pageMeta: sdk.PageMetadata{
Offset: 0,
Limit: 100,
DomainID: domainID,
Offset: 0,
Limit: 100,
},
svcReq: mgclients.Page{
Offset: 0,
@@ -381,12 +382,12 @@ func TestListThings(t *testing.T) {
},
},
{
desc: "list all things with an invalid token",
token: invalidToken,
desc: "list all things with an invalid token",
domainID: domainID,
token: invalidToken,
pageMeta: sdk.PageMetadata{
Offset: 0,
Limit: 100,
DomainID: domainID,
Offset: 0,
Limit: 100,
},
svcReq: mgclients.Page{
Offset: 0,
@@ -400,12 +401,12 @@ func TestListThings(t *testing.T) {
err: errors.NewSDKErrorWithStatus(svcerr.ErrAuthentication, http.StatusUnauthorized),
},
{
desc: "list all things with limit greater than max",
token: validToken,
desc: "list all things with limit greater than max",
domainID: domainID,
token: validToken,
pageMeta: sdk.PageMetadata{
Offset: 0,
Limit: 1000,
DomainID: domainID,
Offset: 0,
Limit: 1000,
},
svcReq: mgclients.Page{},
svcRes: mgclients.ClientsPage{},
@@ -414,13 +415,13 @@ func TestListThings(t *testing.T) {
err: errors.NewSDKErrorWithStatus(errors.Wrap(apiutil.ErrValidation, apiutil.ErrLimitSize), http.StatusBadRequest),
},
{
desc: "list all things with name size greater than max",
token: validToken,
desc: "list all things with name size greater than max",
domainID: domainID,
token: validToken,
pageMeta: sdk.PageMetadata{
Offset: 0,
Limit: 100,
Name: strings.Repeat("a", 1025),
DomainID: domainID,
Offset: 0,
Limit: 100,
Name: strings.Repeat("a", 1025),
},
svcReq: mgclients.Page{},
svcRes: mgclients.ClientsPage{},
@@ -429,13 +430,13 @@ func TestListThings(t *testing.T) {
err: errors.NewSDKErrorWithStatus(errors.Wrap(apiutil.ErrValidation, apiutil.ErrNameSize), http.StatusBadRequest),
},
{
desc: "list all things with status",
token: validToken,
desc: "list all things with status",
domainID: domainID,
token: validToken,
pageMeta: sdk.PageMetadata{
Offset: 0,
Limit: 100,
Status: mgclients.DisabledStatus.String(),
DomainID: domainID,
Offset: 0,
Limit: 100,
Status: mgclients.DisabledStatus.String(),
},
svcReq: mgclients.Page{
Offset: 0,
@@ -463,13 +464,13 @@ func TestListThings(t *testing.T) {
err: nil,
},
{
desc: "list all things with tags",
token: validToken,
desc: "list all things with tags",
domainID: domainID,
token: validToken,
pageMeta: sdk.PageMetadata{
Offset: 0,
Limit: 100,
Tag: "tag1",
DomainID: domainID,
Offset: 0,
Limit: 100,
Tag: "tag1",
},
svcReq: mgclients.Page{
Offset: 0,
@@ -497,15 +498,15 @@ func TestListThings(t *testing.T) {
err: nil,
},
{
desc: "list all things with invalid metadata",
token: validToken,
desc: "list all things with invalid metadata",
domainID: domainID,
token: validToken,
pageMeta: sdk.PageMetadata{
Offset: 0,
Limit: 100,
Metadata: map[string]interface{}{
"test": make(chan int),
},
DomainID: domainID,
},
svcReq: mgclients.Page{},
svcRes: mgclients.ClientsPage{},
@@ -514,12 +515,12 @@ func TestListThings(t *testing.T) {
err: errors.NewSDKError(errors.New("json: unsupported type: chan int")),
},
{
desc: "list all things with response that can't be unmarshalled",
token: validToken,
desc: "list all things with response that can't be unmarshalled",
domainID: domainID,
token: validToken,
pageMeta: sdk.PageMetadata{
Offset: 0,
Limit: 100,
DomainID: domainID,
Offset: 0,
Limit: 100,
},
svcReq: mgclients.Page{
Offset: 0,
@@ -550,11 +551,11 @@ func TestListThings(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, mock.Anything).Return(tc.session, tc.authenticateErr)
svcCall := tsvc.On("ListClients", mock.Anything, tc.session, mock.Anything, tc.svcReq).Return(tc.svcRes, tc.svcErr)
resp, err := mgsdk.Things(tc.pageMeta, tc.token)
resp, err := mgsdk.Things(tc.pageMeta, tc.domainID, tc.token)
assert.Equal(t, tc.err, err)
assert.Equal(t, tc.response, resp)
if tc.err == nil {
@@ -588,6 +589,7 @@ func TestListThingsByChannel(t *testing.T) {
cases := []struct {
desc string
token string
domainID string
session mgauthn.Session
channelID string
pageMeta sdk.PageMetadata
@@ -600,12 +602,12 @@ func TestListThingsByChannel(t *testing.T) {
}{
{
desc: "list things successfully",
domainID: domainID,
token: validToken,
channelID: validID,
pageMeta: sdk.PageMetadata{
Offset: 0,
Limit: 100,
DomainID: domainID,
Offset: 0,
Limit: 100,
},
svcReq: mgclients.Page{
Offset: 0,
@@ -632,12 +634,12 @@ func TestListThingsByChannel(t *testing.T) {
},
{
desc: "list things with an invalid token",
domainID: domainID,
token: invalidToken,
channelID: validID,
pageMeta: sdk.PageMetadata{
Offset: 0,
Limit: 100,
DomainID: domainID,
Offset: 0,
Limit: 100,
},
svcReq: mgclients.Page{
Offset: 0,
@@ -652,12 +654,12 @@ func TestListThingsByChannel(t *testing.T) {
},
{
desc: "list things with empty token",
domainID: domainID,
token: "",
channelID: validID,
pageMeta: sdk.PageMetadata{
Offset: 0,
Limit: 100,
DomainID: domainID,
Offset: 0,
Limit: 100,
},
svcReq: mgclients.Page{},
svcRes: mgclients.MembersPage{},
@@ -667,13 +669,13 @@ func TestListThingsByChannel(t *testing.T) {
},
{
desc: "list things with status",
domainID: domainID,
token: validToken,
channelID: validID,
pageMeta: sdk.PageMetadata{
Offset: 0,
Limit: 100,
Status: mgclients.DisabledStatus.String(),
DomainID: domainID,
Offset: 0,
Limit: 100,
Status: mgclients.DisabledStatus.String(),
},
svcReq: mgclients.Page{
Offset: 0,
@@ -702,12 +704,12 @@ func TestListThingsByChannel(t *testing.T) {
},
{
desc: "list things with empty channel id",
domainID: domainID,
token: validToken,
channelID: "",
pageMeta: sdk.PageMetadata{
Offset: 0,
Limit: 100,
DomainID: domainID,
Offset: 0,
Limit: 100,
},
svcReq: mgclients.Page{},
svcRes: mgclients.MembersPage{},
@@ -717,6 +719,7 @@ func TestListThingsByChannel(t *testing.T) {
},
{
desc: "list things with invalid metadata",
domainID: domainID,
token: validToken,
channelID: validID,
pageMeta: sdk.PageMetadata{
@@ -725,7 +728,6 @@ func TestListThingsByChannel(t *testing.T) {
Metadata: map[string]interface{}{
"test": make(chan int),
},
DomainID: domainID,
},
svcReq: mgclients.Page{},
svcRes: mgclients.MembersPage{},
@@ -735,12 +737,12 @@ func TestListThingsByChannel(t *testing.T) {
},
{
desc: "list things with response that can't be unmarshalled",
domainID: domainID,
token: validToken,
channelID: validID,
pageMeta: sdk.PageMetadata{
Offset: 0,
Limit: 100,
DomainID: domainID,
Offset: 0,
Limit: 100,
},
svcReq: mgclients.Page{
Offset: 0,
@@ -771,11 +773,11 @@ func TestListThingsByChannel(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, mock.Anything).Return(tc.session, tc.authenticateErr)
svcCall := tsvc.On("ListClientsByGroup", mock.Anything, tc.session, tc.channelID, tc.svcReq).Return(tc.svcRes, tc.svcErr)
resp, err := mgsdk.ThingsByChannel(tc.channelID, tc.pageMeta, tc.token)
resp, err := mgsdk.ThingsByChannel(tc.channelID, tc.pageMeta, tc.domainID, tc.token)
assert.Equal(t, tc.err, err)
assert.Equal(t, tc.response, resp)
if tc.err == nil {
@@ -881,7 +883,7 @@ func TestViewThing(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, mock.Anything).Return(tc.session, tc.authenticateErr)
svcCall := tsvc.On("ViewClient", mock.Anything, tc.session, tc.thingID).Return(tc.svcRes, tc.svcErr)
@@ -976,7 +978,7 @@ func TestViewThingPermissions(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, mock.Anything).Return(tc.session, tc.authenticateErr)
svcCall := tsvc.On("ViewClientPerms", mock.Anything, tc.session, tc.thingID).Return(tc.svcRes, tc.svcErr)
@@ -1134,7 +1136,7 @@ func TestUpdateThing(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, mock.Anything).Return(tc.session, tc.authenticateErr)
svcCall := tsvc.On("UpdateClient", mock.Anything, tc.session, tc.svcReq).Return(tc.svcRes, tc.svcErr)
@@ -1286,7 +1288,7 @@ func TestUpdateThingTags(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, mock.Anything).Return(tc.session, tc.authenticateErr)
svcCall := tsvc.On("UpdateClientTags", mock.Anything, tc.session, tc.svcReq).Return(tc.svcRes, tc.svcErr)
@@ -1418,7 +1420,7 @@ func TestUpdateThingSecret(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, mock.Anything).Return(tc.session, tc.authenticateErr)
svcCall := tsvc.On("UpdateClientSecret", mock.Anything, tc.session, tc.thingID, tc.newSecret).Return(tc.svcRes, tc.svcErr)
@@ -1521,7 +1523,7 @@ func TestEnableThing(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, mock.Anything).Return(tc.session, tc.authenticateErr)
svcCall := tsvc.On("EnableClient", mock.Anything, tc.session, tc.thingID).Return(tc.svcRes, tc.svcErr)
@@ -1624,7 +1626,7 @@ func TestDisableThing(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, mock.Anything).Return(tc.session, tc.authenticateErr)
svcCall := tsvc.On("DisableClient", mock.Anything, tc.session, tc.thingID).Return(tc.svcRes, tc.svcErr)
@@ -1739,7 +1741,7 @@ func TestShareThing(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, mock.Anything).Return(tc.session, tc.authenticateErr)
svcCall := tsvc.On("Share", mock.Anything, tc.session, tc.thingID, tc.shareReq.Relation, tc.shareReq.UserIDs[0]).Return(tc.svcErr)
@@ -1840,7 +1842,7 @@ func TestUnshareThing(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, mock.Anything).Return(tc.session, tc.authenticateErr)
svcCall := tsvc.On("Unshare", mock.Anything, tc.session, tc.thingID, tc.shareReq.Relation, tc.shareReq.UserIDs[0]).Return(tc.svcErr)
@@ -1921,7 +1923,7 @@ func TestDeleteThing(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, mock.Anything).Return(tc.session, tc.authenticateErr)
svcCall := tsvc.On("DeleteClient", mock.Anything, tc.session, tc.thingID).Return(tc.svcErr)
@@ -2177,7 +2179,7 @@ func TestListUserThings(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, mock.Anything).Return(tc.session, tc.authenticateErr)
svcCall := tsvc.On("ListClients", mock.Anything, tc.session, tc.userID, tc.svcReq).Return(tc.svcRes, tc.svcErr)
pkg/sdk/go/tokens.go
+2 -7
View File
@@ -22,7 +22,6 @@ type Token struct {
type Login struct {
Identity string `json:"identity"`
Secret string `json:"secret"`
DomainID string `json:"domain_id,omitempty"`
}
func (sdk mgSDK) CreateToken(lt Login) (Token, errors.SDKError) {
@@ -45,14 +44,10 @@ func (sdk mgSDK) CreateToken(lt Login) (Token, errors.SDKError) {
return token, nil
}
func (sdk mgSDK) RefreshToken(lt Login, token string) (Token, errors.SDKError) {
data, err := json.Marshal(lt)
if err != nil {
return Token{}, errors.NewSDKError(err)
}
func (sdk mgSDK) RefreshToken(token string) (Token, errors.SDKError) {
url := fmt.Sprintf("%s/%s/%s", sdk.usersURL, usersEndpoint, refreshTokenEndpoint)
_, body, sdkerr := sdk.processRequest(http.MethodPost, url, token, data, nil, http.StatusCreated)
_, body, sdkerr := sdk.processRequest(http.MethodPost, url, token, nil, nil, http.StatusCreated)
if sdkerr != nil {
return Token{}, sdkerr
}
pkg/sdk/go/tokens_test.go
+9 -24
View File
@@ -43,7 +43,6 @@ func TestIssueToken(t *testing.T) {
login: sdk.Login{
Identity: client.Credentials.Identity,
Secret: client.Credentials.Secret,
DomainID: validID,
},
svcRes: &magistrala.Token{
AccessToken: token.AccessToken,
@@ -59,7 +58,6 @@ func TestIssueToken(t *testing.T) {
login: sdk.Login{
Identity: invalidIdentity,
Secret: client.Credentials.Secret,
DomainID: validID,
},
svcRes: &magistrala.Token{},
svcErr: svcerr.ErrAuthentication,
@@ -71,7 +69,6 @@ func TestIssueToken(t *testing.T) {
login: sdk.Login{
Identity: client.Credentials.Identity,
Secret: "invalid",
DomainID: validID,
},
svcRes: &magistrala.Token{},
svcErr: svcerr.ErrLogin,
@@ -83,7 +80,6 @@ func TestIssueToken(t *testing.T) {
login: sdk.Login{
Identity: "",
Secret: client.Credentials.Secret,
DomainID: validID,
},
svcRes: &magistrala.Token{},
svcErr: nil,
@@ -95,7 +91,6 @@ func TestIssueToken(t *testing.T) {
login: sdk.Login{
Identity: client.Credentials.Identity,
Secret: "",
DomainID: validID,
},
svcRes: &magistrala.Token{},
svcErr: nil,
@@ -105,12 +100,12 @@ func TestIssueToken(t *testing.T) {
}
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
svcCall := svc.On("IssueToken", mock.Anything, tc.login.Identity, tc.login.Secret, tc.login.DomainID).Return(tc.svcRes, tc.svcErr)
svcCall := svc.On("IssueToken", mock.Anything, tc.login.Identity, tc.login.Secret).Return(tc.svcRes, tc.svcErr)
resp, err := mgsdk.CreateToken(tc.login)
assert.Equal(t, tc.err, err)
assert.Equal(t, tc.response, resp)
if tc.err == nil {
ok := svcCall.Parent.AssertCalled(t, "IssueToken", mock.Anything, tc.login.Identity, tc.login.Secret, tc.login.DomainID)
ok := svcCall.Parent.AssertCalled(t, "IssueToken", mock.Anything, tc.login.Identity, tc.login.Secret)
assert.True(t, ok)
}
svcCall.Unset()
@@ -132,7 +127,6 @@ func TestRefreshToken(t *testing.T) {
cases := []struct {
desc string
token string
login sdk.Login
svcRes *magistrala.Token
svcErr error
identifyErr error
@@ -142,9 +136,6 @@ func TestRefreshToken(t *testing.T) {
{
desc: "refresh token successfully",
token: token.RefreshToken,
login: sdk.Login{
DomainID: validID,
},
svcRes: &magistrala.Token{
AccessToken: token.AccessToken,
RefreshToken: &token.RefreshToken,
@@ -154,22 +145,16 @@ func TestRefreshToken(t *testing.T) {
err: nil,
},
{
desc: "refresh token with invalid token",
token: invalidToken,
login: sdk.Login{
DomainID: validID,
},
desc: "refresh token with invalid token",
token: invalidToken,
svcRes: nil,
identifyErr: svcerr.ErrAuthentication,
response: sdk.Token{},
err: errors.NewSDKErrorWithStatus(svcerr.ErrAuthentication, http.StatusUnauthorized),
},
{
desc: "refresh token with empty token",
token: "",
login: sdk.Login{
DomainID: validID,
},
desc: "refresh token with empty token",
token: "",
response: sdk.Token{},
err: errors.NewSDKErrorWithStatus(apiutil.ErrBearerToken, http.StatusUnauthorized),
},
@@ -177,12 +162,12 @@ func TestRefreshToken(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
authCall := auth.On("Authenticate", mock.Anything, mock.Anything).Return(mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: validID}, tc.identifyErr)
svcCall := svc.On("RefreshToken", mock.Anything, mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: validID}, tc.token, tc.login.DomainID).Return(tc.svcRes, tc.svcErr)
resp, err := mgsdk.RefreshToken(tc.login, tc.token)
svcCall := svc.On("RefreshToken", mock.Anything, mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: validID}, tc.token).Return(tc.svcRes, tc.svcErr)
resp, err := mgsdk.RefreshToken(tc.token)
assert.Equal(t, tc.err, err)
assert.Equal(t, tc.response, resp)
if tc.err == nil {
ok := svcCall.Parent.AssertCalled(t, "RefreshToken", mock.Anything, mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: validID}, tc.token, tc.login.DomainID)
ok := svcCall.Parent.AssertCalled(t, "RefreshToken", mock.Anything, mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: validID}, tc.token)
assert.True(t, ok)
}
svcCall.Unset()
pkg/sdk/go/users_test.go
+2 -2
View File
@@ -2131,7 +2131,7 @@ func TestListMembers(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
svcCall := svc.On("ListMembers", mock.Anything, tc.session, "groups", tc.groupID, tc.svcReq).Return(tc.svcRes, tc.svcErr)
@@ -2394,7 +2394,7 @@ func TestListUserGroups(t *testing.T) {
for _, tc := range cases {
t.Run(tc.desc, func(t *testing.T) {
if tc.token == validToken {
tc.session = mgauthn.Session{DomainUserID: validID, UserID: validID, DomainID: domainID}
tc.session = mgauthn.Session{DomainUserID: domainID + "_" + validID, UserID: validID, DomainID: domainID}
}
authCall := auth.On("Authenticate", mock.Anything, tc.token).Return(tc.session, tc.authenticateErr)
svcCall := svc.On("ListGroups", mock.Anything, tc.session, "users", tc.userID, tc.svcReq).Return(tc.svcRes, tc.svcErr)
pkg/sdk/mocks/sdk.go
+126 -126
View File
@@ -206,9 +206,9 @@ func (_m *SDK) BootstrapSecure(externalID string, externalKey string, cryptoKey
return r0, r1
}
// Bootstraps provides a mock function with given fields: pm, token
func (_m *SDK) Bootstraps(pm sdk.PageMetadata, token string) (sdk.BootstrapPage, errors.SDKError) {
ret := _m.Called(pm, token)
// Bootstraps provides a mock function with given fields: pm, domainID, token
func (_m *SDK) Bootstraps(pm sdk.PageMetadata, domainID string, token string) (sdk.BootstrapPage, errors.SDKError) {
ret := _m.Called(pm, domainID, token)
if len(ret) == 0 {
panic("no return value specified for Bootstraps")
@@ -216,17 +216,17 @@ func (_m *SDK) Bootstraps(pm sdk.PageMetadata, token string) (sdk.BootstrapPage,
var r0 sdk.BootstrapPage
var r1 errors.SDKError
if rf, ok := ret.Get(0).(func(sdk.PageMetadata, string) (sdk.BootstrapPage, errors.SDKError)); ok {
return rf(pm, token)
if rf, ok := ret.Get(0).(func(sdk.PageMetadata, string, string) (sdk.BootstrapPage, errors.SDKError)); ok {
return rf(pm, domainID, token)
}
if rf, ok := ret.Get(0).(func(sdk.PageMetadata, string) sdk.BootstrapPage); ok {
r0 = rf(pm, token)
if rf, ok := ret.Get(0).(func(sdk.PageMetadata, string, string) sdk.BootstrapPage); ok {
r0 = rf(pm, domainID, token)
} else {
r0 = ret.Get(0).(sdk.BootstrapPage)
}
if rf, ok := ret.Get(1).(func(sdk.PageMetadata, string) errors.SDKError); ok {
r1 = rf(pm, token)
if rf, ok := ret.Get(1).(func(sdk.PageMetadata, string, string) errors.SDKError); ok {
r1 = rf(pm, domainID, token)
} else {
if ret.Get(1) != nil {
r1 = ret.Get(1).(errors.SDKError)
@@ -296,9 +296,9 @@ func (_m *SDK) ChannelPermissions(id string, domainID string, token string) (sdk
return r0, r1
}
// Channels provides a mock function with given fields: pm, token
func (_m *SDK) Channels(pm sdk.PageMetadata, token string) (sdk.ChannelsPage, errors.SDKError) {
ret := _m.Called(pm, token)
// Channels provides a mock function with given fields: pm, domainID, token
func (_m *SDK) Channels(pm sdk.PageMetadata, domainID string, token string) (sdk.ChannelsPage, errors.SDKError) {
ret := _m.Called(pm, domainID, token)
if len(ret) == 0 {
panic("no return value specified for Channels")
@@ -306,17 +306,17 @@ func (_m *SDK) Channels(pm sdk.PageMetadata, token string) (sdk.ChannelsPage, er
var r0 sdk.ChannelsPage
var r1 errors.SDKError
if rf, ok := ret.Get(0).(func(sdk.PageMetadata, string) (sdk.ChannelsPage, errors.SDKError)); ok {
return rf(pm, token)
if rf, ok := ret.Get(0).(func(sdk.PageMetadata, string, string) (sdk.ChannelsPage, errors.SDKError)); ok {
return rf(pm, domainID, token)
}
if rf, ok := ret.Get(0).(func(sdk.PageMetadata, string) sdk.ChannelsPage); ok {
r0 = rf(pm, token)
if rf, ok := ret.Get(0).(func(sdk.PageMetadata, string, string) sdk.ChannelsPage); ok {
r0 = rf(pm, domainID, token)
} else {
r0 = ret.Get(0).(sdk.ChannelsPage)
}
if rf, ok := ret.Get(1).(func(sdk.PageMetadata, string) errors.SDKError); ok {
r1 = rf(pm, token)
if rf, ok := ret.Get(1).(func(sdk.PageMetadata, string, string) errors.SDKError); ok {
r1 = rf(pm, domainID, token)
} else {
if ret.Get(1) != nil {
r1 = ret.Get(1).(errors.SDKError)
@@ -356,9 +356,9 @@ func (_m *SDK) ChannelsByThing(thingID string, pm sdk.PageMetadata, domainID str
return r0, r1
}
// Children provides a mock function with given fields: id, pm, token
func (_m *SDK) Children(id string, pm sdk.PageMetadata, token string) (sdk.GroupsPage, errors.SDKError) {
ret := _m.Called(id, pm, token)
// Children provides a mock function with given fields: id, pm, domainID, token
func (_m *SDK) Children(id string, pm sdk.PageMetadata, domainID string, token string) (sdk.GroupsPage, errors.SDKError) {
ret := _m.Called(id, pm, domainID, token)
if len(ret) == 0 {
panic("no return value specified for Children")
@@ -366,17 +366,17 @@ func (_m *SDK) Children(id string, pm sdk.PageMetadata, token string) (sdk.Group
var r0 sdk.GroupsPage
var r1 errors.SDKError
if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string) (sdk.GroupsPage, errors.SDKError)); ok {
return rf(id, pm, token)
if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string, string) (sdk.GroupsPage, errors.SDKError)); ok {
return rf(id, pm, domainID, token)
}
if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string) sdk.GroupsPage); ok {
r0 = rf(id, pm, token)
if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string, string) sdk.GroupsPage); ok {
r0 = rf(id, pm, domainID, token)
} else {
r0 = ret.Get(0).(sdk.GroupsPage)
}
if rf, ok := ret.Get(1).(func(string, sdk.PageMetadata, string) errors.SDKError); ok {
r1 = rf(id, pm, token)
if rf, ok := ret.Get(1).(func(string, sdk.PageMetadata, string, string) errors.SDKError); ok {
r1 = rf(id, pm, domainID, token)
} else {
if ret.Get(1) != nil {
r1 = ret.Get(1).(errors.SDKError)
@@ -1256,9 +1256,9 @@ func (_m *SDK) GroupPermissions(id string, domainID string, token string) (sdk.G
return r0, r1
}
// Groups provides a mock function with given fields: pm, token
func (_m *SDK) Groups(pm sdk.PageMetadata, token string) (sdk.GroupsPage, errors.SDKError) {
ret := _m.Called(pm, token)
// Groups provides a mock function with given fields: pm, domainID, token
func (_m *SDK) Groups(pm sdk.PageMetadata, domainID string, token string) (sdk.GroupsPage, errors.SDKError) {
ret := _m.Called(pm, domainID, token)
if len(ret) == 0 {
panic("no return value specified for Groups")
@@ -1266,17 +1266,17 @@ func (_m *SDK) Groups(pm sdk.PageMetadata, token string) (sdk.GroupsPage, errors
var r0 sdk.GroupsPage
var r1 errors.SDKError
if rf, ok := ret.Get(0).(func(sdk.PageMetadata, string) (sdk.GroupsPage, errors.SDKError)); ok {
return rf(pm, token)
if rf, ok := ret.Get(0).(func(sdk.PageMetadata, string, string) (sdk.GroupsPage, errors.SDKError)); ok {
return rf(pm, domainID, token)
}
if rf, ok := ret.Get(0).(func(sdk.PageMetadata, string) sdk.GroupsPage); ok {
r0 = rf(pm, token)
if rf, ok := ret.Get(0).(func(sdk.PageMetadata, string, string) sdk.GroupsPage); ok {
r0 = rf(pm, domainID, token)
} else {
r0 = ret.Get(0).(sdk.GroupsPage)
}
if rf, ok := ret.Get(1).(func(sdk.PageMetadata, string) errors.SDKError); ok {
r1 = rf(pm, token)
if rf, ok := ret.Get(1).(func(sdk.PageMetadata, string, string) errors.SDKError); ok {
r1 = rf(pm, domainID, token)
} else {
if ret.Get(1) != nil {
r1 = ret.Get(1).(errors.SDKError)
@@ -1344,9 +1344,9 @@ func (_m *SDK) Invitation(userID string, domainID string, token string) (sdk.Inv
return r0, r1
}
// Invitations provides a mock function with given fields: pm, token
func (_m *SDK) Invitations(pm sdk.PageMetadata, token string) (sdk.InvitationPage, error) {
ret := _m.Called(pm, token)
// Invitations provides a mock function with given fields: pm, domainID, token
func (_m *SDK) Invitations(pm sdk.PageMetadata, domainID string, token string) (sdk.InvitationPage, error) {
ret := _m.Called(pm, domainID, token)
if len(ret) == 0 {
panic("no return value specified for Invitations")
@@ -1354,17 +1354,17 @@ func (_m *SDK) Invitations(pm sdk.PageMetadata, token string) (sdk.InvitationPag
var r0 sdk.InvitationPage
var r1 error
if rf, ok := ret.Get(0).(func(sdk.PageMetadata, string) (sdk.InvitationPage, error)); ok {
return rf(pm, token)
if rf, ok := ret.Get(0).(func(sdk.PageMetadata, string, string) (sdk.InvitationPage, error)); ok {
return rf(pm, domainID, token)
}
if rf, ok := ret.Get(0).(func(sdk.PageMetadata, string) sdk.InvitationPage); ok {
r0 = rf(pm, token)
if rf, ok := ret.Get(0).(func(sdk.PageMetadata, string, string) sdk.InvitationPage); ok {
r0 = rf(pm, domainID, token)
} else {
r0 = ret.Get(0).(sdk.InvitationPage)
}
if rf, ok := ret.Get(1).(func(sdk.PageMetadata, string) error); ok {
r1 = rf(pm, token)
if rf, ok := ret.Get(1).(func(sdk.PageMetadata, string, string) error); ok {
r1 = rf(pm, domainID, token)
} else {
r1 = ret.Error(1)
}
@@ -1430,9 +1430,9 @@ func (_m *SDK) Journal(entityType string, entityID string, pm sdk.PageMetadata,
return r0, r1
}
// ListChannelUserGroups provides a mock function with given fields: channelID, pm, token
func (_m *SDK) ListChannelUserGroups(channelID string, pm sdk.PageMetadata, token string) (sdk.GroupsPage, errors.SDKError) {
ret := _m.Called(channelID, pm, token)
// ListChannelUserGroups provides a mock function with given fields: channelID, pm, domainID, token
func (_m *SDK) ListChannelUserGroups(channelID string, pm sdk.PageMetadata, domainID string, token string) (sdk.GroupsPage, errors.SDKError) {
ret := _m.Called(channelID, pm, domainID, token)
if len(ret) == 0 {
panic("no return value specified for ListChannelUserGroups")
@@ -1440,17 +1440,17 @@ func (_m *SDK) ListChannelUserGroups(channelID string, pm sdk.PageMetadata, toke
var r0 sdk.GroupsPage
var r1 errors.SDKError
if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string) (sdk.GroupsPage, errors.SDKError)); ok {
return rf(channelID, pm, token)
if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string, string) (sdk.GroupsPage, errors.SDKError)); ok {
return rf(channelID, pm, domainID, token)
}
if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string) sdk.GroupsPage); ok {
r0 = rf(channelID, pm, token)
if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string, string) sdk.GroupsPage); ok {
r0 = rf(channelID, pm, domainID, token)
} else {
r0 = ret.Get(0).(sdk.GroupsPage)
}
if rf, ok := ret.Get(1).(func(string, sdk.PageMetadata, string) errors.SDKError); ok {
r1 = rf(channelID, pm, token)
if rf, ok := ret.Get(1).(func(string, sdk.PageMetadata, string, string) errors.SDKError); ok {
r1 = rf(channelID, pm, domainID, token)
} else {
if ret.Get(1) != nil {
r1 = ret.Get(1).(errors.SDKError)
@@ -1460,9 +1460,9 @@ func (_m *SDK) ListChannelUserGroups(channelID string, pm sdk.PageMetadata, toke
return r0, r1
}
// ListChannelUsers provides a mock function with given fields: channelID, pm, token
func (_m *SDK) ListChannelUsers(channelID string, pm sdk.PageMetadata, token string) (sdk.UsersPage, errors.SDKError) {
ret := _m.Called(channelID, pm, token)
// ListChannelUsers provides a mock function with given fields: channelID, pm, domainID, token
func (_m *SDK) ListChannelUsers(channelID string, pm sdk.PageMetadata, domainID string, token string) (sdk.UsersPage, errors.SDKError) {
ret := _m.Called(channelID, pm, domainID, token)
if len(ret) == 0 {
panic("no return value specified for ListChannelUsers")
@@ -1470,17 +1470,17 @@ func (_m *SDK) ListChannelUsers(channelID string, pm sdk.PageMetadata, token str
var r0 sdk.UsersPage
var r1 errors.SDKError
if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string) (sdk.UsersPage, errors.SDKError)); ok {
return rf(channelID, pm, token)
if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string, string) (sdk.UsersPage, errors.SDKError)); ok {
return rf(channelID, pm, domainID, token)
}
if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string) sdk.UsersPage); ok {
r0 = rf(channelID, pm, token)
if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string, string) sdk.UsersPage); ok {
r0 = rf(channelID, pm, domainID, token)
} else {
r0 = ret.Get(0).(sdk.UsersPage)
}
if rf, ok := ret.Get(1).(func(string, sdk.PageMetadata, string) errors.SDKError); ok {
r1 = rf(channelID, pm, token)
if rf, ok := ret.Get(1).(func(string, sdk.PageMetadata, string, string) errors.SDKError); ok {
r1 = rf(channelID, pm, domainID, token)
} else {
if ret.Get(1) != nil {
r1 = ret.Get(1).(errors.SDKError)
@@ -1520,9 +1520,9 @@ func (_m *SDK) ListDomainUsers(domainID string, pm sdk.PageMetadata, token strin
return r0, r1
}
// ListGroupChannels provides a mock function with given fields: groupID, pm, token
func (_m *SDK) ListGroupChannels(groupID string, pm sdk.PageMetadata, token string) (sdk.ChannelsPage, errors.SDKError) {
ret := _m.Called(groupID, pm, token)
// ListGroupChannels provides a mock function with given fields: groupID, pm, domainID, token
func (_m *SDK) ListGroupChannels(groupID string, pm sdk.PageMetadata, domainID string, token string) (sdk.ChannelsPage, errors.SDKError) {
ret := _m.Called(groupID, pm, domainID, token)
if len(ret) == 0 {
panic("no return value specified for ListGroupChannels")
@@ -1530,17 +1530,17 @@ func (_m *SDK) ListGroupChannels(groupID string, pm sdk.PageMetadata, token stri
var r0 sdk.ChannelsPage
var r1 errors.SDKError
if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string) (sdk.ChannelsPage, errors.SDKError)); ok {
return rf(groupID, pm, token)
if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string, string) (sdk.ChannelsPage, errors.SDKError)); ok {
return rf(groupID, pm, domainID, token)
}
if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string) sdk.ChannelsPage); ok {
r0 = rf(groupID, pm, token)
if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string, string) sdk.ChannelsPage); ok {
r0 = rf(groupID, pm, domainID, token)
} else {
r0 = ret.Get(0).(sdk.ChannelsPage)
}
if rf, ok := ret.Get(1).(func(string, sdk.PageMetadata, string) errors.SDKError); ok {
r1 = rf(groupID, pm, token)
if rf, ok := ret.Get(1).(func(string, sdk.PageMetadata, string, string) errors.SDKError); ok {
r1 = rf(groupID, pm, domainID, token)
} else {
if ret.Get(1) != nil {
r1 = ret.Get(1).(errors.SDKError)
@@ -1550,9 +1550,9 @@ func (_m *SDK) ListGroupChannels(groupID string, pm sdk.PageMetadata, token stri
return r0, r1
}
// ListGroupUsers provides a mock function with given fields: groupID, pm, token
func (_m *SDK) ListGroupUsers(groupID string, pm sdk.PageMetadata, token string) (sdk.UsersPage, errors.SDKError) {
ret := _m.Called(groupID, pm, token)
// ListGroupUsers provides a mock function with given fields: groupID, pm, domainID, token
func (_m *SDK) ListGroupUsers(groupID string, pm sdk.PageMetadata, domainID string, token string) (sdk.UsersPage, errors.SDKError) {
ret := _m.Called(groupID, pm, domainID, token)
if len(ret) == 0 {
panic("no return value specified for ListGroupUsers")
@@ -1560,17 +1560,17 @@ func (_m *SDK) ListGroupUsers(groupID string, pm sdk.PageMetadata, token string)
var r0 sdk.UsersPage
var r1 errors.SDKError
if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string) (sdk.UsersPage, errors.SDKError)); ok {
return rf(groupID, pm, token)
if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string, string) (sdk.UsersPage, errors.SDKError)); ok {
return rf(groupID, pm, domainID, token)
}
if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string) sdk.UsersPage); ok {
r0 = rf(groupID, pm, token)
if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string, string) sdk.UsersPage); ok {
r0 = rf(groupID, pm, domainID, token)
} else {
r0 = ret.Get(0).(sdk.UsersPage)
}
if rf, ok := ret.Get(1).(func(string, sdk.PageMetadata, string) errors.SDKError); ok {
r1 = rf(groupID, pm, token)
if rf, ok := ret.Get(1).(func(string, sdk.PageMetadata, string, string) errors.SDKError); ok {
r1 = rf(groupID, pm, domainID, token)
} else {
if ret.Get(1) != nil {
r1 = ret.Get(1).(errors.SDKError)
@@ -1610,9 +1610,9 @@ func (_m *SDK) ListSubscriptions(pm sdk.PageMetadata, token string) (sdk.Subscri
return r0, r1
}
// ListThingUsers provides a mock function with given fields: thingID, pm, token
func (_m *SDK) ListThingUsers(thingID string, pm sdk.PageMetadata, token string) (sdk.UsersPage, errors.SDKError) {
ret := _m.Called(thingID, pm, token)
// ListThingUsers provides a mock function with given fields: thingID, pm, domainID, token
func (_m *SDK) ListThingUsers(thingID string, pm sdk.PageMetadata, domainID string, token string) (sdk.UsersPage, errors.SDKError) {
ret := _m.Called(thingID, pm, domainID, token)
if len(ret) == 0 {
panic("no return value specified for ListThingUsers")
@@ -1620,17 +1620,17 @@ func (_m *SDK) ListThingUsers(thingID string, pm sdk.PageMetadata, token string)
var r0 sdk.UsersPage
var r1 errors.SDKError
if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string) (sdk.UsersPage, errors.SDKError)); ok {
return rf(thingID, pm, token)
if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string, string) (sdk.UsersPage, errors.SDKError)); ok {
return rf(thingID, pm, domainID, token)
}
if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string) sdk.UsersPage); ok {
r0 = rf(thingID, pm, token)
if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string, string) sdk.UsersPage); ok {
r0 = rf(thingID, pm, domainID, token)
} else {
r0 = ret.Get(0).(sdk.UsersPage)
}
if rf, ok := ret.Get(1).(func(string, sdk.PageMetadata, string) errors.SDKError); ok {
r1 = rf(thingID, pm, token)
if rf, ok := ret.Get(1).(func(string, sdk.PageMetadata, string, string) errors.SDKError); ok {
r1 = rf(thingID, pm, domainID, token)
} else {
if ret.Get(1) != nil {
r1 = ret.Get(1).(errors.SDKError)
@@ -1790,9 +1790,9 @@ func (_m *SDK) Members(groupID string, meta sdk.PageMetadata, token string) (sdk
return r0, r1
}
// Parents provides a mock function with given fields: id, pm, token
func (_m *SDK) Parents(id string, pm sdk.PageMetadata, token string) (sdk.GroupsPage, errors.SDKError) {
ret := _m.Called(id, pm, token)
// Parents provides a mock function with given fields: id, pm, domainID, token
func (_m *SDK) Parents(id string, pm sdk.PageMetadata, domainID string, token string) (sdk.GroupsPage, errors.SDKError) {
ret := _m.Called(id, pm, domainID, token)
if len(ret) == 0 {
panic("no return value specified for Parents")
@@ -1800,17 +1800,17 @@ func (_m *SDK) Parents(id string, pm sdk.PageMetadata, token string) (sdk.Groups
var r0 sdk.GroupsPage
var r1 errors.SDKError
if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string) (sdk.GroupsPage, errors.SDKError)); ok {
return rf(id, pm, token)
if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string, string) (sdk.GroupsPage, errors.SDKError)); ok {
return rf(id, pm, domainID, token)
}
if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string) sdk.GroupsPage); ok {
r0 = rf(id, pm, token)
if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string, string) sdk.GroupsPage); ok {
r0 = rf(id, pm, domainID, token)
} else {
r0 = ret.Get(0).(sdk.GroupsPage)
}
if rf, ok := ret.Get(1).(func(string, sdk.PageMetadata, string) errors.SDKError); ok {
r1 = rf(id, pm, token)
if rf, ok := ret.Get(1).(func(string, sdk.PageMetadata, string, string) errors.SDKError); ok {
r1 = rf(id, pm, domainID, token)
} else {
if ret.Get(1) != nil {
r1 = ret.Get(1).(errors.SDKError)
@@ -1850,9 +1850,9 @@ func (_m *SDK) ReadMessages(pm sdk.MessagePageMetadata, chanID string, token str
return r0, r1
}
// RefreshToken provides a mock function with given fields: lt, token
func (_m *SDK) RefreshToken(lt sdk.Login, token string) (sdk.Token, errors.SDKError) {
ret := _m.Called(lt, token)
// RefreshToken provides a mock function with given fields: token
func (_m *SDK) RefreshToken(token string) (sdk.Token, errors.SDKError) {
ret := _m.Called(token)
if len(ret) == 0 {
panic("no return value specified for RefreshToken")
@@ -1860,17 +1860,17 @@ func (_m *SDK) RefreshToken(lt sdk.Login, token string) (sdk.Token, errors.SDKEr
var r0 sdk.Token
var r1 errors.SDKError
if rf, ok := ret.Get(0).(func(sdk.Login, string) (sdk.Token, errors.SDKError)); ok {
return rf(lt, token)
if rf, ok := ret.Get(0).(func(string) (sdk.Token, errors.SDKError)); ok {
return rf(token)
}
if rf, ok := ret.Get(0).(func(sdk.Login, string) sdk.Token); ok {
r0 = rf(lt, token)
if rf, ok := ret.Get(0).(func(string) sdk.Token); ok {
r0 = rf(token)
} else {
r0 = ret.Get(0).(sdk.Token)
}
if rf, ok := ret.Get(1).(func(sdk.Login, string) errors.SDKError); ok {
r1 = rf(lt, token)
if rf, ok := ret.Get(1).(func(string) errors.SDKError); ok {
r1 = rf(token)
} else {
if ret.Get(1) != nil {
r1 = ret.Get(1).(errors.SDKError)
@@ -2236,9 +2236,9 @@ func (_m *SDK) ThingPermissions(id string, domainID string, token string) (sdk.T
return r0, r1
}
// Things provides a mock function with given fields: pm, token
func (_m *SDK) Things(pm sdk.PageMetadata, token string) (sdk.ThingsPage, errors.SDKError) {
ret := _m.Called(pm, token)
// Things provides a mock function with given fields: pm, domainID, token
func (_m *SDK) Things(pm sdk.PageMetadata, domainID string, token string) (sdk.ThingsPage, errors.SDKError) {
ret := _m.Called(pm, domainID, token)
if len(ret) == 0 {
panic("no return value specified for Things")
@@ -2246,17 +2246,17 @@ func (_m *SDK) Things(pm sdk.PageMetadata, token string) (sdk.ThingsPage, errors
var r0 sdk.ThingsPage
var r1 errors.SDKError
if rf, ok := ret.Get(0).(func(sdk.PageMetadata, string) (sdk.ThingsPage, errors.SDKError)); ok {
return rf(pm, token)
if rf, ok := ret.Get(0).(func(sdk.PageMetadata, string, string) (sdk.ThingsPage, errors.SDKError)); ok {
return rf(pm, domainID, token)
}
if rf, ok := ret.Get(0).(func(sdk.PageMetadata, string) sdk.ThingsPage); ok {
r0 = rf(pm, token)
if rf, ok := ret.Get(0).(func(sdk.PageMetadata, string, string) sdk.ThingsPage); ok {
r0 = rf(pm, domainID, token)
} else {
r0 = ret.Get(0).(sdk.ThingsPage)
}
if rf, ok := ret.Get(1).(func(sdk.PageMetadata, string) errors.SDKError); ok {
r1 = rf(pm, token)
if rf, ok := ret.Get(1).(func(sdk.PageMetadata, string, string) errors.SDKError); ok {
r1 = rf(pm, domainID, token)
} else {
if ret.Get(1) != nil {
r1 = ret.Get(1).(errors.SDKError)
@@ -2266,9 +2266,9 @@ func (_m *SDK) Things(pm sdk.PageMetadata, token string) (sdk.ThingsPage, errors
return r0, r1
}
// ThingsByChannel provides a mock function with given fields: chanID, pm, token
func (_m *SDK) ThingsByChannel(chanID string, pm sdk.PageMetadata, token string) (sdk.ThingsPage, errors.SDKError) {
ret := _m.Called(chanID, pm, token)
// ThingsByChannel provides a mock function with given fields: chanID, pm, domainID, token
func (_m *SDK) ThingsByChannel(chanID string, pm sdk.PageMetadata, domainID string, token string) (sdk.ThingsPage, errors.SDKError) {
ret := _m.Called(chanID, pm, domainID, token)
if len(ret) == 0 {
panic("no return value specified for ThingsByChannel")
@@ -2276,17 +2276,17 @@ func (_m *SDK) ThingsByChannel(chanID string, pm sdk.PageMetadata, token string)
var r0 sdk.ThingsPage
var r1 errors.SDKError
if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string) (sdk.ThingsPage, errors.SDKError)); ok {
return rf(chanID, pm, token)
if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string, string) (sdk.ThingsPage, errors.SDKError)); ok {
return rf(chanID, pm, domainID, token)
}
if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string) sdk.ThingsPage); ok {
r0 = rf(chanID, pm, token)
if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string, string) sdk.ThingsPage); ok {
r0 = rf(chanID, pm, domainID, token)
} else {
r0 = ret.Get(0).(sdk.ThingsPage)
}
if rf, ok := ret.Get(1).(func(string, sdk.PageMetadata, string) errors.SDKError); ok {
r1 = rf(chanID, pm, token)
if rf, ok := ret.Get(1).(func(string, sdk.PageMetadata, string, string) errors.SDKError); ok {
r1 = rf(chanID, pm, domainID, token)
} else {
if ret.Get(1) != nil {
r1 = ret.Get(1).(errors.SDKError)