From 0fc523c629bdd63fc898c64aadc858d28d4ff3f1 Mon Sep 17 00:00:00 2001 From: pashakostohrys Date: Tue, 25 Jun 2024 23:01:28 +0300 Subject: [PATCH] move unit tests to proto3 Signed-off-by: pashakostohrys --- cmd/argocd/commands/app_test.go | 2 +- server/application/application_test.go | 413 ++++++++++++------------- server/deeplinks/deeplinks_test.go | 20 +- test/e2e/fixture/app/actions.go | 8 +- 4 files changed, 221 insertions(+), 222 deletions(-) diff --git a/cmd/argocd/commands/app_test.go b/cmd/argocd/commands/app_test.go index 73eace8bd250a..a0cb6abc48ccc 100644 --- a/cmd/argocd/commands/app_test.go +++ b/cmd/argocd/commands/app_test.go @@ -93,7 +93,7 @@ func Test_getRefreshType(t *testing.T) { assert.Nil(t, refreshType) } else { assert.NotNil(t, refreshType) - assert.Equal(t, *testCase.expected, *refreshType) + assert.Equal(t, *testCase.expected, refreshType) } }) } diff --git a/server/application/application_test.go b/server/application/application_test.go index 96bfeaf51221c..4b08f24c8b193 100644 --- a/server/application/application_test.go +++ b/server/application/application_test.go @@ -39,7 +39,6 @@ import ( "k8s.io/client-go/rest" kubetesting "k8s.io/client-go/testing" k8scache "k8s.io/client-go/tools/cache" - "k8s.io/utils/ptr" "sigs.k8s.io/yaml" "github.com/argoproj/argo-cd/v2/common" @@ -610,9 +609,9 @@ func (t *TestServerStream) Recv() (*application.ApplicationManifestQueryWithFile t.headerSent = true return &application.ApplicationManifestQueryWithFilesWrapper{Part: &application.ApplicationManifestQueryWithFilesWrapper_Query{ Query: &application.ApplicationManifestQueryWithFiles{ - Name: ptr.To(t.appName), - Project: ptr.To(t.project), - Checksum: ptr.To(""), + Name: t.appName, + Project: t.project, + Checksum: "", }, }}, nil } @@ -798,58 +797,58 @@ func TestNoAppEnumeration(t *testing.T) { t.Run("Get", func(t *testing.T) { // nolint:staticcheck - _, err := appServer.Get(adminCtx, &application.ApplicationQuery{Name: ptr.To("test")}) + _, err := appServer.Get(adminCtx, &application.ApplicationQuery{Name: "test"}) require.NoError(t, err) // nolint:staticcheck - _, err = appServer.Get(noRoleCtx, &application.ApplicationQuery{Name: ptr.To("test")}) + _, err = appServer.Get(noRoleCtx, &application.ApplicationQuery{Name: "test"}) assert.Equal(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") // nolint:staticcheck - _, err = appServer.Get(adminCtx, &application.ApplicationQuery{Name: ptr.To("doest-not-exist")}) + _, err = appServer.Get(adminCtx, &application.ApplicationQuery{Name: "doest-not-exist"}) assert.Equal(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") // nolint:staticcheck - _, err = appServer.Get(adminCtx, &application.ApplicationQuery{Name: ptr.To("doest-not-exist"), Project: []string{"test"}}) + _, err = appServer.Get(adminCtx, &application.ApplicationQuery{Name: "doest-not-exist", Project: []string{"test"}}) assert.Equal(t, "rpc error: code = NotFound desc = applications.argoproj.io \"doest-not-exist\" not found", err.Error(), "when the request specifies a project, we can return the standard k8s error message") }) t.Run("GetManifests", func(t *testing.T) { - _, err := appServer.GetManifests(adminCtx, &application.ApplicationManifestQuery{Name: ptr.To("test")}) + _, err := appServer.GetManifests(adminCtx, &application.ApplicationManifestQuery{Name: "test"}) require.NoError(t, err) - _, err = appServer.GetManifests(noRoleCtx, &application.ApplicationManifestQuery{Name: ptr.To("test")}) + _, err = appServer.GetManifests(noRoleCtx, &application.ApplicationManifestQuery{Name: "test"}) assert.Equal(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") - _, err = appServer.GetManifests(adminCtx, &application.ApplicationManifestQuery{Name: ptr.To("doest-not-exist")}) + _, err = appServer.GetManifests(adminCtx, &application.ApplicationManifestQuery{Name: "doest-not-exist"}) assert.Equal(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") - _, err = appServer.GetManifests(adminCtx, &application.ApplicationManifestQuery{Name: ptr.To("doest-not-exist"), Project: ptr.To("test")}) + _, err = appServer.GetManifests(adminCtx, &application.ApplicationManifestQuery{Name: "doest-not-exist", Project: "test"}) assert.Equal(t, "rpc error: code = NotFound desc = applications.argoproj.io \"doest-not-exist\" not found", err.Error(), "when the request specifies a project, we can return the standard k8s error message") }) t.Run("ListResourceEvents", func(t *testing.T) { - _, err := appServer.ListResourceEvents(adminCtx, &application.ApplicationResourceEventsQuery{Name: ptr.To("test")}) + _, err := appServer.ListResourceEvents(adminCtx, &application.ApplicationResourceEventsQuery{Name: "test"}) require.NoError(t, err) - _, err = appServer.ListResourceEvents(noRoleCtx, &application.ApplicationResourceEventsQuery{Name: ptr.To("test")}) + _, err = appServer.ListResourceEvents(noRoleCtx, &application.ApplicationResourceEventsQuery{Name: "test"}) assert.Equal(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") - _, err = appServer.ListResourceEvents(adminCtx, &application.ApplicationResourceEventsQuery{Name: ptr.To("doest-not-exist")}) + _, err = appServer.ListResourceEvents(adminCtx, &application.ApplicationResourceEventsQuery{Name: "doest-not-exist"}) assert.Equal(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") - _, err = appServer.ListResourceEvents(adminCtx, &application.ApplicationResourceEventsQuery{Name: ptr.To("doest-not-exist"), Project: ptr.To("test")}) + _, err = appServer.ListResourceEvents(adminCtx, &application.ApplicationResourceEventsQuery{Name: "doest-not-exist", Project: "test"}) assert.Equal(t, "rpc error: code = NotFound desc = applications.argoproj.io \"doest-not-exist\" not found", err.Error(), "when the request specifies a project, we can return the standard k8s error message") }) t.Run("UpdateSpec", func(t *testing.T) { - _, err := appServer.UpdateSpec(adminCtx, &application.ApplicationUpdateSpecRequest{Name: ptr.To("test"), Spec: &appsv1.ApplicationSpec{ + _, err := appServer.UpdateSpec(adminCtx, &application.ApplicationUpdateSpecRequest{Name: "test", Spec: &appsv1.ApplicationSpec{ Destination: appsv1.ApplicationDestination{Namespace: "default", Server: "https://cluster-api.example.com"}, Source: &appsv1.ApplicationSource{RepoURL: "https://some-fake-source", Path: "."}, }}) require.NoError(t, err) - _, err = appServer.UpdateSpec(noRoleCtx, &application.ApplicationUpdateSpecRequest{Name: ptr.To("test"), Spec: &appsv1.ApplicationSpec{ + _, err = appServer.UpdateSpec(noRoleCtx, &application.ApplicationUpdateSpecRequest{Name: "test", Spec: &appsv1.ApplicationSpec{ Destination: appsv1.ApplicationDestination{Namespace: "default", Server: "https://cluster-api.example.com"}, Source: &appsv1.ApplicationSource{RepoURL: "https://some-fake-source", Path: "."}, }}) assert.Equal(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") - _, err = appServer.UpdateSpec(adminCtx, &application.ApplicationUpdateSpecRequest{Name: ptr.To("doest-not-exist"), Spec: &appsv1.ApplicationSpec{ + _, err = appServer.UpdateSpec(adminCtx, &application.ApplicationUpdateSpecRequest{Name: "doest-not-exist", Spec: &appsv1.ApplicationSpec{ Destination: appsv1.ApplicationDestination{Namespace: "default", Server: "https://cluster-api.example.com"}, Source: &appsv1.ApplicationSource{RepoURL: "https://some-fake-source", Path: "."}, }}) assert.Equal(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") - _, err = appServer.UpdateSpec(adminCtx, &application.ApplicationUpdateSpecRequest{Name: ptr.To("doest-not-exist"), Project: ptr.To("test"), Spec: &appsv1.ApplicationSpec{ + _, err = appServer.UpdateSpec(adminCtx, &application.ApplicationUpdateSpecRequest{Name: "doest-not-exist", Project: "test", Spec: &appsv1.ApplicationSpec{ Destination: appsv1.ApplicationDestination{Namespace: "default", Server: "https://cluster-api.example.com"}, Source: &appsv1.ApplicationSource{RepoURL: "https://some-fake-source", Path: "."}, }}) @@ -857,105 +856,105 @@ func TestNoAppEnumeration(t *testing.T) { }) t.Run("Patch", func(t *testing.T) { - _, err := appServer.Patch(adminCtx, &application.ApplicationPatchRequest{Name: ptr.To("test"), Patch: ptr.To(`[{"op": "replace", "path": "/spec/source/path", "value": "foo"}]`)}) + _, err := appServer.Patch(adminCtx, &application.ApplicationPatchRequest{Name: "test", Patch: `[{"op": "replace", "path": "/spec/source/path", "value": "foo"}]`}) require.NoError(t, err) - _, err = appServer.Patch(noRoleCtx, &application.ApplicationPatchRequest{Name: ptr.To("test"), Patch: ptr.To(`[{"op": "replace", "path": "/spec/source/path", "value": "foo"}]`)}) + _, err = appServer.Patch(noRoleCtx, &application.ApplicationPatchRequest{Name: "test", Patch: `[{"op": "replace", "path": "/spec/source/path", "value": "foo"}]`}) assert.Equal(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") - _, err = appServer.Patch(adminCtx, &application.ApplicationPatchRequest{Name: ptr.To("doest-not-exist")}) + _, err = appServer.Patch(adminCtx, &application.ApplicationPatchRequest{Name: "doest-not-exist"}) assert.Equal(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") - _, err = appServer.Patch(adminCtx, &application.ApplicationPatchRequest{Name: ptr.To("doest-not-exist"), Project: ptr.To("test")}) + _, err = appServer.Patch(adminCtx, &application.ApplicationPatchRequest{Name: "doest-not-exist", Project: "test"}) assert.Equal(t, "rpc error: code = NotFound desc = applications.argoproj.io \"doest-not-exist\" not found", err.Error(), "when the request specifies a project, we can return the standard k8s error message") }) t.Run("GetResource", func(t *testing.T) { - _, err := appServer.GetResource(adminCtx, &application.ApplicationResourceRequest{Name: ptr.To("test"), ResourceName: ptr.To("test"), Group: ptr.To("apps"), Kind: ptr.To("Deployment"), Namespace: ptr.To("test")}) + _, err := appServer.GetResource(adminCtx, &application.ApplicationResourceRequest{Name: "test", ResourceName: "test", Group: "apps", Kind: "Deployment", Namespace: "test"}) require.NoError(t, err) - _, err = appServer.GetResource(noRoleCtx, &application.ApplicationResourceRequest{Name: ptr.To("test"), ResourceName: ptr.To("test"), Group: ptr.To("apps"), Kind: ptr.To("Deployment"), Namespace: ptr.To("test")}) + _, err = appServer.GetResource(noRoleCtx, &application.ApplicationResourceRequest{Name: "test", ResourceName: "test", Group: "apps", Kind: "Deployment", Namespace: "test"}) assert.Equal(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") - _, err = appServer.GetResource(adminCtx, &application.ApplicationResourceRequest{Name: ptr.To("doest-not-exist"), ResourceName: ptr.To("test"), Group: ptr.To("apps"), Kind: ptr.To("Deployment"), Namespace: ptr.To("test")}) + _, err = appServer.GetResource(adminCtx, &application.ApplicationResourceRequest{Name: "doest-not-exist", ResourceName: "test", Group: "apps", Kind: "Deployment", Namespace: "test"}) assert.Equal(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") - _, err = appServer.GetResource(adminCtx, &application.ApplicationResourceRequest{Name: ptr.To("doest-not-exist"), Project: ptr.To("test"), ResourceName: ptr.To("test"), Group: ptr.To("apps"), Kind: ptr.To("Deployment"), Namespace: ptr.To("test")}) + _, err = appServer.GetResource(adminCtx, &application.ApplicationResourceRequest{Name: "doest-not-exist", Project: "test", ResourceName: "test", Group: "apps", Kind: "Deployment", Namespace: "test"}) assert.Equal(t, "rpc error: code = NotFound desc = applications.argoproj.io \"doest-not-exist\" not found", err.Error(), "when the request specifies a project, we can return the standard k8s error message") }) t.Run("PatchResource", func(t *testing.T) { - _, err := appServer.PatchResource(adminCtx, &application.ApplicationResourcePatchRequest{Name: ptr.To("test"), ResourceName: ptr.To("test"), Group: ptr.To("apps"), Kind: ptr.To("Deployment"), Namespace: ptr.To("test"), Patch: ptr.To(`[{"op": "replace", "path": "/spec/replicas", "value": 3}]`)}) + _, err := appServer.PatchResource(adminCtx, &application.ApplicationResourcePatchRequest{Name: "test", ResourceName: "test", Group: "apps", Kind: "Deployment", Namespace: "test", Patch: `[{"op": "replace", "path": "/spec/replicas", "value": 3}]`}) // This will always throw an error, because the kubectl mock for PatchResource is hard-coded to return nil. // The best we can do is to confirm we get past the permission check. assert.NotEqual(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") - _, err = appServer.PatchResource(noRoleCtx, &application.ApplicationResourcePatchRequest{Name: ptr.To("test"), ResourceName: ptr.To("test"), Group: ptr.To("apps"), Kind: ptr.To("Deployment"), Namespace: ptr.To("test"), Patch: ptr.To(`[{"op": "replace", "path": "/spec/replicas", "value": 3}]`)}) + _, err = appServer.PatchResource(noRoleCtx, &application.ApplicationResourcePatchRequest{Name: "test", ResourceName: "test", Group: "apps", Kind: "Deployment", Namespace: "test", Patch: `[{"op": "replace", "path": "/spec/replicas", "value": 3}]`}) assert.Equal(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") - _, err = appServer.PatchResource(adminCtx, &application.ApplicationResourcePatchRequest{Name: ptr.To("doest-not-exist"), ResourceName: ptr.To("test"), Group: ptr.To("apps"), Kind: ptr.To("Deployment"), Namespace: ptr.To("test"), Patch: ptr.To(`[{"op": "replace", "path": "/spec/replicas", "value": 3}]`)}) + _, err = appServer.PatchResource(adminCtx, &application.ApplicationResourcePatchRequest{Name: "doest-not-exist", ResourceName: "test", Group: "apps", Kind: "Deployment", Namespace: "test", Patch: `[{"op": "replace", "path": "/spec/replicas", "value": 3}]`}) assert.Equal(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") - _, err = appServer.PatchResource(adminCtx, &application.ApplicationResourcePatchRequest{Name: ptr.To("doest-not-exist"), Project: ptr.To("test"), ResourceName: ptr.To("test"), Group: ptr.To("apps"), Kind: ptr.To("Deployment"), Namespace: ptr.To("test"), Patch: ptr.To(`[{"op": "replace", "path": "/spec/replicas", "value": 3}]`)}) + _, err = appServer.PatchResource(adminCtx, &application.ApplicationResourcePatchRequest{Name: "doest-not-exist", Project: "test", ResourceName: "test", Group: "apps", Kind: "Deployment", Namespace: "test", Patch: `[{"op": "replace", "path": "/spec/replicas", "value": 3}]`}) assert.Equal(t, "rpc error: code = NotFound desc = applications.argoproj.io \"doest-not-exist\" not found", err.Error(), "when the request specifies a project, we can return the standard k8s error message") }) t.Run("DeleteResource", func(t *testing.T) { - _, err := appServer.DeleteResource(adminCtx, &application.ApplicationResourceDeleteRequest{Name: ptr.To("test"), ResourceName: ptr.To("test"), Group: ptr.To("apps"), Kind: ptr.To("Deployment"), Namespace: ptr.To("test")}) + _, err := appServer.DeleteResource(adminCtx, &application.ApplicationResourceDeleteRequest{Name: "test", ResourceName: "test", Group: "apps", Kind: "Deployment", Namespace: "test"}) require.NoError(t, err) - _, err = appServer.DeleteResource(noRoleCtx, &application.ApplicationResourceDeleteRequest{Name: ptr.To("test"), ResourceName: ptr.To("test"), Group: ptr.To("apps"), Kind: ptr.To("Deployment"), Namespace: ptr.To("test")}) + _, err = appServer.DeleteResource(noRoleCtx, &application.ApplicationResourceDeleteRequest{Name: "test", ResourceName: "test", Group: "apps", Kind: "Deployment", Namespace: "test"}) assert.Equal(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") - _, err = appServer.DeleteResource(adminCtx, &application.ApplicationResourceDeleteRequest{Name: ptr.To("doest-not-exist"), ResourceName: ptr.To("test"), Group: ptr.To("apps"), Kind: ptr.To("Deployment"), Namespace: ptr.To("test")}) + _, err = appServer.DeleteResource(adminCtx, &application.ApplicationResourceDeleteRequest{Name: "doest-not-exist", ResourceName: "test", Group: "apps", Kind: "Deployment", Namespace: "test"}) assert.Equal(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") - _, err = appServer.DeleteResource(adminCtx, &application.ApplicationResourceDeleteRequest{Name: ptr.To("doest-not-exist"), Project: ptr.To("test"), ResourceName: ptr.To("test"), Group: ptr.To("apps"), Kind: ptr.To("Deployment"), Namespace: ptr.To("test")}) + _, err = appServer.DeleteResource(adminCtx, &application.ApplicationResourceDeleteRequest{Name: "doest-not-exist", Project: "test", ResourceName: "test", Group: "apps", Kind: "Deployment", Namespace: "test"}) assert.Equal(t, "rpc error: code = NotFound desc = applications.argoproj.io \"doest-not-exist\" not found", err.Error(), "when the request specifies a project, we can return the standard k8s error message") }) t.Run("ResourceTree", func(t *testing.T) { - _, err := appServer.ResourceTree(adminCtx, &application.ResourcesQuery{ApplicationName: ptr.To("test")}) + _, err := appServer.ResourceTree(adminCtx, &application.ResourcesQuery{ApplicationName: "test"}) require.NoError(t, err) - _, err = appServer.ResourceTree(noRoleCtx, &application.ResourcesQuery{ApplicationName: ptr.To("test")}) + _, err = appServer.ResourceTree(noRoleCtx, &application.ResourcesQuery{ApplicationName: "test"}) assert.Equal(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") - _, err = appServer.ResourceTree(adminCtx, &application.ResourcesQuery{ApplicationName: ptr.To("doest-not-exist")}) + _, err = appServer.ResourceTree(adminCtx, &application.ResourcesQuery{ApplicationName: "doest-not-exist"}) assert.Equal(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") - _, err = appServer.ResourceTree(adminCtx, &application.ResourcesQuery{ApplicationName: ptr.To("doest-not-exist"), Project: ptr.To("test")}) + _, err = appServer.ResourceTree(adminCtx, &application.ResourcesQuery{ApplicationName: "doest-not-exist", Project: "test"}) assert.Equal(t, "rpc error: code = NotFound desc = applications.argoproj.io \"doest-not-exist\" not found", err.Error(), "when the request specifies a project, we can return the standard k8s error message") }) t.Run("RevisionMetadata", func(t *testing.T) { - _, err := appServer.RevisionMetadata(adminCtx, &application.RevisionMetadataQuery{Name: ptr.To("test")}) + _, err := appServer.RevisionMetadata(adminCtx, &application.RevisionMetadataQuery{Name: "test"}) require.NoError(t, err) - _, err = appServer.RevisionMetadata(adminCtx, &application.RevisionMetadataQuery{Name: ptr.To("test-multi"), SourceIndex: ptr.To(int32(0)), VersionId: ptr.To(int32(1))}) + _, err = appServer.RevisionMetadata(adminCtx, &application.RevisionMetadataQuery{Name: "test-multi", SourceIndex: int32(0), VersionId: int32(1)}) require.NoError(t, err) - _, err = appServer.RevisionMetadata(noRoleCtx, &application.RevisionMetadataQuery{Name: ptr.To("test")}) + _, err = appServer.RevisionMetadata(noRoleCtx, &application.RevisionMetadataQuery{Name: "test"}) assert.Equal(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") - _, err = appServer.RevisionMetadata(adminCtx, &application.RevisionMetadataQuery{Name: ptr.To("doest-not-exist")}) + _, err = appServer.RevisionMetadata(adminCtx, &application.RevisionMetadataQuery{Name: "doest-not-exist"}) assert.Equal(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") - _, err = appServer.RevisionMetadata(adminCtx, &application.RevisionMetadataQuery{Name: ptr.To("doest-not-exist"), Project: ptr.To("test")}) + _, err = appServer.RevisionMetadata(adminCtx, &application.RevisionMetadataQuery{Name: "doest-not-exist", Project: "test"}) assert.Equal(t, "rpc error: code = NotFound desc = applications.argoproj.io \"doest-not-exist\" not found", err.Error(), "when the request specifies a project, we can return the standard k8s error message") }) t.Run("RevisionChartDetails", func(t *testing.T) { - _, err := appServer.RevisionChartDetails(adminCtx, &application.RevisionMetadataQuery{Name: ptr.To("test-helm")}) + _, err := appServer.RevisionChartDetails(adminCtx, &application.RevisionMetadataQuery{Name: "test-helm"}) require.NoError(t, err) - _, err = appServer.RevisionChartDetails(noRoleCtx, &application.RevisionMetadataQuery{Name: ptr.To("test-helm")}) + _, err = appServer.RevisionChartDetails(noRoleCtx, &application.RevisionMetadataQuery{Name: "test-helm"}) assert.Equal(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") - _, err = appServer.RevisionChartDetails(adminCtx, &application.RevisionMetadataQuery{Name: ptr.To("doest-not-exist")}) + _, err = appServer.RevisionChartDetails(adminCtx, &application.RevisionMetadataQuery{Name: "doest-not-exist"}) assert.Equal(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") - _, err = appServer.RevisionChartDetails(adminCtx, &application.RevisionMetadataQuery{Name: ptr.To("doest-not-exist"), Project: ptr.To("test")}) + _, err = appServer.RevisionChartDetails(adminCtx, &application.RevisionMetadataQuery{Name: "doest-not-exist", Project: "test"}) assert.Equal(t, "rpc error: code = NotFound desc = applications.argoproj.io \"doest-not-exist\" not found", err.Error(), "when the request specifies a project, we can return the standard k8s error message") }) t.Run("ManagedResources", func(t *testing.T) { - _, err := appServer.ManagedResources(adminCtx, &application.ResourcesQuery{ApplicationName: ptr.To("test")}) + _, err := appServer.ManagedResources(adminCtx, &application.ResourcesQuery{ApplicationName: "test"}) require.NoError(t, err) - _, err = appServer.ManagedResources(noRoleCtx, &application.ResourcesQuery{ApplicationName: ptr.To("test")}) + _, err = appServer.ManagedResources(noRoleCtx, &application.ResourcesQuery{ApplicationName: "test"}) assert.Equal(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") - _, err = appServer.ManagedResources(adminCtx, &application.ResourcesQuery{ApplicationName: ptr.To("doest-not-exist")}) + _, err = appServer.ManagedResources(adminCtx, &application.ResourcesQuery{ApplicationName: "doest-not-exist"}) assert.Equal(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") - _, err = appServer.ManagedResources(adminCtx, &application.ResourcesQuery{ApplicationName: ptr.To("doest-not-exist"), Project: ptr.To("test")}) + _, err = appServer.ManagedResources(adminCtx, &application.ResourcesQuery{ApplicationName: "doest-not-exist", Project: "test"}) assert.Equal(t, "rpc error: code = NotFound desc = applications.argoproj.io \"doest-not-exist\" not found", err.Error(), "when the request specifies a project, we can return the standard k8s error message") }) t.Run("Sync", func(t *testing.T) { - _, err := appServer.Sync(adminCtx, &application.ApplicationSyncRequest{Name: ptr.To("test")}) + _, err := appServer.Sync(adminCtx, &application.ApplicationSyncRequest{Name: "test"}) require.NoError(t, err) - _, err = appServer.Sync(noRoleCtx, &application.ApplicationSyncRequest{Name: ptr.To("test")}) + _, err = appServer.Sync(noRoleCtx, &application.ApplicationSyncRequest{Name: "test"}) assert.Equal(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") - _, err = appServer.Sync(adminCtx, &application.ApplicationSyncRequest{Name: ptr.To("doest-not-exist")}) + _, err = appServer.Sync(adminCtx, &application.ApplicationSyncRequest{Name: "doest-not-exist"}) assert.Equal(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") - _, err = appServer.Sync(adminCtx, &application.ApplicationSyncRequest{Name: ptr.To("doest-not-exist"), Project: ptr.To("test")}) + _, err = appServer.Sync(adminCtx, &application.ApplicationSyncRequest{Name: "doest-not-exist", Project: "test"}) assert.Equal(t, "rpc error: code = NotFound desc = applications.argoproj.io \"doest-not-exist\" not found", err.Error(), "when the request specifies a project, we can return the standard k8s error message") }) @@ -963,64 +962,64 @@ func TestNoAppEnumeration(t *testing.T) { // The sync operation is already started from the previous test. We just need to set the field that the // controller would set if this were an actual Argo CD environment. setSyncRunningOperationState(t, appServer) - _, err := appServer.TerminateOperation(adminCtx, &application.OperationTerminateRequest{Name: ptr.To("test")}) + _, err := appServer.TerminateOperation(adminCtx, &application.OperationTerminateRequest{Name: "test"}) require.NoError(t, err) - _, err = appServer.TerminateOperation(noRoleCtx, &application.OperationTerminateRequest{Name: ptr.To("test")}) + _, err = appServer.TerminateOperation(noRoleCtx, &application.OperationTerminateRequest{Name: "test"}) assert.Equal(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") - _, err = appServer.TerminateOperation(adminCtx, &application.OperationTerminateRequest{Name: ptr.To("doest-not-exist")}) + _, err = appServer.TerminateOperation(adminCtx, &application.OperationTerminateRequest{Name: "doest-not-exist"}) assert.Equal(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") - _, err = appServer.TerminateOperation(adminCtx, &application.OperationTerminateRequest{Name: ptr.To("doest-not-exist"), Project: ptr.To("test")}) + _, err = appServer.TerminateOperation(adminCtx, &application.OperationTerminateRequest{Name: "doest-not-exist", Project: "test"}) assert.Equal(t, "rpc error: code = NotFound desc = applications.argoproj.io \"doest-not-exist\" not found", err.Error(), "when the request specifies a project, we can return the standard k8s error message") }) t.Run("Rollback", func(t *testing.T) { unsetSyncRunningOperationState(t, appServer) - _, err := appServer.Rollback(adminCtx, &application.ApplicationRollbackRequest{Name: ptr.To("test")}) + _, err := appServer.Rollback(adminCtx, &application.ApplicationRollbackRequest{Name: "test"}) require.NoError(t, err) - _, err = appServer.Rollback(adminCtx, &application.ApplicationRollbackRequest{Name: ptr.To("test-multi"), Id: ptr.To(int64(1))}) + _, err = appServer.Rollback(adminCtx, &application.ApplicationRollbackRequest{Name: "test-multi", Id: int64(1)}) require.NoError(t, err) - _, err = appServer.Rollback(noRoleCtx, &application.ApplicationRollbackRequest{Name: ptr.To("test")}) + _, err = appServer.Rollback(noRoleCtx, &application.ApplicationRollbackRequest{Name: "test"}) assert.Equal(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") - _, err = appServer.Rollback(adminCtx, &application.ApplicationRollbackRequest{Name: ptr.To("doest-not-exist")}) + _, err = appServer.Rollback(adminCtx, &application.ApplicationRollbackRequest{Name: "doest-not-exist"}) assert.Equal(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") - _, err = appServer.Rollback(adminCtx, &application.ApplicationRollbackRequest{Name: ptr.To("doest-not-exist"), Project: ptr.To("test")}) + _, err = appServer.Rollback(adminCtx, &application.ApplicationRollbackRequest{Name: "doest-not-exist", Project: "test"}) assert.Equal(t, "rpc error: code = NotFound desc = applications.argoproj.io \"doest-not-exist\" not found", err.Error(), "when the request specifies a project, we can return the standard k8s error message") }) t.Run("ListResourceActions", func(t *testing.T) { - _, err := appServer.ListResourceActions(adminCtx, &application.ApplicationResourceRequest{Name: ptr.To("test"), ResourceName: ptr.To("test"), Group: ptr.To("apps"), Kind: ptr.To("Deployment"), Namespace: ptr.To("test")}) + _, err := appServer.ListResourceActions(adminCtx, &application.ApplicationResourceRequest{Name: "test", ResourceName: "test", Group: "apps", Kind: "Deployment", Namespace: "test"}) require.NoError(t, err) - _, err = appServer.ListResourceActions(noRoleCtx, &application.ApplicationResourceRequest{Name: ptr.To("test")}) + _, err = appServer.ListResourceActions(noRoleCtx, &application.ApplicationResourceRequest{Name: "test"}) assert.Equal(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") - _, err = appServer.ListResourceActions(noRoleCtx, &application.ApplicationResourceRequest{Group: ptr.To("argoproj.io"), Kind: ptr.To("Application"), Name: ptr.To("test")}) + _, err = appServer.ListResourceActions(noRoleCtx, &application.ApplicationResourceRequest{Group: "argoproj.io", Kind: "Application", Name: "test"}) assert.Equal(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") - _, err = appServer.ListResourceActions(adminCtx, &application.ApplicationResourceRequest{Name: ptr.To("doest-not-exist")}) + _, err = appServer.ListResourceActions(adminCtx, &application.ApplicationResourceRequest{Name: "doest-not-exist"}) assert.Equal(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") - _, err = appServer.ListResourceActions(adminCtx, &application.ApplicationResourceRequest{Name: ptr.To("doest-not-exist"), Project: ptr.To("test")}) + _, err = appServer.ListResourceActions(adminCtx, &application.ApplicationResourceRequest{Name: "doest-not-exist", Project: "test"}) assert.Equal(t, "rpc error: code = NotFound desc = applications.argoproj.io \"doest-not-exist\" not found", err.Error(), "when the request specifies a project, we can return the standard k8s error message") }) t.Run("RunResourceAction", func(t *testing.T) { - _, err := appServer.RunResourceAction(adminCtx, &application.ResourceActionRunRequest{Name: ptr.To("test"), ResourceName: ptr.To("test"), Group: ptr.To("apps"), Kind: ptr.To("Deployment"), Namespace: ptr.To("test"), Action: ptr.To("restart")}) + _, err := appServer.RunResourceAction(adminCtx, &application.ResourceActionRunRequest{Name: "test", ResourceName: "test", Group: "apps", Kind: "Deployment", Namespace: "test", Action: "restart"}) require.NoError(t, err) - _, err = appServer.RunResourceAction(noRoleCtx, &application.ResourceActionRunRequest{Name: ptr.To("test")}) + _, err = appServer.RunResourceAction(noRoleCtx, &application.ResourceActionRunRequest{Name: "test"}) assert.Equal(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") - _, err = appServer.RunResourceAction(noRoleCtx, &application.ResourceActionRunRequest{Group: ptr.To("argoproj.io"), Kind: ptr.To("Application"), Name: ptr.To("test")}) + _, err = appServer.RunResourceAction(noRoleCtx, &application.ResourceActionRunRequest{Group: "argoproj.io", Kind: "Application", Name: "test"}) assert.Equal(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") - _, err = appServer.RunResourceAction(adminCtx, &application.ResourceActionRunRequest{Name: ptr.To("doest-not-exist")}) + _, err = appServer.RunResourceAction(adminCtx, &application.ResourceActionRunRequest{Name: "doest-not-exist"}) assert.Equal(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") - _, err = appServer.RunResourceAction(adminCtx, &application.ResourceActionRunRequest{Name: ptr.To("doest-not-exist"), Project: ptr.To("test")}) + _, err = appServer.RunResourceAction(adminCtx, &application.ResourceActionRunRequest{Name: "doest-not-exist", Project: "test"}) assert.Equal(t, "rpc error: code = NotFound desc = applications.argoproj.io \"doest-not-exist\" not found", err.Error(), "when the request specifies a project, we can return the standard k8s error message") }) t.Run("GetApplicationSyncWindows", func(t *testing.T) { - _, err := appServer.GetApplicationSyncWindows(adminCtx, &application.ApplicationSyncWindowsQuery{Name: ptr.To("test")}) + _, err := appServer.GetApplicationSyncWindows(adminCtx, &application.ApplicationSyncWindowsQuery{Name: "test"}) require.NoError(t, err) - _, err = appServer.GetApplicationSyncWindows(noRoleCtx, &application.ApplicationSyncWindowsQuery{Name: ptr.To("test")}) + _, err = appServer.GetApplicationSyncWindows(noRoleCtx, &application.ApplicationSyncWindowsQuery{Name: "test"}) assert.Equal(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") - _, err = appServer.GetApplicationSyncWindows(adminCtx, &application.ApplicationSyncWindowsQuery{Name: ptr.To("doest-not-exist")}) + _, err = appServer.GetApplicationSyncWindows(adminCtx, &application.ApplicationSyncWindowsQuery{Name: "doest-not-exist"}) assert.Equal(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") - _, err = appServer.GetApplicationSyncWindows(adminCtx, &application.ApplicationSyncWindowsQuery{Name: ptr.To("doest-not-exist"), Project: ptr.To("test")}) + _, err = appServer.GetApplicationSyncWindows(adminCtx, &application.ApplicationSyncWindowsQuery{Name: "doest-not-exist", Project: "test"}) assert.Equal(t, "rpc error: code = NotFound desc = applications.argoproj.io \"doest-not-exist\" not found", err.Error(), "when the request specifies a project, we can return the standard k8s error message") }) @@ -1036,58 +1035,58 @@ func TestNoAppEnumeration(t *testing.T) { }) t.Run("WatchResourceTree", func(t *testing.T) { - err := appServer.WatchResourceTree(&application.ResourcesQuery{ApplicationName: ptr.To("test")}, &TestResourceTreeServer{ctx: adminCtx}) + err := appServer.WatchResourceTree(&application.ResourcesQuery{ApplicationName: "test"}, &TestResourceTreeServer{ctx: adminCtx}) require.NoError(t, err) - err = appServer.WatchResourceTree(&application.ResourcesQuery{ApplicationName: ptr.To("test")}, &TestResourceTreeServer{ctx: noRoleCtx}) + err = appServer.WatchResourceTree(&application.ResourcesQuery{ApplicationName: "test"}, &TestResourceTreeServer{ctx: noRoleCtx}) assert.Equal(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") - err = appServer.WatchResourceTree(&application.ResourcesQuery{ApplicationName: ptr.To("does-not-exist")}, &TestResourceTreeServer{ctx: adminCtx}) + err = appServer.WatchResourceTree(&application.ResourcesQuery{ApplicationName: "does-not-exist"}, &TestResourceTreeServer{ctx: adminCtx}) assert.Equal(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") - err = appServer.WatchResourceTree(&application.ResourcesQuery{ApplicationName: ptr.To("does-not-exist"), Project: ptr.To("test")}, &TestResourceTreeServer{ctx: adminCtx}) + err = appServer.WatchResourceTree(&application.ResourcesQuery{ApplicationName: "does-not-exist", Project: "test"}, &TestResourceTreeServer{ctx: adminCtx}) assert.Equal(t, "rpc error: code = NotFound desc = applications.argoproj.io \"does-not-exist\" not found", err.Error(), "when the request specifies a project, we can return the standard k8s error message") }) t.Run("PodLogs", func(t *testing.T) { - err := appServer.PodLogs(&application.ApplicationPodLogsQuery{Name: ptr.To("test")}, &TestPodLogsServer{ctx: adminCtx}) + err := appServer.PodLogs(&application.ApplicationPodLogsQuery{Name: "test"}, &TestPodLogsServer{ctx: adminCtx}) require.NoError(t, err) - err = appServer.PodLogs(&application.ApplicationPodLogsQuery{Name: ptr.To("test")}, &TestPodLogsServer{ctx: noRoleCtx}) + err = appServer.PodLogs(&application.ApplicationPodLogsQuery{Name: "test"}, &TestPodLogsServer{ctx: noRoleCtx}) assert.Equal(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") - err = appServer.PodLogs(&application.ApplicationPodLogsQuery{Name: ptr.To("does-not-exist")}, &TestPodLogsServer{ctx: adminCtx}) + err = appServer.PodLogs(&application.ApplicationPodLogsQuery{Name: "does-not-exist"}, &TestPodLogsServer{ctx: adminCtx}) assert.Equal(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") - err = appServer.PodLogs(&application.ApplicationPodLogsQuery{Name: ptr.To("does-not-exist"), Project: ptr.To("test")}, &TestPodLogsServer{ctx: adminCtx}) + err = appServer.PodLogs(&application.ApplicationPodLogsQuery{Name: "does-not-exist", Project: "test"}, &TestPodLogsServer{ctx: adminCtx}) assert.Equal(t, "rpc error: code = NotFound desc = applications.argoproj.io \"does-not-exist\" not found", err.Error(), "when the request specifies a project, we can return the standard k8s error message") }) t.Run("ListLinks", func(t *testing.T) { - _, err := appServer.ListLinks(adminCtx, &application.ListAppLinksRequest{Name: ptr.To("test")}) + _, err := appServer.ListLinks(adminCtx, &application.ListAppLinksRequest{Name: "test"}) require.NoError(t, err) - _, err = appServer.ListLinks(noRoleCtx, &application.ListAppLinksRequest{Name: ptr.To("test")}) + _, err = appServer.ListLinks(noRoleCtx, &application.ListAppLinksRequest{Name: "test"}) assert.Equal(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") - _, err = appServer.ListLinks(adminCtx, &application.ListAppLinksRequest{Name: ptr.To("does-not-exist")}) + _, err = appServer.ListLinks(adminCtx, &application.ListAppLinksRequest{Name: "does-not-exist"}) assert.Equal(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") - _, err = appServer.ListLinks(adminCtx, &application.ListAppLinksRequest{Name: ptr.To("does-not-exist"), Project: ptr.To("test")}) + _, err = appServer.ListLinks(adminCtx, &application.ListAppLinksRequest{Name: "does-not-exist", Project: "test"}) assert.Equal(t, "rpc error: code = NotFound desc = applications.argoproj.io \"does-not-exist\" not found", err.Error(), "when the request specifies a project, we can return the standard k8s error message") }) t.Run("ListResourceLinks", func(t *testing.T) { - _, err := appServer.ListResourceLinks(adminCtx, &application.ApplicationResourceRequest{Name: ptr.To("test"), ResourceName: ptr.To("test"), Group: ptr.To("apps"), Kind: ptr.To("Deployment"), Namespace: ptr.To("test")}) + _, err := appServer.ListResourceLinks(adminCtx, &application.ApplicationResourceRequest{Name: "test", ResourceName: "test", Group: "apps", Kind: "Deployment", Namespace: "test"}) require.NoError(t, err) - _, err = appServer.ListResourceLinks(noRoleCtx, &application.ApplicationResourceRequest{Name: ptr.To("test"), ResourceName: ptr.To("test"), Group: ptr.To("apps"), Kind: ptr.To("Deployment"), Namespace: ptr.To("test")}) + _, err = appServer.ListResourceLinks(noRoleCtx, &application.ApplicationResourceRequest{Name: "test", ResourceName: "test", Group: "apps", Kind: "Deployment", Namespace: "test"}) assert.Equal(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") - _, err = appServer.ListResourceLinks(adminCtx, &application.ApplicationResourceRequest{Name: ptr.To("does-not-exist"), ResourceName: ptr.To("test"), Group: ptr.To("apps"), Kind: ptr.To("Deployment"), Namespace: ptr.To("test")}) + _, err = appServer.ListResourceLinks(adminCtx, &application.ApplicationResourceRequest{Name: "does-not-exist", ResourceName: "test", Group: "apps", Kind: "Deployment", Namespace: "test"}) assert.Equal(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") - _, err = appServer.ListResourceLinks(adminCtx, &application.ApplicationResourceRequest{Name: ptr.To("does-not-exist"), ResourceName: ptr.To("test"), Group: ptr.To("apps"), Kind: ptr.To("Deployment"), Namespace: ptr.To("test"), Project: ptr.To("test")}) + _, err = appServer.ListResourceLinks(adminCtx, &application.ApplicationResourceRequest{Name: "does-not-exist", ResourceName: "test", Group: "apps", Kind: "Deployment", Namespace: "test", Project: "test"}) assert.Equal(t, "rpc error: code = NotFound desc = applications.argoproj.io \"does-not-exist\" not found", err.Error(), "when the request specifies a project, we can return the standard k8s error message") }) // Do this last so other stuff doesn't fail. t.Run("Delete", func(t *testing.T) { - _, err := appServer.Delete(adminCtx, &application.ApplicationDeleteRequest{Name: ptr.To("test")}) + _, err := appServer.Delete(adminCtx, &application.ApplicationDeleteRequest{Name: "test"}) require.NoError(t, err) - _, err = appServer.Delete(noRoleCtx, &application.ApplicationDeleteRequest{Name: ptr.To("test")}) + _, err = appServer.Delete(noRoleCtx, &application.ApplicationDeleteRequest{Name: "test"}) assert.Equal(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") - _, err = appServer.Delete(adminCtx, &application.ApplicationDeleteRequest{Name: ptr.To("doest-not-exist")}) + _, err = appServer.Delete(adminCtx, &application.ApplicationDeleteRequest{Name: "doest-not-exist"}) assert.Equal(t, permissionDeniedErr.Error(), err.Error(), "error message must be _only_ the permission error, to avoid leaking information about app existence") - _, err = appServer.Delete(adminCtx, &application.ApplicationDeleteRequest{Name: ptr.To("doest-not-exist"), Project: ptr.To("test")}) + _, err = appServer.Delete(adminCtx, &application.ApplicationDeleteRequest{Name: "doest-not-exist", Project: "test"}) assert.Equal(t, "rpc error: code = NotFound desc = applications.argoproj.io \"doest-not-exist\" not found", err.Error(), "when the request specifies a project, we can return the standard k8s error message") }) } @@ -1131,7 +1130,7 @@ func TestListAppsInNamespaceWithLabels(t *testing.T) { appServer.ns = "test-namespace" appQuery := application.ApplicationQuery{} namespace := "test-namespace" - appQuery.AppNamespace = &namespace + appQuery.AppNamespace = namespace testListAppsWithLabels(t, appQuery, appServer) } @@ -1195,7 +1194,7 @@ func testListAppsWithLabels(t *testing.T, appQuery application.ApplicationQuery, // test valid scenarios for _, validTest := range validTests { t.Run(validTest.testName, func(t *testing.T) { - appQuery.Selector = &validTest.label + appQuery.Selector = validTest.label res, err := appServer.List(context.Background(), &appQuery) require.NoError(t, err) apps := []string{} @@ -1225,7 +1224,7 @@ func testListAppsWithLabels(t *testing.T, appQuery application.ApplicationQuery, // test invalid scenarios for _, invalidTest := range invalidTests { t.Run(invalidTest.testName, func(t *testing.T) { - appQuery.Selector = &invalidTest.label + appQuery.Selector = invalidTest.label _, err := appServer.List(context.Background(), &appQuery) assert.ErrorContains(t, err, invalidTest.errorMesage) }) @@ -1424,7 +1423,7 @@ func BenchmarkListMuchAppsWithName(b *testing.B) { b.ResetTimer() for n := 0; n < b.N; n++ { - app := &application.ApplicationQuery{Name: strToPtr("test-app000099")} + app := &application.ApplicationQuery{Name: "test-app000099"} _, err := appServer.List(context.Background(), app) if err != nil { break @@ -1465,7 +1464,7 @@ func BenchmarkListMuchAppsWithRepo(b *testing.B) { b.ResetTimer() for n := 0; n < b.N; n++ { - app := &application.ApplicationQuery{Repo: strToPtr("https://some-fake-source")} + app := &application.ApplicationQuery{Repo: "https://some-fake-source"} _, err := appServer.List(context.Background(), app) if err != nil { break @@ -1536,12 +1535,12 @@ func TestUpdateAppSpec(t *testing.T) { appServer := newTestAppServer(t, testApp) testApp.Spec.Project = "" spec, err := appServer.UpdateSpec(context.Background(), &application.ApplicationUpdateSpecRequest{ - Name: &testApp.Name, + Name: testApp.Name, Spec: &testApp.Spec, }) require.NoError(t, err) assert.Equal(t, "default", spec.Project) - app, err := appServer.Get(context.Background(), &application.ApplicationQuery{Name: &testApp.Name}) + app, err := appServer.Get(context.Background(), &application.ApplicationQuery{Name: testApp.Name}) require.NoError(t, err) assert.Equal(t, "default", app.Spec.Project) } @@ -1555,7 +1554,7 @@ func TestDeleteApp(t *testing.T) { app, err := appServer.Create(ctx, &createReq) require.NoError(t, err) - app, err = appServer.Get(ctx, &application.ApplicationQuery{Name: &app.Name}) + app, err = appServer.Get(ctx, &application.ApplicationQuery{Name: app.Name}) require.NoError(t, err) assert.NotNil(t, app) @@ -1578,7 +1577,7 @@ func TestDeleteApp(t *testing.T) { appServer.appclientset = fakeAppCs trueVar := true - _, err = appServer.Delete(ctx, &application.ApplicationDeleteRequest{Name: &app.Name, Cascade: &trueVar}) + _, err = appServer.Delete(ctx, &application.ApplicationDeleteRequest{Name: app.Name, Cascade: trueVar}) require.NoError(t, err) assert.True(t, patched) assert.True(t, deleted) @@ -1587,7 +1586,7 @@ func TestDeleteApp(t *testing.T) { falseVar := false patched = false deleted = false - _, err = appServer.Delete(ctx, &application.ApplicationDeleteRequest{Name: &app.Name, Cascade: &falseVar}) + _, err = appServer.Delete(ctx, &application.ApplicationDeleteRequest{Name: app.Name, Cascade: falseVar}) require.NoError(t, err) assert.False(t, patched) assert.True(t, deleted) @@ -1601,7 +1600,7 @@ func TestDeleteApp(t *testing.T) { t.Run("Delete with background propagation policy", func(t *testing.T) { policy := backgroundPropagationPolicy - _, err = appServer.Delete(ctx, &application.ApplicationDeleteRequest{Name: &app.Name, PropagationPolicy: &policy}) + _, err = appServer.Delete(ctx, &application.ApplicationDeleteRequest{Name: app.Name, PropagationPolicy: policy}) require.NoError(t, err) assert.True(t, patched) assert.True(t, deleted) @@ -1610,7 +1609,7 @@ func TestDeleteApp(t *testing.T) { t.Run("Delete with cascade disabled and background propagation policy", func(t *testing.T) { policy := backgroundPropagationPolicy - _, err = appServer.Delete(ctx, &application.ApplicationDeleteRequest{Name: &app.Name, Cascade: &falseVar, PropagationPolicy: &policy}) + _, err = appServer.Delete(ctx, &application.ApplicationDeleteRequest{Name: app.Name, Cascade: falseVar, PropagationPolicy: policy}) require.EqualError(t, err, "rpc error: code = InvalidArgument desc = cannot set propagation policy when cascading is disabled") assert.False(t, patched) assert.False(t, deleted) @@ -1619,7 +1618,7 @@ func TestDeleteApp(t *testing.T) { t.Run("Delete with invalid propagation policy", func(t *testing.T) { invalidPolicy := "invalid" - _, err = appServer.Delete(ctx, &application.ApplicationDeleteRequest{Name: &app.Name, Cascade: &trueVar, PropagationPolicy: &invalidPolicy}) + _, err = appServer.Delete(ctx, &application.ApplicationDeleteRequest{Name: app.Name, Cascade: trueVar, PropagationPolicy: invalidPolicy}) require.EqualError(t, err, "rpc error: code = InvalidArgument desc = invalid propagation policy: invalid") assert.False(t, patched) assert.False(t, deleted) @@ -1628,7 +1627,7 @@ func TestDeleteApp(t *testing.T) { t.Run("Delete with foreground propagation policy", func(t *testing.T) { policy := foregroundPropagationPolicy - _, err = appServer.Delete(ctx, &application.ApplicationDeleteRequest{Name: &app.Name, Cascade: &trueVar, PropagationPolicy: &policy}) + _, err = appServer.Delete(ctx, &application.ApplicationDeleteRequest{Name: app.Name, Cascade: trueVar, PropagationPolicy: policy}) require.NoError(t, err) assert.True(t, patched) assert.True(t, deleted) @@ -1645,12 +1644,12 @@ func TestDeleteResourcesRBAC(t *testing.T) { appServer.enf.SetDefaultRole("") req := application.ApplicationResourceDeleteRequest{ - Name: &testApp.Name, - AppNamespace: &testApp.Namespace, - Group: strToPtr("fake.io"), - Kind: strToPtr("PodTest"), - Namespace: strToPtr("fake-ns"), - ResourceName: strToPtr("my-pod-test"), + Name: testApp.Name, + AppNamespace: testApp.Namespace, + Group: "fake.io", + Kind: "PodTest", + Namespace: "fake-ns", + ResourceName: "my-pod-test", } expectedErrorWhenDeleteAllowed := "rpc error: code = InvalidArgument desc = PodTest fake.io my-pod-test not found as part of application test-app" @@ -1708,12 +1707,12 @@ func TestPatchResourcesRBAC(t *testing.T) { appServer.enf.SetDefaultRole("") req := application.ApplicationResourcePatchRequest{ - Name: &testApp.Name, - AppNamespace: &testApp.Namespace, - Group: strToPtr("fake.io"), - Kind: strToPtr("PodTest"), - Namespace: strToPtr("fake-ns"), - ResourceName: strToPtr("my-pod-test"), + Name: testApp.Name, + AppNamespace: testApp.Namespace, + Group: "fake.io", + Kind: "PodTest", + Namespace: "fake-ns", + ResourceName: "my-pod-test", } expectedErrorWhenUpdateAllowed := "rpc error: code = InvalidArgument desc = PodTest fake.io my-pod-test not found as part of application test-app" @@ -1772,7 +1771,7 @@ func TestSyncAndTerminate(t *testing.T) { } app, err := appServer.Create(ctx, &createReq) require.NoError(t, err) - app, err = appServer.Sync(ctx, &application.ApplicationSyncRequest{Name: &app.Name}) + app, err = appServer.Sync(ctx, &application.ApplicationSyncRequest{Name: app.Name}) require.NoError(t, err) assert.NotNil(t, app) assert.NotNil(t, app.Operation) @@ -1792,11 +1791,11 @@ func TestSyncAndTerminate(t *testing.T) { _, err = appServer.appclientset.ArgoprojV1alpha1().Applications(appServer.ns).Update(context.Background(), app, metav1.UpdateOptions{}) require.NoError(t, err) - resp, err := appServer.TerminateOperation(ctx, &application.OperationTerminateRequest{Name: &app.Name}) + resp, err := appServer.TerminateOperation(ctx, &application.OperationTerminateRequest{Name: app.Name}) require.NoError(t, err) assert.NotNil(t, resp) - app, err = appServer.Get(ctx, &application.ApplicationQuery{Name: &app.Name}) + app, err = appServer.Get(ctx, &application.ApplicationQuery{Name: app.Name}) require.NoError(t, err) assert.NotNil(t, app) assert.Equal(t, synccommon.OperationTerminating, app.Status.OperationState.Phase) @@ -1816,7 +1815,7 @@ func TestSyncHelm(t *testing.T) { app, err := appServer.Create(ctx, &application.ApplicationCreateRequest{Application: testApp}) require.NoError(t, err) - app, err = appServer.Sync(ctx, &application.ApplicationSyncRequest{Name: &app.Name}) + app, err = appServer.Sync(ctx, &application.ApplicationSyncRequest{Name: app.Name}) require.NoError(t, err) assert.NotNil(t, app) assert.NotNil(t, app.Operation) @@ -1836,7 +1835,7 @@ func TestSyncGit(t *testing.T) { app, err := appServer.Create(ctx, &application.ApplicationCreateRequest{Application: testApp}) require.NoError(t, err) syncReq := &application.ApplicationSyncRequest{ - Name: &app.Name, + Name: app.Name, Manifests: []string{ `apiVersion: v1 kind: ServiceAccount @@ -1864,8 +1863,8 @@ func TestRollbackApp(t *testing.T) { appServer := newTestAppServer(t, testApp) updatedApp, err := appServer.Rollback(context.Background(), &application.ApplicationRollbackRequest{ - Name: &testApp.Name, - Id: ptr.To(int64(1)), + Name: testApp.Name, + Id: int64(1), }) require.NoError(t, err) @@ -1948,19 +1947,19 @@ func TestAppJsonPatch(t *testing.T) { appServer := newTestAppServer(t, testApp) appServer.enf.SetDefaultRole("") - app, err := appServer.Patch(ctx, &application.ApplicationPatchRequest{Name: &testApp.Name, Patch: ptr.To("garbage")}) + app, err := appServer.Patch(ctx, &application.ApplicationPatchRequest{Name: testApp.Name, Patch: "garbage"}) require.Error(t, err) assert.Nil(t, app) - app, err = appServer.Patch(ctx, &application.ApplicationPatchRequest{Name: &testApp.Name, Patch: ptr.To("[]")}) + app, err = appServer.Patch(ctx, &application.ApplicationPatchRequest{Name: testApp.Name, Patch: "[]"}) require.NoError(t, err) assert.NotNil(t, app) - app, err = appServer.Patch(ctx, &application.ApplicationPatchRequest{Name: &testApp.Name, Patch: ptr.To(`[{"op": "replace", "path": "/spec/source/path", "value": "foo"}]`)}) + app, err = appServer.Patch(ctx, &application.ApplicationPatchRequest{Name: testApp.Name, Patch: `[{"op": "replace", "path": "/spec/source/path", "value": "foo"}]`}) require.NoError(t, err) assert.Equal(t, "foo", app.Spec.Source.Path) - app, err = appServer.Patch(ctx, &application.ApplicationPatchRequest{Name: &testApp.Name, Patch: ptr.To(`[{"op": "remove", "path": "/metadata/annotations/test.annotation"}]`)}) + app, err = appServer.Patch(ctx, &application.ApplicationPatchRequest{Name: testApp.Name, Patch: `[{"op": "remove", "path": "/metadata/annotations/test.annotation"}]`}) require.NoError(t, err) assert.NotContains(t, app.Annotations, "test.annotation") } @@ -1974,7 +1973,7 @@ func TestAppMergePatch(t *testing.T) { appServer.enf.SetDefaultRole("") app, err := appServer.Patch(ctx, &application.ApplicationPatchRequest{ - Name: &testApp.Name, Patch: ptr.To(`{"spec": { "source": { "path": "foo" } }}`), PatchType: ptr.To("merge"), + Name: testApp.Name, Patch: `{"spec": { "source": { "path": "foo" } }}`, PatchType: "merge", }) require.NoError(t, err) assert.Equal(t, "foo", app.Spec.Source.Path) @@ -1986,7 +1985,7 @@ func TestServer_GetApplicationSyncWindowsState(t *testing.T) { testApp.Spec.Project = "proj-maint" appServer := newTestAppServer(t, testApp) - active, err := appServer.GetApplicationSyncWindows(context.Background(), &application.ApplicationSyncWindowsQuery{Name: &testApp.Name}) + active, err := appServer.GetApplicationSyncWindows(context.Background(), &application.ApplicationSyncWindowsQuery{Name: testApp.Name}) require.NoError(t, err) assert.Len(t, active.ActiveWindows, 1) }) @@ -1995,7 +1994,7 @@ func TestServer_GetApplicationSyncWindowsState(t *testing.T) { testApp.Spec.Project = "default" appServer := newTestAppServer(t, testApp) - active, err := appServer.GetApplicationSyncWindows(context.Background(), &application.ApplicationSyncWindowsQuery{Name: &testApp.Name}) + active, err := appServer.GetApplicationSyncWindows(context.Background(), &application.ApplicationSyncWindowsQuery{Name: testApp.Name}) require.NoError(t, err) assert.Empty(t, active.ActiveWindows) }) @@ -2004,7 +2003,7 @@ func TestServer_GetApplicationSyncWindowsState(t *testing.T) { testApp.Spec.Project = "none" appServer := newTestAppServer(t, testApp) - active, err := appServer.GetApplicationSyncWindows(context.Background(), &application.ApplicationSyncWindowsQuery{Name: &testApp.Name}) + active, err := appServer.GetApplicationSyncWindows(context.Background(), &application.ApplicationSyncWindowsQuery{Name: testApp.Name}) assert.Contains(t, err.Error(), "not exist") assert.Nil(t, active) }) @@ -2125,7 +2124,7 @@ func TestLogsGetSelectedPod(t *testing.T) { t.Run("GetAllPods", func(t *testing.T) { podQuery := application.ApplicationPodLogsQuery{ - Name: &appName, + Name: appName, } pods := getSelectedPods(treeNodes, &podQuery) assert.Len(t, pods, 2) @@ -2136,10 +2135,10 @@ func TestLogsGetSelectedPod(t *testing.T) { kind := "ReplicaSet" name := "rs" podQuery := application.ApplicationPodLogsQuery{ - Name: &appName, - Group: &group, - Kind: &kind, - ResourceName: &name, + Name: appName, + Group: group, + Kind: kind, + ResourceName: name, } pods := getSelectedPods(treeNodes, &podQuery) assert.Len(t, pods, 1) @@ -2150,10 +2149,10 @@ func TestLogsGetSelectedPod(t *testing.T) { kind := "Deployment" name := "deployment" podQuery := application.ApplicationPodLogsQuery{ - Name: &appName, - Group: &group, - Kind: &kind, - ResourceName: &name, + Name: appName, + Group: group, + Kind: kind, + ResourceName: name, } pods := getSelectedPods(treeNodes, &podQuery) assert.Len(t, pods, 1) @@ -2164,10 +2163,10 @@ func TestLogsGetSelectedPod(t *testing.T) { kind := "Service" name := "service" podQuery := application.ApplicationPodLogsQuery{ - Name: &appName, - Group: &group, - Kind: &kind, - ResourceName: &name, + Name: appName, + Group: group, + Kind: kind, + ResourceName: name, } pods := getSelectedPods(treeNodes, &podQuery) assert.Empty(t, pods) @@ -2182,7 +2181,7 @@ func TestMaxPodLogsRender(t *testing.T) { appServer, adminCtx := createAppServerWithMaxLodLogs(t, podNumber) t.Run("PodLogs", func(t *testing.T) { - err := appServer.PodLogs(&application.ApplicationPodLogsQuery{Name: ptr.To("test")}, &TestPodLogsServer{ctx: adminCtx}) + err := appServer.PodLogs(&application.ApplicationPodLogsQuery{Name: "test"}, &TestPodLogsServer{ctx: adminCtx}) statusCode, _ := status.FromError(err) assert.Equal(t, codes.OK, statusCode.Code()) }) @@ -2192,7 +2191,7 @@ func TestMaxPodLogsRender(t *testing.T) { appServer, adminCtx = createAppServerWithMaxLodLogs(t, podNumber) t.Run("PodLogs", func(t *testing.T) { - err := appServer.PodLogs(&application.ApplicationPodLogsQuery{Name: ptr.To("test")}, &TestPodLogsServer{ctx: adminCtx}) + err := appServer.PodLogs(&application.ApplicationPodLogsQuery{Name: "test"}, &TestPodLogsServer{ctx: adminCtx}) require.Error(t, err) statusCode, _ := status.FromError(err) assert.Equal(t, codes.InvalidArgument, statusCode.Code()) @@ -2205,7 +2204,7 @@ func TestMaxPodLogsRender(t *testing.T) { appServer, adminCtx = createAppServerWithMaxLodLogs(t, podNumber, customMaxPodLogsToRender) t.Run("PodLogs", func(t *testing.T) { - err := appServer.PodLogs(&application.ApplicationPodLogsQuery{Name: ptr.To("test")}, &TestPodLogsServer{ctx: adminCtx}) + err := appServer.PodLogs(&application.ApplicationPodLogsQuery{Name: "test"}, &TestPodLogsServer{ctx: adminCtx}) statusCode, _ := status.FromError(err) assert.Equal(t, codes.OK, statusCode.Code()) }) @@ -2216,7 +2215,7 @@ func TestMaxPodLogsRender(t *testing.T) { appServer, adminCtx = createAppServerWithMaxLodLogs(t, podNumber, customMaxPodLogsToRender) t.Run("PodLogs", func(t *testing.T) { - err := appServer.PodLogs(&application.ApplicationPodLogsQuery{Name: ptr.To("test")}, &TestPodLogsServer{ctx: adminCtx}) + err := appServer.PodLogs(&application.ApplicationPodLogsQuery{Name: "test"}, &TestPodLogsServer{ctx: adminCtx}) require.Error(t, err) statusCode, _ := status.FromError(err) assert.Equal(t, codes.InvalidArgument, statusCode.Code()) @@ -2309,8 +2308,8 @@ func TestGetAppRefresh_NormalRefresh(t *testing.T) { go refreshAnnotationRemover(t, ctx, &patched, appServer, testApp.Name, ch) _, err := appServer.Get(context.Background(), &application.ApplicationQuery{ - Name: &testApp.Name, - Refresh: ptr.To(string(appsv1.RefreshTypeNormal)), + Name: testApp.Name, + Refresh: string(appsv1.RefreshTypeNormal), }) require.NoError(t, err) @@ -2344,8 +2343,8 @@ func TestGetAppRefresh_HardRefresh(t *testing.T) { go refreshAnnotationRemover(t, ctx, &patched, appServer, testApp.Name, ch) _, err := appServer.Get(context.Background(), &application.ApplicationQuery{ - Name: &testApp.Name, - Refresh: ptr.To(string(appsv1.RefreshTypeHard)), + Name: testApp.Name, + Refresh: string(appsv1.RefreshTypeHard), }) require.NoError(t, err) require.NotNil(t, getAppDetailsQuery) @@ -2489,14 +2488,14 @@ func TestRunNewStyleResourceAction(t *testing.T) { require.NoError(t, err) appResponse, runErr := appServer.RunResourceAction(context.Background(), &application.ResourceActionRunRequest{ - Name: &testApp.Name, - Namespace: &namespace, - Action: &action, - AppNamespace: &testApp.Namespace, - ResourceName: &resourceName, - Version: &version, - Group: &group, - Kind: &kind, + Name: testApp.Name, + Namespace: namespace, + Action: action, + AppNamespace: testApp.Namespace, + ResourceName: resourceName, + Version: version, + Group: group, + Kind: kind, }) assert.Contains(t, runErr.Error(), "is not permitted to manage") @@ -2515,14 +2514,14 @@ func TestRunNewStyleResourceAction(t *testing.T) { require.NoError(t, err) appResponse, runErr := appServer.RunResourceAction(context.Background(), &application.ResourceActionRunRequest{ - Name: &testApp.Name, - Namespace: &namespace, - Action: &action, - AppNamespace: &testApp.Namespace, - ResourceName: &resourceName, - Version: &version, - Group: &group, - Kind: &kind, + Name: testApp.Name, + Namespace: namespace, + Action: action, + AppNamespace: testApp.Namespace, + ResourceName: resourceName, + Version: version, + Group: group, + Kind: kind, }) require.NoError(t, runErr) @@ -2586,14 +2585,14 @@ func TestRunOldStyleResourceAction(t *testing.T) { require.NoError(t, err) appResponse, runErr := appServer.RunResourceAction(context.Background(), &application.ResourceActionRunRequest{ - Name: &testApp.Name, - Namespace: &namespace, - Action: &action, - AppNamespace: &testApp.Namespace, - ResourceName: &resourceName, - Version: &version, - Group: &group, - Kind: &kind, + Name: testApp.Name, + Namespace: namespace, + Action: action, + AppNamespace: testApp.Namespace, + ResourceName: resourceName, + Version: version, + Group: group, + Kind: kind, }) require.NoError(t, runErr) @@ -2676,7 +2675,7 @@ func TestAppNamespaceRestrictions(t *testing.T) { testApp2 := newTestApp() testApp2.Namespace = "argocd-1" appServer := newTestAppServer(t, testApp1, testApp2) - apps, err := appServer.List(context.TODO(), &application.ApplicationQuery{AppNamespace: ptr.To("argocd-1")}) + apps, err := appServer.List(context.TODO(), &application.ApplicationQuery{AppNamespace: "argocd-1"}) require.NoError(t, err) require.Empty(t, apps.Items) }) @@ -2695,7 +2694,7 @@ func TestAppNamespaceRestrictions(t *testing.T) { testApp := newTestApp() appServer := newTestAppServer(t, testApp) app, err := appServer.Get(context.TODO(), &application.ApplicationQuery{ - Name: ptr.To("test-app"), + Name: "test-app", }) require.NoError(t, err) assert.Equal(t, "test-app", app.GetName()) @@ -2705,8 +2704,8 @@ func TestAppNamespaceRestrictions(t *testing.T) { testApp.Namespace = "argocd-1" appServer := newTestAppServer(t, testApp) app, err := appServer.Get(context.TODO(), &application.ApplicationQuery{ - Name: ptr.To("test-app"), - AppNamespace: ptr.To("argocd-1"), + Name: "test-app", + AppNamespace: "argocd-1", }) require.Error(t, err) require.ErrorContains(t, err, "permission denied") @@ -2727,8 +2726,8 @@ func TestAppNamespaceRestrictions(t *testing.T) { appServer := newTestAppServer(t, testApp, otherNsProj) appServer.enabledNamespaces = []string{"argocd-1"} app, err := appServer.Get(context.TODO(), &application.ApplicationQuery{ - Name: ptr.To("test-app"), - AppNamespace: ptr.To("argocd-1"), + Name: "test-app", + AppNamespace: "argocd-1", }) require.NoError(t, err) require.NotNil(t, app) @@ -2750,8 +2749,8 @@ func TestAppNamespaceRestrictions(t *testing.T) { appServer := newTestAppServer(t, testApp, otherNsProj) appServer.enabledNamespaces = []string{"argocd-1"} app, err := appServer.Get(context.TODO(), &application.ApplicationQuery{ - Name: ptr.To("test-app"), - AppNamespace: ptr.To("argocd-1"), + Name: "test-app", + AppNamespace: "argocd-1", }) require.Error(t, err) require.Nil(t, app) @@ -2837,7 +2836,7 @@ func TestAppNamespaceRestrictions(t *testing.T) { } appServer := newTestAppServer(t, testApp, otherNsProj) appServer.enabledNamespaces = []string{"argocd-1"} - active, err := appServer.GetApplicationSyncWindows(context.TODO(), &application.ApplicationSyncWindowsQuery{Name: &testApp.Name, AppNamespace: &testApp.Namespace}) + active, err := appServer.GetApplicationSyncWindows(context.TODO(), &application.ApplicationSyncWindowsQuery{Name: testApp.Name, AppNamespace: testApp.Namespace}) require.NoError(t, err) assert.Empty(t, active.ActiveWindows) }) @@ -2855,7 +2854,7 @@ func TestAppNamespaceRestrictions(t *testing.T) { } appServer := newTestAppServer(t, testApp, otherNsProj) appServer.enabledNamespaces = []string{"argocd-1"} - active, err := appServer.GetApplicationSyncWindows(context.TODO(), &application.ApplicationSyncWindowsQuery{Name: &testApp.Name, AppNamespace: &testApp.Namespace}) + active, err := appServer.GetApplicationSyncWindows(context.TODO(), &application.ApplicationSyncWindowsQuery{Name: testApp.Name, AppNamespace: testApp.Namespace}) require.Error(t, err) require.Nil(t, active) require.ErrorContains(t, err, "app is not allowed in project") @@ -2875,8 +2874,8 @@ func TestAppNamespaceRestrictions(t *testing.T) { appServer := newTestAppServer(t, testApp, otherNsProj) appServer.enabledNamespaces = []string{"argocd-1"} links, err := appServer.ListLinks(context.TODO(), &application.ListAppLinksRequest{ - Name: ptr.To("test-app"), - Namespace: ptr.To("argocd-1"), + Name: "test-app", + Namespace: "argocd-1", }) require.Error(t, err) require.Nil(t, links) @@ -2897,8 +2896,8 @@ func TestAppNamespaceRestrictions(t *testing.T) { appServer := newTestAppServer(t, testApp, otherNsProj) appServer.enabledNamespaces = []string{"argocd-1"} links, err := appServer.ListLinks(context.TODO(), &application.ListAppLinksRequest{ - Name: ptr.To("test-app"), - Namespace: ptr.To("argocd-1"), + Name: "test-app", + Namespace: "argocd-1", }) require.NoError(t, err) assert.Empty(t, links.Items) @@ -2945,7 +2944,7 @@ func TestGetAmbiguousRevision_MultiSource(t *testing.T) { Sources: nil, } syncReq = &application.ApplicationSyncRequest{ - Revision: strToPtr("revision3"), + Revision: "revision3", } expected = "revision3" result = getAmbiguousRevision(app, syncReq, sourceIndex) @@ -2963,7 +2962,7 @@ func TestGetAmbiguousRevision_SingleSource(t *testing.T) { }, } syncReq := &application.ApplicationSyncRequest{ - Revision: strToPtr("rev1"), + Revision: "rev1", } // Test when app.Spec.HasMultipleSources() is true @@ -3016,7 +3015,7 @@ func TestServer_ResolveSourceRevisions_SingleSource(t *testing.T) { } syncReq := &application.ApplicationSyncRequest{ - Revision: strToPtr("HEAD"), + Revision: "HEAD", } revision, displayRevision, sourceRevisions, displayRevisions, err := s.resolveSourceRevisions(ctx, a, syncReq) @@ -3274,10 +3273,10 @@ func Test_RevisionMetadata(t *testing.T) { s := newTestAppServer(t, app) request := &application.RevisionMetadataQuery{ - Name: pointer.String(app.Name), - Revision: pointer.String("HEAD"), - SourceIndex: tcc.sourceIndex, - VersionId: tcc.versionId, + Name: app.Name, + Revision: "HEAD", + SourceIndex: *tcc.sourceIndex, + VersionId: *tcc.versionId, } _, err := s.RevisionMetadata(context.Background(), request) diff --git a/server/deeplinks/deeplinks_test.go b/server/deeplinks/deeplinks_test.go index 8458a72770f50..288df9b888590 100644 --- a/server/deeplinks/deeplinks_test.go +++ b/server/deeplinks/deeplinks_test.go @@ -80,8 +80,8 @@ func TestDeepLinks(t *testing.T) { Condition: ptr.To(`application.metadata.name == "test" && project.metadata.name == "test-project"`), }}, outputLinks: []*application.LinkInfo{{ - Title: ptr.To("link"), - Url: ptr.To("http://example.com/test&value1&test-repo.git&test-cluster"), + Title: "link", + Url: "http://example.com/test&value1&test-repo.git&test-cluster", }}, error: []string{}, }, @@ -96,8 +96,8 @@ func TestDeepLinks(t *testing.T) { Condition: ptr.To(`app.metadata.name == "test" && project.metadata.name == "test-project"`), }}, outputLinks: []*application.LinkInfo{{ - Title: ptr.To("link"), - Url: ptr.To("http://example.com/test&value1&test-repo.git&test-cluster"), + Title: "link", + Url: "http://example.com/test&value1&test-repo.git&test-cluster", }}, error: []string{}, }, @@ -123,8 +123,8 @@ func TestDeepLinks(t *testing.T) { }, }, outputLinks: []*application.LinkInfo{{ - Title: ptr.To("link"), - Url: ptr.To("http://example.com/test&testns"), + Title: "link", + Url: "http://example.com/test&testns", }}, error: []string{"failed to evaluate link condition 'application.metadata.test matches \"test\"' with resource test, error=interface conversion: interface {} is nil, not string (1:27)\n | application.metadata.test matches \"test\"\n | ..........................^"}, }, @@ -145,8 +145,8 @@ func TestDeepLinks(t *testing.T) { }, }, outputLinks: []*application.LinkInfo{{ - Title: ptr.To("link"), - Url: ptr.To("http://example.com/test&testns"), + Title: "link", + Url: "http://example.com/test&testns", }}, error: []string{"link condition '1 + 1' evaluated to non-boolean value for resource test"}, }, @@ -161,8 +161,8 @@ func TestDeepLinks(t *testing.T) { Condition: ptr.To(`application.metadata.name == "test" && project.metadata.name == "test-project"`), }}, outputLinks: []*application.LinkInfo{{ - Title: ptr.To("link"), - Url: ptr.To("http://example.com/test_cluster&test-repo.git"), + Title: "link", + Url: "http://example.com/test_cluster&test-repo.git", }}, error: []string{}, }, diff --git a/test/e2e/fixture/app/actions.go b/test/e2e/fixture/app/actions.go index 1d013b6628963..0ececd055659f 100644 --- a/test/e2e/fixture/app/actions.go +++ b/test/e2e/fixture/app/actions.go @@ -305,10 +305,10 @@ func (a *Actions) PatchAppHttp(patch string) *Actions { appName := a.context.AppQualifiedName() appNamespace := a.context.AppNamespace() patchRequest := &client.ApplicationPatchRequest{ - Name: &appName, - PatchType: &patchType, - Patch: &patch, - AppNamespace: &appNamespace, + Name: appName, + PatchType: patchType, + Patch: patch, + AppNamespace: appNamespace, } jsonBytes, err := json.MarshalIndent(patchRequest, "", " ") errors.CheckError(err)