From f885f834b2eeac41cabc4f79ff9d61bc5a51dce1 Mon Sep 17 00:00:00 2001 From: Felix Gateru Date: Wed, 8 Jan 2025 15:33:04 +0300 Subject: [PATCH 01/11] refactor: aligh bootstrap with new supermq architecture Signed-off-by: Felix Gateru --- Makefile | 2 +- docker/addons/bootstrap/docker-compose.yml | 10 +++++----- docker/nginx/entrypoint.sh | 2 +- 3 files changed, 7 insertions(+), 7 deletions(-) diff --git a/Makefile b/Makefile index db30d18f1..d02e98253 100644 --- a/Makefile +++ b/Makefile @@ -252,5 +252,5 @@ run: check_certs run_addons: check_certs $(foreach SVC,$(RUN_ADDON_ARGS),$(if $(filter $(SVC),$(ADDON_SERVICES) $(EXTERNAL_SERVICES)),,$(error Invalid Service $(SVC)))) @for SVC in $(RUN_ADDON_ARGS); do \ - MG_ADDONS_CERTS_PATH_PREFIX="../." docker compose -f docker/addons/$$SVC/docker-compose.yml -p $(DOCKER_PROJECT) --env-file ./docker/.env $(DOCKER_COMPOSE_COMMAND) $(args) & \ + SMQ_ADDONS_CERTS_PATH_PREFIX="../." docker compose -f docker/addons/$$SVC/docker-compose.yml -p $(DOCKER_PROJECT) --env-file ./docker/.env $(DOCKER_COMPOSE_COMMAND) $(args) & \ done diff --git a/docker/addons/bootstrap/docker-compose.yml b/docker/addons/bootstrap/docker-compose.yml index 5296df8c6..d5280140d 100644 --- a/docker/addons/bootstrap/docker-compose.yml +++ b/docker/addons/bootstrap/docker-compose.yml @@ -18,9 +18,9 @@ services: container_name: magistrala-bootstrap-db restart: on-failure environment: - POSTGRES_USER: ${MG_BOOTSTRAP_DB_USER} - POSTGRES_PASSWORD: ${MG_BOOTSTRAP_DB_PASS} - POSTGRES_DB: ${MG_BOOTSTRAP_DB_NAME} + POSTGRES_USER: ${SMQ_BOOTSTRAP_DB_USER} + POSTGRES_PASSWORD: ${SMQ_BOOTSTRAP_DB_PASS} + POSTGRES_DB: ${SMQ_BOOTSTRAP_DB_NAME} networks: - magistrala-base-net volumes: @@ -33,7 +33,7 @@ services: - bootstrap-db restart: on-failure ports: - - ${MG_BOOTSTRAP_HTTP_PORT}:${MG_BOOTSTRAP_HTTP_PORT} + - ${SMQ_BOOTSTRAP_HTTP_PORT}:${SMQ_BOOTSTRAP_HTTP_PORT} environment: MG_BOOTSTRAP_LOG_LEVEL: ${MG_BOOTSTRAP_LOG_LEVEL} MG_BOOTSTRAP_ENCRYPT_KEY: ${MG_BOOTSTRAP_ENCRYPT_KEY} @@ -88,4 +88,4 @@ services: source: ${MG_ADDONS_CERTS_PATH_PREFIX}${SMQ_AUTH_GRPC_SERVER_CA_CERTS:-./ssl/certs/dummy/server_ca} target: /auth-grpc-server-ca${SMQ_AUTH_GRPC_SERVER_CA_CERTS:+.crt} bind: - create_host_path: true + create_host_path: true \ No newline at end of file diff --git a/docker/nginx/entrypoint.sh b/docker/nginx/entrypoint.sh index fa6d32672..5474a6baa 100755 --- a/docker/nginx/entrypoint.sh +++ b/docker/nginx/entrypoint.sh @@ -24,4 +24,4 @@ envsubst ' ${SMQ_INVITATIONS_HTTP_PORT} ${SMQ_WS_ADAPTER_HTTP_PORT}' /etc/nginx/nginx.conf -exec nginx -g "daemon off;" +exec nginx -g "daemon off;" \ No newline at end of file From 5f7b12d9336537bfc541d029903c196eb0488885 Mon Sep 17 00:00:00 2001 From: Felix Gateru Date: Thu, 9 Jan 2025 09:19:00 +0300 Subject: [PATCH 02/11] refactor: rename env variables Signed-off-by: Felix Gateru --- Makefile | 2 +- docker/addons/bootstrap/docker-compose.yml | 8 ++++---- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/Makefile b/Makefile index d02e98253..db30d18f1 100644 --- a/Makefile +++ b/Makefile @@ -252,5 +252,5 @@ run: check_certs run_addons: check_certs $(foreach SVC,$(RUN_ADDON_ARGS),$(if $(filter $(SVC),$(ADDON_SERVICES) $(EXTERNAL_SERVICES)),,$(error Invalid Service $(SVC)))) @for SVC in $(RUN_ADDON_ARGS); do \ - SMQ_ADDONS_CERTS_PATH_PREFIX="../." docker compose -f docker/addons/$$SVC/docker-compose.yml -p $(DOCKER_PROJECT) --env-file ./docker/.env $(DOCKER_COMPOSE_COMMAND) $(args) & \ + MG_ADDONS_CERTS_PATH_PREFIX="../." docker compose -f docker/addons/$$SVC/docker-compose.yml -p $(DOCKER_PROJECT) --env-file ./docker/.env $(DOCKER_COMPOSE_COMMAND) $(args) & \ done diff --git a/docker/addons/bootstrap/docker-compose.yml b/docker/addons/bootstrap/docker-compose.yml index d5280140d..d881cf1d8 100644 --- a/docker/addons/bootstrap/docker-compose.yml +++ b/docker/addons/bootstrap/docker-compose.yml @@ -18,9 +18,9 @@ services: container_name: magistrala-bootstrap-db restart: on-failure environment: - POSTGRES_USER: ${SMQ_BOOTSTRAP_DB_USER} - POSTGRES_PASSWORD: ${SMQ_BOOTSTRAP_DB_PASS} - POSTGRES_DB: ${SMQ_BOOTSTRAP_DB_NAME} + POSTGRES_USER: ${MG_BOOTSTRAP_DB_USER} + POSTGRES_PASSWORD: ${MG_BOOTSTRAP_DB_PASS} + POSTGRES_DB: ${MG_BOOTSTRAP_DB_NAME} networks: - magistrala-base-net volumes: @@ -33,7 +33,7 @@ services: - bootstrap-db restart: on-failure ports: - - ${SMQ_BOOTSTRAP_HTTP_PORT}:${SMQ_BOOTSTRAP_HTTP_PORT} + - ${MG_BOOTSTRAP_HTTP_PORT}:${MG_BOOTSTRAP_HTTP_PORT} environment: MG_BOOTSTRAP_LOG_LEVEL: ${MG_BOOTSTRAP_LOG_LEVEL} MG_BOOTSTRAP_ENCRYPT_KEY: ${MG_BOOTSTRAP_ENCRYPT_KEY} From 308325d30fc15a4e0555dbc4ffe92a12563592ee Mon Sep 17 00:00:00 2001 From: Felix Gateru Date: Thu, 9 Jan 2025 15:20:10 +0300 Subject: [PATCH 03/11] style: add empty line to config files and bootstrap docker compose file Signed-off-by: Felix Gateru --- docker/addons/bootstrap/docker-compose.yml | 2 +- docker/nginx/entrypoint.sh | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/docker/addons/bootstrap/docker-compose.yml b/docker/addons/bootstrap/docker-compose.yml index d881cf1d8..5296df8c6 100644 --- a/docker/addons/bootstrap/docker-compose.yml +++ b/docker/addons/bootstrap/docker-compose.yml @@ -88,4 +88,4 @@ services: source: ${MG_ADDONS_CERTS_PATH_PREFIX}${SMQ_AUTH_GRPC_SERVER_CA_CERTS:-./ssl/certs/dummy/server_ca} target: /auth-grpc-server-ca${SMQ_AUTH_GRPC_SERVER_CA_CERTS:+.crt} bind: - create_host_path: true \ No newline at end of file + create_host_path: true diff --git a/docker/nginx/entrypoint.sh b/docker/nginx/entrypoint.sh index 5474a6baa..fa6d32672 100755 --- a/docker/nginx/entrypoint.sh +++ b/docker/nginx/entrypoint.sh @@ -24,4 +24,4 @@ envsubst ' ${SMQ_INVITATIONS_HTTP_PORT} ${SMQ_WS_ADAPTER_HTTP_PORT}' /etc/nginx/nginx.conf -exec nginx -g "daemon off;" \ No newline at end of file +exec nginx -g "daemon off;" From d66071dacc7e507fadefc52eea763e75e43ee520 Mon Sep 17 00:00:00 2001 From: Felix Gateru Date: Thu, 9 Jan 2025 17:23:39 +0300 Subject: [PATCH 04/11] refactor: add supermq sdk to magistrala sdk Signed-off-by: Felix Gateru --- pkg/sdk/bootstrap_test.go | 2 +- pkg/sdk/responses.go | 8 ++------ pkg/sdk/sdk.go | 6 +++--- 3 files changed, 6 insertions(+), 10 deletions(-) diff --git a/pkg/sdk/bootstrap_test.go b/pkg/sdk/bootstrap_test.go index aafbc03ab..255084626 100644 --- a/pkg/sdk/bootstrap_test.go +++ b/pkg/sdk/bootstrap_test.go @@ -325,7 +325,7 @@ func TestListBootstraps(t *testing.T) { Configs: []bootstrap.Config{bootstrapConfig}, }, response: sdk.BootstrapPage{ - PageRes: sdk.PageRes{ + PageRes: supermqSDK.PageRes{ Total: 1, }, Configs: []sdk.BootstrapConfig{configRes}, diff --git a/pkg/sdk/responses.go b/pkg/sdk/responses.go index 541a4ea07..10be60be8 100644 --- a/pkg/sdk/responses.go +++ b/pkg/sdk/responses.go @@ -3,14 +3,10 @@ package sdk -type PageRes struct { - Total uint64 `json:"total"` - Offset uint64 `json:"offset"` - Limit uint64 `json:"limit"` -} +import supermqSDK "github.com/absmach/supermq/pkg/sdk" // bootstrapsPage contains list of bootstrap configs in a page with proper metadata. type BootstrapPage struct { Configs []BootstrapConfig `json:"configs"` - PageRes + supermqSDK.PageRes } diff --git a/pkg/sdk/sdk.go b/pkg/sdk/sdk.go index a27201583..f4bd1da95 100644 --- a/pkg/sdk/sdk.go +++ b/pkg/sdk/sdk.go @@ -28,7 +28,7 @@ type PageMetadata struct { Total uint64 `json:"total"` Offset uint64 `json:"offset"` Limit uint64 `json:"limit"` - Metadata Metadata `json:"metadata,omitempty"` + Metadata supermqSDK.Metadata `json:"metadata,omitempty"` } // SDK contains Magistrala API. @@ -105,7 +105,7 @@ type SDK interface { // example: // bootstrap, _ := sdk.BootstrapSecure("externalID", "externalKey", "cryptoKey") // fmt.Println(bootstrap) - BootstrapSecure(externalID, externalKey, cryptoKey string) (BootstrapConfig, errors.SDKError) + //BootstrapSecure(externalID, externalKey, cryptoKey string) (BootstrapConfig, errors.SDKError) // Bootstraps retrieves a list of managed configs. // @@ -116,7 +116,7 @@ type SDK interface { // } // bootstraps, _ := sdk.Bootstraps(pm, "domainID", "token") // fmt.Println(bootstraps) - Bootstraps(pm PageMetadata, domainID, token string) (BootstrapPage, errors.SDKError) + //Bootstraps(pm PageMetadata, domainID, token string) (BootstrapPage, errors.SDKError) // Whitelist updates Client state Config with given ID belonging to the user identified by the given token. // From abcb21dda11ad698f97b306d22345823ad841285 Mon Sep 17 00:00:00 2001 From: Felix Gateru Date: Fri, 10 Jan 2025 15:05:36 +0300 Subject: [PATCH 05/11] refactor: extend supermq sdk in magistrala sdk Signed-off-by: Felix Gateru --- pkg/sdk/bootstrap_test.go | 2 +- pkg/sdk/responses.go | 4 ++-- pkg/sdk/sdk.go | 6 +++--- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/pkg/sdk/bootstrap_test.go b/pkg/sdk/bootstrap_test.go index 255084626..9ba34b998 100644 --- a/pkg/sdk/bootstrap_test.go +++ b/pkg/sdk/bootstrap_test.go @@ -325,7 +325,7 @@ func TestListBootstraps(t *testing.T) { Configs: []bootstrap.Config{bootstrapConfig}, }, response: sdk.BootstrapPage{ - PageRes: supermqSDK.PageRes{ + PageRes: smqSDK.PageRes{ Total: 1, }, Configs: []sdk.BootstrapConfig{configRes}, diff --git a/pkg/sdk/responses.go b/pkg/sdk/responses.go index 10be60be8..a5e47f1a3 100644 --- a/pkg/sdk/responses.go +++ b/pkg/sdk/responses.go @@ -3,10 +3,10 @@ package sdk -import supermqSDK "github.com/absmach/supermq/pkg/sdk" +import smqSDK "github.com/absmach/supermq/pkg/sdk" // bootstrapsPage contains list of bootstrap configs in a page with proper metadata. type BootstrapPage struct { Configs []BootstrapConfig `json:"configs"` - supermqSDK.PageRes + smqSDK.PageRes } diff --git a/pkg/sdk/sdk.go b/pkg/sdk/sdk.go index f4bd1da95..a27201583 100644 --- a/pkg/sdk/sdk.go +++ b/pkg/sdk/sdk.go @@ -28,7 +28,7 @@ type PageMetadata struct { Total uint64 `json:"total"` Offset uint64 `json:"offset"` Limit uint64 `json:"limit"` - Metadata supermqSDK.Metadata `json:"metadata,omitempty"` + Metadata Metadata `json:"metadata,omitempty"` } // SDK contains Magistrala API. @@ -105,7 +105,7 @@ type SDK interface { // example: // bootstrap, _ := sdk.BootstrapSecure("externalID", "externalKey", "cryptoKey") // fmt.Println(bootstrap) - //BootstrapSecure(externalID, externalKey, cryptoKey string) (BootstrapConfig, errors.SDKError) + BootstrapSecure(externalID, externalKey, cryptoKey string) (BootstrapConfig, errors.SDKError) // Bootstraps retrieves a list of managed configs. // @@ -116,7 +116,7 @@ type SDK interface { // } // bootstraps, _ := sdk.Bootstraps(pm, "domainID", "token") // fmt.Println(bootstraps) - //Bootstraps(pm PageMetadata, domainID, token string) (BootstrapPage, errors.SDKError) + Bootstraps(pm PageMetadata, domainID, token string) (BootstrapPage, errors.SDKError) // Whitelist updates Client state Config with given ID belonging to the user identified by the given token. // From 48813b13037c6594a8585192bf58cb5a45d9ff35 Mon Sep 17 00:00:00 2001 From: Felix Gateru Date: Fri, 10 Jan 2025 15:13:04 +0300 Subject: [PATCH 06/11] reafctor: update responses Signed-off-by: Felix Gateru --- pkg/sdk/bootstrap_test.go | 2 +- pkg/sdk/responses.go | 8 ++++++-- 2 files changed, 7 insertions(+), 3 deletions(-) diff --git a/pkg/sdk/bootstrap_test.go b/pkg/sdk/bootstrap_test.go index 9ba34b998..aafbc03ab 100644 --- a/pkg/sdk/bootstrap_test.go +++ b/pkg/sdk/bootstrap_test.go @@ -325,7 +325,7 @@ func TestListBootstraps(t *testing.T) { Configs: []bootstrap.Config{bootstrapConfig}, }, response: sdk.BootstrapPage{ - PageRes: smqSDK.PageRes{ + PageRes: sdk.PageRes{ Total: 1, }, Configs: []sdk.BootstrapConfig{configRes}, diff --git a/pkg/sdk/responses.go b/pkg/sdk/responses.go index a5e47f1a3..541a4ea07 100644 --- a/pkg/sdk/responses.go +++ b/pkg/sdk/responses.go @@ -3,10 +3,14 @@ package sdk -import smqSDK "github.com/absmach/supermq/pkg/sdk" +type PageRes struct { + Total uint64 `json:"total"` + Offset uint64 `json:"offset"` + Limit uint64 `json:"limit"` +} // bootstrapsPage contains list of bootstrap configs in a page with proper metadata. type BootstrapPage struct { Configs []BootstrapConfig `json:"configs"` - smqSDK.PageRes + PageRes } From 197d2410d8b5f98e15ad2147ab35e924d0568aec Mon Sep 17 00:00:00 2001 From: Felix Gateru Date: Thu, 9 Jan 2025 17:52:13 +0300 Subject: [PATCH 07/11] feat: add readers and consumers sdk Signed-off-by: Felix Gateru --- pkg/sdk/consumers.go | 89 ++++++++ pkg/sdk/consumers_test.go | 458 ++++++++++++++++++++++++++++++++++++++ pkg/sdk/messages .go | 78 +++++++ pkg/sdk/messages_test.go | 247 ++++++++++++++++++++ pkg/sdk/responses.go | 16 ++ 5 files changed, 888 insertions(+) create mode 100644 pkg/sdk/consumers.go create mode 100644 pkg/sdk/consumers_test.go create mode 100644 pkg/sdk/messages .go create mode 100644 pkg/sdk/messages_test.go diff --git a/pkg/sdk/consumers.go b/pkg/sdk/consumers.go new file mode 100644 index 000000000..15efbe241 --- /dev/null +++ b/pkg/sdk/consumers.go @@ -0,0 +1,89 @@ +// Copyright (c) Abstract Machines +// SPDX-License-Identifier: Apache-2.0 + +package sdk + +import ( + "encoding/json" + "fmt" + "net/http" + "strings" + + "github.com/absmach/supermq/pkg/errors" +) + +const ( + subscriptionEndpoint = "subscriptions" +) + +type Subscription struct { + ID string `json:"id,omitempty"` + OwnerID string `json:"owner_id,omitempty"` + Topic string `json:"topic,omitempty"` + Contact string `json:"contact,omitempty"` +} + +func (sdk mgSDK) CreateSubscription(topic, contact, token string) (string, errors.SDKError) { + sub := Subscription{ + Topic: topic, + Contact: contact, + } + data, err := json.Marshal(sub) + if err != nil { + return "", errors.NewSDKError(err) + } + + url := fmt.Sprintf("%s/%s", sdk.usersURL, subscriptionEndpoint) + + headers, _, sdkerr := sdk.processRequest(http.MethodPost, url, token, data, nil, http.StatusCreated) + if sdkerr != nil { + return "", sdkerr + } + + id := strings.TrimPrefix(headers.Get("Location"), fmt.Sprintf("/%s/", subscriptionEndpoint)) + + return id, nil +} + +func (sdk mgSDK) ListSubscriptions(pm PageMetadata, token string) (SubscriptionPage, errors.SDKError) { + url, err := sdk.withQueryParams(sdk.usersURL, subscriptionEndpoint, pm) + if err != nil { + return SubscriptionPage{}, errors.NewSDKError(err) + } + + _, body, sdkerr := sdk.processRequest(http.MethodGet, url, token, nil, nil, http.StatusOK) + if sdkerr != nil { + return SubscriptionPage{}, sdkerr + } + + var sp SubscriptionPage + if err := json.Unmarshal(body, &sp); err != nil { + return SubscriptionPage{}, errors.NewSDKError(err) + } + + return sp, nil +} + +func (sdk mgSDK) ViewSubscription(id, token string) (Subscription, errors.SDKError) { + url := fmt.Sprintf("%s/%s/%s", sdk.usersURL, subscriptionEndpoint, id) + + _, body, err := sdk.processRequest(http.MethodGet, url, token, nil, nil, http.StatusOK) + if err != nil { + return Subscription{}, err + } + + var sub Subscription + if err := json.Unmarshal(body, &sub); err != nil { + return Subscription{}, errors.NewSDKError(err) + } + + return sub, nil +} + +func (sdk mgSDK) DeleteSubscription(id, token string) errors.SDKError { + url := fmt.Sprintf("%s/%s/%s", sdk.usersURL, subscriptionEndpoint, id) + + _, _, err := sdk.processRequest(http.MethodDelete, url, token, nil, nil, http.StatusNoContent) + + return err +} diff --git a/pkg/sdk/consumers_test.go b/pkg/sdk/consumers_test.go new file mode 100644 index 000000000..76472ca7c --- /dev/null +++ b/pkg/sdk/consumers_test.go @@ -0,0 +1,458 @@ +// Copyright (c) Abstract Machines +// SPDX-License-Identifier: Apache-2.0 + +package sdk_test + +import ( + "fmt" + "net/http" + "net/http/httptest" + "testing" + + "github.com/absmach/magistrala/consumers/notifiers" + httpapi "github.com/absmach/magistrala/consumers/notifiers/api" + notmocks "github.com/absmach/magistrala/consumers/notifiers/mocks" + "github.com/absmach/magistrala/internal/testsutil" + sdk "github.com/absmach/magistrala/pkg/sdk" + apiutil "github.com/absmach/supermq/api/http/util" + smqlog "github.com/absmach/supermq/logger" + "github.com/absmach/supermq/pkg/errors" + svcerr "github.com/absmach/supermq/pkg/errors/service" + supermqSDK "github.com/absmach/supermq/pkg/sdk" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" +) + +var ( + ownerID = testsutil.GenerateUUID(&testing.T{}) + subID = testsutil.GenerateUUID(&testing.T{}) + sdkSubReq = sdk.Subscription{ + Topic: "topic", + Contact: "contact", + } + sdkSubRes = sdk.Subscription{ + Topic: "topic", + Contact: "contact", + OwnerID: ownerID, + ID: subID, + } + notSubReq = notifiers.Subscription{ + Contact: "contact", + Topic: "topic", + } + notSubRes = notifiers.Subscription{ + Contact: "contact", + Topic: "topic", + OwnerID: ownerID, + ID: subID, + } + validToken = "validToken" + invalidToken = "invalidToken" + wrongID = "wrongID" + instanceID = "instanceID" + contentType = supermqSDK.CTJSON +) + +func setupSubscriptions() (*httptest.Server, *notmocks.Service) { + nsvc := new(notmocks.Service) + logger := smqlog.NewMock() + mux := httpapi.MakeHandler(nsvc, logger, instanceID) + + return httptest.NewServer(mux), nsvc +} + +func TestCreateSubscription(t *testing.T) { + ts, nsvc := setupSubscriptions() + defer ts.Close() + + sdkConf := sdk.Config{ + UsersURL: ts.URL, + MsgContentType: contentType, + TLSVerification: false, + } + + mgsdk := sdk.NewSDK(sdkConf) + + cases := []struct { + desc string + subscription sdk.Subscription + token string + empty bool + id string + svcReq notifiers.Subscription + svcErr error + svcRes string + err errors.SDKError + }{ + { + desc: "create new subscription", + subscription: sdkSubReq, + token: validToken, + empty: false, + svcReq: notSubReq, + svcRes: subID, + svcErr: nil, + err: nil, + }, + { + desc: "create new subscription with empty token", + subscription: sdkSubReq, + token: "", + empty: true, + svcReq: notifiers.Subscription{}, + svcRes: "", + svcErr: nil, + err: errors.NewSDKErrorWithStatus(errors.Wrap(apiutil.ErrValidation, apiutil.ErrBearerToken), http.StatusUnauthorized), + }, + { + desc: "create new subscription with invalid token", + subscription: sdkSubReq, + token: invalidToken, + empty: true, + svcReq: notSubReq, + svcRes: "", + svcErr: svcerr.ErrAuthentication, + err: errors.NewSDKErrorWithStatus(svcerr.ErrAuthentication, http.StatusUnauthorized), + }, + { + desc: "create new subscription with empty topic", + subscription: sdk.Subscription{ + Topic: "", + Contact: "contact", + }, + token: validToken, + empty: true, + svcReq: notifiers.Subscription{}, + svcErr: nil, + svcRes: "", + err: errors.NewSDKErrorWithStatus(errors.Wrap(apiutil.ErrValidation, apiutil.ErrInvalidTopic), http.StatusBadRequest), + }, + { + desc: "create new subscription with empty contact", + subscription: sdk.Subscription{ + Topic: "topic", + Contact: "", + }, + token: validToken, + empty: true, + svcReq: notifiers.Subscription{}, + svcErr: nil, + svcRes: "", + err: errors.NewSDKErrorWithStatus(errors.Wrap(apiutil.ErrValidation, apiutil.ErrInvalidContact), http.StatusBadRequest), + }, + } + for _, tc := range cases { + t.Run(tc.desc, func(t *testing.T) { + svcCall := nsvc.On("CreateSubscription", mock.Anything, tc.token, tc.svcReq).Return(tc.svcRes, tc.svcErr) + loc, err := mgsdk.CreateSubscription(tc.subscription.Topic, tc.subscription.Contact, tc.token) + assert.Equal(t, tc.err, err) + assert.Equal(t, tc.empty, loc == "") + if tc.err == nil { + ok := svcCall.Parent.AssertCalled(t, "CreateSubscription", mock.Anything, tc.token, tc.svcReq) + assert.True(t, ok) + } + svcCall.Unset() + }) + } +} + +func TestViewSubscription(t *testing.T) { + ts, nsvc := setupSubscriptions() + defer ts.Close() + sdkConf := sdk.Config{ + UsersURL: ts.URL, + MsgContentType: contentType, + TLSVerification: false, + } + + mgsdk := sdk.NewSDK(sdkConf) + + cases := []struct { + desc string + subID string + token string + svcRes notifiers.Subscription + svcErr error + response sdk.Subscription + err errors.SDKError + }{ + { + desc: "view existing subscription", + subID: subID, + token: validToken, + svcRes: notSubRes, + svcErr: nil, + response: sdkSubRes, + err: nil, + }, + { + desc: "view non-existent subscription", + subID: wrongID, + token: validToken, + svcRes: notifiers.Subscription{}, + svcErr: svcerr.ErrNotFound, + response: sdk.Subscription{}, + err: errors.NewSDKErrorWithStatus(svcerr.ErrNotFound, http.StatusNotFound), + }, + { + desc: "view subscription with invalid token", + subID: subID, + token: invalidToken, + svcRes: notifiers.Subscription{}, + svcErr: svcerr.ErrAuthentication, + response: sdk.Subscription{}, + err: errors.NewSDKErrorWithStatus(svcerr.ErrAuthentication, http.StatusUnauthorized), + }, + { + desc: "view subscription with empty token", + subID: subID, + token: "", + svcRes: notifiers.Subscription{}, + svcErr: nil, + response: sdk.Subscription{}, + err: errors.NewSDKErrorWithStatus(errors.Wrap(apiutil.ErrValidation, apiutil.ErrBearerToken), http.StatusUnauthorized), + }, + } + for _, tc := range cases { + t.Run(tc.desc, func(t *testing.T) { + svcCall := nsvc.On("ViewSubscription", mock.Anything, tc.token, tc.subID).Return(tc.svcRes, tc.svcErr) + resp, err := mgsdk.ViewSubscription(tc.subID, tc.token) + assert.Equal(t, tc.err, err) + assert.Equal(t, tc.response, resp) + if tc.err == nil { + ok := svcCall.Parent.AssertCalled(t, "ViewSubscription", mock.Anything, tc.token, tc.subID) + assert.True(t, ok) + } + svcCall.Unset() + }) + } +} + +func TestListSubscription(t *testing.T) { + ts, nsvc := setupSubscriptions() + defer ts.Close() + sdkConf := sdk.Config{ + UsersURL: ts.URL, + MsgContentType: contentType, + TLSVerification: false, + } + + mgsdk := sdk.NewSDK(sdkConf) + nSubs := 10 + noSubs := []notifiers.Subscription{} + sdSubs := []sdk.Subscription{} + for i := 0; i < nSubs; i++ { + nosub := notifiers.Subscription{ + OwnerID: ownerID, + Topic: fmt.Sprintf("topic_%d", i), + Contact: fmt.Sprintf("contact_%d", i), + } + noSubs = append(noSubs, nosub) + sdsub := sdk.Subscription{ + OwnerID: ownerID, + Topic: fmt.Sprintf("topic_%d", i), + Contact: fmt.Sprintf("contact_%d", i), + } + sdSubs = append(sdSubs, sdsub) + } + + cases := []struct { + desc string + token string + pageMeta sdk.PageMetadata + svcReq notifiers.PageMetadata + svcRes notifiers.Page + svcErr error + response sdk.SubscriptionPage + err errors.SDKError + }{ + { + desc: "list all subscription", + token: validToken, + pageMeta: sdk.PageMetadata{ + Offset: 0, + Limit: 10, + }, + svcReq: notifiers.PageMetadata{ + Offset: 0, + Limit: 10, + }, + svcRes: notifiers.Page{ + Total: 10, + Subscriptions: noSubs, + }, + svcErr: nil, + response: sdk.SubscriptionPage{ + PageRes: sdk.PageRes{ + Total: 10, + }, + Subscriptions: sdSubs, + }, + err: nil, + }, + { + desc: "list subscription with specific topic", + token: validToken, + pageMeta: sdk.PageMetadata{ + Offset: 0, + Limit: 10, + Topic: "topic_1", + }, + svcReq: notifiers.PageMetadata{ + Offset: 0, + Limit: 10, + Topic: "topic_1", + }, + svcRes: notifiers.Page{ + Total: uint(len(noSubs[1:2])), + Subscriptions: noSubs[1:2], + }, + svcErr: nil, + response: sdk.SubscriptionPage{ + PageRes: sdk.PageRes{ + Total: uint64(len(sdSubs[1:2])), + }, + Subscriptions: sdSubs[1:2], + }, + err: nil, + }, + { + desc: "list subscription with specific contact", + token: validToken, + pageMeta: sdk.PageMetadata{ + Offset: 0, + Limit: 10, + Contact: "contact_1", + }, + svcReq: notifiers.PageMetadata{ + Offset: 0, + Limit: 10, + Contact: "contact_1", + }, + svcRes: notifiers.Page{ + Total: uint(len(noSubs[1:2])), + Subscriptions: noSubs[1:2], + }, + svcErr: nil, + response: sdk.SubscriptionPage{ + PageRes: sdk.PageRes{ + Total: uint64(len(sdSubs[1:2])), + }, + Subscriptions: sdSubs[1:2], + }, + err: nil, + }, + { + desc: "list subscription with invalid token", + token: invalidToken, + pageMeta: sdk.PageMetadata{ + Offset: 0, + Limit: 10, + }, + svcReq: notifiers.PageMetadata{ + Offset: 0, + Limit: 10, + }, + svcRes: notifiers.Page{}, + svcErr: svcerr.ErrAuthentication, + response: sdk.SubscriptionPage{}, + err: errors.NewSDKErrorWithStatus(svcerr.ErrAuthentication, http.StatusUnauthorized), + }, + { + desc: "list subscription with empty token", + token: "", + pageMeta: sdk.PageMetadata{ + Offset: 0, + Limit: 10, + }, + svcReq: notifiers.PageMetadata{}, + svcRes: notifiers.Page{}, + svcErr: nil, + response: sdk.SubscriptionPage{}, + err: errors.NewSDKErrorWithStatus(errors.Wrap(apiutil.ErrValidation, apiutil.ErrBearerToken), http.StatusUnauthorized), + }, + } + + for _, tc := range cases { + t.Run(tc.desc, func(t *testing.T) { + svcCall := nsvc.On("ListSubscriptions", mock.Anything, tc.token, tc.svcReq).Return(tc.svcRes, tc.svcErr) + resp, err := mgsdk.ListSubscriptions(tc.pageMeta, tc.token) + assert.Equal(t, tc.err, err) + assert.Equal(t, tc.response, resp) + if tc.err == nil { + ok := svcCall.Parent.AssertCalled(t, "ListSubscriptions", mock.Anything, tc.token, tc.svcReq) + assert.True(t, ok) + } + svcCall.Unset() + }) + } +} + +func TestDeleteSubscription(t *testing.T) { + ts, nsvc := setupSubscriptions() + defer ts.Close() + sdkConf := sdk.Config{ + UsersURL: ts.URL, + MsgContentType: contentType, + TLSVerification: false, + } + + mgsdk := sdk.NewSDK(sdkConf) + + cases := []struct { + desc string + subID string + token string + svcErr error + err errors.SDKError + }{ + { + desc: "delete existing subscription", + subID: subID, + token: validToken, + svcErr: nil, + err: nil, + }, + { + desc: "delete non-existent subscription", + subID: wrongID, + token: validToken, + svcErr: svcerr.ErrRemoveEntity, + err: errors.NewSDKErrorWithStatus(svcerr.ErrRemoveEntity, http.StatusUnprocessableEntity), + }, + { + desc: "delete subscription with invalid token", + subID: subID, + token: invalidToken, + svcErr: svcerr.ErrAuthentication, + err: errors.NewSDKErrorWithStatus(svcerr.ErrAuthentication, http.StatusUnauthorized), + }, + { + desc: "delete subscription with empty token", + subID: subID, + token: "", + svcErr: nil, + err: errors.NewSDKErrorWithStatus(errors.Wrap(apiutil.ErrValidation, apiutil.ErrBearerToken), http.StatusUnauthorized), + }, + { + desc: "delete subscription with empty subID", + subID: "", + token: validToken, + svcErr: nil, + err: errors.NewSDKErrorWithStatus(errors.Wrap(apiutil.ErrValidation, apiutil.ErrMissingID), http.StatusBadRequest), + }, + } + + for _, tc := range cases { + t.Run(tc.desc, func(t *testing.T) { + svcCall := nsvc.On("RemoveSubscription", mock.Anything, tc.token, tc.subID).Return(tc.svcErr) + err := mgsdk.DeleteSubscription(tc.subID, tc.token) + assert.Equal(t, tc.err, err) + if tc.err == nil { + ok := svcCall.Parent.AssertCalled(t, "RemoveSubscription", mock.Anything, tc.token, tc.subID) + assert.True(t, ok) + } + svcCall.Unset() + }) + } +} diff --git a/pkg/sdk/messages .go b/pkg/sdk/messages .go new file mode 100644 index 000000000..d2e74b1c3 --- /dev/null +++ b/pkg/sdk/messages .go @@ -0,0 +1,78 @@ +// Copyright (c) Abstract Machines +// SPDX-License-Identifier: Apache-2.0 + +package sdk + +import ( + "encoding/json" + "fmt" + "net/http" + "net/url" + "strconv" + "strings" + + "github.com/absmach/supermq/pkg/errors" + supermqSDK "github.com/absmach/supermq/pkg/sdk" +) + +const channelParts = 2 + +func (sdk mgSDK) ReadMessages(pm MessagePageMetadata, chanName, domainID, token string) (supermqSDK.MessagesPage, errors.SDKError) { + chanNameParts := strings.SplitN(chanName, ".", channelParts) + chanID := chanNameParts[0] + subtopicPart := "" + if len(chanNameParts) == channelParts { + subtopicPart = fmt.Sprintf("?subtopic=%s", chanNameParts[1]) + } + + msgURL, err := sdk.withMessageQueryParams(sdk.readerURL, fmt.Sprintf("channels/%s/messages%s", chanID, subtopicPart), pm) + if err != nil { + return supermqSDK.MessagesPage{}, errors.NewSDKError(err) + } + + header := make(map[string]string) + header["Content-Type"] = string(sdk.msgContentType) + + _, body, sdkerr := sdk.processRequest(http.MethodGet, msgURL, token, nil, header, http.StatusOK) + if sdkerr != nil { + return supermqSDK.MessagesPage{}, sdkerr + } + + var mp supermqSDK.MessagesPage + if err := json.Unmarshal(body, &mp); err != nil { + return supermqSDK.MessagesPage{}, errors.NewSDKError(err) + } + + return mp, nil +} + +func (sdk mgSDK) withMessageQueryParams(baseURL, endpoint string, mpm MessagePageMetadata) (string, error) { + b, err := json.Marshal(mpm) + if err != nil { + return "", err + } + q := map[string]interface{}{} + if err := json.Unmarshal(b, &q); err != nil { + return "", err + } + ret := url.Values{} + for k, v := range q { + switch t := v.(type) { + case string: + ret.Add(k, t) + case float64: + ret.Add(k, strconv.FormatFloat(t, 'f', -1, 64)) + case uint64: + ret.Add(k, strconv.FormatUint(t, 10)) + case int64: + ret.Add(k, strconv.FormatInt(t, 10)) + case json.Number: + ret.Add(k, t.String()) + case bool: + ret.Add(k, strconv.FormatBool(t)) + } + } + qs := ret.Encode() + + return fmt.Sprintf("%s/%s?%s", baseURL, endpoint, qs), nil +} diff --git a/pkg/sdk/messages_test.go b/pkg/sdk/messages_test.go new file mode 100644 index 000000000..9309c0afa --- /dev/null +++ b/pkg/sdk/messages_test.go @@ -0,0 +1,247 @@ +// Copyright (c) Abstract Machines +// SPDX-License-Identifier: Apache-2.0 + +package sdk_test + +import ( + "fmt" + "net/http" + "net/http/httptest" + "testing" + + "github.com/absmach/magistrala/internal/testsutil" + grpcChannelsV1 "github.com/absmach/supermq/api/grpc/channels/v1" + apiutil "github.com/absmach/supermq/api/http/util" + chmocks "github.com/absmach/supermq/channels/mocks" + climocks "github.com/absmach/supermq/clients/mocks" + smqauthn "github.com/absmach/supermq/pkg/authn" + authnmocks "github.com/absmach/supermq/pkg/authn/mocks" + "github.com/absmach/supermq/pkg/errors" + svcerr "github.com/absmach/supermq/pkg/errors/service" + sdk "github.com/absmach/supermq/pkg/sdk" + "github.com/absmach/supermq/pkg/transformers/senml" + "github.com/absmach/supermq/readers" + readersapi "github.com/absmach/supermq/readers/api" + readersmocks "github.com/absmach/supermq/readers/mocks" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" +) + +var ( + channelsGRPCClient *chmocks.ChannelsServiceClient + clientsGRPCClient *climocks.ClientsServiceClient + validID = testsutil.GenerateUUID(&testing.T{}) +) + +func setupReaders() (*httptest.Server, *authnmocks.Authentication, *readersmocks.MessageRepository) { + repo := new(readersmocks.MessageRepository) + authn := new(authnmocks.Authentication) + clientsGRPCClient = new(climocks.ClientsServiceClient) + channelsGRPCClient = new(chmocks.ChannelsServiceClient) + + mux := readersapi.MakeHandler(repo, authn, clientsGRPCClient, channelsGRPCClient, "test", "") + return httptest.NewServer(mux), authn, repo +} + +func TestReadMessages(t *testing.T) { + ts, authn, repo := setupReaders() + defer ts.Close() + + channelID := "channelID" + msgValue := 1.6 + boolVal := true + msg := senml.Message{ + Name: "current", + Time: 1720000000, + Value: &msgValue, + Publisher: validID, + } + invalidMsg := "[{\"n\":\"current\",\"t\":-1,\"v\":1.6}]" + + sdkConf := sdk.Config{ + ReaderURL: ts.URL, + } + + mgsdk := sdk.NewSDK(sdkConf) + + cases := []struct { + desc string + token string + chanName string + domainID string + messagePageMeta sdk.MessagePageMetadata + authzErr error + authnErr error + repoRes readers.MessagesPage + repoErr error + response sdk.MessagesPage + err errors.SDKError + }{ + { + desc: "read messages successfully", + token: validToken, + chanName: channelID, + domainID: validID, + messagePageMeta: sdk.MessagePageMetadata{ + PageMetadata: sdk.PageMetadata{ + Offset: 0, + Limit: 10, + Level: 0, + }, + Publisher: validID, + BoolValue: &boolVal, + }, + repoRes: readers.MessagesPage{ + Total: 1, + Messages: []readers.Message{msg}, + }, + repoErr: nil, + response: sdk.MessagesPage{ + PageRes: sdk.PageRes{ + Total: 1, + }, + Messages: []senml.Message{msg}, + }, + err: nil, + }, + { + desc: "read messages successfully with subtopic", + token: validToken, + chanName: channelID + ".subtopic", + domainID: validID, + messagePageMeta: sdk.MessagePageMetadata{ + PageMetadata: sdk.PageMetadata{ + Offset: 0, + Limit: 10, + }, + Publisher: validID, + }, + repoRes: readers.MessagesPage{ + Total: 1, + Messages: []readers.Message{msg}, + }, + repoErr: nil, + response: sdk.MessagesPage{ + PageRes: sdk.PageRes{ + Total: 1, + }, + Messages: []senml.Message{msg}, + }, + err: nil, + }, + { + desc: "read messages with invalid token", + token: invalidToken, + chanName: channelID, + domainID: validID, + messagePageMeta: sdk.MessagePageMetadata{ + PageMetadata: sdk.PageMetadata{ + Offset: 0, + Limit: 10, + }, + Subtopic: "subtopic", + Publisher: validID, + }, + authzErr: svcerr.ErrAuthorization, + repoRes: readers.MessagesPage{}, + response: sdk.MessagesPage{}, + err: errors.NewSDKErrorWithStatus(errors.Wrap(svcerr.ErrAuthorization, svcerr.ErrAuthorization), http.StatusUnauthorized), + }, + { + desc: "read messages with empty token", + token: "", + chanName: channelID, + domainID: validID, + messagePageMeta: sdk.MessagePageMetadata{ + PageMetadata: sdk.PageMetadata{ + Offset: 0, + Limit: 10, + }, + Subtopic: "subtopic", + Publisher: validID, + }, + authnErr: svcerr.ErrAuthentication, + repoRes: readers.MessagesPage{}, + response: sdk.MessagesPage{}, + err: errors.NewSDKErrorWithStatus(errors.Wrap(apiutil.ErrValidation, apiutil.ErrBearerToken), http.StatusUnauthorized), + }, + { + desc: "read messages with empty channel ID", + token: validToken, + chanName: "", + domainID: validID, + messagePageMeta: sdk.MessagePageMetadata{ + PageMetadata: sdk.PageMetadata{ + Offset: 0, + Limit: 10, + }, + Subtopic: "subtopic", + Publisher: validID, + }, + repoRes: readers.MessagesPage{}, + repoErr: nil, + response: sdk.MessagesPage{}, + err: errors.NewSDKErrorWithStatus(errors.Wrap(apiutil.ErrValidation, apiutil.ErrMissingID), http.StatusBadRequest), + }, + { + desc: "read messages with invalid message page metadata", + token: validToken, + chanName: channelID, + domainID: validID, + messagePageMeta: sdk.MessagePageMetadata{ + PageMetadata: sdk.PageMetadata{ + Offset: 0, + Limit: 10, + Metadata: map[string]interface{}{ + "key": make(chan int), + }, + }, + Subtopic: "subtopic", + Publisher: validID, + }, + repoRes: readers.MessagesPage{}, + repoErr: nil, + response: sdk.MessagesPage{}, + err: errors.NewSDKError(errors.New("json: unsupported type: chan int")), + }, + { + desc: "read messages with response that cannot be unmarshalled", + token: validToken, + chanName: channelID, + domainID: validID, + messagePageMeta: sdk.MessagePageMetadata{ + PageMetadata: sdk.PageMetadata{ + Offset: 0, + Limit: 10, + }, + Subtopic: "subtopic", + Publisher: validID, + }, + repoRes: readers.MessagesPage{ + Total: 1, + Messages: []readers.Message{invalidMsg}, + }, + repoErr: nil, + response: sdk.MessagesPage{}, + err: errors.NewSDKError(errors.New("json: cannot unmarshal string into Go struct field MessagesPage.messages of type senml.Message")), + }, + } + for _, tc := range cases { + t.Run(tc.desc, func(t *testing.T) { + authCall1 := authn.On("Authenticate", mock.Anything, tc.token).Return(smqauthn.Session{UserID: validID}, tc.authnErr) + authzCall := channelsGRPCClient.On("Authorize", mock.Anything, mock.Anything).Return(&grpcChannelsV1.AuthzRes{Authorized: true}, tc.authzErr) + repoCall := repo.On("ReadAll", channelID, mock.Anything).Return(tc.repoRes, tc.repoErr) + response, err := mgsdk.ReadMessages(tc.messagePageMeta, tc.chanName, tc.domainID, tc.token) + fmt.Println(err) + assert.Equal(t, tc.err, err) + assert.Equal(t, tc.response, response) + if tc.err == nil { + ok := repoCall.Parent.AssertCalled(t, "ReadAll", channelID, mock.Anything) + assert.True(t, ok) + } + authCall1.Unset() + authzCall.Unset() + repoCall.Unset() + }) + } +} diff --git a/pkg/sdk/responses.go b/pkg/sdk/responses.go index 541a4ea07..975da6144 100644 --- a/pkg/sdk/responses.go +++ b/pkg/sdk/responses.go @@ -14,3 +14,19 @@ type BootstrapPage struct { Configs []BootstrapConfig `json:"configs"` PageRes } + +// Copyright (c) Abstract Machines +// SPDX-License-Identifier: Apache-2.0 + +package sdk + +type PageRes struct { + Total uint64 `json:"total"` + Offset uint64 `json:"offset"` + Limit uint64 `json:"limit"` +} + +type SubscriptionPage struct { + Subscriptions []Subscription `json:"subscriptions"` + PageRes +} From 8df4803f691c0f0ce3e90d0dc3b0b6e9ce7667cf Mon Sep 17 00:00:00 2001 From: Felix Gateru Date: Fri, 10 Jan 2025 09:13:44 +0300 Subject: [PATCH 08/11] ci(messages.go): fix filename Signed-off-by: Felix Gateru --- pkg/sdk/{messages .go => messages.go} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename pkg/sdk/{messages .go => messages.go} (100%) diff --git a/pkg/sdk/messages .go b/pkg/sdk/messages.go similarity index 100% rename from pkg/sdk/messages .go rename to pkg/sdk/messages.go From 3c24d9996a16ba5f48136e8142a7b33c210aa6bf Mon Sep 17 00:00:00 2001 From: Felix Gateru Date: Fri, 10 Jan 2025 18:24:50 +0300 Subject: [PATCH 09/11] feat: add readers sdk Signed-off-by: Felix Gateru --- apidocs/openapi/notifiers.yml | 6 +- apidocs/openapi/readers.yml | 4 +- cmd/postgres-reader/main.go | 2 +- cmd/timescale-reader/main.go | 2 +- consumers/notifiers/api/endpoint.go | 2 +- consumers/notifiers/api/endpoint_test.go | 2 +- consumers/notifiers/api/logging.go | 2 +- consumers/notifiers/api/metrics.go | 2 +- consumers/notifiers/api/transport.go | 2 +- consumers/notifiers/mocks/repository.go | 2 +- consumers/notifiers/mocks/service.go | 2 +- consumers/notifiers/notifier.go | 22 + consumers/notifiers/postgres/subscriptions.go | 2 +- .../notifiers/postgres/subscriptions_test.go | 2 +- consumers/notifiers/service.go | 9 +- consumers/notifiers/service_test.go | 2 +- consumers/notifiers/smpp/notifier.go | 2 +- consumers/notifiers/smtp/notifier.go | 2 +- consumers/notifiers/tracing/subscriptions.go | 2 +- go.mod | 3 +- go.sum | 6 +- pkg/sdk/consumers.go | 4 +- pkg/sdk/consumers_test.go | 8 +- pkg/sdk/messages.go | 13 +- pkg/sdk/messages_test.go | 7 +- pkg/sdk/mocks/sdk.go | 4390 ++++++++++++++++- pkg/sdk/responses.go | 18 +- pkg/sdk/sdk.go | 91 +- readers/api/endpoint_test.go | 2 +- readers/messages.go | 84 - readers/mocks/doc.go | 5 - readers/mocks/messages.go | 57 - tools/e2e/cmd/main.go | 2 +- tools/mqtt-bench/cmd/main.go | 2 +- tools/provision/cmd/main.go | 2 +- 35 files changed, 4518 insertions(+), 247 deletions(-) create mode 100644 consumers/notifiers/notifier.go delete mode 100644 readers/messages.go delete mode 100644 readers/mocks/doc.go delete mode 100644 readers/mocks/messages.go diff --git a/apidocs/openapi/notifiers.yml b/apidocs/openapi/notifiers.yml index 62a681eaa..3a8cc5f0f 100644 --- a/apidocs/openapi/notifiers.yml +++ b/apidocs/openapi/notifiers.yml @@ -13,7 +13,7 @@ info: license: name: Apache 2.0 url: https://github.com/absmach/magistrala/blob/main/LICENSE - version: 0.14.0 + version: 0.15.1 servers: - url: http://localhost:9014 @@ -44,7 +44,7 @@ paths: "400": description: Failed due to malformed JSON. "401": - description: Missing or invalid access token provided. + description: Missing or invalid access token provided. "403": description: Failed to perform authorization over the entity. "409": @@ -278,7 +278,7 @@ components: content: application/health+json: schema: - $ref: "./schemas/HealthInfo.yml" + $ref: "./schemas/health_info.yml" securitySchemes: bearerAuth: diff --git a/apidocs/openapi/readers.yml b/apidocs/openapi/readers.yml index 8cf7ea521..18700e0a0 100644 --- a/apidocs/openapi/readers.yml +++ b/apidocs/openapi/readers.yml @@ -13,7 +13,7 @@ info: license: name: Apache 2.0 url: https://github.com/absmach/magistrala/blob/main/LICENSE - version: 0.14.0 + version: 0.15.1 servers: - url: http://localhost:9003 @@ -292,7 +292,7 @@ components: content: application/health+json: schema: - $ref: "./schemas/HealthInfo.yml" + $ref: "./schemas/health_info.yml" securitySchemes: bearerAuth: diff --git a/cmd/postgres-reader/main.go b/cmd/postgres-reader/main.go index db4f5dc7f..931255e8c 100644 --- a/cmd/postgres-reader/main.go +++ b/cmd/postgres-reader/main.go @@ -12,6 +12,7 @@ import ( "os" chclient "github.com/absmach/callhome/pkg/client" + httpapi "github.com/absmach/magistrala/readers/api" "github.com/absmach/magistrala/readers/postgres" "github.com/absmach/supermq" smqlog "github.com/absmach/supermq/logger" @@ -23,7 +24,6 @@ import ( httpserver "github.com/absmach/supermq/pkg/server/http" "github.com/absmach/supermq/pkg/uuid" "github.com/absmach/supermq/readers" - httpapi "github.com/absmach/supermq/readers/api" "github.com/caarlos0/env/v11" "github.com/jmoiron/sqlx" "golang.org/x/sync/errgroup" diff --git a/cmd/timescale-reader/main.go b/cmd/timescale-reader/main.go index 1f9b2fabb..12b3243ea 100644 --- a/cmd/timescale-reader/main.go +++ b/cmd/timescale-reader/main.go @@ -12,6 +12,7 @@ import ( "os" chclient "github.com/absmach/callhome/pkg/client" + httpapi "github.com/absmach/magistrala/readers/api" "github.com/absmach/magistrala/readers/timescale" "github.com/absmach/supermq" smqlog "github.com/absmach/supermq/logger" @@ -23,7 +24,6 @@ import ( httpserver "github.com/absmach/supermq/pkg/server/http" "github.com/absmach/supermq/pkg/uuid" "github.com/absmach/supermq/readers" - httpapi "github.com/absmach/supermq/readers/api" "github.com/caarlos0/env/v11" "github.com/jmoiron/sqlx" "golang.org/x/sync/errgroup" diff --git a/consumers/notifiers/api/endpoint.go b/consumers/notifiers/api/endpoint.go index 42b8055ea..77267b67f 100644 --- a/consumers/notifiers/api/endpoint.go +++ b/consumers/notifiers/api/endpoint.go @@ -6,8 +6,8 @@ package api import ( "context" + notifiers "github.com/absmach/magistrala/consumers/notifiers" apiutil "github.com/absmach/supermq/api/http/util" - notifiers "github.com/absmach/supermq/consumers/notifiers" "github.com/absmach/supermq/pkg/errors" "github.com/go-kit/kit/endpoint" ) diff --git a/consumers/notifiers/api/endpoint_test.go b/consumers/notifiers/api/endpoint_test.go index ed248b208..140e0204b 100644 --- a/consumers/notifiers/api/endpoint_test.go +++ b/consumers/notifiers/api/endpoint_test.go @@ -13,11 +13,11 @@ import ( "strings" "testing" + "github.com/absmach/magistrala/consumers/notifiers" "github.com/absmach/magistrala/consumers/notifiers/api" "github.com/absmach/magistrala/consumers/notifiers/mocks" "github.com/absmach/magistrala/internal/testsutil" apiutil "github.com/absmach/supermq/api/http/util" - "github.com/absmach/supermq/consumers/notifiers" smqlog "github.com/absmach/supermq/logger" svcerr "github.com/absmach/supermq/pkg/errors/service" "github.com/absmach/supermq/pkg/uuid" diff --git a/consumers/notifiers/api/logging.go b/consumers/notifiers/api/logging.go index ae779b1aa..e327d9226 100644 --- a/consumers/notifiers/api/logging.go +++ b/consumers/notifiers/api/logging.go @@ -10,7 +10,7 @@ import ( "log/slog" "time" - "github.com/absmach/supermq/consumers/notifiers" + "github.com/absmach/magistrala/consumers/notifiers" ) var _ notifiers.Service = (*loggingMiddleware)(nil) diff --git a/consumers/notifiers/api/metrics.go b/consumers/notifiers/api/metrics.go index ce312c35c..209730288 100644 --- a/consumers/notifiers/api/metrics.go +++ b/consumers/notifiers/api/metrics.go @@ -9,7 +9,7 @@ import ( "context" "time" - "github.com/absmach/supermq/consumers/notifiers" + "github.com/absmach/magistrala/consumers/notifiers" "github.com/go-kit/kit/metrics" ) diff --git a/consumers/notifiers/api/transport.go b/consumers/notifiers/api/transport.go index 605833fe0..e3924563f 100644 --- a/consumers/notifiers/api/transport.go +++ b/consumers/notifiers/api/transport.go @@ -10,10 +10,10 @@ import ( "net/http" "strings" + "github.com/absmach/magistrala/consumers/notifiers" "github.com/absmach/supermq" api "github.com/absmach/supermq/api/http" apiutil "github.com/absmach/supermq/api/http/util" - "github.com/absmach/supermq/consumers/notifiers" "github.com/absmach/supermq/pkg/errors" "github.com/go-chi/chi/v5" kithttp "github.com/go-kit/kit/transport/http" diff --git a/consumers/notifiers/mocks/repository.go b/consumers/notifiers/mocks/repository.go index b815d6f11..49e572762 100644 --- a/consumers/notifiers/mocks/repository.go +++ b/consumers/notifiers/mocks/repository.go @@ -7,7 +7,7 @@ package mocks import ( context "context" - notifiers "github.com/absmach/supermq/consumers/notifiers" + notifiers "github.com/absmach/magistrala/consumers/notifiers" mock "github.com/stretchr/testify/mock" ) diff --git a/consumers/notifiers/mocks/service.go b/consumers/notifiers/mocks/service.go index 50f463e18..9fe9494f0 100644 --- a/consumers/notifiers/mocks/service.go +++ b/consumers/notifiers/mocks/service.go @@ -7,7 +7,7 @@ package mocks import ( context "context" - notifiers "github.com/absmach/supermq/consumers/notifiers" + notifiers "github.com/absmach/magistrala/consumers/notifiers" mock "github.com/stretchr/testify/mock" ) diff --git a/consumers/notifiers/notifier.go b/consumers/notifiers/notifier.go new file mode 100644 index 000000000..0337176d4 --- /dev/null +++ b/consumers/notifiers/notifier.go @@ -0,0 +1,22 @@ +// Copyright (c) Abstract Machines +// SPDX-License-Identifier: Apache-2.0 + +package notifiers + +import ( + "errors" + + "github.com/absmach/supermq/pkg/messaging" +) + +// ErrNotify wraps sending notification errors. +var ErrNotify = errors.New("error sending notification") + +// Notifier represents an API for sending notification. +// +//go:generate mockery --name Notifier --output=./mocks --filename notifier.go --quiet --note "Copyright (c) Abstract Machines" +type Notifier interface { + // Notify method is used to send notification for the + // received message to the provided list of receivers. + Notify(from string, to []string, msg *messaging.Message) error +} diff --git a/consumers/notifiers/postgres/subscriptions.go b/consumers/notifiers/postgres/subscriptions.go index 71e7ab495..dee5213b2 100644 --- a/consumers/notifiers/postgres/subscriptions.go +++ b/consumers/notifiers/postgres/subscriptions.go @@ -9,7 +9,7 @@ import ( "fmt" "strings" - "github.com/absmach/supermq/consumers/notifiers" + "github.com/absmach/magistrala/consumers/notifiers" "github.com/absmach/supermq/pkg/errors" repoerr "github.com/absmach/supermq/pkg/errors/repository" "github.com/jackc/pgerrcode" diff --git a/consumers/notifiers/postgres/subscriptions_test.go b/consumers/notifiers/postgres/subscriptions_test.go index d974fbfb9..22885d40c 100644 --- a/consumers/notifiers/postgres/subscriptions_test.go +++ b/consumers/notifiers/postgres/subscriptions_test.go @@ -8,8 +8,8 @@ import ( "fmt" "testing" + "github.com/absmach/magistrala/consumers/notifiers" "github.com/absmach/magistrala/consumers/notifiers/postgres" - "github.com/absmach/supermq/consumers/notifiers" "github.com/absmach/supermq/pkg/errors" repoerr "github.com/absmach/supermq/pkg/errors/repository" "github.com/stretchr/testify/assert" diff --git a/consumers/notifiers/service.go b/consumers/notifiers/service.go index 0b864a1c6..02d02503f 100644 --- a/consumers/notifiers/service.go +++ b/consumers/notifiers/service.go @@ -9,7 +9,6 @@ import ( "github.com/absmach/supermq" "github.com/absmach/supermq/consumers" - notif "github.com/absmach/supermq/consumers/notifiers" smqauthn "github.com/absmach/supermq/pkg/authn" "github.com/absmach/supermq/pkg/errors" svcerr "github.com/absmach/supermq/pkg/errors/service" @@ -47,13 +46,13 @@ type notifierService struct { authn smqauthn.Authentication subs SubscriptionsRepository idp supermq.IDProvider - notifier notif.Notifier + notifier Notifier errCh chan error from string } // New instantiates the subscriptions service implementation. -func New(authn smqauthn.Authentication, subs SubscriptionsRepository, idp supermq.IDProvider, notifier notif.Notifier, from string) Service { +func New(authn smqauthn.Authentication, subs SubscriptionsRepository, idp supermq.IDProvider, notifier Notifier, from string) Service { return ¬ifierService{ authn: authn, subs: subs, @@ -132,7 +131,7 @@ func (ns *notifierService) ConsumeBlocking(ctx context.Context, message interfac if len(to) > 0 { err := ns.notifier.Notify(ns.from, to, msg) if err != nil { - return errors.Wrap(notif.ErrNotify, err) + return errors.Wrap(ErrNotify, err) } } @@ -166,7 +165,7 @@ func (ns *notifierService) ConsumeAsync(ctx context.Context, message interface{} } if len(to) > 0 { if err := ns.notifier.Notify(ns.from, to, msg); err != nil { - ns.errCh <- errors.Wrap(notif.ErrNotify, err) + ns.errCh <- errors.Wrap(ErrNotify, err) } } } diff --git a/consumers/notifiers/service_test.go b/consumers/notifiers/service_test.go index ee61a64cb..ebc2c8e7b 100644 --- a/consumers/notifiers/service_test.go +++ b/consumers/notifiers/service_test.go @@ -8,9 +8,9 @@ import ( "fmt" "testing" + "github.com/absmach/magistrala/consumers/notifiers" "github.com/absmach/magistrala/consumers/notifiers/mocks" "github.com/absmach/magistrala/internal/testsutil" - "github.com/absmach/supermq/consumers/notifiers" smqauthn "github.com/absmach/supermq/pkg/authn" authnmocks "github.com/absmach/supermq/pkg/authn/mocks" "github.com/absmach/supermq/pkg/errors" diff --git a/consumers/notifiers/smpp/notifier.go b/consumers/notifiers/smpp/notifier.go index 63394ea74..f8d6ffa5f 100644 --- a/consumers/notifiers/smpp/notifier.go +++ b/consumers/notifiers/smpp/notifier.go @@ -6,7 +6,7 @@ package smpp import ( "time" - "github.com/absmach/supermq/consumers/notifiers" + "github.com/absmach/magistrala/consumers/notifiers" "github.com/absmach/supermq/pkg/messaging" "github.com/absmach/supermq/pkg/transformers" "github.com/absmach/supermq/pkg/transformers/json" diff --git a/consumers/notifiers/smtp/notifier.go b/consumers/notifiers/smtp/notifier.go index a45d0f1b9..13ebc3f06 100644 --- a/consumers/notifiers/smtp/notifier.go +++ b/consumers/notifiers/smtp/notifier.go @@ -6,8 +6,8 @@ package smtp import ( "fmt" + "github.com/absmach/magistrala/consumers/notifiers" "github.com/absmach/magistrala/internal/email" - "github.com/absmach/supermq/consumers/notifiers" "github.com/absmach/supermq/pkg/messaging" ) diff --git a/consumers/notifiers/tracing/subscriptions.go b/consumers/notifiers/tracing/subscriptions.go index 8236e7635..c8c292012 100644 --- a/consumers/notifiers/tracing/subscriptions.go +++ b/consumers/notifiers/tracing/subscriptions.go @@ -8,7 +8,7 @@ package tracing import ( "context" - "github.com/absmach/supermq/consumers/notifiers" + "github.com/absmach/magistrala/consumers/notifiers" "go.opentelemetry.io/otel/attribute" "go.opentelemetry.io/otel/trace" ) diff --git a/go.mod b/go.mod index 56d4e13cc..a527a27d1 100644 --- a/go.mod +++ b/go.mod @@ -6,13 +6,12 @@ require ( github.com/0x6flab/namegenerator v1.4.0 github.com/absmach/callhome v0.14.0 github.com/absmach/certs v0.0.0-20241209153600-91270de67b5a - github.com/absmach/supermq v0.16.1-0.20250110085603-df5d752c4b50 + github.com/absmach/supermq v0.16.1-0.20250110102639-a9169276e54c github.com/authzed/authzed-go v1.2.1 github.com/authzed/grpcutil v0.0.0-20240123194739-2ea1e3d2d98b github.com/caarlos0/env/v11 v11.3.1 github.com/eclipse/paho.mqtt.golang v1.5.0 github.com/fiorix/go-smpp v0.0.0-20210403173735-2894b96e70ba - github.com/go-chi/chi v4.1.2+incompatible github.com/go-chi/chi/v5 v5.2.0 github.com/go-kit/kit v0.13.0 github.com/gofrs/uuid/v5 v5.3.0 diff --git a/go.sum b/go.sum index d1c9eb38b..0e487948c 100644 --- a/go.sum +++ b/go.sum @@ -27,8 +27,8 @@ github.com/absmach/mgate v0.4.5 h1:l6RmrEsR9jxkdb9WHUSecmT0HA41TkZZQVffFfUAIfI= github.com/absmach/mgate v0.4.5/go.mod h1:IvRIHZexZPEIAPmmaJF0L5DY2ERjj+GxRGitOW4s6qo= github.com/absmach/senml v1.0.6 h1:WPeIl6vQ00k7ghWSZYT/QP0KUxq2+4zQoaC7240pLFk= github.com/absmach/senml v1.0.6/go.mod h1:QnJNPy1DJPy0+qUW21PTcH/xoh0LgfYZxTfwriMIvmQ= -github.com/absmach/supermq v0.16.1-0.20250110085603-df5d752c4b50 h1:ndn1Z9wxUIH5chingm2hy3ZhIMt0+lDjD/CFaBEULbY= -github.com/absmach/supermq v0.16.1-0.20250110085603-df5d752c4b50/go.mod h1:VihyvWijocoz2yhXGAL+qHtid24O+qL/N2lxP2vRf/c= +github.com/absmach/supermq v0.16.1-0.20250110102639-a9169276e54c h1:s2OxO+rV1PMm/H2jqWVG8IF+HCVfawt8nGN/gY+SIa0= +github.com/absmach/supermq v0.16.1-0.20250110102639-a9169276e54c/go.mod h1:As0UgktURYeC5/SvC269WfdG9satLst8CQcxc2dC02E= github.com/authzed/authzed-go v1.2.1 h1:o54aIs0ocDfVJl/rfIt/75vrb6z+tgPuXjMlSsSEwH0= github.com/authzed/authzed-go v1.2.1/go.mod h1:/+NblSrzA6Lm6vUO3fqZyLh8MDCLUQq2AyJMlHb32DE= github.com/authzed/grpcutil v0.0.0-20240123194739-2ea1e3d2d98b h1:wbh8IK+aMLTCey9sZasO7b6BWLAJnHHvb79fvWCXwxw= @@ -99,8 +99,6 @@ github.com/fsnotify/fsnotify v1.8.0 h1:dAwr6QBTBZIkG8roQaJjGof0pp0EeF+tNV7YBP3F/ github.com/fsnotify/fsnotify v1.8.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0= github.com/fxamacker/cbor/v2 v2.7.0 h1:iM5WgngdRBanHcxugY4JySA0nk1wZorNOpTgCMedv5E= github.com/fxamacker/cbor/v2 v2.7.0/go.mod h1:pxXPTn3joSm21Gbwsv0w9OSA2y1HFR9qXEeXQVeNoDQ= -github.com/go-chi/chi v4.1.2+incompatible h1:fGFk2Gmi/YKXk0OmGfBh0WgmN3XB8lVnEyNz34tQRec= -github.com/go-chi/chi v4.1.2+incompatible/go.mod h1:eB3wogJHnLi3x/kFX2A+IbTBlXxmMeXJVKy9tTv1XzQ= github.com/go-chi/chi/v5 v5.2.0 h1:Aj1EtB0qR2Rdo2dG4O94RIU35w2lvQSj6BRA4+qwFL0= github.com/go-chi/chi/v5 v5.2.0/go.mod h1:DslCQbL2OYiznFReuXYUmQ2hGd1aDpCnlMNITLSKoi8= github.com/go-gorp/gorp/v3 v3.1.0 h1:ItKF/Vbuj31dmV4jxA1qblpSwkl9g1typ24xoe70IGs= diff --git a/pkg/sdk/consumers.go b/pkg/sdk/consumers.go index 15efbe241..3019db67e 100644 --- a/pkg/sdk/consumers.go +++ b/pkg/sdk/consumers.go @@ -12,9 +12,7 @@ import ( "github.com/absmach/supermq/pkg/errors" ) -const ( - subscriptionEndpoint = "subscriptions" -) +const subscriptionEndpoint = "subscriptions" type Subscription struct { ID string `json:"id,omitempty"` diff --git a/pkg/sdk/consumers_test.go b/pkg/sdk/consumers_test.go index 76472ca7c..6fc997719 100644 --- a/pkg/sdk/consumers_test.go +++ b/pkg/sdk/consumers_test.go @@ -46,11 +46,9 @@ var ( OwnerID: ownerID, ID: subID, } - validToken = "validToken" - invalidToken = "invalidToken" - wrongID = "wrongID" - instanceID = "instanceID" - contentType = supermqSDK.CTJSON + wrongID = "wrongID" + instanceID = "instanceID" + contentType = supermqSDK.CTJSON ) func setupSubscriptions() (*httptest.Server, *notmocks.Service) { diff --git a/pkg/sdk/messages.go b/pkg/sdk/messages.go index d2e74b1c3..29b7cd4af 100644 --- a/pkg/sdk/messages.go +++ b/pkg/sdk/messages.go @@ -12,12 +12,11 @@ import ( "strings" "github.com/absmach/supermq/pkg/errors" - supermqSDK "github.com/absmach/supermq/pkg/sdk" ) const channelParts = 2 -func (sdk mgSDK) ReadMessages(pm MessagePageMetadata, chanName, domainID, token string) (supermqSDK.MessagesPage, errors.SDKError) { +func (sdk mgSDK) ReadMessages(pm MessagePageMetadata, chanName, domainID, token string) (MessagesPage, errors.SDKError) { chanNameParts := strings.SplitN(chanName, ".", channelParts) chanID := chanNameParts[0] subtopicPart := "" @@ -25,9 +24,9 @@ func (sdk mgSDK) ReadMessages(pm MessagePageMetadata, chanName, domainID, token subtopicPart = fmt.Sprintf("?subtopic=%s", chanNameParts[1]) } - msgURL, err := sdk.withMessageQueryParams(sdk.readerURL, fmt.Sprintf("channels/%s/messages%s", chanID, subtopicPart), pm) + msgURL, err := sdk.withMessageQueryParams(sdk.readersURL, fmt.Sprintf("channels/%s/messages%s", chanID, subtopicPart), pm) if err != nil { - return supermqSDK.MessagesPage{}, errors.NewSDKError(err) + return MessagesPage{}, errors.NewSDKError(err) } header := make(map[string]string) @@ -35,12 +34,12 @@ func (sdk mgSDK) ReadMessages(pm MessagePageMetadata, chanName, domainID, token _, body, sdkerr := sdk.processRequest(http.MethodGet, msgURL, token, nil, header, http.StatusOK) if sdkerr != nil { - return supermqSDK.MessagesPage{}, sdkerr + return MessagesPage{}, sdkerr } - var mp supermqSDK.MessagesPage + var mp MessagesPage if err := json.Unmarshal(body, &mp); err != nil { - return supermqSDK.MessagesPage{}, errors.NewSDKError(err) + return MessagesPage{}, errors.NewSDKError(err) } return mp, nil diff --git a/pkg/sdk/messages_test.go b/pkg/sdk/messages_test.go index 9309c0afa..1b772e774 100644 --- a/pkg/sdk/messages_test.go +++ b/pkg/sdk/messages_test.go @@ -9,7 +9,8 @@ import ( "net/http/httptest" "testing" - "github.com/absmach/magistrala/internal/testsutil" + sdk "github.com/absmach/magistrala/pkg/sdk" + readersapi "github.com/absmach/magistrala/readers/api" grpcChannelsV1 "github.com/absmach/supermq/api/grpc/channels/v1" apiutil "github.com/absmach/supermq/api/http/util" chmocks "github.com/absmach/supermq/channels/mocks" @@ -18,10 +19,8 @@ import ( authnmocks "github.com/absmach/supermq/pkg/authn/mocks" "github.com/absmach/supermq/pkg/errors" svcerr "github.com/absmach/supermq/pkg/errors/service" - sdk "github.com/absmach/supermq/pkg/sdk" "github.com/absmach/supermq/pkg/transformers/senml" "github.com/absmach/supermq/readers" - readersapi "github.com/absmach/supermq/readers/api" readersmocks "github.com/absmach/supermq/readers/mocks" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/mock" @@ -30,7 +29,6 @@ import ( var ( channelsGRPCClient *chmocks.ChannelsServiceClient clientsGRPCClient *climocks.ClientsServiceClient - validID = testsutil.GenerateUUID(&testing.T{}) ) func setupReaders() (*httptest.Server, *authnmocks.Authentication, *readersmocks.MessageRepository) { @@ -226,6 +224,7 @@ func TestReadMessages(t *testing.T) { err: errors.NewSDKError(errors.New("json: cannot unmarshal string into Go struct field MessagesPage.messages of type senml.Message")), }, } + for _, tc := range cases { t.Run(tc.desc, func(t *testing.T) { authCall1 := authn.On("Authenticate", mock.Anything, tc.token).Return(smqauthn.Session{UserID: validID}, tc.authnErr) diff --git a/pkg/sdk/mocks/sdk.go b/pkg/sdk/mocks/sdk.go index 9f66e4820..205cafb40 100644 --- a/pkg/sdk/mocks/sdk.go +++ b/pkg/sdk/mocks/sdk.go @@ -1,7 +1,9 @@ -// Code generated by mockery v2.43.2. DO NOT EDIT. - // Copyright (c) Abstract Machines +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by mockery v2.43.2. DO NOT EDIT. + package mocks import ( @@ -20,6 +22,14 @@ type SDK struct { mock.Mock } +type SDK_Expecter struct { + mock *mock.Mock +} + +func (_m *SDK) EXPECT() *SDK_Expecter { + return &SDK_Expecter{mock: &_m.Mock} +} + // AcceptInvitation provides a mock function with given fields: domainID, token func (_m *SDK) AcceptInvitation(domainID string, token string) error { ret := _m.Called(domainID, token) @@ -38,6 +48,35 @@ func (_m *SDK) AcceptInvitation(domainID string, token string) error { return r0 } +// SDK_AcceptInvitation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AcceptInvitation' +type SDK_AcceptInvitation_Call struct { + *mock.Call +} + +// AcceptInvitation is a helper method to define mock.On call +// - domainID string +// - token string +func (_e *SDK_Expecter) AcceptInvitation(domainID interface{}, token interface{}) *SDK_AcceptInvitation_Call { + return &SDK_AcceptInvitation_Call{Call: _e.mock.On("AcceptInvitation", domainID, token)} +} + +func (_c *SDK_AcceptInvitation_Call) Run(run func(domainID string, token string)) *SDK_AcceptInvitation_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *SDK_AcceptInvitation_Call) Return(err error) *SDK_AcceptInvitation_Call { + _c.Call.Return(err) + return _c +} + +func (_c *SDK_AcceptInvitation_Call) RunAndReturn(run func(string, string) error) *SDK_AcceptInvitation_Call { + _c.Call.Return(run) + return _c +} + // AddBootstrap provides a mock function with given fields: cfg, domainID, token func (_m *SDK) AddBootstrap(cfg sdk.BootstrapConfig, domainID string, token string) (string, errors.SDKError) { ret := _m.Called(cfg, domainID, token) @@ -68,6 +107,36 @@ func (_m *SDK) AddBootstrap(cfg sdk.BootstrapConfig, domainID string, token stri return r0, r1 } +// SDK_AddBootstrap_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddBootstrap' +type SDK_AddBootstrap_Call struct { + *mock.Call +} + +// AddBootstrap is a helper method to define mock.On call +// - cfg sdk.BootstrapConfig +// - domainID string +// - token string +func (_e *SDK_Expecter) AddBootstrap(cfg interface{}, domainID interface{}, token interface{}) *SDK_AddBootstrap_Call { + return &SDK_AddBootstrap_Call{Call: _e.mock.On("AddBootstrap", cfg, domainID, token)} +} + +func (_c *SDK_AddBootstrap_Call) Run(run func(cfg sdk.BootstrapConfig, domainID string, token string)) *SDK_AddBootstrap_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(sdk.BootstrapConfig), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_AddBootstrap_Call) Return(_a0 string, _a1 errors.SDKError) *SDK_AddBootstrap_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_AddBootstrap_Call) RunAndReturn(run func(sdk.BootstrapConfig, string, string) (string, errors.SDKError)) *SDK_AddBootstrap_Call { + _c.Call.Return(run) + return _c +} + // AddChildren provides a mock function with given fields: id, domainID, groupIDs, token func (_m *SDK) AddChildren(id string, domainID string, groupIDs []string, token string) errors.SDKError { ret := _m.Called(id, domainID, groupIDs, token) @@ -88,6 +157,37 @@ func (_m *SDK) AddChildren(id string, domainID string, groupIDs []string, token return r0 } +// SDK_AddChildren_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddChildren' +type SDK_AddChildren_Call struct { + *mock.Call +} + +// AddChildren is a helper method to define mock.On call +// - id string +// - domainID string +// - groupIDs []string +// - token string +func (_e *SDK_Expecter) AddChildren(id interface{}, domainID interface{}, groupIDs interface{}, token interface{}) *SDK_AddChildren_Call { + return &SDK_AddChildren_Call{Call: _e.mock.On("AddChildren", id, domainID, groupIDs, token)} +} + +func (_c *SDK_AddChildren_Call) Run(run func(id string, domainID string, groupIDs []string, token string)) *SDK_AddChildren_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].([]string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_AddChildren_Call) Return(_a0 errors.SDKError) *SDK_AddChildren_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_AddChildren_Call) RunAndReturn(run func(string, string, []string, string) errors.SDKError) *SDK_AddChildren_Call { + _c.Call.Return(run) + return _c +} + // AddClientRoleActions provides a mock function with given fields: id, roleID, domainID, actions, token func (_m *SDK) AddClientRoleActions(id string, roleID string, domainID string, actions []string, token string) ([]string, errors.SDKError) { ret := _m.Called(id, roleID, domainID, actions, token) @@ -120,6 +220,38 @@ func (_m *SDK) AddClientRoleActions(id string, roleID string, domainID string, a return r0, r1 } +// SDK_AddClientRoleActions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddClientRoleActions' +type SDK_AddClientRoleActions_Call struct { + *mock.Call +} + +// AddClientRoleActions is a helper method to define mock.On call +// - id string +// - roleID string +// - domainID string +// - actions []string +// - token string +func (_e *SDK_Expecter) AddClientRoleActions(id interface{}, roleID interface{}, domainID interface{}, actions interface{}, token interface{}) *SDK_AddClientRoleActions_Call { + return &SDK_AddClientRoleActions_Call{Call: _e.mock.On("AddClientRoleActions", id, roleID, domainID, actions, token)} +} + +func (_c *SDK_AddClientRoleActions_Call) Run(run func(id string, roleID string, domainID string, actions []string, token string)) *SDK_AddClientRoleActions_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string), args[3].([]string), args[4].(string)) + }) + return _c +} + +func (_c *SDK_AddClientRoleActions_Call) Return(_a0 []string, _a1 errors.SDKError) *SDK_AddClientRoleActions_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_AddClientRoleActions_Call) RunAndReturn(run func(string, string, string, []string, string) ([]string, errors.SDKError)) *SDK_AddClientRoleActions_Call { + _c.Call.Return(run) + return _c +} + // AddClientRoleMembers provides a mock function with given fields: id, roleID, domainID, members, token func (_m *SDK) AddClientRoleMembers(id string, roleID string, domainID string, members []string, token string) ([]string, errors.SDKError) { ret := _m.Called(id, roleID, domainID, members, token) @@ -152,6 +284,38 @@ func (_m *SDK) AddClientRoleMembers(id string, roleID string, domainID string, m return r0, r1 } +// SDK_AddClientRoleMembers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddClientRoleMembers' +type SDK_AddClientRoleMembers_Call struct { + *mock.Call +} + +// AddClientRoleMembers is a helper method to define mock.On call +// - id string +// - roleID string +// - domainID string +// - members []string +// - token string +func (_e *SDK_Expecter) AddClientRoleMembers(id interface{}, roleID interface{}, domainID interface{}, members interface{}, token interface{}) *SDK_AddClientRoleMembers_Call { + return &SDK_AddClientRoleMembers_Call{Call: _e.mock.On("AddClientRoleMembers", id, roleID, domainID, members, token)} +} + +func (_c *SDK_AddClientRoleMembers_Call) Run(run func(id string, roleID string, domainID string, members []string, token string)) *SDK_AddClientRoleMembers_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string), args[3].([]string), args[4].(string)) + }) + return _c +} + +func (_c *SDK_AddClientRoleMembers_Call) Return(_a0 []string, _a1 errors.SDKError) *SDK_AddClientRoleMembers_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_AddClientRoleMembers_Call) RunAndReturn(run func(string, string, string, []string, string) ([]string, errors.SDKError)) *SDK_AddClientRoleMembers_Call { + _c.Call.Return(run) + return _c +} + // AddDomainRoleActions provides a mock function with given fields: id, roleID, actions, token func (_m *SDK) AddDomainRoleActions(id string, roleID string, actions []string, token string) ([]string, errors.SDKError) { ret := _m.Called(id, roleID, actions, token) @@ -184,6 +348,37 @@ func (_m *SDK) AddDomainRoleActions(id string, roleID string, actions []string, return r0, r1 } +// SDK_AddDomainRoleActions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddDomainRoleActions' +type SDK_AddDomainRoleActions_Call struct { + *mock.Call +} + +// AddDomainRoleActions is a helper method to define mock.On call +// - id string +// - roleID string +// - actions []string +// - token string +func (_e *SDK_Expecter) AddDomainRoleActions(id interface{}, roleID interface{}, actions interface{}, token interface{}) *SDK_AddDomainRoleActions_Call { + return &SDK_AddDomainRoleActions_Call{Call: _e.mock.On("AddDomainRoleActions", id, roleID, actions, token)} +} + +func (_c *SDK_AddDomainRoleActions_Call) Run(run func(id string, roleID string, actions []string, token string)) *SDK_AddDomainRoleActions_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].([]string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_AddDomainRoleActions_Call) Return(_a0 []string, _a1 errors.SDKError) *SDK_AddDomainRoleActions_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_AddDomainRoleActions_Call) RunAndReturn(run func(string, string, []string, string) ([]string, errors.SDKError)) *SDK_AddDomainRoleActions_Call { + _c.Call.Return(run) + return _c +} + // AddDomainRoleMembers provides a mock function with given fields: id, roleID, members, token func (_m *SDK) AddDomainRoleMembers(id string, roleID string, members []string, token string) ([]string, errors.SDKError) { ret := _m.Called(id, roleID, members, token) @@ -216,6 +411,37 @@ func (_m *SDK) AddDomainRoleMembers(id string, roleID string, members []string, return r0, r1 } +// SDK_AddDomainRoleMembers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddDomainRoleMembers' +type SDK_AddDomainRoleMembers_Call struct { + *mock.Call +} + +// AddDomainRoleMembers is a helper method to define mock.On call +// - id string +// - roleID string +// - members []string +// - token string +func (_e *SDK_Expecter) AddDomainRoleMembers(id interface{}, roleID interface{}, members interface{}, token interface{}) *SDK_AddDomainRoleMembers_Call { + return &SDK_AddDomainRoleMembers_Call{Call: _e.mock.On("AddDomainRoleMembers", id, roleID, members, token)} +} + +func (_c *SDK_AddDomainRoleMembers_Call) Run(run func(id string, roleID string, members []string, token string)) *SDK_AddDomainRoleMembers_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].([]string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_AddDomainRoleMembers_Call) Return(_a0 []string, _a1 errors.SDKError) *SDK_AddDomainRoleMembers_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_AddDomainRoleMembers_Call) RunAndReturn(run func(string, string, []string, string) ([]string, errors.SDKError)) *SDK_AddDomainRoleMembers_Call { + _c.Call.Return(run) + return _c +} + // AddGroupRoleActions provides a mock function with given fields: id, roleID, domainID, actions, token func (_m *SDK) AddGroupRoleActions(id string, roleID string, domainID string, actions []string, token string) ([]string, errors.SDKError) { ret := _m.Called(id, roleID, domainID, actions, token) @@ -248,6 +474,38 @@ func (_m *SDK) AddGroupRoleActions(id string, roleID string, domainID string, ac return r0, r1 } +// SDK_AddGroupRoleActions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddGroupRoleActions' +type SDK_AddGroupRoleActions_Call struct { + *mock.Call +} + +// AddGroupRoleActions is a helper method to define mock.On call +// - id string +// - roleID string +// - domainID string +// - actions []string +// - token string +func (_e *SDK_Expecter) AddGroupRoleActions(id interface{}, roleID interface{}, domainID interface{}, actions interface{}, token interface{}) *SDK_AddGroupRoleActions_Call { + return &SDK_AddGroupRoleActions_Call{Call: _e.mock.On("AddGroupRoleActions", id, roleID, domainID, actions, token)} +} + +func (_c *SDK_AddGroupRoleActions_Call) Run(run func(id string, roleID string, domainID string, actions []string, token string)) *SDK_AddGroupRoleActions_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string), args[3].([]string), args[4].(string)) + }) + return _c +} + +func (_c *SDK_AddGroupRoleActions_Call) Return(_a0 []string, _a1 errors.SDKError) *SDK_AddGroupRoleActions_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_AddGroupRoleActions_Call) RunAndReturn(run func(string, string, string, []string, string) ([]string, errors.SDKError)) *SDK_AddGroupRoleActions_Call { + _c.Call.Return(run) + return _c +} + // AddGroupRoleMembers provides a mock function with given fields: id, roleID, domainID, members, token func (_m *SDK) AddGroupRoleMembers(id string, roleID string, domainID string, members []string, token string) ([]string, errors.SDKError) { ret := _m.Called(id, roleID, domainID, members, token) @@ -280,6 +538,38 @@ func (_m *SDK) AddGroupRoleMembers(id string, roleID string, domainID string, me return r0, r1 } +// SDK_AddGroupRoleMembers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddGroupRoleMembers' +type SDK_AddGroupRoleMembers_Call struct { + *mock.Call +} + +// AddGroupRoleMembers is a helper method to define mock.On call +// - id string +// - roleID string +// - domainID string +// - members []string +// - token string +func (_e *SDK_Expecter) AddGroupRoleMembers(id interface{}, roleID interface{}, domainID interface{}, members interface{}, token interface{}) *SDK_AddGroupRoleMembers_Call { + return &SDK_AddGroupRoleMembers_Call{Call: _e.mock.On("AddGroupRoleMembers", id, roleID, domainID, members, token)} +} + +func (_c *SDK_AddGroupRoleMembers_Call) Run(run func(id string, roleID string, domainID string, members []string, token string)) *SDK_AddGroupRoleMembers_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string), args[3].([]string), args[4].(string)) + }) + return _c +} + +func (_c *SDK_AddGroupRoleMembers_Call) Return(_a0 []string, _a1 errors.SDKError) *SDK_AddGroupRoleMembers_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_AddGroupRoleMembers_Call) RunAndReturn(run func(string, string, string, []string, string) ([]string, errors.SDKError)) *SDK_AddGroupRoleMembers_Call { + _c.Call.Return(run) + return _c +} + // AvailableClientRoleActions provides a mock function with given fields: domainID, token func (_m *SDK) AvailableClientRoleActions(domainID string, token string) ([]string, errors.SDKError) { ret := _m.Called(domainID, token) @@ -312,6 +602,35 @@ func (_m *SDK) AvailableClientRoleActions(domainID string, token string) ([]stri return r0, r1 } +// SDK_AvailableClientRoleActions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AvailableClientRoleActions' +type SDK_AvailableClientRoleActions_Call struct { + *mock.Call +} + +// AvailableClientRoleActions is a helper method to define mock.On call +// - domainID string +// - token string +func (_e *SDK_Expecter) AvailableClientRoleActions(domainID interface{}, token interface{}) *SDK_AvailableClientRoleActions_Call { + return &SDK_AvailableClientRoleActions_Call{Call: _e.mock.On("AvailableClientRoleActions", domainID, token)} +} + +func (_c *SDK_AvailableClientRoleActions_Call) Run(run func(domainID string, token string)) *SDK_AvailableClientRoleActions_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *SDK_AvailableClientRoleActions_Call) Return(_a0 []string, _a1 errors.SDKError) *SDK_AvailableClientRoleActions_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_AvailableClientRoleActions_Call) RunAndReturn(run func(string, string) ([]string, errors.SDKError)) *SDK_AvailableClientRoleActions_Call { + _c.Call.Return(run) + return _c +} + // AvailableDomainRoleActions provides a mock function with given fields: token func (_m *SDK) AvailableDomainRoleActions(token string) ([]string, errors.SDKError) { ret := _m.Called(token) @@ -344,6 +663,34 @@ func (_m *SDK) AvailableDomainRoleActions(token string) ([]string, errors.SDKErr return r0, r1 } +// SDK_AvailableDomainRoleActions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AvailableDomainRoleActions' +type SDK_AvailableDomainRoleActions_Call struct { + *mock.Call +} + +// AvailableDomainRoleActions is a helper method to define mock.On call +// - token string +func (_e *SDK_Expecter) AvailableDomainRoleActions(token interface{}) *SDK_AvailableDomainRoleActions_Call { + return &SDK_AvailableDomainRoleActions_Call{Call: _e.mock.On("AvailableDomainRoleActions", token)} +} + +func (_c *SDK_AvailableDomainRoleActions_Call) Run(run func(token string)) *SDK_AvailableDomainRoleActions_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *SDK_AvailableDomainRoleActions_Call) Return(_a0 []string, _a1 errors.SDKError) *SDK_AvailableDomainRoleActions_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_AvailableDomainRoleActions_Call) RunAndReturn(run func(string) ([]string, errors.SDKError)) *SDK_AvailableDomainRoleActions_Call { + _c.Call.Return(run) + return _c +} + // AvailableGroupRoleActions provides a mock function with given fields: id, token func (_m *SDK) AvailableGroupRoleActions(id string, token string) ([]string, errors.SDKError) { ret := _m.Called(id, token) @@ -376,6 +723,35 @@ func (_m *SDK) AvailableGroupRoleActions(id string, token string) ([]string, err return r0, r1 } +// SDK_AvailableGroupRoleActions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AvailableGroupRoleActions' +type SDK_AvailableGroupRoleActions_Call struct { + *mock.Call +} + +// AvailableGroupRoleActions is a helper method to define mock.On call +// - id string +// - token string +func (_e *SDK_Expecter) AvailableGroupRoleActions(id interface{}, token interface{}) *SDK_AvailableGroupRoleActions_Call { + return &SDK_AvailableGroupRoleActions_Call{Call: _e.mock.On("AvailableGroupRoleActions", id, token)} +} + +func (_c *SDK_AvailableGroupRoleActions_Call) Run(run func(id string, token string)) *SDK_AvailableGroupRoleActions_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *SDK_AvailableGroupRoleActions_Call) Return(_a0 []string, _a1 errors.SDKError) *SDK_AvailableGroupRoleActions_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_AvailableGroupRoleActions_Call) RunAndReturn(run func(string, string) ([]string, errors.SDKError)) *SDK_AvailableGroupRoleActions_Call { + _c.Call.Return(run) + return _c +} + // Bootstrap provides a mock function with given fields: externalID, externalKey func (_m *SDK) Bootstrap(externalID string, externalKey string) (sdk.BootstrapConfig, errors.SDKError) { ret := _m.Called(externalID, externalKey) @@ -406,6 +782,35 @@ func (_m *SDK) Bootstrap(externalID string, externalKey string) (sdk.BootstrapCo return r0, r1 } +// SDK_Bootstrap_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Bootstrap' +type SDK_Bootstrap_Call struct { + *mock.Call +} + +// Bootstrap is a helper method to define mock.On call +// - externalID string +// - externalKey string +func (_e *SDK_Expecter) Bootstrap(externalID interface{}, externalKey interface{}) *SDK_Bootstrap_Call { + return &SDK_Bootstrap_Call{Call: _e.mock.On("Bootstrap", externalID, externalKey)} +} + +func (_c *SDK_Bootstrap_Call) Run(run func(externalID string, externalKey string)) *SDK_Bootstrap_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *SDK_Bootstrap_Call) Return(_a0 sdk.BootstrapConfig, _a1 errors.SDKError) *SDK_Bootstrap_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_Bootstrap_Call) RunAndReturn(run func(string, string) (sdk.BootstrapConfig, errors.SDKError)) *SDK_Bootstrap_Call { + _c.Call.Return(run) + return _c +} + // BootstrapSecure provides a mock function with given fields: externalID, externalKey, cryptoKey func (_m *SDK) BootstrapSecure(externalID string, externalKey string, cryptoKey string) (sdk.BootstrapConfig, errors.SDKError) { ret := _m.Called(externalID, externalKey, cryptoKey) @@ -436,6 +841,36 @@ func (_m *SDK) BootstrapSecure(externalID string, externalKey string, cryptoKey return r0, r1 } +// SDK_BootstrapSecure_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BootstrapSecure' +type SDK_BootstrapSecure_Call struct { + *mock.Call +} + +// BootstrapSecure is a helper method to define mock.On call +// - externalID string +// - externalKey string +// - cryptoKey string +func (_e *SDK_Expecter) BootstrapSecure(externalID interface{}, externalKey interface{}, cryptoKey interface{}) *SDK_BootstrapSecure_Call { + return &SDK_BootstrapSecure_Call{Call: _e.mock.On("BootstrapSecure", externalID, externalKey, cryptoKey)} +} + +func (_c *SDK_BootstrapSecure_Call) Run(run func(externalID string, externalKey string, cryptoKey string)) *SDK_BootstrapSecure_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_BootstrapSecure_Call) Return(_a0 sdk.BootstrapConfig, _a1 errors.SDKError) *SDK_BootstrapSecure_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_BootstrapSecure_Call) RunAndReturn(run func(string, string, string) (sdk.BootstrapConfig, errors.SDKError)) *SDK_BootstrapSecure_Call { + _c.Call.Return(run) + return _c +} + // Bootstraps provides a mock function with given fields: pm, domainID, token func (_m *SDK) Bootstraps(pm sdk.PageMetadata, domainID string, token string) (sdk.BootstrapPage, errors.SDKError) { ret := _m.Called(pm, domainID, token) @@ -466,6 +901,36 @@ func (_m *SDK) Bootstraps(pm sdk.PageMetadata, domainID string, token string) (s return r0, r1 } +// SDK_Bootstraps_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Bootstraps' +type SDK_Bootstraps_Call struct { + *mock.Call +} + +// Bootstraps is a helper method to define mock.On call +// - pm sdk.PageMetadata +// - domainID string +// - token string +func (_e *SDK_Expecter) Bootstraps(pm interface{}, domainID interface{}, token interface{}) *SDK_Bootstraps_Call { + return &SDK_Bootstraps_Call{Call: _e.mock.On("Bootstraps", pm, domainID, token)} +} + +func (_c *SDK_Bootstraps_Call) Run(run func(pm sdk.PageMetadata, domainID string, token string)) *SDK_Bootstraps_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(sdk.PageMetadata), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_Bootstraps_Call) Return(_a0 sdk.BootstrapPage, _a1 errors.SDKError) *SDK_Bootstraps_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_Bootstraps_Call) RunAndReturn(run func(sdk.PageMetadata, string, string) (sdk.BootstrapPage, errors.SDKError)) *SDK_Bootstraps_Call { + _c.Call.Return(run) + return _c +} + // Channel provides a mock function with given fields: id, domainID, token func (_m *SDK) Channel(id string, domainID string, token string) (pkgsdk.Channel, errors.SDKError) { ret := _m.Called(id, domainID, token) @@ -496,6 +961,36 @@ func (_m *SDK) Channel(id string, domainID string, token string) (pkgsdk.Channel return r0, r1 } +// SDK_Channel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Channel' +type SDK_Channel_Call struct { + *mock.Call +} + +// Channel is a helper method to define mock.On call +// - id string +// - domainID string +// - token string +func (_e *SDK_Expecter) Channel(id interface{}, domainID interface{}, token interface{}) *SDK_Channel_Call { + return &SDK_Channel_Call{Call: _e.mock.On("Channel", id, domainID, token)} +} + +func (_c *SDK_Channel_Call) Run(run func(id string, domainID string, token string)) *SDK_Channel_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_Channel_Call) Return(_a0 pkgsdk.Channel, _a1 errors.SDKError) *SDK_Channel_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_Channel_Call) RunAndReturn(run func(string, string, string) (pkgsdk.Channel, errors.SDKError)) *SDK_Channel_Call { + _c.Call.Return(run) + return _c +} + // Channels provides a mock function with given fields: pm, domainID, token func (_m *SDK) Channels(pm pkgsdk.PageMetadata, domainID string, token string) (pkgsdk.ChannelsPage, errors.SDKError) { ret := _m.Called(pm, domainID, token) @@ -526,6 +1021,36 @@ func (_m *SDK) Channels(pm pkgsdk.PageMetadata, domainID string, token string) ( return r0, r1 } +// SDK_Channels_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Channels' +type SDK_Channels_Call struct { + *mock.Call +} + +// Channels is a helper method to define mock.On call +// - pm pkgsdk.PageMetadata +// - domainID string +// - token string +func (_e *SDK_Expecter) Channels(pm interface{}, domainID interface{}, token interface{}) *SDK_Channels_Call { + return &SDK_Channels_Call{Call: _e.mock.On("Channels", pm, domainID, token)} +} + +func (_c *SDK_Channels_Call) Run(run func(pm pkgsdk.PageMetadata, domainID string, token string)) *SDK_Channels_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(pkgsdk.PageMetadata), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_Channels_Call) Return(_a0 pkgsdk.ChannelsPage, _a1 errors.SDKError) *SDK_Channels_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_Channels_Call) RunAndReturn(run func(pkgsdk.PageMetadata, string, string) (pkgsdk.ChannelsPage, errors.SDKError)) *SDK_Channels_Call { + _c.Call.Return(run) + return _c +} + // Children provides a mock function with given fields: id, domainID, pm, token func (_m *SDK) Children(id string, domainID string, pm pkgsdk.PageMetadata, token string) (pkgsdk.GroupsPage, errors.SDKError) { ret := _m.Called(id, domainID, pm, token) @@ -556,6 +1081,37 @@ func (_m *SDK) Children(id string, domainID string, pm pkgsdk.PageMetadata, toke return r0, r1 } +// SDK_Children_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Children' +type SDK_Children_Call struct { + *mock.Call +} + +// Children is a helper method to define mock.On call +// - id string +// - domainID string +// - pm pkgsdk.PageMetadata +// - token string +func (_e *SDK_Expecter) Children(id interface{}, domainID interface{}, pm interface{}, token interface{}) *SDK_Children_Call { + return &SDK_Children_Call{Call: _e.mock.On("Children", id, domainID, pm, token)} +} + +func (_c *SDK_Children_Call) Run(run func(id string, domainID string, pm pkgsdk.PageMetadata, token string)) *SDK_Children_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(pkgsdk.PageMetadata), args[3].(string)) + }) + return _c +} + +func (_c *SDK_Children_Call) Return(_a0 pkgsdk.GroupsPage, _a1 errors.SDKError) *SDK_Children_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_Children_Call) RunAndReturn(run func(string, string, pkgsdk.PageMetadata, string) (pkgsdk.GroupsPage, errors.SDKError)) *SDK_Children_Call { + _c.Call.Return(run) + return _c +} + // Client provides a mock function with given fields: id, domainID, token func (_m *SDK) Client(id string, domainID string, token string) (pkgsdk.Client, errors.SDKError) { ret := _m.Called(id, domainID, token) @@ -586,6 +1142,36 @@ func (_m *SDK) Client(id string, domainID string, token string) (pkgsdk.Client, return r0, r1 } +// SDK_Client_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Client' +type SDK_Client_Call struct { + *mock.Call +} + +// Client is a helper method to define mock.On call +// - id string +// - domainID string +// - token string +func (_e *SDK_Expecter) Client(id interface{}, domainID interface{}, token interface{}) *SDK_Client_Call { + return &SDK_Client_Call{Call: _e.mock.On("Client", id, domainID, token)} +} + +func (_c *SDK_Client_Call) Run(run func(id string, domainID string, token string)) *SDK_Client_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_Client_Call) Return(_a0 pkgsdk.Client, _a1 errors.SDKError) *SDK_Client_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_Client_Call) RunAndReturn(run func(string, string, string) (pkgsdk.Client, errors.SDKError)) *SDK_Client_Call { + _c.Call.Return(run) + return _c +} + // ClientRole provides a mock function with given fields: id, roleID, domainID, token func (_m *SDK) ClientRole(id string, roleID string, domainID string, token string) (pkgsdk.Role, errors.SDKError) { ret := _m.Called(id, roleID, domainID, token) @@ -616,6 +1202,37 @@ func (_m *SDK) ClientRole(id string, roleID string, domainID string, token strin return r0, r1 } +// SDK_ClientRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClientRole' +type SDK_ClientRole_Call struct { + *mock.Call +} + +// ClientRole is a helper method to define mock.On call +// - id string +// - roleID string +// - domainID string +// - token string +func (_e *SDK_Expecter) ClientRole(id interface{}, roleID interface{}, domainID interface{}, token interface{}) *SDK_ClientRole_Call { + return &SDK_ClientRole_Call{Call: _e.mock.On("ClientRole", id, roleID, domainID, token)} +} + +func (_c *SDK_ClientRole_Call) Run(run func(id string, roleID string, domainID string, token string)) *SDK_ClientRole_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_ClientRole_Call) Return(_a0 pkgsdk.Role, _a1 errors.SDKError) *SDK_ClientRole_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_ClientRole_Call) RunAndReturn(run func(string, string, string, string) (pkgsdk.Role, errors.SDKError)) *SDK_ClientRole_Call { + _c.Call.Return(run) + return _c +} + // ClientRoleActions provides a mock function with given fields: id, roleID, domainID, token func (_m *SDK) ClientRoleActions(id string, roleID string, domainID string, token string) ([]string, errors.SDKError) { ret := _m.Called(id, roleID, domainID, token) @@ -648,6 +1265,37 @@ func (_m *SDK) ClientRoleActions(id string, roleID string, domainID string, toke return r0, r1 } +// SDK_ClientRoleActions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClientRoleActions' +type SDK_ClientRoleActions_Call struct { + *mock.Call +} + +// ClientRoleActions is a helper method to define mock.On call +// - id string +// - roleID string +// - domainID string +// - token string +func (_e *SDK_Expecter) ClientRoleActions(id interface{}, roleID interface{}, domainID interface{}, token interface{}) *SDK_ClientRoleActions_Call { + return &SDK_ClientRoleActions_Call{Call: _e.mock.On("ClientRoleActions", id, roleID, domainID, token)} +} + +func (_c *SDK_ClientRoleActions_Call) Run(run func(id string, roleID string, domainID string, token string)) *SDK_ClientRoleActions_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_ClientRoleActions_Call) Return(_a0 []string, _a1 errors.SDKError) *SDK_ClientRoleActions_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_ClientRoleActions_Call) RunAndReturn(run func(string, string, string, string) ([]string, errors.SDKError)) *SDK_ClientRoleActions_Call { + _c.Call.Return(run) + return _c +} + // ClientRoleMembers provides a mock function with given fields: id, roleID, domainID, pm, token func (_m *SDK) ClientRoleMembers(id string, roleID string, domainID string, pm pkgsdk.PageMetadata, token string) (pkgsdk.RoleMembersPage, errors.SDKError) { ret := _m.Called(id, roleID, domainID, pm, token) @@ -678,6 +1326,38 @@ func (_m *SDK) ClientRoleMembers(id string, roleID string, domainID string, pm p return r0, r1 } +// SDK_ClientRoleMembers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClientRoleMembers' +type SDK_ClientRoleMembers_Call struct { + *mock.Call +} + +// ClientRoleMembers is a helper method to define mock.On call +// - id string +// - roleID string +// - domainID string +// - pm pkgsdk.PageMetadata +// - token string +func (_e *SDK_Expecter) ClientRoleMembers(id interface{}, roleID interface{}, domainID interface{}, pm interface{}, token interface{}) *SDK_ClientRoleMembers_Call { + return &SDK_ClientRoleMembers_Call{Call: _e.mock.On("ClientRoleMembers", id, roleID, domainID, pm, token)} +} + +func (_c *SDK_ClientRoleMembers_Call) Run(run func(id string, roleID string, domainID string, pm pkgsdk.PageMetadata, token string)) *SDK_ClientRoleMembers_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string), args[3].(pkgsdk.PageMetadata), args[4].(string)) + }) + return _c +} + +func (_c *SDK_ClientRoleMembers_Call) Return(_a0 pkgsdk.RoleMembersPage, _a1 errors.SDKError) *SDK_ClientRoleMembers_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_ClientRoleMembers_Call) RunAndReturn(run func(string, string, string, pkgsdk.PageMetadata, string) (pkgsdk.RoleMembersPage, errors.SDKError)) *SDK_ClientRoleMembers_Call { + _c.Call.Return(run) + return _c +} + // ClientRoles provides a mock function with given fields: id, domainID, pm, token func (_m *SDK) ClientRoles(id string, domainID string, pm pkgsdk.PageMetadata, token string) (pkgsdk.RolesPage, errors.SDKError) { ret := _m.Called(id, domainID, pm, token) @@ -708,6 +1388,37 @@ func (_m *SDK) ClientRoles(id string, domainID string, pm pkgsdk.PageMetadata, t return r0, r1 } +// SDK_ClientRoles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClientRoles' +type SDK_ClientRoles_Call struct { + *mock.Call +} + +// ClientRoles is a helper method to define mock.On call +// - id string +// - domainID string +// - pm pkgsdk.PageMetadata +// - token string +func (_e *SDK_Expecter) ClientRoles(id interface{}, domainID interface{}, pm interface{}, token interface{}) *SDK_ClientRoles_Call { + return &SDK_ClientRoles_Call{Call: _e.mock.On("ClientRoles", id, domainID, pm, token)} +} + +func (_c *SDK_ClientRoles_Call) Run(run func(id string, domainID string, pm pkgsdk.PageMetadata, token string)) *SDK_ClientRoles_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(pkgsdk.PageMetadata), args[3].(string)) + }) + return _c +} + +func (_c *SDK_ClientRoles_Call) Return(_a0 pkgsdk.RolesPage, _a1 errors.SDKError) *SDK_ClientRoles_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_ClientRoles_Call) RunAndReturn(run func(string, string, pkgsdk.PageMetadata, string) (pkgsdk.RolesPage, errors.SDKError)) *SDK_ClientRoles_Call { + _c.Call.Return(run) + return _c +} + // Clients provides a mock function with given fields: pm, domainID, token func (_m *SDK) Clients(pm pkgsdk.PageMetadata, domainID string, token string) (pkgsdk.ClientsPage, errors.SDKError) { ret := _m.Called(pm, domainID, token) @@ -738,6 +1449,36 @@ func (_m *SDK) Clients(pm pkgsdk.PageMetadata, domainID string, token string) (p return r0, r1 } +// SDK_Clients_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Clients' +type SDK_Clients_Call struct { + *mock.Call +} + +// Clients is a helper method to define mock.On call +// - pm pkgsdk.PageMetadata +// - domainID string +// - token string +func (_e *SDK_Expecter) Clients(pm interface{}, domainID interface{}, token interface{}) *SDK_Clients_Call { + return &SDK_Clients_Call{Call: _e.mock.On("Clients", pm, domainID, token)} +} + +func (_c *SDK_Clients_Call) Run(run func(pm pkgsdk.PageMetadata, domainID string, token string)) *SDK_Clients_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(pkgsdk.PageMetadata), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_Clients_Call) Return(_a0 pkgsdk.ClientsPage, _a1 errors.SDKError) *SDK_Clients_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_Clients_Call) RunAndReturn(run func(pkgsdk.PageMetadata, string, string) (pkgsdk.ClientsPage, errors.SDKError)) *SDK_Clients_Call { + _c.Call.Return(run) + return _c +} + // Connect provides a mock function with given fields: conn, domainID, token func (_m *SDK) Connect(conn pkgsdk.Connection, domainID string, token string) errors.SDKError { ret := _m.Called(conn, domainID, token) @@ -758,13 +1499,43 @@ func (_m *SDK) Connect(conn pkgsdk.Connection, domainID string, token string) er return r0 } -// ConnectClients provides a mock function with given fields: channelID, clientIDs, connTypes, domainID, token -func (_m *SDK) ConnectClients(channelID string, clientIDs []string, connTypes []string, domainID string, token string) errors.SDKError { - ret := _m.Called(channelID, clientIDs, connTypes, domainID, token) +// SDK_Connect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Connect' +type SDK_Connect_Call struct { + *mock.Call +} - if len(ret) == 0 { - panic("no return value specified for ConnectClients") - } +// Connect is a helper method to define mock.On call +// - conn pkgsdk.Connection +// - domainID string +// - token string +func (_e *SDK_Expecter) Connect(conn interface{}, domainID interface{}, token interface{}) *SDK_Connect_Call { + return &SDK_Connect_Call{Call: _e.mock.On("Connect", conn, domainID, token)} +} + +func (_c *SDK_Connect_Call) Run(run func(conn pkgsdk.Connection, domainID string, token string)) *SDK_Connect_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(pkgsdk.Connection), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_Connect_Call) Return(_a0 errors.SDKError) *SDK_Connect_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_Connect_Call) RunAndReturn(run func(pkgsdk.Connection, string, string) errors.SDKError) *SDK_Connect_Call { + _c.Call.Return(run) + return _c +} + +// ConnectClients provides a mock function with given fields: channelID, clientIDs, connTypes, domainID, token +func (_m *SDK) ConnectClients(channelID string, clientIDs []string, connTypes []string, domainID string, token string) errors.SDKError { + ret := _m.Called(channelID, clientIDs, connTypes, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for ConnectClients") + } var r0 errors.SDKError if rf, ok := ret.Get(0).(func(string, []string, []string, string, string) errors.SDKError); ok { @@ -778,6 +1549,38 @@ func (_m *SDK) ConnectClients(channelID string, clientIDs []string, connTypes [] return r0 } +// SDK_ConnectClients_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConnectClients' +type SDK_ConnectClients_Call struct { + *mock.Call +} + +// ConnectClients is a helper method to define mock.On call +// - channelID string +// - clientIDs []string +// - connTypes []string +// - domainID string +// - token string +func (_e *SDK_Expecter) ConnectClients(channelID interface{}, clientIDs interface{}, connTypes interface{}, domainID interface{}, token interface{}) *SDK_ConnectClients_Call { + return &SDK_ConnectClients_Call{Call: _e.mock.On("ConnectClients", channelID, clientIDs, connTypes, domainID, token)} +} + +func (_c *SDK_ConnectClients_Call) Run(run func(channelID string, clientIDs []string, connTypes []string, domainID string, token string)) *SDK_ConnectClients_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].([]string), args[2].([]string), args[3].(string), args[4].(string)) + }) + return _c +} + +func (_c *SDK_ConnectClients_Call) Return(_a0 errors.SDKError) *SDK_ConnectClients_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_ConnectClients_Call) RunAndReturn(run func(string, []string, []string, string, string) errors.SDKError) *SDK_ConnectClients_Call { + _c.Call.Return(run) + return _c +} + // CreateChannel provides a mock function with given fields: channel, domainID, token func (_m *SDK) CreateChannel(channel pkgsdk.Channel, domainID string, token string) (pkgsdk.Channel, errors.SDKError) { ret := _m.Called(channel, domainID, token) @@ -808,6 +1611,36 @@ func (_m *SDK) CreateChannel(channel pkgsdk.Channel, domainID string, token stri return r0, r1 } +// SDK_CreateChannel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateChannel' +type SDK_CreateChannel_Call struct { + *mock.Call +} + +// CreateChannel is a helper method to define mock.On call +// - channel pkgsdk.Channel +// - domainID string +// - token string +func (_e *SDK_Expecter) CreateChannel(channel interface{}, domainID interface{}, token interface{}) *SDK_CreateChannel_Call { + return &SDK_CreateChannel_Call{Call: _e.mock.On("CreateChannel", channel, domainID, token)} +} + +func (_c *SDK_CreateChannel_Call) Run(run func(channel pkgsdk.Channel, domainID string, token string)) *SDK_CreateChannel_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(pkgsdk.Channel), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_CreateChannel_Call) Return(_a0 pkgsdk.Channel, _a1 errors.SDKError) *SDK_CreateChannel_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_CreateChannel_Call) RunAndReturn(run func(pkgsdk.Channel, string, string) (pkgsdk.Channel, errors.SDKError)) *SDK_CreateChannel_Call { + _c.Call.Return(run) + return _c +} + // CreateChannels provides a mock function with given fields: channels, domainID, token func (_m *SDK) CreateChannels(channels []pkgsdk.Channel, domainID string, token string) ([]pkgsdk.Channel, errors.SDKError) { ret := _m.Called(channels, domainID, token) @@ -840,6 +1673,36 @@ func (_m *SDK) CreateChannels(channels []pkgsdk.Channel, domainID string, token return r0, r1 } +// SDK_CreateChannels_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateChannels' +type SDK_CreateChannels_Call struct { + *mock.Call +} + +// CreateChannels is a helper method to define mock.On call +// - channels []pkgsdk.Channel +// - domainID string +// - token string +func (_e *SDK_Expecter) CreateChannels(channels interface{}, domainID interface{}, token interface{}) *SDK_CreateChannels_Call { + return &SDK_CreateChannels_Call{Call: _e.mock.On("CreateChannels", channels, domainID, token)} +} + +func (_c *SDK_CreateChannels_Call) Run(run func(channels []pkgsdk.Channel, domainID string, token string)) *SDK_CreateChannels_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].([]pkgsdk.Channel), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_CreateChannels_Call) Return(_a0 []pkgsdk.Channel, _a1 errors.SDKError) *SDK_CreateChannels_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_CreateChannels_Call) RunAndReturn(run func([]pkgsdk.Channel, string, string) ([]pkgsdk.Channel, errors.SDKError)) *SDK_CreateChannels_Call { + _c.Call.Return(run) + return _c +} + // CreateClient provides a mock function with given fields: client, domainID, token func (_m *SDK) CreateClient(client pkgsdk.Client, domainID string, token string) (pkgsdk.Client, errors.SDKError) { ret := _m.Called(client, domainID, token) @@ -870,6 +1733,36 @@ func (_m *SDK) CreateClient(client pkgsdk.Client, domainID string, token string) return r0, r1 } +// SDK_CreateClient_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateClient' +type SDK_CreateClient_Call struct { + *mock.Call +} + +// CreateClient is a helper method to define mock.On call +// - client pkgsdk.Client +// - domainID string +// - token string +func (_e *SDK_Expecter) CreateClient(client interface{}, domainID interface{}, token interface{}) *SDK_CreateClient_Call { + return &SDK_CreateClient_Call{Call: _e.mock.On("CreateClient", client, domainID, token)} +} + +func (_c *SDK_CreateClient_Call) Run(run func(client pkgsdk.Client, domainID string, token string)) *SDK_CreateClient_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(pkgsdk.Client), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_CreateClient_Call) Return(_a0 pkgsdk.Client, _a1 errors.SDKError) *SDK_CreateClient_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_CreateClient_Call) RunAndReturn(run func(pkgsdk.Client, string, string) (pkgsdk.Client, errors.SDKError)) *SDK_CreateClient_Call { + _c.Call.Return(run) + return _c +} + // CreateClientRole provides a mock function with given fields: id, domainID, rq, token func (_m *SDK) CreateClientRole(id string, domainID string, rq pkgsdk.RoleReq, token string) (pkgsdk.Role, errors.SDKError) { ret := _m.Called(id, domainID, rq, token) @@ -900,6 +1793,37 @@ func (_m *SDK) CreateClientRole(id string, domainID string, rq pkgsdk.RoleReq, t return r0, r1 } +// SDK_CreateClientRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateClientRole' +type SDK_CreateClientRole_Call struct { + *mock.Call +} + +// CreateClientRole is a helper method to define mock.On call +// - id string +// - domainID string +// - rq pkgsdk.RoleReq +// - token string +func (_e *SDK_Expecter) CreateClientRole(id interface{}, domainID interface{}, rq interface{}, token interface{}) *SDK_CreateClientRole_Call { + return &SDK_CreateClientRole_Call{Call: _e.mock.On("CreateClientRole", id, domainID, rq, token)} +} + +func (_c *SDK_CreateClientRole_Call) Run(run func(id string, domainID string, rq pkgsdk.RoleReq, token string)) *SDK_CreateClientRole_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(pkgsdk.RoleReq), args[3].(string)) + }) + return _c +} + +func (_c *SDK_CreateClientRole_Call) Return(_a0 pkgsdk.Role, _a1 errors.SDKError) *SDK_CreateClientRole_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_CreateClientRole_Call) RunAndReturn(run func(string, string, pkgsdk.RoleReq, string) (pkgsdk.Role, errors.SDKError)) *SDK_CreateClientRole_Call { + _c.Call.Return(run) + return _c +} + // CreateClients provides a mock function with given fields: client, domainID, token func (_m *SDK) CreateClients(client []pkgsdk.Client, domainID string, token string) ([]pkgsdk.Client, errors.SDKError) { ret := _m.Called(client, domainID, token) @@ -932,6 +1856,36 @@ func (_m *SDK) CreateClients(client []pkgsdk.Client, domainID string, token stri return r0, r1 } +// SDK_CreateClients_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateClients' +type SDK_CreateClients_Call struct { + *mock.Call +} + +// CreateClients is a helper method to define mock.On call +// - client []pkgsdk.Client +// - domainID string +// - token string +func (_e *SDK_Expecter) CreateClients(client interface{}, domainID interface{}, token interface{}) *SDK_CreateClients_Call { + return &SDK_CreateClients_Call{Call: _e.mock.On("CreateClients", client, domainID, token)} +} + +func (_c *SDK_CreateClients_Call) Run(run func(client []pkgsdk.Client, domainID string, token string)) *SDK_CreateClients_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].([]pkgsdk.Client), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_CreateClients_Call) Return(_a0 []pkgsdk.Client, _a1 errors.SDKError) *SDK_CreateClients_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_CreateClients_Call) RunAndReturn(run func([]pkgsdk.Client, string, string) ([]pkgsdk.Client, errors.SDKError)) *SDK_CreateClients_Call { + _c.Call.Return(run) + return _c +} + // CreateDomain provides a mock function with given fields: d, token func (_m *SDK) CreateDomain(d pkgsdk.Domain, token string) (pkgsdk.Domain, errors.SDKError) { ret := _m.Called(d, token) @@ -962,6 +1916,35 @@ func (_m *SDK) CreateDomain(d pkgsdk.Domain, token string) (pkgsdk.Domain, error return r0, r1 } +// SDK_CreateDomain_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateDomain' +type SDK_CreateDomain_Call struct { + *mock.Call +} + +// CreateDomain is a helper method to define mock.On call +// - d pkgsdk.Domain +// - token string +func (_e *SDK_Expecter) CreateDomain(d interface{}, token interface{}) *SDK_CreateDomain_Call { + return &SDK_CreateDomain_Call{Call: _e.mock.On("CreateDomain", d, token)} +} + +func (_c *SDK_CreateDomain_Call) Run(run func(d pkgsdk.Domain, token string)) *SDK_CreateDomain_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(pkgsdk.Domain), args[1].(string)) + }) + return _c +} + +func (_c *SDK_CreateDomain_Call) Return(_a0 pkgsdk.Domain, _a1 errors.SDKError) *SDK_CreateDomain_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_CreateDomain_Call) RunAndReturn(run func(pkgsdk.Domain, string) (pkgsdk.Domain, errors.SDKError)) *SDK_CreateDomain_Call { + _c.Call.Return(run) + return _c +} + // CreateDomainRole provides a mock function with given fields: id, rq, token func (_m *SDK) CreateDomainRole(id string, rq pkgsdk.RoleReq, token string) (pkgsdk.Role, errors.SDKError) { ret := _m.Called(id, rq, token) @@ -992,6 +1975,36 @@ func (_m *SDK) CreateDomainRole(id string, rq pkgsdk.RoleReq, token string) (pkg return r0, r1 } +// SDK_CreateDomainRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateDomainRole' +type SDK_CreateDomainRole_Call struct { + *mock.Call +} + +// CreateDomainRole is a helper method to define mock.On call +// - id string +// - rq pkgsdk.RoleReq +// - token string +func (_e *SDK_Expecter) CreateDomainRole(id interface{}, rq interface{}, token interface{}) *SDK_CreateDomainRole_Call { + return &SDK_CreateDomainRole_Call{Call: _e.mock.On("CreateDomainRole", id, rq, token)} +} + +func (_c *SDK_CreateDomainRole_Call) Run(run func(id string, rq pkgsdk.RoleReq, token string)) *SDK_CreateDomainRole_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(pkgsdk.RoleReq), args[2].(string)) + }) + return _c +} + +func (_c *SDK_CreateDomainRole_Call) Return(_a0 pkgsdk.Role, _a1 errors.SDKError) *SDK_CreateDomainRole_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_CreateDomainRole_Call) RunAndReturn(run func(string, pkgsdk.RoleReq, string) (pkgsdk.Role, errors.SDKError)) *SDK_CreateDomainRole_Call { + _c.Call.Return(run) + return _c +} + // CreateGroup provides a mock function with given fields: group, domainID, token func (_m *SDK) CreateGroup(group pkgsdk.Group, domainID string, token string) (pkgsdk.Group, errors.SDKError) { ret := _m.Called(group, domainID, token) @@ -1022,6 +2035,36 @@ func (_m *SDK) CreateGroup(group pkgsdk.Group, domainID string, token string) (p return r0, r1 } +// SDK_CreateGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateGroup' +type SDK_CreateGroup_Call struct { + *mock.Call +} + +// CreateGroup is a helper method to define mock.On call +// - group pkgsdk.Group +// - domainID string +// - token string +func (_e *SDK_Expecter) CreateGroup(group interface{}, domainID interface{}, token interface{}) *SDK_CreateGroup_Call { + return &SDK_CreateGroup_Call{Call: _e.mock.On("CreateGroup", group, domainID, token)} +} + +func (_c *SDK_CreateGroup_Call) Run(run func(group pkgsdk.Group, domainID string, token string)) *SDK_CreateGroup_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(pkgsdk.Group), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_CreateGroup_Call) Return(_a0 pkgsdk.Group, _a1 errors.SDKError) *SDK_CreateGroup_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_CreateGroup_Call) RunAndReturn(run func(pkgsdk.Group, string, string) (pkgsdk.Group, errors.SDKError)) *SDK_CreateGroup_Call { + _c.Call.Return(run) + return _c +} + // CreateGroupRole provides a mock function with given fields: id, domainID, rq, token func (_m *SDK) CreateGroupRole(id string, domainID string, rq pkgsdk.RoleReq, token string) (pkgsdk.Role, errors.SDKError) { ret := _m.Called(id, domainID, rq, token) @@ -1052,6 +2095,37 @@ func (_m *SDK) CreateGroupRole(id string, domainID string, rq pkgsdk.RoleReq, to return r0, r1 } +// SDK_CreateGroupRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateGroupRole' +type SDK_CreateGroupRole_Call struct { + *mock.Call +} + +// CreateGroupRole is a helper method to define mock.On call +// - id string +// - domainID string +// - rq pkgsdk.RoleReq +// - token string +func (_e *SDK_Expecter) CreateGroupRole(id interface{}, domainID interface{}, rq interface{}, token interface{}) *SDK_CreateGroupRole_Call { + return &SDK_CreateGroupRole_Call{Call: _e.mock.On("CreateGroupRole", id, domainID, rq, token)} +} + +func (_c *SDK_CreateGroupRole_Call) Run(run func(id string, domainID string, rq pkgsdk.RoleReq, token string)) *SDK_CreateGroupRole_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(pkgsdk.RoleReq), args[3].(string)) + }) + return _c +} + +func (_c *SDK_CreateGroupRole_Call) Return(_a0 pkgsdk.Role, _a1 errors.SDKError) *SDK_CreateGroupRole_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_CreateGroupRole_Call) RunAndReturn(run func(string, string, pkgsdk.RoleReq, string) (pkgsdk.Role, errors.SDKError)) *SDK_CreateGroupRole_Call { + _c.Call.Return(run) + return _c +} + // CreateSubscription provides a mock function with given fields: topic, contact, token func (_m *SDK) CreateSubscription(topic string, contact string, token string) (string, errors.SDKError) { ret := _m.Called(topic, contact, token) @@ -1082,6 +2156,36 @@ func (_m *SDK) CreateSubscription(topic string, contact string, token string) (s return r0, r1 } +// SDK_CreateSubscription_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateSubscription' +type SDK_CreateSubscription_Call struct { + *mock.Call +} + +// CreateSubscription is a helper method to define mock.On call +// - topic string +// - contact string +// - token string +func (_e *SDK_Expecter) CreateSubscription(topic interface{}, contact interface{}, token interface{}) *SDK_CreateSubscription_Call { + return &SDK_CreateSubscription_Call{Call: _e.mock.On("CreateSubscription", topic, contact, token)} +} + +func (_c *SDK_CreateSubscription_Call) Run(run func(topic string, contact string, token string)) *SDK_CreateSubscription_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_CreateSubscription_Call) Return(_a0 string, _a1 errors.SDKError) *SDK_CreateSubscription_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_CreateSubscription_Call) RunAndReturn(run func(string, string, string) (string, errors.SDKError)) *SDK_CreateSubscription_Call { + _c.Call.Return(run) + return _c +} + // CreateToken provides a mock function with given fields: lt func (_m *SDK) CreateToken(lt pkgsdk.Login) (pkgsdk.Token, errors.SDKError) { ret := _m.Called(lt) @@ -1112,6 +2216,34 @@ func (_m *SDK) CreateToken(lt pkgsdk.Login) (pkgsdk.Token, errors.SDKError) { return r0, r1 } +// SDK_CreateToken_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateToken' +type SDK_CreateToken_Call struct { + *mock.Call +} + +// CreateToken is a helper method to define mock.On call +// - lt pkgsdk.Login +func (_e *SDK_Expecter) CreateToken(lt interface{}) *SDK_CreateToken_Call { + return &SDK_CreateToken_Call{Call: _e.mock.On("CreateToken", lt)} +} + +func (_c *SDK_CreateToken_Call) Run(run func(lt pkgsdk.Login)) *SDK_CreateToken_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(pkgsdk.Login)) + }) + return _c +} + +func (_c *SDK_CreateToken_Call) Return(_a0 pkgsdk.Token, _a1 errors.SDKError) *SDK_CreateToken_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_CreateToken_Call) RunAndReturn(run func(pkgsdk.Login) (pkgsdk.Token, errors.SDKError)) *SDK_CreateToken_Call { + _c.Call.Return(run) + return _c +} + // CreateUser provides a mock function with given fields: user, token func (_m *SDK) CreateUser(user pkgsdk.User, token string) (pkgsdk.User, errors.SDKError) { ret := _m.Called(user, token) @@ -1142,6 +2274,35 @@ func (_m *SDK) CreateUser(user pkgsdk.User, token string) (pkgsdk.User, errors.S return r0, r1 } +// SDK_CreateUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateUser' +type SDK_CreateUser_Call struct { + *mock.Call +} + +// CreateUser is a helper method to define mock.On call +// - user pkgsdk.User +// - token string +func (_e *SDK_Expecter) CreateUser(user interface{}, token interface{}) *SDK_CreateUser_Call { + return &SDK_CreateUser_Call{Call: _e.mock.On("CreateUser", user, token)} +} + +func (_c *SDK_CreateUser_Call) Run(run func(user pkgsdk.User, token string)) *SDK_CreateUser_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(pkgsdk.User), args[1].(string)) + }) + return _c +} + +func (_c *SDK_CreateUser_Call) Return(_a0 pkgsdk.User, _a1 errors.SDKError) *SDK_CreateUser_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_CreateUser_Call) RunAndReturn(run func(pkgsdk.User, string) (pkgsdk.User, errors.SDKError)) *SDK_CreateUser_Call { + _c.Call.Return(run) + return _c +} + // DeleteChannel provides a mock function with given fields: id, domainID, token func (_m *SDK) DeleteChannel(id string, domainID string, token string) errors.SDKError { ret := _m.Called(id, domainID, token) @@ -1162,6 +2323,36 @@ func (_m *SDK) DeleteChannel(id string, domainID string, token string) errors.SD return r0 } +// SDK_DeleteChannel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteChannel' +type SDK_DeleteChannel_Call struct { + *mock.Call +} + +// DeleteChannel is a helper method to define mock.On call +// - id string +// - domainID string +// - token string +func (_e *SDK_Expecter) DeleteChannel(id interface{}, domainID interface{}, token interface{}) *SDK_DeleteChannel_Call { + return &SDK_DeleteChannel_Call{Call: _e.mock.On("DeleteChannel", id, domainID, token)} +} + +func (_c *SDK_DeleteChannel_Call) Run(run func(id string, domainID string, token string)) *SDK_DeleteChannel_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_DeleteChannel_Call) Return(_a0 errors.SDKError) *SDK_DeleteChannel_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_DeleteChannel_Call) RunAndReturn(run func(string, string, string) errors.SDKError) *SDK_DeleteChannel_Call { + _c.Call.Return(run) + return _c +} + // DeleteClient provides a mock function with given fields: id, domainID, token func (_m *SDK) DeleteClient(id string, domainID string, token string) errors.SDKError { ret := _m.Called(id, domainID, token) @@ -1182,6 +2373,36 @@ func (_m *SDK) DeleteClient(id string, domainID string, token string) errors.SDK return r0 } +// SDK_DeleteClient_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteClient' +type SDK_DeleteClient_Call struct { + *mock.Call +} + +// DeleteClient is a helper method to define mock.On call +// - id string +// - domainID string +// - token string +func (_e *SDK_Expecter) DeleteClient(id interface{}, domainID interface{}, token interface{}) *SDK_DeleteClient_Call { + return &SDK_DeleteClient_Call{Call: _e.mock.On("DeleteClient", id, domainID, token)} +} + +func (_c *SDK_DeleteClient_Call) Run(run func(id string, domainID string, token string)) *SDK_DeleteClient_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_DeleteClient_Call) Return(_a0 errors.SDKError) *SDK_DeleteClient_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_DeleteClient_Call) RunAndReturn(run func(string, string, string) errors.SDKError) *SDK_DeleteClient_Call { + _c.Call.Return(run) + return _c +} + // DeleteClientRole provides a mock function with given fields: id, roleID, domainID, token func (_m *SDK) DeleteClientRole(id string, roleID string, domainID string, token string) errors.SDKError { ret := _m.Called(id, roleID, domainID, token) @@ -1202,6 +2423,37 @@ func (_m *SDK) DeleteClientRole(id string, roleID string, domainID string, token return r0 } +// SDK_DeleteClientRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteClientRole' +type SDK_DeleteClientRole_Call struct { + *mock.Call +} + +// DeleteClientRole is a helper method to define mock.On call +// - id string +// - roleID string +// - domainID string +// - token string +func (_e *SDK_Expecter) DeleteClientRole(id interface{}, roleID interface{}, domainID interface{}, token interface{}) *SDK_DeleteClientRole_Call { + return &SDK_DeleteClientRole_Call{Call: _e.mock.On("DeleteClientRole", id, roleID, domainID, token)} +} + +func (_c *SDK_DeleteClientRole_Call) Run(run func(id string, roleID string, domainID string, token string)) *SDK_DeleteClientRole_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_DeleteClientRole_Call) Return(_a0 errors.SDKError) *SDK_DeleteClientRole_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_DeleteClientRole_Call) RunAndReturn(run func(string, string, string, string) errors.SDKError) *SDK_DeleteClientRole_Call { + _c.Call.Return(run) + return _c +} + // DeleteDomainRole provides a mock function with given fields: id, roleID, token func (_m *SDK) DeleteDomainRole(id string, roleID string, token string) errors.SDKError { ret := _m.Called(id, roleID, token) @@ -1222,6 +2474,36 @@ func (_m *SDK) DeleteDomainRole(id string, roleID string, token string) errors.S return r0 } +// SDK_DeleteDomainRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteDomainRole' +type SDK_DeleteDomainRole_Call struct { + *mock.Call +} + +// DeleteDomainRole is a helper method to define mock.On call +// - id string +// - roleID string +// - token string +func (_e *SDK_Expecter) DeleteDomainRole(id interface{}, roleID interface{}, token interface{}) *SDK_DeleteDomainRole_Call { + return &SDK_DeleteDomainRole_Call{Call: _e.mock.On("DeleteDomainRole", id, roleID, token)} +} + +func (_c *SDK_DeleteDomainRole_Call) Run(run func(id string, roleID string, token string)) *SDK_DeleteDomainRole_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_DeleteDomainRole_Call) Return(_a0 errors.SDKError) *SDK_DeleteDomainRole_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_DeleteDomainRole_Call) RunAndReturn(run func(string, string, string) errors.SDKError) *SDK_DeleteDomainRole_Call { + _c.Call.Return(run) + return _c +} + // DeleteGroup provides a mock function with given fields: id, domainID, token func (_m *SDK) DeleteGroup(id string, domainID string, token string) errors.SDKError { ret := _m.Called(id, domainID, token) @@ -1242,6 +2524,36 @@ func (_m *SDK) DeleteGroup(id string, domainID string, token string) errors.SDKE return r0 } +// SDK_DeleteGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteGroup' +type SDK_DeleteGroup_Call struct { + *mock.Call +} + +// DeleteGroup is a helper method to define mock.On call +// - id string +// - domainID string +// - token string +func (_e *SDK_Expecter) DeleteGroup(id interface{}, domainID interface{}, token interface{}) *SDK_DeleteGroup_Call { + return &SDK_DeleteGroup_Call{Call: _e.mock.On("DeleteGroup", id, domainID, token)} +} + +func (_c *SDK_DeleteGroup_Call) Run(run func(id string, domainID string, token string)) *SDK_DeleteGroup_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_DeleteGroup_Call) Return(_a0 errors.SDKError) *SDK_DeleteGroup_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_DeleteGroup_Call) RunAndReturn(run func(string, string, string) errors.SDKError) *SDK_DeleteGroup_Call { + _c.Call.Return(run) + return _c +} + // DeleteGroupRole provides a mock function with given fields: id, roleID, domainID, token func (_m *SDK) DeleteGroupRole(id string, roleID string, domainID string, token string) errors.SDKError { ret := _m.Called(id, roleID, domainID, token) @@ -1262,6 +2574,37 @@ func (_m *SDK) DeleteGroupRole(id string, roleID string, domainID string, token return r0 } +// SDK_DeleteGroupRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteGroupRole' +type SDK_DeleteGroupRole_Call struct { + *mock.Call +} + +// DeleteGroupRole is a helper method to define mock.On call +// - id string +// - roleID string +// - domainID string +// - token string +func (_e *SDK_Expecter) DeleteGroupRole(id interface{}, roleID interface{}, domainID interface{}, token interface{}) *SDK_DeleteGroupRole_Call { + return &SDK_DeleteGroupRole_Call{Call: _e.mock.On("DeleteGroupRole", id, roleID, domainID, token)} +} + +func (_c *SDK_DeleteGroupRole_Call) Run(run func(id string, roleID string, domainID string, token string)) *SDK_DeleteGroupRole_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_DeleteGroupRole_Call) Return(_a0 errors.SDKError) *SDK_DeleteGroupRole_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_DeleteGroupRole_Call) RunAndReturn(run func(string, string, string, string) errors.SDKError) *SDK_DeleteGroupRole_Call { + _c.Call.Return(run) + return _c +} + // DeleteInvitation provides a mock function with given fields: userID, domainID, token func (_m *SDK) DeleteInvitation(userID string, domainID string, token string) error { ret := _m.Called(userID, domainID, token) @@ -1280,6 +2623,36 @@ func (_m *SDK) DeleteInvitation(userID string, domainID string, token string) er return r0 } +// SDK_DeleteInvitation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteInvitation' +type SDK_DeleteInvitation_Call struct { + *mock.Call +} + +// DeleteInvitation is a helper method to define mock.On call +// - userID string +// - domainID string +// - token string +func (_e *SDK_Expecter) DeleteInvitation(userID interface{}, domainID interface{}, token interface{}) *SDK_DeleteInvitation_Call { + return &SDK_DeleteInvitation_Call{Call: _e.mock.On("DeleteInvitation", userID, domainID, token)} +} + +func (_c *SDK_DeleteInvitation_Call) Run(run func(userID string, domainID string, token string)) *SDK_DeleteInvitation_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_DeleteInvitation_Call) Return(err error) *SDK_DeleteInvitation_Call { + _c.Call.Return(err) + return _c +} + +func (_c *SDK_DeleteInvitation_Call) RunAndReturn(run func(string, string, string) error) *SDK_DeleteInvitation_Call { + _c.Call.Return(run) + return _c +} + // DeleteSubscription provides a mock function with given fields: id, token func (_m *SDK) DeleteSubscription(id string, token string) errors.SDKError { ret := _m.Called(id, token) @@ -1300,6 +2673,35 @@ func (_m *SDK) DeleteSubscription(id string, token string) errors.SDKError { return r0 } +// SDK_DeleteSubscription_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteSubscription' +type SDK_DeleteSubscription_Call struct { + *mock.Call +} + +// DeleteSubscription is a helper method to define mock.On call +// - id string +// - token string +func (_e *SDK_Expecter) DeleteSubscription(id interface{}, token interface{}) *SDK_DeleteSubscription_Call { + return &SDK_DeleteSubscription_Call{Call: _e.mock.On("DeleteSubscription", id, token)} +} + +func (_c *SDK_DeleteSubscription_Call) Run(run func(id string, token string)) *SDK_DeleteSubscription_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *SDK_DeleteSubscription_Call) Return(_a0 errors.SDKError) *SDK_DeleteSubscription_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_DeleteSubscription_Call) RunAndReturn(run func(string, string) errors.SDKError) *SDK_DeleteSubscription_Call { + _c.Call.Return(run) + return _c +} + // DeleteUser provides a mock function with given fields: id, token func (_m *SDK) DeleteUser(id string, token string) errors.SDKError { ret := _m.Called(id, token) @@ -1320,6 +2722,35 @@ func (_m *SDK) DeleteUser(id string, token string) errors.SDKError { return r0 } +// SDK_DeleteUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteUser' +type SDK_DeleteUser_Call struct { + *mock.Call +} + +// DeleteUser is a helper method to define mock.On call +// - id string +// - token string +func (_e *SDK_Expecter) DeleteUser(id interface{}, token interface{}) *SDK_DeleteUser_Call { + return &SDK_DeleteUser_Call{Call: _e.mock.On("DeleteUser", id, token)} +} + +func (_c *SDK_DeleteUser_Call) Run(run func(id string, token string)) *SDK_DeleteUser_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *SDK_DeleteUser_Call) Return(_a0 errors.SDKError) *SDK_DeleteUser_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_DeleteUser_Call) RunAndReturn(run func(string, string) errors.SDKError) *SDK_DeleteUser_Call { + _c.Call.Return(run) + return _c +} + // DisableChannel provides a mock function with given fields: id, domainID, token func (_m *SDK) DisableChannel(id string, domainID string, token string) (pkgsdk.Channel, errors.SDKError) { ret := _m.Called(id, domainID, token) @@ -1350,6 +2781,36 @@ func (_m *SDK) DisableChannel(id string, domainID string, token string) (pkgsdk. return r0, r1 } +// SDK_DisableChannel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableChannel' +type SDK_DisableChannel_Call struct { + *mock.Call +} + +// DisableChannel is a helper method to define mock.On call +// - id string +// - domainID string +// - token string +func (_e *SDK_Expecter) DisableChannel(id interface{}, domainID interface{}, token interface{}) *SDK_DisableChannel_Call { + return &SDK_DisableChannel_Call{Call: _e.mock.On("DisableChannel", id, domainID, token)} +} + +func (_c *SDK_DisableChannel_Call) Run(run func(id string, domainID string, token string)) *SDK_DisableChannel_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_DisableChannel_Call) Return(_a0 pkgsdk.Channel, _a1 errors.SDKError) *SDK_DisableChannel_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_DisableChannel_Call) RunAndReturn(run func(string, string, string) (pkgsdk.Channel, errors.SDKError)) *SDK_DisableChannel_Call { + _c.Call.Return(run) + return _c +} + // DisableClient provides a mock function with given fields: id, domainID, token func (_m *SDK) DisableClient(id string, domainID string, token string) (pkgsdk.Client, errors.SDKError) { ret := _m.Called(id, domainID, token) @@ -1380,6 +2841,36 @@ func (_m *SDK) DisableClient(id string, domainID string, token string) (pkgsdk.C return r0, r1 } +// SDK_DisableClient_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableClient' +type SDK_DisableClient_Call struct { + *mock.Call +} + +// DisableClient is a helper method to define mock.On call +// - id string +// - domainID string +// - token string +func (_e *SDK_Expecter) DisableClient(id interface{}, domainID interface{}, token interface{}) *SDK_DisableClient_Call { + return &SDK_DisableClient_Call{Call: _e.mock.On("DisableClient", id, domainID, token)} +} + +func (_c *SDK_DisableClient_Call) Run(run func(id string, domainID string, token string)) *SDK_DisableClient_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_DisableClient_Call) Return(_a0 pkgsdk.Client, _a1 errors.SDKError) *SDK_DisableClient_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_DisableClient_Call) RunAndReturn(run func(string, string, string) (pkgsdk.Client, errors.SDKError)) *SDK_DisableClient_Call { + _c.Call.Return(run) + return _c +} + // DisableDomain provides a mock function with given fields: domainID, token func (_m *SDK) DisableDomain(domainID string, token string) errors.SDKError { ret := _m.Called(domainID, token) @@ -1400,7 +2891,36 @@ func (_m *SDK) DisableDomain(domainID string, token string) errors.SDKError { return r0 } -// DisableGroup provides a mock function with given fields: id, domainID, token +// SDK_DisableDomain_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableDomain' +type SDK_DisableDomain_Call struct { + *mock.Call +} + +// DisableDomain is a helper method to define mock.On call +// - domainID string +// - token string +func (_e *SDK_Expecter) DisableDomain(domainID interface{}, token interface{}) *SDK_DisableDomain_Call { + return &SDK_DisableDomain_Call{Call: _e.mock.On("DisableDomain", domainID, token)} +} + +func (_c *SDK_DisableDomain_Call) Run(run func(domainID string, token string)) *SDK_DisableDomain_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *SDK_DisableDomain_Call) Return(_a0 errors.SDKError) *SDK_DisableDomain_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_DisableDomain_Call) RunAndReturn(run func(string, string) errors.SDKError) *SDK_DisableDomain_Call { + _c.Call.Return(run) + return _c +} + +// DisableGroup provides a mock function with given fields: id, domainID, token func (_m *SDK) DisableGroup(id string, domainID string, token string) (pkgsdk.Group, errors.SDKError) { ret := _m.Called(id, domainID, token) @@ -1430,6 +2950,36 @@ func (_m *SDK) DisableGroup(id string, domainID string, token string) (pkgsdk.Gr return r0, r1 } +// SDK_DisableGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableGroup' +type SDK_DisableGroup_Call struct { + *mock.Call +} + +// DisableGroup is a helper method to define mock.On call +// - id string +// - domainID string +// - token string +func (_e *SDK_Expecter) DisableGroup(id interface{}, domainID interface{}, token interface{}) *SDK_DisableGroup_Call { + return &SDK_DisableGroup_Call{Call: _e.mock.On("DisableGroup", id, domainID, token)} +} + +func (_c *SDK_DisableGroup_Call) Run(run func(id string, domainID string, token string)) *SDK_DisableGroup_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_DisableGroup_Call) Return(_a0 pkgsdk.Group, _a1 errors.SDKError) *SDK_DisableGroup_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_DisableGroup_Call) RunAndReturn(run func(string, string, string) (pkgsdk.Group, errors.SDKError)) *SDK_DisableGroup_Call { + _c.Call.Return(run) + return _c +} + // DisableUser provides a mock function with given fields: id, token func (_m *SDK) DisableUser(id string, token string) (pkgsdk.User, errors.SDKError) { ret := _m.Called(id, token) @@ -1460,6 +3010,35 @@ func (_m *SDK) DisableUser(id string, token string) (pkgsdk.User, errors.SDKErro return r0, r1 } +// SDK_DisableUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableUser' +type SDK_DisableUser_Call struct { + *mock.Call +} + +// DisableUser is a helper method to define mock.On call +// - id string +// - token string +func (_e *SDK_Expecter) DisableUser(id interface{}, token interface{}) *SDK_DisableUser_Call { + return &SDK_DisableUser_Call{Call: _e.mock.On("DisableUser", id, token)} +} + +func (_c *SDK_DisableUser_Call) Run(run func(id string, token string)) *SDK_DisableUser_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *SDK_DisableUser_Call) Return(_a0 pkgsdk.User, _a1 errors.SDKError) *SDK_DisableUser_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_DisableUser_Call) RunAndReturn(run func(string, string) (pkgsdk.User, errors.SDKError)) *SDK_DisableUser_Call { + _c.Call.Return(run) + return _c +} + // Disconnect provides a mock function with given fields: conn, domainID, token func (_m *SDK) Disconnect(conn pkgsdk.Connection, domainID string, token string) errors.SDKError { ret := _m.Called(conn, domainID, token) @@ -1480,6 +3059,36 @@ func (_m *SDK) Disconnect(conn pkgsdk.Connection, domainID string, token string) return r0 } +// SDK_Disconnect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Disconnect' +type SDK_Disconnect_Call struct { + *mock.Call +} + +// Disconnect is a helper method to define mock.On call +// - conn pkgsdk.Connection +// - domainID string +// - token string +func (_e *SDK_Expecter) Disconnect(conn interface{}, domainID interface{}, token interface{}) *SDK_Disconnect_Call { + return &SDK_Disconnect_Call{Call: _e.mock.On("Disconnect", conn, domainID, token)} +} + +func (_c *SDK_Disconnect_Call) Run(run func(conn pkgsdk.Connection, domainID string, token string)) *SDK_Disconnect_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(pkgsdk.Connection), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_Disconnect_Call) Return(_a0 errors.SDKError) *SDK_Disconnect_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_Disconnect_Call) RunAndReturn(run func(pkgsdk.Connection, string, string) errors.SDKError) *SDK_Disconnect_Call { + _c.Call.Return(run) + return _c +} + // DisconnectClients provides a mock function with given fields: channelID, clientIDs, connTypes, domainID, token func (_m *SDK) DisconnectClients(channelID string, clientIDs []string, connTypes []string, domainID string, token string) errors.SDKError { ret := _m.Called(channelID, clientIDs, connTypes, domainID, token) @@ -1500,6 +3109,38 @@ func (_m *SDK) DisconnectClients(channelID string, clientIDs []string, connTypes return r0 } +// SDK_DisconnectClients_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisconnectClients' +type SDK_DisconnectClients_Call struct { + *mock.Call +} + +// DisconnectClients is a helper method to define mock.On call +// - channelID string +// - clientIDs []string +// - connTypes []string +// - domainID string +// - token string +func (_e *SDK_Expecter) DisconnectClients(channelID interface{}, clientIDs interface{}, connTypes interface{}, domainID interface{}, token interface{}) *SDK_DisconnectClients_Call { + return &SDK_DisconnectClients_Call{Call: _e.mock.On("DisconnectClients", channelID, clientIDs, connTypes, domainID, token)} +} + +func (_c *SDK_DisconnectClients_Call) Run(run func(channelID string, clientIDs []string, connTypes []string, domainID string, token string)) *SDK_DisconnectClients_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].([]string), args[2].([]string), args[3].(string), args[4].(string)) + }) + return _c +} + +func (_c *SDK_DisconnectClients_Call) Return(_a0 errors.SDKError) *SDK_DisconnectClients_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_DisconnectClients_Call) RunAndReturn(run func(string, []string, []string, string, string) errors.SDKError) *SDK_DisconnectClients_Call { + _c.Call.Return(run) + return _c +} + // Domain provides a mock function with given fields: domainID, token func (_m *SDK) Domain(domainID string, token string) (pkgsdk.Domain, errors.SDKError) { ret := _m.Called(domainID, token) @@ -1530,6 +3171,35 @@ func (_m *SDK) Domain(domainID string, token string) (pkgsdk.Domain, errors.SDKE return r0, r1 } +// SDK_Domain_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Domain' +type SDK_Domain_Call struct { + *mock.Call +} + +// Domain is a helper method to define mock.On call +// - domainID string +// - token string +func (_e *SDK_Expecter) Domain(domainID interface{}, token interface{}) *SDK_Domain_Call { + return &SDK_Domain_Call{Call: _e.mock.On("Domain", domainID, token)} +} + +func (_c *SDK_Domain_Call) Run(run func(domainID string, token string)) *SDK_Domain_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *SDK_Domain_Call) Return(_a0 pkgsdk.Domain, _a1 errors.SDKError) *SDK_Domain_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_Domain_Call) RunAndReturn(run func(string, string) (pkgsdk.Domain, errors.SDKError)) *SDK_Domain_Call { + _c.Call.Return(run) + return _c +} + // DomainRole provides a mock function with given fields: id, roleID, token func (_m *SDK) DomainRole(id string, roleID string, token string) (pkgsdk.Role, errors.SDKError) { ret := _m.Called(id, roleID, token) @@ -1560,6 +3230,36 @@ func (_m *SDK) DomainRole(id string, roleID string, token string) (pkgsdk.Role, return r0, r1 } +// SDK_DomainRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DomainRole' +type SDK_DomainRole_Call struct { + *mock.Call +} + +// DomainRole is a helper method to define mock.On call +// - id string +// - roleID string +// - token string +func (_e *SDK_Expecter) DomainRole(id interface{}, roleID interface{}, token interface{}) *SDK_DomainRole_Call { + return &SDK_DomainRole_Call{Call: _e.mock.On("DomainRole", id, roleID, token)} +} + +func (_c *SDK_DomainRole_Call) Run(run func(id string, roleID string, token string)) *SDK_DomainRole_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_DomainRole_Call) Return(_a0 pkgsdk.Role, _a1 errors.SDKError) *SDK_DomainRole_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_DomainRole_Call) RunAndReturn(run func(string, string, string) (pkgsdk.Role, errors.SDKError)) *SDK_DomainRole_Call { + _c.Call.Return(run) + return _c +} + // DomainRoleActions provides a mock function with given fields: id, roleID, token func (_m *SDK) DomainRoleActions(id string, roleID string, token string) ([]string, errors.SDKError) { ret := _m.Called(id, roleID, token) @@ -1592,6 +3292,36 @@ func (_m *SDK) DomainRoleActions(id string, roleID string, token string) ([]stri return r0, r1 } +// SDK_DomainRoleActions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DomainRoleActions' +type SDK_DomainRoleActions_Call struct { + *mock.Call +} + +// DomainRoleActions is a helper method to define mock.On call +// - id string +// - roleID string +// - token string +func (_e *SDK_Expecter) DomainRoleActions(id interface{}, roleID interface{}, token interface{}) *SDK_DomainRoleActions_Call { + return &SDK_DomainRoleActions_Call{Call: _e.mock.On("DomainRoleActions", id, roleID, token)} +} + +func (_c *SDK_DomainRoleActions_Call) Run(run func(id string, roleID string, token string)) *SDK_DomainRoleActions_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_DomainRoleActions_Call) Return(_a0 []string, _a1 errors.SDKError) *SDK_DomainRoleActions_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_DomainRoleActions_Call) RunAndReturn(run func(string, string, string) ([]string, errors.SDKError)) *SDK_DomainRoleActions_Call { + _c.Call.Return(run) + return _c +} + // DomainRoleMembers provides a mock function with given fields: id, roleID, pm, token func (_m *SDK) DomainRoleMembers(id string, roleID string, pm pkgsdk.PageMetadata, token string) (pkgsdk.RoleMembersPage, errors.SDKError) { ret := _m.Called(id, roleID, pm, token) @@ -1622,6 +3352,37 @@ func (_m *SDK) DomainRoleMembers(id string, roleID string, pm pkgsdk.PageMetadat return r0, r1 } +// SDK_DomainRoleMembers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DomainRoleMembers' +type SDK_DomainRoleMembers_Call struct { + *mock.Call +} + +// DomainRoleMembers is a helper method to define mock.On call +// - id string +// - roleID string +// - pm pkgsdk.PageMetadata +// - token string +func (_e *SDK_Expecter) DomainRoleMembers(id interface{}, roleID interface{}, pm interface{}, token interface{}) *SDK_DomainRoleMembers_Call { + return &SDK_DomainRoleMembers_Call{Call: _e.mock.On("DomainRoleMembers", id, roleID, pm, token)} +} + +func (_c *SDK_DomainRoleMembers_Call) Run(run func(id string, roleID string, pm pkgsdk.PageMetadata, token string)) *SDK_DomainRoleMembers_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(pkgsdk.PageMetadata), args[3].(string)) + }) + return _c +} + +func (_c *SDK_DomainRoleMembers_Call) Return(_a0 pkgsdk.RoleMembersPage, _a1 errors.SDKError) *SDK_DomainRoleMembers_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_DomainRoleMembers_Call) RunAndReturn(run func(string, string, pkgsdk.PageMetadata, string) (pkgsdk.RoleMembersPage, errors.SDKError)) *SDK_DomainRoleMembers_Call { + _c.Call.Return(run) + return _c +} + // DomainRoles provides a mock function with given fields: id, pm, token func (_m *SDK) DomainRoles(id string, pm pkgsdk.PageMetadata, token string) (pkgsdk.RolesPage, errors.SDKError) { ret := _m.Called(id, pm, token) @@ -1652,6 +3413,36 @@ func (_m *SDK) DomainRoles(id string, pm pkgsdk.PageMetadata, token string) (pkg return r0, r1 } +// SDK_DomainRoles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DomainRoles' +type SDK_DomainRoles_Call struct { + *mock.Call +} + +// DomainRoles is a helper method to define mock.On call +// - id string +// - pm pkgsdk.PageMetadata +// - token string +func (_e *SDK_Expecter) DomainRoles(id interface{}, pm interface{}, token interface{}) *SDK_DomainRoles_Call { + return &SDK_DomainRoles_Call{Call: _e.mock.On("DomainRoles", id, pm, token)} +} + +func (_c *SDK_DomainRoles_Call) Run(run func(id string, pm pkgsdk.PageMetadata, token string)) *SDK_DomainRoles_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(pkgsdk.PageMetadata), args[2].(string)) + }) + return _c +} + +func (_c *SDK_DomainRoles_Call) Return(_a0 pkgsdk.RolesPage, _a1 errors.SDKError) *SDK_DomainRoles_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_DomainRoles_Call) RunAndReturn(run func(string, pkgsdk.PageMetadata, string) (pkgsdk.RolesPage, errors.SDKError)) *SDK_DomainRoles_Call { + _c.Call.Return(run) + return _c +} + // Domains provides a mock function with given fields: pm, token func (_m *SDK) Domains(pm pkgsdk.PageMetadata, token string) (pkgsdk.DomainsPage, errors.SDKError) { ret := _m.Called(pm, token) @@ -1682,6 +3473,35 @@ func (_m *SDK) Domains(pm pkgsdk.PageMetadata, token string) (pkgsdk.DomainsPage return r0, r1 } +// SDK_Domains_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Domains' +type SDK_Domains_Call struct { + *mock.Call +} + +// Domains is a helper method to define mock.On call +// - pm pkgsdk.PageMetadata +// - token string +func (_e *SDK_Expecter) Domains(pm interface{}, token interface{}) *SDK_Domains_Call { + return &SDK_Domains_Call{Call: _e.mock.On("Domains", pm, token)} +} + +func (_c *SDK_Domains_Call) Run(run func(pm pkgsdk.PageMetadata, token string)) *SDK_Domains_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(pkgsdk.PageMetadata), args[1].(string)) + }) + return _c +} + +func (_c *SDK_Domains_Call) Return(_a0 pkgsdk.DomainsPage, _a1 errors.SDKError) *SDK_Domains_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_Domains_Call) RunAndReturn(run func(pkgsdk.PageMetadata, string) (pkgsdk.DomainsPage, errors.SDKError)) *SDK_Domains_Call { + _c.Call.Return(run) + return _c +} + // EnableChannel provides a mock function with given fields: id, domainID, token func (_m *SDK) EnableChannel(id string, domainID string, token string) (pkgsdk.Channel, errors.SDKError) { ret := _m.Called(id, domainID, token) @@ -1712,6 +3532,36 @@ func (_m *SDK) EnableChannel(id string, domainID string, token string) (pkgsdk.C return r0, r1 } +// SDK_EnableChannel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableChannel' +type SDK_EnableChannel_Call struct { + *mock.Call +} + +// EnableChannel is a helper method to define mock.On call +// - id string +// - domainID string +// - token string +func (_e *SDK_Expecter) EnableChannel(id interface{}, domainID interface{}, token interface{}) *SDK_EnableChannel_Call { + return &SDK_EnableChannel_Call{Call: _e.mock.On("EnableChannel", id, domainID, token)} +} + +func (_c *SDK_EnableChannel_Call) Run(run func(id string, domainID string, token string)) *SDK_EnableChannel_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_EnableChannel_Call) Return(_a0 pkgsdk.Channel, _a1 errors.SDKError) *SDK_EnableChannel_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_EnableChannel_Call) RunAndReturn(run func(string, string, string) (pkgsdk.Channel, errors.SDKError)) *SDK_EnableChannel_Call { + _c.Call.Return(run) + return _c +} + // EnableClient provides a mock function with given fields: id, domainID, token func (_m *SDK) EnableClient(id string, domainID string, token string) (pkgsdk.Client, errors.SDKError) { ret := _m.Called(id, domainID, token) @@ -1742,6 +3592,36 @@ func (_m *SDK) EnableClient(id string, domainID string, token string) (pkgsdk.Cl return r0, r1 } +// SDK_EnableClient_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableClient' +type SDK_EnableClient_Call struct { + *mock.Call +} + +// EnableClient is a helper method to define mock.On call +// - id string +// - domainID string +// - token string +func (_e *SDK_Expecter) EnableClient(id interface{}, domainID interface{}, token interface{}) *SDK_EnableClient_Call { + return &SDK_EnableClient_Call{Call: _e.mock.On("EnableClient", id, domainID, token)} +} + +func (_c *SDK_EnableClient_Call) Run(run func(id string, domainID string, token string)) *SDK_EnableClient_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_EnableClient_Call) Return(_a0 pkgsdk.Client, _a1 errors.SDKError) *SDK_EnableClient_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_EnableClient_Call) RunAndReturn(run func(string, string, string) (pkgsdk.Client, errors.SDKError)) *SDK_EnableClient_Call { + _c.Call.Return(run) + return _c +} + // EnableDomain provides a mock function with given fields: domainID, token func (_m *SDK) EnableDomain(domainID string, token string) errors.SDKError { ret := _m.Called(domainID, token) @@ -1762,6 +3642,35 @@ func (_m *SDK) EnableDomain(domainID string, token string) errors.SDKError { return r0 } +// SDK_EnableDomain_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableDomain' +type SDK_EnableDomain_Call struct { + *mock.Call +} + +// EnableDomain is a helper method to define mock.On call +// - domainID string +// - token string +func (_e *SDK_Expecter) EnableDomain(domainID interface{}, token interface{}) *SDK_EnableDomain_Call { + return &SDK_EnableDomain_Call{Call: _e.mock.On("EnableDomain", domainID, token)} +} + +func (_c *SDK_EnableDomain_Call) Run(run func(domainID string, token string)) *SDK_EnableDomain_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *SDK_EnableDomain_Call) Return(_a0 errors.SDKError) *SDK_EnableDomain_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_EnableDomain_Call) RunAndReturn(run func(string, string) errors.SDKError) *SDK_EnableDomain_Call { + _c.Call.Return(run) + return _c +} + // EnableGroup provides a mock function with given fields: id, domainID, token func (_m *SDK) EnableGroup(id string, domainID string, token string) (pkgsdk.Group, errors.SDKError) { ret := _m.Called(id, domainID, token) @@ -1792,6 +3701,36 @@ func (_m *SDK) EnableGroup(id string, domainID string, token string) (pkgsdk.Gro return r0, r1 } +// SDK_EnableGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableGroup' +type SDK_EnableGroup_Call struct { + *mock.Call +} + +// EnableGroup is a helper method to define mock.On call +// - id string +// - domainID string +// - token string +func (_e *SDK_Expecter) EnableGroup(id interface{}, domainID interface{}, token interface{}) *SDK_EnableGroup_Call { + return &SDK_EnableGroup_Call{Call: _e.mock.On("EnableGroup", id, domainID, token)} +} + +func (_c *SDK_EnableGroup_Call) Run(run func(id string, domainID string, token string)) *SDK_EnableGroup_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_EnableGroup_Call) Return(_a0 pkgsdk.Group, _a1 errors.SDKError) *SDK_EnableGroup_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_EnableGroup_Call) RunAndReturn(run func(string, string, string) (pkgsdk.Group, errors.SDKError)) *SDK_EnableGroup_Call { + _c.Call.Return(run) + return _c +} + // EnableUser provides a mock function with given fields: id, token func (_m *SDK) EnableUser(id string, token string) (pkgsdk.User, errors.SDKError) { ret := _m.Called(id, token) @@ -1822,6 +3761,35 @@ func (_m *SDK) EnableUser(id string, token string) (pkgsdk.User, errors.SDKError return r0, r1 } +// SDK_EnableUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableUser' +type SDK_EnableUser_Call struct { + *mock.Call +} + +// EnableUser is a helper method to define mock.On call +// - id string +// - token string +func (_e *SDK_Expecter) EnableUser(id interface{}, token interface{}) *SDK_EnableUser_Call { + return &SDK_EnableUser_Call{Call: _e.mock.On("EnableUser", id, token)} +} + +func (_c *SDK_EnableUser_Call) Run(run func(id string, token string)) *SDK_EnableUser_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *SDK_EnableUser_Call) Return(_a0 pkgsdk.User, _a1 errors.SDKError) *SDK_EnableUser_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_EnableUser_Call) RunAndReturn(run func(string, string) (pkgsdk.User, errors.SDKError)) *SDK_EnableUser_Call { + _c.Call.Return(run) + return _c +} + // FreezeDomain provides a mock function with given fields: domainID, token func (_m *SDK) FreezeDomain(domainID string, token string) errors.SDKError { ret := _m.Called(domainID, token) @@ -1842,6 +3810,35 @@ func (_m *SDK) FreezeDomain(domainID string, token string) errors.SDKError { return r0 } +// SDK_FreezeDomain_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FreezeDomain' +type SDK_FreezeDomain_Call struct { + *mock.Call +} + +// FreezeDomain is a helper method to define mock.On call +// - domainID string +// - token string +func (_e *SDK_Expecter) FreezeDomain(domainID interface{}, token interface{}) *SDK_FreezeDomain_Call { + return &SDK_FreezeDomain_Call{Call: _e.mock.On("FreezeDomain", domainID, token)} +} + +func (_c *SDK_FreezeDomain_Call) Run(run func(domainID string, token string)) *SDK_FreezeDomain_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *SDK_FreezeDomain_Call) Return(_a0 errors.SDKError) *SDK_FreezeDomain_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_FreezeDomain_Call) RunAndReturn(run func(string, string) errors.SDKError) *SDK_FreezeDomain_Call { + _c.Call.Return(run) + return _c +} + // Group provides a mock function with given fields: id, domainID, token func (_m *SDK) Group(id string, domainID string, token string) (pkgsdk.Group, errors.SDKError) { ret := _m.Called(id, domainID, token) @@ -1872,6 +3869,36 @@ func (_m *SDK) Group(id string, domainID string, token string) (pkgsdk.Group, er return r0, r1 } +// SDK_Group_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Group' +type SDK_Group_Call struct { + *mock.Call +} + +// Group is a helper method to define mock.On call +// - id string +// - domainID string +// - token string +func (_e *SDK_Expecter) Group(id interface{}, domainID interface{}, token interface{}) *SDK_Group_Call { + return &SDK_Group_Call{Call: _e.mock.On("Group", id, domainID, token)} +} + +func (_c *SDK_Group_Call) Run(run func(id string, domainID string, token string)) *SDK_Group_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_Group_Call) Return(_a0 pkgsdk.Group, _a1 errors.SDKError) *SDK_Group_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_Group_Call) RunAndReturn(run func(string, string, string) (pkgsdk.Group, errors.SDKError)) *SDK_Group_Call { + _c.Call.Return(run) + return _c +} + // GroupRole provides a mock function with given fields: id, roleID, domainID, token func (_m *SDK) GroupRole(id string, roleID string, domainID string, token string) (pkgsdk.Role, errors.SDKError) { ret := _m.Called(id, roleID, domainID, token) @@ -1902,6 +3929,37 @@ func (_m *SDK) GroupRole(id string, roleID string, domainID string, token string return r0, r1 } +// SDK_GroupRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GroupRole' +type SDK_GroupRole_Call struct { + *mock.Call +} + +// GroupRole is a helper method to define mock.On call +// - id string +// - roleID string +// - domainID string +// - token string +func (_e *SDK_Expecter) GroupRole(id interface{}, roleID interface{}, domainID interface{}, token interface{}) *SDK_GroupRole_Call { + return &SDK_GroupRole_Call{Call: _e.mock.On("GroupRole", id, roleID, domainID, token)} +} + +func (_c *SDK_GroupRole_Call) Run(run func(id string, roleID string, domainID string, token string)) *SDK_GroupRole_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_GroupRole_Call) Return(_a0 pkgsdk.Role, _a1 errors.SDKError) *SDK_GroupRole_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_GroupRole_Call) RunAndReturn(run func(string, string, string, string) (pkgsdk.Role, errors.SDKError)) *SDK_GroupRole_Call { + _c.Call.Return(run) + return _c +} + // GroupRoleActions provides a mock function with given fields: id, roleID, domainID, token func (_m *SDK) GroupRoleActions(id string, roleID string, domainID string, token string) ([]string, errors.SDKError) { ret := _m.Called(id, roleID, domainID, token) @@ -1934,6 +3992,37 @@ func (_m *SDK) GroupRoleActions(id string, roleID string, domainID string, token return r0, r1 } +// SDK_GroupRoleActions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GroupRoleActions' +type SDK_GroupRoleActions_Call struct { + *mock.Call +} + +// GroupRoleActions is a helper method to define mock.On call +// - id string +// - roleID string +// - domainID string +// - token string +func (_e *SDK_Expecter) GroupRoleActions(id interface{}, roleID interface{}, domainID interface{}, token interface{}) *SDK_GroupRoleActions_Call { + return &SDK_GroupRoleActions_Call{Call: _e.mock.On("GroupRoleActions", id, roleID, domainID, token)} +} + +func (_c *SDK_GroupRoleActions_Call) Run(run func(id string, roleID string, domainID string, token string)) *SDK_GroupRoleActions_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_GroupRoleActions_Call) Return(_a0 []string, _a1 errors.SDKError) *SDK_GroupRoleActions_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_GroupRoleActions_Call) RunAndReturn(run func(string, string, string, string) ([]string, errors.SDKError)) *SDK_GroupRoleActions_Call { + _c.Call.Return(run) + return _c +} + // GroupRoleMembers provides a mock function with given fields: id, roleID, domainID, pm, token func (_m *SDK) GroupRoleMembers(id string, roleID string, domainID string, pm pkgsdk.PageMetadata, token string) (pkgsdk.RoleMembersPage, errors.SDKError) { ret := _m.Called(id, roleID, domainID, pm, token) @@ -1964,6 +4053,38 @@ func (_m *SDK) GroupRoleMembers(id string, roleID string, domainID string, pm pk return r0, r1 } +// SDK_GroupRoleMembers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GroupRoleMembers' +type SDK_GroupRoleMembers_Call struct { + *mock.Call +} + +// GroupRoleMembers is a helper method to define mock.On call +// - id string +// - roleID string +// - domainID string +// - pm pkgsdk.PageMetadata +// - token string +func (_e *SDK_Expecter) GroupRoleMembers(id interface{}, roleID interface{}, domainID interface{}, pm interface{}, token interface{}) *SDK_GroupRoleMembers_Call { + return &SDK_GroupRoleMembers_Call{Call: _e.mock.On("GroupRoleMembers", id, roleID, domainID, pm, token)} +} + +func (_c *SDK_GroupRoleMembers_Call) Run(run func(id string, roleID string, domainID string, pm pkgsdk.PageMetadata, token string)) *SDK_GroupRoleMembers_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string), args[3].(pkgsdk.PageMetadata), args[4].(string)) + }) + return _c +} + +func (_c *SDK_GroupRoleMembers_Call) Return(_a0 pkgsdk.RoleMembersPage, _a1 errors.SDKError) *SDK_GroupRoleMembers_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_GroupRoleMembers_Call) RunAndReturn(run func(string, string, string, pkgsdk.PageMetadata, string) (pkgsdk.RoleMembersPage, errors.SDKError)) *SDK_GroupRoleMembers_Call { + _c.Call.Return(run) + return _c +} + // GroupRoles provides a mock function with given fields: id, domainID, pm, token func (_m *SDK) GroupRoles(id string, domainID string, pm pkgsdk.PageMetadata, token string) (pkgsdk.RolesPage, errors.SDKError) { ret := _m.Called(id, domainID, pm, token) @@ -1994,6 +4115,37 @@ func (_m *SDK) GroupRoles(id string, domainID string, pm pkgsdk.PageMetadata, to return r0, r1 } +// SDK_GroupRoles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GroupRoles' +type SDK_GroupRoles_Call struct { + *mock.Call +} + +// GroupRoles is a helper method to define mock.On call +// - id string +// - domainID string +// - pm pkgsdk.PageMetadata +// - token string +func (_e *SDK_Expecter) GroupRoles(id interface{}, domainID interface{}, pm interface{}, token interface{}) *SDK_GroupRoles_Call { + return &SDK_GroupRoles_Call{Call: _e.mock.On("GroupRoles", id, domainID, pm, token)} +} + +func (_c *SDK_GroupRoles_Call) Run(run func(id string, domainID string, pm pkgsdk.PageMetadata, token string)) *SDK_GroupRoles_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(pkgsdk.PageMetadata), args[3].(string)) + }) + return _c +} + +func (_c *SDK_GroupRoles_Call) Return(_a0 pkgsdk.RolesPage, _a1 errors.SDKError) *SDK_GroupRoles_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_GroupRoles_Call) RunAndReturn(run func(string, string, pkgsdk.PageMetadata, string) (pkgsdk.RolesPage, errors.SDKError)) *SDK_GroupRoles_Call { + _c.Call.Return(run) + return _c +} + // Groups provides a mock function with given fields: pm, domainID, token func (_m *SDK) Groups(pm pkgsdk.PageMetadata, domainID string, token string) (pkgsdk.GroupsPage, errors.SDKError) { ret := _m.Called(pm, domainID, token) @@ -2024,6 +4176,36 @@ func (_m *SDK) Groups(pm pkgsdk.PageMetadata, domainID string, token string) (pk return r0, r1 } +// SDK_Groups_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Groups' +type SDK_Groups_Call struct { + *mock.Call +} + +// Groups is a helper method to define mock.On call +// - pm pkgsdk.PageMetadata +// - domainID string +// - token string +func (_e *SDK_Expecter) Groups(pm interface{}, domainID interface{}, token interface{}) *SDK_Groups_Call { + return &SDK_Groups_Call{Call: _e.mock.On("Groups", pm, domainID, token)} +} + +func (_c *SDK_Groups_Call) Run(run func(pm pkgsdk.PageMetadata, domainID string, token string)) *SDK_Groups_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(pkgsdk.PageMetadata), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_Groups_Call) Return(_a0 pkgsdk.GroupsPage, _a1 errors.SDKError) *SDK_Groups_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_Groups_Call) RunAndReturn(run func(pkgsdk.PageMetadata, string, string) (pkgsdk.GroupsPage, errors.SDKError)) *SDK_Groups_Call { + _c.Call.Return(run) + return _c +} + // Health provides a mock function with given fields: service func (_m *SDK) Health(service string) (pkgsdk.HealthInfo, errors.SDKError) { ret := _m.Called(service) @@ -2054,6 +4236,34 @@ func (_m *SDK) Health(service string) (pkgsdk.HealthInfo, errors.SDKError) { return r0, r1 } +// SDK_Health_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Health' +type SDK_Health_Call struct { + *mock.Call +} + +// Health is a helper method to define mock.On call +// - service string +func (_e *SDK_Expecter) Health(service interface{}) *SDK_Health_Call { + return &SDK_Health_Call{Call: _e.mock.On("Health", service)} +} + +func (_c *SDK_Health_Call) Run(run func(service string)) *SDK_Health_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *SDK_Health_Call) Return(_a0 pkgsdk.HealthInfo, _a1 errors.SDKError) *SDK_Health_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_Health_Call) RunAndReturn(run func(string) (pkgsdk.HealthInfo, errors.SDKError)) *SDK_Health_Call { + _c.Call.Return(run) + return _c +} + // Hierarchy provides a mock function with given fields: id, domainID, pm, token func (_m *SDK) Hierarchy(id string, domainID string, pm pkgsdk.PageMetadata, token string) (pkgsdk.GroupsHierarchyPage, errors.SDKError) { ret := _m.Called(id, domainID, pm, token) @@ -2084,6 +4294,37 @@ func (_m *SDK) Hierarchy(id string, domainID string, pm pkgsdk.PageMetadata, tok return r0, r1 } +// SDK_Hierarchy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Hierarchy' +type SDK_Hierarchy_Call struct { + *mock.Call +} + +// Hierarchy is a helper method to define mock.On call +// - id string +// - domainID string +// - pm pkgsdk.PageMetadata +// - token string +func (_e *SDK_Expecter) Hierarchy(id interface{}, domainID interface{}, pm interface{}, token interface{}) *SDK_Hierarchy_Call { + return &SDK_Hierarchy_Call{Call: _e.mock.On("Hierarchy", id, domainID, pm, token)} +} + +func (_c *SDK_Hierarchy_Call) Run(run func(id string, domainID string, pm pkgsdk.PageMetadata, token string)) *SDK_Hierarchy_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(pkgsdk.PageMetadata), args[3].(string)) + }) + return _c +} + +func (_c *SDK_Hierarchy_Call) Return(_a0 pkgsdk.GroupsHierarchyPage, _a1 errors.SDKError) *SDK_Hierarchy_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_Hierarchy_Call) RunAndReturn(run func(string, string, pkgsdk.PageMetadata, string) (pkgsdk.GroupsHierarchyPage, errors.SDKError)) *SDK_Hierarchy_Call { + _c.Call.Return(run) + return _c +} + // Invitation provides a mock function with given fields: userID, domainID, token func (_m *SDK) Invitation(userID string, domainID string, token string) (pkgsdk.Invitation, error) { ret := _m.Called(userID, domainID, token) @@ -2112,11 +4353,41 @@ func (_m *SDK) Invitation(userID string, domainID string, token string) (pkgsdk. return r0, r1 } -// Invitations provides a mock function with given fields: pm, token -func (_m *SDK) Invitations(pm pkgsdk.PageMetadata, token string) (pkgsdk.InvitationPage, error) { - ret := _m.Called(pm, token) +// SDK_Invitation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Invitation' +type SDK_Invitation_Call struct { + *mock.Call +} - if len(ret) == 0 { +// Invitation is a helper method to define mock.On call +// - userID string +// - domainID string +// - token string +func (_e *SDK_Expecter) Invitation(userID interface{}, domainID interface{}, token interface{}) *SDK_Invitation_Call { + return &SDK_Invitation_Call{Call: _e.mock.On("Invitation", userID, domainID, token)} +} + +func (_c *SDK_Invitation_Call) Run(run func(userID string, domainID string, token string)) *SDK_Invitation_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_Invitation_Call) Return(invitation pkgsdk.Invitation, err error) *SDK_Invitation_Call { + _c.Call.Return(invitation, err) + return _c +} + +func (_c *SDK_Invitation_Call) RunAndReturn(run func(string, string, string) (pkgsdk.Invitation, error)) *SDK_Invitation_Call { + _c.Call.Return(run) + return _c +} + +// Invitations provides a mock function with given fields: pm, token +func (_m *SDK) Invitations(pm pkgsdk.PageMetadata, token string) (pkgsdk.InvitationPage, error) { + ret := _m.Called(pm, token) + + if len(ret) == 0 { panic("no return value specified for Invitations") } @@ -2140,6 +4411,35 @@ func (_m *SDK) Invitations(pm pkgsdk.PageMetadata, token string) (pkgsdk.Invitat return r0, r1 } +// SDK_Invitations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Invitations' +type SDK_Invitations_Call struct { + *mock.Call +} + +// Invitations is a helper method to define mock.On call +// - pm pkgsdk.PageMetadata +// - token string +func (_e *SDK_Expecter) Invitations(pm interface{}, token interface{}) *SDK_Invitations_Call { + return &SDK_Invitations_Call{Call: _e.mock.On("Invitations", pm, token)} +} + +func (_c *SDK_Invitations_Call) Run(run func(pm pkgsdk.PageMetadata, token string)) *SDK_Invitations_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(pkgsdk.PageMetadata), args[1].(string)) + }) + return _c +} + +func (_c *SDK_Invitations_Call) Return(invitations pkgsdk.InvitationPage, err error) *SDK_Invitations_Call { + _c.Call.Return(invitations, err) + return _c +} + +func (_c *SDK_Invitations_Call) RunAndReturn(run func(pkgsdk.PageMetadata, string) (pkgsdk.InvitationPage, error)) *SDK_Invitations_Call { + _c.Call.Return(run) + return _c +} + // IssueCert provides a mock function with given fields: clientID, validity, domainID, token func (_m *SDK) IssueCert(clientID string, validity string, domainID string, token string) (pkgsdk.Cert, errors.SDKError) { ret := _m.Called(clientID, validity, domainID, token) @@ -2170,6 +4470,37 @@ func (_m *SDK) IssueCert(clientID string, validity string, domainID string, toke return r0, r1 } +// SDK_IssueCert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IssueCert' +type SDK_IssueCert_Call struct { + *mock.Call +} + +// IssueCert is a helper method to define mock.On call +// - clientID string +// - validity string +// - domainID string +// - token string +func (_e *SDK_Expecter) IssueCert(clientID interface{}, validity interface{}, domainID interface{}, token interface{}) *SDK_IssueCert_Call { + return &SDK_IssueCert_Call{Call: _e.mock.On("IssueCert", clientID, validity, domainID, token)} +} + +func (_c *SDK_IssueCert_Call) Run(run func(clientID string, validity string, domainID string, token string)) *SDK_IssueCert_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_IssueCert_Call) Return(_a0 pkgsdk.Cert, _a1 errors.SDKError) *SDK_IssueCert_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_IssueCert_Call) RunAndReturn(run func(string, string, string, string) (pkgsdk.Cert, errors.SDKError)) *SDK_IssueCert_Call { + _c.Call.Return(run) + return _c +} + // Journal provides a mock function with given fields: entityType, entityID, domainID, pm, token func (_m *SDK) Journal(entityType string, entityID string, domainID string, pm pkgsdk.PageMetadata, token string) (pkgsdk.JournalsPage, error) { ret := _m.Called(entityType, entityID, domainID, pm, token) @@ -2198,6 +4529,38 @@ func (_m *SDK) Journal(entityType string, entityID string, domainID string, pm p return r0, r1 } +// SDK_Journal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Journal' +type SDK_Journal_Call struct { + *mock.Call +} + +// Journal is a helper method to define mock.On call +// - entityType string +// - entityID string +// - domainID string +// - pm pkgsdk.PageMetadata +// - token string +func (_e *SDK_Expecter) Journal(entityType interface{}, entityID interface{}, domainID interface{}, pm interface{}, token interface{}) *SDK_Journal_Call { + return &SDK_Journal_Call{Call: _e.mock.On("Journal", entityType, entityID, domainID, pm, token)} +} + +func (_c *SDK_Journal_Call) Run(run func(entityType string, entityID string, domainID string, pm pkgsdk.PageMetadata, token string)) *SDK_Journal_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string), args[3].(pkgsdk.PageMetadata), args[4].(string)) + }) + return _c +} + +func (_c *SDK_Journal_Call) Return(journal pkgsdk.JournalsPage, err error) *SDK_Journal_Call { + _c.Call.Return(journal, err) + return _c +} + +func (_c *SDK_Journal_Call) RunAndReturn(run func(string, string, string, pkgsdk.PageMetadata, string) (pkgsdk.JournalsPage, error)) *SDK_Journal_Call { + _c.Call.Return(run) + return _c +} + // ListChannelUsers provides a mock function with given fields: channelID, domainID, pm, token func (_m *SDK) ListChannelUsers(channelID string, domainID string, pm pkgsdk.PageMetadata, token string) (pkgsdk.UsersPage, errors.SDKError) { ret := _m.Called(channelID, domainID, pm, token) @@ -2228,6 +4591,37 @@ func (_m *SDK) ListChannelUsers(channelID string, domainID string, pm pkgsdk.Pag return r0, r1 } +// SDK_ListChannelUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListChannelUsers' +type SDK_ListChannelUsers_Call struct { + *mock.Call +} + +// ListChannelUsers is a helper method to define mock.On call +// - channelID string +// - domainID string +// - pm pkgsdk.PageMetadata +// - token string +func (_e *SDK_Expecter) ListChannelUsers(channelID interface{}, domainID interface{}, pm interface{}, token interface{}) *SDK_ListChannelUsers_Call { + return &SDK_ListChannelUsers_Call{Call: _e.mock.On("ListChannelUsers", channelID, domainID, pm, token)} +} + +func (_c *SDK_ListChannelUsers_Call) Run(run func(channelID string, domainID string, pm pkgsdk.PageMetadata, token string)) *SDK_ListChannelUsers_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(pkgsdk.PageMetadata), args[3].(string)) + }) + return _c +} + +func (_c *SDK_ListChannelUsers_Call) Return(_a0 pkgsdk.UsersPage, _a1 errors.SDKError) *SDK_ListChannelUsers_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_ListChannelUsers_Call) RunAndReturn(run func(string, string, pkgsdk.PageMetadata, string) (pkgsdk.UsersPage, errors.SDKError)) *SDK_ListChannelUsers_Call { + _c.Call.Return(run) + return _c +} + // ListClientUsers provides a mock function with given fields: clientID, domainID, pm, token func (_m *SDK) ListClientUsers(clientID string, domainID string, pm pkgsdk.PageMetadata, token string) (pkgsdk.UsersPage, errors.SDKError) { ret := _m.Called(clientID, domainID, pm, token) @@ -2258,6 +4652,37 @@ func (_m *SDK) ListClientUsers(clientID string, domainID string, pm pkgsdk.PageM return r0, r1 } +// SDK_ListClientUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListClientUsers' +type SDK_ListClientUsers_Call struct { + *mock.Call +} + +// ListClientUsers is a helper method to define mock.On call +// - clientID string +// - domainID string +// - pm pkgsdk.PageMetadata +// - token string +func (_e *SDK_Expecter) ListClientUsers(clientID interface{}, domainID interface{}, pm interface{}, token interface{}) *SDK_ListClientUsers_Call { + return &SDK_ListClientUsers_Call{Call: _e.mock.On("ListClientUsers", clientID, domainID, pm, token)} +} + +func (_c *SDK_ListClientUsers_Call) Run(run func(clientID string, domainID string, pm pkgsdk.PageMetadata, token string)) *SDK_ListClientUsers_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(pkgsdk.PageMetadata), args[3].(string)) + }) + return _c +} + +func (_c *SDK_ListClientUsers_Call) Return(_a0 pkgsdk.UsersPage, _a1 errors.SDKError) *SDK_ListClientUsers_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_ListClientUsers_Call) RunAndReturn(run func(string, string, pkgsdk.PageMetadata, string) (pkgsdk.UsersPage, errors.SDKError)) *SDK_ListClientUsers_Call { + _c.Call.Return(run) + return _c +} + // ListDomainUsers provides a mock function with given fields: domainID, pm, token func (_m *SDK) ListDomainUsers(domainID string, pm pkgsdk.PageMetadata, token string) (pkgsdk.UsersPage, errors.SDKError) { ret := _m.Called(domainID, pm, token) @@ -2288,26 +4713,56 @@ func (_m *SDK) ListDomainUsers(domainID string, pm pkgsdk.PageMetadata, token st return r0, r1 } +// SDK_ListDomainUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListDomainUsers' +type SDK_ListDomainUsers_Call struct { + *mock.Call +} + +// ListDomainUsers is a helper method to define mock.On call +// - domainID string +// - pm pkgsdk.PageMetadata +// - token string +func (_e *SDK_Expecter) ListDomainUsers(domainID interface{}, pm interface{}, token interface{}) *SDK_ListDomainUsers_Call { + return &SDK_ListDomainUsers_Call{Call: _e.mock.On("ListDomainUsers", domainID, pm, token)} +} + +func (_c *SDK_ListDomainUsers_Call) Run(run func(domainID string, pm pkgsdk.PageMetadata, token string)) *SDK_ListDomainUsers_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(pkgsdk.PageMetadata), args[2].(string)) + }) + return _c +} + +func (_c *SDK_ListDomainUsers_Call) Return(_a0 pkgsdk.UsersPage, _a1 errors.SDKError) *SDK_ListDomainUsers_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_ListDomainUsers_Call) RunAndReturn(run func(string, pkgsdk.PageMetadata, string) (pkgsdk.UsersPage, errors.SDKError)) *SDK_ListDomainUsers_Call { + _c.Call.Return(run) + return _c +} + // ListSubscriptions provides a mock function with given fields: pm, token -func (_m *SDK) ListSubscriptions(pm pkgsdk.PageMetadata, token string) (pkgsdk.SubscriptionPage, errors.SDKError) { +func (_m *SDK) ListSubscriptions(pm sdk.PageMetadata, token string) (sdk.SubscriptionPage, errors.SDKError) { ret := _m.Called(pm, token) if len(ret) == 0 { panic("no return value specified for ListSubscriptions") } - var r0 pkgsdk.SubscriptionPage + var r0 sdk.SubscriptionPage var r1 errors.SDKError - if rf, ok := ret.Get(0).(func(pkgsdk.PageMetadata, string) (pkgsdk.SubscriptionPage, errors.SDKError)); ok { + if rf, ok := ret.Get(0).(func(sdk.PageMetadata, string) (sdk.SubscriptionPage, errors.SDKError)); ok { return rf(pm, token) } - if rf, ok := ret.Get(0).(func(pkgsdk.PageMetadata, string) pkgsdk.SubscriptionPage); ok { + if rf, ok := ret.Get(0).(func(sdk.PageMetadata, string) sdk.SubscriptionPage); ok { r0 = rf(pm, token) } else { - r0 = ret.Get(0).(pkgsdk.SubscriptionPage) + r0 = ret.Get(0).(sdk.SubscriptionPage) } - if rf, ok := ret.Get(1).(func(pkgsdk.PageMetadata, string) errors.SDKError); ok { + if rf, ok := ret.Get(1).(func(sdk.PageMetadata, string) errors.SDKError); ok { r1 = rf(pm, token) } else { if ret.Get(1) != nil { @@ -2318,6 +4773,35 @@ func (_m *SDK) ListSubscriptions(pm pkgsdk.PageMetadata, token string) (pkgsdk.S return r0, r1 } +// SDK_ListSubscriptions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSubscriptions' +type SDK_ListSubscriptions_Call struct { + *mock.Call +} + +// ListSubscriptions is a helper method to define mock.On call +// - pm sdk.PageMetadata +// - token string +func (_e *SDK_Expecter) ListSubscriptions(pm interface{}, token interface{}) *SDK_ListSubscriptions_Call { + return &SDK_ListSubscriptions_Call{Call: _e.mock.On("ListSubscriptions", pm, token)} +} + +func (_c *SDK_ListSubscriptions_Call) Run(run func(pm sdk.PageMetadata, token string)) *SDK_ListSubscriptions_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(sdk.PageMetadata), args[1].(string)) + }) + return _c +} + +func (_c *SDK_ListSubscriptions_Call) Return(_a0 sdk.SubscriptionPage, _a1 errors.SDKError) *SDK_ListSubscriptions_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_ListSubscriptions_Call) RunAndReturn(run func(sdk.PageMetadata, string) (sdk.SubscriptionPage, errors.SDKError)) *SDK_ListSubscriptions_Call { + _c.Call.Return(run) + return _c +} + // ListUserClients provides a mock function with given fields: userID, domainID, pm, token func (_m *SDK) ListUserClients(userID string, domainID string, pm pkgsdk.PageMetadata, token string) (pkgsdk.ClientsPage, errors.SDKError) { ret := _m.Called(userID, domainID, pm, token) @@ -2348,6 +4832,37 @@ func (_m *SDK) ListUserClients(userID string, domainID string, pm pkgsdk.PageMet return r0, r1 } +// SDK_ListUserClients_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListUserClients' +type SDK_ListUserClients_Call struct { + *mock.Call +} + +// ListUserClients is a helper method to define mock.On call +// - userID string +// - domainID string +// - pm pkgsdk.PageMetadata +// - token string +func (_e *SDK_Expecter) ListUserClients(userID interface{}, domainID interface{}, pm interface{}, token interface{}) *SDK_ListUserClients_Call { + return &SDK_ListUserClients_Call{Call: _e.mock.On("ListUserClients", userID, domainID, pm, token)} +} + +func (_c *SDK_ListUserClients_Call) Run(run func(userID string, domainID string, pm pkgsdk.PageMetadata, token string)) *SDK_ListUserClients_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(pkgsdk.PageMetadata), args[3].(string)) + }) + return _c +} + +func (_c *SDK_ListUserClients_Call) Return(_a0 pkgsdk.ClientsPage, _a1 errors.SDKError) *SDK_ListUserClients_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_ListUserClients_Call) RunAndReturn(run func(string, string, pkgsdk.PageMetadata, string) (pkgsdk.ClientsPage, errors.SDKError)) *SDK_ListUserClients_Call { + _c.Call.Return(run) + return _c +} + // Members provides a mock function with given fields: groupID, domainID, pm, token func (_m *SDK) Members(groupID string, domainID string, pm pkgsdk.PageMetadata, token string) (pkgsdk.UsersPage, errors.SDKError) { ret := _m.Called(groupID, domainID, pm, token) @@ -2378,26 +4893,57 @@ func (_m *SDK) Members(groupID string, domainID string, pm pkgsdk.PageMetadata, return r0, r1 } +// SDK_Members_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Members' +type SDK_Members_Call struct { + *mock.Call +} + +// Members is a helper method to define mock.On call +// - groupID string +// - domainID string +// - pm pkgsdk.PageMetadata +// - token string +func (_e *SDK_Expecter) Members(groupID interface{}, domainID interface{}, pm interface{}, token interface{}) *SDK_Members_Call { + return &SDK_Members_Call{Call: _e.mock.On("Members", groupID, domainID, pm, token)} +} + +func (_c *SDK_Members_Call) Run(run func(groupID string, domainID string, pm pkgsdk.PageMetadata, token string)) *SDK_Members_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(pkgsdk.PageMetadata), args[3].(string)) + }) + return _c +} + +func (_c *SDK_Members_Call) Return(_a0 pkgsdk.UsersPage, _a1 errors.SDKError) *SDK_Members_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_Members_Call) RunAndReturn(run func(string, string, pkgsdk.PageMetadata, string) (pkgsdk.UsersPage, errors.SDKError)) *SDK_Members_Call { + _c.Call.Return(run) + return _c +} + // ReadMessages provides a mock function with given fields: pm, chanID, domainID, token -func (_m *SDK) ReadMessages(pm pkgsdk.MessagePageMetadata, chanID string, domainID string, token string) (pkgsdk.MessagesPage, errors.SDKError) { +func (_m *SDK) ReadMessages(pm sdk.MessagePageMetadata, chanID string, domainID string, token string) (sdk.MessagesPage, errors.SDKError) { ret := _m.Called(pm, chanID, domainID, token) if len(ret) == 0 { panic("no return value specified for ReadMessages") } - var r0 pkgsdk.MessagesPage + var r0 sdk.MessagesPage var r1 errors.SDKError - if rf, ok := ret.Get(0).(func(pkgsdk.MessagePageMetadata, string, string, string) (pkgsdk.MessagesPage, errors.SDKError)); ok { + if rf, ok := ret.Get(0).(func(sdk.MessagePageMetadata, string, string, string) (sdk.MessagesPage, errors.SDKError)); ok { return rf(pm, chanID, domainID, token) } - if rf, ok := ret.Get(0).(func(pkgsdk.MessagePageMetadata, string, string, string) pkgsdk.MessagesPage); ok { + if rf, ok := ret.Get(0).(func(sdk.MessagePageMetadata, string, string, string) sdk.MessagesPage); ok { r0 = rf(pm, chanID, domainID, token) } else { - r0 = ret.Get(0).(pkgsdk.MessagesPage) + r0 = ret.Get(0).(sdk.MessagesPage) } - if rf, ok := ret.Get(1).(func(pkgsdk.MessagePageMetadata, string, string, string) errors.SDKError); ok { + if rf, ok := ret.Get(1).(func(sdk.MessagePageMetadata, string, string, string) errors.SDKError); ok { r1 = rf(pm, chanID, domainID, token) } else { if ret.Get(1) != nil { @@ -2408,6 +4954,37 @@ func (_m *SDK) ReadMessages(pm pkgsdk.MessagePageMetadata, chanID string, domain return r0, r1 } +// SDK_ReadMessages_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReadMessages' +type SDK_ReadMessages_Call struct { + *mock.Call +} + +// ReadMessages is a helper method to define mock.On call +// - pm sdk.MessagePageMetadata +// - chanID string +// - domainID string +// - token string +func (_e *SDK_Expecter) ReadMessages(pm interface{}, chanID interface{}, domainID interface{}, token interface{}) *SDK_ReadMessages_Call { + return &SDK_ReadMessages_Call{Call: _e.mock.On("ReadMessages", pm, chanID, domainID, token)} +} + +func (_c *SDK_ReadMessages_Call) Run(run func(pm sdk.MessagePageMetadata, chanID string, domainID string, token string)) *SDK_ReadMessages_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(sdk.MessagePageMetadata), args[1].(string), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_ReadMessages_Call) Return(_a0 sdk.MessagesPage, _a1 errors.SDKError) *SDK_ReadMessages_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_ReadMessages_Call) RunAndReturn(run func(sdk.MessagePageMetadata, string, string, string) (sdk.MessagesPage, errors.SDKError)) *SDK_ReadMessages_Call { + _c.Call.Return(run) + return _c +} + // RefreshToken provides a mock function with given fields: token func (_m *SDK) RefreshToken(token string) (pkgsdk.Token, errors.SDKError) { ret := _m.Called(token) @@ -2438,6 +5015,34 @@ func (_m *SDK) RefreshToken(token string) (pkgsdk.Token, errors.SDKError) { return r0, r1 } +// SDK_RefreshToken_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RefreshToken' +type SDK_RefreshToken_Call struct { + *mock.Call +} + +// RefreshToken is a helper method to define mock.On call +// - token string +func (_e *SDK_Expecter) RefreshToken(token interface{}) *SDK_RefreshToken_Call { + return &SDK_RefreshToken_Call{Call: _e.mock.On("RefreshToken", token)} +} + +func (_c *SDK_RefreshToken_Call) Run(run func(token string)) *SDK_RefreshToken_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *SDK_RefreshToken_Call) Return(_a0 pkgsdk.Token, _a1 errors.SDKError) *SDK_RefreshToken_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_RefreshToken_Call) RunAndReturn(run func(string) (pkgsdk.Token, errors.SDKError)) *SDK_RefreshToken_Call { + _c.Call.Return(run) + return _c +} + // RejectInvitation provides a mock function with given fields: domainID, token func (_m *SDK) RejectInvitation(domainID string, token string) error { ret := _m.Called(domainID, token) @@ -2456,6 +5061,35 @@ func (_m *SDK) RejectInvitation(domainID string, token string) error { return r0 } +// SDK_RejectInvitation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RejectInvitation' +type SDK_RejectInvitation_Call struct { + *mock.Call +} + +// RejectInvitation is a helper method to define mock.On call +// - domainID string +// - token string +func (_e *SDK_Expecter) RejectInvitation(domainID interface{}, token interface{}) *SDK_RejectInvitation_Call { + return &SDK_RejectInvitation_Call{Call: _e.mock.On("RejectInvitation", domainID, token)} +} + +func (_c *SDK_RejectInvitation_Call) Run(run func(domainID string, token string)) *SDK_RejectInvitation_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *SDK_RejectInvitation_Call) Return(err error) *SDK_RejectInvitation_Call { + _c.Call.Return(err) + return _c +} + +func (_c *SDK_RejectInvitation_Call) RunAndReturn(run func(string, string) error) *SDK_RejectInvitation_Call { + _c.Call.Return(run) + return _c +} + // RemoveAllChildren provides a mock function with given fields: id, domainID, token func (_m *SDK) RemoveAllChildren(id string, domainID string, token string) errors.SDKError { ret := _m.Called(id, domainID, token) @@ -2476,6 +5110,36 @@ func (_m *SDK) RemoveAllChildren(id string, domainID string, token string) error return r0 } +// SDK_RemoveAllChildren_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveAllChildren' +type SDK_RemoveAllChildren_Call struct { + *mock.Call +} + +// RemoveAllChildren is a helper method to define mock.On call +// - id string +// - domainID string +// - token string +func (_e *SDK_Expecter) RemoveAllChildren(id interface{}, domainID interface{}, token interface{}) *SDK_RemoveAllChildren_Call { + return &SDK_RemoveAllChildren_Call{Call: _e.mock.On("RemoveAllChildren", id, domainID, token)} +} + +func (_c *SDK_RemoveAllChildren_Call) Run(run func(id string, domainID string, token string)) *SDK_RemoveAllChildren_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_RemoveAllChildren_Call) Return(_a0 errors.SDKError) *SDK_RemoveAllChildren_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_RemoveAllChildren_Call) RunAndReturn(run func(string, string, string) errors.SDKError) *SDK_RemoveAllChildren_Call { + _c.Call.Return(run) + return _c +} + // RemoveAllClientRoleActions provides a mock function with given fields: id, roleID, domainID, token func (_m *SDK) RemoveAllClientRoleActions(id string, roleID string, domainID string, token string) errors.SDKError { ret := _m.Called(id, roleID, domainID, token) @@ -2496,6 +5160,37 @@ func (_m *SDK) RemoveAllClientRoleActions(id string, roleID string, domainID str return r0 } +// SDK_RemoveAllClientRoleActions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveAllClientRoleActions' +type SDK_RemoveAllClientRoleActions_Call struct { + *mock.Call +} + +// RemoveAllClientRoleActions is a helper method to define mock.On call +// - id string +// - roleID string +// - domainID string +// - token string +func (_e *SDK_Expecter) RemoveAllClientRoleActions(id interface{}, roleID interface{}, domainID interface{}, token interface{}) *SDK_RemoveAllClientRoleActions_Call { + return &SDK_RemoveAllClientRoleActions_Call{Call: _e.mock.On("RemoveAllClientRoleActions", id, roleID, domainID, token)} +} + +func (_c *SDK_RemoveAllClientRoleActions_Call) Run(run func(id string, roleID string, domainID string, token string)) *SDK_RemoveAllClientRoleActions_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_RemoveAllClientRoleActions_Call) Return(_a0 errors.SDKError) *SDK_RemoveAllClientRoleActions_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_RemoveAllClientRoleActions_Call) RunAndReturn(run func(string, string, string, string) errors.SDKError) *SDK_RemoveAllClientRoleActions_Call { + _c.Call.Return(run) + return _c +} + // RemoveAllClientRoleMembers provides a mock function with given fields: id, roleID, domainID, token func (_m *SDK) RemoveAllClientRoleMembers(id string, roleID string, domainID string, token string) errors.SDKError { ret := _m.Called(id, roleID, domainID, token) @@ -2516,6 +5211,37 @@ func (_m *SDK) RemoveAllClientRoleMembers(id string, roleID string, domainID str return r0 } +// SDK_RemoveAllClientRoleMembers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveAllClientRoleMembers' +type SDK_RemoveAllClientRoleMembers_Call struct { + *mock.Call +} + +// RemoveAllClientRoleMembers is a helper method to define mock.On call +// - id string +// - roleID string +// - domainID string +// - token string +func (_e *SDK_Expecter) RemoveAllClientRoleMembers(id interface{}, roleID interface{}, domainID interface{}, token interface{}) *SDK_RemoveAllClientRoleMembers_Call { + return &SDK_RemoveAllClientRoleMembers_Call{Call: _e.mock.On("RemoveAllClientRoleMembers", id, roleID, domainID, token)} +} + +func (_c *SDK_RemoveAllClientRoleMembers_Call) Run(run func(id string, roleID string, domainID string, token string)) *SDK_RemoveAllClientRoleMembers_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_RemoveAllClientRoleMembers_Call) Return(_a0 errors.SDKError) *SDK_RemoveAllClientRoleMembers_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_RemoveAllClientRoleMembers_Call) RunAndReturn(run func(string, string, string, string) errors.SDKError) *SDK_RemoveAllClientRoleMembers_Call { + _c.Call.Return(run) + return _c +} + // RemoveAllDomainRoleActions provides a mock function with given fields: id, roleID, token func (_m *SDK) RemoveAllDomainRoleActions(id string, roleID string, token string) errors.SDKError { ret := _m.Called(id, roleID, token) @@ -2536,6 +5262,36 @@ func (_m *SDK) RemoveAllDomainRoleActions(id string, roleID string, token string return r0 } +// SDK_RemoveAllDomainRoleActions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveAllDomainRoleActions' +type SDK_RemoveAllDomainRoleActions_Call struct { + *mock.Call +} + +// RemoveAllDomainRoleActions is a helper method to define mock.On call +// - id string +// - roleID string +// - token string +func (_e *SDK_Expecter) RemoveAllDomainRoleActions(id interface{}, roleID interface{}, token interface{}) *SDK_RemoveAllDomainRoleActions_Call { + return &SDK_RemoveAllDomainRoleActions_Call{Call: _e.mock.On("RemoveAllDomainRoleActions", id, roleID, token)} +} + +func (_c *SDK_RemoveAllDomainRoleActions_Call) Run(run func(id string, roleID string, token string)) *SDK_RemoveAllDomainRoleActions_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_RemoveAllDomainRoleActions_Call) Return(_a0 errors.SDKError) *SDK_RemoveAllDomainRoleActions_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_RemoveAllDomainRoleActions_Call) RunAndReturn(run func(string, string, string) errors.SDKError) *SDK_RemoveAllDomainRoleActions_Call { + _c.Call.Return(run) + return _c +} + // RemoveAllDomainRoleMembers provides a mock function with given fields: id, roleID, token func (_m *SDK) RemoveAllDomainRoleMembers(id string, roleID string, token string) errors.SDKError { ret := _m.Called(id, roleID, token) @@ -2556,6 +5312,36 @@ func (_m *SDK) RemoveAllDomainRoleMembers(id string, roleID string, token string return r0 } +// SDK_RemoveAllDomainRoleMembers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveAllDomainRoleMembers' +type SDK_RemoveAllDomainRoleMembers_Call struct { + *mock.Call +} + +// RemoveAllDomainRoleMembers is a helper method to define mock.On call +// - id string +// - roleID string +// - token string +func (_e *SDK_Expecter) RemoveAllDomainRoleMembers(id interface{}, roleID interface{}, token interface{}) *SDK_RemoveAllDomainRoleMembers_Call { + return &SDK_RemoveAllDomainRoleMembers_Call{Call: _e.mock.On("RemoveAllDomainRoleMembers", id, roleID, token)} +} + +func (_c *SDK_RemoveAllDomainRoleMembers_Call) Run(run func(id string, roleID string, token string)) *SDK_RemoveAllDomainRoleMembers_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_RemoveAllDomainRoleMembers_Call) Return(_a0 errors.SDKError) *SDK_RemoveAllDomainRoleMembers_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_RemoveAllDomainRoleMembers_Call) RunAndReturn(run func(string, string, string) errors.SDKError) *SDK_RemoveAllDomainRoleMembers_Call { + _c.Call.Return(run) + return _c +} + // RemoveAllGroupRoleActions provides a mock function with given fields: id, roleID, domainID, token func (_m *SDK) RemoveAllGroupRoleActions(id string, roleID string, domainID string, token string) errors.SDKError { ret := _m.Called(id, roleID, domainID, token) @@ -2576,6 +5362,37 @@ func (_m *SDK) RemoveAllGroupRoleActions(id string, roleID string, domainID stri return r0 } +// SDK_RemoveAllGroupRoleActions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveAllGroupRoleActions' +type SDK_RemoveAllGroupRoleActions_Call struct { + *mock.Call +} + +// RemoveAllGroupRoleActions is a helper method to define mock.On call +// - id string +// - roleID string +// - domainID string +// - token string +func (_e *SDK_Expecter) RemoveAllGroupRoleActions(id interface{}, roleID interface{}, domainID interface{}, token interface{}) *SDK_RemoveAllGroupRoleActions_Call { + return &SDK_RemoveAllGroupRoleActions_Call{Call: _e.mock.On("RemoveAllGroupRoleActions", id, roleID, domainID, token)} +} + +func (_c *SDK_RemoveAllGroupRoleActions_Call) Run(run func(id string, roleID string, domainID string, token string)) *SDK_RemoveAllGroupRoleActions_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_RemoveAllGroupRoleActions_Call) Return(_a0 errors.SDKError) *SDK_RemoveAllGroupRoleActions_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_RemoveAllGroupRoleActions_Call) RunAndReturn(run func(string, string, string, string) errors.SDKError) *SDK_RemoveAllGroupRoleActions_Call { + _c.Call.Return(run) + return _c +} + // RemoveAllGroupRoleMembers provides a mock function with given fields: id, roleID, domainID, token func (_m *SDK) RemoveAllGroupRoleMembers(id string, roleID string, domainID string, token string) errors.SDKError { ret := _m.Called(id, roleID, domainID, token) @@ -2596,6 +5413,37 @@ func (_m *SDK) RemoveAllGroupRoleMembers(id string, roleID string, domainID stri return r0 } +// SDK_RemoveAllGroupRoleMembers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveAllGroupRoleMembers' +type SDK_RemoveAllGroupRoleMembers_Call struct { + *mock.Call +} + +// RemoveAllGroupRoleMembers is a helper method to define mock.On call +// - id string +// - roleID string +// - domainID string +// - token string +func (_e *SDK_Expecter) RemoveAllGroupRoleMembers(id interface{}, roleID interface{}, domainID interface{}, token interface{}) *SDK_RemoveAllGroupRoleMembers_Call { + return &SDK_RemoveAllGroupRoleMembers_Call{Call: _e.mock.On("RemoveAllGroupRoleMembers", id, roleID, domainID, token)} +} + +func (_c *SDK_RemoveAllGroupRoleMembers_Call) Run(run func(id string, roleID string, domainID string, token string)) *SDK_RemoveAllGroupRoleMembers_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_RemoveAllGroupRoleMembers_Call) Return(_a0 errors.SDKError) *SDK_RemoveAllGroupRoleMembers_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_RemoveAllGroupRoleMembers_Call) RunAndReturn(run func(string, string, string, string) errors.SDKError) *SDK_RemoveAllGroupRoleMembers_Call { + _c.Call.Return(run) + return _c +} + // RemoveBootstrap provides a mock function with given fields: id, domainID, token func (_m *SDK) RemoveBootstrap(id string, domainID string, token string) errors.SDKError { ret := _m.Called(id, domainID, token) @@ -2616,6 +5464,36 @@ func (_m *SDK) RemoveBootstrap(id string, domainID string, token string) errors. return r0 } +// SDK_RemoveBootstrap_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveBootstrap' +type SDK_RemoveBootstrap_Call struct { + *mock.Call +} + +// RemoveBootstrap is a helper method to define mock.On call +// - id string +// - domainID string +// - token string +func (_e *SDK_Expecter) RemoveBootstrap(id interface{}, domainID interface{}, token interface{}) *SDK_RemoveBootstrap_Call { + return &SDK_RemoveBootstrap_Call{Call: _e.mock.On("RemoveBootstrap", id, domainID, token)} +} + +func (_c *SDK_RemoveBootstrap_Call) Run(run func(id string, domainID string, token string)) *SDK_RemoveBootstrap_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_RemoveBootstrap_Call) Return(_a0 errors.SDKError) *SDK_RemoveBootstrap_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_RemoveBootstrap_Call) RunAndReturn(run func(string, string, string) errors.SDKError) *SDK_RemoveBootstrap_Call { + _c.Call.Return(run) + return _c +} + // RemoveChannelParent provides a mock function with given fields: id, domainID, groupID, token func (_m *SDK) RemoveChannelParent(id string, domainID string, groupID string, token string) errors.SDKError { ret := _m.Called(id, domainID, groupID, token) @@ -2636,6 +5514,37 @@ func (_m *SDK) RemoveChannelParent(id string, domainID string, groupID string, t return r0 } +// SDK_RemoveChannelParent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveChannelParent' +type SDK_RemoveChannelParent_Call struct { + *mock.Call +} + +// RemoveChannelParent is a helper method to define mock.On call +// - id string +// - domainID string +// - groupID string +// - token string +func (_e *SDK_Expecter) RemoveChannelParent(id interface{}, domainID interface{}, groupID interface{}, token interface{}) *SDK_RemoveChannelParent_Call { + return &SDK_RemoveChannelParent_Call{Call: _e.mock.On("RemoveChannelParent", id, domainID, groupID, token)} +} + +func (_c *SDK_RemoveChannelParent_Call) Run(run func(id string, domainID string, groupID string, token string)) *SDK_RemoveChannelParent_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_RemoveChannelParent_Call) Return(_a0 errors.SDKError) *SDK_RemoveChannelParent_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_RemoveChannelParent_Call) RunAndReturn(run func(string, string, string, string) errors.SDKError) *SDK_RemoveChannelParent_Call { + _c.Call.Return(run) + return _c +} + // RemoveChildren provides a mock function with given fields: id, domainID, groupIDs, token func (_m *SDK) RemoveChildren(id string, domainID string, groupIDs []string, token string) errors.SDKError { ret := _m.Called(id, domainID, groupIDs, token) @@ -2656,6 +5565,37 @@ func (_m *SDK) RemoveChildren(id string, domainID string, groupIDs []string, tok return r0 } +// SDK_RemoveChildren_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveChildren' +type SDK_RemoveChildren_Call struct { + *mock.Call +} + +// RemoveChildren is a helper method to define mock.On call +// - id string +// - domainID string +// - groupIDs []string +// - token string +func (_e *SDK_Expecter) RemoveChildren(id interface{}, domainID interface{}, groupIDs interface{}, token interface{}) *SDK_RemoveChildren_Call { + return &SDK_RemoveChildren_Call{Call: _e.mock.On("RemoveChildren", id, domainID, groupIDs, token)} +} + +func (_c *SDK_RemoveChildren_Call) Run(run func(id string, domainID string, groupIDs []string, token string)) *SDK_RemoveChildren_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].([]string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_RemoveChildren_Call) Return(_a0 errors.SDKError) *SDK_RemoveChildren_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_RemoveChildren_Call) RunAndReturn(run func(string, string, []string, string) errors.SDKError) *SDK_RemoveChildren_Call { + _c.Call.Return(run) + return _c +} + // RemoveClientParent provides a mock function with given fields: id, domainID, groupID, token func (_m *SDK) RemoveClientParent(id string, domainID string, groupID string, token string) errors.SDKError { ret := _m.Called(id, domainID, groupID, token) @@ -2676,6 +5616,37 @@ func (_m *SDK) RemoveClientParent(id string, domainID string, groupID string, to return r0 } +// SDK_RemoveClientParent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveClientParent' +type SDK_RemoveClientParent_Call struct { + *mock.Call +} + +// RemoveClientParent is a helper method to define mock.On call +// - id string +// - domainID string +// - groupID string +// - token string +func (_e *SDK_Expecter) RemoveClientParent(id interface{}, domainID interface{}, groupID interface{}, token interface{}) *SDK_RemoveClientParent_Call { + return &SDK_RemoveClientParent_Call{Call: _e.mock.On("RemoveClientParent", id, domainID, groupID, token)} +} + +func (_c *SDK_RemoveClientParent_Call) Run(run func(id string, domainID string, groupID string, token string)) *SDK_RemoveClientParent_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_RemoveClientParent_Call) Return(_a0 errors.SDKError) *SDK_RemoveClientParent_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_RemoveClientParent_Call) RunAndReturn(run func(string, string, string, string) errors.SDKError) *SDK_RemoveClientParent_Call { + _c.Call.Return(run) + return _c +} + // RemoveClientRoleActions provides a mock function with given fields: id, roleID, domainID, actions, token func (_m *SDK) RemoveClientRoleActions(id string, roleID string, domainID string, actions []string, token string) errors.SDKError { ret := _m.Called(id, roleID, domainID, actions, token) @@ -2696,6 +5667,38 @@ func (_m *SDK) RemoveClientRoleActions(id string, roleID string, domainID string return r0 } +// SDK_RemoveClientRoleActions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveClientRoleActions' +type SDK_RemoveClientRoleActions_Call struct { + *mock.Call +} + +// RemoveClientRoleActions is a helper method to define mock.On call +// - id string +// - roleID string +// - domainID string +// - actions []string +// - token string +func (_e *SDK_Expecter) RemoveClientRoleActions(id interface{}, roleID interface{}, domainID interface{}, actions interface{}, token interface{}) *SDK_RemoveClientRoleActions_Call { + return &SDK_RemoveClientRoleActions_Call{Call: _e.mock.On("RemoveClientRoleActions", id, roleID, domainID, actions, token)} +} + +func (_c *SDK_RemoveClientRoleActions_Call) Run(run func(id string, roleID string, domainID string, actions []string, token string)) *SDK_RemoveClientRoleActions_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string), args[3].([]string), args[4].(string)) + }) + return _c +} + +func (_c *SDK_RemoveClientRoleActions_Call) Return(_a0 errors.SDKError) *SDK_RemoveClientRoleActions_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_RemoveClientRoleActions_Call) RunAndReturn(run func(string, string, string, []string, string) errors.SDKError) *SDK_RemoveClientRoleActions_Call { + _c.Call.Return(run) + return _c +} + // RemoveClientRoleMembers provides a mock function with given fields: id, roleID, domainID, members, token func (_m *SDK) RemoveClientRoleMembers(id string, roleID string, domainID string, members []string, token string) errors.SDKError { ret := _m.Called(id, roleID, domainID, members, token) @@ -2716,6 +5719,38 @@ func (_m *SDK) RemoveClientRoleMembers(id string, roleID string, domainID string return r0 } +// SDK_RemoveClientRoleMembers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveClientRoleMembers' +type SDK_RemoveClientRoleMembers_Call struct { + *mock.Call +} + +// RemoveClientRoleMembers is a helper method to define mock.On call +// - id string +// - roleID string +// - domainID string +// - members []string +// - token string +func (_e *SDK_Expecter) RemoveClientRoleMembers(id interface{}, roleID interface{}, domainID interface{}, members interface{}, token interface{}) *SDK_RemoveClientRoleMembers_Call { + return &SDK_RemoveClientRoleMembers_Call{Call: _e.mock.On("RemoveClientRoleMembers", id, roleID, domainID, members, token)} +} + +func (_c *SDK_RemoveClientRoleMembers_Call) Run(run func(id string, roleID string, domainID string, members []string, token string)) *SDK_RemoveClientRoleMembers_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string), args[3].([]string), args[4].(string)) + }) + return _c +} + +func (_c *SDK_RemoveClientRoleMembers_Call) Return(_a0 errors.SDKError) *SDK_RemoveClientRoleMembers_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_RemoveClientRoleMembers_Call) RunAndReturn(run func(string, string, string, []string, string) errors.SDKError) *SDK_RemoveClientRoleMembers_Call { + _c.Call.Return(run) + return _c +} + // RemoveDomainRoleActions provides a mock function with given fields: id, roleID, actions, token func (_m *SDK) RemoveDomainRoleActions(id string, roleID string, actions []string, token string) errors.SDKError { ret := _m.Called(id, roleID, actions, token) @@ -2736,6 +5771,37 @@ func (_m *SDK) RemoveDomainRoleActions(id string, roleID string, actions []strin return r0 } +// SDK_RemoveDomainRoleActions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveDomainRoleActions' +type SDK_RemoveDomainRoleActions_Call struct { + *mock.Call +} + +// RemoveDomainRoleActions is a helper method to define mock.On call +// - id string +// - roleID string +// - actions []string +// - token string +func (_e *SDK_Expecter) RemoveDomainRoleActions(id interface{}, roleID interface{}, actions interface{}, token interface{}) *SDK_RemoveDomainRoleActions_Call { + return &SDK_RemoveDomainRoleActions_Call{Call: _e.mock.On("RemoveDomainRoleActions", id, roleID, actions, token)} +} + +func (_c *SDK_RemoveDomainRoleActions_Call) Run(run func(id string, roleID string, actions []string, token string)) *SDK_RemoveDomainRoleActions_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].([]string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_RemoveDomainRoleActions_Call) Return(_a0 errors.SDKError) *SDK_RemoveDomainRoleActions_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_RemoveDomainRoleActions_Call) RunAndReturn(run func(string, string, []string, string) errors.SDKError) *SDK_RemoveDomainRoleActions_Call { + _c.Call.Return(run) + return _c +} + // RemoveDomainRoleMembers provides a mock function with given fields: id, roleID, members, token func (_m *SDK) RemoveDomainRoleMembers(id string, roleID string, members []string, token string) errors.SDKError { ret := _m.Called(id, roleID, members, token) @@ -2756,6 +5822,37 @@ func (_m *SDK) RemoveDomainRoleMembers(id string, roleID string, members []strin return r0 } +// SDK_RemoveDomainRoleMembers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveDomainRoleMembers' +type SDK_RemoveDomainRoleMembers_Call struct { + *mock.Call +} + +// RemoveDomainRoleMembers is a helper method to define mock.On call +// - id string +// - roleID string +// - members []string +// - token string +func (_e *SDK_Expecter) RemoveDomainRoleMembers(id interface{}, roleID interface{}, members interface{}, token interface{}) *SDK_RemoveDomainRoleMembers_Call { + return &SDK_RemoveDomainRoleMembers_Call{Call: _e.mock.On("RemoveDomainRoleMembers", id, roleID, members, token)} +} + +func (_c *SDK_RemoveDomainRoleMembers_Call) Run(run func(id string, roleID string, members []string, token string)) *SDK_RemoveDomainRoleMembers_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].([]string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_RemoveDomainRoleMembers_Call) Return(_a0 errors.SDKError) *SDK_RemoveDomainRoleMembers_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_RemoveDomainRoleMembers_Call) RunAndReturn(run func(string, string, []string, string) errors.SDKError) *SDK_RemoveDomainRoleMembers_Call { + _c.Call.Return(run) + return _c +} + // RemoveGroupParent provides a mock function with given fields: id, domainID, groupID, token func (_m *SDK) RemoveGroupParent(id string, domainID string, groupID string, token string) errors.SDKError { ret := _m.Called(id, domainID, groupID, token) @@ -2776,6 +5873,37 @@ func (_m *SDK) RemoveGroupParent(id string, domainID string, groupID string, tok return r0 } +// SDK_RemoveGroupParent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveGroupParent' +type SDK_RemoveGroupParent_Call struct { + *mock.Call +} + +// RemoveGroupParent is a helper method to define mock.On call +// - id string +// - domainID string +// - groupID string +// - token string +func (_e *SDK_Expecter) RemoveGroupParent(id interface{}, domainID interface{}, groupID interface{}, token interface{}) *SDK_RemoveGroupParent_Call { + return &SDK_RemoveGroupParent_Call{Call: _e.mock.On("RemoveGroupParent", id, domainID, groupID, token)} +} + +func (_c *SDK_RemoveGroupParent_Call) Run(run func(id string, domainID string, groupID string, token string)) *SDK_RemoveGroupParent_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_RemoveGroupParent_Call) Return(_a0 errors.SDKError) *SDK_RemoveGroupParent_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_RemoveGroupParent_Call) RunAndReturn(run func(string, string, string, string) errors.SDKError) *SDK_RemoveGroupParent_Call { + _c.Call.Return(run) + return _c +} + // RemoveGroupRoleActions provides a mock function with given fields: id, roleID, domainID, actions, token func (_m *SDK) RemoveGroupRoleActions(id string, roleID string, domainID string, actions []string, token string) errors.SDKError { ret := _m.Called(id, roleID, domainID, actions, token) @@ -2796,6 +5924,38 @@ func (_m *SDK) RemoveGroupRoleActions(id string, roleID string, domainID string, return r0 } +// SDK_RemoveGroupRoleActions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveGroupRoleActions' +type SDK_RemoveGroupRoleActions_Call struct { + *mock.Call +} + +// RemoveGroupRoleActions is a helper method to define mock.On call +// - id string +// - roleID string +// - domainID string +// - actions []string +// - token string +func (_e *SDK_Expecter) RemoveGroupRoleActions(id interface{}, roleID interface{}, domainID interface{}, actions interface{}, token interface{}) *SDK_RemoveGroupRoleActions_Call { + return &SDK_RemoveGroupRoleActions_Call{Call: _e.mock.On("RemoveGroupRoleActions", id, roleID, domainID, actions, token)} +} + +func (_c *SDK_RemoveGroupRoleActions_Call) Run(run func(id string, roleID string, domainID string, actions []string, token string)) *SDK_RemoveGroupRoleActions_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string), args[3].([]string), args[4].(string)) + }) + return _c +} + +func (_c *SDK_RemoveGroupRoleActions_Call) Return(_a0 errors.SDKError) *SDK_RemoveGroupRoleActions_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_RemoveGroupRoleActions_Call) RunAndReturn(run func(string, string, string, []string, string) errors.SDKError) *SDK_RemoveGroupRoleActions_Call { + _c.Call.Return(run) + return _c +} + // RemoveGroupRoleMembers provides a mock function with given fields: id, roleID, domainID, members, token func (_m *SDK) RemoveGroupRoleMembers(id string, roleID string, domainID string, members []string, token string) errors.SDKError { ret := _m.Called(id, roleID, domainID, members, token) @@ -2816,6 +5976,38 @@ func (_m *SDK) RemoveGroupRoleMembers(id string, roleID string, domainID string, return r0 } +// SDK_RemoveGroupRoleMembers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveGroupRoleMembers' +type SDK_RemoveGroupRoleMembers_Call struct { + *mock.Call +} + +// RemoveGroupRoleMembers is a helper method to define mock.On call +// - id string +// - roleID string +// - domainID string +// - members []string +// - token string +func (_e *SDK_Expecter) RemoveGroupRoleMembers(id interface{}, roleID interface{}, domainID interface{}, members interface{}, token interface{}) *SDK_RemoveGroupRoleMembers_Call { + return &SDK_RemoveGroupRoleMembers_Call{Call: _e.mock.On("RemoveGroupRoleMembers", id, roleID, domainID, members, token)} +} + +func (_c *SDK_RemoveGroupRoleMembers_Call) Run(run func(id string, roleID string, domainID string, members []string, token string)) *SDK_RemoveGroupRoleMembers_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string), args[3].([]string), args[4].(string)) + }) + return _c +} + +func (_c *SDK_RemoveGroupRoleMembers_Call) Return(_a0 errors.SDKError) *SDK_RemoveGroupRoleMembers_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_RemoveGroupRoleMembers_Call) RunAndReturn(run func(string, string, string, []string, string) errors.SDKError) *SDK_RemoveGroupRoleMembers_Call { + _c.Call.Return(run) + return _c +} + // ResetPassword provides a mock function with given fields: password, confPass, token func (_m *SDK) ResetPassword(password string, confPass string, token string) errors.SDKError { ret := _m.Called(password, confPass, token) @@ -2836,6 +6028,36 @@ func (_m *SDK) ResetPassword(password string, confPass string, token string) err return r0 } +// SDK_ResetPassword_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResetPassword' +type SDK_ResetPassword_Call struct { + *mock.Call +} + +// ResetPassword is a helper method to define mock.On call +// - password string +// - confPass string +// - token string +func (_e *SDK_Expecter) ResetPassword(password interface{}, confPass interface{}, token interface{}) *SDK_ResetPassword_Call { + return &SDK_ResetPassword_Call{Call: _e.mock.On("ResetPassword", password, confPass, token)} +} + +func (_c *SDK_ResetPassword_Call) Run(run func(password string, confPass string, token string)) *SDK_ResetPassword_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_ResetPassword_Call) Return(_a0 errors.SDKError) *SDK_ResetPassword_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_ResetPassword_Call) RunAndReturn(run func(string, string, string) errors.SDKError) *SDK_ResetPassword_Call { + _c.Call.Return(run) + return _c +} + // ResetPasswordRequest provides a mock function with given fields: email func (_m *SDK) ResetPasswordRequest(email string) errors.SDKError { ret := _m.Called(email) @@ -2856,6 +6078,34 @@ func (_m *SDK) ResetPasswordRequest(email string) errors.SDKError { return r0 } +// SDK_ResetPasswordRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResetPasswordRequest' +type SDK_ResetPasswordRequest_Call struct { + *mock.Call +} + +// ResetPasswordRequest is a helper method to define mock.On call +// - email string +func (_e *SDK_Expecter) ResetPasswordRequest(email interface{}) *SDK_ResetPasswordRequest_Call { + return &SDK_ResetPasswordRequest_Call{Call: _e.mock.On("ResetPasswordRequest", email)} +} + +func (_c *SDK_ResetPasswordRequest_Call) Run(run func(email string)) *SDK_ResetPasswordRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *SDK_ResetPasswordRequest_Call) Return(_a0 errors.SDKError) *SDK_ResetPasswordRequest_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_ResetPasswordRequest_Call) RunAndReturn(run func(string) errors.SDKError) *SDK_ResetPasswordRequest_Call { + _c.Call.Return(run) + return _c +} + // RevokeCert provides a mock function with given fields: clientID, domainID, token func (_m *SDK) RevokeCert(clientID string, domainID string, token string) (time.Time, errors.SDKError) { ret := _m.Called(clientID, domainID, token) @@ -2886,6 +6136,36 @@ func (_m *SDK) RevokeCert(clientID string, domainID string, token string) (time. return r0, r1 } +// SDK_RevokeCert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RevokeCert' +type SDK_RevokeCert_Call struct { + *mock.Call +} + +// RevokeCert is a helper method to define mock.On call +// - clientID string +// - domainID string +// - token string +func (_e *SDK_Expecter) RevokeCert(clientID interface{}, domainID interface{}, token interface{}) *SDK_RevokeCert_Call { + return &SDK_RevokeCert_Call{Call: _e.mock.On("RevokeCert", clientID, domainID, token)} +} + +func (_c *SDK_RevokeCert_Call) Run(run func(clientID string, domainID string, token string)) *SDK_RevokeCert_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_RevokeCert_Call) Return(_a0 time.Time, _a1 errors.SDKError) *SDK_RevokeCert_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_RevokeCert_Call) RunAndReturn(run func(string, string, string) (time.Time, errors.SDKError)) *SDK_RevokeCert_Call { + _c.Call.Return(run) + return _c +} + // SearchUsers provides a mock function with given fields: pm, token func (_m *SDK) SearchUsers(pm pkgsdk.PageMetadata, token string) (pkgsdk.UsersPage, errors.SDKError) { ret := _m.Called(pm, token) @@ -2916,6 +6196,35 @@ func (_m *SDK) SearchUsers(pm pkgsdk.PageMetadata, token string) (pkgsdk.UsersPa return r0, r1 } +// SDK_SearchUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SearchUsers' +type SDK_SearchUsers_Call struct { + *mock.Call +} + +// SearchUsers is a helper method to define mock.On call +// - pm pkgsdk.PageMetadata +// - token string +func (_e *SDK_Expecter) SearchUsers(pm interface{}, token interface{}) *SDK_SearchUsers_Call { + return &SDK_SearchUsers_Call{Call: _e.mock.On("SearchUsers", pm, token)} +} + +func (_c *SDK_SearchUsers_Call) Run(run func(pm pkgsdk.PageMetadata, token string)) *SDK_SearchUsers_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(pkgsdk.PageMetadata), args[1].(string)) + }) + return _c +} + +func (_c *SDK_SearchUsers_Call) Return(_a0 pkgsdk.UsersPage, _a1 errors.SDKError) *SDK_SearchUsers_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_SearchUsers_Call) RunAndReturn(run func(pkgsdk.PageMetadata, string) (pkgsdk.UsersPage, errors.SDKError)) *SDK_SearchUsers_Call { + _c.Call.Return(run) + return _c +} + // SendInvitation provides a mock function with given fields: invitation, token func (_m *SDK) SendInvitation(invitation pkgsdk.Invitation, token string) error { ret := _m.Called(invitation, token) @@ -2934,6 +6243,35 @@ func (_m *SDK) SendInvitation(invitation pkgsdk.Invitation, token string) error return r0 } +// SDK_SendInvitation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendInvitation' +type SDK_SendInvitation_Call struct { + *mock.Call +} + +// SendInvitation is a helper method to define mock.On call +// - invitation pkgsdk.Invitation +// - token string +func (_e *SDK_Expecter) SendInvitation(invitation interface{}, token interface{}) *SDK_SendInvitation_Call { + return &SDK_SendInvitation_Call{Call: _e.mock.On("SendInvitation", invitation, token)} +} + +func (_c *SDK_SendInvitation_Call) Run(run func(invitation pkgsdk.Invitation, token string)) *SDK_SendInvitation_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(pkgsdk.Invitation), args[1].(string)) + }) + return _c +} + +func (_c *SDK_SendInvitation_Call) Return(err error) *SDK_SendInvitation_Call { + _c.Call.Return(err) + return _c +} + +func (_c *SDK_SendInvitation_Call) RunAndReturn(run func(pkgsdk.Invitation, string) error) *SDK_SendInvitation_Call { + _c.Call.Return(run) + return _c +} + // SendMessage provides a mock function with given fields: chanID, msg, key func (_m *SDK) SendMessage(chanID string, msg string, key string) errors.SDKError { ret := _m.Called(chanID, msg, key) @@ -2954,6 +6292,36 @@ func (_m *SDK) SendMessage(chanID string, msg string, key string) errors.SDKErro return r0 } +// SDK_SendMessage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMessage' +type SDK_SendMessage_Call struct { + *mock.Call +} + +// SendMessage is a helper method to define mock.On call +// - chanID string +// - msg string +// - key string +func (_e *SDK_Expecter) SendMessage(chanID interface{}, msg interface{}, key interface{}) *SDK_SendMessage_Call { + return &SDK_SendMessage_Call{Call: _e.mock.On("SendMessage", chanID, msg, key)} +} + +func (_c *SDK_SendMessage_Call) Run(run func(chanID string, msg string, key string)) *SDK_SendMessage_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_SendMessage_Call) Return(_a0 errors.SDKError) *SDK_SendMessage_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_SendMessage_Call) RunAndReturn(run func(string, string, string) errors.SDKError) *SDK_SendMessage_Call { + _c.Call.Return(run) + return _c +} + // SetChannelParent provides a mock function with given fields: id, domainID, groupID, token func (_m *SDK) SetChannelParent(id string, domainID string, groupID string, token string) errors.SDKError { ret := _m.Called(id, domainID, groupID, token) @@ -2974,6 +6342,37 @@ func (_m *SDK) SetChannelParent(id string, domainID string, groupID string, toke return r0 } +// SDK_SetChannelParent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetChannelParent' +type SDK_SetChannelParent_Call struct { + *mock.Call +} + +// SetChannelParent is a helper method to define mock.On call +// - id string +// - domainID string +// - groupID string +// - token string +func (_e *SDK_Expecter) SetChannelParent(id interface{}, domainID interface{}, groupID interface{}, token interface{}) *SDK_SetChannelParent_Call { + return &SDK_SetChannelParent_Call{Call: _e.mock.On("SetChannelParent", id, domainID, groupID, token)} +} + +func (_c *SDK_SetChannelParent_Call) Run(run func(id string, domainID string, groupID string, token string)) *SDK_SetChannelParent_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_SetChannelParent_Call) Return(_a0 errors.SDKError) *SDK_SetChannelParent_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_SetChannelParent_Call) RunAndReturn(run func(string, string, string, string) errors.SDKError) *SDK_SetChannelParent_Call { + _c.Call.Return(run) + return _c +} + // SetClientParent provides a mock function with given fields: id, domainID, groupID, token func (_m *SDK) SetClientParent(id string, domainID string, groupID string, token string) errors.SDKError { ret := _m.Called(id, domainID, groupID, token) @@ -2994,6 +6393,37 @@ func (_m *SDK) SetClientParent(id string, domainID string, groupID string, token return r0 } +// SDK_SetClientParent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetClientParent' +type SDK_SetClientParent_Call struct { + *mock.Call +} + +// SetClientParent is a helper method to define mock.On call +// - id string +// - domainID string +// - groupID string +// - token string +func (_e *SDK_Expecter) SetClientParent(id interface{}, domainID interface{}, groupID interface{}, token interface{}) *SDK_SetClientParent_Call { + return &SDK_SetClientParent_Call{Call: _e.mock.On("SetClientParent", id, domainID, groupID, token)} +} + +func (_c *SDK_SetClientParent_Call) Run(run func(id string, domainID string, groupID string, token string)) *SDK_SetClientParent_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_SetClientParent_Call) Return(_a0 errors.SDKError) *SDK_SetClientParent_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_SetClientParent_Call) RunAndReturn(run func(string, string, string, string) errors.SDKError) *SDK_SetClientParent_Call { + _c.Call.Return(run) + return _c +} + // SetContentType provides a mock function with given fields: ct func (_m *SDK) SetContentType(ct pkgsdk.ContentType) errors.SDKError { ret := _m.Called(ct) @@ -3014,6 +6444,34 @@ func (_m *SDK) SetContentType(ct pkgsdk.ContentType) errors.SDKError { return r0 } +// SDK_SetContentType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetContentType' +type SDK_SetContentType_Call struct { + *mock.Call +} + +// SetContentType is a helper method to define mock.On call +// - ct pkgsdk.ContentType +func (_e *SDK_Expecter) SetContentType(ct interface{}) *SDK_SetContentType_Call { + return &SDK_SetContentType_Call{Call: _e.mock.On("SetContentType", ct)} +} + +func (_c *SDK_SetContentType_Call) Run(run func(ct pkgsdk.ContentType)) *SDK_SetContentType_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(pkgsdk.ContentType)) + }) + return _c +} + +func (_c *SDK_SetContentType_Call) Return(_a0 errors.SDKError) *SDK_SetContentType_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_SetContentType_Call) RunAndReturn(run func(pkgsdk.ContentType) errors.SDKError) *SDK_SetContentType_Call { + _c.Call.Return(run) + return _c +} + // SetGroupParent provides a mock function with given fields: id, domainID, groupID, token func (_m *SDK) SetGroupParent(id string, domainID string, groupID string, token string) errors.SDKError { ret := _m.Called(id, domainID, groupID, token) @@ -3034,6 +6492,37 @@ func (_m *SDK) SetGroupParent(id string, domainID string, groupID string, token return r0 } +// SDK_SetGroupParent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetGroupParent' +type SDK_SetGroupParent_Call struct { + *mock.Call +} + +// SetGroupParent is a helper method to define mock.On call +// - id string +// - domainID string +// - groupID string +// - token string +func (_e *SDK_Expecter) SetGroupParent(id interface{}, domainID interface{}, groupID interface{}, token interface{}) *SDK_SetGroupParent_Call { + return &SDK_SetGroupParent_Call{Call: _e.mock.On("SetGroupParent", id, domainID, groupID, token)} +} + +func (_c *SDK_SetGroupParent_Call) Run(run func(id string, domainID string, groupID string, token string)) *SDK_SetGroupParent_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_SetGroupParent_Call) Return(_a0 errors.SDKError) *SDK_SetGroupParent_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_SetGroupParent_Call) RunAndReturn(run func(string, string, string, string) errors.SDKError) *SDK_SetGroupParent_Call { + _c.Call.Return(run) + return _c +} + // UpdateBootstrap provides a mock function with given fields: cfg, domainID, token func (_m *SDK) UpdateBootstrap(cfg sdk.BootstrapConfig, domainID string, token string) errors.SDKError { ret := _m.Called(cfg, domainID, token) @@ -3054,6 +6543,36 @@ func (_m *SDK) UpdateBootstrap(cfg sdk.BootstrapConfig, domainID string, token s return r0 } +// SDK_UpdateBootstrap_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateBootstrap' +type SDK_UpdateBootstrap_Call struct { + *mock.Call +} + +// UpdateBootstrap is a helper method to define mock.On call +// - cfg sdk.BootstrapConfig +// - domainID string +// - token string +func (_e *SDK_Expecter) UpdateBootstrap(cfg interface{}, domainID interface{}, token interface{}) *SDK_UpdateBootstrap_Call { + return &SDK_UpdateBootstrap_Call{Call: _e.mock.On("UpdateBootstrap", cfg, domainID, token)} +} + +func (_c *SDK_UpdateBootstrap_Call) Run(run func(cfg sdk.BootstrapConfig, domainID string, token string)) *SDK_UpdateBootstrap_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(sdk.BootstrapConfig), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_UpdateBootstrap_Call) Return(_a0 errors.SDKError) *SDK_UpdateBootstrap_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_UpdateBootstrap_Call) RunAndReturn(run func(sdk.BootstrapConfig, string, string) errors.SDKError) *SDK_UpdateBootstrap_Call { + _c.Call.Return(run) + return _c +} + // UpdateBootstrapCerts provides a mock function with given fields: id, clientCert, clientKey, ca, domainID, token func (_m *SDK) UpdateBootstrapCerts(id string, clientCert string, clientKey string, ca string, domainID string, token string) (sdk.BootstrapConfig, errors.SDKError) { ret := _m.Called(id, clientCert, clientKey, ca, domainID, token) @@ -3084,6 +6603,39 @@ func (_m *SDK) UpdateBootstrapCerts(id string, clientCert string, clientKey stri return r0, r1 } +// SDK_UpdateBootstrapCerts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateBootstrapCerts' +type SDK_UpdateBootstrapCerts_Call struct { + *mock.Call +} + +// UpdateBootstrapCerts is a helper method to define mock.On call +// - id string +// - clientCert string +// - clientKey string +// - ca string +// - domainID string +// - token string +func (_e *SDK_Expecter) UpdateBootstrapCerts(id interface{}, clientCert interface{}, clientKey interface{}, ca interface{}, domainID interface{}, token interface{}) *SDK_UpdateBootstrapCerts_Call { + return &SDK_UpdateBootstrapCerts_Call{Call: _e.mock.On("UpdateBootstrapCerts", id, clientCert, clientKey, ca, domainID, token)} +} + +func (_c *SDK_UpdateBootstrapCerts_Call) Run(run func(id string, clientCert string, clientKey string, ca string, domainID string, token string)) *SDK_UpdateBootstrapCerts_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string), args[3].(string), args[4].(string), args[5].(string)) + }) + return _c +} + +func (_c *SDK_UpdateBootstrapCerts_Call) Return(_a0 sdk.BootstrapConfig, _a1 errors.SDKError) *SDK_UpdateBootstrapCerts_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_UpdateBootstrapCerts_Call) RunAndReturn(run func(string, string, string, string, string, string) (sdk.BootstrapConfig, errors.SDKError)) *SDK_UpdateBootstrapCerts_Call { + _c.Call.Return(run) + return _c +} + // UpdateBootstrapConnection provides a mock function with given fields: id, channels, domainID, token func (_m *SDK) UpdateBootstrapConnection(id string, channels []string, domainID string, token string) errors.SDKError { ret := _m.Called(id, channels, domainID, token) @@ -3101,7 +6653,38 @@ func (_m *SDK) UpdateBootstrapConnection(id string, channels []string, domainID } } - return r0 + return r0 +} + +// SDK_UpdateBootstrapConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateBootstrapConnection' +type SDK_UpdateBootstrapConnection_Call struct { + *mock.Call +} + +// UpdateBootstrapConnection is a helper method to define mock.On call +// - id string +// - channels []string +// - domainID string +// - token string +func (_e *SDK_Expecter) UpdateBootstrapConnection(id interface{}, channels interface{}, domainID interface{}, token interface{}) *SDK_UpdateBootstrapConnection_Call { + return &SDK_UpdateBootstrapConnection_Call{Call: _e.mock.On("UpdateBootstrapConnection", id, channels, domainID, token)} +} + +func (_c *SDK_UpdateBootstrapConnection_Call) Run(run func(id string, channels []string, domainID string, token string)) *SDK_UpdateBootstrapConnection_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].([]string), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_UpdateBootstrapConnection_Call) Return(_a0 errors.SDKError) *SDK_UpdateBootstrapConnection_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_UpdateBootstrapConnection_Call) RunAndReturn(run func(string, []string, string, string) errors.SDKError) *SDK_UpdateBootstrapConnection_Call { + _c.Call.Return(run) + return _c } // UpdateChannel provides a mock function with given fields: channel, domainID, token @@ -3134,6 +6717,36 @@ func (_m *SDK) UpdateChannel(channel pkgsdk.Channel, domainID string, token stri return r0, r1 } +// SDK_UpdateChannel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateChannel' +type SDK_UpdateChannel_Call struct { + *mock.Call +} + +// UpdateChannel is a helper method to define mock.On call +// - channel pkgsdk.Channel +// - domainID string +// - token string +func (_e *SDK_Expecter) UpdateChannel(channel interface{}, domainID interface{}, token interface{}) *SDK_UpdateChannel_Call { + return &SDK_UpdateChannel_Call{Call: _e.mock.On("UpdateChannel", channel, domainID, token)} +} + +func (_c *SDK_UpdateChannel_Call) Run(run func(channel pkgsdk.Channel, domainID string, token string)) *SDK_UpdateChannel_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(pkgsdk.Channel), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_UpdateChannel_Call) Return(_a0 pkgsdk.Channel, _a1 errors.SDKError) *SDK_UpdateChannel_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_UpdateChannel_Call) RunAndReturn(run func(pkgsdk.Channel, string, string) (pkgsdk.Channel, errors.SDKError)) *SDK_UpdateChannel_Call { + _c.Call.Return(run) + return _c +} + // UpdateChannelTags provides a mock function with given fields: c, domainID, token func (_m *SDK) UpdateChannelTags(c pkgsdk.Channel, domainID string, token string) (pkgsdk.Channel, errors.SDKError) { ret := _m.Called(c, domainID, token) @@ -3164,6 +6777,36 @@ func (_m *SDK) UpdateChannelTags(c pkgsdk.Channel, domainID string, token string return r0, r1 } +// SDK_UpdateChannelTags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateChannelTags' +type SDK_UpdateChannelTags_Call struct { + *mock.Call +} + +// UpdateChannelTags is a helper method to define mock.On call +// - c pkgsdk.Channel +// - domainID string +// - token string +func (_e *SDK_Expecter) UpdateChannelTags(c interface{}, domainID interface{}, token interface{}) *SDK_UpdateChannelTags_Call { + return &SDK_UpdateChannelTags_Call{Call: _e.mock.On("UpdateChannelTags", c, domainID, token)} +} + +func (_c *SDK_UpdateChannelTags_Call) Run(run func(c pkgsdk.Channel, domainID string, token string)) *SDK_UpdateChannelTags_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(pkgsdk.Channel), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_UpdateChannelTags_Call) Return(_a0 pkgsdk.Channel, _a1 errors.SDKError) *SDK_UpdateChannelTags_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_UpdateChannelTags_Call) RunAndReturn(run func(pkgsdk.Channel, string, string) (pkgsdk.Channel, errors.SDKError)) *SDK_UpdateChannelTags_Call { + _c.Call.Return(run) + return _c +} + // UpdateClient provides a mock function with given fields: client, domainID, token func (_m *SDK) UpdateClient(client pkgsdk.Client, domainID string, token string) (pkgsdk.Client, errors.SDKError) { ret := _m.Called(client, domainID, token) @@ -3194,6 +6837,36 @@ func (_m *SDK) UpdateClient(client pkgsdk.Client, domainID string, token string) return r0, r1 } +// SDK_UpdateClient_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateClient' +type SDK_UpdateClient_Call struct { + *mock.Call +} + +// UpdateClient is a helper method to define mock.On call +// - client pkgsdk.Client +// - domainID string +// - token string +func (_e *SDK_Expecter) UpdateClient(client interface{}, domainID interface{}, token interface{}) *SDK_UpdateClient_Call { + return &SDK_UpdateClient_Call{Call: _e.mock.On("UpdateClient", client, domainID, token)} +} + +func (_c *SDK_UpdateClient_Call) Run(run func(client pkgsdk.Client, domainID string, token string)) *SDK_UpdateClient_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(pkgsdk.Client), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_UpdateClient_Call) Return(_a0 pkgsdk.Client, _a1 errors.SDKError) *SDK_UpdateClient_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_UpdateClient_Call) RunAndReturn(run func(pkgsdk.Client, string, string) (pkgsdk.Client, errors.SDKError)) *SDK_UpdateClient_Call { + _c.Call.Return(run) + return _c +} + // UpdateClientRole provides a mock function with given fields: id, roleID, newName, domainID, token func (_m *SDK) UpdateClientRole(id string, roleID string, newName string, domainID string, token string) (pkgsdk.Role, errors.SDKError) { ret := _m.Called(id, roleID, newName, domainID, token) @@ -3224,6 +6897,38 @@ func (_m *SDK) UpdateClientRole(id string, roleID string, newName string, domain return r0, r1 } +// SDK_UpdateClientRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateClientRole' +type SDK_UpdateClientRole_Call struct { + *mock.Call +} + +// UpdateClientRole is a helper method to define mock.On call +// - id string +// - roleID string +// - newName string +// - domainID string +// - token string +func (_e *SDK_Expecter) UpdateClientRole(id interface{}, roleID interface{}, newName interface{}, domainID interface{}, token interface{}) *SDK_UpdateClientRole_Call { + return &SDK_UpdateClientRole_Call{Call: _e.mock.On("UpdateClientRole", id, roleID, newName, domainID, token)} +} + +func (_c *SDK_UpdateClientRole_Call) Run(run func(id string, roleID string, newName string, domainID string, token string)) *SDK_UpdateClientRole_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string), args[3].(string), args[4].(string)) + }) + return _c +} + +func (_c *SDK_UpdateClientRole_Call) Return(_a0 pkgsdk.Role, _a1 errors.SDKError) *SDK_UpdateClientRole_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_UpdateClientRole_Call) RunAndReturn(run func(string, string, string, string, string) (pkgsdk.Role, errors.SDKError)) *SDK_UpdateClientRole_Call { + _c.Call.Return(run) + return _c +} + // UpdateClientSecret provides a mock function with given fields: id, secret, domainID, token func (_m *SDK) UpdateClientSecret(id string, secret string, domainID string, token string) (pkgsdk.Client, errors.SDKError) { ret := _m.Called(id, secret, domainID, token) @@ -3254,6 +6959,37 @@ func (_m *SDK) UpdateClientSecret(id string, secret string, domainID string, tok return r0, r1 } +// SDK_UpdateClientSecret_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateClientSecret' +type SDK_UpdateClientSecret_Call struct { + *mock.Call +} + +// UpdateClientSecret is a helper method to define mock.On call +// - id string +// - secret string +// - domainID string +// - token string +func (_e *SDK_Expecter) UpdateClientSecret(id interface{}, secret interface{}, domainID interface{}, token interface{}) *SDK_UpdateClientSecret_Call { + return &SDK_UpdateClientSecret_Call{Call: _e.mock.On("UpdateClientSecret", id, secret, domainID, token)} +} + +func (_c *SDK_UpdateClientSecret_Call) Run(run func(id string, secret string, domainID string, token string)) *SDK_UpdateClientSecret_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_UpdateClientSecret_Call) Return(_a0 pkgsdk.Client, _a1 errors.SDKError) *SDK_UpdateClientSecret_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_UpdateClientSecret_Call) RunAndReturn(run func(string, string, string, string) (pkgsdk.Client, errors.SDKError)) *SDK_UpdateClientSecret_Call { + _c.Call.Return(run) + return _c +} + // UpdateClientTags provides a mock function with given fields: client, domainID, token func (_m *SDK) UpdateClientTags(client pkgsdk.Client, domainID string, token string) (pkgsdk.Client, errors.SDKError) { ret := _m.Called(client, domainID, token) @@ -3284,6 +7020,36 @@ func (_m *SDK) UpdateClientTags(client pkgsdk.Client, domainID string, token str return r0, r1 } +// SDK_UpdateClientTags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateClientTags' +type SDK_UpdateClientTags_Call struct { + *mock.Call +} + +// UpdateClientTags is a helper method to define mock.On call +// - client pkgsdk.Client +// - domainID string +// - token string +func (_e *SDK_Expecter) UpdateClientTags(client interface{}, domainID interface{}, token interface{}) *SDK_UpdateClientTags_Call { + return &SDK_UpdateClientTags_Call{Call: _e.mock.On("UpdateClientTags", client, domainID, token)} +} + +func (_c *SDK_UpdateClientTags_Call) Run(run func(client pkgsdk.Client, domainID string, token string)) *SDK_UpdateClientTags_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(pkgsdk.Client), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_UpdateClientTags_Call) Return(_a0 pkgsdk.Client, _a1 errors.SDKError) *SDK_UpdateClientTags_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_UpdateClientTags_Call) RunAndReturn(run func(pkgsdk.Client, string, string) (pkgsdk.Client, errors.SDKError)) *SDK_UpdateClientTags_Call { + _c.Call.Return(run) + return _c +} + // UpdateDomain provides a mock function with given fields: d, token func (_m *SDK) UpdateDomain(d pkgsdk.Domain, token string) (pkgsdk.Domain, errors.SDKError) { ret := _m.Called(d, token) @@ -3314,6 +7080,35 @@ func (_m *SDK) UpdateDomain(d pkgsdk.Domain, token string) (pkgsdk.Domain, error return r0, r1 } +// SDK_UpdateDomain_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateDomain' +type SDK_UpdateDomain_Call struct { + *mock.Call +} + +// UpdateDomain is a helper method to define mock.On call +// - d pkgsdk.Domain +// - token string +func (_e *SDK_Expecter) UpdateDomain(d interface{}, token interface{}) *SDK_UpdateDomain_Call { + return &SDK_UpdateDomain_Call{Call: _e.mock.On("UpdateDomain", d, token)} +} + +func (_c *SDK_UpdateDomain_Call) Run(run func(d pkgsdk.Domain, token string)) *SDK_UpdateDomain_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(pkgsdk.Domain), args[1].(string)) + }) + return _c +} + +func (_c *SDK_UpdateDomain_Call) Return(_a0 pkgsdk.Domain, _a1 errors.SDKError) *SDK_UpdateDomain_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_UpdateDomain_Call) RunAndReturn(run func(pkgsdk.Domain, string) (pkgsdk.Domain, errors.SDKError)) *SDK_UpdateDomain_Call { + _c.Call.Return(run) + return _c +} + // UpdateDomainRole provides a mock function with given fields: id, roleID, newName, token func (_m *SDK) UpdateDomainRole(id string, roleID string, newName string, token string) (pkgsdk.Role, errors.SDKError) { ret := _m.Called(id, roleID, newName, token) @@ -3344,6 +7139,37 @@ func (_m *SDK) UpdateDomainRole(id string, roleID string, newName string, token return r0, r1 } +// SDK_UpdateDomainRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateDomainRole' +type SDK_UpdateDomainRole_Call struct { + *mock.Call +} + +// UpdateDomainRole is a helper method to define mock.On call +// - id string +// - roleID string +// - newName string +// - token string +func (_e *SDK_Expecter) UpdateDomainRole(id interface{}, roleID interface{}, newName interface{}, token interface{}) *SDK_UpdateDomainRole_Call { + return &SDK_UpdateDomainRole_Call{Call: _e.mock.On("UpdateDomainRole", id, roleID, newName, token)} +} + +func (_c *SDK_UpdateDomainRole_Call) Run(run func(id string, roleID string, newName string, token string)) *SDK_UpdateDomainRole_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_UpdateDomainRole_Call) Return(_a0 pkgsdk.Role, _a1 errors.SDKError) *SDK_UpdateDomainRole_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_UpdateDomainRole_Call) RunAndReturn(run func(string, string, string, string) (pkgsdk.Role, errors.SDKError)) *SDK_UpdateDomainRole_Call { + _c.Call.Return(run) + return _c +} + // UpdateGroup provides a mock function with given fields: group, domainID, token func (_m *SDK) UpdateGroup(group pkgsdk.Group, domainID string, token string) (pkgsdk.Group, errors.SDKError) { ret := _m.Called(group, domainID, token) @@ -3374,6 +7200,36 @@ func (_m *SDK) UpdateGroup(group pkgsdk.Group, domainID string, token string) (p return r0, r1 } +// SDK_UpdateGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateGroup' +type SDK_UpdateGroup_Call struct { + *mock.Call +} + +// UpdateGroup is a helper method to define mock.On call +// - group pkgsdk.Group +// - domainID string +// - token string +func (_e *SDK_Expecter) UpdateGroup(group interface{}, domainID interface{}, token interface{}) *SDK_UpdateGroup_Call { + return &SDK_UpdateGroup_Call{Call: _e.mock.On("UpdateGroup", group, domainID, token)} +} + +func (_c *SDK_UpdateGroup_Call) Run(run func(group pkgsdk.Group, domainID string, token string)) *SDK_UpdateGroup_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(pkgsdk.Group), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_UpdateGroup_Call) Return(_a0 pkgsdk.Group, _a1 errors.SDKError) *SDK_UpdateGroup_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_UpdateGroup_Call) RunAndReturn(run func(pkgsdk.Group, string, string) (pkgsdk.Group, errors.SDKError)) *SDK_UpdateGroup_Call { + _c.Call.Return(run) + return _c +} + // UpdateGroupRole provides a mock function with given fields: id, roleID, newName, domainID, token func (_m *SDK) UpdateGroupRole(id string, roleID string, newName string, domainID string, token string) (pkgsdk.Role, errors.SDKError) { ret := _m.Called(id, roleID, newName, domainID, token) @@ -3404,6 +7260,38 @@ func (_m *SDK) UpdateGroupRole(id string, roleID string, newName string, domainI return r0, r1 } +// SDK_UpdateGroupRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateGroupRole' +type SDK_UpdateGroupRole_Call struct { + *mock.Call +} + +// UpdateGroupRole is a helper method to define mock.On call +// - id string +// - roleID string +// - newName string +// - domainID string +// - token string +func (_e *SDK_Expecter) UpdateGroupRole(id interface{}, roleID interface{}, newName interface{}, domainID interface{}, token interface{}) *SDK_UpdateGroupRole_Call { + return &SDK_UpdateGroupRole_Call{Call: _e.mock.On("UpdateGroupRole", id, roleID, newName, domainID, token)} +} + +func (_c *SDK_UpdateGroupRole_Call) Run(run func(id string, roleID string, newName string, domainID string, token string)) *SDK_UpdateGroupRole_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string), args[3].(string), args[4].(string)) + }) + return _c +} + +func (_c *SDK_UpdateGroupRole_Call) Return(_a0 pkgsdk.Role, _a1 errors.SDKError) *SDK_UpdateGroupRole_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_UpdateGroupRole_Call) RunAndReturn(run func(string, string, string, string, string) (pkgsdk.Role, errors.SDKError)) *SDK_UpdateGroupRole_Call { + _c.Call.Return(run) + return _c +} + // UpdatePassword provides a mock function with given fields: oldPass, newPass, token func (_m *SDK) UpdatePassword(oldPass string, newPass string, token string) (pkgsdk.User, errors.SDKError) { ret := _m.Called(oldPass, newPass, token) @@ -3434,6 +7322,36 @@ func (_m *SDK) UpdatePassword(oldPass string, newPass string, token string) (pkg return r0, r1 } +// SDK_UpdatePassword_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdatePassword' +type SDK_UpdatePassword_Call struct { + *mock.Call +} + +// UpdatePassword is a helper method to define mock.On call +// - oldPass string +// - newPass string +// - token string +func (_e *SDK_Expecter) UpdatePassword(oldPass interface{}, newPass interface{}, token interface{}) *SDK_UpdatePassword_Call { + return &SDK_UpdatePassword_Call{Call: _e.mock.On("UpdatePassword", oldPass, newPass, token)} +} + +func (_c *SDK_UpdatePassword_Call) Run(run func(oldPass string, newPass string, token string)) *SDK_UpdatePassword_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_UpdatePassword_Call) Return(_a0 pkgsdk.User, _a1 errors.SDKError) *SDK_UpdatePassword_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_UpdatePassword_Call) RunAndReturn(run func(string, string, string) (pkgsdk.User, errors.SDKError)) *SDK_UpdatePassword_Call { + _c.Call.Return(run) + return _c +} + // UpdateProfilePicture provides a mock function with given fields: user, token func (_m *SDK) UpdateProfilePicture(user pkgsdk.User, token string) (pkgsdk.User, errors.SDKError) { ret := _m.Called(user, token) @@ -3464,6 +7382,35 @@ func (_m *SDK) UpdateProfilePicture(user pkgsdk.User, token string) (pkgsdk.User return r0, r1 } +// SDK_UpdateProfilePicture_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateProfilePicture' +type SDK_UpdateProfilePicture_Call struct { + *mock.Call +} + +// UpdateProfilePicture is a helper method to define mock.On call +// - user pkgsdk.User +// - token string +func (_e *SDK_Expecter) UpdateProfilePicture(user interface{}, token interface{}) *SDK_UpdateProfilePicture_Call { + return &SDK_UpdateProfilePicture_Call{Call: _e.mock.On("UpdateProfilePicture", user, token)} +} + +func (_c *SDK_UpdateProfilePicture_Call) Run(run func(user pkgsdk.User, token string)) *SDK_UpdateProfilePicture_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(pkgsdk.User), args[1].(string)) + }) + return _c +} + +func (_c *SDK_UpdateProfilePicture_Call) Return(_a0 pkgsdk.User, _a1 errors.SDKError) *SDK_UpdateProfilePicture_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_UpdateProfilePicture_Call) RunAndReturn(run func(pkgsdk.User, string) (pkgsdk.User, errors.SDKError)) *SDK_UpdateProfilePicture_Call { + _c.Call.Return(run) + return _c +} + // UpdateUser provides a mock function with given fields: user, token func (_m *SDK) UpdateUser(user pkgsdk.User, token string) (pkgsdk.User, errors.SDKError) { ret := _m.Called(user, token) @@ -3494,6 +7441,35 @@ func (_m *SDK) UpdateUser(user pkgsdk.User, token string) (pkgsdk.User, errors.S return r0, r1 } +// SDK_UpdateUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateUser' +type SDK_UpdateUser_Call struct { + *mock.Call +} + +// UpdateUser is a helper method to define mock.On call +// - user pkgsdk.User +// - token string +func (_e *SDK_Expecter) UpdateUser(user interface{}, token interface{}) *SDK_UpdateUser_Call { + return &SDK_UpdateUser_Call{Call: _e.mock.On("UpdateUser", user, token)} +} + +func (_c *SDK_UpdateUser_Call) Run(run func(user pkgsdk.User, token string)) *SDK_UpdateUser_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(pkgsdk.User), args[1].(string)) + }) + return _c +} + +func (_c *SDK_UpdateUser_Call) Return(_a0 pkgsdk.User, _a1 errors.SDKError) *SDK_UpdateUser_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_UpdateUser_Call) RunAndReturn(run func(pkgsdk.User, string) (pkgsdk.User, errors.SDKError)) *SDK_UpdateUser_Call { + _c.Call.Return(run) + return _c +} + // UpdateUserEmail provides a mock function with given fields: user, token func (_m *SDK) UpdateUserEmail(user pkgsdk.User, token string) (pkgsdk.User, errors.SDKError) { ret := _m.Called(user, token) @@ -3524,6 +7500,35 @@ func (_m *SDK) UpdateUserEmail(user pkgsdk.User, token string) (pkgsdk.User, err return r0, r1 } +// SDK_UpdateUserEmail_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateUserEmail' +type SDK_UpdateUserEmail_Call struct { + *mock.Call +} + +// UpdateUserEmail is a helper method to define mock.On call +// - user pkgsdk.User +// - token string +func (_e *SDK_Expecter) UpdateUserEmail(user interface{}, token interface{}) *SDK_UpdateUserEmail_Call { + return &SDK_UpdateUserEmail_Call{Call: _e.mock.On("UpdateUserEmail", user, token)} +} + +func (_c *SDK_UpdateUserEmail_Call) Run(run func(user pkgsdk.User, token string)) *SDK_UpdateUserEmail_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(pkgsdk.User), args[1].(string)) + }) + return _c +} + +func (_c *SDK_UpdateUserEmail_Call) Return(_a0 pkgsdk.User, _a1 errors.SDKError) *SDK_UpdateUserEmail_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_UpdateUserEmail_Call) RunAndReturn(run func(pkgsdk.User, string) (pkgsdk.User, errors.SDKError)) *SDK_UpdateUserEmail_Call { + _c.Call.Return(run) + return _c +} + // UpdateUserRole provides a mock function with given fields: user, token func (_m *SDK) UpdateUserRole(user pkgsdk.User, token string) (pkgsdk.User, errors.SDKError) { ret := _m.Called(user, token) @@ -3554,6 +7559,35 @@ func (_m *SDK) UpdateUserRole(user pkgsdk.User, token string) (pkgsdk.User, erro return r0, r1 } +// SDK_UpdateUserRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateUserRole' +type SDK_UpdateUserRole_Call struct { + *mock.Call +} + +// UpdateUserRole is a helper method to define mock.On call +// - user pkgsdk.User +// - token string +func (_e *SDK_Expecter) UpdateUserRole(user interface{}, token interface{}) *SDK_UpdateUserRole_Call { + return &SDK_UpdateUserRole_Call{Call: _e.mock.On("UpdateUserRole", user, token)} +} + +func (_c *SDK_UpdateUserRole_Call) Run(run func(user pkgsdk.User, token string)) *SDK_UpdateUserRole_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(pkgsdk.User), args[1].(string)) + }) + return _c +} + +func (_c *SDK_UpdateUserRole_Call) Return(_a0 pkgsdk.User, _a1 errors.SDKError) *SDK_UpdateUserRole_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_UpdateUserRole_Call) RunAndReturn(run func(pkgsdk.User, string) (pkgsdk.User, errors.SDKError)) *SDK_UpdateUserRole_Call { + _c.Call.Return(run) + return _c +} + // UpdateUserTags provides a mock function with given fields: user, token func (_m *SDK) UpdateUserTags(user pkgsdk.User, token string) (pkgsdk.User, errors.SDKError) { ret := _m.Called(user, token) @@ -3584,6 +7618,35 @@ func (_m *SDK) UpdateUserTags(user pkgsdk.User, token string) (pkgsdk.User, erro return r0, r1 } +// SDK_UpdateUserTags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateUserTags' +type SDK_UpdateUserTags_Call struct { + *mock.Call +} + +// UpdateUserTags is a helper method to define mock.On call +// - user pkgsdk.User +// - token string +func (_e *SDK_Expecter) UpdateUserTags(user interface{}, token interface{}) *SDK_UpdateUserTags_Call { + return &SDK_UpdateUserTags_Call{Call: _e.mock.On("UpdateUserTags", user, token)} +} + +func (_c *SDK_UpdateUserTags_Call) Run(run func(user pkgsdk.User, token string)) *SDK_UpdateUserTags_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(pkgsdk.User), args[1].(string)) + }) + return _c +} + +func (_c *SDK_UpdateUserTags_Call) Return(_a0 pkgsdk.User, _a1 errors.SDKError) *SDK_UpdateUserTags_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_UpdateUserTags_Call) RunAndReturn(run func(pkgsdk.User, string) (pkgsdk.User, errors.SDKError)) *SDK_UpdateUserTags_Call { + _c.Call.Return(run) + return _c +} + // UpdateUsername provides a mock function with given fields: user, token func (_m *SDK) UpdateUsername(user pkgsdk.User, token string) (pkgsdk.User, errors.SDKError) { ret := _m.Called(user, token) @@ -3614,6 +7677,35 @@ func (_m *SDK) UpdateUsername(user pkgsdk.User, token string) (pkgsdk.User, erro return r0, r1 } +// SDK_UpdateUsername_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateUsername' +type SDK_UpdateUsername_Call struct { + *mock.Call +} + +// UpdateUsername is a helper method to define mock.On call +// - user pkgsdk.User +// - token string +func (_e *SDK_Expecter) UpdateUsername(user interface{}, token interface{}) *SDK_UpdateUsername_Call { + return &SDK_UpdateUsername_Call{Call: _e.mock.On("UpdateUsername", user, token)} +} + +func (_c *SDK_UpdateUsername_Call) Run(run func(user pkgsdk.User, token string)) *SDK_UpdateUsername_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(pkgsdk.User), args[1].(string)) + }) + return _c +} + +func (_c *SDK_UpdateUsername_Call) Return(_a0 pkgsdk.User, _a1 errors.SDKError) *SDK_UpdateUsername_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_UpdateUsername_Call) RunAndReturn(run func(pkgsdk.User, string) (pkgsdk.User, errors.SDKError)) *SDK_UpdateUsername_Call { + _c.Call.Return(run) + return _c +} + // User provides a mock function with given fields: id, token func (_m *SDK) User(id string, token string) (pkgsdk.User, errors.SDKError) { ret := _m.Called(id, token) @@ -3644,6 +7736,35 @@ func (_m *SDK) User(id string, token string) (pkgsdk.User, errors.SDKError) { return r0, r1 } +// SDK_User_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'User' +type SDK_User_Call struct { + *mock.Call +} + +// User is a helper method to define mock.On call +// - id string +// - token string +func (_e *SDK_Expecter) User(id interface{}, token interface{}) *SDK_User_Call { + return &SDK_User_Call{Call: _e.mock.On("User", id, token)} +} + +func (_c *SDK_User_Call) Run(run func(id string, token string)) *SDK_User_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *SDK_User_Call) Return(_a0 pkgsdk.User, _a1 errors.SDKError) *SDK_User_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_User_Call) RunAndReturn(run func(string, string) (pkgsdk.User, errors.SDKError)) *SDK_User_Call { + _c.Call.Return(run) + return _c +} + // UserProfile provides a mock function with given fields: token func (_m *SDK) UserProfile(token string) (pkgsdk.User, errors.SDKError) { ret := _m.Called(token) @@ -3674,6 +7795,34 @@ func (_m *SDK) UserProfile(token string) (pkgsdk.User, errors.SDKError) { return r0, r1 } +// SDK_UserProfile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UserProfile' +type SDK_UserProfile_Call struct { + *mock.Call +} + +// UserProfile is a helper method to define mock.On call +// - token string +func (_e *SDK_Expecter) UserProfile(token interface{}) *SDK_UserProfile_Call { + return &SDK_UserProfile_Call{Call: _e.mock.On("UserProfile", token)} +} + +func (_c *SDK_UserProfile_Call) Run(run func(token string)) *SDK_UserProfile_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *SDK_UserProfile_Call) Return(_a0 pkgsdk.User, _a1 errors.SDKError) *SDK_UserProfile_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_UserProfile_Call) RunAndReturn(run func(string) (pkgsdk.User, errors.SDKError)) *SDK_UserProfile_Call { + _c.Call.Return(run) + return _c +} + // Users provides a mock function with given fields: pm, token func (_m *SDK) Users(pm pkgsdk.PageMetadata, token string) (pkgsdk.UsersPage, errors.SDKError) { ret := _m.Called(pm, token) @@ -3704,6 +7853,35 @@ func (_m *SDK) Users(pm pkgsdk.PageMetadata, token string) (pkgsdk.UsersPage, er return r0, r1 } +// SDK_Users_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Users' +type SDK_Users_Call struct { + *mock.Call +} + +// Users is a helper method to define mock.On call +// - pm pkgsdk.PageMetadata +// - token string +func (_e *SDK_Expecter) Users(pm interface{}, token interface{}) *SDK_Users_Call { + return &SDK_Users_Call{Call: _e.mock.On("Users", pm, token)} +} + +func (_c *SDK_Users_Call) Run(run func(pm pkgsdk.PageMetadata, token string)) *SDK_Users_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(pkgsdk.PageMetadata), args[1].(string)) + }) + return _c +} + +func (_c *SDK_Users_Call) Return(_a0 pkgsdk.UsersPage, _a1 errors.SDKError) *SDK_Users_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_Users_Call) RunAndReturn(run func(pkgsdk.PageMetadata, string) (pkgsdk.UsersPage, errors.SDKError)) *SDK_Users_Call { + _c.Call.Return(run) + return _c +} + // ViewBootstrap provides a mock function with given fields: id, domainID, token func (_m *SDK) ViewBootstrap(id string, domainID string, token string) (sdk.BootstrapConfig, errors.SDKError) { ret := _m.Called(id, domainID, token) @@ -3734,6 +7912,36 @@ func (_m *SDK) ViewBootstrap(id string, domainID string, token string) (sdk.Boot return r0, r1 } +// SDK_ViewBootstrap_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ViewBootstrap' +type SDK_ViewBootstrap_Call struct { + *mock.Call +} + +// ViewBootstrap is a helper method to define mock.On call +// - id string +// - domainID string +// - token string +func (_e *SDK_Expecter) ViewBootstrap(id interface{}, domainID interface{}, token interface{}) *SDK_ViewBootstrap_Call { + return &SDK_ViewBootstrap_Call{Call: _e.mock.On("ViewBootstrap", id, domainID, token)} +} + +func (_c *SDK_ViewBootstrap_Call) Run(run func(id string, domainID string, token string)) *SDK_ViewBootstrap_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_ViewBootstrap_Call) Return(_a0 sdk.BootstrapConfig, _a1 errors.SDKError) *SDK_ViewBootstrap_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_ViewBootstrap_Call) RunAndReturn(run func(string, string, string) (sdk.BootstrapConfig, errors.SDKError)) *SDK_ViewBootstrap_Call { + _c.Call.Return(run) + return _c +} + // ViewCert provides a mock function with given fields: certID, domainID, token func (_m *SDK) ViewCert(certID string, domainID string, token string) (pkgsdk.Cert, errors.SDKError) { ret := _m.Called(certID, domainID, token) @@ -3764,6 +7972,36 @@ func (_m *SDK) ViewCert(certID string, domainID string, token string) (pkgsdk.Ce return r0, r1 } +// SDK_ViewCert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ViewCert' +type SDK_ViewCert_Call struct { + *mock.Call +} + +// ViewCert is a helper method to define mock.On call +// - certID string +// - domainID string +// - token string +func (_e *SDK_Expecter) ViewCert(certID interface{}, domainID interface{}, token interface{}) *SDK_ViewCert_Call { + return &SDK_ViewCert_Call{Call: _e.mock.On("ViewCert", certID, domainID, token)} +} + +func (_c *SDK_ViewCert_Call) Run(run func(certID string, domainID string, token string)) *SDK_ViewCert_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_ViewCert_Call) Return(_a0 pkgsdk.Cert, _a1 errors.SDKError) *SDK_ViewCert_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_ViewCert_Call) RunAndReturn(run func(string, string, string) (pkgsdk.Cert, errors.SDKError)) *SDK_ViewCert_Call { + _c.Call.Return(run) + return _c +} + // ViewCertByClient provides a mock function with given fields: clientID, domainID, token func (_m *SDK) ViewCertByClient(clientID string, domainID string, token string) (pkgsdk.CertSerials, errors.SDKError) { ret := _m.Called(clientID, domainID, token) @@ -3794,23 +8032,53 @@ func (_m *SDK) ViewCertByClient(clientID string, domainID string, token string) return r0, r1 } +// SDK_ViewCertByClient_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ViewCertByClient' +type SDK_ViewCertByClient_Call struct { + *mock.Call +} + +// ViewCertByClient is a helper method to define mock.On call +// - clientID string +// - domainID string +// - token string +func (_e *SDK_Expecter) ViewCertByClient(clientID interface{}, domainID interface{}, token interface{}) *SDK_ViewCertByClient_Call { + return &SDK_ViewCertByClient_Call{Call: _e.mock.On("ViewCertByClient", clientID, domainID, token)} +} + +func (_c *SDK_ViewCertByClient_Call) Run(run func(clientID string, domainID string, token string)) *SDK_ViewCertByClient_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_ViewCertByClient_Call) Return(_a0 pkgsdk.CertSerials, _a1 errors.SDKError) *SDK_ViewCertByClient_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_ViewCertByClient_Call) RunAndReturn(run func(string, string, string) (pkgsdk.CertSerials, errors.SDKError)) *SDK_ViewCertByClient_Call { + _c.Call.Return(run) + return _c +} + // ViewSubscription provides a mock function with given fields: id, token -func (_m *SDK) ViewSubscription(id string, token string) (pkgsdk.Subscription, errors.SDKError) { +func (_m *SDK) ViewSubscription(id string, token string) (sdk.Subscription, errors.SDKError) { ret := _m.Called(id, token) if len(ret) == 0 { panic("no return value specified for ViewSubscription") } - var r0 pkgsdk.Subscription + var r0 sdk.Subscription var r1 errors.SDKError - if rf, ok := ret.Get(0).(func(string, string) (pkgsdk.Subscription, errors.SDKError)); ok { + if rf, ok := ret.Get(0).(func(string, string) (sdk.Subscription, errors.SDKError)); ok { return rf(id, token) } - if rf, ok := ret.Get(0).(func(string, string) pkgsdk.Subscription); ok { + if rf, ok := ret.Get(0).(func(string, string) sdk.Subscription); ok { r0 = rf(id, token) } else { - r0 = ret.Get(0).(pkgsdk.Subscription) + r0 = ret.Get(0).(sdk.Subscription) } if rf, ok := ret.Get(1).(func(string, string) errors.SDKError); ok { @@ -3824,6 +8092,35 @@ func (_m *SDK) ViewSubscription(id string, token string) (pkgsdk.Subscription, e return r0, r1 } +// SDK_ViewSubscription_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ViewSubscription' +type SDK_ViewSubscription_Call struct { + *mock.Call +} + +// ViewSubscription is a helper method to define mock.On call +// - id string +// - token string +func (_e *SDK_Expecter) ViewSubscription(id interface{}, token interface{}) *SDK_ViewSubscription_Call { + return &SDK_ViewSubscription_Call{Call: _e.mock.On("ViewSubscription", id, token)} +} + +func (_c *SDK_ViewSubscription_Call) Run(run func(id string, token string)) *SDK_ViewSubscription_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *SDK_ViewSubscription_Call) Return(_a0 sdk.Subscription, _a1 errors.SDKError) *SDK_ViewSubscription_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_ViewSubscription_Call) RunAndReturn(run func(string, string) (sdk.Subscription, errors.SDKError)) *SDK_ViewSubscription_Call { + _c.Call.Return(run) + return _c +} + // Whitelist provides a mock function with given fields: clientID, state, domainID, token func (_m *SDK) Whitelist(clientID string, state int, domainID string, token string) errors.SDKError { ret := _m.Called(clientID, state, domainID, token) @@ -3844,6 +8141,37 @@ func (_m *SDK) Whitelist(clientID string, state int, domainID string, token stri return r0 } +// SDK_Whitelist_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Whitelist' +type SDK_Whitelist_Call struct { + *mock.Call +} + +// Whitelist is a helper method to define mock.On call +// - clientID string +// - state int +// - domainID string +// - token string +func (_e *SDK_Expecter) Whitelist(clientID interface{}, state interface{}, domainID interface{}, token interface{}) *SDK_Whitelist_Call { + return &SDK_Whitelist_Call{Call: _e.mock.On("Whitelist", clientID, state, domainID, token)} +} + +func (_c *SDK_Whitelist_Call) Run(run func(clientID string, state int, domainID string, token string)) *SDK_Whitelist_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(int), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_Whitelist_Call) Return(_a0 errors.SDKError) *SDK_Whitelist_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_Whitelist_Call) RunAndReturn(run func(string, int, string, string) errors.SDKError) *SDK_Whitelist_Call { + _c.Call.Return(run) + return _c +} + // NewSDK creates a new instance of SDK. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. // The first argument is typically a *testing.T value. func NewSDK(t interface { diff --git a/pkg/sdk/responses.go b/pkg/sdk/responses.go index 975da6144..6aaf74744 100644 --- a/pkg/sdk/responses.go +++ b/pkg/sdk/responses.go @@ -3,6 +3,8 @@ package sdk +import "github.com/absmach/supermq/pkg/transformers/senml" + type PageRes struct { Total uint64 `json:"total"` Offset uint64 `json:"offset"` @@ -15,18 +17,12 @@ type BootstrapPage struct { PageRes } -// Copyright (c) Abstract Machines -// SPDX-License-Identifier: Apache-2.0 - -package sdk - -type PageRes struct { - Total uint64 `json:"total"` - Offset uint64 `json:"offset"` - Limit uint64 `json:"limit"` -} - type SubscriptionPage struct { Subscriptions []Subscription `json:"subscriptions"` PageRes } + +type MessagesPage struct { + Messages []senml.Message `json:"messages,omitempty"` + PageRes +} diff --git a/pkg/sdk/sdk.go b/pkg/sdk/sdk.go index a27201583..e17762521 100644 --- a/pkg/sdk/sdk.go +++ b/pkg/sdk/sdk.go @@ -29,6 +29,26 @@ type PageMetadata struct { Offset uint64 `json:"offset"` Limit uint64 `json:"limit"` Metadata Metadata `json:"metadata,omitempty"` + Topic string `json:"topic,omitempty"` + Contact string `json:"contact,omitempty"` + DomainID string `json:"domain_id,omitempty"` + Level uint64 `json:"level,omitempty"` +} + +type MessagePageMetadata struct { + PageMetadata + Subtopic string `json:"subtopic,omitempty"` + Publisher string `json:"publisher,omitempty"` + Comparator string `json:"comparator,omitempty"` + BoolValue *bool `json:"vb,omitempty"` + StringValue string `json:"vs,omitempty"` + DataValue string `json:"vd,omitempty"` + From float64 `json:"from,omitempty"` + To float64 `json:"to,omitempty"` + Aggregation string `json:"aggregation,omitempty"` + Interval string `json:"interval,omitempty"` + Value float64 `json:"value,omitempty"` + Protocol string `json:"protocol,omitempty"` } // SDK contains Magistrala API. @@ -124,12 +144,58 @@ type SDK interface { // err := sdk.Whitelist("clientID", 1, "domainID", "token") // fmt.Println(err) Whitelist(clientID string, state int, domainID, token string) errors.SDKError + + // ReadMessages read messages of specified channel. + // + // example: + // pm := sdk.MessagePageMetadata{ + // Offset: 0, + // Limit: 10, + // } + // msgs, _ := sdk.ReadMessages(pm,"channelID", "domainID", "token") + // fmt.Println(msgs) + ReadMessages(pm MessagePageMetadata, chanID, domainID, token string) (MessagesPage, errors.SDKError) + + // CreateSubscription creates a new subscription + // + // example: + // subscription, _ := sdk.CreateSubscription("topic", "contact", "token") + // fmt.Println(subscription) + CreateSubscription(topic, contact, token string) (string, errors.SDKError) + + // ListSubscriptions list subscriptions given list parameters. + // + // example: + // pm := sdk.PageMetadata{ + // Offset: 0, + // Limit: 10, + // } + // subscriptions, _ := sdk.ListSubscriptions(pm, "token") + // fmt.Println(subscriptions) + ListSubscriptions(pm PageMetadata, token string) (SubscriptionPage, errors.SDKError) + + // ViewSubscription retrieves a subscription with the provided id. + // + // example: + // subscription, _ := sdk.ViewSubscription("id", "token") + // fmt.Println(subscription) + ViewSubscription(id, token string) (Subscription, errors.SDKError) + + // DeleteSubscription removes a subscription with the provided id. + // + // example: + // err := sdk.DeleteSubscription("id", "token") + // fmt.Println(err) + DeleteSubscription(id, token string) errors.SDKError } type mgSDK struct { - bootstrapURL string - client *http.Client - curlFlag bool + bootstrapURL string + readersURL string + usersURL string + client *http.Client + curlFlag bool + msgContentType smqSDK.ContentType smqSDK.SDK } @@ -159,7 +225,6 @@ func NewSDK(conf Config) SDK { smqSDK := smqSDK.NewSDK(smqSDK.Config{ CertsURL: conf.CertsURL, HTTPAdapterURL: conf.HTTPAdapterURL, - ReaderURL: conf.ReaderURL, ClientsURL: conf.ClientsURL, UsersURL: conf.UsersURL, GroupsURL: conf.GroupsURL, @@ -175,7 +240,11 @@ func NewSDK(conf Config) SDK { }) return &mgSDK{ - bootstrapURL: conf.BootstrapURL, + bootstrapURL: conf.BootstrapURL, + readersURL: conf.ReaderURL, + usersURL: conf.UsersURL, + msgContentType: conf.MsgContentType, + client: &http.Client{ Transport: &http.Transport{ TLSClientConfig: &tls.Config{ @@ -265,6 +334,18 @@ func (pm PageMetadata) query() (string, error) { } q.Add("metadata", string(md)) } + if pm.Topic != "" { + q.Add("topic", pm.Topic) + } + if pm.Contact != "" { + q.Add("contact", pm.Contact) + } + if pm.DomainID != "" { + q.Add("domain_id", pm.DomainID) + } + if pm.Level != 0 { + q.Add("level", strconv.FormatUint(pm.Level, 10)) + } return q.Encode(), nil } diff --git a/readers/api/endpoint_test.go b/readers/api/endpoint_test.go index ef8d9fdae..b9e1f97ae 100644 --- a/readers/api/endpoint_test.go +++ b/readers/api/endpoint_test.go @@ -12,6 +12,7 @@ import ( "time" "github.com/absmach/magistrala/internal/testsutil" + "github.com/absmach/magistrala/readers/api" grpcChannelsV1 "github.com/absmach/supermq/api/grpc/channels/v1" grpcClientsV1 "github.com/absmach/supermq/api/grpc/clients/v1" apiutil "github.com/absmach/supermq/api/http/util" @@ -22,7 +23,6 @@ import ( svcerr "github.com/absmach/supermq/pkg/errors/service" "github.com/absmach/supermq/pkg/transformers/senml" "github.com/absmach/supermq/readers" - "github.com/absmach/supermq/readers/api" "github.com/absmach/supermq/readers/mocks" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/mock" diff --git a/readers/messages.go b/readers/messages.go deleted file mode 100644 index 19ce1c08a..000000000 --- a/readers/messages.go +++ /dev/null @@ -1,84 +0,0 @@ -// Copyright (c) Abstract Machines -// SPDX-License-Identifier: Apache-2.0 - -package readers - -import "errors" - -const ( - // EqualKey represents the equal comparison operator key. - EqualKey = "eq" - // LowerThanKey represents the lower-than comparison operator key. - LowerThanKey = "lt" - // LowerThanEqualKey represents the lower-than-or-equal comparison operator key. - LowerThanEqualKey = "le" - // GreaterThanKey represents the greater-than-or-equal comparison operator key. - GreaterThanKey = "gt" - // GreaterThanEqualKey represents the greater-than-or-equal comparison operator key. - GreaterThanEqualKey = "ge" -) - -// ErrReadMessages indicates failure occurred while reading messages from database. -var ErrReadMessages = errors.New("failed to read messages from database") - -// MessageRepository specifies message reader API. -// -//go:generate mockery --name MessageRepository --output=./mocks --filename messages.go --quiet --note "Copyright (c) Abstract Machines" -type MessageRepository interface { - // ReadAll skips given number of messages for given channel and returns next - // limited number of messages. - ReadAll(chanID string, pm PageMetadata) (MessagesPage, error) -} - -// Message represents any message format. -type Message interface{} - -// MessagesPage contains page related metadata as well as list of messages that -// belong to this page. -type MessagesPage struct { - PageMetadata - Total uint64 - Messages []Message -} - -// PageMetadata represents the parameters used to create database queries. -type PageMetadata struct { - Offset uint64 `json:"offset"` - Limit uint64 `json:"limit"` - Subtopic string `json:"subtopic,omitempty"` - Publisher string `json:"publisher,omitempty"` - Protocol string `json:"protocol,omitempty"` - Name string `json:"name,omitempty"` - Value float64 `json:"v,omitempty"` - Comparator string `json:"comparator,omitempty"` - BoolValue bool `json:"vb,omitempty"` - StringValue string `json:"vs,omitempty"` - DataValue string `json:"vd,omitempty"` - From float64 `json:"from,omitempty"` - To float64 `json:"to,omitempty"` - Format string `json:"format,omitempty"` - Aggregation string `json:"aggregation,omitempty"` - Interval string `json:"interval,omitempty"` -} - -// ParseValueComparator convert comparison operator keys into mathematic anotation. -func ParseValueComparator(query map[string]interface{}) string { - comparator := "=" - val, ok := query["comparator"] - if ok { - switch val.(string) { - case EqualKey: - comparator = "=" - case LowerThanKey: - comparator = "<" - case LowerThanEqualKey: - comparator = "<=" - case GreaterThanKey: - comparator = ">" - case GreaterThanEqualKey: - comparator = ">=" - } - } - - return comparator -} diff --git a/readers/mocks/doc.go b/readers/mocks/doc.go deleted file mode 100644 index 16ed198af..000000000 --- a/readers/mocks/doc.go +++ /dev/null @@ -1,5 +0,0 @@ -// Copyright (c) Abstract Machines -// SPDX-License-Identifier: Apache-2.0 - -// Package mocks contains mocks for testing purposes. -package mocks diff --git a/readers/mocks/messages.go b/readers/mocks/messages.go deleted file mode 100644 index 3968840e8..000000000 --- a/readers/mocks/messages.go +++ /dev/null @@ -1,57 +0,0 @@ -// Code generated by mockery v2.43.2. DO NOT EDIT. - -// Copyright (c) Abstract Machines - -package mocks - -import ( - readers "github.com/absmach/magistrala/readers" - mock "github.com/stretchr/testify/mock" -) - -// MessageRepository is an autogenerated mock type for the MessageRepository type -type MessageRepository struct { - mock.Mock -} - -// ReadAll provides a mock function with given fields: chanID, pm -func (_m *MessageRepository) ReadAll(chanID string, pm readers.PageMetadata) (readers.MessagesPage, error) { - ret := _m.Called(chanID, pm) - - if len(ret) == 0 { - panic("no return value specified for ReadAll") - } - - var r0 readers.MessagesPage - var r1 error - if rf, ok := ret.Get(0).(func(string, readers.PageMetadata) (readers.MessagesPage, error)); ok { - return rf(chanID, pm) - } - if rf, ok := ret.Get(0).(func(string, readers.PageMetadata) readers.MessagesPage); ok { - r0 = rf(chanID, pm) - } else { - r0 = ret.Get(0).(readers.MessagesPage) - } - - if rf, ok := ret.Get(1).(func(string, readers.PageMetadata) error); ok { - r1 = rf(chanID, pm) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// NewMessageRepository creates a new instance of MessageRepository. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewMessageRepository(t interface { - mock.TestingT - Cleanup(func()) -}) *MessageRepository { - mock := &MessageRepository{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} diff --git a/tools/e2e/cmd/main.go b/tools/e2e/cmd/main.go index 44c42e379..a1d10e03b 100644 --- a/tools/e2e/cmd/main.go +++ b/tools/e2e/cmd/main.go @@ -7,7 +7,7 @@ package main import ( "log" - "github.com/absmach/supermq/tools/e2e" + "github.com/absmach/magistrala/tools/e2e" cc "github.com/ivanpirog/coloredcobra" "github.com/spf13/cobra" ) diff --git a/tools/mqtt-bench/cmd/main.go b/tools/mqtt-bench/cmd/main.go index a2cf5fc0e..a93820a68 100644 --- a/tools/mqtt-bench/cmd/main.go +++ b/tools/mqtt-bench/cmd/main.go @@ -7,7 +7,7 @@ package main import ( "log" - bench "github.com/absmach/supermq/tools/mqtt-bench" + bench "github.com/absmach/magistrala/tools/mqtt-bench" "github.com/spf13/cobra" "github.com/spf13/viper" ) diff --git a/tools/provision/cmd/main.go b/tools/provision/cmd/main.go index 418c543df..5326ee930 100644 --- a/tools/provision/cmd/main.go +++ b/tools/provision/cmd/main.go @@ -7,7 +7,7 @@ package main import ( "log" - "github.com/absmach/supermq/tools/provision" + "github.com/absmach/magistrala/tools/provision" "github.com/spf13/cobra" ) From 4500290eb91189c6db873f545241ef9ba04d54f3 Mon Sep 17 00:00:00 2001 From: Felix Gateru Date: Mon, 13 Jan 2025 07:04:46 +0300 Subject: [PATCH 10/11] refactor: remove notifier interface Signed-off-by: Felix Gateru --- consumers/notifiers/mocks/notifier.go | 47 --------------------------- consumers/notifiers/notifier.go | 22 ------------- consumers/notifiers/service.go | 2 +- consumers/notifiers/service_test.go | 3 +- consumers/notifiers/smpp/notifier.go | 2 +- consumers/notifiers/smtp/notifier.go | 2 +- 6 files changed, 5 insertions(+), 73 deletions(-) delete mode 100644 consumers/notifiers/mocks/notifier.go delete mode 100644 consumers/notifiers/notifier.go diff --git a/consumers/notifiers/mocks/notifier.go b/consumers/notifiers/mocks/notifier.go deleted file mode 100644 index edd18a0d2..000000000 --- a/consumers/notifiers/mocks/notifier.go +++ /dev/null @@ -1,47 +0,0 @@ -// Code generated by mockery v2.43.2. DO NOT EDIT. - -// Copyright (c) Abstract Machines - -package mocks - -import ( - messaging "github.com/absmach/supermq/pkg/messaging" - mock "github.com/stretchr/testify/mock" -) - -// Notifier is an autogenerated mock type for the Notifier type -type Notifier struct { - mock.Mock -} - -// Notify provides a mock function with given fields: from, to, msg -func (_m *Notifier) Notify(from string, to []string, msg *messaging.Message) error { - ret := _m.Called(from, to, msg) - - if len(ret) == 0 { - panic("no return value specified for Notify") - } - - var r0 error - if rf, ok := ret.Get(0).(func(string, []string, *messaging.Message) error); ok { - r0 = rf(from, to, msg) - } else { - r0 = ret.Error(0) - } - - return r0 -} - -// NewNotifier creates a new instance of Notifier. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewNotifier(t interface { - mock.TestingT - Cleanup(func()) -}) *Notifier { - mock := &Notifier{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} diff --git a/consumers/notifiers/notifier.go b/consumers/notifiers/notifier.go deleted file mode 100644 index 0337176d4..000000000 --- a/consumers/notifiers/notifier.go +++ /dev/null @@ -1,22 +0,0 @@ -// Copyright (c) Abstract Machines -// SPDX-License-Identifier: Apache-2.0 - -package notifiers - -import ( - "errors" - - "github.com/absmach/supermq/pkg/messaging" -) - -// ErrNotify wraps sending notification errors. -var ErrNotify = errors.New("error sending notification") - -// Notifier represents an API for sending notification. -// -//go:generate mockery --name Notifier --output=./mocks --filename notifier.go --quiet --note "Copyright (c) Abstract Machines" -type Notifier interface { - // Notify method is used to send notification for the - // received message to the provided list of receivers. - Notify(from string, to []string, msg *messaging.Message) error -} diff --git a/consumers/notifiers/service.go b/consumers/notifiers/service.go index 02d02503f..af9595845 100644 --- a/consumers/notifiers/service.go +++ b/consumers/notifiers/service.go @@ -46,7 +46,7 @@ type notifierService struct { authn smqauthn.Authentication subs SubscriptionsRepository idp supermq.IDProvider - notifier Notifier + notifier consumers.Notifier errCh chan error from string } diff --git a/consumers/notifiers/service_test.go b/consumers/notifiers/service_test.go index ebc2c8e7b..99b09eee1 100644 --- a/consumers/notifiers/service_test.go +++ b/consumers/notifiers/service_test.go @@ -20,6 +20,7 @@ import ( "github.com/absmach/supermq/pkg/uuid" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/mock" + smqmocks "github.com/absmach/supermq/consumers/notifiers/mocks" ) const ( @@ -32,7 +33,7 @@ const ( func newService() (notifiers.Service, *authnmocks.Authentication, *mocks.SubscriptionsRepository) { repo := new(mocks.SubscriptionsRepository) auth := new(authnmocks.Authentication) - notifier := new(mocks.Notifier) + notifier := new(smqmocks.Notifier) idp := uuid.NewMock() from := "exampleFrom" return notifiers.New(auth, repo, idp, notifier, from), auth, repo diff --git a/consumers/notifiers/smpp/notifier.go b/consumers/notifiers/smpp/notifier.go index f8d6ffa5f..63394ea74 100644 --- a/consumers/notifiers/smpp/notifier.go +++ b/consumers/notifiers/smpp/notifier.go @@ -6,7 +6,7 @@ package smpp import ( "time" - "github.com/absmach/magistrala/consumers/notifiers" + "github.com/absmach/supermq/consumers/notifiers" "github.com/absmach/supermq/pkg/messaging" "github.com/absmach/supermq/pkg/transformers" "github.com/absmach/supermq/pkg/transformers/json" diff --git a/consumers/notifiers/smtp/notifier.go b/consumers/notifiers/smtp/notifier.go index 13ebc3f06..797c75dcb 100644 --- a/consumers/notifiers/smtp/notifier.go +++ b/consumers/notifiers/smtp/notifier.go @@ -6,7 +6,7 @@ package smtp import ( "fmt" - "github.com/absmach/magistrala/consumers/notifiers" + "github.com/absmach/supermq/consumers/notifiers" "github.com/absmach/magistrala/internal/email" "github.com/absmach/supermq/pkg/messaging" ) From ebe52aac93a28a16987e5aec7726000839f91b7b Mon Sep 17 00:00:00 2001 From: Felix Gateru Date: Mon, 13 Jan 2025 12:23:39 +0300 Subject: [PATCH 11/11] refactor: remove notifier interface Signed-off-by: Felix Gateru --- consumers/notifiers/service.go | 6 +++--- consumers/notifiers/service_test.go | 5 +++-- consumers/notifiers/smpp/notifier.go | 6 +++--- consumers/notifiers/smtp/notifier.go | 6 +++--- go.mod | 4 ++-- go.sum | 8 ++++---- 6 files changed, 18 insertions(+), 17 deletions(-) diff --git a/consumers/notifiers/service.go b/consumers/notifiers/service.go index af9595845..105cc37ea 100644 --- a/consumers/notifiers/service.go +++ b/consumers/notifiers/service.go @@ -52,7 +52,7 @@ type notifierService struct { } // New instantiates the subscriptions service implementation. -func New(authn smqauthn.Authentication, subs SubscriptionsRepository, idp supermq.IDProvider, notifier Notifier, from string) Service { +func New(authn smqauthn.Authentication, subs SubscriptionsRepository, idp supermq.IDProvider, notifier consumers.Notifier, from string) Service { return ¬ifierService{ authn: authn, subs: subs, @@ -131,7 +131,7 @@ func (ns *notifierService) ConsumeBlocking(ctx context.Context, message interfac if len(to) > 0 { err := ns.notifier.Notify(ns.from, to, msg) if err != nil { - return errors.Wrap(ErrNotify, err) + return errors.Wrap(consumers.ErrNotify, err) } } @@ -165,7 +165,7 @@ func (ns *notifierService) ConsumeAsync(ctx context.Context, message interface{} } if len(to) > 0 { if err := ns.notifier.Notify(ns.from, to, msg); err != nil { - ns.errCh <- errors.Wrap(ErrNotify, err) + ns.errCh <- errors.Wrap(consumers.ErrNotify, err) } } } diff --git a/consumers/notifiers/service_test.go b/consumers/notifiers/service_test.go index 99b09eee1..68483b6c0 100644 --- a/consumers/notifiers/service_test.go +++ b/consumers/notifiers/service_test.go @@ -11,6 +11,8 @@ import ( "github.com/absmach/magistrala/consumers/notifiers" "github.com/absmach/magistrala/consumers/notifiers/mocks" "github.com/absmach/magistrala/internal/testsutil" + "github.com/absmach/supermq/consumers" + smqmocks "github.com/absmach/supermq/consumers/mocks" smqauthn "github.com/absmach/supermq/pkg/authn" authnmocks "github.com/absmach/supermq/pkg/authn/mocks" "github.com/absmach/supermq/pkg/errors" @@ -20,7 +22,6 @@ import ( "github.com/absmach/supermq/pkg/uuid" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/mock" - smqmocks "github.com/absmach/supermq/consumers/notifiers/mocks" ) const ( @@ -347,7 +348,7 @@ func TestConsume(t *testing.T) { { desc: "test fail", msg: &errMsg, - err: notifiers.ErrNotify, + err: consumers.ErrNotify, }, } diff --git a/consumers/notifiers/smpp/notifier.go b/consumers/notifiers/smpp/notifier.go index 63394ea74..0ee3cfbc8 100644 --- a/consumers/notifiers/smpp/notifier.go +++ b/consumers/notifiers/smpp/notifier.go @@ -6,7 +6,7 @@ package smpp import ( "time" - "github.com/absmach/supermq/consumers/notifiers" + "github.com/absmach/supermq/consumers" "github.com/absmach/supermq/pkg/messaging" "github.com/absmach/supermq/pkg/transformers" "github.com/absmach/supermq/pkg/transformers/json" @@ -15,7 +15,7 @@ import ( "github.com/fiorix/go-smpp/smpp/pdu/pdutext" ) -var _ notifiers.Notifier = (*notifier)(nil) +var _ consumers.Notifier = (*notifier)(nil) type notifier struct { transmitter *smpp.Transmitter @@ -27,7 +27,7 @@ type notifier struct { } // New instantiates SMTP message notifier. -func New(cfg Config) notifiers.Notifier { +func New(cfg Config) consumers.Notifier { t := &smpp.Transmitter{ Addr: cfg.Address, User: cfg.Username, diff --git a/consumers/notifiers/smtp/notifier.go b/consumers/notifiers/smtp/notifier.go index 797c75dcb..2e84d2e58 100644 --- a/consumers/notifiers/smtp/notifier.go +++ b/consumers/notifiers/smtp/notifier.go @@ -6,8 +6,8 @@ package smtp import ( "fmt" - "github.com/absmach/supermq/consumers/notifiers" "github.com/absmach/magistrala/internal/email" + "github.com/absmach/supermq/consumers" "github.com/absmach/supermq/pkg/messaging" ) @@ -16,14 +16,14 @@ const ( contentTemplate = "A publisher with an id %s sent the message over %s with the following values \n %s" ) -var _ notifiers.Notifier = (*notifier)(nil) +var _ consumers.Notifier = (*notifier)(nil) type notifier struct { agent *email.Agent } // New instantiates SMTP message notifier. -func New(agent *email.Agent) notifiers.Notifier { +func New(agent *email.Agent) consumers.Notifier { return ¬ifier{agent: agent} } diff --git a/go.mod b/go.mod index a527a27d1..23916fb9f 100644 --- a/go.mod +++ b/go.mod @@ -6,7 +6,7 @@ require ( github.com/0x6flab/namegenerator v1.4.0 github.com/absmach/callhome v0.14.0 github.com/absmach/certs v0.0.0-20241209153600-91270de67b5a - github.com/absmach/supermq v0.16.1-0.20250110102639-a9169276e54c + github.com/absmach/supermq v0.16.1-0.20250113091433-3a11b54394b2 github.com/authzed/authzed-go v1.2.1 github.com/authzed/grpcutil v0.0.0-20240123194739-2ea1e3d2d98b github.com/caarlos0/env/v11 v11.3.1 @@ -36,7 +36,7 @@ require ( go.opentelemetry.io/otel/trace v1.33.0 golang.org/x/sync v0.10.0 gonum.org/v1/gonum v0.15.1 - google.golang.org/grpc v1.69.2 + google.golang.org/grpc v1.69.4 gopkg.in/gomail.v2 v2.0.0-20160411212932-81ebce5c23df moul.io/http2curl v1.0.0 ) diff --git a/go.sum b/go.sum index 0e487948c..b57418ff1 100644 --- a/go.sum +++ b/go.sum @@ -27,8 +27,8 @@ github.com/absmach/mgate v0.4.5 h1:l6RmrEsR9jxkdb9WHUSecmT0HA41TkZZQVffFfUAIfI= github.com/absmach/mgate v0.4.5/go.mod h1:IvRIHZexZPEIAPmmaJF0L5DY2ERjj+GxRGitOW4s6qo= github.com/absmach/senml v1.0.6 h1:WPeIl6vQ00k7ghWSZYT/QP0KUxq2+4zQoaC7240pLFk= github.com/absmach/senml v1.0.6/go.mod h1:QnJNPy1DJPy0+qUW21PTcH/xoh0LgfYZxTfwriMIvmQ= -github.com/absmach/supermq v0.16.1-0.20250110102639-a9169276e54c h1:s2OxO+rV1PMm/H2jqWVG8IF+HCVfawt8nGN/gY+SIa0= -github.com/absmach/supermq v0.16.1-0.20250110102639-a9169276e54c/go.mod h1:As0UgktURYeC5/SvC269WfdG9satLst8CQcxc2dC02E= +github.com/absmach/supermq v0.16.1-0.20250113091433-3a11b54394b2 h1:mG0ucTmOE41BOzKpZyNkGHbLFangumlZd3TUddJ0J2U= +github.com/absmach/supermq v0.16.1-0.20250113091433-3a11b54394b2/go.mod h1:DjM4b/VF9m/o/MmQ/WUExbdatIvPnqyREe9zFEbW2YI= github.com/authzed/authzed-go v1.2.1 h1:o54aIs0ocDfVJl/rfIt/75vrb6z+tgPuXjMlSsSEwH0= github.com/authzed/authzed-go v1.2.1/go.mod h1:/+NblSrzA6Lm6vUO3fqZyLh8MDCLUQq2AyJMlHb32DE= github.com/authzed/grpcutil v0.0.0-20240123194739-2ea1e3d2d98b h1:wbh8IK+aMLTCey9sZasO7b6BWLAJnHHvb79fvWCXwxw= @@ -591,8 +591,8 @@ google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyac google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY= google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk= -google.golang.org/grpc v1.69.2 h1:U3S9QEtbXC0bYNvRtcoklF3xGtLViumSYxWykJS+7AU= -google.golang.org/grpc v1.69.2/go.mod h1:vyjdE6jLBI76dgpDojsFGNaHlxdjXN9ghpnd2o7JGZ4= +google.golang.org/grpc v1.69.4 h1:MF5TftSMkd8GLw/m0KM6V8CMOCY6NZ1NQDPGFgbTt4A= +google.golang.org/grpc v1.69.4/go.mod h1:vyjdE6jLBI76dgpDojsFGNaHlxdjXN9ghpnd2o7JGZ4= google.golang.org/protobuf v1.36.2 h1:R8FeyR1/eLmkutZOM5CWghmo5itiG9z0ktFlTVLuTmU= google.golang.org/protobuf v1.36.2/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE= gopkg.in/alexcesaro/quotedprintable.v3 v3.0.0-20150716171945-2caba252f4dc h1:2gGKlE2+asNV9m7xrywl36YYNnBG5ZQ0r/BOOxqPpmk=