MG-887 - Create certs, messages, health, consumers CLI tests (#2350)

Signed-off-by: nyagamunene <stevenyaga2014@gmail.com>

cli/certs_test.go

@@ -0,0 +1,258 @@
+// Copyright (c) Abstract Machines
+// SPDX-License-Identifier: Apache-2.0
+
+package cli_test
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/absmach/magistrala/cli"
+	"github.com/absmach/magistrala/pkg/errors"
+	svcerr "github.com/absmach/magistrala/pkg/errors/service"
+	mgsdk "github.com/absmach/magistrala/pkg/sdk/go"
+	sdkmocks "github.com/absmach/magistrala/pkg/sdk/mocks"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+)
+
+var cert = mgsdk.Cert{
+	ThingID: thing.ID,
+}
+
+func TestGetCertCmd(t *testing.T) {
+	sdkMock := new(sdkmocks.SDK)
+	cli.SetSDK(sdkMock)
+	certCmd := cli.NewCertsCmd()
+	rootCmd := setFlags(certCmd)
+
+	var ct mgsdk.Cert
+	var cts mgsdk.CertSerials
+
+	cases := []struct {
+		desc          string
+		args          []string
+		sdkErr        errors.SDKError
+		errLogMessage string
+		logType       outputLog
+		serials       mgsdk.CertSerials
+		cert          mgsdk.Cert
+	}{
+		{
+			desc: "get cert successfully",
+			args: []string{
+				"thing",
+				thing.ID,
+				validToken,
+			},
+			logType: entityLog,
+			serials: mgsdk.CertSerials{
+				PageRes: mgsdk.PageRes{
+					Total:  1,
+					Offset: 0,
+					Limit:  10,
+				},
+				Certs: []mgsdk.Cert{cert},
+			},
+		},
+		{
+			desc: "get cert successfully by id",
+			args: []string{
+				thing.ID,
+				validToken,
+			},
+			logType: entityLog,
+			cert:    cert,
+		},
+		{
+			desc: "get cert with invalid token",
+			args: []string{
+				"thing",
+				thing.ID,
+				invalidToken,
+			},
+			sdkErr:        errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusUnauthorized),
+			errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusUnauthorized)),
+			logType:       errLog,
+		},
+		{
+			desc: "get cert by id with invalid token",
+			args: []string{
+				thing.ID,
+				invalidToken,
+			},
+			sdkErr:        errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusUnauthorized),
+			errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrAuthorization, http.StatusUnauthorized)),
+			logType:       errLog,
+		},
+		{
+			desc: "get cert with invalid args",
+			args: []string{
+				thing.ID,
+			},
+			logType: usageLog,
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.desc, func(t *testing.T) {
+			sdkCall := sdkMock.On("ViewCertByThing", mock.Anything, mock.Anything).Return(tc.serials, tc.sdkErr)
+			sdkCall1 := sdkMock.On("ViewCert", mock.Anything, mock.Anything).Return(tc.cert, tc.sdkErr)
+			out := executeCommand(t, rootCmd, append([]string{getCmd}, tc.args...)...)
+			switch tc.logType {
+			case entityLog:
+				if tc.args[1] == "thing" {
+					err := json.Unmarshal([]byte(out), &cts)
+					assert.Nil(t, err)
+					assert.Equal(t, tc.serials, cts, fmt.Sprintf("%s unexpected response: expected: %v, got: %v", tc.desc, tc.serials, cts))
+				} else {
+					err := json.Unmarshal([]byte(out), &ct)
+					assert.Nil(t, err)
+					assert.Equal(t, tc.cert, ct, fmt.Sprintf("%s unexpected response: expected: %v, got: %v", tc.desc, tc.cert, ct))
+				}
+
+			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()
+		})
+	}
+}
+
+func TestRevokeCertCmd(t *testing.T) {
+	sdkMock := new(sdkmocks.SDK)
+	cli.SetSDK(sdkMock)
+	certCmd := cli.NewCertsCmd()
+	rootCmd := setFlags(certCmd)
+
+	revokeTime := time.Now()
+
+	cases := []struct {
+		desc          string
+		args          []string
+		sdkErr        errors.SDKError
+		logType       outputLog
+		errLogMessage string
+		time          time.Time
+		response      string
+	}{
+		{
+			desc: "revoke cert successfully",
+			args: []string{
+				thing.ID,
+				token,
+			},
+			logType:  revokeLog,
+			response: fmt.Sprintf("\nrevoked: %s\n\n", revokeTime),
+			time:     revokeTime,
+		},
+		{
+			desc: "revoke cert with invalid args",
+			args: []string{
+				thing.ID,
+				token,
+				extraArg,
+			},
+			logType: usageLog,
+		},
+		{
+			desc: "revoke cert with invalid token",
+			args: []string{
+				thing.ID,
+				invalidToken,
+			},
+			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("RevokeCert", tc.args[0], tc.args[1]).Return(tc.time, tc.sdkErr)
+			out := executeCommand(t, rootCmd, append([]string{revokeCmd}, tc.args...)...)
+
+			switch tc.logType {
+			case revokeLog:
+				assert.Equal(t, tc.response, out, fmt.Sprintf("%s unexpected error response: expected %s got errLogMessage:%s", tc.desc, tc.response, 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))
+			case usageLog:
+				assert.False(t, strings.Contains(out, rootCmd.Use), fmt.Sprintf("%s invalid usage: %s", tc.desc, out))
+			}
+			sdkCall.Unset()
+		})
+	}
+}
+
+func TestIssueCertCmd(t *testing.T) {
+	sdkMock := new(sdkmocks.SDK)
+	cli.SetSDK(sdkMock)
+	certCmd := cli.NewCertsCmd()
+	rootCmd := setFlags(certCmd)
+
+	var ct mgsdk.Cert
+	cases := []struct {
+		desc          string
+		args          []string
+		logType       outputLog
+		errLogMessage string
+		sdkErr        errors.SDKError
+		cert          mgsdk.Cert
+	}{
+		{
+			desc: "issue cert successfully",
+			args: []string{
+				thing.ID,
+				validToken,
+			},
+			cert:    cert,
+			logType: entityLog,
+		},
+		{
+			desc: "issue cert with invalid args",
+			args: []string{
+				thing.ID,
+				validToken,
+				extraArg,
+			},
+			logType: usageLog,
+		},
+		{
+			desc: "issue cert with invalid token",
+			args: []string{
+				thing.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("IssueCert", mock.Anything, mock.Anything, tc.args[1]).Return(tc.cert, tc.sdkErr)
+			out := executeCommand(t, rootCmd, append([]string{issueCmd}, tc.args...)...)
+
+			switch tc.logType {
+			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))
+			case entityLog:
+				err := json.Unmarshal([]byte(out), &ct)
+				assert.Nil(t, err)
+				assert.Equal(t, tc.cert, ct, fmt.Sprintf("%s unexpected response: expected: %v, got: %v", tc.desc, tc.cert, ct))
+			}
+			sdkCall.Unset()
+		})
+	}
+}

cli/commands_test.go

@@ -3,31 +3,58 @@
 
 package cli_test
 
+// CRUD and common commands
+const (
+	createCmd  = "create"
+	updateCmd  = "update"
+	getCmd     = "get"
+	enableCmd  = "enable"
+	disableCmd = "disable"
+	updCmd     = "update"
+	delCmd     = "delete"
+	rmCmd      = "remove"
+)
+
+// Users commands
 const (
-	createCmd     = "create"
-	getCmd        = "get"
 	tokCmd        = "token"
 	refTokCmd     = "refreshtoken"
-	updCmd        = "update"
 	profCmd       = "profile"
 	resPassReqCmd = "resetpasswordrequest"
 	resPassCmd    = "resetpassword"
 	passCmd       = "password"
-	enableCmd     = "enable"
-	disableCmd    = "disable"
-	delCmd        = "delete"
-	chansCmd      = "channels"
-	thsCmd        = "things"
 	domsCmd       = "domains"
-	grpCmd        = "groups"
-	connsCmd      = "connections"
-	connCmd       = "connect"
-	disconnCmd    = "disconnect"
-	shrCmd        = "share"
-	unshrCmd      = "unshare"
-	childCmd      = "children"
-	parentCmd     = "parents"
-	usrCmd        = "users"
-	assignCmd     = "assign"
-	unassignCmd   = "unassign"
+)
+
+// Things commands
+const (
+	thsCmd     = "things"
+	connsCmd   = "connections"
+	connCmd    = "connect"
+	disconnCmd = "disconnect"
+	shrCmd     = "share"
+	unshrCmd   = "unshare"
+)
+
+// Groups and channels commands
+const (
+	chansCmd    = "channels"
+	grpCmd      = "groups"
+	childCmd    = "children"
+	parentCmd   = "parents"
+	usrCmd      = "users"
+	assignCmd   = "assign"
+	unassignCmd = "unassign"
+)
+
+// Certs commands
+const (
+	revokeCmd = "revoke"
+	issueCmd  = "issue"
+)
+
+// Messages commands
+const (
+	sendCmd = "send"
+	readCmd = "read"
 )

cli/consumers_test.go

@@ -0,0 +1,273 @@
+// Copyright (c) Abstract Machines
+// SPDX-License-Identifier: Apache-2.0
+
+package cli_test
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strings"
+	"testing"
+
+	"github.com/absmach/magistrala/cli"
+	"github.com/absmach/magistrala/internal/testsutil"
+	"github.com/absmach/magistrala/pkg/errors"
+	svcerr "github.com/absmach/magistrala/pkg/errors/service"
+	mgsdk "github.com/absmach/magistrala/pkg/sdk/go"
+	sdkmocks "github.com/absmach/magistrala/pkg/sdk/mocks"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+)
+
+var subscription = mgsdk.Subscription{
+	ID:      testsutil.GenerateUUID(&testing.T{}),
+	OwnerID: user.ID,
+	Topic:   "topic",
+	Contact: "identity@example.com",
+}
+
+func TestCreateSubscriptionCmd(t *testing.T) {
+	sdkMock := new(sdkmocks.SDK)
+	cli.SetSDK(sdkMock)
+	subCmd := cli.NewSubscriptionCmd()
+	rootCmd := setFlags(subCmd)
+
+	cases := []struct {
+		desc          string
+		args          []string
+		logType       outputLog
+		errLogMessage string
+		sdkErr        errors.SDKError
+		response      string
+		id            string
+	}{
+		{
+			desc: "create subscription successfully",
+			args: []string{
+				subscription.Topic,
+				subscription.Contact,
+				validToken,
+			},
+			id:       user.ID,
+			response: fmt.Sprintf("\ncreated: %s\n\n", user.ID),
+			logType:  createLog,
+		},
+		{
+			desc: "create subscription with invalid args",
+			args: []string{
+				subscription.Topic,
+				subscription.Contact,
+				validToken,
+				extraArg,
+			},
+			logType: usageLog,
+		},
+		{
+			desc: "create subscription with invalid token",
+			args: []string{
+				subscription.Topic,
+				subscription.Contact,
+				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("CreateSubscription", tc.args[0], tc.args[1], tc.args[2]).Return(tc.id, tc.sdkErr)
+			out := executeCommand(t, rootCmd, append([]string{createCmd}, tc.args...)...)
+
+			switch tc.logType {
+			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))
+			case createLog:
+				assert.Equal(t, tc.response, out, fmt.Sprintf("%s unexpected error response: expected %s got errLogMessage:%s", tc.desc, tc.response, out))
+			}
+			sdkCall.Unset()
+		})
+	}
+}
+
+func TestGetSubscriptionsCmd(t *testing.T) {
+	sdkMock := new(sdkmocks.SDK)
+	cli.SetSDK(sdkMock)
+	subCmd := cli.NewSubscriptionCmd()
+	rootCmd := setFlags(subCmd)
+
+	var sub mgsdk.Subscription
+	var page mgsdk.SubscriptionPage
+
+	cases := []struct {
+		desc          string
+		args          []string
+		sdkErr        errors.SDKError
+		page          mgsdk.SubscriptionPage
+		subscription  mgsdk.Subscription
+		logType       outputLog
+		errLogMessage string
+	}{
+		{
+			desc: "get all subscriptions successfully",
+			args: []string{
+				all,
+				token,
+			},
+			page: mgsdk.SubscriptionPage{
+				Subscriptions: []mgsdk.Subscription{subscription},
+			},
+			logType: entityLog,
+		},
+		{
+			desc: "get subscription with id",
+			args: []string{
+				subscription.ID,
+				token,
+			},
+			logType:      entityLog,
+			subscription: subscription,
+		},
+		{
+			desc: "get subscriptions with invalid args",
+			args: []string{
+				all,
+				token,
+				extraArg,
+			},
+			logType: usageLog,
+		},
+		{
+			desc: "get all subscriptions with invalid token",
+			args: []string{
+				all,
+				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 subscription without domain token",
+			args: []string{
+				subscription.ID,
+				tokenWithoutDomain,
+			},
+			logType:       errLog,
+			sdkErr:        errors.NewSDKErrorWithStatus(svcerr.ErrDomainAuthorization, http.StatusForbidden),
+			errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(svcerr.ErrDomainAuthorization, http.StatusForbidden)),
+		},
+		{
+			desc: "get subscription with invalid id",
+			args: []string{
+				invalidID,
+				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("ViewSubscription", tc.args[0], tc.args[1]).Return(tc.subscription, tc.sdkErr)
+			sdkCall1 := sdkMock.On("ListSubscriptions", mock.Anything, tc.args[1]).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), &sub)
+					assert.Nil(t, err)
+					assert.Equal(t, tc.subscription, sub, fmt.Sprintf("%v unexpected response, expected: %v, got: %v", tc.desc, tc.subscription, sub))
+				}
+			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()
+		})
+	}
+}
+
+func TestRemoveSubscriptionCmd(t *testing.T) {
+	sdkMock := new(sdkmocks.SDK)
+	cli.SetSDK(sdkMock)
+	subCmd := cli.NewSubscriptionCmd()
+	rootCmd := setFlags(subCmd)
+
+	cases := []struct {
+		desc          string
+		args          []string
+		sdkErr        errors.SDKError
+		logType       outputLog
+		errLogMessage string
+	}{
+		{
+			desc: "remove subscription successfully",
+			args: []string{
+				subscription.ID,
+				token,
+			},
+			logType: okLog,
+		},
+		{
+			desc: "remove subscription with invalid args",
+			args: []string{
+				subscription.ID,
+				token,
+				extraArg,
+			},
+			logType: usageLog,
+		},
+		{
+			desc: "remove subscription with invalid subscription id",
+			args: []string{
+				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: "remove subscription with invalid token",
+			args: []string{
+				subscription.ID,
+				invalidToken,
+			},
+			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("DeleteSubscription", tc.args[0], tc.args[1]).Return(tc.sdkErr)
+			out := executeCommand(t, rootCmd, append([]string{rmCmd}, 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 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()
+		})
+	}
+}

cli/health_test.go

@@ -0,0 +1,84 @@
+// Copyright (c) Abstract Machines
+// SPDX-License-Identifier: Apache-2.0
+
+package cli_test
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/absmach/magistrala/cli"
+	"github.com/absmach/magistrala/pkg/errors"
+	mgsdk "github.com/absmach/magistrala/pkg/sdk/go"
+	sdkmocks "github.com/absmach/magistrala/pkg/sdk/mocks"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+)
+
+func TestHealthCmd(t *testing.T) {
+	sdkMock := new(sdkmocks.SDK)
+	cli.SetSDK(sdkMock)
+	healthCmd := cli.NewHealthCmd()
+	rootCmd := setFlags(healthCmd)
+	service := "users"
+
+	var health mgsdk.HealthInfo
+	cases := []struct {
+		desc          string
+		args          []string
+		logType       outputLog
+		errLogMessage string
+		health        mgsdk.HealthInfo
+		sdkErr        errors.SDKError
+	}{
+		{
+			desc: "Check health successfully",
+			args: []string{
+				service,
+			},
+			logType: entityLog,
+			health: mgsdk.HealthInfo{
+				Status:      "pass",
+				Description: "users service",
+			},
+		},
+		{
+			desc: "Check health with invalid args",
+			args: []string{
+				service,
+				extraArg,
+			},
+			logType: usageLog,
+		},
+		{
+			desc: "Check health with invalid service",
+			args: []string{
+				"invalid",
+			},
+			sdkErr:        errors.NewSDKErrorWithStatus(errors.New("unsupported protocol scheme"), 306),
+			errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(errors.New("unsupported protocol scheme"), 306)),
+			logType:       errLog,
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.desc, func(t *testing.T) {
+			sdkCall := sdkMock.On("Health", mock.Anything).Return(tc.health, tc.sdkErr)
+			out := executeCommand(t, rootCmd, tc.args...)
+
+			switch tc.logType {
+			case entityLog:
+				err := json.Unmarshal([]byte(out), &health)
+				assert.Nil(t, err)
+				assert.Equal(t, tc.health, health, fmt.Sprintf("%s unexpected response: expected: %v, got: %v", tc.desc, tc.health, health))
+			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.True(t, strings.Contains(out, rootCmd.Use), fmt.Sprintf("%s invalid usage: %s", tc.desc, out))
+			}
+			sdkCall.Unset()
+		})
+	}
+}

cli/message.go

@@ -10,7 +10,7 @@ import (
 
 var cmdMessages = []cobra.Command{
 	{
-		Use:   "send <channel_id.subtopic> <JSON_string> <thing_key>",
+		Use:   "send <channel_id.subtopic> <JSON_string> <thing_secret>",
 		Short: "Send messages",
 		Long:  `Sends message on the channel`,
 		Run: func(cmd *cobra.Command, args []string) {

cli/message_test.go

@@ -0,0 +1,162 @@
+// Copyright (c) Abstract Machines
+// SPDX-License-Identifier: Apache-2.0
+
+package cli_test
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strings"
+	"testing"
+
+	"github.com/absmach/magistrala/cli"
+	"github.com/absmach/magistrala/pkg/errors"
+	svcerr "github.com/absmach/magistrala/pkg/errors/service"
+	mgsdk "github.com/absmach/magistrala/pkg/sdk/go"
+	sdkmocks "github.com/absmach/magistrala/pkg/sdk/mocks"
+	"github.com/absmach/magistrala/pkg/transformers/senml"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+)
+
+func TestSendMesageCmd(t *testing.T) {
+	sdkMock := new(sdkmocks.SDK)
+	cli.SetSDK(sdkMock)
+	messageCmd := cli.NewMessagesCmd()
+	rootCmd := setFlags(messageCmd)
+
+	message := "[{\"bn\":\"Dev1\",\"n\":\"temp\",\"v\":20}, {\"n\":\"hum\",\"v\":40}, {\"bn\":\"Dev2\", \"n\":\"temp\",\"v\":20}, {\"n\":\"hum\",\"v\":40}]"
+
+	cases := []struct {
+		desc          string
+		args          []string
+		logType       outputLog
+		errLogMessage string
+		sdkErr        errors.SDKError
+	}{
+		{
+			desc: "send message successfully",
+			args: []string{
+				channel.ID,
+				message,
+				thing.Credentials.Secret,
+			},
+			logType: okLog,
+		},
+		{
+			desc: "send message with invalid args",
+			args: []string{
+				channel.ID,
+				message,
+				thing.Credentials.Secret,
+				extraArg,
+			},
+			logType: usageLog,
+		},
+		{
+			desc: "send message with invalid thing secret",
+			args: []string{
+				channel.ID,
+				message,
+				"invalid_secret",
+			},
+			sdkErr:        errors.NewSDKErrorWithStatus(errors.Wrap(svcerr.ErrAuthentication, errors.Wrap(svcerr.ErrAuthorization, svcerr.ErrNotFound)), http.StatusBadRequest),
+			errLogMessage: fmt.Sprintf("\nerror: %s\n\n", errors.NewSDKErrorWithStatus(errors.Wrap(svcerr.ErrAuthentication, errors.Wrap(svcerr.ErrAuthorization, svcerr.ErrNotFound)), http.StatusBadRequest)),
+			logType:       errLog,
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.desc, func(t *testing.T) {
+			sdkCall := sdkMock.On("SendMessage", tc.args[0], tc.args[1], tc.args[2]).Return(tc.sdkErr)
+			out := executeCommand(t, rootCmd, append([]string{sendCmd}, 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 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()
+		})
+	}
+}
+
+func TestReadMesageCmd(t *testing.T) {
+	sdkMock := new(sdkmocks.SDK)
+	cli.SetSDK(sdkMock)
+	messageCmd := cli.NewMessagesCmd()
+	rootCmd := setFlags(messageCmd)
+
+	var mp mgsdk.MessagesPage
+	cases := []struct {
+		desc          string
+		args          []string
+		logType       outputLog
+		errLogMessage string
+		sdkErr        errors.SDKError
+		page          mgsdk.MessagesPage
+	}{
+		{
+			desc: "read message successfully",
+			args: []string{
+				channel.ID,
+				validToken,
+			},
+			page: mgsdk.MessagesPage{
+				PageRes: mgsdk.PageRes{
+					Total:  1,
+					Offset: 0,
+					Limit:  10,
+				},
+				Messages: []senml.Message{
+					{
+						Channel: channel.ID,
+					},
+				},
+			},
+			logType: entityLog,
+		},
+		{
+			desc: "read message with invalid args",
+			args: []string{
+				channel.ID,
+				validToken,
+				extraArg,
+			},
+			logType: usageLog,
+		},
+		{
+			desc: "read message with invalid token",
+			args: []string{
+				channel.ID,
+				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("ReadMessages", mock.Anything, tc.args[0], tc.args[1]).Return(tc.page, tc.sdkErr)
+			out := executeCommand(t, rootCmd, append([]string{readCmd}, tc.args...)...)
+
+			switch tc.logType {
+			case entityLog:
+				err := json.Unmarshal([]byte(out), &mp)
+				assert.Nil(t, err)
+				assert.Equal(t, tc.page, mp, fmt.Sprintf("%s unexpected response: expected: %v, got: %v", tc.desc, tc.page, mp))
+			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()
+		})
+	}
+}

cli/setup_test.go

@@ -19,6 +19,8 @@ const (
 	errLog
 	entityLog
 	okLog
+	createLog
+	revokeLog
 )
 
 func executeCommand(t *testing.T, root *cobra.Command, args ...string) string {

cli/things_test.go

@@ -31,8 +31,11 @@ var (
 )
 
 var thing = mgsdk.Thing{
-	ID:       testsutil.GenerateUUID(&testing.T{}),
-	Name:     "testthing",
+	ID:   testsutil.GenerateUUID(&testing.T{}),
+	Name: "testthing",
+	Credentials: mgsdk.Credentials{
+		Secret: "secret",
+	},
 	DomainID: testsutil.GenerateUUID(&testing.T{}),
 	Status:   mgclients.EnabledStatus.String(),
 }

tools/config/.golangci.yml

@@ -12,6 +12,10 @@ issues:
   exclude:
     - "string `Usage:\n` has (\\d+) occurrences, make it a constant"
     - "string `For example:\n` has (\\d+) occurrences, make it a constant"
+  exclude-rules:
+    - path: cli/commands_test.go
+      linters:
+        - godot
 
 linters-settings:
   importas: