diff --git a/internal/cli/atlas/deployments/delete.go b/internal/cli/atlas/deployments/delete.go index bbcc18561a..8e531bad7b 100644 --- a/internal/cli/atlas/deployments/delete.go +++ b/internal/cli/atlas/deployments/delete.go @@ -86,6 +86,7 @@ func (opts *DeleteOpts) runLocal(ctx context.Context) error { } func (opts *DeleteOpts) PostRun() error { + opts.UpdateDeploymentTelemetry() if !opts.EnableWatch || !opts.IsAtlasDeploymentType() { return nil } diff --git a/internal/cli/atlas/deployments/delete_test.go b/internal/cli/atlas/deployments/delete_test.go index a77700abaf..37c1b62559 100644 --- a/internal/cli/atlas/deployments/delete_test.go +++ b/internal/cli/atlas/deployments/delete_test.go @@ -159,3 +159,27 @@ func TestDeleteBuilder(t *testing.T) { []string{flag.TypeFlag, flag.Force, flag.EnableWatch, flag.WatchTimeout, flag.ProjectID}, ) } + +func TestDelete_PostRun(t *testing.T) { + ctrl := gomock.NewController(t) + deploymentsTest := fixture.NewMockLocalDeploymentOpts(ctrl, "localDeployment") + buf := new(bytes.Buffer) + + opts := &DeleteOpts{ + DeploymentOpts: *deploymentsTest.Opts, + GlobalOpts: cli.GlobalOpts{ + ProjectID: "64f670f0bf789926667dad1a", + }, + OutputOpts: cli.OutputOpts{ + OutWriter: buf, + }, + DeleteOpts: cli.NewDeleteOpts(deleteSuccessMessage, deleteFailMessage), + } + + deploymentsTest.MockDeploymentTelemetry.EXPECT().AppendDeploymentType().Times(1) + + if err := opts.PostRun(); err != nil { + t.Fatalf("PostRun() unexpected error: %v", err) + } + t.Log(buf.String()) +} diff --git a/internal/cli/atlas/deployments/list.go b/internal/cli/atlas/deployments/list.go index df75990293..25e169f7fe 100644 --- a/internal/cli/atlas/deployments/list.go +++ b/internal/cli/atlas/deployments/list.go @@ -71,6 +71,7 @@ func (opts *ListOpts) Run(ctx context.Context) error { } func (opts *ListOpts) PostRun() error { + opts.UpdateDeploymentTelemetry() return opts.PostRunMessages() } @@ -89,7 +90,8 @@ func ListBuilder() *cobra.Command { PreRunE: func(cmd *cobra.Command, _ []string) error { return opts.PreRunE( opts.InitStore(cmd.Context(), cmd.OutOrStdout()), - opts.InitOutput(cmd.OutOrStdout(), listTemplate)) + opts.InitOutput(cmd.OutOrStdout(), listTemplate), + ) }, RunE: func(cmd *cobra.Command, _ []string) error { return opts.Run(cmd.Context()) diff --git a/internal/cli/atlas/deployments/list_test.go b/internal/cli/atlas/deployments/list_test.go index 6d6531c9a6..23dbc9d9dc 100644 --- a/internal/cli/atlas/deployments/list_test.go +++ b/internal/cli/atlas/deployments/list_test.go @@ -24,6 +24,7 @@ import ( "github.com/golang/mock/gomock" "github.com/mongodb/mongodb-atlas-cli/atlascli/internal/cli" "github.com/mongodb/mongodb-atlas-cli/atlascli/internal/cli/atlas/deployments/options" + "github.com/mongodb/mongodb-atlas-cli/atlascli/internal/cli/atlas/deployments/test/fixture" "github.com/mongodb/mongodb-atlas-cli/atlascli/internal/config" "github.com/mongodb/mongodb-atlas-cli/atlascli/internal/flag" "github.com/mongodb/mongodb-atlas-cli/atlascli/internal/mocks" @@ -147,3 +148,43 @@ func TestListBuilder(t *testing.T) { []string{flag.ProjectID}, ) } + +func TestList_PostRun(t *testing.T) { + ctrl := gomock.NewController(t) + buf := new(bytes.Buffer) + + mockStore := mocks.NewMockClusterLister(ctrl) + mockCredentialsGetter := mocks.NewMockCredentialsGetter(ctrl) + mockProfileReader := mocks.NewMockProfileReader(ctrl) + + deploymentsTest := fixture.NewMockLocalDeploymentOpts(ctrl, "localDeployment") + deploymentsTest.Opts.Config = mockProfileReader + deploymentsTest.Opts.CredStore = mockCredentialsGetter + deploymentsTest.Opts.AtlasClusterListStore = mockStore + + listOpts := &ListOpts{ + DeploymentOpts: *deploymentsTest.Opts, + GlobalOpts: cli.GlobalOpts{ + ProjectID: "64f670f0bf789926667dad1a", + }, + OutputOpts: cli.OutputOpts{ + Template: listTemplate, + OutWriter: buf, + }, + } + + mockCredentialsGetter. + EXPECT(). + AuthType(). + Return(config.OAuth). + Times(1) + + deploymentsTest.MockDeploymentTelemetry. + EXPECT(). + AppendDeploymentType(). + Times(1) + + if err := listOpts.PostRun(); err != nil { + t.Fatalf("PostRun() unexpected error: %v", err) + } +} diff --git a/internal/cli/atlas/deployments/logs.go b/internal/cli/atlas/deployments/logs.go index f6496940e2..bab5bea6da 100644 --- a/internal/cli/atlas/deployments/logs.go +++ b/internal/cli/atlas/deployments/logs.go @@ -30,7 +30,6 @@ import ( "github.com/mongodb/mongodb-atlas-cli/atlascli/internal/flag" "github.com/mongodb/mongodb-atlas-cli/atlascli/internal/search" "github.com/mongodb/mongodb-atlas-cli/atlascli/internal/store" - "github.com/mongodb/mongodb-atlas-cli/atlascli/internal/telemetry" "github.com/mongodb/mongodb-atlas-cli/atlascli/internal/usage" "github.com/spf13/afero" "github.com/spf13/cobra" @@ -67,12 +66,10 @@ func (opts *DownloadOpts) Run(ctx context.Context) error { } if opts.IsLocalDeploymentType() { - telemetry.AppendOption(telemetry.WithDeploymentType(options.LocalCluster)) return opts.RunLocal(ctx) } if opts.IsAtlasDeploymentType() { - telemetry.AppendOption(telemetry.WithDeploymentType(options.LocalCluster)) if err := opts.validateAtlasFlags(); err != nil { return err } diff --git a/internal/cli/atlas/deployments/options/connect_opts.go b/internal/cli/atlas/deployments/options/connect_opts.go index 9f3ff87b7d..b56effc094 100644 --- a/internal/cli/atlas/deployments/options/connect_opts.go +++ b/internal/cli/atlas/deployments/options/connect_opts.go @@ -53,7 +53,6 @@ func (opts *ConnectOpts) Connect(ctx context.Context) error { } if opts.IsAtlasDeploymentType() { - telemetry.AppendOption(telemetry.WithDeploymentType(AtlasCluster)) if err := opts.validateAndPromptAtlasOpts(); err != nil { return err } @@ -61,7 +60,6 @@ func (opts *ConnectOpts) Connect(ctx context.Context) error { return opts.connectToAtlas() } - telemetry.AppendOption(telemetry.WithDeploymentType(LocalCluster)) return opts.connectToLocal(ctx) } diff --git a/internal/cli/atlas/deployments/options/deployment_opts.go b/internal/cli/atlas/deployments/options/deployment_opts.go index 746e856364..384145b177 100644 --- a/internal/cli/atlas/deployments/options/deployment_opts.go +++ b/internal/cli/atlas/deployments/options/deployment_opts.go @@ -96,6 +96,7 @@ type DeploymentOpts struct { DefaultSetter cli.DefaultSetterOpts AtlasClusterListStore store.ClusterLister Config setup.ProfileReader + DeploymentTelemetry DeploymentTelemetry } type Deployment struct { @@ -115,6 +116,8 @@ func (opts *DeploymentOpts) InitStore(ctx context.Context, writer io.Writer) fun return err } opts.DefaultSetter.OutWriter = writer + opts.DeploymentTelemetry = NewDeploymentTypeTelemetry(opts) + opts.UpdateDeploymentTelemetry() return opts.DefaultSetter.InitStore(ctx) } } @@ -242,19 +245,11 @@ func (opts *DeploymentOpts) ValidateAndPromptDeploymentType() error { } func (opts *DeploymentOpts) IsAtlasDeploymentType() bool { - if strings.EqualFold(opts.DeploymentType, AtlasCluster) { - telemetry.AppendOption(telemetry.WithDeploymentType(AtlasCluster)) - return true - } - return false + return strings.EqualFold(opts.DeploymentType, AtlasCluster) } func (opts *DeploymentOpts) IsLocalDeploymentType() bool { - if strings.EqualFold(opts.DeploymentType, LocalCluster) { - telemetry.AppendOption(telemetry.WithDeploymentType(LocalCluster)) - return true - } - return false + return strings.EqualFold(opts.DeploymentType, LocalCluster) } func (opts *DeploymentOpts) NoDeploymentTypeSet() bool { @@ -264,3 +259,7 @@ func (opts *DeploymentOpts) NoDeploymentTypeSet() bool { func (opts *DeploymentOpts) IsAuthEnabled() bool { return opts.DBUsername != "" } + +func (opts *DeploymentOpts) UpdateDeploymentTelemetry() { + opts.DeploymentTelemetry.AppendDeploymentType() +} diff --git a/internal/cli/atlas/deployments/options/deployment_opts_telemetry.go b/internal/cli/atlas/deployments/options/deployment_opts_telemetry.go new file mode 100644 index 0000000000..6dbe93c065 --- /dev/null +++ b/internal/cli/atlas/deployments/options/deployment_opts_telemetry.go @@ -0,0 +1,36 @@ +// Copyright 2023 MongoDB Inc +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package options + +import ( + "github.com/mongodb/mongodb-atlas-cli/atlascli/internal/telemetry" +) + +//go:generate mockgen -destination=../../../../mocks/mock_deployment_opts_telemetry.go -package=mocks github.com/mongodb/mongodb-atlas-cli/atlascli/internal/cli/atlas/deployments/options DeploymentTelemetry +type DeploymentTelemetry interface { + AppendDeploymentType() +} + +func NewDeploymentTypeTelemetry(opts *DeploymentOpts) DeploymentTelemetry { + return opts +} + +func (opts *DeploymentOpts) AppendDeploymentType() { + if opts.IsLocalDeploymentType() { + telemetry.AppendOption(telemetry.WithDeploymentType(LocalCluster)) + } else if opts.IsAtlasDeploymentType() { + telemetry.AppendOption(telemetry.WithDeploymentType(AtlasCluster)) + } +} diff --git a/internal/cli/atlas/deployments/test/fixture/deployment.go b/internal/cli/atlas/deployments/test/fixture/deployment.go index 9a3eb61a76..ff6afc58ce 100644 --- a/internal/cli/atlas/deployments/test/fixture/deployment.go +++ b/internal/cli/atlas/deployments/test/fixture/deployment.go @@ -24,5 +24,6 @@ type MockDeploymentOpts struct { MockCredentialsGetter *mocks.MockCredentialsGetter MockAtlasClusterListStore *mocks.MockClusterLister MockPodman *mocks.MockClient + MockDeploymentTelemetry *mocks.MockDeploymentTelemetry Opts *options.DeploymentOpts } diff --git a/internal/cli/atlas/deployments/test/fixture/deployment_local.go b/internal/cli/atlas/deployments/test/fixture/deployment_local.go index ff450c89bf..82329895f2 100644 --- a/internal/cli/atlas/deployments/test/fixture/deployment_local.go +++ b/internal/cli/atlas/deployments/test/fixture/deployment_local.go @@ -24,15 +24,19 @@ import ( func NewMockLocalDeploymentOpts(ctrl *gomock.Controller, deploymentName string) MockDeploymentOpts { mockPodman := mocks.NewMockClient(ctrl) - return MockDeploymentOpts{ - ctrl: ctrl, - MockPodman: mockPodman, + mockDeploymentTelemetry := mocks.NewMockDeploymentTelemetry(ctrl) + mockOpts := MockDeploymentOpts{ + ctrl: ctrl, + MockPodman: mockPodman, + MockDeploymentTelemetry: mockDeploymentTelemetry, Opts: &options.DeploymentOpts{ - PodmanClient: mockPodman, - DeploymentName: deploymentName, - DeploymentType: "local", + PodmanClient: mockPodman, + DeploymentName: deploymentName, + DeploymentType: "local", + DeploymentTelemetry: mockDeploymentTelemetry, }, } + return mockOpts } func (m *MockDeploymentOpts) LocalMockFlowWithMockContainer(ctx context.Context, mockContainer []*podman.Container) { diff --git a/internal/mocks/mock_deployment_opts_telemetry.go b/internal/mocks/mock_deployment_opts_telemetry.go new file mode 100644 index 0000000000..e4f1779198 --- /dev/null +++ b/internal/mocks/mock_deployment_opts_telemetry.go @@ -0,0 +1,46 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/mongodb/mongodb-atlas-cli/atlascli/internal/cli/atlas/deployments/options (interfaces: DeploymentTelemetry) + +// Package mocks is a generated GoMock package. +package mocks + +import ( + reflect "reflect" + + gomock "github.com/golang/mock/gomock" +) + +// MockDeploymentTelemetry is a mock of DeploymentTelemetry interface. +type MockDeploymentTelemetry struct { + ctrl *gomock.Controller + recorder *MockDeploymentTelemetryMockRecorder +} + +// MockDeploymentTelemetryMockRecorder is the mock recorder for MockDeploymentTelemetry. +type MockDeploymentTelemetryMockRecorder struct { + mock *MockDeploymentTelemetry +} + +// NewMockDeploymentTelemetry creates a new mock instance. +func NewMockDeploymentTelemetry(ctrl *gomock.Controller) *MockDeploymentTelemetry { + mock := &MockDeploymentTelemetry{ctrl: ctrl} + mock.recorder = &MockDeploymentTelemetryMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockDeploymentTelemetry) EXPECT() *MockDeploymentTelemetryMockRecorder { + return m.recorder +} + +// AppendDeploymentType mocks base method. +func (m *MockDeploymentTelemetry) AppendDeploymentType() { + m.ctrl.T.Helper() + m.ctrl.Call(m, "AppendDeploymentType") +} + +// AppendDeploymentType indicates an expected call of AppendDeploymentType. +func (mr *MockDeploymentTelemetryMockRecorder) AppendDeploymentType() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendDeploymentType", reflect.TypeOf((*MockDeploymentTelemetry)(nil).AppendDeploymentType)) +}