From fabe555d169b36551e52d66f612c6b4f99b187df Mon Sep 17 00:00:00 2001 From: Lee Spottiswood Date: Fri, 8 Sep 2023 16:02:51 +0100 Subject: [PATCH] add account client commands --- cmd/account/account.go | 1 + cmd/account/account_client.go | 318 +++++++++++++++++++++++++++ cmd/account/account_client_test.go | 335 +++++++++++++++++++++++++++++ cmd/account/output.go | 5 + go.mod | 2 +- go.sum | 4 +- test/mocks/mock_accountservice.go | 279 +++++++++++++++--------- 7 files changed, 845 insertions(+), 99 deletions(-) create mode 100644 cmd/account/account_client.go create mode 100644 cmd/account/account_client_test.go diff --git a/cmd/account/account.go b/cmd/account/account.go index 36b9667..40f567c 100644 --- a/cmd/account/account.go +++ b/cmd/account/account.go @@ -12,6 +12,7 @@ func AccountRootCmd(f factory.ClientFactory) *cobra.Command { } // Child root commands + cmd.AddCommand(accountClientRootCmd(f)) cmd.AddCommand(accountContactRootCmd(f)) cmd.AddCommand(accountDetailsRootCmd(f)) cmd.AddCommand(accountCreditRootCmd(f)) diff --git a/cmd/account/account_client.go b/cmd/account/account_client.go new file mode 100644 index 0000000..ef69d97 --- /dev/null +++ b/cmd/account/account_client.go @@ -0,0 +1,318 @@ +package account + +import ( + "errors" + "fmt" + "strconv" + + "github.com/ans-group/cli/internal/pkg/factory" + "github.com/ans-group/cli/internal/pkg/helper" + "github.com/ans-group/cli/internal/pkg/output" + "github.com/ans-group/sdk-go/pkg/service/account" + "github.com/spf13/cobra" +) + +func accountClientRootCmd(f factory.ClientFactory) *cobra.Command { + cmd := &cobra.Command{ + Use: "client", + Short: "sub-commands relating to clients", + } + + // Child commands + cmd.AddCommand(accountClientListCmd(f)) + cmd.AddCommand(accountClientShowCmd(f)) + cmd.AddCommand(accountClientCreateCmd(f)) + cmd.AddCommand(accountClientUpdateCmd(f)) + cmd.AddCommand(accountClientDeleteCmd(f)) + + return cmd +} + +func accountClientListCmd(f factory.ClientFactory) *cobra.Command { + return &cobra.Command{ + Use: "list", + Short: "Lists clients", + Long: "This command lists clients", + Example: "ans account client list", + RunE: func(cmd *cobra.Command, args []string) error { + c, err := f.NewClient() + if err != nil { + return err + } + + return accountClientList(c.AccountService(), cmd, args) + }, + } +} + +func accountClientList(service account.AccountService, cmd *cobra.Command, args []string) error { + params, err := helper.GetAPIRequestParametersFromFlags(cmd) + if err != nil { + return err + } + + clients, err := service.GetClients(params) + if err != nil { + return fmt.Errorf("Error retrieving clients: %s", err) + } + + return output.CommandOutput(cmd, OutputAccountClientsProvider(clients)) +} + +func accountClientShowCmd(f factory.ClientFactory) *cobra.Command { + return &cobra.Command{ + Use: "show ...", + Short: "Shows a client", + Long: "This command shows one or more clients", + Example: "ans account client show 123", + Args: func(cmd *cobra.Command, args []string) error { + if len(args) < 1 { + return errors.New("Missing client") + } + + return nil + }, + RunE: func(cmd *cobra.Command, args []string) error { + c, err := f.NewClient() + if err != nil { + return err + } + + return accountClientShow(c.AccountService(), cmd, args) + }, + } +} + +func accountClientShow(service account.AccountService, cmd *cobra.Command, args []string) error { + var clients []account.Client + for _, arg := range args { + clientID, err := strconv.Atoi(arg) + if err != nil { + output.OutputWithErrorLevelf("Invalid client ID [%s]", arg) + continue + } + + client, err := service.GetClient(clientID) + if err != nil { + output.OutputWithErrorLevelf("Error retrieving client [%s]: %s", arg, err) + continue + } + + clients = append(clients, client) + } + + return output.CommandOutput(cmd, OutputAccountClientsProvider(clients)) +} + +func accountClientCreateCmd(f factory.ClientFactory) *cobra.Command { + cmd := &cobra.Command{ + Use: "create", + Short: "Creates a client", + Long: "This command creates a client", + Example: "ans account client create", + RunE: func(cmd *cobra.Command, args []string) error { + c, err := f.NewClient() + if err != nil { + return err + } + + return accountClientCreate(c.AccountService(), cmd, args) + }, + } + + // Setup flags + cmd.Flags().String("company-name", "", "Name of company") + cmd.Flags().String("first-name", "", "First name of client contact") + cmd.Flags().String("last-name", "", "Last name of client contact") + cmd.Flags().String("email-address", "", "Email address of client contact") + cmd.Flags().String("limited-number", "", "Limited company number") + cmd.Flags().String("vat-number", "", "VAT number") + cmd.Flags().String("address", "", "Address of company") + cmd.Flags().String("address1", "", "Address line 1 of company") + cmd.Flags().String("city", "", "City of company") + cmd.Flags().String("county", "", "County of company") + cmd.Flags().String("country", "", "Country of company") + cmd.Flags().String("postcode", "", "Post code of company") + cmd.Flags().String("phone-number", "", "Phone number of company") + cmd.Flags().String("fax-number", "", "Fax number of company") + cmd.Flags().String("mobile-number", "", "Mobile number of company") + cmd.Flags().String("type", "", "Type of client") + cmd.Flags().String("user-name", "", "Username of client contact") + cmd.Flags().String("id-reference", "", "ID reference for client") + cmd.Flags().String("nominet-contact-id", "", "ID of Nominet contact") + + return cmd +} + +func accountClientCreate(service account.AccountService, cmd *cobra.Command, args []string) error { + createRequest := account.CreateClientRequest{} + createRequest.CompanyName, _ = cmd.Flags().GetString("company-name") + createRequest.FirstName, _ = cmd.Flags().GetString("first-name") + createRequest.LastName, _ = cmd.Flags().GetString("last-name") + createRequest.EmailAddress, _ = cmd.Flags().GetString("email-address") + createRequest.LimitedNumber, _ = cmd.Flags().GetString("limited-number") + createRequest.VATNumber, _ = cmd.Flags().GetString("vat-number") + createRequest.Address, _ = cmd.Flags().GetString("address") + createRequest.Address1, _ = cmd.Flags().GetString("address1") + createRequest.City, _ = cmd.Flags().GetString("city") + createRequest.County, _ = cmd.Flags().GetString("county") + createRequest.Country, _ = cmd.Flags().GetString("country") + createRequest.Postcode, _ = cmd.Flags().GetString("postcode") + createRequest.Phone, _ = cmd.Flags().GetString("phone-number") + createRequest.Fax, _ = cmd.Flags().GetString("fax-number") + createRequest.Mobile, _ = cmd.Flags().GetString("mobile-number") + createRequest.Type, _ = cmd.Flags().GetString("type") + createRequest.UserName, _ = cmd.Flags().GetString("user-name") + createRequest.IDReference, _ = cmd.Flags().GetString("id-reference") + createRequest.NominetContactID, _ = cmd.Flags().GetString("nominet-contact-id") + + id, err := service.CreateClient(createRequest) + if err != nil { + return fmt.Errorf("Error creating client: %s", err) + } + + client, err := service.GetClient(id) + if err != nil { + return fmt.Errorf("Error retrieving new client: %s", err) + } + + return output.CommandOutput(cmd, OutputAccountClientsProvider([]account.Client{client})) +} + +func accountClientUpdateCmd(f factory.ClientFactory) *cobra.Command { + cmd := &cobra.Command{ + Use: "update ...", + Short: "Updates a client", + Long: "This command updates one or more clients", + Example: "ans account client update 123 --name \"test client 1\"", + Args: func(cmd *cobra.Command, args []string) error { + if len(args) < 1 { + return errors.New("Missing client") + } + + return nil + }, + RunE: func(cmd *cobra.Command, args []string) error { + c, err := f.NewClient() + if err != nil { + return err + } + + return accountClientUpdate(c.AccountService(), cmd, args) + }, + } + + // Setup flags + cmd.Flags().String("company-name", "", "Name of company") + cmd.Flags().String("first-name", "", "First name of client contact") + cmd.Flags().String("last-name", "", "Last name of client contact") + cmd.Flags().String("email-address", "", "Email address of client contact") + cmd.Flags().String("limited-number", "", "Limited company number") + cmd.Flags().String("vat-number", "", "VAT number") + cmd.Flags().String("address", "", "Address of company") + cmd.Flags().String("address1", "", "Address line 1 of company") + cmd.Flags().String("city", "", "City of company") + cmd.Flags().String("county", "", "County of company") + cmd.Flags().String("country", "", "Country of company") + cmd.Flags().String("postcode", "", "Post code of company") + cmd.Flags().String("phone-number", "", "Phone number of company") + cmd.Flags().String("fax-number", "", "Fax number of company") + cmd.Flags().String("mobile-number", "", "Mobile number of company") + cmd.Flags().String("type", "", "Type of client") + cmd.Flags().String("user-name", "", "Username of client contact") + cmd.Flags().String("id-reference", "", "ID reference for client") + cmd.Flags().String("nominet-contact-id", "", "ID of Nominet contact") + + return cmd +} + +func accountClientUpdate(service account.AccountService, cmd *cobra.Command, args []string) error { + + patchRequest := account.PatchClientRequest{} + patchRequest.CompanyName, _ = cmd.Flags().GetString("company-name") + patchRequest.FirstName, _ = cmd.Flags().GetString("first-name") + patchRequest.LastName, _ = cmd.Flags().GetString("last-name") + patchRequest.EmailAddress, _ = cmd.Flags().GetString("email-address") + patchRequest.LimitedNumber, _ = cmd.Flags().GetString("limited-number") + patchRequest.VATNumber, _ = cmd.Flags().GetString("vat-number") + patchRequest.Address, _ = cmd.Flags().GetString("address") + patchRequest.Address1, _ = cmd.Flags().GetString("address1") + patchRequest.City, _ = cmd.Flags().GetString("city") + patchRequest.County, _ = cmd.Flags().GetString("county") + patchRequest.Country, _ = cmd.Flags().GetString("country") + patchRequest.Postcode, _ = cmd.Flags().GetString("postcode") + patchRequest.Phone, _ = cmd.Flags().GetString("phone-number") + patchRequest.Fax, _ = cmd.Flags().GetString("fax-number") + patchRequest.Mobile, _ = cmd.Flags().GetString("mobile-number") + patchRequest.Type, _ = cmd.Flags().GetString("type") + patchRequest.UserName, _ = cmd.Flags().GetString("user-name") + patchRequest.IDReference, _ = cmd.Flags().GetString("id-reference") + patchRequest.NominetContactID, _ = cmd.Flags().GetString("nominet-contact-id") + + var clients []account.Client + + for _, arg := range args { + clientID, err := strconv.Atoi(arg) + if err != nil { + output.OutputWithErrorLevelf("Invalid client ID [%s]", arg) + continue + } + + err = service.PatchClient(clientID, patchRequest) + if err != nil { + output.OutputWithErrorLevelf("Error updating client [%d]: %s", clientID, err.Error()) + continue + } + + client, err := service.GetClient(clientID) + if err != nil { + output.OutputWithErrorLevelf("Error retrieving updated client [%d]: %s", clientID, err.Error()) + continue + } + + clients = append(clients, client) + } + + return output.CommandOutput(cmd, OutputAccountClientsProvider(clients)) +} + +func accountClientDeleteCmd(f factory.ClientFactory) *cobra.Command { + return &cobra.Command{ + Use: "delete ...", + Short: "Removes a client", + Long: "This command removes one or more clients", + Example: "ans account client delete 123", + Args: func(cmd *cobra.Command, args []string) error { + if len(args) < 1 { + return errors.New("Missing client") + } + + return nil + }, + RunE: func(cmd *cobra.Command, args []string) error { + c, err := f.NewClient() + if err != nil { + return err + } + + accountClientDelete(c.AccountService(), cmd, args) + return nil + }, + } +} + +func accountClientDelete(service account.AccountService, cmd *cobra.Command, args []string) { + for _, arg := range args { + clientID, err := strconv.Atoi(arg) + if err != nil { + output.OutputWithErrorLevelf("Invalid client ID [%s]", arg) + continue + } + + err = service.DeleteClient(clientID) + if err != nil { + output.OutputWithErrorLevelf("Error removing client [%d]: %s", clientID, err) + continue + } + } +} diff --git a/cmd/account/account_client_test.go b/cmd/account/account_client_test.go new file mode 100644 index 0000000..5a7b67d --- /dev/null +++ b/cmd/account/account_client_test.go @@ -0,0 +1,335 @@ +package account + +import ( + "errors" + "testing" + + "github.com/ans-group/cli/internal/pkg/clierrors" + "github.com/ans-group/cli/test/mocks" + "github.com/ans-group/cli/test/test_output" + "github.com/ans-group/sdk-go/pkg/service/account" + gomock "github.com/golang/mock/gomock" + "github.com/spf13/cobra" + "github.com/stretchr/testify/assert" +) + +func Test_accountClientList(t *testing.T) { + t.Run("DefaultRetrieve", func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + service := mocks.NewMockAccountService(mockCtrl) + + service.EXPECT().GetClients(gomock.Any()).Return([]account.Client{}, nil).Times(1) + + accountClientList(service, &cobra.Command{}, []string{}) + }) + + t.Run("MalformedFlag_ReturnsError", func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + service := mocks.NewMockAccountService(mockCtrl) + cmd := &cobra.Command{} + cmd.Flags().StringArray("filter", []string{"invalidfilter"}, "") + + err := accountClientList(service, cmd, []string{}) + + assert.IsType(t, &clierrors.ErrInvalidFlagValue{}, err) + }) + + t.Run("GetClientsError_ReturnsError", func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + service := mocks.NewMockAccountService(mockCtrl) + + service.EXPECT().GetClients(gomock.Any()).Return([]account.Client{}, errors.New("test error")).Times(1) + + err := accountClientList(service, &cobra.Command{}, []string{}) + + assert.Equal(t, "Error retrieving clients: test error", err.Error()) + }) +} + +func Test_accountClientShowCmd_Args(t *testing.T) { + t.Run("ValidArgs_NoError", func(t *testing.T) { + err := accountClientShowCmd(nil).Args(nil, []string{"123"}) + + assert.Nil(t, err) + }) + + t.Run("InvalidArgs_Error", func(t *testing.T) { + err := accountClientShowCmd(nil).Args(nil, []string{}) + + assert.NotNil(t, err) + assert.Equal(t, "Missing client", err.Error()) + }) +} + +func Test_accountClientShow(t *testing.T) { + t.Run("SingleClient", func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + service := mocks.NewMockAccountService(mockCtrl) + + service.EXPECT().GetClient(123).Return(account.Client{}, nil).Times(1) + + accountClientShow(service, &cobra.Command{}, []string{"123"}) + }) + + t.Run("MultipleClients", func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + service := mocks.NewMockAccountService(mockCtrl) + + gomock.InOrder( + service.EXPECT().GetClient(123).Return(account.Client{}, nil), + service.EXPECT().GetClient(456).Return(account.Client{}, nil), + ) + + accountClientShow(service, &cobra.Command{}, []string{"123", "456"}) + }) + + t.Run("GetClientID_OutputsError", func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + service := mocks.NewMockAccountService(mockCtrl) + + test_output.AssertErrorOutput(t, "Invalid client ID [abc]\n", func() { + accountClientShow(service, &cobra.Command{}, []string{"abc"}) + }) + }) + + t.Run("GetClientError_OutputsError", func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + service := mocks.NewMockAccountService(mockCtrl) + + service.EXPECT().GetClient(123).Return(account.Client{}, errors.New("test error")) + + test_output.AssertErrorOutput(t, "Error retrieving client [123]: test error\n", func() { + accountClientShow(service, &cobra.Command{}, []string{"123"}) + }) + }) +} + +func Test_accountClientCreate(t *testing.T) { + t.Run("DefaultCreate", func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + service := mocks.NewMockAccountService(mockCtrl) + cmd := accountClientCreateCmd(nil) + cmd.Flags().Set("company-name", "test client 1") + + expectedReq := account.CreateClientRequest{ + CompanyName: "test client 1", + } + + gomock.InOrder( + service.EXPECT().CreateClient(expectedReq).Return(123, nil), + service.EXPECT().GetClient(123).Return(account.Client{}, nil), + ) + + accountClientCreate(service, cmd, []string{}) + }) + + t.Run("CreateClientError_ReturnsError", func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + service := mocks.NewMockAccountService(mockCtrl) + + service.EXPECT().CreateClient(gomock.Any()).Return(0, errors.New("test error")).Times(1) + + err := accountClientCreate(service, &cobra.Command{}, []string{}) + + assert.Equal(t, "Error creating client: test error", err.Error()) + }) + + t.Run("GetClientError_ReturnsError", func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + service := mocks.NewMockAccountService(mockCtrl) + + gomock.InOrder( + service.EXPECT().CreateClient(gomock.Any()).Return(123, nil), + service.EXPECT().GetClient(123).Return(account.Client{}, errors.New("test error")), + ) + + err := accountClientCreate(service, &cobra.Command{}, []string{}) + + assert.Equal(t, "Error retrieving new client: test error", err.Error()) + }) +} + +func Test_accountClientUpdateCmd_Args(t *testing.T) { + t.Run("ValidArgs_NoError", func(t *testing.T) { + err := accountClientUpdateCmd(nil).Args(nil, []string{"123"}) + + assert.Nil(t, err) + }) + + t.Run("InvalidArgs_Error", func(t *testing.T) { + err := accountClientUpdateCmd(nil).Args(nil, []string{}) + + assert.NotNil(t, err) + assert.Equal(t, "Missing client", err.Error()) + }) +} + +func Test_accountClientUpdate(t *testing.T) { + t.Run("SingleClient_SetsCPU", func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + service := mocks.NewMockAccountService(mockCtrl) + cmd := accountClientUpdateCmd(nil) + cmd.Flags().Set("company-name", "test") + + expectedPatch := account.PatchClientRequest{ + CompanyName: "test", + } + + gomock.InOrder( + service.EXPECT().PatchClient(123, expectedPatch).Return(nil), + service.EXPECT().GetClient(123).Return(account.Client{}, nil), + ) + + accountClientUpdate(service, cmd, []string{"123"}) + }) + + t.Run("MultipleClients", func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + service := mocks.NewMockAccountService(mockCtrl) + cmd := accountClientUpdateCmd(nil) + cmd.Flags().Set("company-name", "test") + + expectedPatch := account.PatchClientRequest{ + CompanyName: "test", + } + + gomock.InOrder( + service.EXPECT().PatchClient(123, gomock.Eq(expectedPatch)).Return(nil), + service.EXPECT().GetClient(123).Return(account.Client{}, nil), + service.EXPECT().PatchClient(456, gomock.Eq(expectedPatch)).Return(nil), + service.EXPECT().GetClient(456).Return(account.Client{}, nil), + ) + + accountClientUpdate(service, cmd, []string{"123", "456"}) + }) + + t.Run("InvalidClientID_OutputsError", func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + service := mocks.NewMockAccountService(mockCtrl) + + test_output.AssertErrorOutput(t, "Invalid client ID [abc]\n", func() { + accountClientUpdate(service, &cobra.Command{}, []string{"abc"}) + }) + }) + + t.Run("PatchClientError_OutputsError", func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + service := mocks.NewMockAccountService(mockCtrl) + + service.EXPECT().PatchClient(123, gomock.Any()).Return(errors.New("test error")) + + test_output.AssertErrorOutput(t, "Error updating client [123]: test error\n", func() { + accountClientUpdate(service, &cobra.Command{}, []string{"123"}) + }) + }) + + t.Run("GetClientError_OutputsError", func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + service := mocks.NewMockAccountService(mockCtrl) + + gomock.InOrder( + service.EXPECT().PatchClient(123, gomock.Any()).Return(nil), + service.EXPECT().GetClient(123).Return(account.Client{}, errors.New("test error")), + ) + + test_output.AssertErrorOutput(t, "Error retrieving updated client [123]: test error\n", func() { + accountClientUpdate(service, &cobra.Command{}, []string{"123"}) + }) + }) +} + +func Test_accountClientDeleteCmd_Args(t *testing.T) { + t.Run("ValidArgs_NoError", func(t *testing.T) { + err := accountClientDeleteCmd(nil).Args(nil, []string{"123"}) + + assert.Nil(t, err) + }) + + t.Run("InvalidArgs_Error", func(t *testing.T) { + err := accountClientDeleteCmd(nil).Args(nil, []string{}) + + assert.NotNil(t, err) + assert.Equal(t, "Missing client", err.Error()) + }) +} + +func Test_accountClientDelete(t *testing.T) { + t.Run("SingleClient", func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + service := mocks.NewMockAccountService(mockCtrl) + + service.EXPECT().DeleteClient(123).Return(nil).Times(1) + + accountClientDelete(service, &cobra.Command{}, []string{"123"}) + }) + + t.Run("MultipleClients", func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + service := mocks.NewMockAccountService(mockCtrl) + + gomock.InOrder( + service.EXPECT().DeleteClient(123).Return(nil), + service.EXPECT().DeleteClient(456).Return(nil), + ) + + accountClientDelete(service, &cobra.Command{}, []string{"123", "456"}) + }) + + t.Run("InvalidClientID_OutputsError", func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + service := mocks.NewMockAccountService(mockCtrl) + + test_output.AssertErrorOutput(t, "Invalid client ID [abc]\n", func() { + accountClientDelete(service, &cobra.Command{}, []string{"abc"}) + }) + }) + + t.Run("GetClientError_OutputsError", func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + service := mocks.NewMockAccountService(mockCtrl) + + service.EXPECT().DeleteClient(123).Return(errors.New("test error")) + + test_output.AssertErrorOutput(t, "Error removing client [123]: test error\n", func() { + accountClientDelete(service, &cobra.Command{}, []string{"123"}) + }) + }) +} diff --git a/cmd/account/output.go b/cmd/account/output.go index 0c10958..378a277 100644 --- a/cmd/account/output.go +++ b/cmd/account/output.go @@ -19,3 +19,8 @@ func OutputAccountCreditsProvider(credits []account.Credit) output.OutputHandler return output.NewSerializedOutputHandlerDataProvider(credits). WithDefaultFields([]string{"type", "total", "remaining"}) } + +func OutputAccountClientsProvider(clients []account.Client) output.OutputHandlerDataProvider { + return output.NewSerializedOutputHandlerDataProvider(clients). + WithDefaultFields([]string{"id", "company_name"}) +} diff --git a/go.mod b/go.mod index cd9164c..04ae077 100644 --- a/go.mod +++ b/go.mod @@ -3,7 +3,7 @@ module github.com/ans-group/cli go 1.18 require ( - github.com/ans-group/sdk-go v1.16.7 + github.com/ans-group/sdk-go v1.16.9 github.com/blang/semver v3.5.1+incompatible github.com/golang/mock v1.6.0 github.com/iancoleman/strcase v0.0.0-20191112232945-16388991a334 diff --git a/go.sum b/go.sum index cdcdb9e..7663b3c 100644 --- a/go.sum +++ b/go.sum @@ -40,8 +40,8 @@ github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03 github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo= github.com/ans-group/go-durationstring v1.2.0 h1:UJIuQATkp0t1rBvZsHRwki33YHV9E+Ulro+3NbMB7MM= github.com/ans-group/go-durationstring v1.2.0/go.mod h1:QGF9Mdpq9058QXaut8r55QWu6lcHX6i/GvF1PZVkV6o= -github.com/ans-group/sdk-go v1.16.7 h1:oVk5ZQA66MBRadIligP8qETbWRcq0iPBTC+bACc/Yl8= -github.com/ans-group/sdk-go v1.16.7/go.mod h1:p1vrXBxHPvMOGlS4sFUSgeLeKAl9vIe/lJ6UaExe49A= +github.com/ans-group/sdk-go v1.16.9 h1:QwK/tkqDSGJEj9fqekMMNgcCHbfcTqx74wtI/4aEZD8= +github.com/ans-group/sdk-go v1.16.9/go.mod h1:p1vrXBxHPvMOGlS4sFUSgeLeKAl9vIe/lJ6UaExe49A= github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8= github.com/blang/semver v3.5.1+incompatible h1:cQNTCjp13qL8KC3Nbxr/y2Bqb63oX6wdnnjpJbkM4JQ= github.com/blang/semver v3.5.1+incompatible/go.mod h1:kRBLl5iJ+tD4TcOOxsy/0fnwebNt5EWlYSAyrTnjyyk= diff --git a/test/mocks/mock_accountservice.go b/test/mocks/mock_accountservice.go index 460b6fb..1b6c362 100644 --- a/test/mocks/mock_accountservice.go +++ b/test/mocks/mock_accountservice.go @@ -5,212 +5,299 @@ package mocks import ( - reflect "reflect" - - gomock "github.com/golang/mock/gomock" - connection "github.com/ans-group/sdk-go/pkg/connection" - account "github.com/ans-group/sdk-go/pkg/service/account" + connection "github.com/ans-group/sdk-go/pkg/connection" + account "github.com/ans-group/sdk-go/pkg/service/account" + gomock "github.com/golang/mock/gomock" + reflect "reflect" ) // MockAccountService is a mock of AccountService interface. type MockAccountService struct { - ctrl *gomock.Controller - recorder *MockAccountServiceMockRecorder + ctrl *gomock.Controller + recorder *MockAccountServiceMockRecorder } // MockAccountServiceMockRecorder is the mock recorder for MockAccountService. type MockAccountServiceMockRecorder struct { - mock *MockAccountService + mock *MockAccountService } // NewMockAccountService creates a new mock instance. func NewMockAccountService(ctrl *gomock.Controller) *MockAccountService { - mock := &MockAccountService{ctrl: ctrl} - mock.recorder = &MockAccountServiceMockRecorder{mock} - return mock + mock := &MockAccountService{ctrl: ctrl} + mock.recorder = &MockAccountServiceMockRecorder{mock} + return mock } // EXPECT returns an object that allows the caller to indicate expected use. func (m *MockAccountService) EXPECT() *MockAccountServiceMockRecorder { - return m.recorder + return m.recorder +} + +// CreateClient mocks base method. +func (m *MockAccountService) CreateClient(arg0 account.CreateClientRequest) (int, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateClient", arg0) + ret0, _ := ret[0].(int) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateClient indicates an expected call of CreateClient. +func (mr *MockAccountServiceMockRecorder) CreateClient(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClient", reflect.TypeOf((*MockAccountService)(nil).CreateClient), arg0) } // CreateInvoiceQuery mocks base method. func (m *MockAccountService) CreateInvoiceQuery(arg0 account.CreateInvoiceQueryRequest) (int, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateInvoiceQuery", arg0) - ret0, _ := ret[0].(int) - ret1, _ := ret[1].(error) - return ret0, ret1 + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateInvoiceQuery", arg0) + ret0, _ := ret[0].(int) + ret1, _ := ret[1].(error) + return ret0, ret1 } // CreateInvoiceQuery indicates an expected call of CreateInvoiceQuery. func (mr *MockAccountServiceMockRecorder) CreateInvoiceQuery(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInvoiceQuery", reflect.TypeOf((*MockAccountService)(nil).CreateInvoiceQuery), arg0) + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInvoiceQuery", reflect.TypeOf((*MockAccountService)(nil).CreateInvoiceQuery), arg0) +} + +// DeleteClient mocks base method. +func (m *MockAccountService) DeleteClient(arg0 int) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteClient", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// DeleteClient indicates an expected call of DeleteClient. +func (mr *MockAccountServiceMockRecorder) DeleteClient(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteClient", reflect.TypeOf((*MockAccountService)(nil).DeleteClient), arg0) +} + +// GetClient mocks base method. +func (m *MockAccountService) GetClient(arg0 int) (account.Client, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetClient", arg0) + ret0, _ := ret[0].(account.Client) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetClient indicates an expected call of GetClient. +func (mr *MockAccountServiceMockRecorder) GetClient(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClient", reflect.TypeOf((*MockAccountService)(nil).GetClient), arg0) +} + +// GetClients mocks base method. +func (m *MockAccountService) GetClients(arg0 connection.APIRequestParameters) ([]account.Client, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetClients", arg0) + ret0, _ := ret[0].([]account.Client) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetClients indicates an expected call of GetClients. +func (mr *MockAccountServiceMockRecorder) GetClients(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClients", reflect.TypeOf((*MockAccountService)(nil).GetClients), arg0) +} + +// GetClientsPaginated mocks base method. +func (m *MockAccountService) GetClientsPaginated(arg0 connection.APIRequestParameters) (*connection.Paginated[account.Client], error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetClientsPaginated", arg0) + ret0, _ := ret[0].(*connection.Paginated[account.Client]) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetClientsPaginated indicates an expected call of GetClientsPaginated. +func (mr *MockAccountServiceMockRecorder) GetClientsPaginated(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClientsPaginated", reflect.TypeOf((*MockAccountService)(nil).GetClientsPaginated), arg0) } // GetContact mocks base method. func (m *MockAccountService) GetContact(arg0 int) (account.Contact, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetContact", arg0) - ret0, _ := ret[0].(account.Contact) - ret1, _ := ret[1].(error) - return ret0, ret1 + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetContact", arg0) + ret0, _ := ret[0].(account.Contact) + ret1, _ := ret[1].(error) + return ret0, ret1 } // GetContact indicates an expected call of GetContact. func (mr *MockAccountServiceMockRecorder) GetContact(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContact", reflect.TypeOf((*MockAccountService)(nil).GetContact), arg0) + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContact", reflect.TypeOf((*MockAccountService)(nil).GetContact), arg0) } // GetContacts mocks base method. func (m *MockAccountService) GetContacts(arg0 connection.APIRequestParameters) ([]account.Contact, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetContacts", arg0) - ret0, _ := ret[0].([]account.Contact) - ret1, _ := ret[1].(error) - return ret0, ret1 + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetContacts", arg0) + ret0, _ := ret[0].([]account.Contact) + ret1, _ := ret[1].(error) + return ret0, ret1 } // GetContacts indicates an expected call of GetContacts. func (mr *MockAccountServiceMockRecorder) GetContacts(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContacts", reflect.TypeOf((*MockAccountService)(nil).GetContacts), arg0) + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContacts", reflect.TypeOf((*MockAccountService)(nil).GetContacts), arg0) } // GetContactsPaginated mocks base method. func (m *MockAccountService) GetContactsPaginated(arg0 connection.APIRequestParameters) (*connection.Paginated[account.Contact], error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetContactsPaginated", arg0) - ret0, _ := ret[0].(*connection.Paginated[account.Contact]) - ret1, _ := ret[1].(error) - return ret0, ret1 + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetContactsPaginated", arg0) + ret0, _ := ret[0].(*connection.Paginated[account.Contact]) + ret1, _ := ret[1].(error) + return ret0, ret1 } // GetContactsPaginated indicates an expected call of GetContactsPaginated. func (mr *MockAccountServiceMockRecorder) GetContactsPaginated(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContactsPaginated", reflect.TypeOf((*MockAccountService)(nil).GetContactsPaginated), arg0) + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContactsPaginated", reflect.TypeOf((*MockAccountService)(nil).GetContactsPaginated), arg0) } // GetCredits mocks base method. func (m *MockAccountService) GetCredits(arg0 connection.APIRequestParameters) ([]account.Credit, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetCredits", arg0) - ret0, _ := ret[0].([]account.Credit) - ret1, _ := ret[1].(error) - return ret0, ret1 + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCredits", arg0) + ret0, _ := ret[0].([]account.Credit) + ret1, _ := ret[1].(error) + return ret0, ret1 } // GetCredits indicates an expected call of GetCredits. func (mr *MockAccountServiceMockRecorder) GetCredits(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCredits", reflect.TypeOf((*MockAccountService)(nil).GetCredits), arg0) + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCredits", reflect.TypeOf((*MockAccountService)(nil).GetCredits), arg0) } // GetDetails mocks base method. func (m *MockAccountService) GetDetails() (account.Details, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetDetails") - ret0, _ := ret[0].(account.Details) - ret1, _ := ret[1].(error) - return ret0, ret1 + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetDetails") + ret0, _ := ret[0].(account.Details) + ret1, _ := ret[1].(error) + return ret0, ret1 } // GetDetails indicates an expected call of GetDetails. func (mr *MockAccountServiceMockRecorder) GetDetails() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDetails", reflect.TypeOf((*MockAccountService)(nil).GetDetails)) + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDetails", reflect.TypeOf((*MockAccountService)(nil).GetDetails)) } // GetInvoice mocks base method. func (m *MockAccountService) GetInvoice(arg0 int) (account.Invoice, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetInvoice", arg0) - ret0, _ := ret[0].(account.Invoice) - ret1, _ := ret[1].(error) - return ret0, ret1 + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetInvoice", arg0) + ret0, _ := ret[0].(account.Invoice) + ret1, _ := ret[1].(error) + return ret0, ret1 } // GetInvoice indicates an expected call of GetInvoice. func (mr *MockAccountServiceMockRecorder) GetInvoice(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInvoice", reflect.TypeOf((*MockAccountService)(nil).GetInvoice), arg0) + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInvoice", reflect.TypeOf((*MockAccountService)(nil).GetInvoice), arg0) } // GetInvoiceQueries mocks base method. func (m *MockAccountService) GetInvoiceQueries(arg0 connection.APIRequestParameters) ([]account.InvoiceQuery, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetInvoiceQueries", arg0) - ret0, _ := ret[0].([]account.InvoiceQuery) - ret1, _ := ret[1].(error) - return ret0, ret1 + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetInvoiceQueries", arg0) + ret0, _ := ret[0].([]account.InvoiceQuery) + ret1, _ := ret[1].(error) + return ret0, ret1 } // GetInvoiceQueries indicates an expected call of GetInvoiceQueries. func (mr *MockAccountServiceMockRecorder) GetInvoiceQueries(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInvoiceQueries", reflect.TypeOf((*MockAccountService)(nil).GetInvoiceQueries), arg0) + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInvoiceQueries", reflect.TypeOf((*MockAccountService)(nil).GetInvoiceQueries), arg0) } // GetInvoiceQueriesPaginated mocks base method. func (m *MockAccountService) GetInvoiceQueriesPaginated(arg0 connection.APIRequestParameters) (*connection.Paginated[account.InvoiceQuery], error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetInvoiceQueriesPaginated", arg0) - ret0, _ := ret[0].(*connection.Paginated[account.InvoiceQuery]) - ret1, _ := ret[1].(error) - return ret0, ret1 + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetInvoiceQueriesPaginated", arg0) + ret0, _ := ret[0].(*connection.Paginated[account.InvoiceQuery]) + ret1, _ := ret[1].(error) + return ret0, ret1 } // GetInvoiceQueriesPaginated indicates an expected call of GetInvoiceQueriesPaginated. func (mr *MockAccountServiceMockRecorder) GetInvoiceQueriesPaginated(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInvoiceQueriesPaginated", reflect.TypeOf((*MockAccountService)(nil).GetInvoiceQueriesPaginated), arg0) + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInvoiceQueriesPaginated", reflect.TypeOf((*MockAccountService)(nil).GetInvoiceQueriesPaginated), arg0) } // GetInvoiceQuery mocks base method. func (m *MockAccountService) GetInvoiceQuery(arg0 int) (account.InvoiceQuery, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetInvoiceQuery", arg0) - ret0, _ := ret[0].(account.InvoiceQuery) - ret1, _ := ret[1].(error) - return ret0, ret1 + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetInvoiceQuery", arg0) + ret0, _ := ret[0].(account.InvoiceQuery) + ret1, _ := ret[1].(error) + return ret0, ret1 } // GetInvoiceQuery indicates an expected call of GetInvoiceQuery. func (mr *MockAccountServiceMockRecorder) GetInvoiceQuery(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInvoiceQuery", reflect.TypeOf((*MockAccountService)(nil).GetInvoiceQuery), arg0) + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInvoiceQuery", reflect.TypeOf((*MockAccountService)(nil).GetInvoiceQuery), arg0) } // GetInvoices mocks base method. func (m *MockAccountService) GetInvoices(arg0 connection.APIRequestParameters) ([]account.Invoice, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetInvoices", arg0) - ret0, _ := ret[0].([]account.Invoice) - ret1, _ := ret[1].(error) - return ret0, ret1 + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetInvoices", arg0) + ret0, _ := ret[0].([]account.Invoice) + ret1, _ := ret[1].(error) + return ret0, ret1 } // GetInvoices indicates an expected call of GetInvoices. func (mr *MockAccountServiceMockRecorder) GetInvoices(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInvoices", reflect.TypeOf((*MockAccountService)(nil).GetInvoices), arg0) + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInvoices", reflect.TypeOf((*MockAccountService)(nil).GetInvoices), arg0) } // GetInvoicesPaginated mocks base method. func (m *MockAccountService) GetInvoicesPaginated(arg0 connection.APIRequestParameters) (*connection.Paginated[account.Invoice], error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetInvoicesPaginated", arg0) - ret0, _ := ret[0].(*connection.Paginated[account.Invoice]) - ret1, _ := ret[1].(error) - return ret0, ret1 + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetInvoicesPaginated", arg0) + ret0, _ := ret[0].(*connection.Paginated[account.Invoice]) + ret1, _ := ret[1].(error) + return ret0, ret1 } // GetInvoicesPaginated indicates an expected call of GetInvoicesPaginated. func (mr *MockAccountServiceMockRecorder) GetInvoicesPaginated(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInvoicesPaginated", reflect.TypeOf((*MockAccountService)(nil).GetInvoicesPaginated), arg0) + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInvoicesPaginated", reflect.TypeOf((*MockAccountService)(nil).GetInvoicesPaginated), arg0) } + +// PatchClient mocks base method. +func (m *MockAccountService) PatchClient(arg0 int, arg1 account.PatchClientRequest) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PatchClient", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// PatchClient indicates an expected call of PatchClient. +func (mr *MockAccountServiceMockRecorder) PatchClient(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchClient", reflect.TypeOf((*MockAccountService)(nil).PatchClient), arg0, arg1) +} \ No newline at end of file