mirror of
https://github.com/absmach/magistrala.git
synced 2026-08-07 07:14:46 +00:00
SMQ-2570 - Update SDK to align with new architecture (#2585)
Signed-off-by: Felix Gateru <felix.gateru@gmail.com>
This commit is contained in:
Felix Gateru
GitHub
+1
-173
@@ -124,28 +124,6 @@ var cmdChannels = []cobra.Command{
|
||||
logJSONCmd(*cmd, channel)
|
||||
},
|
||||
},
|
||||
{
|
||||
Use: "connections <channel_id> <domain_id> <user_auth_token>",
|
||||
Short: "Connections list",
|
||||
Long: `List of Clients connected to a Channel`,
|
||||
Run: func(cmd *cobra.Command, args []string) {
|
||||
if len(args) != 3 {
|
||||
logUsageCmd(*cmd, cmd.Use)
|
||||
return
|
||||
}
|
||||
pm := smqsdk.PageMetadata{
|
||||
Offset: Offset,
|
||||
Limit: Limit,
|
||||
}
|
||||
cl, err := sdk.ClientsByChannel(args[0], pm, args[1], args[2])
|
||||
if err != nil {
|
||||
logErrorCmd(*cmd, err)
|
||||
return
|
||||
}
|
||||
|
||||
logJSONCmd(*cmd, cl)
|
||||
},
|
||||
},
|
||||
{
|
||||
Use: "enable <channel_id> <domain_id> <user_auth_token>",
|
||||
Short: "Change channel status to enabled",
|
||||
@@ -199,7 +177,7 @@ var cmdChannels = []cobra.Command{
|
||||
Offset: Offset,
|
||||
Limit: Limit,
|
||||
}
|
||||
ul, err := sdk.ListChannelUsers(args[0], pm, args[1], args[2])
|
||||
ul, err := sdk.ListChannelUsers(args[0], args[1], pm, args[2])
|
||||
if err != nil {
|
||||
logErrorCmd(*cmd, err)
|
||||
return
|
||||
@@ -208,154 +186,6 @@ var cmdChannels = []cobra.Command{
|
||||
logJSONCmd(*cmd, ul)
|
||||
},
|
||||
},
|
||||
{
|
||||
Use: "groups <channel_id> <domain_id> <user_auth_token>",
|
||||
Short: "List groups",
|
||||
Long: "List groups of a channel\n" +
|
||||
"Usage:\n" +
|
||||
"\tsupermq-cli channels groups <channel_id> $DOMAINID $USERTOKEN\n",
|
||||
Run: func(cmd *cobra.Command, args []string) {
|
||||
if len(args) != 3 {
|
||||
logUsageCmd(*cmd, cmd.Use)
|
||||
return
|
||||
}
|
||||
pm := smqsdk.PageMetadata{
|
||||
Offset: Offset,
|
||||
Limit: Limit,
|
||||
}
|
||||
ul, err := sdk.ListChannelUserGroups(args[0], pm, args[1], args[2])
|
||||
if err != nil {
|
||||
logErrorCmd(*cmd, err)
|
||||
return
|
||||
}
|
||||
|
||||
logJSONCmd(*cmd, ul)
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
var channelAssignCmds = []cobra.Command{
|
||||
{
|
||||
Use: "users <relation> <user_ids> <channel_id> <domain_id> <user_auth_token>",
|
||||
Short: "Assign users",
|
||||
Long: "Assign users to a channel\n" +
|
||||
"Usage:\n" +
|
||||
"\tsupermq-cli channels assign users <relation> '[\"<user_id_1>\", \"<user_id_2>\"]' <channel_id> $DOMAINID $USERTOKEN\n",
|
||||
Run: func(cmd *cobra.Command, args []string) {
|
||||
if len(args) != 5 {
|
||||
logUsageCmd(*cmd, cmd.Use)
|
||||
return
|
||||
}
|
||||
var userIDs []string
|
||||
if err := json.Unmarshal([]byte(args[1]), &userIDs); err != nil {
|
||||
logErrorCmd(*cmd, err)
|
||||
return
|
||||
}
|
||||
if err := sdk.AddUserToChannel(args[2], smqsdk.UsersRelationRequest{Relation: args[0], UserIDs: userIDs}, args[3], args[4]); err != nil {
|
||||
logErrorCmd(*cmd, err)
|
||||
return
|
||||
}
|
||||
logOKCmd(*cmd)
|
||||
},
|
||||
},
|
||||
{
|
||||
Use: "groups <group_ids> <channel_id> <domain_id> <user_auth_token>",
|
||||
Short: "Assign groups",
|
||||
Long: "Assign groups to a channel\n" +
|
||||
"Usage:\n" +
|
||||
"\tsupermq-cli channels assign groups '[\"<group_id_1>\", \"<group_id_2>\"]' <channel_id> $DOMAINID $USERTOKEN\n",
|
||||
|
||||
Run: func(cmd *cobra.Command, args []string) {
|
||||
if len(args) != 4 {
|
||||
logUsageCmd(*cmd, cmd.Use)
|
||||
return
|
||||
}
|
||||
var groupIDs []string
|
||||
if err := json.Unmarshal([]byte(args[0]), &groupIDs); err != nil {
|
||||
logErrorCmd(*cmd, err)
|
||||
return
|
||||
}
|
||||
if err := sdk.AddUserGroupToChannel(args[1], smqsdk.UserGroupsRequest{UserGroupIDs: groupIDs}, args[2], args[3]); err != nil {
|
||||
logErrorCmd(*cmd, err)
|
||||
return
|
||||
}
|
||||
logOKCmd(*cmd)
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
var channelUnassignCmds = []cobra.Command{
|
||||
{
|
||||
Use: "groups <group_ids> <channel_id> <domain_id> <user_auth_token>",
|
||||
Short: "Unassign groups",
|
||||
Long: "Unassign groups from a channel\n" +
|
||||
"Usage:\n" +
|
||||
"\tsupermq-cli channels unassign groups '[\"<group_id_1>\", \"<group_id_2>\"]' <channel_id> $DOMAINID $USERTOKEN\n",
|
||||
Run: func(cmd *cobra.Command, args []string) {
|
||||
if len(args) != 4 {
|
||||
logUsageCmd(*cmd, cmd.Use)
|
||||
return
|
||||
}
|
||||
var groupIDs []string
|
||||
if err := json.Unmarshal([]byte(args[0]), &groupIDs); err != nil {
|
||||
logErrorCmd(*cmd, err)
|
||||
return
|
||||
}
|
||||
if err := sdk.RemoveUserGroupFromChannel(args[1], smqsdk.UserGroupsRequest{UserGroupIDs: groupIDs}, args[2], args[3]); err != nil {
|
||||
logErrorCmd(*cmd, err)
|
||||
return
|
||||
}
|
||||
logOKCmd(*cmd)
|
||||
},
|
||||
},
|
||||
|
||||
{
|
||||
Use: "users <relation> <user_ids> <channel_id> <domain_id> <user_auth_token>",
|
||||
Short: "Unassign users",
|
||||
Long: "Unassign users from a channel\n" +
|
||||
"Usage:\n" +
|
||||
"\tsupermq-cli channels unassign users <relation> '[\"<user_id_1>\", \"<user_id_2>\"]' <channel_id> $DOMAINID $USERTOKEN\n",
|
||||
Run: func(cmd *cobra.Command, args []string) {
|
||||
if len(args) != 5 {
|
||||
logUsageCmd(*cmd, cmd.Use)
|
||||
return
|
||||
}
|
||||
var userIDs []string
|
||||
if err := json.Unmarshal([]byte(args[1]), &userIDs); err != nil {
|
||||
logErrorCmd(*cmd, err)
|
||||
return
|
||||
}
|
||||
if err := sdk.RemoveUserFromChannel(args[2], smqsdk.UsersRelationRequest{Relation: args[0], UserIDs: userIDs}, args[3], args[4]); err != nil {
|
||||
logErrorCmd(*cmd, err)
|
||||
return
|
||||
}
|
||||
logOKCmd(*cmd)
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
func NewChannelAssignCmds() *cobra.Command {
|
||||
cmd := cobra.Command{
|
||||
Use: "assign [users | groups]",
|
||||
Short: "Assign users or groups to a channel",
|
||||
Long: "Assign users or groups to a channel",
|
||||
}
|
||||
for i := range channelAssignCmds {
|
||||
cmd.AddCommand(&channelAssignCmds[i])
|
||||
}
|
||||
return &cmd
|
||||
}
|
||||
|
||||
func NewChannelUnassignCmds() *cobra.Command {
|
||||
cmd := cobra.Command{
|
||||
Use: "unassign [users | groups]",
|
||||
Short: "Unassign users or groups from a channel",
|
||||
Long: "Unassign users or groups from a channel",
|
||||
}
|
||||
for i := range channelUnassignCmds {
|
||||
cmd.AddCommand(&channelUnassignCmds[i])
|
||||
}
|
||||
return &cmd
|
||||
}
|
||||
|
||||
// NewChannelsCmd returns channels command.
|
||||
@@ -370,7 +200,5 @@ func NewChannelsCmd() *cobra.Command {
|
||||
cmd.AddCommand(&cmdChannels[i])
|
||||
}
|
||||
|
||||
cmd.AddCommand(NewChannelAssignCmds())
|
||||
cmd.AddCommand(NewChannelUnassignCmds())
|
||||
return &cmd
|
||||
}
|
||||
|
||||
@@ -368,82 +368,6 @@ func TestUpdateChannelCmd(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func TestListConnectionsCmd(t *testing.T) {
|
||||
sdkMock := new(sdkmocks.SDK)
|
||||
cli.SetSDK(sdkMock)
|
||||
channelCmd := cli.NewChannelsCmd()
|
||||
rootCmd := setFlags(channelCmd)
|
||||
|
||||
var tp mgsdk.ClientsPage
|
||||
cases := []struct {
|
||||
desc string
|
||||
args []string
|
||||
sdkErr errors.SDKError
|
||||
errLogMessage string
|
||||
logType outputLog
|
||||
page mgsdk.ClientsPage
|
||||
}{
|
||||
{
|
||||
desc: "list connections successfully",
|
||||
args: []string{
|
||||
channel.ID,
|
||||
domainID,
|
||||
token,
|
||||
},
|
||||
page: mgsdk.ClientsPage{
|
||||
PageRes: mgsdk.PageRes{
|
||||
Total: 1,
|
||||
Offset: 0,
|
||||
Limit: 10,
|
||||
},
|
||||
Clients: []mgsdk.Client{client},
|
||||
},
|
||||
logType: entityLog,
|
||||
},
|
||||
{
|
||||
desc: "list connections with invalid args",
|
||||
args: []string{
|
||||
channel.ID,
|
||||
domainID,
|
||||
token,
|
||||
extraArg,
|
||||
},
|
||||
logType: usageLog,
|
||||
},
|
||||
{
|
||||
desc: "list connections with invalid channel id",
|
||||
args: []string{
|
||||
invalidID,
|
||||
domainID,
|
||||
token,
|
||||
},
|
||||
sdkErr: errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
|
||||
errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden)),
|
||||
logType: errLog,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.desc, func(t *testing.T) {
|
||||
sdkCall := sdkMock.On("ClientsByChannel", tc.args[0], mock.Anything, tc.args[1], tc.args[2]).Return(tc.page, tc.sdkErr)
|
||||
out := executeCommand(t, rootCmd, append([]string{connsCmd}, tc.args...)...)
|
||||
switch tc.logType {
|
||||
case entityLog:
|
||||
err := json.Unmarshal([]byte(out), &tp)
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to unmarshal JSON: %v", err)
|
||||
}
|
||||
assert.Equal(t, tc.page, tp, fmt.Sprintf("%v unexpected response, expected: %v, got: %v", tc.desc, tc.page, tp))
|
||||
case usageLog:
|
||||
assert.False(t, strings.Contains(out, rootCmd.Use), fmt.Sprintf("%s invalid usage: %s", tc.desc, out))
|
||||
case errLog:
|
||||
assert.Equal(t, tc.errLogMessage, out, fmt.Sprintf("%s unexpected error response: expected %s got errLogMessage:%s", tc.desc, tc.errLogMessage, out))
|
||||
}
|
||||
sdkCall.Unset()
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestEnableChannelCmd(t *testing.T) {
|
||||
sdkMock := new(sdkmocks.SDK)
|
||||
cli.SetSDK(sdkMock)
|
||||
@@ -606,532 +530,3 @@ func TestDisableChannelCmd(t *testing.T) {
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestUsersChannelCmd(t *testing.T) {
|
||||
sdkMock := new(sdkmocks.SDK)
|
||||
cli.SetSDK(sdkMock)
|
||||
channelsCmd := cli.NewChannelsCmd()
|
||||
rootCmd := setFlags(channelsCmd)
|
||||
|
||||
page := mgsdk.UsersPage{}
|
||||
|
||||
cases := []struct {
|
||||
desc string
|
||||
args []string
|
||||
logType outputLog
|
||||
errLogMessage string
|
||||
page mgsdk.UsersPage
|
||||
sdkErr errors.SDKError
|
||||
}{
|
||||
{
|
||||
desc: "get channel's users successfully",
|
||||
args: []string{
|
||||
channel.ID,
|
||||
domainID,
|
||||
token,
|
||||
},
|
||||
page: mgsdk.UsersPage{
|
||||
PageRes: mgsdk.PageRes{
|
||||
Total: 1,
|
||||
Offset: 0,
|
||||
Limit: 10,
|
||||
},
|
||||
Users: []mgsdk.User{user},
|
||||
},
|
||||
logType: entityLog,
|
||||
},
|
||||
{
|
||||
desc: "list channel users with invalid args",
|
||||
args: []string{
|
||||
channel.ID,
|
||||
domainID,
|
||||
token,
|
||||
extraArg,
|
||||
},
|
||||
logType: usageLog,
|
||||
},
|
||||
{
|
||||
desc: "list channel users with invalid id",
|
||||
args: []string{
|
||||
invalidID,
|
||||
domainID,
|
||||
token,
|
||||
},
|
||||
sdkErr: errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
|
||||
errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden)),
|
||||
logType: errLog,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.desc, func(t *testing.T) {
|
||||
sdkCall := sdkMock.On("ListChannelUsers", tc.args[0], mock.Anything, tc.args[1], tc.args[2]).Return(tc.page, tc.sdkErr)
|
||||
out := executeCommand(t, rootCmd, append([]string{usrCmd}, tc.args...)...)
|
||||
|
||||
switch tc.logType {
|
||||
case entityLog:
|
||||
err := json.Unmarshal([]byte(out), &page)
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to unmarshal JSON: %v", err)
|
||||
}
|
||||
assert.Equal(t, tc.page, page, fmt.Sprintf("%v unexpected response, expected: %v, got: %v", tc.desc, tc.page, page))
|
||||
case usageLog:
|
||||
assert.False(t, strings.Contains(out, rootCmd.Use), fmt.Sprintf("%s invalid usage: %s", tc.desc, out))
|
||||
case errLog:
|
||||
assert.Equal(t, tc.errLogMessage, out, fmt.Sprintf("%s unexpected error response: expected %s got errLogMessage:%s", tc.desc, tc.errLogMessage, out))
|
||||
}
|
||||
sdkCall.Unset()
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestListGroupCmd(t *testing.T) {
|
||||
sdkMock := new(sdkmocks.SDK)
|
||||
cli.SetSDK(sdkMock)
|
||||
channelsCmd := cli.NewChannelsCmd()
|
||||
rootCmd := setFlags(channelsCmd)
|
||||
|
||||
var gp mgsdk.GroupsPage
|
||||
cases := []struct {
|
||||
desc string
|
||||
args []string
|
||||
sdkErr errors.SDKError
|
||||
errLogMessage string
|
||||
logType outputLog
|
||||
page mgsdk.GroupsPage
|
||||
}{
|
||||
{
|
||||
desc: "list groups successfully",
|
||||
args: []string{
|
||||
channel.ID,
|
||||
domainID,
|
||||
token,
|
||||
},
|
||||
page: mgsdk.GroupsPage{
|
||||
PageRes: mgsdk.PageRes{
|
||||
Total: 1,
|
||||
Offset: 0,
|
||||
Limit: 10,
|
||||
},
|
||||
Groups: []mgsdk.Group{group},
|
||||
},
|
||||
logType: entityLog,
|
||||
},
|
||||
{
|
||||
desc: "list groups with invalid args",
|
||||
args: []string{
|
||||
channel.ID,
|
||||
domainID,
|
||||
token,
|
||||
extraArg,
|
||||
},
|
||||
logType: usageLog,
|
||||
},
|
||||
{
|
||||
desc: "list groups with invalid channel id",
|
||||
args: []string{
|
||||
invalidID,
|
||||
domainID,
|
||||
token,
|
||||
},
|
||||
sdkErr: errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
|
||||
errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden)),
|
||||
logType: errLog,
|
||||
},
|
||||
}
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.desc, func(t *testing.T) {
|
||||
sdkCall := sdkMock.On("ListChannelUserGroups", tc.args[0], mock.Anything, tc.args[1], tc.args[2]).Return(tc.page, tc.sdkErr)
|
||||
out := executeCommand(t, rootCmd, append([]string{grpCmd}, tc.args...)...)
|
||||
switch tc.logType {
|
||||
case entityLog:
|
||||
err := json.Unmarshal([]byte(out), &gp)
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to unmarshal JSON: %v", err)
|
||||
}
|
||||
assert.Equal(t, tc.page, gp, fmt.Sprintf("%v unexpected response, expected: %v, got: %v", tc.desc, tc.page, gp))
|
||||
case usageLog:
|
||||
assert.False(t, strings.Contains(out, rootCmd.Use), fmt.Sprintf("%s invalid usage: %s", tc.desc, out))
|
||||
case errLog:
|
||||
assert.Equal(t, tc.errLogMessage, out, fmt.Sprintf("%s unexpected error response: expected %s got errLogMessage:%s", tc.desc, tc.errLogMessage, out))
|
||||
}
|
||||
sdkCall.Unset()
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestAssignUserCmd(t *testing.T) {
|
||||
sdkMock := new(sdkmocks.SDK)
|
||||
cli.SetSDK(sdkMock)
|
||||
channelsCmd := cli.NewChannelsCmd()
|
||||
rootCmd := setFlags(channelsCmd)
|
||||
|
||||
userIds := fmt.Sprintf("[\"%s\"]", user.ID)
|
||||
|
||||
cases := []struct {
|
||||
desc string
|
||||
args []string
|
||||
logType outputLog
|
||||
errLogMessage string
|
||||
sdkErr errors.SDKError
|
||||
}{
|
||||
{
|
||||
desc: "assign user successfully",
|
||||
args: []string{
|
||||
relation,
|
||||
userIds,
|
||||
channel.ID,
|
||||
domainID,
|
||||
token,
|
||||
},
|
||||
logType: okLog,
|
||||
},
|
||||
{
|
||||
desc: "assign user with invalid args",
|
||||
args: []string{
|
||||
relation,
|
||||
userIds,
|
||||
channel.ID,
|
||||
domainID,
|
||||
token,
|
||||
extraArg,
|
||||
},
|
||||
logType: usageLog,
|
||||
},
|
||||
{
|
||||
desc: "assign user with invalid json",
|
||||
args: []string{
|
||||
relation,
|
||||
fmt.Sprintf("[\"%s\"", user.ID),
|
||||
channel.ID,
|
||||
domainID,
|
||||
token,
|
||||
},
|
||||
sdkErr: errors.NewSDKError(errors.New("unexpected end of JSON input")),
|
||||
errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.New("unexpected end of JSON input")),
|
||||
logType: errLog,
|
||||
},
|
||||
{
|
||||
desc: "assign user with invalid channel id",
|
||||
args: []string{
|
||||
relation,
|
||||
userIds,
|
||||
invalidID,
|
||||
domainID,
|
||||
token,
|
||||
},
|
||||
sdkErr: errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
|
||||
errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden)),
|
||||
logType: errLog,
|
||||
},
|
||||
{
|
||||
desc: "assign user with invalid user id",
|
||||
args: []string{
|
||||
relation,
|
||||
fmt.Sprintf("[\"%s\"]", invalidID),
|
||||
channel.ID,
|
||||
domainID,
|
||||
token,
|
||||
},
|
||||
sdkErr: errors.NewSDKErrorWithStatus(svcerr.ErrAddPolicies, http.StatusBadRequest),
|
||||
errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAddPolicies, http.StatusBadRequest)),
|
||||
logType: errLog,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.desc, func(t *testing.T) {
|
||||
sdkCall := sdkMock.On("AddUserToChannel", tc.args[2], mock.Anything, tc.args[3], tc.args[4]).Return(tc.sdkErr)
|
||||
out := executeCommand(t, rootCmd, append([]string{assignCmd, usrCmd}, tc.args...)...)
|
||||
switch tc.logType {
|
||||
case okLog:
|
||||
assert.True(t, strings.Contains(out, "ok"), fmt.Sprintf("%s unexpected response: expected success message, got: %v", tc.desc, out))
|
||||
case usageLog:
|
||||
assert.False(t, strings.Contains(out, rootCmd.Use), fmt.Sprintf("%s invalid usage: %s", tc.desc, out))
|
||||
case errLog:
|
||||
assert.Equal(t, tc.errLogMessage, out, fmt.Sprintf("%s unexpected error response: expected %s got errLogMessage:%s", tc.desc, tc.errLogMessage, out))
|
||||
}
|
||||
sdkCall.Unset()
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestAssignGroupCmd(t *testing.T) {
|
||||
sdkMock := new(sdkmocks.SDK)
|
||||
cli.SetSDK(sdkMock)
|
||||
channelsCmd := cli.NewChannelsCmd()
|
||||
rootCmd := setFlags(channelsCmd)
|
||||
|
||||
grpIds := fmt.Sprintf("[\"%s\"]", group.ID)
|
||||
|
||||
cases := []struct {
|
||||
desc string
|
||||
args []string
|
||||
logType outputLog
|
||||
errLogMessage string
|
||||
sdkErr errors.SDKError
|
||||
}{
|
||||
{
|
||||
desc: "assign group successfully",
|
||||
args: []string{
|
||||
grpIds,
|
||||
channel.ID,
|
||||
domainID,
|
||||
token,
|
||||
},
|
||||
logType: okLog,
|
||||
},
|
||||
{
|
||||
desc: "assign group with invalid args",
|
||||
args: []string{
|
||||
grpIds,
|
||||
channel.ID,
|
||||
domainID,
|
||||
token,
|
||||
extraArg,
|
||||
},
|
||||
logType: usageLog,
|
||||
},
|
||||
{
|
||||
desc: "assign group with invalid json",
|
||||
args: []string{
|
||||
fmt.Sprintf("[\"%s\"", group.ID),
|
||||
channel.ID,
|
||||
domainID,
|
||||
token,
|
||||
},
|
||||
sdkErr: errors.NewSDKError(errors.New("unexpected end of JSON input")),
|
||||
errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.New("unexpected end of JSON input")),
|
||||
logType: errLog,
|
||||
},
|
||||
{
|
||||
desc: "assign group with invalid channel id",
|
||||
args: []string{
|
||||
grpIds,
|
||||
invalidID,
|
||||
domainID,
|
||||
token,
|
||||
},
|
||||
sdkErr: errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
|
||||
errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden)),
|
||||
logType: errLog,
|
||||
},
|
||||
{
|
||||
desc: "assign group with invalid user id",
|
||||
args: []string{
|
||||
fmt.Sprintf("[\"%s\"]", invalidID),
|
||||
channel.ID,
|
||||
domainID,
|
||||
token,
|
||||
},
|
||||
sdkErr: errors.NewSDKErrorWithStatus(svcerr.ErrAddPolicies, http.StatusBadRequest),
|
||||
errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAddPolicies, http.StatusBadRequest)),
|
||||
logType: errLog,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.desc, func(t *testing.T) {
|
||||
sdkCall := sdkMock.On("AddUserGroupToChannel", tc.args[1], mock.Anything, tc.args[2], tc.args[3]).Return(tc.sdkErr)
|
||||
out := executeCommand(t, rootCmd, append([]string{assignCmd, grpCmd}, tc.args...)...)
|
||||
switch tc.logType {
|
||||
case okLog:
|
||||
assert.True(t, strings.Contains(out, "ok"), fmt.Sprintf("%s unexpected response: expected success message, got: %v", tc.desc, out))
|
||||
case usageLog:
|
||||
assert.False(t, strings.Contains(out, rootCmd.Use), fmt.Sprintf("%s invalid usage: %s", tc.desc, out))
|
||||
case errLog:
|
||||
assert.Equal(t, tc.errLogMessage, out, fmt.Sprintf("%s unexpected error response: expected %s got errLogMessage:%s", tc.desc, tc.errLogMessage, out))
|
||||
}
|
||||
sdkCall.Unset()
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestUnassignUserCmd(t *testing.T) {
|
||||
sdkMock := new(sdkmocks.SDK)
|
||||
cli.SetSDK(sdkMock)
|
||||
channelsCmd := cli.NewChannelsCmd()
|
||||
rootCmd := setFlags(channelsCmd)
|
||||
|
||||
userIds := fmt.Sprintf("[\"%s\"]", user.ID)
|
||||
|
||||
cases := []struct {
|
||||
desc string
|
||||
args []string
|
||||
logType outputLog
|
||||
errLogMessage string
|
||||
sdkErr errors.SDKError
|
||||
}{
|
||||
{
|
||||
desc: "unassign user successfully",
|
||||
args: []string{
|
||||
relation,
|
||||
userIds,
|
||||
channel.ID,
|
||||
domainID,
|
||||
token,
|
||||
},
|
||||
logType: okLog,
|
||||
},
|
||||
{
|
||||
desc: "unassign user with invalid args",
|
||||
args: []string{
|
||||
relation,
|
||||
userIds,
|
||||
channel.ID,
|
||||
domainID,
|
||||
token,
|
||||
extraArg,
|
||||
},
|
||||
logType: usageLog,
|
||||
},
|
||||
{
|
||||
desc: "unassign user with invalid json",
|
||||
args: []string{
|
||||
relation,
|
||||
fmt.Sprintf("[\"%s\"", user.ID),
|
||||
channel.ID,
|
||||
domainID,
|
||||
token,
|
||||
},
|
||||
sdkErr: errors.NewSDKError(errors.New("unexpected end of JSON input")),
|
||||
errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.New("unexpected end of JSON input")),
|
||||
logType: errLog,
|
||||
},
|
||||
{
|
||||
desc: "unassign user with invalid channel id",
|
||||
args: []string{
|
||||
relation,
|
||||
userIds,
|
||||
invalidID,
|
||||
domainID,
|
||||
token,
|
||||
},
|
||||
sdkErr: errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
|
||||
errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden)),
|
||||
logType: errLog,
|
||||
},
|
||||
{
|
||||
desc: "unassign user with invalid user id",
|
||||
args: []string{
|
||||
relation,
|
||||
fmt.Sprintf("[\"%s\"]", invalidID),
|
||||
channel.ID,
|
||||
domainID,
|
||||
token,
|
||||
},
|
||||
sdkErr: errors.NewSDKErrorWithStatus(svcerr.ErrAddPolicies, http.StatusBadRequest),
|
||||
errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAddPolicies, http.StatusBadRequest)),
|
||||
logType: errLog,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.desc, func(t *testing.T) {
|
||||
sdkCall := sdkMock.On("RemoveUserFromChannel", tc.args[2], mock.Anything, tc.args[3], tc.args[4]).Return(tc.sdkErr)
|
||||
out := executeCommand(t, rootCmd, append([]string{unassignCmd, usrCmd}, tc.args...)...)
|
||||
switch tc.logType {
|
||||
case okLog:
|
||||
assert.True(t, strings.Contains(out, "ok"), fmt.Sprintf("%s unexpected response: expected success message, got: %v", tc.desc, out))
|
||||
case usageLog:
|
||||
assert.False(t, strings.Contains(out, rootCmd.Use), fmt.Sprintf("%s invalid usage: %s", tc.desc, out))
|
||||
case errLog:
|
||||
assert.Equal(t, tc.errLogMessage, out, fmt.Sprintf("%s unexpected error response: expected %s got errLogMessage:%s", tc.desc, tc.errLogMessage, out))
|
||||
}
|
||||
sdkCall.Unset()
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestUnassignGroupCmd(t *testing.T) {
|
||||
sdkMock := new(sdkmocks.SDK)
|
||||
cli.SetSDK(sdkMock)
|
||||
channelsCmd := cli.NewChannelsCmd()
|
||||
rootCmd := setFlags(channelsCmd)
|
||||
|
||||
grpIds := fmt.Sprintf("[\"%s\"]", group.ID)
|
||||
|
||||
cases := []struct {
|
||||
desc string
|
||||
args []string
|
||||
logType outputLog
|
||||
errLogMessage string
|
||||
sdkErr errors.SDKError
|
||||
}{
|
||||
{
|
||||
desc: "unassign group successfully",
|
||||
args: []string{
|
||||
unassignCmd,
|
||||
grpCmd,
|
||||
grpIds,
|
||||
channel.ID,
|
||||
domainID,
|
||||
token,
|
||||
},
|
||||
logType: okLog,
|
||||
},
|
||||
{
|
||||
desc: "unassign group with invalid args",
|
||||
args: []string{
|
||||
grpIds,
|
||||
channel.ID,
|
||||
domainID,
|
||||
token,
|
||||
extraArg,
|
||||
},
|
||||
logType: usageLog,
|
||||
},
|
||||
{
|
||||
desc: "unassign group with invalid json",
|
||||
args: []string{
|
||||
fmt.Sprintf("[\"%s\"", group.ID),
|
||||
channel.ID,
|
||||
domainID,
|
||||
token,
|
||||
},
|
||||
sdkErr: errors.NewSDKError(errors.New("unexpected end of JSON input")),
|
||||
errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.New("unexpected end of JSON input")),
|
||||
logType: errLog,
|
||||
},
|
||||
{
|
||||
desc: "unassign group with invalid channel id",
|
||||
args: []string{
|
||||
grpIds,
|
||||
invalidID,
|
||||
domainID,
|
||||
token,
|
||||
},
|
||||
sdkErr: errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
|
||||
errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden)),
|
||||
logType: errLog,
|
||||
},
|
||||
{
|
||||
desc: "unassign group with invalid user id",
|
||||
args: []string{
|
||||
fmt.Sprintf("[\"%s\"]", invalidID),
|
||||
channel.ID,
|
||||
domainID,
|
||||
token,
|
||||
},
|
||||
sdkErr: errors.NewSDKErrorWithStatus(svcerr.ErrAddPolicies, http.StatusBadRequest),
|
||||
errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAddPolicies, http.StatusBadRequest)),
|
||||
logType: errLog,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.desc, func(t *testing.T) {
|
||||
sdkCall := sdkMock.On("RemoveUserGroupFromChannel", tc.args[1], mock.Anything, tc.args[2], tc.args[3]).Return(tc.sdkErr)
|
||||
out := executeCommand(t, rootCmd, append([]string{unassignCmd, grpCmd}, tc.args...)...)
|
||||
switch tc.logType {
|
||||
case okLog:
|
||||
assert.True(t, strings.Contains(out, "ok"), fmt.Sprintf("%s unexpected response: expected success message, got: %v", tc.desc, out))
|
||||
case usageLog:
|
||||
assert.False(t, strings.Contains(out, rootCmd.Use), fmt.Sprintf("%s invalid usage: %s", tc.desc, out))
|
||||
case errLog:
|
||||
assert.Equal(t, tc.errLogMessage, out, fmt.Sprintf("%s unexpected error response: expected %s got errLogMessage:%s", tc.desc, tc.errLogMessage, out))
|
||||
}
|
||||
sdkCall.Unset()
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
+1
-73
@@ -197,54 +197,6 @@ var cmdClients = []cobra.Command{
|
||||
logJSONCmd(*cmd, client)
|
||||
},
|
||||
},
|
||||
{
|
||||
Use: "share <client_id> <user_id> <relation> <domain_id> <user_auth_token>",
|
||||
Short: "Share client with a user",
|
||||
Long: "Share client with a user\n" +
|
||||
"Usage:\n" +
|
||||
"\tsupermq-cli clients share <client_id> <user_id> <relation> $DOMAINID $USERTOKEN\n",
|
||||
Run: func(cmd *cobra.Command, args []string) {
|
||||
if len(args) != 5 {
|
||||
logUsageCmd(*cmd, cmd.Use)
|
||||
return
|
||||
}
|
||||
req := smqsdk.UsersRelationRequest{
|
||||
Relation: args[2],
|
||||
UserIDs: []string{args[1]},
|
||||
}
|
||||
err := sdk.ShareClient(args[0], req, args[3], args[4])
|
||||
if err != nil {
|
||||
logErrorCmd(*cmd, err)
|
||||
return
|
||||
}
|
||||
|
||||
logOKCmd(*cmd)
|
||||
},
|
||||
},
|
||||
{
|
||||
Use: "unshare <client_id> <user_id> <relation> <domain_id> <user_auth_token>",
|
||||
Short: "Unshare client with a user",
|
||||
Long: "Unshare client with a user\n" +
|
||||
"Usage:\n" +
|
||||
"\tsupermq-cli clients share <client_id> <user_id> <relation> $DOMAINID $USERTOKEN\n",
|
||||
Run: func(cmd *cobra.Command, args []string) {
|
||||
if len(args) != 5 {
|
||||
logUsageCmd(*cmd, cmd.Use)
|
||||
return
|
||||
}
|
||||
req := smqsdk.UsersRelationRequest{
|
||||
Relation: args[2],
|
||||
UserIDs: []string{args[1]},
|
||||
}
|
||||
err := sdk.UnshareClient(args[0], req, args[3], args[4])
|
||||
if err != nil {
|
||||
logErrorCmd(*cmd, err)
|
||||
return
|
||||
}
|
||||
|
||||
logOKCmd(*cmd)
|
||||
},
|
||||
},
|
||||
{
|
||||
Use: "connect <client_id> <channel_id> <domain_id> <user_auth_token>",
|
||||
Short: "Connect client",
|
||||
@@ -293,30 +245,6 @@ var cmdClients = []cobra.Command{
|
||||
logOKCmd(*cmd)
|
||||
},
|
||||
},
|
||||
{
|
||||
Use: "connections <client_id> <domain_id> <user_auth_token>",
|
||||
Short: "Connected list",
|
||||
Long: "List of Channels connected to Client\n" +
|
||||
"Usage:\n" +
|
||||
"\tsupermq-cli connections <client_id> $DOMAINID $USERTOKEN\n",
|
||||
Run: func(cmd *cobra.Command, args []string) {
|
||||
if len(args) != 3 {
|
||||
logUsageCmd(*cmd, cmd.Use)
|
||||
return
|
||||
}
|
||||
pm := smqsdk.PageMetadata{
|
||||
Offset: Offset,
|
||||
Limit: Limit,
|
||||
}
|
||||
cl, err := sdk.ChannelsByClient(args[0], pm, args[1], args[2])
|
||||
if err != nil {
|
||||
logErrorCmd(*cmd, err)
|
||||
return
|
||||
}
|
||||
|
||||
logJSONCmd(*cmd, cl)
|
||||
},
|
||||
},
|
||||
{
|
||||
Use: "users <client_id> <domain_id> <user_auth_token>",
|
||||
Short: "List users",
|
||||
@@ -332,7 +260,7 @@ var cmdClients = []cobra.Command{
|
||||
Offset: Offset,
|
||||
Limit: Limit,
|
||||
}
|
||||
ul, err := sdk.ListClientUsers(args[0], pm, args[1], args[2])
|
||||
ul, err := sdk.ListClientUsers(args[0], args[1], pm, args[2])
|
||||
if err != nil {
|
||||
logErrorCmd(*cmd, err)
|
||||
return
|
||||
|
||||
@@ -978,266 +978,3 @@ func TestDisconnectClientCmd(t *testing.T) {
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestListConnectionCmd(t *testing.T) {
|
||||
sdkMock := new(sdkmocks.SDK)
|
||||
cli.SetSDK(sdkMock)
|
||||
clientsCmd := cli.NewClientsCmd()
|
||||
rootCmd := setFlags(clientsCmd)
|
||||
|
||||
cp := sdk.ChannelsPage{}
|
||||
cases := []struct {
|
||||
desc string
|
||||
args []string
|
||||
logType outputLog
|
||||
page sdk.ChannelsPage
|
||||
errLogMessage string
|
||||
sdkErr errors.SDKError
|
||||
}{
|
||||
{
|
||||
desc: "list connections successfully",
|
||||
args: []string{
|
||||
client.ID,
|
||||
domainID,
|
||||
token,
|
||||
},
|
||||
page: sdk.ChannelsPage{
|
||||
PageRes: sdk.PageRes{
|
||||
Total: 1,
|
||||
Offset: 0,
|
||||
Limit: 10,
|
||||
},
|
||||
Channels: []sdk.Channel{channel},
|
||||
},
|
||||
logType: entityLog,
|
||||
},
|
||||
{
|
||||
desc: "list connections with invalid args",
|
||||
args: []string{
|
||||
client.ID,
|
||||
domainID,
|
||||
token,
|
||||
extraArg,
|
||||
},
|
||||
logType: usageLog,
|
||||
},
|
||||
{
|
||||
desc: "list connections with invalid client ID",
|
||||
args: []string{
|
||||
invalidID,
|
||||
domainID,
|
||||
token,
|
||||
},
|
||||
sdkErr: errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
|
||||
errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden)),
|
||||
logType: errLog,
|
||||
},
|
||||
{
|
||||
desc: "list connections with invalid token",
|
||||
args: []string{
|
||||
client.ID,
|
||||
domainID,
|
||||
invalidToken,
|
||||
},
|
||||
sdkErr: errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusUnauthorized),
|
||||
errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusUnauthorized)),
|
||||
logType: errLog,
|
||||
},
|
||||
}
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.desc, func(t *testing.T) {
|
||||
sdkCall := sdkMock.On("ChannelsByClient", tc.args[0], mock.Anything, tc.args[1], tc.args[2]).Return(tc.page, tc.sdkErr)
|
||||
out := executeCommand(t, rootCmd, append([]string{connsCmd}, tc.args...)...)
|
||||
|
||||
switch tc.logType {
|
||||
case entityLog:
|
||||
err := json.Unmarshal([]byte(out), &cp)
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to unmarshal JSON: %v", err)
|
||||
}
|
||||
assert.Equal(t, tc.page, cp, fmt.Sprintf("%v unexpected response, expected: %v, got: %v", tc.desc, tc.page, cp))
|
||||
case usageLog:
|
||||
assert.False(t, strings.Contains(out, rootCmd.Use), fmt.Sprintf("%s invalid usage: %s", tc.desc, out))
|
||||
case errLog:
|
||||
assert.Equal(t, tc.errLogMessage, out, fmt.Sprintf("%s unexpected error response: expected %s got errLogMessage:%s", tc.desc, tc.errLogMessage, out))
|
||||
}
|
||||
|
||||
sdkCall.Unset()
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestShareClientCmd(t *testing.T) {
|
||||
sdkMock := new(sdkmocks.SDK)
|
||||
cli.SetSDK(sdkMock)
|
||||
clientCmd := cli.NewClientsCmd()
|
||||
rootCmd := setFlags(clientCmd)
|
||||
|
||||
cases := []struct {
|
||||
desc string
|
||||
args []string
|
||||
logType outputLog
|
||||
sdkErr errors.SDKError
|
||||
errLogMessage string
|
||||
}{
|
||||
{
|
||||
desc: "share client successfully",
|
||||
args: []string{
|
||||
client.ID,
|
||||
user.ID,
|
||||
relation,
|
||||
domainID,
|
||||
token,
|
||||
},
|
||||
logType: okLog,
|
||||
},
|
||||
{
|
||||
desc: "share client with invalid user id",
|
||||
args: []string{
|
||||
client.ID,
|
||||
invalidID,
|
||||
relation,
|
||||
domainID,
|
||||
token,
|
||||
},
|
||||
sdkErr: errors.NewSDKErrorWithStatus(svcerr.ErrAddPolicies, http.StatusBadRequest),
|
||||
errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAddPolicies, http.StatusBadRequest)),
|
||||
logType: errLog,
|
||||
},
|
||||
{
|
||||
desc: "share client with invalid client ID",
|
||||
args: []string{
|
||||
invalidID,
|
||||
user.ID,
|
||||
relation,
|
||||
domainID,
|
||||
token,
|
||||
},
|
||||
sdkErr: errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
|
||||
errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden)),
|
||||
logType: errLog,
|
||||
},
|
||||
{
|
||||
desc: "share client with invalid args",
|
||||
args: []string{
|
||||
client.ID,
|
||||
user.ID,
|
||||
relation,
|
||||
domainID,
|
||||
token,
|
||||
extraArg,
|
||||
},
|
||||
logType: usageLog,
|
||||
},
|
||||
{
|
||||
desc: "share client with invalid relation",
|
||||
args: []string{
|
||||
client.ID,
|
||||
user.ID,
|
||||
"invalid",
|
||||
domainID,
|
||||
token,
|
||||
},
|
||||
sdkErr: errors.NewSDKErrorWithStatus(svcerr.ErrUpdateEntity, http.StatusBadRequest),
|
||||
errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrUpdateEntity, http.StatusBadRequest)),
|
||||
logType: errLog,
|
||||
},
|
||||
}
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.desc, func(t *testing.T) {
|
||||
sdkCall := sdkMock.On("ShareClient", tc.args[0], mock.Anything, tc.args[3], tc.args[4]).Return(tc.sdkErr)
|
||||
out := executeCommand(t, rootCmd, append([]string{shrCmd}, tc.args...)...)
|
||||
|
||||
switch tc.logType {
|
||||
case okLog:
|
||||
assert.True(t, strings.Contains(out, "ok"), fmt.Sprintf("%s unexpected response: expected success message, got: %v", tc.desc, out))
|
||||
case usageLog:
|
||||
assert.False(t, strings.Contains(out, rootCmd.Use), fmt.Sprintf("%s invalid usage: %s", tc.desc, out))
|
||||
case errLog:
|
||||
assert.Equal(t, tc.errLogMessage, out, fmt.Sprintf("%s unexpected error response: expected %s got errLogMessage:%s", tc.desc, tc.errLogMessage, out))
|
||||
}
|
||||
sdkCall.Unset()
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestUnshareClientCmd(t *testing.T) {
|
||||
sdkMock := new(sdkmocks.SDK)
|
||||
cli.SetSDK(sdkMock)
|
||||
clientsCmd := cli.NewClientsCmd()
|
||||
rootCmd := setFlags(clientsCmd)
|
||||
|
||||
cases := []struct {
|
||||
desc string
|
||||
args []string
|
||||
logType outputLog
|
||||
sdkErr errors.SDKError
|
||||
errLogMessage string
|
||||
}{
|
||||
{
|
||||
desc: "unshare client successfully",
|
||||
args: []string{
|
||||
client.ID,
|
||||
user.ID,
|
||||
relation,
|
||||
domainID,
|
||||
token,
|
||||
},
|
||||
logType: okLog,
|
||||
},
|
||||
{
|
||||
desc: "unshare client with invalid client ID",
|
||||
args: []string{
|
||||
invalidID,
|
||||
user.ID,
|
||||
relation,
|
||||
domainID,
|
||||
token,
|
||||
},
|
||||
sdkErr: errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
|
||||
errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden)),
|
||||
logType: errLog,
|
||||
},
|
||||
{
|
||||
desc: "unshare client with invalid args",
|
||||
args: []string{
|
||||
client.ID,
|
||||
user.ID,
|
||||
relation,
|
||||
domainID,
|
||||
token,
|
||||
extraArg,
|
||||
},
|
||||
logType: usageLog,
|
||||
},
|
||||
{
|
||||
desc: "unshare client with invalid relation",
|
||||
args: []string{
|
||||
client.ID,
|
||||
user.ID,
|
||||
"invalid",
|
||||
domainID,
|
||||
token,
|
||||
},
|
||||
sdkErr: errors.NewSDKErrorWithStatus(svcerr.ErrUpdateEntity, http.StatusBadRequest),
|
||||
errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrUpdateEntity, http.StatusBadRequest)),
|
||||
logType: errLog,
|
||||
},
|
||||
}
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.desc, func(t *testing.T) {
|
||||
sdkCall := sdkMock.On("UnshareClient", tc.args[0], mock.Anything, tc.args[3], tc.args[4]).Return(tc.sdkErr)
|
||||
out := executeCommand(t, rootCmd, append([]string{unshrCmd}, tc.args...)...)
|
||||
|
||||
switch tc.logType {
|
||||
case okLog:
|
||||
assert.True(t, strings.Contains(out, "ok"), fmt.Sprintf("%s unexpected response: expected success message, got: %v", tc.desc, out))
|
||||
case usageLog:
|
||||
assert.False(t, strings.Contains(out, rootCmd.Use), fmt.Sprintf("%s invalid usage: %s", tc.desc, out))
|
||||
case errLog:
|
||||
assert.Equal(t, tc.errLogMessage, out, fmt.Sprintf("%s unexpected error response: expected %s got errLogMessage:%s", tc.desc, tc.errLogMessage, out))
|
||||
}
|
||||
sdkCall.Unset()
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
@@ -173,78 +173,6 @@ var cmdDomains = []cobra.Command{
|
||||
},
|
||||
}
|
||||
|
||||
var domainAssignCmds = []cobra.Command{
|
||||
{
|
||||
Use: "users <relation> <user_ids> <domain_id> <token>",
|
||||
Short: "Assign users",
|
||||
Long: "Assign users to a domain\n" +
|
||||
"Usage:\n" +
|
||||
"\tsupermq-cli domains assign users <relation> '[\"<user_id_1>\", \"<user_id_2>\"]' <domain_id> $TOKEN\n",
|
||||
Run: func(cmd *cobra.Command, args []string) {
|
||||
if len(args) != 4 {
|
||||
logUsageCmd(*cmd, cmd.Use)
|
||||
return
|
||||
}
|
||||
var userIDs []string
|
||||
if err := json.Unmarshal([]byte(args[1]), &userIDs); err != nil {
|
||||
logErrorCmd(*cmd, err)
|
||||
return
|
||||
}
|
||||
if err := sdk.AddUserToDomain(args[2], smqsdk.UsersRelationRequest{Relation: args[0], UserIDs: userIDs}, args[3]); err != nil {
|
||||
logErrorCmd(*cmd, err)
|
||||
return
|
||||
}
|
||||
logOKCmd(*cmd)
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
var domainUnassignCmds = []cobra.Command{
|
||||
{
|
||||
Use: "users <user_id> <domain_id> <token>",
|
||||
Short: "Unassign users",
|
||||
Long: "Unassign users from a domain\n" +
|
||||
"Usage:\n" +
|
||||
"\tsupermq-cli domains unassign users <user_id> <domain_id> $TOKEN\n",
|
||||
Run: func(cmd *cobra.Command, args []string) {
|
||||
if len(args) != 3 {
|
||||
logUsageCmd(*cmd, cmd.Use)
|
||||
return
|
||||
}
|
||||
|
||||
if err := sdk.RemoveUserFromDomain(args[1], args[0], args[2]); err != nil {
|
||||
logErrorCmd(*cmd, err)
|
||||
return
|
||||
}
|
||||
logOKCmd(*cmd)
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
func NewDomainAssignCmds() *cobra.Command {
|
||||
cmd := cobra.Command{
|
||||
Use: "assign [users]",
|
||||
Short: "Assign users to a domain",
|
||||
Long: "Assign users to a domain",
|
||||
}
|
||||
for i := range domainAssignCmds {
|
||||
cmd.AddCommand(&domainAssignCmds[i])
|
||||
}
|
||||
return &cmd
|
||||
}
|
||||
|
||||
func NewDomainUnassignCmds() *cobra.Command {
|
||||
cmd := cobra.Command{
|
||||
Use: "unassign [users]",
|
||||
Short: "Unassign users from a domain",
|
||||
Long: "Unassign users from a domain",
|
||||
}
|
||||
for i := range domainUnassignCmds {
|
||||
cmd.AddCommand(&domainUnassignCmds[i])
|
||||
}
|
||||
return &cmd
|
||||
}
|
||||
|
||||
// NewDomainsCmd returns domains command.
|
||||
func NewDomainsCmd() *cobra.Command {
|
||||
cmd := cobra.Command{
|
||||
@@ -257,7 +185,5 @@ func NewDomainsCmd() *cobra.Command {
|
||||
cmd.AddCommand(&cmdDomains[i])
|
||||
}
|
||||
|
||||
cmd.AddCommand(NewDomainAssignCmds())
|
||||
cmd.AddCommand(NewDomainUnassignCmds())
|
||||
return &cmd
|
||||
}
|
||||
|
||||
@@ -503,167 +503,3 @@ func TestDisableDomainCmd(t *testing.T) {
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestAssignUserToDomainCmd(t *testing.T) {
|
||||
sdkMock := new(sdkmocks.SDK)
|
||||
cli.SetSDK(sdkMock)
|
||||
domainsCmd := cli.NewDomainsCmd()
|
||||
rootCmd := setFlags(domainsCmd)
|
||||
|
||||
userIds := fmt.Sprintf("[\"%s\"]", user.ID)
|
||||
|
||||
cases := []struct {
|
||||
desc string
|
||||
args []string
|
||||
logType outputLog
|
||||
errLogMessage string
|
||||
sdkErr errors.SDKError
|
||||
}{
|
||||
{
|
||||
desc: "assign user successfully",
|
||||
args: []string{
|
||||
relation,
|
||||
userIds,
|
||||
domain.ID,
|
||||
token,
|
||||
},
|
||||
logType: okLog,
|
||||
},
|
||||
{
|
||||
desc: "assign user with invalid args",
|
||||
args: []string{
|
||||
relation,
|
||||
userIds,
|
||||
domain.ID,
|
||||
token,
|
||||
extraArg,
|
||||
},
|
||||
logType: usageLog,
|
||||
},
|
||||
{
|
||||
desc: "assign user with invalid json",
|
||||
args: []string{
|
||||
relation,
|
||||
fmt.Sprintf("[\"%s\"", user.ID),
|
||||
domain.ID,
|
||||
token,
|
||||
},
|
||||
sdkErr: errors.NewSDKError(errors.New("unexpected end of JSON input")),
|
||||
errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.New("unexpected end of JSON input")),
|
||||
logType: errLog,
|
||||
},
|
||||
{
|
||||
desc: "assign user with invalid domain id",
|
||||
args: []string{
|
||||
relation,
|
||||
userIds,
|
||||
invalidID,
|
||||
token,
|
||||
},
|
||||
sdkErr: errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
|
||||
errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden)),
|
||||
logType: errLog,
|
||||
},
|
||||
{
|
||||
desc: "assign user with invalid user id",
|
||||
args: []string{
|
||||
relation,
|
||||
fmt.Sprintf("[\"%s\"]", invalidID),
|
||||
domain.ID,
|
||||
token,
|
||||
},
|
||||
sdkErr: errors.NewSDKErrorWithStatus(svcerr.ErrAddPolicies, http.StatusBadRequest),
|
||||
errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAddPolicies, http.StatusBadRequest)),
|
||||
logType: errLog,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.desc, func(t *testing.T) {
|
||||
sdkCall := sdkMock.On("AddUserToDomain", tc.args[2], mock.Anything, tc.args[3]).Return(tc.sdkErr)
|
||||
out := executeCommand(t, rootCmd, append([]string{assignCmd, usrCmd}, tc.args...)...)
|
||||
switch tc.logType {
|
||||
case okLog:
|
||||
assert.True(t, strings.Contains(out, "ok"), fmt.Sprintf("%s unexpected response: expected success message, got: %v", tc.desc, out))
|
||||
case usageLog:
|
||||
assert.False(t, strings.Contains(out, rootCmd.Use), fmt.Sprintf("%s invalid usage: %s", tc.desc, out))
|
||||
case errLog:
|
||||
assert.Equal(t, tc.errLogMessage, out, fmt.Sprintf("%s unexpected error response: expected %s got errLogMessage:%s", tc.desc, tc.errLogMessage, out))
|
||||
}
|
||||
sdkCall.Unset()
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestUnassignUserTodomainCmd(t *testing.T) {
|
||||
sdkMock := new(sdkmocks.SDK)
|
||||
cli.SetSDK(sdkMock)
|
||||
domainsCmd := cli.NewDomainsCmd()
|
||||
rootCmd := setFlags(domainsCmd)
|
||||
|
||||
cases := []struct {
|
||||
desc string
|
||||
args []string
|
||||
logType outputLog
|
||||
errLogMessage string
|
||||
sdkErr errors.SDKError
|
||||
}{
|
||||
{
|
||||
desc: "unassign user successfully",
|
||||
args: []string{
|
||||
user.ID,
|
||||
domain.ID,
|
||||
token,
|
||||
},
|
||||
logType: okLog,
|
||||
},
|
||||
{
|
||||
desc: "unassign user with invalid args",
|
||||
args: []string{
|
||||
user.ID,
|
||||
domain.ID,
|
||||
token,
|
||||
extraArg,
|
||||
},
|
||||
logType: usageLog,
|
||||
},
|
||||
{
|
||||
desc: "unassign user with invalid domain id",
|
||||
args: []string{
|
||||
user.ID,
|
||||
invalidID,
|
||||
token,
|
||||
},
|
||||
sdkErr: errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
|
||||
errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden)),
|
||||
logType: errLog,
|
||||
},
|
||||
{
|
||||
desc: "unassign user with invalid user id",
|
||||
args: []string{
|
||||
invalidID,
|
||||
domain.ID,
|
||||
token,
|
||||
},
|
||||
sdkErr: errors.NewSDKErrorWithStatus(svcerr.ErrAddPolicies, http.StatusBadRequest),
|
||||
errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAddPolicies, http.StatusBadRequest)),
|
||||
logType: errLog,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.desc, func(t *testing.T) {
|
||||
sdkCall := sdkMock.On("RemoveUserFromDomain", tc.args[1], tc.args[0], tc.args[2]).Return(tc.sdkErr)
|
||||
out := executeCommand(t, rootCmd, append([]string{unassignCmd, usrCmd}, tc.args...)...)
|
||||
switch tc.logType {
|
||||
case okLog:
|
||||
assert.True(t, strings.Contains(out, "ok"), fmt.Sprintf("%s unexpected response: expected success message, got: %v", tc.desc, out))
|
||||
case usageLog:
|
||||
assert.False(t, strings.Contains(out, rootCmd.Use), fmt.Sprintf("%s invalid usage: %s", tc.desc, out))
|
||||
case errLog:
|
||||
assert.Equal(t, tc.errLogMessage, out, fmt.Sprintf("%s unexpected error response: expected %s got errLogMessage:%s", tc.desc, tc.errLogMessage, out))
|
||||
}
|
||||
sdkCall.Unset()
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
-206
@@ -64,84 +64,6 @@ var cmdGroups = []cobra.Command{
|
||||
logJSONCmd(*cmd, group)
|
||||
},
|
||||
},
|
||||
{
|
||||
Use: "get [all | children <group_id> | parents <group_id> | members <group_id> | <group_id>] <domain_id> <user_auth_token>",
|
||||
Short: "Get group",
|
||||
Long: "Get all users groups, group children or group by id.\n" +
|
||||
"Usage:\n" +
|
||||
"\tsupermq-cli groups get all $DOMAINID $USERTOKEN - lists all groups\n" +
|
||||
"\tsupermq-cli groups get children <group_id> $DOMAINID $USERTOKEN - lists all children groups of <group_id>\n" +
|
||||
"\tsupermq-cli groups get parents <group_id> $DOMAINID $USERTOKEN - lists all parent groups of <group_id>\n" +
|
||||
"\tsupermq-cli groups get <group_id> $DOMAINID $USERTOKEN - shows group with provided group ID\n",
|
||||
Run: func(cmd *cobra.Command, args []string) {
|
||||
if len(args) < 3 {
|
||||
logUsageCmd(*cmd, cmd.Use)
|
||||
return
|
||||
}
|
||||
if args[0] == all {
|
||||
if len(args) > 3 {
|
||||
logUsageCmd(*cmd, cmd.Use)
|
||||
return
|
||||
}
|
||||
pm := smqsdk.PageMetadata{
|
||||
Offset: Offset,
|
||||
Limit: Limit,
|
||||
}
|
||||
l, err := sdk.Groups(pm, args[1], args[2])
|
||||
if err != nil {
|
||||
logErrorCmd(*cmd, err)
|
||||
return
|
||||
}
|
||||
logJSONCmd(*cmd, l)
|
||||
return
|
||||
}
|
||||
if args[0] == "children" {
|
||||
if len(args) > 4 {
|
||||
logUsageCmd(*cmd, cmd.Use)
|
||||
return
|
||||
}
|
||||
pm := smqsdk.PageMetadata{
|
||||
Offset: Offset,
|
||||
Limit: Limit,
|
||||
DomainID: args[2],
|
||||
}
|
||||
l, err := sdk.Children(args[1], pm, args[2], args[3])
|
||||
if err != nil {
|
||||
logErrorCmd(*cmd, err)
|
||||
return
|
||||
}
|
||||
logJSONCmd(*cmd, l)
|
||||
return
|
||||
}
|
||||
if args[0] == "parents" {
|
||||
if len(args) > 4 {
|
||||
logUsageCmd(*cmd, cmd.Use)
|
||||
return
|
||||
}
|
||||
pm := smqsdk.PageMetadata{
|
||||
Offset: Offset,
|
||||
Limit: Limit,
|
||||
}
|
||||
l, err := sdk.Parents(args[1], pm, args[2], args[3])
|
||||
if err != nil {
|
||||
logErrorCmd(*cmd, err)
|
||||
return
|
||||
}
|
||||
logJSONCmd(*cmd, l)
|
||||
return
|
||||
}
|
||||
if len(args) > 3 {
|
||||
logUsageCmd(*cmd, cmd.Use)
|
||||
return
|
||||
}
|
||||
t, err := sdk.Group(args[0], args[1], args[2])
|
||||
if err != nil {
|
||||
logErrorCmd(*cmd, err)
|
||||
return
|
||||
}
|
||||
logJSONCmd(*cmd, t)
|
||||
},
|
||||
},
|
||||
{
|
||||
Use: "delete <group_id> <domain_id> <user_auth_token>",
|
||||
Short: "Delete group",
|
||||
@@ -160,54 +82,6 @@ var cmdGroups = []cobra.Command{
|
||||
logOKCmd(*cmd)
|
||||
},
|
||||
},
|
||||
{
|
||||
Use: "users <group_id> <domain_id> <user_auth_token>",
|
||||
Short: "List users",
|
||||
Long: "List users in a group\n" +
|
||||
"Usage:\n" +
|
||||
"\tsupermq-cli groups users <group_id> $DOMAINID $USERTOKEN",
|
||||
Run: func(cmd *cobra.Command, args []string) {
|
||||
if len(args) != 3 {
|
||||
logUsageCmd(*cmd, cmd.Use)
|
||||
return
|
||||
}
|
||||
pm := smqsdk.PageMetadata{
|
||||
Offset: Offset,
|
||||
Limit: Limit,
|
||||
Status: Status,
|
||||
}
|
||||
users, err := sdk.ListGroupUsers(args[0], pm, args[1], args[2])
|
||||
if err != nil {
|
||||
logErrorCmd(*cmd, err)
|
||||
return
|
||||
}
|
||||
logJSONCmd(*cmd, users)
|
||||
},
|
||||
},
|
||||
{
|
||||
Use: "channels <group_id> <domain_id> <user_auth_token>",
|
||||
Short: "List channels",
|
||||
Long: "List channels in a group\n" +
|
||||
"Usage:\n" +
|
||||
"\tsupermq-cli groups channels <group_id> $DOMAINID $USERTOKEN",
|
||||
Run: func(cmd *cobra.Command, args []string) {
|
||||
if len(args) != 3 {
|
||||
logUsageCmd(*cmd, cmd.Use)
|
||||
return
|
||||
}
|
||||
pm := smqsdk.PageMetadata{
|
||||
Offset: Offset,
|
||||
Limit: Limit,
|
||||
Status: Status,
|
||||
}
|
||||
channels, err := sdk.ListGroupChannels(args[0], pm, args[1], args[2])
|
||||
if err != nil {
|
||||
logErrorCmd(*cmd, err)
|
||||
return
|
||||
}
|
||||
logJSONCmd(*cmd, channels)
|
||||
},
|
||||
},
|
||||
{
|
||||
Use: "enable <group_id> <domain_id> <user_auth_token>",
|
||||
Short: "Change group status to enabled",
|
||||
@@ -252,84 +126,6 @@ var cmdGroups = []cobra.Command{
|
||||
},
|
||||
}
|
||||
|
||||
var groupAssignCmds = []cobra.Command{
|
||||
{
|
||||
Use: "users <relation> <user_ids> <group_id> <domain_id> <user_auth_token>",
|
||||
Short: "Assign users",
|
||||
Long: "Assign users to a group\n" +
|
||||
"Usage:\n" +
|
||||
"\tsupermq-cli groups assign users <relation> '[\"<user_id_1>\", \"<user_id_2>\"]' <group_id> $DOMAINID $USERTOKEN\n",
|
||||
Run: func(cmd *cobra.Command, args []string) {
|
||||
if len(args) != 5 {
|
||||
logUsageCmd(*cmd, cmd.Use)
|
||||
return
|
||||
}
|
||||
var userIDs []string
|
||||
if err := json.Unmarshal([]byte(args[1]), &userIDs); err != nil {
|
||||
logErrorCmd(*cmd, err)
|
||||
return
|
||||
}
|
||||
if err := sdk.AddUserToGroup(args[2], smqsdk.UsersRelationRequest{Relation: args[0], UserIDs: userIDs}, args[3], args[4]); err != nil {
|
||||
logErrorCmd(*cmd, err)
|
||||
return
|
||||
}
|
||||
logOKCmd(*cmd)
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
var groupUnassignCmds = []cobra.Command{
|
||||
{
|
||||
Use: "users <relation> <user_ids> <group_id> <domain_id> <user_auth_token>",
|
||||
Short: "Unassign users",
|
||||
Long: "Unassign users from a group\n" +
|
||||
"Usage:\n" +
|
||||
"\tsupermq-cli groups unassign users <relation> '[\"<user_id_1>\", \"<user_id_2>\"]' <group_id> $DOMAINID $USERTOKEN\n",
|
||||
Run: func(cmd *cobra.Command, args []string) {
|
||||
if len(args) != 5 {
|
||||
logUsageCmd(*cmd, cmd.Use)
|
||||
return
|
||||
}
|
||||
var userIDs []string
|
||||
if err := json.Unmarshal([]byte(args[1]), &userIDs); err != nil {
|
||||
logErrorCmd(*cmd, err)
|
||||
return
|
||||
}
|
||||
if err := sdk.RemoveUserFromGroup(args[2], smqsdk.UsersRelationRequest{Relation: args[0], UserIDs: userIDs}, args[3], args[4]); err != nil {
|
||||
logErrorCmd(*cmd, err)
|
||||
return
|
||||
}
|
||||
logOKCmd(*cmd)
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
func NewGroupAssignCmds() *cobra.Command {
|
||||
cmd := cobra.Command{
|
||||
Use: "assign [users]",
|
||||
Short: "Assign users to a group",
|
||||
Long: "Assign users to a group",
|
||||
}
|
||||
|
||||
for i := range groupAssignCmds {
|
||||
cmd.AddCommand(&groupAssignCmds[i])
|
||||
}
|
||||
return &cmd
|
||||
}
|
||||
|
||||
func NewGroupUnassignCmds() *cobra.Command {
|
||||
cmd := cobra.Command{
|
||||
Use: "unassign [users]",
|
||||
Short: "Unassign users from a group",
|
||||
Long: "Unassign users from a group",
|
||||
}
|
||||
|
||||
for i := range groupUnassignCmds {
|
||||
cmd.AddCommand(&groupUnassignCmds[i])
|
||||
}
|
||||
return &cmd
|
||||
}
|
||||
|
||||
// NewGroupsCmd returns users command.
|
||||
func NewGroupsCmd() *cobra.Command {
|
||||
cmd := cobra.Command{
|
||||
@@ -342,7 +138,5 @@ func NewGroupsCmd() *cobra.Command {
|
||||
cmd.AddCommand(&cmdGroups[i])
|
||||
}
|
||||
|
||||
cmd.AddCommand(NewGroupAssignCmds())
|
||||
cmd.AddCommand(NewGroupUnassignCmds())
|
||||
return &cmd
|
||||
}
|
||||
|
||||
@@ -116,213 +116,6 @@ func TestCreateGroupCmd(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func TestGetGroupsCmd(t *testing.T) {
|
||||
sdkMock := new(sdkmocks.SDK)
|
||||
cli.SetSDK(sdkMock)
|
||||
groupCmd := cli.NewGroupsCmd()
|
||||
rootCmd := setFlags(groupCmd)
|
||||
|
||||
var ch mgsdk.Group
|
||||
var page mgsdk.GroupsPage
|
||||
|
||||
cases := []struct {
|
||||
desc string
|
||||
args []string
|
||||
sdkErr errors.SDKError
|
||||
page mgsdk.GroupsPage
|
||||
group mgsdk.Group
|
||||
logType outputLog
|
||||
errLogMessage string
|
||||
}{
|
||||
{
|
||||
desc: "get all groups successfully",
|
||||
args: []string{
|
||||
all,
|
||||
domainID,
|
||||
token,
|
||||
},
|
||||
page: mgsdk.GroupsPage{
|
||||
Groups: []mgsdk.Group{group},
|
||||
},
|
||||
logType: entityLog,
|
||||
},
|
||||
{
|
||||
desc: "get all groups with invalid args",
|
||||
args: []string{
|
||||
all,
|
||||
domainID,
|
||||
token,
|
||||
extraArg,
|
||||
},
|
||||
logType: usageLog,
|
||||
},
|
||||
{
|
||||
desc: "get children groups successfully",
|
||||
args: []string{
|
||||
childCmd,
|
||||
group.ID,
|
||||
domainID,
|
||||
token,
|
||||
},
|
||||
page: mgsdk.GroupsPage{
|
||||
Groups: []mgsdk.Group{group},
|
||||
},
|
||||
logType: entityLog,
|
||||
},
|
||||
{
|
||||
desc: "get children groups with invalid args",
|
||||
args: []string{
|
||||
childCmd,
|
||||
group.ID,
|
||||
domainID,
|
||||
token,
|
||||
extraArg,
|
||||
},
|
||||
logType: usageLog,
|
||||
},
|
||||
{
|
||||
desc: "get children groups with invalid token",
|
||||
args: []string{
|
||||
childCmd,
|
||||
group.ID,
|
||||
domainID,
|
||||
invalidToken,
|
||||
},
|
||||
logType: errLog,
|
||||
sdkErr: errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
|
||||
errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden)),
|
||||
},
|
||||
{
|
||||
desc: "get parents groups successfully",
|
||||
args: []string{
|
||||
parentCmd,
|
||||
group.ID,
|
||||
domainID,
|
||||
token,
|
||||
},
|
||||
page: mgsdk.GroupsPage{
|
||||
Groups: []mgsdk.Group{group},
|
||||
},
|
||||
logType: entityLog,
|
||||
},
|
||||
{
|
||||
desc: "get parents groups with invalid args",
|
||||
args: []string{
|
||||
parentCmd,
|
||||
group.ID,
|
||||
domainID,
|
||||
token,
|
||||
extraArg,
|
||||
},
|
||||
logType: usageLog,
|
||||
},
|
||||
{
|
||||
desc: "get parents groups with invalid token",
|
||||
args: []string{
|
||||
parentCmd,
|
||||
group.ID,
|
||||
domainID,
|
||||
invalidToken,
|
||||
},
|
||||
logType: errLog,
|
||||
sdkErr: errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
|
||||
errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden)),
|
||||
},
|
||||
{
|
||||
desc: "get group with id",
|
||||
args: []string{
|
||||
group.ID,
|
||||
domainID,
|
||||
token,
|
||||
},
|
||||
logType: entityLog,
|
||||
group: group,
|
||||
},
|
||||
{
|
||||
desc: "get groups with invalid args",
|
||||
args: []string{
|
||||
all,
|
||||
},
|
||||
logType: usageLog,
|
||||
},
|
||||
{
|
||||
desc: "get all groups with invalid token",
|
||||
args: []string{
|
||||
all,
|
||||
domainID,
|
||||
invalidToken,
|
||||
},
|
||||
logType: errLog,
|
||||
sdkErr: errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
|
||||
errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden)),
|
||||
},
|
||||
{
|
||||
desc: "get group with invalid domain",
|
||||
args: []string{
|
||||
group.ID,
|
||||
invalidID,
|
||||
token,
|
||||
},
|
||||
logType: errLog,
|
||||
sdkErr: errors.NewSDKErrorWithStatus(svcerr.ErrDomainAuthorization, http.StatusForbidden),
|
||||
errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrDomainAuthorization, http.StatusForbidden)),
|
||||
},
|
||||
{
|
||||
desc: "get group with invalid id",
|
||||
args: []string{
|
||||
invalidID,
|
||||
domainID,
|
||||
token,
|
||||
},
|
||||
sdkErr: errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
|
||||
errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden)),
|
||||
logType: errLog,
|
||||
},
|
||||
{
|
||||
desc: "get group with invalid args",
|
||||
args: []string{
|
||||
group.ID,
|
||||
domainID,
|
||||
token,
|
||||
extraArg,
|
||||
},
|
||||
logType: usageLog,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.desc, func(t *testing.T) {
|
||||
sdkCall := sdkMock.On("Group", mock.Anything, mock.Anything, mock.Anything).Return(tc.group, tc.sdkErr)
|
||||
sdkCall1 := sdkMock.On("Groups", mock.Anything, mock.Anything, mock.Anything).Return(tc.page, tc.sdkErr)
|
||||
sdkCall2 := sdkMock.On("Parents", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tc.page, tc.sdkErr)
|
||||
sdkCall3 := sdkMock.On("Children", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tc.page, tc.sdkErr)
|
||||
|
||||
out := executeCommand(t, rootCmd, append([]string{getCmd}, tc.args...)...)
|
||||
|
||||
switch tc.logType {
|
||||
case entityLog:
|
||||
if tc.args[1] == all {
|
||||
err := json.Unmarshal([]byte(out), &page)
|
||||
assert.Nil(t, err)
|
||||
assert.Equal(t, tc.page, page, fmt.Sprintf("%v unexpected response, expected: %v, got: %v", tc.desc, tc.page, page))
|
||||
} else {
|
||||
err := json.Unmarshal([]byte(out), &ch)
|
||||
assert.Nil(t, err)
|
||||
assert.Equal(t, tc.group, ch, fmt.Sprintf("%v unexpected response, expected: %v, got: %v", tc.desc, tc.group, ch))
|
||||
}
|
||||
case errLog:
|
||||
assert.Equal(t, tc.errLogMessage, out, fmt.Sprintf("%s unexpected error response: expected %s got errLogMessage:%s", tc.desc, tc.errLogMessage, out))
|
||||
case usageLog:
|
||||
assert.False(t, strings.Contains(out, rootCmd.Use), fmt.Sprintf("%s invalid usage: %s", tc.desc, out))
|
||||
}
|
||||
sdkCall.Unset()
|
||||
sdkCall1.Unset()
|
||||
sdkCall2.Unset()
|
||||
sdkCall3.Unset()
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestDeletegroupCmd(t *testing.T) {
|
||||
sdkMock := new(sdkmocks.SDK)
|
||||
cli.SetSDK(sdkMock)
|
||||
@@ -479,156 +272,6 @@ func TestUpdategroupCmd(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func TestListUsersCmd(t *testing.T) {
|
||||
sdkMock := new(sdkmocks.SDK)
|
||||
cli.SetSDK(sdkMock)
|
||||
groupsCmd := cli.NewGroupsCmd()
|
||||
rootCmd := setFlags(groupsCmd)
|
||||
|
||||
var up mgsdk.UsersPage
|
||||
cases := []struct {
|
||||
desc string
|
||||
args []string
|
||||
sdkErr errors.SDKError
|
||||
errLogMessage string
|
||||
logType outputLog
|
||||
page mgsdk.UsersPage
|
||||
}{
|
||||
{
|
||||
desc: "list users successfully",
|
||||
args: []string{
|
||||
group.ID,
|
||||
domainID,
|
||||
token,
|
||||
},
|
||||
page: mgsdk.UsersPage{
|
||||
PageRes: mgsdk.PageRes{
|
||||
Total: 1,
|
||||
Offset: 0,
|
||||
Limit: 10,
|
||||
},
|
||||
Users: []mgsdk.User{user},
|
||||
},
|
||||
logType: entityLog,
|
||||
},
|
||||
{
|
||||
desc: "list users with invalid args",
|
||||
args: []string{
|
||||
group.ID,
|
||||
domainID,
|
||||
token,
|
||||
extraArg,
|
||||
},
|
||||
logType: usageLog,
|
||||
},
|
||||
{
|
||||
desc: "list users with invalid id",
|
||||
args: []string{
|
||||
invalidID,
|
||||
domainID,
|
||||
token,
|
||||
},
|
||||
sdkErr: errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
|
||||
errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden)),
|
||||
logType: errLog,
|
||||
},
|
||||
}
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.desc, func(t *testing.T) {
|
||||
sdkCall := sdkMock.On("ListGroupUsers", tc.args[0], mock.Anything, tc.args[1], tc.args[2]).Return(tc.page, tc.sdkErr)
|
||||
out := executeCommand(t, rootCmd, append([]string{usrCmd}, tc.args...)...)
|
||||
switch tc.logType {
|
||||
case entityLog:
|
||||
err := json.Unmarshal([]byte(out), &up)
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to unmarshal JSON: %v", err)
|
||||
}
|
||||
assert.Equal(t, tc.page, up, fmt.Sprintf("%v unexpected response, expected: %v, got: %v", tc.desc, tc.page, up))
|
||||
case usageLog:
|
||||
assert.False(t, strings.Contains(out, rootCmd.Use), fmt.Sprintf("%s invalid usage: %s", tc.desc, out))
|
||||
case errLog:
|
||||
assert.Equal(t, tc.errLogMessage, out, fmt.Sprintf("%s unexpected error response: expected %s got errLogMessage:%s", tc.desc, tc.errLogMessage, out))
|
||||
}
|
||||
sdkCall.Unset()
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestListChannelsCmd(t *testing.T) {
|
||||
sdkMock := new(sdkmocks.SDK)
|
||||
cli.SetSDK(sdkMock)
|
||||
groupsCmd := cli.NewGroupsCmd()
|
||||
rootCmd := setFlags(groupsCmd)
|
||||
|
||||
var cp mgsdk.ChannelsPage
|
||||
cases := []struct {
|
||||
desc string
|
||||
args []string
|
||||
sdkErr errors.SDKError
|
||||
errLogMessage string
|
||||
logType outputLog
|
||||
page mgsdk.ChannelsPage
|
||||
}{
|
||||
{
|
||||
desc: "list channels successfully",
|
||||
args: []string{
|
||||
group.ID,
|
||||
domainID,
|
||||
token,
|
||||
},
|
||||
page: mgsdk.ChannelsPage{
|
||||
PageRes: mgsdk.PageRes{
|
||||
Total: 1,
|
||||
Offset: 0,
|
||||
Limit: 10,
|
||||
},
|
||||
Channels: []mgsdk.Channel{channel},
|
||||
},
|
||||
logType: entityLog,
|
||||
},
|
||||
{
|
||||
desc: "list channels with invalid args",
|
||||
args: []string{
|
||||
group.ID,
|
||||
domainID,
|
||||
token,
|
||||
extraArg,
|
||||
},
|
||||
logType: usageLog,
|
||||
},
|
||||
{
|
||||
desc: "list channels with invalid id",
|
||||
args: []string{
|
||||
invalidID,
|
||||
domainID,
|
||||
token,
|
||||
},
|
||||
sdkErr: errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
|
||||
errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden)),
|
||||
logType: errLog,
|
||||
},
|
||||
}
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.desc, func(t *testing.T) {
|
||||
sdkCall := sdkMock.On("ListGroupChannels", tc.args[0], mock.Anything, tc.args[1], tc.args[2]).Return(tc.page, tc.sdkErr)
|
||||
out := executeCommand(t, rootCmd, append([]string{chansCmd}, tc.args...)...)
|
||||
switch tc.logType {
|
||||
case entityLog:
|
||||
err := json.Unmarshal([]byte(out), &cp)
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to unmarshal JSON: %v", err)
|
||||
}
|
||||
assert.Equal(t, tc.page, cp, fmt.Sprintf("%v unexpected response, expected: %v, got: %v", tc.desc, tc.page, cp))
|
||||
case usageLog:
|
||||
assert.False(t, strings.Contains(out, rootCmd.Use), fmt.Sprintf("%s invalid usage: %s", tc.desc, out))
|
||||
case errLog:
|
||||
assert.Equal(t, tc.errLogMessage, out, fmt.Sprintf("%s unexpected error response: expected %s got errLogMessage:%s", tc.desc, tc.errLogMessage, out))
|
||||
}
|
||||
sdkCall.Unset()
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestEnablegroupCmd(t *testing.T) {
|
||||
sdkMock := new(sdkmocks.SDK)
|
||||
cli.SetSDK(sdkMock)
|
||||
@@ -791,195 +434,3 @@ func TestDisablegroupCmd(t *testing.T) {
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestAssignUserToGroupCmd(t *testing.T) {
|
||||
sdkMock := new(sdkmocks.SDK)
|
||||
cli.SetSDK(sdkMock)
|
||||
groupsCmd := cli.NewGroupsCmd()
|
||||
rootCmd := setFlags(groupsCmd)
|
||||
|
||||
userIds := fmt.Sprintf("[\"%s\"]", user.ID)
|
||||
|
||||
cases := []struct {
|
||||
desc string
|
||||
args []string
|
||||
logType outputLog
|
||||
errLogMessage string
|
||||
sdkErr errors.SDKError
|
||||
}{
|
||||
{
|
||||
desc: "assign user successfully",
|
||||
args: []string{
|
||||
relation,
|
||||
userIds,
|
||||
group.ID,
|
||||
domainID,
|
||||
token,
|
||||
},
|
||||
logType: okLog,
|
||||
},
|
||||
{
|
||||
desc: "assign user with invalid args",
|
||||
args: []string{
|
||||
relation,
|
||||
userIds,
|
||||
group.ID,
|
||||
domainID,
|
||||
token,
|
||||
extraArg,
|
||||
},
|
||||
logType: usageLog,
|
||||
},
|
||||
{
|
||||
desc: "assign user with invalid json",
|
||||
args: []string{
|
||||
relation,
|
||||
fmt.Sprintf("[\"%s\"", user.ID),
|
||||
group.ID,
|
||||
domainID,
|
||||
token,
|
||||
},
|
||||
sdkErr: errors.NewSDKError(errors.New("unexpected end of JSON input")),
|
||||
errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.New("unexpected end of JSON input")),
|
||||
logType: errLog,
|
||||
},
|
||||
{
|
||||
desc: "assign user with invalid group id",
|
||||
args: []string{
|
||||
relation,
|
||||
userIds,
|
||||
invalidID,
|
||||
domainID,
|
||||
token,
|
||||
},
|
||||
sdkErr: errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
|
||||
errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden)),
|
||||
logType: errLog,
|
||||
},
|
||||
{
|
||||
desc: "assign user with invalid user id",
|
||||
args: []string{
|
||||
relation,
|
||||
fmt.Sprintf("[\"%s\"]", invalidID),
|
||||
group.ID,
|
||||
domainID,
|
||||
token,
|
||||
},
|
||||
sdkErr: errors.NewSDKErrorWithStatus(svcerr.ErrAddPolicies, http.StatusBadRequest),
|
||||
errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAddPolicies, http.StatusBadRequest)),
|
||||
logType: errLog,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.desc, func(t *testing.T) {
|
||||
sdkCall := sdkMock.On("AddUserToGroup", tc.args[2], mock.Anything, tc.args[3], tc.args[4]).Return(tc.sdkErr)
|
||||
out := executeCommand(t, rootCmd, append([]string{assignCmd, usrCmd}, tc.args...)...)
|
||||
switch tc.logType {
|
||||
case okLog:
|
||||
assert.True(t, strings.Contains(out, "ok"), fmt.Sprintf("%s unexpected response: expected success message, got: %v", tc.desc, out))
|
||||
case usageLog:
|
||||
assert.False(t, strings.Contains(out, rootCmd.Use), fmt.Sprintf("%s invalid usage: %s", tc.desc, out))
|
||||
case errLog:
|
||||
assert.Equal(t, tc.errLogMessage, out, fmt.Sprintf("%s unexpected error response: expected %s got errLogMessage:%s", tc.desc, tc.errLogMessage, out))
|
||||
}
|
||||
sdkCall.Unset()
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestUnassignUserToGroupCmd(t *testing.T) {
|
||||
sdkMock := new(sdkmocks.SDK)
|
||||
cli.SetSDK(sdkMock)
|
||||
groupsCmd := cli.NewGroupsCmd()
|
||||
rootCmd := setFlags(groupsCmd)
|
||||
|
||||
userIds := fmt.Sprintf("[\"%s\"]", user.ID)
|
||||
|
||||
cases := []struct {
|
||||
desc string
|
||||
args []string
|
||||
logType outputLog
|
||||
errLogMessage string
|
||||
sdkErr errors.SDKError
|
||||
}{
|
||||
{
|
||||
desc: "unassign user successfully",
|
||||
args: []string{
|
||||
relation,
|
||||
userIds,
|
||||
group.ID,
|
||||
domainID,
|
||||
token,
|
||||
},
|
||||
logType: okLog,
|
||||
},
|
||||
{
|
||||
desc: "unassign user with invalid args",
|
||||
args: []string{
|
||||
relation,
|
||||
userIds,
|
||||
group.ID,
|
||||
domainID,
|
||||
token,
|
||||
extraArg,
|
||||
},
|
||||
logType: usageLog,
|
||||
},
|
||||
{
|
||||
desc: "unassign user with invalid json",
|
||||
args: []string{
|
||||
relation,
|
||||
fmt.Sprintf("[\"%s\"", user.ID),
|
||||
group.ID,
|
||||
domainID,
|
||||
token,
|
||||
},
|
||||
sdkErr: errors.NewSDKError(errors.New("unexpected end of JSON input")),
|
||||
errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.New("unexpected end of JSON input")),
|
||||
logType: errLog,
|
||||
},
|
||||
{
|
||||
desc: "unassign user with invalid group id",
|
||||
args: []string{
|
||||
relation,
|
||||
userIds,
|
||||
invalidID,
|
||||
domainID,
|
||||
token,
|
||||
},
|
||||
sdkErr: errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
|
||||
errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden)),
|
||||
logType: errLog,
|
||||
},
|
||||
{
|
||||
desc: "unassign user with invalid user id",
|
||||
args: []string{
|
||||
relation,
|
||||
fmt.Sprintf("[\"%s\"]", invalidID),
|
||||
group.ID,
|
||||
domainID,
|
||||
token,
|
||||
},
|
||||
sdkErr: errors.NewSDKErrorWithStatus(svcerr.ErrAddPolicies, http.StatusBadRequest),
|
||||
errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAddPolicies, http.StatusBadRequest)),
|
||||
logType: errLog,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.desc, func(t *testing.T) {
|
||||
sdkCall := sdkMock.On("RemoveUserFromGroup", tc.args[2], mock.Anything, tc.args[3], tc.args[4]).Return(tc.sdkErr)
|
||||
out := executeCommand(t, rootCmd, append([]string{unassignCmd, usrCmd}, tc.args...)...)
|
||||
switch tc.logType {
|
||||
case okLog:
|
||||
assert.True(t, strings.Contains(out, "ok"), fmt.Sprintf("%s unexpected response: expected success message, got: %v", tc.desc, out))
|
||||
case usageLog:
|
||||
assert.False(t, strings.Contains(out, rootCmd.Use), fmt.Sprintf("%s invalid usage: %s", tc.desc, out))
|
||||
case errLog:
|
||||
assert.Equal(t, tc.errLogMessage, out, fmt.Sprintf("%s unexpected error response: expected %s got errLogMessage:%s", tc.desc, tc.errLogMessage, out))
|
||||
}
|
||||
sdkCall.Unset()
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
+3
-85
@@ -371,40 +371,13 @@ var cmdUsers = []cobra.Command{
|
||||
},
|
||||
},
|
||||
{
|
||||
Use: "channels <user_id> <user_auth_token>",
|
||||
Short: "List channels",
|
||||
Long: "List channels of user\n" +
|
||||
"Usage:\n" +
|
||||
"\tsupermq-cli users channels <user_id> <user_auth_token>\n",
|
||||
Run: func(cmd *cobra.Command, args []string) {
|
||||
if len(args) != 2 {
|
||||
logUsageCmd(*cmd, cmd.Use)
|
||||
return
|
||||
}
|
||||
|
||||
pm := smqsdk.PageMetadata{
|
||||
Offset: Offset,
|
||||
Limit: Limit,
|
||||
}
|
||||
|
||||
cp, err := sdk.ListUserChannels(args[0], pm, args[1])
|
||||
if err != nil {
|
||||
logErrorCmd(*cmd, err)
|
||||
return
|
||||
}
|
||||
|
||||
logJSONCmd(*cmd, cp)
|
||||
},
|
||||
},
|
||||
|
||||
{
|
||||
Use: "clients <user_id> <user_auth_token>",
|
||||
Use: "clients <user_id> <domain_id> <user_auth_token>",
|
||||
Short: "List clients",
|
||||
Long: "List clients of user\n" +
|
||||
"Usage:\n" +
|
||||
"\tsupermq-cli users clients <user_id> <user_auth_token>\n",
|
||||
Run: func(cmd *cobra.Command, args []string) {
|
||||
if len(args) != 2 {
|
||||
if len(args) != 3 {
|
||||
logUsageCmd(*cmd, cmd.Use)
|
||||
return
|
||||
}
|
||||
@@ -414,7 +387,7 @@ var cmdUsers = []cobra.Command{
|
||||
Limit: Limit,
|
||||
}
|
||||
|
||||
tp, err := sdk.ListUserClients(args[0], pm, args[1])
|
||||
tp, err := sdk.ListUserClients(args[0], args[1], pm, args[2])
|
||||
if err != nil {
|
||||
logErrorCmd(*cmd, err)
|
||||
return
|
||||
@@ -423,61 +396,6 @@ var cmdUsers = []cobra.Command{
|
||||
logJSONCmd(*cmd, tp)
|
||||
},
|
||||
},
|
||||
|
||||
{
|
||||
Use: "domains <user_id> <user_auth_token>",
|
||||
Short: "List domains",
|
||||
Long: "List user's domains\n" +
|
||||
"Usage:\n" +
|
||||
"\tsupermq-cli users domains <user_id> <user_auth_token>\n",
|
||||
Run: func(cmd *cobra.Command, args []string) {
|
||||
if len(args) != 2 {
|
||||
logUsageCmd(*cmd, cmd.Use)
|
||||
return
|
||||
}
|
||||
|
||||
pm := smqsdk.PageMetadata{
|
||||
Offset: Offset,
|
||||
Limit: Limit,
|
||||
}
|
||||
|
||||
dp, err := sdk.ListUserDomains(args[0], pm, args[1])
|
||||
if err != nil {
|
||||
logErrorCmd(*cmd, err)
|
||||
return
|
||||
}
|
||||
|
||||
logJSONCmd(*cmd, dp)
|
||||
},
|
||||
},
|
||||
|
||||
{
|
||||
Use: "groups <user_id> <user_auth_token>",
|
||||
Short: "List groups",
|
||||
Long: "List groups of user\n" +
|
||||
"Usage:\n" +
|
||||
"\tsupermq-cli users groups <user_id> <user_auth_token>\n",
|
||||
Run: func(cmd *cobra.Command, args []string) {
|
||||
if len(args) != 2 {
|
||||
logUsageCmd(*cmd, cmd.Use)
|
||||
return
|
||||
}
|
||||
|
||||
pm := smqsdk.PageMetadata{
|
||||
Offset: Offset,
|
||||
Limit: Limit,
|
||||
}
|
||||
|
||||
users, err := sdk.ListUserGroups(args[0], pm, args[1])
|
||||
if err != nil {
|
||||
logErrorCmd(*cmd, err)
|
||||
return
|
||||
}
|
||||
|
||||
logJSONCmd(*cmd, users)
|
||||
},
|
||||
},
|
||||
|
||||
{
|
||||
Use: "search <query> <user_auth_token>",
|
||||
Short: "Search users",
|
||||
|
||||
@@ -1125,322 +1125,3 @@ func TestDeleteUserCmd(t *testing.T) {
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestListUserChannelsCmd(t *testing.T) {
|
||||
sdkMock := new(sdkmocks.SDK)
|
||||
cli.SetSDK(sdkMock)
|
||||
usersCmd := cli.NewUsersCmd()
|
||||
rootCmd := setFlags(usersCmd)
|
||||
ch := mgsdk.Channel{
|
||||
ID: testsutil.GenerateUUID(t),
|
||||
Name: "testchannel",
|
||||
}
|
||||
|
||||
var pg mgsdk.ChannelsPage
|
||||
|
||||
cases := []struct {
|
||||
desc string
|
||||
args []string
|
||||
sdkerr errors.SDKError
|
||||
errLogMessage string
|
||||
channel mgsdk.Channel
|
||||
page mgsdk.ChannelsPage
|
||||
output bool
|
||||
logType outputLog
|
||||
}{
|
||||
{
|
||||
desc: "list user channels successfully",
|
||||
args: []string{
|
||||
user.ID,
|
||||
validToken,
|
||||
},
|
||||
sdkerr: nil,
|
||||
logType: entityLog,
|
||||
page: mgsdk.ChannelsPage{
|
||||
Channels: []mgsdk.Channel{ch},
|
||||
},
|
||||
},
|
||||
{
|
||||
desc: "list user channels successfully with flags",
|
||||
args: []string{
|
||||
user.ID,
|
||||
validToken,
|
||||
"--offset=0",
|
||||
"--limit=5",
|
||||
},
|
||||
sdkerr: nil,
|
||||
logType: entityLog,
|
||||
page: mgsdk.ChannelsPage{
|
||||
Channels: []mgsdk.Channel{ch},
|
||||
},
|
||||
},
|
||||
{
|
||||
desc: "list user channels with invalid args",
|
||||
args: []string{
|
||||
user.ID,
|
||||
validToken,
|
||||
extraArg,
|
||||
},
|
||||
logType: usageLog,
|
||||
},
|
||||
{
|
||||
desc: "list user channels with invalid token",
|
||||
args: []string{
|
||||
user.ID,
|
||||
invalidToken,
|
||||
},
|
||||
logType: errLog,
|
||||
sdkerr: errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
|
||||
errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden)),
|
||||
},
|
||||
}
|
||||
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.desc, func(t *testing.T) {
|
||||
sdkCall := sdkMock.On("ListUserChannels", tc.args[0], mock.Anything, tc.args[1]).Return(tc.page, tc.sdkerr)
|
||||
out := executeCommand(t, rootCmd, append([]string{chansCmd}, tc.args...)...)
|
||||
|
||||
switch tc.logType {
|
||||
case errLog:
|
||||
assert.Equal(t, tc.errLogMessage, out, fmt.Sprintf("%s unexpected error response: expected %s got errLogMessage:%s", tc.desc, tc.errLogMessage, out))
|
||||
case usageLog:
|
||||
assert.False(t, strings.Contains(out, rootCmd.Use), fmt.Sprintf("%s invalid usage: %s", tc.desc, out))
|
||||
case entityLog:
|
||||
err := json.Unmarshal([]byte(out), &pg)
|
||||
if err != nil {
|
||||
t.Fatalf("json.Unmarshal failed: %v", err)
|
||||
}
|
||||
assert.Equal(t, tc.page, pg, fmt.Sprintf("%s unexpected response: expected: %v, got: %v", tc.desc, tc.page, pg))
|
||||
}
|
||||
|
||||
sdkCall.Unset()
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestListUserClientsCmd(t *testing.T) {
|
||||
sdkMock := new(sdkmocks.SDK)
|
||||
cli.SetSDK(sdkMock)
|
||||
usersCmd := cli.NewUsersCmd()
|
||||
rootCmd := setFlags(usersCmd)
|
||||
th := mgsdk.Client{
|
||||
ID: testsutil.GenerateUUID(t),
|
||||
Name: "testclient",
|
||||
}
|
||||
|
||||
var pg mgsdk.ClientsPage
|
||||
|
||||
cases := []struct {
|
||||
desc string
|
||||
args []string
|
||||
sdkerr errors.SDKError
|
||||
errLogMessage string
|
||||
client mgsdk.Client
|
||||
page mgsdk.ClientsPage
|
||||
logType outputLog
|
||||
}{
|
||||
{
|
||||
desc: "list user clients successfully",
|
||||
args: []string{
|
||||
user.ID,
|
||||
validToken,
|
||||
},
|
||||
sdkerr: nil,
|
||||
logType: entityLog,
|
||||
page: mgsdk.ClientsPage{
|
||||
Clients: []mgsdk.Client{th},
|
||||
},
|
||||
},
|
||||
{
|
||||
desc: "list user clients with invalid args",
|
||||
args: []string{
|
||||
user.ID,
|
||||
validToken,
|
||||
extraArg,
|
||||
},
|
||||
logType: usageLog,
|
||||
},
|
||||
{
|
||||
desc: "list user clients with invalid token",
|
||||
args: []string{
|
||||
user.ID,
|
||||
invalidToken,
|
||||
},
|
||||
logType: errLog,
|
||||
sdkerr: errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
|
||||
errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden)),
|
||||
},
|
||||
}
|
||||
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.desc, func(t *testing.T) {
|
||||
sdkCall := sdkMock.On("ListUserClients", tc.args[0], mock.Anything, tc.args[1]).Return(tc.page, tc.sdkerr)
|
||||
out := executeCommand(t, rootCmd, append([]string{cliCmd}, tc.args...)...)
|
||||
|
||||
switch tc.logType {
|
||||
case errLog:
|
||||
assert.Equal(t, tc.errLogMessage, out, fmt.Sprintf("%s unexpected error response: expected %s got errLogMessage:%s", tc.desc, tc.errLogMessage, out))
|
||||
case usageLog:
|
||||
assert.False(t, strings.Contains(out, rootCmd.Use), fmt.Sprintf("%s invalid usage: %s", tc.desc, out))
|
||||
case entityLog:
|
||||
err := json.Unmarshal([]byte(out), &pg)
|
||||
if err != nil {
|
||||
t.Fatalf("json.Unmarshal failed: %v", err)
|
||||
}
|
||||
assert.Equal(t, tc.page, pg, fmt.Sprintf("%s unexpected response: expected: %v, got: %v", tc.desc, tc.page, pg))
|
||||
}
|
||||
|
||||
sdkCall.Unset()
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestListUserDomainsCmd(t *testing.T) {
|
||||
sdkMock := new(sdkmocks.SDK)
|
||||
cli.SetSDK(sdkMock)
|
||||
usersCmd := cli.NewUsersCmd()
|
||||
rootCmd := setFlags(usersCmd)
|
||||
d := mgsdk.Domain{
|
||||
ID: testsutil.GenerateUUID(t),
|
||||
Name: "testdomain",
|
||||
}
|
||||
|
||||
cases := []struct {
|
||||
desc string
|
||||
args []string
|
||||
sdkerr errors.SDKError
|
||||
errLogMessage string
|
||||
logType outputLog
|
||||
page mgsdk.DomainsPage
|
||||
}{
|
||||
{
|
||||
desc: "list user domains successfully",
|
||||
args: []string{
|
||||
user.ID,
|
||||
validToken,
|
||||
},
|
||||
sdkerr: nil,
|
||||
logType: entityLog,
|
||||
page: mgsdk.DomainsPage{
|
||||
Domains: []mgsdk.Domain{d},
|
||||
},
|
||||
},
|
||||
{
|
||||
desc: "list user domains with invalid args",
|
||||
args: []string{
|
||||
user.ID,
|
||||
validToken,
|
||||
extraArg,
|
||||
},
|
||||
logType: usageLog,
|
||||
},
|
||||
{
|
||||
desc: "list user domains with invalid token",
|
||||
args: []string{
|
||||
user.ID,
|
||||
invalidToken,
|
||||
},
|
||||
logType: errLog,
|
||||
sdkerr: errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
|
||||
errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden)),
|
||||
},
|
||||
}
|
||||
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.desc, func(t *testing.T) {
|
||||
var pg mgsdk.DomainsPage
|
||||
sdkCall := sdkMock.On("ListUserDomains", tc.args[0], mock.Anything, tc.args[1]).Return(tc.page, tc.sdkerr)
|
||||
out := executeCommand(t, rootCmd, append([]string{domsCmd}, tc.args...)...)
|
||||
|
||||
switch tc.logType {
|
||||
case errLog:
|
||||
assert.Equal(t, tc.errLogMessage, out, fmt.Sprintf("%s unexpected error response: expected %s got errLogMessage:%s", tc.desc, tc.errLogMessage, out))
|
||||
case usageLog:
|
||||
assert.False(t, strings.Contains(out, rootCmd.Use), fmt.Sprintf("%s invalid usage: %s", tc.desc, out))
|
||||
case entityLog:
|
||||
err := json.Unmarshal([]byte(out), &pg)
|
||||
if err != nil {
|
||||
t.Fatalf("json.Unmarshal failed: %v", err)
|
||||
}
|
||||
assert.Equal(t, tc.page, pg, fmt.Sprintf("%s unexpected response: expected: %v, got: %v", tc.desc, tc.page, pg))
|
||||
}
|
||||
|
||||
sdkCall.Unset()
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestListUserGroupsCmd(t *testing.T) {
|
||||
sdkMock := new(sdkmocks.SDK)
|
||||
cli.SetSDK(sdkMock)
|
||||
usersCmd := cli.NewUsersCmd()
|
||||
rootCmd := setFlags(usersCmd)
|
||||
g := mgsdk.Group{
|
||||
ID: testsutil.GenerateUUID(t),
|
||||
Name: "testgroup",
|
||||
}
|
||||
|
||||
cases := []struct {
|
||||
desc string
|
||||
args []string
|
||||
sdkerr errors.SDKError
|
||||
errLogMessage string
|
||||
logType outputLog
|
||||
page mgsdk.GroupsPage
|
||||
}{
|
||||
{
|
||||
desc: "list user groups successfully",
|
||||
args: []string{
|
||||
user.ID,
|
||||
validToken,
|
||||
},
|
||||
sdkerr: nil,
|
||||
logType: entityLog,
|
||||
page: mgsdk.GroupsPage{
|
||||
Groups: []mgsdk.Group{g},
|
||||
},
|
||||
},
|
||||
{
|
||||
desc: "list user groups with invalid args",
|
||||
args: []string{
|
||||
user.ID,
|
||||
validToken,
|
||||
extraArg,
|
||||
},
|
||||
logType: usageLog,
|
||||
},
|
||||
{
|
||||
desc: "list user groups with invalid token",
|
||||
args: []string{
|
||||
user.ID,
|
||||
invalidToken,
|
||||
},
|
||||
logType: errLog,
|
||||
sdkerr: errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden),
|
||||
errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusForbidden)),
|
||||
},
|
||||
}
|
||||
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.desc, func(t *testing.T) {
|
||||
var pg mgsdk.GroupsPage
|
||||
sdkCall := sdkMock.On("ListUserGroups", tc.args[0], mock.Anything, tc.args[1]).Return(tc.page, tc.sdkerr)
|
||||
out := executeCommand(t, rootCmd, append([]string{grpCmd}, tc.args...)...)
|
||||
|
||||
switch tc.logType {
|
||||
case errLog:
|
||||
assert.Equal(t, tc.errLogMessage, out, fmt.Sprintf("%s unexpected error response: expected %s got errLogMessage:%s", tc.desc, tc.errLogMessage, out))
|
||||
case usageLog:
|
||||
assert.False(t, strings.Contains(out, rootCmd.Use), fmt.Sprintf("%s invalid usage: %s", tc.desc, out))
|
||||
case entityLog:
|
||||
err := json.Unmarshal([]byte(out), &pg)
|
||||
if err != nil {
|
||||
t.Fatalf("json.Unmarshal failed: %v", err)
|
||||
}
|
||||
assert.Equal(t, tc.page, pg, fmt.Sprintf("%s unexpected response: expected: %v, got: %v", tc.desc, tc.page, pg))
|
||||
}
|
||||
|
||||
sdkCall.Unset()
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user