Elgato_dark/argo-cd
1
0
Fork 0
mirror of https://github.com/argoproj/argo-cd synced 2026-04-21 17:07:16 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 22

chore: extend require-error rule from testifylint (#18681)

Browse source 
Signed-off-by: Matthieu MOREL <matthieu.morel35@gmail.com>
This commit is contained in:
Matthieu MOREL 2024-06-15 19:51:18 +02:00 committed by GitHub
parent e3fa52dd83
commit eac08dcf79
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
26 changed files with 561 additions and 603 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
.golangci.yaml
View file

@ -7,10 +7,6 @@ issues:
text: "require-error:"
linters:
- testifylint
- path: "util/(argo|cache|cert|clusterauth|config|db|dex|git|gpg)/"
text: "require-error:"
linters:
- testifylint
max-issues-per-linter: 0
max-same-issues: 0
linters:

68
util/argo/argo_test.go
View file

@ -42,7 +42,7 @@ func TestRefreshApp(t *testing.T) {
appClientset := appclientset.NewSimpleClientset(&testApp)
appIf := appClientset.ArgoprojV1alpha1().Applications("default")
_, err := RefreshApp(appIf, "test-app", argoappv1.RefreshTypeNormal)
assert.NoError(t, err)
require.NoError(t, err)
// For some reason, the fake Application interface doesn't reflect the patch status after Patch(),
// so can't verify it was set in unit tests.
//_, ok := newApp.Annotations[common.AnnotationKeyRefresh]
@ -82,7 +82,7 @@ func TestGetAppProjectWithNoProjDefined(t *testing.T) {
settingsMgr := settings.NewSettingsManager(context.Background(), kubeClient, test.FakeArgoCDNamespace)
argoDB := db.NewDB("default", settingsMgr, kubeClient)
proj, err := GetAppProject(&testApp, applisters.NewAppProjectLister(informer.GetIndexer()), namespace, settingsMgr, argoDB, ctx)
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, proj.Name, projName)
}
@ -283,7 +283,7 @@ func TestValidatePermissionsEmptyDestination(t *testing.T) {
Destinations: []argoappv1.ApplicationDestination{{Server: "*", Namespace: "*"}},
},
}, nil)
assert.NoError(t, err)
require.NoError(t, err)
assert.ElementsMatch(t, conditions, []argoappv1.ApplicationCondition{{Type: argoappv1.ApplicationConditionInvalidSpecError, Message: "Destination server missing from app spec"}})
}
@ -305,7 +305,7 @@ func TestValidateChartWithoutRevision(t *testing.T) {
Destinations: []argoappv1.ApplicationDestination{{Server: "*", Namespace: "*"}},
},
}, db)
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, conditions, 1)
assert.Equal(t, argoappv1.ApplicationConditionInvalidSpecError, conditions[0].Type)
assert.Equal(t, "spec.source.targetRevision is required if the manifest source is a helm chart", conditions[0].Message)
@ -332,7 +332,7 @@ func TestAPIResourcesToStrings(t *testing.T) {
func TestValidateRepo(t *testing.T) {
repoPath, err := filepath.Abs("./../..")
assert.NoError(t, err)
require.NoError(t, err)
apiResources := []kube.APIResourceInfo{{
GroupVersionResource: schema.GroupVersionResource{Group: "apps", Version: "v1beta1"},
@ -428,7 +428,7 @@ func TestValidateRepo(t *testing.T) {
conditions, err := ValidateRepo(context.Background(), app, repoClientSet, db, &kubetest.MockKubectlCmd{Version: kubeVersion, APIResources: apiResources}, proj, settingsMgr)
assert.NoError(t, err)
require.NoError(t, err)
assert.Empty(t, conditions)
assert.ElementsMatch(t, []string{"apps/v1beta1", "apps/v1beta1/Deployment", "apps/v1beta2", "apps/v1beta2/Deployment"}, receivedRequest.ApiVersions)
assert.Equal(t, kubeVersion, receivedRequest.KubeVersion)
@ -615,7 +615,7 @@ func TestValidatePermissions(t *testing.T) {
proj := argoappv1.AppProject{}
db := &dbmocks.ArgoDB{}
conditions, err := ValidatePermissions(context.Background(), &spec, &proj, db)
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, conditions, 1)
assert.Equal(t, argoappv1.ApplicationConditionInvalidSpecError, conditions[0].Type)
assert.Contains(t, conditions[0].Message, "are required")
@ -632,7 +632,7 @@ func TestValidatePermissions(t *testing.T) {
proj := argoappv1.AppProject{}
db := &dbmocks.ArgoDB{}
conditions, err := ValidatePermissions(context.Background(), &spec, &proj, db)
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, conditions, 1)
assert.Equal(t, argoappv1.ApplicationConditionInvalidSpecError, conditions[0].Type)
assert.Contains(t, conditions[0].Message, "are required")
@ -649,7 +649,7 @@ func TestValidatePermissions(t *testing.T) {
proj := argoappv1.AppProject{}
db := &dbmocks.ArgoDB{}
conditions, err := ValidatePermissions(context.Background(), &spec, &proj, db)
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, conditions, 1)
assert.Equal(t, argoappv1.ApplicationConditionInvalidSpecError, conditions[0].Type)
assert.Contains(t, conditions[0].Message, "is required if the manifest source is a helm chart")
@ -683,7 +683,7 @@ func TestValidatePermissions(t *testing.T) {
db := &dbmocks.ArgoDB{}
db.On("GetCluster", context.Background(), spec.Destination.Server).Return(cluster, nil)
conditions, err := ValidatePermissions(context.Background(), &spec, &proj, db)
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, conditions, 1)
assert.Contains(t, conditions[0].Message, "application repo http://some/where is not permitted")
})
@ -716,7 +716,7 @@ func TestValidatePermissions(t *testing.T) {
db := &dbmocks.ArgoDB{}
db.On("GetCluster", context.Background(), spec.Destination.Server).Return(cluster, nil)
conditions, err := ValidatePermissions(context.Background(), &spec, &proj, db)
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, conditions, 1)
assert.Contains(t, conditions[0].Message, "application destination")
})
@ -748,7 +748,7 @@ func TestValidatePermissions(t *testing.T) {
db := &dbmocks.ArgoDB{}
db.On("GetCluster", context.Background(), spec.Destination.Server).Return(nil, status.Errorf(codes.NotFound, "Cluster does not exist"))
conditions, err := ValidatePermissions(context.Background(), &spec, &proj, db)
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, conditions, 1)
assert.Contains(t, conditions[0].Message, "has not been configured")
})
@ -780,7 +780,7 @@ func TestValidatePermissions(t *testing.T) {
db := &dbmocks.ArgoDB{}
db.On("GetClusterServersByName", context.Background(), "does-not-exist").Return(nil, nil)
conditions, err := ValidatePermissions(context.Background(), &spec, &proj, db)
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, conditions, 1)
assert.Contains(t, conditions[0].Message, "unable to find destination server: there are no clusters with this name: does-not-exist")
})
@ -812,7 +812,7 @@ func TestValidatePermissions(t *testing.T) {
db := &dbmocks.ArgoDB{}
db.On("GetCluster", context.Background(), spec.Destination.Server).Return(nil, fmt.Errorf("Unknown error occurred"))
_, err := ValidatePermissions(context.Background(), &spec, &proj, db)
assert.Error(t, err)
require.Error(t, err)
})
t.Run("Destination cluster name resolves to valid server", func(t *testing.T) {
@ -847,7 +847,7 @@ func TestValidatePermissions(t *testing.T) {
db.On("GetClusterServersByName", context.Background(), "does-exist").Return([]string{"https://127.0.0.1:6443"}, nil)
db.On("GetCluster", context.Background(), "https://127.0.0.1:6443").Return(&cluster, nil)
conditions, err := ValidatePermissions(context.Background(), &spec, &proj, db)
assert.NoError(t, err)
require.NoError(t, err)
assert.Empty(t, conditions)
})
}
@ -856,7 +856,7 @@ func TestSetAppOperations(t *testing.T) {
t.Run("Application not existing", func(t *testing.T) {
appIf := appclientset.NewSimpleClientset().ArgoprojV1alpha1().Applications("default")
app, err := SetAppOperation(appIf, "someapp", &argoappv1.Operation{Sync: &argoappv1.SyncOperation{Revision: "aaa"}})
assert.Error(t, err)
require.Error(t, err)
assert.Nil(t, app)
})
@ -870,7 +870,7 @@ func TestSetAppOperations(t *testing.T) {
}
appIf := appclientset.NewSimpleClientset(&a).ArgoprojV1alpha1().Applications("default")
app, err := SetAppOperation(appIf, "someapp", &argoappv1.Operation{Sync: &argoappv1.SyncOperation{Revision: "aaa"}})
assert.Error(t, err)
require.Error(t, err)
assert.Contains(t, err.Error(), "operation is already in progress")
assert.Nil(t, app)
})
@ -884,7 +884,7 @@ func TestSetAppOperations(t *testing.T) {
}
appIf := appclientset.NewSimpleClientset(&a).ArgoprojV1alpha1().Applications("default")
app, err := SetAppOperation(appIf, "someapp", &argoappv1.Operation{Sync: nil})
assert.Error(t, err)
require.Error(t, err)
assert.Contains(t, err.Error(), "Operation unspecified")
assert.Nil(t, app)
})
@ -898,7 +898,7 @@ func TestSetAppOperations(t *testing.T) {
}
appIf := appclientset.NewSimpleClientset(&a).ArgoprojV1alpha1().Applications("default")
app, err := SetAppOperation(appIf, "someapp", &argoappv1.Operation{Sync: &argoappv1.SyncOperation{Revision: "aaa"}})
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, app)
})
}
@ -911,7 +911,7 @@ func TestValidateDestination(t *testing.T) {
}
appCond := ValidateDestination(context.Background(), &dest, nil)
assert.NoError(t, appCond)
require.NoError(t, appCond)
assert.False(t, dest.IsServerInferred())
})
@ -924,7 +924,7 @@ func TestValidateDestination(t *testing.T) {
db.On("GetClusterServersByName", context.Background(), "minikube").Return([]string{"https://127.0.0.1:6443"}, nil)
appCond := ValidateDestination(context.Background(), &dest, db)
assert.NoError(t, appCond)
require.NoError(t, appCond)
assert.Equal(t, "https://127.0.0.1:6443", dest.Server)
assert.True(t, dest.IsServerInferred())
})
@ -1003,19 +1003,19 @@ func TestFilterByName(t *testing.T) {
t.Run("Name is empty string", func(t *testing.T) {
res, err := FilterByName(apps, "")
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, res, 2)
})
t.Run("Single app by name", func(t *testing.T) {
res, err := FilterByName(apps, "foo")
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, res, 1)
})
t.Run("No such app", func(t *testing.T) {
res, err := FilterByName(apps, "foobar")
assert.Error(t, err)
require.Error(t, err)
assert.Empty(t, res)
})
}
@ -1263,7 +1263,7 @@ func Test_AppInstanceNameFromQualified(t *testing.T) {
func Test_GetRefSources(t *testing.T) {
repoPath, err := filepath.Abs("./../..")
assert.NoError(t, err)
require.NoError(t, err)
getMultiSourceAppSpec := func(sources argoappv1.ApplicationSources) *argoappv1.ApplicationSpec {
return &argoappv1.ApplicationSpec{
@ -1288,7 +1288,7 @@ func Test_GetRefSources(t *testing.T) {
Repo: *repo,
},
}
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, refSources, 1)
assert.Equal(t, expectedRefSource, refSources)
})
@ -1303,7 +1303,7 @@ func Test_GetRefSources(t *testing.T) {
return nil, errors.New("repo does not exist")
}, []string{}, false)
assert.Error(t, err)
require.Error(t, err)
assert.Empty(t, refSources)
})
@ -1317,7 +1317,7 @@ func Test_GetRefSources(t *testing.T) {
return nil, err
}, []string{}, false)
assert.Error(t, err)
require.Error(t, err)
assert.Empty(t, refSources)
})
@ -1331,7 +1331,7 @@ func Test_GetRefSources(t *testing.T) {
return nil, err
}, []string{}, false)
assert.Error(t, err)
require.Error(t, err)
assert.Empty(t, refSources)
})
}
@ -1347,7 +1347,7 @@ func TestValidatePermissionsMultipleSources(t *testing.T) {
proj := argoappv1.AppProject{}
db := &dbmocks.ArgoDB{}
conditions, err := ValidatePermissions(context.Background(), &spec, &proj, db)
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, conditions, 1)
assert.Equal(t, argoappv1.ApplicationConditionInvalidSpecError, conditions[0].Type)
assert.Contains(t, conditions[0].Message, "are required")
@ -1367,7 +1367,7 @@ func TestValidatePermissionsMultipleSources(t *testing.T) {
proj := argoappv1.AppProject{}
db := &dbmocks.ArgoDB{}
conditions, err := ValidatePermissions(context.Background(), &spec, &proj, db)
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, conditions, 1)
assert.Equal(t, argoappv1.ApplicationConditionInvalidSpecError, conditions[0].Type)
assert.Contains(t, conditions[0].Message, "are required")
@ -1403,7 +1403,7 @@ func TestValidatePermissionsMultipleSources(t *testing.T) {
db := &dbmocks.ArgoDB{}
db.On("GetCluster", context.Background(), spec.Destination.Server).Return(cluster, nil)
conditions, err := ValidatePermissions(context.Background(), &spec, &proj, db)
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, conditions, 1)
assert.Contains(t, conditions[0].Message, "application repo http://some/where is not permitted")
})
@ -1442,7 +1442,7 @@ func TestValidatePermissionsMultipleSources(t *testing.T) {
db.On("GetClusterServersByName", context.Background(), "does-exist").Return([]string{"https://127.0.0.1:6443"}, nil)
db.On("GetCluster", context.Background(), "https://127.0.0.1:6443").Return(&cluster, nil)
conditions, err := ValidatePermissions(context.Background(), &spec, &proj, db)
assert.NoError(t, err)
require.NoError(t, err)
assert.Empty(t, conditions)
})
}
@ -1569,7 +1569,7 @@ func TestAugmentSyncMsg(t *testing.T) {
require.Error(t, err)
assert.Equal(t, tt.errMsg, err.Error())
} else {
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, tt.expectedMessage, msg)
}
})

2
util/argo/diff/diff_test.go
View file

@ -140,7 +140,7 @@ func TestStateDiff(t *testing.T) {
result, err := argo.StateDiff(tc.liveState, tc.desiredState, dc)
// then
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, result)
assert.True(t, result.Modified)
normalized := testutil.YamlToUnstructured(string(result.NormalizedLive))

18
util/argo/managedfields/managed_fields_test.go
View file

@ -34,17 +34,17 @@ func TestNormalize(t *testing.T) {
require.NotNil(t, desiredResult)
desiredReplicas, ok, err := unstructured.NestedFloat64(desiredResult.Object, "spec", "replicas")
assert.False(t, ok)
assert.NoError(t, err)
require.NoError(t, err)
liveReplicas, ok, err := unstructured.NestedFloat64(liveResult.Object, "spec", "replicas")
assert.False(t, ok)
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, liveReplicas, desiredReplicas)
liveRevisionHistory, ok, err := unstructured.NestedFloat64(liveResult.Object, "spec", "revisionHistoryLimit")
assert.False(t, ok)
assert.NoError(t, err)
require.NoError(t, err)
desiredRevisionHistory, ok, err := unstructured.NestedFloat64(desiredResult.Object, "spec", "revisionHistoryLimit")
assert.False(t, ok)
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, liveRevisionHistory, desiredRevisionHistory)
})
t.Run("will keep conflicting fields if not from trusted manager", func(t *testing.T) {
@ -58,7 +58,7 @@ func TestNormalize(t *testing.T) {
liveResult, desiredResult, err := managedfields.Normalize(liveState, desiredState, trustedManagers, &pt)
// then
assert.NoError(t, err)
require.NoError(t, err)
validateNestedFloat64(t, float64(3), desiredResult, "spec", "replicas")
validateNestedFloat64(t, float64(1), desiredResult, "spec", "revisionHistoryLimit")
validateNestedFloat64(t, float64(2), liveResult, "spec", "replicas")
@ -74,7 +74,7 @@ func TestNormalize(t *testing.T) {
liveResult, desiredResult, err := managedfields.Normalize(nil, desiredState, trustedManagers, &pt)
// then
assert.NoError(t, err)
require.NoError(t, err)
assert.Nil(t, liveResult)
assert.Nil(t, desiredResult)
validateNestedFloat64(t, float64(3), desiredState, "spec", "replicas")
@ -90,7 +90,7 @@ func TestNormalize(t *testing.T) {
liveResult, desiredResult, err := managedfields.Normalize(liveState, nil, trustedManagers, &pt)
// then
assert.NoError(t, err)
require.NoError(t, err)
assert.Nil(t, liveResult)
assert.Nil(t, desiredResult)
validateNestedFloat64(t, float64(2), liveState, "spec", "replicas")
@ -106,7 +106,7 @@ func TestNormalize(t *testing.T) {
liveResult, desiredResult, err := managedfields.Normalize(liveState, desiredState, []string{}, &pt)
// then
assert.NoError(t, err)
require.NoError(t, err)
assert.Nil(t, liveResult)
assert.Nil(t, desiredResult)
validateNestedFloat64(t, float64(3), desiredState, "spec", "replicas")
@ -153,7 +153,7 @@ func getNestedFloat64(t *testing.T, obj *unstructured.Unstructured, fields ...st
t.Helper()
current, ok, err := unstructured.NestedFloat64(obj.Object, fields...)
assert.True(t, ok, "nested field not found")
assert.NoError(t, err)
require.NoError(t, err)
return current
}

72
util/argo/normalizers/diff_normalizer_test.go
View file

@ -21,22 +21,22 @@ func TestNormalizeObjectWithMatchedGroupKind(t *testing.T) {
JSONPointers: []string{"/not-matching-path", "/spec/template/spec/containers"},
}}, make(map[string]v1alpha1.ResourceOverride), IgnoreNormalizerOpts{})
assert.NoError(t, err)
require.NoError(t, err)
deployment := test.NewDeployment()
_, has, err := unstructured.NestedSlice(deployment.Object, "spec", "template", "spec", "containers")
assert.NoError(t, err)
require.NoError(t, err)
assert.True(t, has)
err = normalizer.Normalize(deployment)
assert.NoError(t, err)
require.NoError(t, err)
_, has, err = unstructured.NestedSlice(deployment.Object, "spec", "template", "spec", "containers")
assert.NoError(t, err)
require.NoError(t, err)
assert.False(t, has)
err = normalizer.Normalize(nil)
assert.Error(t, err)
require.Error(t, err)
}
func TestNormalizeNoMatchedGroupKinds(t *testing.T) {
@ -46,15 +46,15 @@ func TestNormalizeNoMatchedGroupKinds(t *testing.T) {
JSONPointers: []string{"/spec"},
}}, make(map[string]v1alpha1.ResourceOverride), IgnoreNormalizerOpts{})
assert.NoError(t, err)
require.NoError(t, err)
deployment := test.NewDeployment()
err = normalizer.Normalize(deployment)
assert.NoError(t, err)
require.NoError(t, err)
_, hasSpec, err := unstructured.NestedMap(deployment.Object, "spec")
assert.NoError(t, err)
require.NoError(t, err)
assert.True(t, hasSpec)
}
@ -65,18 +65,18 @@ func TestNormalizeMatchedResourceOverrides(t *testing.T) {
},
}, IgnoreNormalizerOpts{})
assert.NoError(t, err)
require.NoError(t, err)
deployment := test.NewDeployment()
_, has, err := unstructured.NestedSlice(deployment.Object, "spec", "template", "spec", "containers")
assert.NoError(t, err)
require.NoError(t, err)
assert.True(t, has)
err = normalizer.Normalize(deployment)
assert.NoError(t, err)
require.NoError(t, err)
_, has, err = unstructured.NestedSlice(deployment.Object, "spec", "template", "spec", "containers")
assert.NoError(t, err)
require.NoError(t, err)
assert.False(t, has)
}
@ -119,19 +119,19 @@ func TestNormalizeMissingJsonPointer(t *testing.T) {
IgnoreDifferences: v1alpha1.OverrideIgnoreDiff{JSONPointers: []string{"/spec/additionalPrinterColumns/0/priority"}},
},
}, IgnoreNormalizerOpts{})
assert.NoError(t, err)
require.NoError(t, err)
deployment := test.NewDeployment()
err = normalizer.Normalize(deployment)
assert.NoError(t, err)
require.NoError(t, err)
crd := unstructured.Unstructured{}
err = yaml.Unmarshal([]byte(testCRDYAML), &crd)
assert.NoError(t, err)
require.NoError(t, err)
err = normalizer.Normalize(&crd)
assert.NoError(t, err)
require.NoError(t, err)
}
func TestNormalizeGlobMatch(t *testing.T) {
@ -141,18 +141,18 @@ func TestNormalizeGlobMatch(t *testing.T) {
},
}, IgnoreNormalizerOpts{})
assert.NoError(t, err)
require.NoError(t, err)
deployment := test.NewDeployment()
_, has, err := unstructured.NestedSlice(deployment.Object, "spec", "template", "spec", "containers")
assert.NoError(t, err)
require.NoError(t, err)
assert.True(t, has)
err = normalizer.Normalize(deployment)
assert.NoError(t, err)
require.NoError(t, err)
_, has, err = unstructured.NestedSlice(deployment.Object, "spec", "template", "spec", "containers")
assert.NoError(t, err)
require.NoError(t, err)
assert.False(t, has)
}
@ -163,7 +163,7 @@ func TestNormalizeJQPathExpression(t *testing.T) {
JQPathExpressions: []string{".spec.template.spec.initContainers[] | select(.name == \"init-container-0\")"},
}}, make(map[string]v1alpha1.ResourceOverride), IgnoreNormalizerOpts{})
assert.NoError(t, err)
require.NoError(t, err)
deployment := test.NewDeployment()
@ -171,22 +171,22 @@ func TestNormalizeJQPathExpression(t *testing.T) {
initContainers = append(initContainers, map[string]interface{}{"name": "init-container-0"})
initContainers = append(initContainers, map[string]interface{}{"name": "init-container-1"})
err = unstructured.SetNestedSlice(deployment.Object, initContainers, "spec", "template", "spec", "initContainers")
assert.NoError(t, err)
require.NoError(t, err)
actualInitContainers, has, err := unstructured.NestedSlice(deployment.Object, "spec", "template", "spec", "initContainers")
assert.NoError(t, err)
require.NoError(t, err)
assert.True(t, has)
assert.Len(t, actualInitContainers, 2)
err = normalizer.Normalize(deployment)
assert.NoError(t, err)
require.NoError(t, err)
actualInitContainers, has, err = unstructured.NestedSlice(deployment.Object, "spec", "template", "spec", "initContainers")
assert.NoError(t, err)
require.NoError(t, err)
assert.True(t, has)
assert.Len(t, actualInitContainers, 1)
actualInitContainerName, has, err := unstructured.NestedString(actualInitContainers[0].(map[string]interface{}), "name")
assert.NoError(t, err)
require.NoError(t, err)
assert.True(t, has)
assert.Equal(t, "init-container-1", actualInitContainerName)
}
@ -199,7 +199,7 @@ func TestNormalizeIllegalJQPathExpression(t *testing.T) {
// JSONPointers: []string{"no-starting-slash"},
}}, make(map[string]v1alpha1.ResourceOverride), IgnoreNormalizerOpts{})
assert.Error(t, err)
require.Error(t, err)
}
func TestNormalizeJQPathExpressionWithError(t *testing.T) {
@ -209,17 +209,17 @@ func TestNormalizeJQPathExpressionWithError(t *testing.T) {
JQPathExpressions: []string{".spec.fakeField.foo[]"},
}}, make(map[string]v1alpha1.ResourceOverride), IgnoreNormalizerOpts{})
assert.NoError(t, err)
require.NoError(t, err)
deployment := test.NewDeployment()
originalDeployment, err := deployment.MarshalJSON()
assert.NoError(t, err)
require.NoError(t, err)
err = normalizer.Normalize(deployment)
assert.NoError(t, err)
require.NoError(t, err)
normalizedDeployment, err := deployment.MarshalJSON()
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, originalDeployment, normalizedDeployment)
}
@ -231,7 +231,7 @@ func TestNormalizeExpectedErrorAreSilenced(t *testing.T) {
},
},
}, IgnoreNormalizerOpts{})
assert.NoError(t, err)
require.NoError(t, err)
ignoreNormalizer := normalizer.(*ignoreNormalizer)
assert.Len(t, ignoreNormalizer.patches, 2)
@ -240,7 +240,7 @@ func TestNormalizeExpectedErrorAreSilenced(t *testing.T) {
deployment := test.NewDeployment()
deploymentData, err := json.Marshal(deployment)
assert.NoError(t, err)
require.NoError(t, err)
// Error: "error in remove for path: '/invalid': Unable to remove nonexistent key: invalid: missing value"
_, err = jsonPatch.Apply(deploymentData)
@ -261,7 +261,7 @@ func TestJqPathExpressionFailWithTimeout(t *testing.T) {
},
},
}, IgnoreNormalizerOpts{})
assert.NoError(t, err)
require.NoError(t, err)
ignoreNormalizer := normalizer.(*ignoreNormalizer)
assert.Len(t, ignoreNormalizer.patches, 1)
@ -269,7 +269,7 @@ func TestJqPathExpressionFailWithTimeout(t *testing.T) {
deployment := test.NewDeployment()
deploymentData, err := json.Marshal(deployment)
assert.NoError(t, err)
require.NoError(t, err)
_, err = jqPatch.Apply(deploymentData)
assert.ErrorContains(t, err, "JQ patch execution timed out")
@ -282,7 +282,7 @@ func TestJQPathExpressionReturnsHelpfulError(t *testing.T) {
JQPathExpressions: []string{`.nothing) | .data["config.yaml"] |= (fromjson | del(.auth) | tojson`},
}}, nil, IgnoreNormalizerOpts{})
assert.NoError(t, err)
require.NoError(t, err)
configMap := test.NewConfigMap()
require.NoError(t, err)

104
util/argo/normalizers/knowntypes_normalizer_test.go
View file

@ -77,36 +77,28 @@ func TestNormalize_MapField(t *testing.T) {
}},
},
})
if !assert.NoError(t, err) {
return
}
require.NoError(t, err)
rollout := mustUnmarshalYAML(someCRDYaml)
err = normalizer.Normalize(rollout)
if !assert.NoError(t, err) {
return
}
require.NoError(t, err)
container, err := nestedSliceMap(rollout.Object, 0, "spec", "template", "spec", "containers")
if !assert.NoError(t, err) {
return
}
require.NoError(t, err)
cpu, ok, err := unstructured.NestedFieldNoCopy(container, "resources", "requests", "cpu")
if !assert.NoError(t, err) || !assert.True(t, ok) {
return
}
require.NoError(t, err)
require.True(t, ok)
assert.Equal(t, "2", cpu)
volumeMount, err := nestedSliceMap(container, 0, "volumeMounts")
if !assert.NoError(t, err) || !assert.True(t, ok) {
return
}
require.NoError(t, err)
require.True(t, ok)
_, ok, err = unstructured.NestedBool(volumeMount, "readOnly")
assert.NoError(t, err)
require.NoError(t, err)
assert.False(t, ok)
}
@ -120,24 +112,17 @@ func TestNormalize_FieldInNestedSlice(t *testing.T) {
}},
},
})
if !assert.NoError(t, err) {
return
}
require.NoError(t, err)
err = normalizer.Normalize(rollout)
if !assert.NoError(t, err) {
return
}
require.NoError(t, err)
container, err := nestedSliceMap(rollout.Object, 0, "spec", "template", "spec", "containers")
if !assert.NoError(t, err) {
return
}
require.NoError(t, err)
cpu, ok, err := unstructured.NestedFieldNoCopy(container, "resources", "requests", "cpu")
if !assert.NoError(t, err) || !assert.True(t, ok) {
return
}
require.NoError(t, err)
require.True(t, ok)
assert.Equal(t, "2", cpu)
}
@ -172,29 +157,20 @@ spec:
}},
},
})
if !assert.NoError(t, err) {
return
}
require.NoError(t, err)
err = normalizer.Normalize(rollout)
if !assert.NoError(t, err) {
return
}
require.NoError(t, err)
template, err := nestedSliceMap(rollout.Object, 0, "spec", "templates")
if !assert.NoError(t, err) {
return
}
require.NoError(t, err)
container, err := nestedSliceMap(template, 0, "spec", "containers")
if !assert.NoError(t, err) {
return
}
require.NoError(t, err)
cpu, ok, err := unstructured.NestedFieldNoCopy(container, "resources", "requests", "cpu")
if !assert.NoError(t, err) || !assert.True(t, ok) {
return
}
require.NoError(t, err)
require.True(t, ok)
assert.Equal(t, "2", cpu)
}
@ -213,19 +189,14 @@ spec:
}},
},
})
if !assert.NoError(t, err) {
return
}
require.NoError(t, err)
err = normalizer.Normalize(rollout)
if !assert.NoError(t, err) {
return
}
require.NoError(t, err)
ram, ok, err := unstructured.NestedFieldNoCopy(rollout.Object, "spec", "ram")
if !assert.NoError(t, err) || !assert.True(t, ok) {
return
}
require.NoError(t, err)
require.True(t, ok)
assert.Equal(t, "1250M", ram)
}
@ -266,33 +237,24 @@ func TestFieldDoesNotExist(t *testing.T) {
}},
},
})
if !assert.NoError(t, err) {
return
}
require.NoError(t, err)
err = normalizer.Normalize(rollout)
if !assert.NoError(t, err) {
return
}
require.NoError(t, err)
container, err := nestedSliceMap(rollout.Object, 0, "spec", "template", "spec", "containers")
if !assert.NoError(t, err) {
return
}
require.NoError(t, err)
cpu, ok, err := unstructured.NestedFieldNoCopy(container, "resources", "requests", "cpu")
if !assert.NoError(t, err) || !assert.True(t, ok) {
return
}
require.NoError(t, err)
require.True(t, ok)
assert.Equal(t, "2000m", cpu)
}
func TestRolloutPreConfigured(t *testing.T) {
normalizer, err := NewKnownTypesNormalizer(map[string]v1alpha1.ResourceOverride{})
if !assert.NoError(t, err) {
return
}
require.NoError(t, err)
_, ok := normalizer.typeFields[schema.GroupKind{Group: application.Group, Kind: "Rollout"}]
assert.True(t, ok)
}
@ -306,18 +268,14 @@ func TestOverrideKeyWithoutGroup(t *testing.T) {
}},
},
})
if !assert.NoError(t, err) {
return
}
require.NoError(t, err)
_, ok := normalizer.typeFields[schema.GroupKind{Group: "", Kind: "ConfigMap"}]
assert.True(t, ok)
}
func TestKnownTypes(t *testing.T) {
typesData, err := os.ReadFile("./diffing_known_types.txt")
if !assert.NoError(t, err) {
return
}
require.NoError(t, err)
for _, typeName := range strings.Split(string(typesData), "\n") {
if typeName = strings.TrimSpace(typeName); typeName == "" {
continue

85
util/argo/resource_tracking_test.go
View file

@ -7,6 +7,7 @@ import (
"github.com/argoproj/argo-cd/v2/util/kube"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"gopkg.in/yaml.v2"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
@ -15,32 +16,32 @@ import (
func TestSetAppInstanceLabel(t *testing.T) {
yamlBytes, err := os.ReadFile("testdata/svc.yaml")
assert.NoError(t, err)
require.NoError(t, err)
var obj unstructured.Unstructured
err = yaml.Unmarshal(yamlBytes, &obj)
assert.NoError(t, err)
require.NoError(t, err)
resourceTracking := NewResourceTracking()
err = resourceTracking.SetAppInstance(&obj, common.LabelKeyAppInstance, "my-app", "", TrackingMethodLabel)
assert.NoError(t, err)
require.NoError(t, err)
app := resourceTracking.GetAppName(&obj, common.LabelKeyAppInstance, TrackingMethodLabel)
assert.Equal(t, "my-app", app)
}
func TestSetAppInstanceAnnotation(t *testing.T) {
yamlBytes, err := os.ReadFile("testdata/svc.yaml")
assert.NoError(t, err)
require.NoError(t, err)
var obj unstructured.Unstructured
err = yaml.Unmarshal(yamlBytes, &obj)
assert.NoError(t, err)
require.NoError(t, err)
resourceTracking := NewResourceTracking()
err = resourceTracking.SetAppInstance(&obj, common.AnnotationKeyAppInstance, "my-app", "", TrackingMethodAnnotation)
assert.NoError(t, err)
require.NoError(t, err)
app := resourceTracking.GetAppName(&obj, common.AnnotationKeyAppInstance, TrackingMethodAnnotation)
assert.Equal(t, "my-app", app)
@ -48,15 +49,15 @@ func TestSetAppInstanceAnnotation(t *testing.T) {
func TestSetAppInstanceAnnotationAndLabel(t *testing.T) {
yamlBytes, err := os.ReadFile("testdata/svc.yaml")
assert.NoError(t, err)
require.NoError(t, err)
var obj unstructured.Unstructured
err = yaml.Unmarshal(yamlBytes, &obj)
assert.NoError(t, err)
require.NoError(t, err)
resourceTracking := NewResourceTracking()
err = resourceTracking.SetAppInstance(&obj, common.LabelKeyAppInstance, "my-app", "", TrackingMethodAnnotationAndLabel)
assert.NoError(t, err)
require.NoError(t, err)
app := resourceTracking.GetAppName(&obj, common.LabelKeyAppInstance, TrackingMethodAnnotationAndLabel)
assert.Equal(t, "my-app", app)
@ -64,15 +65,15 @@ func TestSetAppInstanceAnnotationAndLabel(t *testing.T) {
func TestSetAppInstanceAnnotationAndLabelLongName(t *testing.T) {
yamlBytes, err := os.ReadFile("testdata/svc.yaml")
assert.NoError(t, err)
require.NoError(t, err)
var obj unstructured.Unstructured
err = yaml.Unmarshal(yamlBytes, &obj)
assert.NoError(t, err)
require.NoError(t, err)
resourceTracking := NewResourceTracking()
err = resourceTracking.SetAppInstance(&obj, common.LabelKeyAppInstance, "my-app-with-an-extremely-long-name-that-is-over-sixty-three-characters", "", TrackingMethodAnnotationAndLabel)
assert.NoError(t, err)
require.NoError(t, err)
// the annotation should still work, so the name from GetAppName should not be truncated
app := resourceTracking.GetAppName(&obj, common.LabelKeyAppInstance, TrackingMethodAnnotationAndLabel)
@ -84,15 +85,15 @@ func TestSetAppInstanceAnnotationAndLabelLongName(t *testing.T) {
func TestSetAppInstanceAnnotationAndLabelLongNameBadEnding(t *testing.T) {
yamlBytes, err := os.ReadFile("testdata/svc.yaml")
assert.NoError(t, err)
require.NoError(t, err)
var obj unstructured.Unstructured
err = yaml.Unmarshal(yamlBytes, &obj)
assert.NoError(t, err)
require.NoError(t, err)
resourceTracking := NewResourceTracking()
err = resourceTracking.SetAppInstance(&obj, common.LabelKeyAppInstance, "the-very-suspicious-name-with-precisely-sixty-three-characters-with-hyphen", "", TrackingMethodAnnotationAndLabel)
assert.NoError(t, err)
require.NoError(t, err)
// the annotation should still work, so the name from GetAppName should not be truncated
app := resourceTracking.GetAppName(&obj, common.LabelKeyAppInstance, TrackingMethodAnnotationAndLabel)
@ -104,10 +105,10 @@ func TestSetAppInstanceAnnotationAndLabelLongNameBadEnding(t *testing.T) {
func TestSetAppInstanceAnnotationAndLabelOutOfBounds(t *testing.T) {
yamlBytes, err := os.ReadFile("testdata/svc.yaml")
assert.NoError(t, err)
require.NoError(t, err)
var obj unstructured.Unstructured
err = yaml.Unmarshal(yamlBytes, &obj)
assert.NoError(t, err)
require.NoError(t, err)
resourceTracking := NewResourceTracking()
@ -118,11 +119,11 @@ func TestSetAppInstanceAnnotationAndLabelOutOfBounds(t *testing.T) {
func TestSetAppInstanceAnnotationNotFound(t *testing.T) {
yamlBytes, err := os.ReadFile("testdata/svc.yaml")
assert.NoError(t, err)
require.NoError(t, err)
var obj unstructured.Unstructured
err = yaml.Unmarshal(yamlBytes, &obj)
assert.NoError(t, err)
require.NoError(t, err)
resourceTracking := NewResourceTracking()
@ -133,9 +134,7 @@ func TestSetAppInstanceAnnotationNotFound(t *testing.T) {
func TestParseAppInstanceValue(t *testing.T) {
resourceTracking := NewResourceTracking()
appInstanceValue, err := resourceTracking.ParseAppInstanceValue("app:<group>/<kind>:<namespace>/<name>")
if !assert.NoError(t, err) {
t.Fatal()
}
require.NoError(t, err)
assert.Equal(t, "app", appInstanceValue.ApplicationName)
assert.Equal(t, "<group>", appInstanceValue.Group)
assert.Equal(t, "<kind>", appInstanceValue.Kind)
@ -146,9 +145,7 @@ func TestParseAppInstanceValue(t *testing.T) {
func TestParseAppInstanceValueColon(t *testing.T) {
resourceTracking := NewResourceTracking()
appInstanceValue, err := resourceTracking.ParseAppInstanceValue("app:<group>/<kind>:<namespace>/<name>:<colon>")
if !assert.NoError(t, err) {
t.Fatal()
}
require.NoError(t, err)
assert.Equal(t, "app", appInstanceValue.ApplicationName)
assert.Equal(t, "<group>", appInstanceValue.Group)
assert.Equal(t, "<kind>", appInstanceValue.Kind)
@ -159,31 +156,27 @@ func TestParseAppInstanceValueColon(t *testing.T) {
func TestParseAppInstanceValueWrongFormat1(t *testing.T) {
resourceTracking := NewResourceTracking()
_, err := resourceTracking.ParseAppInstanceValue("app")
assert.Error(t, err, WrongResourceTrackingFormat)
require.Error(t, err, WrongResourceTrackingFormat)
}
func TestParseAppInstanceValueWrongFormat2(t *testing.T) {
resourceTracking := NewResourceTracking()
_, err := resourceTracking.ParseAppInstanceValue("app;group/kind/ns")
assert.Error(t, err, WrongResourceTrackingFormat)
require.Error(t, err, WrongResourceTrackingFormat)
}
func TestParseAppInstanceValueCorrectFormat(t *testing.T) {
resourceTracking := NewResourceTracking()
_, err := resourceTracking.ParseAppInstanceValue("app:group/kind:test/ns")
assert.NoError(t, err)
require.NoError(t, err)
}
func sampleResource() *unstructured.Unstructured {
func sampleResource(t *testing.T) *unstructured.Unstructured {
yamlBytes, err := os.ReadFile("testdata/svc.yaml")
if err != nil {
panic(err)
}
require.NoError(t, err)
var obj *unstructured.Unstructured
err = yaml.Unmarshal(yamlBytes, &obj)
if err != nil {
panic(err)
}
require.NoError(t, err)
return obj
}
@ -191,20 +184,20 @@ func TestResourceIdNormalizer_Normalize(t *testing.T) {
rt := NewResourceTracking()
// live object is a resource that has old style tracking label
liveObj := sampleResource()
liveObj := sampleResource(t)
err := rt.SetAppInstance(liveObj, common.LabelKeyAppInstance, "my-app", "", TrackingMethodLabel)
assert.NoError(t, err)
require.NoError(t, err)
// config object is a resource that has new style tracking annotation
configObj := sampleResource()
configObj := sampleResource(t)
err = rt.SetAppInstance(configObj, common.AnnotationKeyAppInstance, "my-app2", "", TrackingMethodAnnotation)
assert.NoError(t, err)
require.NoError(t, err)
_ = rt.Normalize(configObj, liveObj, common.LabelKeyAppInstance, string(TrackingMethodAnnotation))
// the normalization should affect add the new style annotation and drop old tracking label from live object
annotation, err := kube.GetAppInstanceAnnotation(configObj, common.AnnotationKeyAppInstance)
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, liveObj.GetAnnotations()[common.AnnotationKeyAppInstance], annotation)
_, hasOldLabel := liveObj.GetLabels()[common.LabelKeyAppInstance]
assert.False(t, hasOldLabel)
@ -214,22 +207,22 @@ func TestResourceIdNormalizer_Normalize_ConfigHasOldLabel(t *testing.T) {
rt := NewResourceTracking()
// live object is a resource that has old style tracking label
liveObj := sampleResource()
liveObj := sampleResource(t)
err := rt.SetAppInstance(liveObj, common.LabelKeyAppInstance, "my-app", "", TrackingMethodLabel)
assert.NoError(t, err)
require.NoError(t, err)
// config object is a resource that has new style tracking annotation
configObj := sampleResource()
configObj := sampleResource(t)
err = rt.SetAppInstance(configObj, common.AnnotationKeyAppInstance, "my-app2", "", TrackingMethodAnnotation)
assert.NoError(t, err)
require.NoError(t, err)
err = rt.SetAppInstance(configObj, common.LabelKeyAppInstance, "my-app", "", TrackingMethodLabel)
assert.NoError(t, err)
require.NoError(t, err)
_ = rt.Normalize(configObj, liveObj, common.LabelKeyAppInstance, string(TrackingMethodAnnotation))
// the normalization should affect add the new style annotation and drop old tracking label from live object
annotation, err := kube.GetAppInstanceAnnotation(configObj, common.AnnotationKeyAppInstance)
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, liveObj.GetAnnotations()[common.AnnotationKeyAppInstance], annotation)
_, hasOldLabel := liveObj.GetLabels()[common.LabelKeyAppInstance]
assert.True(t, hasOldLabel)

11
util/cache/appstate/cache_test.go vendored
View file

@ -6,6 +6,7 @@ import (
"github.com/spf13/cobra"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
. "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1"
cacheutil "github.com/argoproj/argo-cd/v2/util/cache"
@ -30,13 +31,13 @@ func TestCache_GetAppManagedResources(t *testing.T) {
assert.Equal(t, ErrCacheMiss, err)
// populate cache
err = cache.SetAppManagedResources("my-appname", []*ResourceDiff{{Name: "my-name"}})
assert.NoError(t, err)
require.NoError(t, err)
// cache miss
err = cache.GetAppManagedResources("other-appname", value)
assert.Equal(t, ErrCacheMiss, err)
// cache hit
err = cache.GetAppManagedResources("my-appname", value)
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, &[]*ResourceDiff{{Name: "my-name"}}, value)
}
@ -48,18 +49,18 @@ func TestCache_GetAppResourcesTree(t *testing.T) {
assert.Equal(t, ErrCacheMiss, err)
// populate cache
err = cache.SetAppResourcesTree("my-appname", &ApplicationTree{Nodes: []ResourceNode{{}}})
assert.NoError(t, err)
require.NoError(t, err)
// cache miss
err = cache.GetAppResourcesTree("other-appname", value)
assert.Equal(t, ErrCacheMiss, err)
// cache hit
err = cache.GetAppResourcesTree("my-appname", value)
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, &ApplicationTree{Nodes: []ResourceNode{{}}}, value)
}
func TestAddCacheFlagsToCmd(t *testing.T) {
cache, err := AddCacheFlagsToCmd(&cobra.Command{})()
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, 1*time.Hour, cache.appStateCacheExpiration)
}

25
util/cache/cache_test.go vendored
View file

@ -9,13 +9,14 @@ import (
"github.com/redis/go-redis/v9"
"github.com/spf13/cobra"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/argoproj/argo-cd/v2/common"
)
func TestAddCacheFlagsToCmd(t *testing.T) {
cache, err := AddCacheFlagsToCmd(&cobra.Command{})()
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, 24*time.Hour, cache.client.(*redisCache).expiration)
}
@ -38,45 +39,45 @@ func TestCacheClient(t *testing.T) {
cache := NewCache(client)
t.Run("SetItem", func(t *testing.T) {
err := cache.SetItem("foo", "bar", &CacheActionOpts{Expiration: 60 * time.Second, DisableOverwrite: true, Delete: false})
assert.NoError(t, err)
require.NoError(t, err)
var output string
err = cache.GetItem("foo", &output)
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, "bar", output)
})
t.Run("SetCacheItem W/Disable Overwrite", func(t *testing.T) {
err := cache.SetItem("foo", "bar", &CacheActionOpts{Expiration: 60 * time.Second, DisableOverwrite: true, Delete: false})
assert.NoError(t, err)
require.NoError(t, err)
var output string
err = cache.GetItem("foo", &output)
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, "bar", output)
err = cache.SetItem("foo", "bar", &CacheActionOpts{Expiration: 60 * time.Second, DisableOverwrite: true, Delete: false})
assert.NoError(t, err)
require.NoError(t, err)
err = cache.GetItem("foo", &output)
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, "bar", output, "output should not have changed with DisableOverwrite set to true")
})
t.Run("GetItem", func(t *testing.T) {
var val string
err := cache.GetItem("foo", &val)
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, "bar", val)
})
t.Run("DeleteItem", func(t *testing.T) {
err := cache.SetItem("foo", "bar", &CacheActionOpts{Expiration: 0, Delete: true})
assert.NoError(t, err)
require.NoError(t, err)
var val string
err = cache.GetItem("foo", &val)
assert.Error(t, err)
require.Error(t, err)
assert.Empty(t, val)
})
t.Run("Check for nil items", func(t *testing.T) {
err := cache.SetItem("foo", nil, &CacheActionOpts{Expiration: 0, Delete: true})
assert.Error(t, err)
require.Error(t, err)
assert.Contains(t, err.Error(), "cannot set nil item")
err = cache.GetItem("foo", nil)
assert.Error(t, err)
require.Error(t, err)
assert.Contains(t, err.Error(), "cannot get item")
})
}

5
util/cache/client_test.go vendored
View file

@ -5,6 +5,7 @@ import (
"time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
type testStruct struct {
@ -27,12 +28,12 @@ func TestCache(t *testing.T) {
})
cacheObj.Foo = "baz"
err = c.Get("key", &obj)
assert.NoError(t, err)
require.NoError(t, err)
assert.EqualValues(t, "foo", obj.Foo)
assert.EqualValues(t, "bar", string(obj.Bar))
err = c.Delete("key")
assert.NoError(t, err)
require.NoError(t, err)
err = c.Get("key", &obj)
assert.Equal(t, err, ErrCacheMiss)
}

5
util/cache/inmemory_test.go vendored
View file

@ -5,6 +5,7 @@ import (
"time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
type foo struct {
@ -20,8 +21,8 @@ func TestInMemoryCache(t *testing.T) {
assert.Equal(t, ErrCacheMiss, err)
// cache hit
err = cache.Set(&Item{Key: "my-key", Object: &foo{Bar: "bar"}})
assert.NoError(t, err)
require.NoError(t, err)
err = cache.Get("my-key", obj)
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, &foo{Bar: "bar"}, obj)
}

33
util/cache/redis_test.go vendored
View file

@ -12,6 +12,7 @@ import (
"github.com/prometheus/client_golang/prometheus"
"github.com/redis/go-redis/v9"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
var (
@ -66,28 +67,28 @@ func TestRedisSetCache(t *testing.T) {
t.Run("Successful set", func(t *testing.T) {
client := NewRedisCache(redis.NewClient(&redis.Options{Addr: mr.Addr()}), 60*time.Second, RedisCompressionNone)
err = client.Set(&Item{Key: "foo", Object: "bar"})
assert.NoError(t, err)
require.NoError(t, err)
})
t.Run("Successful get", func(t *testing.T) {
var res string
client := NewRedisCache(redis.NewClient(&redis.Options{Addr: mr.Addr()}), 10*time.Second, RedisCompressionNone)
err = client.Get("foo", &res)
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, "bar", res)
})
t.Run("Successful delete", func(t *testing.T) {
client := NewRedisCache(redis.NewClient(&redis.Options{Addr: mr.Addr()}), 10*time.Second, RedisCompressionNone)
err = client.Delete("foo")
assert.NoError(t, err)
require.NoError(t, err)
})
t.Run("Cache miss", func(t *testing.T) {
var res string
client := NewRedisCache(redis.NewClient(&redis.Options{Addr: mr.Addr()}), 10*time.Second, RedisCompressionNone)
err = client.Get("foo", &res)
assert.Error(t, err)
require.Error(t, err)
assert.Contains(t, err.Error(), "cache: key is missing")
})
}
@ -104,14 +105,14 @@ func TestRedisSetCacheCompressed(t *testing.T) {
client := NewRedisCache(redisClient, 10*time.Second, RedisCompressionGZip)
testValue := "my-value"
assert.NoError(t, client.Set(&Item{Key: "my-key", Object: testValue}))
require.NoError(t, client.Set(&Item{Key: "my-key", Object: testValue}))
compressedData, err := redisClient.Get(context.Background(), "my-key.gz").Bytes()
assert.NoError(t, err)
require.NoError(t, err)
assert.Greater(t, len(compressedData), len([]byte(testValue)), "compressed data is bigger than uncompressed")
var result string
assert.NoError(t, client.Get("my-key", &result))
require.NoError(t, client.Get("my-key", &result))
assert.Equal(t, testValue, result)
}
@ -136,29 +137,29 @@ func TestRedisMetrics(t *testing.T) {
// client successful request
err = client.Set(&Item{Key: "foo", Object: "bar"})
assert.NoError(t, err)
require.NoError(t, err)
err = client.Get("foo", &res)
assert.NoError(t, err)
require.NoError(t, err)
c, err := ms.redisRequestCounter.GetMetricWithLabelValues("mock", "false")
assert.NoError(t, err)
require.NoError(t, err)
err = c.Write(metric)
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, float64(2), metric.Counter.GetValue())
// faulty client failed request
err = faultyClient.Get("foo", &res)
assert.Error(t, err)
require.Error(t, err)
c, err = ms.redisRequestCounter.GetMetricWithLabelValues("mock", "true")
assert.NoError(t, err)
require.NoError(t, err)
err = c.Write(metric)
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, float64(1), metric.Counter.GetValue())
// both clients histogram count
o, err := ms.redisRequestHistogram.GetMetricWithLabelValues("mock")
assert.NoError(t, err)
require.NoError(t, err)
err = o.(prometheus.Metric).Write(metric)
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, 3, int(metric.Histogram.GetSampleCount()))
}

57
util/cert/cert_test.go
View file

@ -7,6 +7,7 @@ import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/argoproj/argo-cd/v2/common"
)
@ -206,59 +207,59 @@ vs-ssh.visualstudio.com ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC7Hr1oTWqNqOlzGJOf
func Test_TLSCertificate_ValidPEM_ValidCert(t *testing.T) {
// Valid PEM data, single certificate, expect array of length 1
certificates, err := ParseTLSCertificatesFromData(Test_TLSValidSingleCert)
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, certificates, 1)
// Expect good decode
x509Cert, err := DecodePEMCertificateToX509(certificates[0])
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, Test_Cert1CN, x509Cert.Subject.String())
}
func Test_TLSCertificate_ValidPEM_InvalidCert(t *testing.T) {
// Valid PEM data, but invalid certificate
certificates, err := ParseTLSCertificatesFromData(Test_TLSInvalidSingleCert)
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, certificates, 1)
// Expect bad decode
_, err = DecodePEMCertificateToX509(certificates[0])
assert.Error(t, err)
require.Error(t, err)
}
func Test_TLSCertificate_InvalidPEM(t *testing.T) {
// Invalid PEM data, expect array of length 0
certificates, err := ParseTLSCertificatesFromData(Test_TLSInvalidPEMData)
assert.NoError(t, err)
require.NoError(t, err)
assert.Empty(t, certificates)
}
func Test_TLSCertificate_ValidPEM_ValidCert_Multi(t *testing.T) {
// Valid PEM data, two certificates, expect array of length 2
certificates, err := ParseTLSCertificatesFromData(Test_TLSValidMultiCert)
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, certificates, 2)
// Expect good decode
x509Cert, err := DecodePEMCertificateToX509(certificates[0])
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, Test_Cert1CN, x509Cert.Subject.String())
x509Cert, err = DecodePEMCertificateToX509(certificates[1])
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, Test_Cert2CN, x509Cert.Subject.String())
}
func Test_TLSCertificate_ValidPEM_ValidCert_FromFile(t *testing.T) {
// Valid PEM data, single certificate from file, expect array of length 1
certificates, err := ParseTLSCertificatesFromPath("../../test/certificates/cert1.pem")
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, certificates, 1)
// Expect good decode
x509Cert, err := DecodePEMCertificateToX509(certificates[0])
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, Test_Cert1CN, x509Cert.Subject.String())
}
func Test_TLSCertPool(t *testing.T) {
certificates, err := ParseTLSCertificatesFromData(Test_TLSValidMultiCert)
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, certificates, 2)
certPool := GetCertPoolFromPEMData(certificates)
assert.NotNil(t, certPool)
@ -267,27 +268,27 @@ func Test_TLSCertPool(t *testing.T) {
func Test_TLSCertificate_CertFromNonExistingFile(t *testing.T) {
// Non-existing file, expect err
_, err := ParseTLSCertificatesFromPath("../../test/certificates/cert_nonexisting.pem")
assert.Error(t, err)
require.Error(t, err)
}
func Test_SSHKnownHostsData_ParseData(t *testing.T) {
// Expect valid data with 7 known host entries
entries, err := ParseSSHKnownHostsFromData(Test_ValidSSHKnownHostsData)
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, entries, 7)
}
func Test_SSHKnownHostsData_ParseFile(t *testing.T) {
// Expect valid data with 7 known host entries
entries, err := ParseSSHKnownHostsFromPath("../../test/certificates/ssh_known_hosts")
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, entries, 7)
}
func Test_SSHKnownHostsData_ParseNonExistingFile(t *testing.T) {
// Expect valid data with 7 known host entries
entries, err := ParseSSHKnownHostsFromPath("../../test/certificates/ssh_known_hosts_invalid")
assert.Error(t, err)
require.Error(t, err)
assert.Nil(t, entries)
}
@ -295,15 +296,15 @@ func Test_SSHKnownHostsData_Tokenize(t *testing.T) {
// All entries should parse to valid SSH public keys
// All entries should be tokenizable, and tokens should be feedable to decoder
entries, err := ParseSSHKnownHostsFromData(Test_ValidSSHKnownHostsData)
assert.NoError(t, err)
require.NoError(t, err)
for _, entry := range entries {
hosts, _, err := KnownHostsLineToPublicKey(entry)
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, hosts, 1)
hoststring, subtype, certdata, err := TokenizeSSHKnownHostsEntry(entry)
assert.NoError(t, err)
require.NoError(t, err)
hosts, _, err = TokenizedDataToPublicKey(hoststring, subtype, string(certdata))
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, hosts, 1)
}
}
@ -333,11 +334,11 @@ func Test_SSHFingerprintSHA256(t *testing.T) {
"ohD8VZEXGWo6Ez8GSEJQ9WpafgLFsOfLOtGGQCQo6Og",
}
entries, err := ParseSSHKnownHostsFromData(Test_ValidSSHKnownHostsData)
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, entries, 7)
for idx, entry := range entries {
_, pubKey, err := KnownHostsLineToPublicKey(entry)
assert.NoError(t, err)
require.NoError(t, err)
fp := SSHFingerprintSHA256(pubKey)
assert.Equal(t, fp, fingerprints[idx])
}
@ -355,7 +356,7 @@ func Test_SSHFingerPrintSHA256FromString(t *testing.T) {
"ohD8VZEXGWo6Ez8GSEJQ9WpafgLFsOfLOtGGQCQo6Og",
}
entries, err := ParseSSHKnownHostsFromData(Test_ValidSSHKnownHostsData)
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, entries, 7)
for idx, entry := range entries {
fp := SSHFingerprintSHA256FromString(entry)
@ -482,7 +483,7 @@ func TestGetCertificateForConnect(t *testing.T) {
}
t.Setenv(common.EnvVarTLSDataPath, temppath)
certs, err := GetCertificateForConnect("127.0.0.1")
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, certs, 1)
})
@ -490,7 +491,7 @@ func TestGetCertificateForConnect(t *testing.T) {
temppath := t.TempDir()
t.Setenv(common.EnvVarTLSDataPath, temppath)
certs, err := GetCertificateForConnect("127.0.0.1")
assert.NoError(t, err)
require.NoError(t, err)
assert.Empty(t, certs)
})
@ -502,7 +503,7 @@ func TestGetCertificateForConnect(t *testing.T) {
}
t.Setenv(common.EnvVarTLSDataPath, temppath)
certs, err := GetCertificateForConnect("127.0.0.1")
assert.Error(t, err)
require.Error(t, err)
assert.Empty(t, certs)
assert.Contains(t, err.Error(), "no certificates found")
})
@ -521,7 +522,7 @@ func TestGetCertBundlePathForRepository(t *testing.T) {
}
t.Setenv(common.EnvVarTLSDataPath, temppath)
certpath, err := GetCertBundlePathForRepository("127.0.0.1")
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, certpath, path.Join(temppath, "127.0.0.1"))
})
@ -529,7 +530,7 @@ func TestGetCertBundlePathForRepository(t *testing.T) {
temppath := t.TempDir()
t.Setenv(common.EnvVarTLSDataPath, temppath)
certpath, err := GetCertBundlePathForRepository("127.0.0.1")
assert.NoError(t, err)
require.NoError(t, err)
assert.Empty(t, certpath)
})
@ -541,7 +542,7 @@ func TestGetCertBundlePathForRepository(t *testing.T) {
}
t.Setenv(common.EnvVarTLSDataPath, temppath)
certpath, err := GetCertBundlePathForRepository("127.0.0.1")
assert.NoError(t, err)
require.NoError(t, err)
assert.Empty(t, certpath)
})
}

41
util/clusterauth/clusterauth_test.go
View file

@ -7,6 +7,7 @@ import (
"time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
corev1 "k8s.io/api/core/v1"
apierr "k8s.io/apimachinery/pkg/api/errors"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@ -54,7 +55,7 @@ func newServiceAccountSecret() *corev1.Secret {
func TestParseServiceAccountToken(t *testing.T) {
claims, err := ParseServiceAccountToken(testToken)
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, testClaims, *claims)
}
@ -78,36 +79,36 @@ func TestCreateServiceAccount(t *testing.T) {
t.Run("New SA", func(t *testing.T) {
cs := fake.NewSimpleClientset(ns)
err := CreateServiceAccount(cs, "argocd-manager", "kube-system")
assert.NoError(t, err)
require.NoError(t, err)
rsa, err := cs.CoreV1().ServiceAccounts("kube-system").Get(context.Background(), "argocd-manager", metav1.GetOptions{})
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, rsa)
})
t.Run("SA exists already", func(t *testing.T) {
cs := fake.NewSimpleClientset(ns, sa)
err := CreateServiceAccount(cs, "argocd-manager", "kube-system")
assert.NoError(t, err)
require.NoError(t, err)
rsa, err := cs.CoreV1().ServiceAccounts("kube-system").Get(context.Background(), "argocd-manager", metav1.GetOptions{})
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, rsa)
})
t.Run("Invalid name", func(t *testing.T) {
cs := fake.NewSimpleClientset(ns)
err := CreateServiceAccount(cs, "", "kube-system")
assert.NoError(t, err)
require.NoError(t, err)
rsa, err := cs.CoreV1().ServiceAccounts("kube-system").Get(context.Background(), "argocd-manager", metav1.GetOptions{})
assert.Error(t, err)
require.Error(t, err)
assert.Nil(t, rsa)
})
t.Run("Invalid namespace", func(t *testing.T) {
cs := fake.NewSimpleClientset()
err := CreateServiceAccount(cs, "argocd-manager", "invalid")
assert.NoError(t, err)
require.NoError(t, err)
rsa, err := cs.CoreV1().ServiceAccounts("invalid").Get(context.Background(), "argocd-manager", metav1.GetOptions{})
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, rsa)
})
}
@ -148,7 +149,7 @@ func TestInstallClusterManagerRBAC(t *testing.T) {
t.Run("Cluster Scope - Success", func(t *testing.T) {
cs := fake.NewSimpleClientset(ns, secret, sa)
token, err := InstallClusterManagerRBAC(cs, "test", nil, testBearerTokenTimeout)
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, "foobar", token)
})
@ -157,14 +158,14 @@ func TestInstallClusterManagerRBAC(t *testing.T) {
nsecret.Data = make(map[string][]byte)
cs := fake.NewSimpleClientset(ns, nsecret, sa)
token, err := InstallClusterManagerRBAC(cs, "test", nil, testBearerTokenTimeout)
assert.Error(t, err)
require.Error(t, err)
assert.Empty(t, token)
})
t.Run("Namespace Scope - Success", func(t *testing.T) {
cs := fake.NewSimpleClientset(ns, secret, sa)
token, err := InstallClusterManagerRBAC(cs, "test", []string{"nsa"}, testBearerTokenTimeout)
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, "foobar", token)
})
@ -173,7 +174,7 @@ func TestInstallClusterManagerRBAC(t *testing.T) {
nsecret.Data = make(map[string][]byte)
cs := fake.NewSimpleClientset(ns, nsecret, sa)
token, err := InstallClusterManagerRBAC(cs, "test", []string{"nsa"}, testBearerTokenTimeout)
assert.Error(t, err)
require.Error(t, err)
assert.Empty(t, token)
})
}
@ -182,7 +183,7 @@ func TestUninstallClusterManagerRBAC(t *testing.T) {
t.Run("Success", func(t *testing.T) {
cs := fake.NewSimpleClientset(newServiceAccountSecret())
err := UninstallClusterManagerRBAC(cs)
assert.NoError(t, err)
require.NoError(t, err)
})
}
@ -201,7 +202,7 @@ func TestGenerateNewClusterManagerSecret(t *testing.T) {
})
created, err := GenerateNewClusterManagerSecret(kubeclientset, &testClaims)
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, "argocd-manager-token-abc123", created.Name)
assert.Equal(t, "fake-token", string(created.Data["token"]))
}
@ -216,12 +217,12 @@ func TestRotateServiceAccountSecrets(t *testing.T) {
kubeclientset := fake.NewSimpleClientset(newServiceAccount(), newServiceAccountSecret(), generatedSecret)
err := RotateServiceAccountSecrets(kubeclientset, &testClaims, generatedSecret)
assert.NoError(t, err)
require.NoError(t, err)
// Verify service account references new secret and old secret is deleted
saClient := kubeclientset.CoreV1().ServiceAccounts(testClaims.Namespace)
sa, err := saClient.Get(context.Background(), testClaims.ServiceAccountName, metav1.GetOptions{})
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, []corev1.ObjectReference{
{
Name: "argocd-manager-token-abc123",
@ -256,7 +257,7 @@ func TestGetServiceAccountBearerToken(t *testing.T) {
kubeclientset := fake.NewSimpleClientset(sa, dockercfgSecret, tokenSecret)
token, err := GetServiceAccountBearerToken(kubeclientset, "kube-system", sa.Name, testBearerTokenTimeout)
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, testToken, token)
}
@ -291,7 +292,7 @@ func Test_getOrCreateServiceAccountTokenSecret_NoSecretForSA(t *testing.T) {
})
got, err := getOrCreateServiceAccountTokenSecret(cs, ArgoCDManagerServiceAccount, ns.Name)
assert.NoError(t, err)
require.NoError(t, err)
assert.Contains(t, got, "argocd-manager-token-")
obj, err := cs.Tracker().Get(schema.GroupVersionResource{Version: "v1", Resource: "serviceaccounts"},
@ -342,7 +343,7 @@ func Test_getOrCreateServiceAccountTokenSecret_SAHasSecret(t *testing.T) {
cs := fake.NewSimpleClientset(ns, saWithSecret, secret)
got, err := getOrCreateServiceAccountTokenSecret(cs, ArgoCDManagerServiceAccount, ns.Name)
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, "sa-secret", got)
obj, err := cs.Tracker().Get(schema.GroupVersionResource{Version: "v1", Resource: "serviceaccounts"},

5
util/config/reader_test.go
View file

@ -11,6 +11,7 @@ import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestUnmarshalLocalFile(t *testing.T) {
@ -125,9 +126,9 @@ func TestUnmarshalReader(t *testing.T) {
value := "test-reader"
instance := testStruct{value}
data, err := json.Marshal(instance)
assert.NoError(t, err)
require.NoError(t, err)
var reader io.Reader = bytes.NewReader(data)
err = UnmarshalReader(reader, &instance)
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, value, instance.Value)
}

77
util/db/certificate_test.go
View file

@ -5,6 +5,7 @@ import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
v1 "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/runtime"
@ -296,7 +297,7 @@ func Test_ListCertificate(t *testing.T) {
HostNamePattern: "*",
CertType: "ssh",
})
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, certList)
assert.Len(t, certList.Items, Test_NumSSHKnownHostsExpected)
for idx, entry := range certList.Items {
@ -310,7 +311,7 @@ func Test_ListCertificate(t *testing.T) {
HostNamePattern: "*",
CertType: "https",
})
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, certList)
assert.Len(t, certList.Items, Test_NumTLSCertificatesExpected)
@ -320,14 +321,14 @@ func Test_ListCertificate(t *testing.T) {
HostNamePattern: "*",
CertType: "*",
})
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, certList)
assert.Len(t, certList.Items, Test_NumTLSCertificatesExpected+Test_NumSSHKnownHostsExpected)
// List all certificates using nil selector
// Expected: List of 10 entries
certList, err = db.ListRepoCertificates(context.Background(), nil)
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, certList)
assert.Len(t, certList.Items, Test_NumTLSCertificatesExpected+Test_NumSSHKnownHostsExpected)
@ -337,7 +338,7 @@ func Test_ListCertificate(t *testing.T) {
HostNamePattern: "gitlab.com",
CertType: "*",
})
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, certList)
assert.Len(t, certList.Items, 4)
for _, entry := range certList.Items {
@ -349,7 +350,7 @@ func Test_ListCertificate(t *testing.T) {
HostNamePattern: "gitlab.com",
CertType: "https",
})
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, certList)
assert.Len(t, certList.Items, 1)
assert.Equal(t, "gitlab.com", certList.Items[0].ServerName)
@ -371,7 +372,7 @@ func Test_CreateSSHKnownHostEntries(t *testing.T) {
},
},
}, false)
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, certList)
assert.Len(t, certList.Items, 1)
@ -385,7 +386,7 @@ func Test_CreateSSHKnownHostEntries(t *testing.T) {
},
},
}, false)
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, certList)
assert.Len(t, certList.Items, 1)
@ -400,7 +401,7 @@ func Test_CreateSSHKnownHostEntries(t *testing.T) {
},
},
}, false)
assert.Error(t, err)
require.Error(t, err)
assert.Nil(t, certList)
// Check if it really was added
@ -409,7 +410,7 @@ func Test_CreateSSHKnownHostEntries(t *testing.T) {
HostNamePattern: "foo.example.com",
CertType: "ssh",
})
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, certList)
assert.Len(t, certList.Items, 1)
@ -424,7 +425,7 @@ func Test_CreateSSHKnownHostEntries(t *testing.T) {
},
},
}, false)
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, certList)
assert.Empty(t, certList.Items)
@ -439,7 +440,7 @@ func Test_CreateSSHKnownHostEntries(t *testing.T) {
},
},
}, false)
assert.Error(t, err)
require.Error(t, err)
assert.Nil(t, certList)
// Existing cert, different data, upsert
@ -452,7 +453,7 @@ func Test_CreateSSHKnownHostEntries(t *testing.T) {
},
},
}, true)
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, certList)
assert.Len(t, certList.Items, 1)
@ -467,7 +468,7 @@ func Test_CreateSSHKnownHostEntries(t *testing.T) {
},
},
}, false)
assert.Error(t, err)
require.Error(t, err)
assert.Nil(t, certList)
// Invalid known hosts entry, case 2: invalid base64 data
@ -481,7 +482,7 @@ func Test_CreateSSHKnownHostEntries(t *testing.T) {
},
},
}, false)
assert.Error(t, err)
require.Error(t, err)
assert.Nil(t, certList)
}
@ -501,7 +502,7 @@ func Test_CreateTLSCertificates(t *testing.T) {
},
},
}, false)
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, certList)
assert.Len(t, certList.Items, 1)
@ -516,7 +517,7 @@ func Test_CreateTLSCertificates(t *testing.T) {
},
},
}, false)
assert.Error(t, err)
require.Error(t, err)
assert.Nil(t, certList)
// Check if it really was added
@ -525,7 +526,7 @@ func Test_CreateTLSCertificates(t *testing.T) {
HostNamePattern: "foo.example.com",
CertType: "https",
})
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, certList)
assert.Len(t, certList.Items, 1)
@ -540,7 +541,7 @@ func Test_CreateTLSCertificates(t *testing.T) {
},
},
}, false)
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, certList)
assert.Len(t, certList.Items, 2)
@ -550,7 +551,7 @@ func Test_CreateTLSCertificates(t *testing.T) {
HostNamePattern: "bar.example.com",
CertType: "https",
})
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, certList)
assert.Len(t, certList.Items, 2)
@ -565,7 +566,7 @@ func Test_CreateTLSCertificates(t *testing.T) {
},
},
}, false)
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, certList)
assert.Empty(t, certList.Items)
@ -580,7 +581,7 @@ func Test_CreateTLSCertificates(t *testing.T) {
},
},
}, false)
assert.Error(t, err)
require.Error(t, err)
assert.Nil(t, certList)
// Valid TLS certificate, existing cert, different data, upsert
@ -594,7 +595,7 @@ func Test_CreateTLSCertificates(t *testing.T) {
},
},
}, true)
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, certList)
assert.Len(t, certList.Items, 2)
@ -604,7 +605,7 @@ func Test_CreateTLSCertificates(t *testing.T) {
HostNamePattern: "foo.example.com",
CertType: "https",
})
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, certList)
assert.Len(t, certList.Items, 2)
for _, entry := range certList.Items {
@ -623,7 +624,7 @@ func Test_CreateTLSCertificates(t *testing.T) {
},
},
}, false)
assert.Error(t, err)
require.Error(t, err)
assert.Nil(t, certList)
// Valid PEM data, new cert, but invalid certificate
@ -637,7 +638,7 @@ func Test_CreateTLSCertificates(t *testing.T) {
},
},
}, false)
assert.Error(t, err)
require.Error(t, err)
assert.Nil(t, certList)
// Invalid PEM data, existing cert, upsert
@ -651,7 +652,7 @@ func Test_CreateTLSCertificates(t *testing.T) {
},
},
}, true)
assert.Error(t, err)
require.Error(t, err)
assert.Nil(t, certList)
// Valid PEM data, existing cert, but invalid certificate, upsert
@ -665,7 +666,7 @@ func Test_CreateTLSCertificates(t *testing.T) {
},
},
}, true)
assert.Error(t, err)
require.Error(t, err)
assert.Nil(t, certList)
}
@ -680,7 +681,7 @@ func Test_RemoveSSHKnownHosts(t *testing.T) {
HostNamePattern: "github.com",
CertType: "ssh",
})
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, certList)
assert.Len(t, certList.Items, 1)
@ -690,7 +691,7 @@ func Test_RemoveSSHKnownHosts(t *testing.T) {
HostNamePattern: "github.com",
CertType: "ssh",
})
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, certList)
assert.Empty(t, certList.Items)
@ -700,7 +701,7 @@ func Test_RemoveSSHKnownHosts(t *testing.T) {
CertType: "ssh",
CertSubType: "ssh-ed25519",
})
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, certList)
assert.Len(t, certList.Items, 1)
@ -710,7 +711,7 @@ func Test_RemoveSSHKnownHosts(t *testing.T) {
CertType: "ssh",
CertSubType: "ssh-ed25519",
})
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, certList)
assert.Empty(t, certList.Items)
@ -719,7 +720,7 @@ func Test_RemoveSSHKnownHosts(t *testing.T) {
certList, err = db.RemoveRepoCertificates(context.Background(), &CertificateListSelector{
CertType: "ssh",
})
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, certList)
assert.Len(t, certList.Items, 5)
@ -728,7 +729,7 @@ func Test_RemoveSSHKnownHosts(t *testing.T) {
certList, err = db.ListRepoCertificates(context.Background(), &CertificateListSelector{
CertType: "ssh",
})
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, certList)
assert.Empty(t, certList.Items)
}
@ -744,7 +745,7 @@ func Test_RemoveTLSCertificates(t *testing.T) {
HostNamePattern: "gitlab.com",
CertType: "https",
})
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, certList)
assert.Len(t, certList.Items, 1)
@ -754,7 +755,7 @@ func Test_RemoveTLSCertificates(t *testing.T) {
HostNamePattern: "gitlab.com",
CertType: "https",
})
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, certList)
assert.Empty(t, certList.Items)
@ -764,7 +765,7 @@ func Test_RemoveTLSCertificates(t *testing.T) {
HostNamePattern: "test.example.com",
CertType: "https",
})
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, certList)
assert.Len(t, certList.Items, 2)
@ -774,7 +775,7 @@ func Test_RemoveTLSCertificates(t *testing.T) {
HostNamePattern: "test.example.com",
CertType: "https",
})
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, certList)
assert.Empty(t, certList.Items)
}

28
util/db/cluster_test.go
View file

@ -25,27 +25,27 @@ const (
func Test_URIToSecretName(t *testing.T) {
name, err := URIToSecretName("cluster", "http://foo")
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, "cluster-foo-752281925", name)
name, err = URIToSecretName("cluster", "http://thelongestdomainnameintheworld.argocd-project.com:3000")
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, "cluster-thelongestdomainnameintheworld.argocd-project.com-2721640553", name)
name, err = URIToSecretName("cluster", "http://[fe80::1ff:fe23:4567:890a]")
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, "cluster-fe80--1ff-fe23-4567-890a-3877258831", name)
name, err = URIToSecretName("cluster", "http://[fe80::1ff:fe23:4567:890a]:8000")
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, "cluster-fe80--1ff-fe23-4567-890a-664858999", name)
name, err = URIToSecretName("cluster", "http://[FE80::1FF:FE23:4567:890A]:8000")
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, "cluster-fe80--1ff-fe23-4567-890a-682802007", name)
name, err = URIToSecretName("cluster", "http://:/abc")
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, "cluster--1969338796", name)
}
@ -108,7 +108,7 @@ func TestClusterToSecret(t *testing.T) {
}
s := &v1.Secret{}
err := clusterToSecret(cluster, s)
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, []byte(cluster.Server), s.Data["server"])
assert.Equal(t, []byte(cluster.Name), s.Data["name"])
@ -145,7 +145,7 @@ func Test_secretToCluster_NoConfig(t *testing.T) {
},
}
cluster, err := SecretToCluster(secret)
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, v1alpha1.Cluster{
Name: "test",
Server: "http://mycluster",
@ -193,14 +193,10 @@ func TestUpdateCluster(t *testing.T) {
Server: "http://mycluster",
RefreshRequestedAt: &requestedAt,
})
if !assert.NoError(t, err) {
return
}
require.NoError(t, err)
secret, err := kubeclientset.CoreV1().Secrets(fakeNamespace).Get(context.Background(), "mycluster", metav1.GetOptions{})
if !assert.NoError(t, err) {
return
}
require.NoError(t, err)
assert.Equal(t, secret.Annotations[v1alpha1.AnnotationKeyRefresh], requestedAt.Format(time.RFC3339))
}
@ -255,7 +251,7 @@ func TestRejectCreationForInClusterWhenDisabled(t *testing.T) {
Server: appv1.KubernetesInternalAPIServerAddr,
Name: "incluster-name",
})
assert.Error(t, err)
require.Error(t, err)
}
func runWatchTest(t *testing.T, db ArgoDB, actions []func(old *v1alpha1.Cluster, new *v1alpha1.Cluster)) {
@ -283,7 +279,7 @@ func runWatchTest(t *testing.T, db ArgoDB, actions []func(old *v1alpha1.Cluster,
}
go func() {
assert.NoError(t, db.WatchClusters(ctx, func(cluster *v1alpha1.Cluster) {
require.NoError(t, db.WatchClusters(ctx, func(cluster *v1alpha1.Cluster) {
doNext(nil, cluster)
}, func(oldCluster *v1alpha1.Cluster, newCluster *v1alpha1.Cluster) {
doNext(oldCluster, newCluster)

83
util/db/db_test.go
View file

@ -7,6 +7,7 @@ import (
"time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
appv1 "k8s.io/api/apps/v1"
@ -58,11 +59,11 @@ func TestCreateRepository(t *testing.T) {
Username: "test-username",
Password: "test-password",
})
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, "https://github.com/argoproj/argocd-example-apps", repo.Repo)
secret, err := clientset.CoreV1().Secrets(testNamespace).Get(context.Background(), RepoURLToSecretName(repoSecretPrefix, repo.Repo, ""), metav1.GetOptions{})
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, common.AnnotationValueManagedByArgoCD, secret.Annotations[common.AnnotationKeyManagedBy])
assert.Equal(t, "test-username", string(secret.Data[username]))
@ -80,7 +81,7 @@ func TestCreateProjectScopedRepository(t *testing.T) {
Password: "test-password",
Project: "test-project",
})
assert.NoError(t, err)
require.NoError(t, err)
otherRepo, err := db.CreateRepository(context.Background(), &v1alpha1.Repository{
Repo: "https://github.com/argoproj/argocd-example-apps",
@ -88,19 +89,19 @@ func TestCreateProjectScopedRepository(t *testing.T) {
Password: "other-password",
Project: "other-project",
})
assert.NoError(t, err)
require.NoError(t, err)
_, err = db.CreateRepository(context.Background(), &v1alpha1.Repository{
Repo: "https://github.com/argoproj/argocd-example-apps",
Username: "wrong-username",
Password: "wrong-password",
})
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, "https://github.com/argoproj/argocd-example-apps", repo.Repo)
secret, err := clientset.CoreV1().Secrets(testNamespace).Get(context.Background(), RepoURLToSecretName(repoSecretPrefix, repo.Repo, "test-project"), metav1.GetOptions{})
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, common.AnnotationValueManagedByArgoCD, secret.Annotations[common.AnnotationKeyManagedBy])
assert.Equal(t, "test-username", string(secret.Data[username]))
@ -109,7 +110,7 @@ func TestCreateProjectScopedRepository(t *testing.T) {
assert.Empty(t, secret.Data[sshPrivateKey])
secret, err = clientset.CoreV1().Secrets(testNamespace).Get(context.Background(), RepoURLToSecretName(repoSecretPrefix, otherRepo.Repo, "other-project"), metav1.GetOptions{})
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, common.AnnotationValueManagedByArgoCD, secret.Annotations[common.AnnotationKeyManagedBy])
assert.Equal(t, "other-username", string(secret.Data[username]))
assert.Equal(t, "other-password", string(secret.Data[password]))
@ -126,11 +127,11 @@ func TestCreateRepoCredentials(t *testing.T) {
Username: "test-username",
Password: "test-password",
})
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, "https://github.com/argoproj/", creds.URL)
secret, err := clientset.CoreV1().Secrets(testNamespace).Get(context.Background(), RepoURLToSecretName(credSecretPrefix, creds.URL, ""), metav1.GetOptions{})
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, common.AnnotationValueManagedByArgoCD, secret.Annotations[common.AnnotationKeyManagedBy])
assert.Equal(t, "test-username", string(secret.Data[username]))
@ -140,7 +141,7 @@ func TestCreateRepoCredentials(t *testing.T) {
created, err := db.CreateRepository(context.Background(), &v1alpha1.Repository{
Repo: "https://github.com/argoproj/argo-cd",
})
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, "https://github.com/argoproj/argo-cd", created.Repo)
// There seems to be a race or some other hiccup in the fake K8s clientset used for this test.
@ -148,7 +149,7 @@ func TestCreateRepoCredentials(t *testing.T) {
time.Sleep(1 * time.Second)
repo, err := db.GetRepository(context.Background(), created.Repo, "")
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, "test-username", repo.Username)
assert.Equal(t, "test-password", repo.Password)
}
@ -216,10 +217,10 @@ func TestGetRepositoryCredentials(t *testing.T) {
got, err := db.GetRepositoryCredentials(context.TODO(), tt.repoURL)
if tt.wantErr {
assert.Error(t, err)
require.Error(t, err)
assert.True(t, errors.IsNotFound(err))
} else {
assert.NoError(t, err)
require.NoError(t, err)
}
assert.Equal(t, tt.want, got)
@ -238,7 +239,7 @@ func TestCreateExistingRepository(t *testing.T) {
Username: "test-username",
Password: "test-password",
})
assert.Error(t, err)
require.Error(t, err)
assert.Equal(t, codes.AlreadyExists, status.Convert(err).Code())
}
@ -285,7 +286,7 @@ func TestGetRepository(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := db.GetRepository(context.TODO(), tt.repoURL, "")
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, tt.want, got)
})
}
@ -323,14 +324,14 @@ func TestDeleteRepositoryManagedSecrets(t *testing.T) {
db := NewDB(testNamespace, settings.NewSettingsManager(context.Background(), clientset, testNamespace), clientset)
err := db.DeleteRepository(context.Background(), "https://github.com/argoproj/argocd-example-apps", "")
assert.NoError(t, err)
require.NoError(t, err)
_, err = clientset.CoreV1().Secrets(testNamespace).Get(context.Background(), "managed-secret", metav1.GetOptions{})
assert.Error(t, err)
require.Error(t, err)
assert.True(t, errors.IsNotFound(err))
cm, err := clientset.CoreV1().ConfigMaps(testNamespace).Get(context.Background(), "argocd-cm", metav1.GetOptions{})
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, "", cm.Data["repositories"])
}
@ -359,15 +360,15 @@ func TestDeleteRepositoryUnmanagedSecrets(t *testing.T) {
db := NewDB(testNamespace, settings.NewSettingsManager(context.Background(), clientset, testNamespace), clientset)
err := db.DeleteRepository(context.Background(), "https://github.com/argoproj/argocd-example-apps", "")
assert.NoError(t, err)
require.NoError(t, err)
s, err := clientset.CoreV1().Secrets(testNamespace).Get(context.Background(), "unmanaged-secret", metav1.GetOptions{})
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, "test-username", string(s.Data[username]))
assert.Equal(t, "test-password", string(s.Data[password]))
cm, err := clientset.CoreV1().ConfigMaps(testNamespace).Get(context.Background(), "argocd-cm", metav1.GetOptions{})
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, "", cm.Data["repositories"])
}
@ -403,7 +404,7 @@ func TestUpdateRepositoryWithManagedSecrets(t *testing.T) {
db := NewDB(testNamespace, settings.NewSettingsManager(context.Background(), clientset, testNamespace), clientset)
repo, err := db.GetRepository(context.Background(), "https://github.com/argoproj/argocd-example-apps", "")
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, "test-username", repo.Username)
assert.Equal(t, "test-password", repo.Password)
assert.Equal(t, "test-ssh-private-key", repo.SSHPrivateKey)
@ -411,14 +412,14 @@ func TestUpdateRepositoryWithManagedSecrets(t *testing.T) {
_, err = db.UpdateRepository(context.Background(), &v1alpha1.Repository{
Repo: "https://github.com/argoproj/argocd-example-apps", Password: "", Username: "", SSHPrivateKey: "",
})
assert.NoError(t, err)
require.NoError(t, err)
_, err = clientset.CoreV1().Secrets(testNamespace).Get(context.Background(), "managed-secret", metav1.GetOptions{})
assert.Error(t, err)
require.Error(t, err)
assert.True(t, errors.IsNotFound(err))
cm, err := clientset.CoreV1().ConfigMaps(testNamespace).Get(context.Background(), "argocd-cm", metav1.GetOptions{})
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, "- url: https://github.com/argoproj/argocd-example-apps", strings.Trim(cm.Data["repositories"], "\n"))
}
@ -466,7 +467,7 @@ func TestRepositorySecretsTrim(t *testing.T) {
db := NewDB(testNamespace, settings.NewSettingsManager(context.Background(), clientset, testNamespace), clientset)
repo, err := db.GetRepository(context.Background(), "https://github.com/argoproj/argocd-example-apps", "")
assert.NoError(t, err)
require.NoError(t, err)
teststruct := []struct {
expectedSecret string
retrievedSecret string
@ -520,7 +521,7 @@ func TestGetClusterSuccessful(t *testing.T) {
db := NewDB(testNamespace, settings.NewSettingsManager(context.Background(), clientset, testNamespace), clientset)
cluster, err := db.GetCluster(context.Background(), server)
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, server, cluster.Server)
assert.Equal(t, name, cluster.Name)
}
@ -531,7 +532,7 @@ func TestGetNonExistingCluster(t *testing.T) {
db := NewDB(testNamespace, settings.NewSettingsManager(context.Background(), clientset, testNamespace), clientset)
_, err := db.GetCluster(context.Background(), server)
assert.Error(t, err)
require.Error(t, err)
status, ok := status.FromError(err)
assert.True(t, ok)
assert.Equal(t, codes.NotFound, status.Code())
@ -545,10 +546,10 @@ func TestCreateClusterSuccessful(t *testing.T) {
_, err := db.CreateCluster(context.Background(), &v1alpha1.Cluster{
Server: server,
})
assert.NoError(t, err)
require.NoError(t, err)
secret, err := clientset.CoreV1().Secrets(testNamespace).Get(context.Background(), "cluster-mycluster-3274446258", metav1.GetOptions{})
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, server, string(secret.Data["server"]))
assert.Equal(t, common.AnnotationValueManagedByArgoCD, secret.Annotations[common.AnnotationKeyManagedBy])
@ -577,10 +578,10 @@ func TestDeleteClusterWithManagedSecret(t *testing.T) {
db := NewDB(testNamespace, settings.NewSettingsManager(context.Background(), clientset, testNamespace), clientset)
err := db.DeleteCluster(context.Background(), clusterURL)
assert.NoError(t, err)
require.NoError(t, err)
_, err = clientset.CoreV1().Secrets(testNamespace).Get(context.Background(), clusterName, metav1.GetOptions{})
assert.Error(t, err)
require.Error(t, err)
assert.True(t, errors.IsNotFound(err))
}
@ -605,10 +606,10 @@ func TestDeleteClusterWithUnmanagedSecret(t *testing.T) {
db := NewDB(testNamespace, settings.NewSettingsManager(context.Background(), clientset, testNamespace), clientset)
err := db.DeleteCluster(context.Background(), clusterURL)
assert.NoError(t, err)
require.NoError(t, err)
secret, err := clientset.CoreV1().Secrets(testNamespace).Get(context.Background(), clusterName, metav1.GetOptions{})
assert.NoError(t, err)
require.NoError(t, err)
assert.Empty(t, secret.Labels)
}
@ -621,7 +622,7 @@ func TestFuzzyEquivalence(t *testing.T) {
repo, err := db.CreateRepository(ctx, &v1alpha1.Repository{
Repo: "https://github.com/argoproj/argocd-example-apps",
})
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, "https://github.com/argoproj/argocd-example-apps", repo.Repo)
repo, err = db.CreateRepository(ctx, &v1alpha1.Repository{
@ -637,7 +638,7 @@ func TestFuzzyEquivalence(t *testing.T) {
assert.Nil(t, repo)
repo, err = db.GetRepository(ctx, "https://github.com/argoproj/argocd-example-APPS", "")
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, "https://github.com/argoproj/argocd-example-apps", repo.Repo)
}
@ -677,7 +678,7 @@ func TestListHelmRepositories(t *testing.T) {
db := NewDB(testNamespace, settings.NewSettingsManager(context.Background(), clientset, testNamespace), clientset)
repos, err := db.ListRepositories(context.Background())
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, repos, 1)
repo := repos[0]
assert.Equal(t, "https://argoproj.github.io/argo-helm", repo.Repo)
@ -724,7 +725,7 @@ func TestHelmRepositorySecretsTrim(t *testing.T) {
db := NewDB(testNamespace, settings.NewSettingsManager(context.Background(), clientset, testNamespace), clientset)
repo, err := db.GetRepository(context.Background(), "https://argoproj.github.io/argo-helm", "")
assert.NoError(t, err)
require.NoError(t, err)
teststruct := []struct {
expectedSecret string
retrievedSecret string
@ -771,7 +772,7 @@ func TestGetClusterServersByName(t *testing.T) {
})
db := NewDB(testNamespace, settings.NewSettingsManager(context.Background(), clientset, testNamespace), clientset)
servers, err := db.GetClusterServersByName(context.Background(), "my-cluster-name")
assert.NoError(t, err)
require.NoError(t, err)
assert.ElementsMatch(t, []string{"https://my-cluster-server"}, servers)
}
@ -779,7 +780,7 @@ func TestGetClusterServersByName_InClusterNotConfigured(t *testing.T) {
clientset := getClientset(nil)
db := NewDB(testNamespace, settings.NewSettingsManager(context.Background(), clientset, testNamespace), clientset)
servers, err := db.GetClusterServersByName(context.Background(), "in-cluster")
assert.NoError(t, err)
require.NoError(t, err)
assert.ElementsMatch(t, []string{v1alpha1.KubernetesInternalAPIServerAddr}, servers)
}
@ -803,7 +804,7 @@ func TestGetClusterServersByName_InClusterConfigured(t *testing.T) {
})
db := NewDB(testNamespace, settings.NewSettingsManager(context.Background(), clientset, testNamespace), clientset)
servers, err := db.GetClusterServersByName(context.Background(), "in-cluster-renamed")
assert.NoError(t, err)
require.NoError(t, err)
assert.ElementsMatch(t, []string{v1alpha1.KubernetesInternalAPIServerAddr}, servers)
}

51
util/db/gpgkeys_test.go
View file

@ -6,6 +6,7 @@ import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
v1 "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/runtime"
@ -118,7 +119,7 @@ func Test_ValidatePGPKey(t *testing.T) {
// Good case - single PGP key
{
key, err := validatePGPKey(testdata.Github_asc)
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, key)
assert.Equal(t, "4AEE18F83AFDEB23", key.KeyID)
assert.NotEmpty(t, key.Owner)
@ -128,13 +129,13 @@ func Test_ValidatePGPKey(t *testing.T) {
// Bad case - Garbage
{
key, err := validatePGPKey(testdata.Garbage_asc)
assert.Error(t, err)
require.Error(t, err)
assert.Nil(t, key)
}
// Bad case - more than one key
{
key, err := validatePGPKey(testdata.Multi_asc)
assert.Error(t, err)
require.Error(t, err)
assert.Nil(t, key)
}
}
@ -149,7 +150,7 @@ func Test_ListConfiguredGPGPublicKeys(t *testing.T) {
panic("could not get database")
}
keys, err := db.ListConfiguredGPGPublicKeys(context.Background())
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, keys, 1)
}
// Good case. No certificates in ConfigMap
@ -161,7 +162,7 @@ func Test_ListConfiguredGPGPublicKeys(t *testing.T) {
panic("could not get database")
}
keys, err := db.ListConfiguredGPGPublicKeys(context.Background())
assert.NoError(t, err)
require.NoError(t, err)
assert.Empty(t, keys)
}
// Bad case. Single key in input, wrong mapping to Key ID in CM
@ -173,7 +174,7 @@ func Test_ListConfiguredGPGPublicKeys(t *testing.T) {
panic("could not get database")
}
keys, err := db.ListConfiguredGPGPublicKeys(context.Background())
assert.Error(t, err)
require.Error(t, err)
assert.Empty(t, keys)
}
// Bad case. Garbage public key
@ -185,7 +186,7 @@ func Test_ListConfiguredGPGPublicKeys(t *testing.T) {
panic("could not get database")
}
keys, err := db.ListConfiguredGPGPublicKeys(context.Background())
assert.Error(t, err)
require.Error(t, err)
assert.Empty(t, keys)
}
// Bad case. Garbage ConfigMap key in data
@ -197,7 +198,7 @@ func Test_ListConfiguredGPGPublicKeys(t *testing.T) {
panic("could not get database")
}
keys, err := db.ListConfiguredGPGPublicKeys(context.Background())
assert.Error(t, err)
require.Error(t, err)
assert.Empty(t, keys)
}
}
@ -211,47 +212,47 @@ func Test_AddGPGPublicKey(t *testing.T) {
// Key should be added
new, skipped, err := db.AddGPGPublicKey(context.Background(), testdata.Github_asc)
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, new, 1)
assert.Empty(t, skipped)
cm, err := settings.GetConfigMapByName(common.ArgoCDGPGKeysConfigMapName)
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, cm.Data, 1)
// Same key should not be added, but skipped
new, skipped, err = db.AddGPGPublicKey(context.Background(), testdata.Github_asc)
assert.NoError(t, err)
require.NoError(t, err)
assert.Empty(t, new)
assert.Len(t, skipped, 1)
cm, err = settings.GetConfigMapByName(common.ArgoCDGPGKeysConfigMapName)
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, cm.Data, 1)
// New keys should be added
new, skipped, err = db.AddGPGPublicKey(context.Background(), testdata.Multi_asc)
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, new, 2)
assert.Empty(t, skipped)
cm, err = settings.GetConfigMapByName(common.ArgoCDGPGKeysConfigMapName)
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, cm.Data, 3)
// Same new keys should be skipped
new, skipped, err = db.AddGPGPublicKey(context.Background(), testdata.Multi_asc)
assert.NoError(t, err)
require.NoError(t, err)
assert.Empty(t, new)
assert.Len(t, skipped, 2)
cm, err = settings.GetConfigMapByName(common.ArgoCDGPGKeysConfigMapName)
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, cm.Data, 3)
// Garbage input should result in error
new, skipped, err = db.AddGPGPublicKey(context.Background(), testdata.Garbage_asc)
assert.Error(t, err)
require.Error(t, err)
assert.Nil(t, new)
assert.Nil(t, skipped)
cm, err = settings.GetConfigMapByName(common.ArgoCDGPGKeysConfigMapName)
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, cm.Data, 3)
}
}
@ -266,28 +267,28 @@ func Test_DeleteGPGPublicKey(t *testing.T) {
// Key should be removed
err := db.DeleteGPGPublicKey(context.Background(), "FDC79815400D88A9")
assert.NoError(t, err)
require.NoError(t, err)
// Key should not exist anymore, therefore can't be deleted again
err = db.DeleteGPGPublicKey(context.Background(), "FDC79815400D88A9")
assert.Error(t, err)
require.Error(t, err)
// One key left in configuration
n, err := db.ListConfiguredGPGPublicKeys(context.Background())
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, n, 1)
// Key should be removed
err = db.DeleteGPGPublicKey(context.Background(), "F7842A5CEAA9C0B1")
assert.NoError(t, err)
require.NoError(t, err)
// Key should not exist anymore, therefore can't be deleted again
err = db.DeleteGPGPublicKey(context.Background(), "F7842A5CEAA9C0B1")
assert.Error(t, err)
require.Error(t, err)
// No key left in configuration
n, err = db.ListConfiguredGPGPublicKeys(context.Background())
assert.NoError(t, err)
require.NoError(t, err)
assert.Empty(t, n)
})
@ -298,6 +299,6 @@ func Test_DeleteGPGPublicKey(t *testing.T) {
// Key should be removed
err := db.DeleteGPGPublicKey(context.Background(), "F7842A5CEAA9C0B1")
assert.Error(t, err)
require.Error(t, err)
})
}

85
util/db/repository_secrets_test.go
View file

@ -6,6 +6,7 @@ import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
corev1 "k8s.io/api/core/v1"
@ -57,7 +58,7 @@ func TestSecretsRepositoryBackend_CreateRepository(t *testing.T) {
output, err := f.repoBackend.CreateRepository(context.Background(), repo)
// then
assert.NoError(t, err)
require.NoError(t, err)
assert.Same(t, repo, output)
secret, err := f.clientSet.CoreV1().Secrets(testNamespace).Get(
@ -66,7 +67,7 @@ func TestSecretsRepositoryBackend_CreateRepository(t *testing.T) {
metav1.GetOptions{},
)
assert.NotNil(t, secret)
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, common.AnnotationValueManagedByArgoCD, secret.Annotations[common.AnnotationKeyManagedBy])
assert.Equal(t, common.LabelValueSecretTypeRepository, secret.Labels[common.LabelKeySecretType])
@ -98,7 +99,7 @@ func TestSecretsRepositoryBackend_CreateRepository(t *testing.T) {
output, err := f.repoBackend.CreateRepository(context.Background(), repo)
// then
assert.Error(t, err)
require.Error(t, err)
assert.Nil(t, output)
status, ok := status.FromError(err)
assert.True(t, ok)
@ -139,7 +140,7 @@ func TestSecretsRepositoryBackend_CreateRepository(t *testing.T) {
output, err := f.repoBackend.CreateRepository(context.Background(), repo)
// then
assert.Error(t, err)
require.Error(t, err)
assert.Nil(t, output)
status, ok := status.FromError(err)
assert.True(t, ok)
@ -215,7 +216,7 @@ func TestSecretsRepositoryBackend_GetRepository(t *testing.T) {
}}
repository, err := testee.GetRepository(context.TODO(), "git@github.com:argoproj/argo-cd.git", "")
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, repository)
assert.Equal(t, "ArgoCD", repository.Name)
assert.Equal(t, "git@github.com:argoproj/argo-cd.git", repository.Repo)
@ -223,7 +224,7 @@ func TestSecretsRepositoryBackend_GetRepository(t *testing.T) {
assert.Equal(t, "somePassword", repository.Password)
repository, err = testee.GetRepository(context.TODO(), "git@github.com:argoproj/argoproj.git", "")
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, repository)
assert.Equal(t, "UserManagedRepo", repository.Name)
assert.Equal(t, "git@github.com:argoproj/argoproj.git", repository.Repo)
@ -231,7 +232,7 @@ func TestSecretsRepositoryBackend_GetRepository(t *testing.T) {
assert.Equal(t, "someOtherPassword", repository.Password)
repository, err = testee.GetRepository(context.TODO(), "git@github.com:argoproj/argo-cd.git", "testProject")
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, repository)
assert.Equal(t, "Scoped ArgoCD", repository.Name)
assert.Equal(t, "git@github.com:argoproj/argo-cd.git", repository.Repo)
@ -240,7 +241,7 @@ func TestSecretsRepositoryBackend_GetRepository(t *testing.T) {
assert.Equal(t, "testProject", repository.Project)
repository, err = testee.GetRepository(context.TODO(), "git@github.com:argoproj/argoproj.git", "testProject")
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, repository)
assert.Equal(t, "Scoped UserManagedRepo", repository.Name)
assert.Equal(t, "git@github.com:argoproj/argoproj.git", repository.Repo)
@ -288,7 +289,7 @@ func TestSecretsRepositoryBackend_ListRepositories(t *testing.T) {
}}
repositories, err := testee.ListRepositories(context.TODO(), nil)
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, repositories, 2)
for _, repository := range repositories {
@ -411,54 +412,54 @@ func TestSecretsRepositoryBackend_UpdateRepository(t *testing.T) {
managedRepository.Username = "newUsername"
updateRepository, err := testee.UpdateRepository(context.TODO(), managedRepository)
assert.NoError(t, err)
require.NoError(t, err)
assert.Same(t, managedRepository, updateRepository)
assert.Equal(t, managedRepository.Username, updateRepository.Username)
secret, err := clientset.CoreV1().Secrets(testNamespace).Get(context.TODO(), managedSecretName, metav1.GetOptions{})
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, secret)
assert.Equal(t, "newUsername", string(secret.Data["username"]))
userProvidedRepository.Username = "newOtherUsername"
updateRepository, err = testee.UpdateRepository(context.TODO(), userProvidedRepository)
assert.NoError(t, err)
require.NoError(t, err)
assert.Same(t, userProvidedRepository, updateRepository)
assert.Equal(t, userProvidedRepository.Username, updateRepository.Username)
secret, err = clientset.CoreV1().Secrets(testNamespace).Get(context.TODO(), "user-managed", metav1.GetOptions{})
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, secret)
assert.Equal(t, "newOtherUsername", string(secret.Data["username"]))
updateRepository, err = testee.UpdateRepository(context.TODO(), newRepository)
assert.NoError(t, err)
require.NoError(t, err)
assert.Same(t, newRepository, updateRepository)
secret, err = clientset.CoreV1().Secrets(testNamespace).Get(context.TODO(), newSecretName, metav1.GetOptions{})
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, secret)
assert.Equal(t, "foo", string(secret.Data["username"]))
managedProjectRepository.Username = "newUsername"
updateRepository, err = testee.UpdateRepository(context.TODO(), managedProjectRepository)
assert.NoError(t, err)
require.NoError(t, err)
assert.Same(t, managedProjectRepository, updateRepository)
assert.Equal(t, managedProjectRepository.Username, updateRepository.Username)
secret, err = clientset.CoreV1().Secrets(testNamespace).Get(context.TODO(), managedProjectSecretName, metav1.GetOptions{})
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, secret)
assert.Equal(t, "newUsername", string(secret.Data["username"]))
userProvidedProjectRepository.Username = "newUsernameScoped"
updateRepository, err = testee.UpdateRepository(context.TODO(), userProvidedProjectRepository)
assert.NoError(t, err)
require.NoError(t, err)
assert.Same(t, userProvidedProjectRepository, updateRepository)
assert.Equal(t, userProvidedProjectRepository.Username, updateRepository.Username)
secret, err = clientset.CoreV1().Secrets(testNamespace).Get(context.TODO(), "user-managed-scoped", metav1.GetOptions{})
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, secret)
assert.Equal(t, "newUsernameScoped", string(secret.Data["username"]))
}
@ -519,25 +520,25 @@ func TestSecretsRepositoryBackend_DeleteRepository(t *testing.T) {
}}
err := testee.DeleteRepository(context.TODO(), "git@github.com:argoproj/argo-cd.git", "")
assert.NoError(t, err)
require.NoError(t, err)
_, err = clientset.CoreV1().Secrets(testNamespace).Get(context.TODO(), managedSecretName, metav1.GetOptions{})
assert.Error(t, err)
require.Error(t, err)
_, err = clientset.CoreV1().Secrets(testNamespace).Get(context.TODO(), managedScopedSecretName, metav1.GetOptions{})
assert.NoError(t, err)
require.NoError(t, err)
err = testee.DeleteRepository(context.TODO(), "git@github.com:argoproj/argo-cd.git", "someProject")
assert.NoError(t, err)
require.NoError(t, err)
_, err = clientset.CoreV1().Secrets(testNamespace).Get(context.TODO(), managedScopedSecretName, metav1.GetOptions{})
assert.Error(t, err)
require.Error(t, err)
err = testee.DeleteRepository(context.TODO(), "git@github.com:argoproj/argoproj.git", "")
assert.NoError(t, err)
require.NoError(t, err)
secret, err := clientset.CoreV1().Secrets(testNamespace).Get(context.TODO(), "user-managed", metav1.GetOptions{})
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, secret)
assert.Empty(t, secret.Labels[common.LabelValueSecretTypeRepository])
}
@ -580,7 +581,7 @@ func TestSecretsRepositoryBackend_CreateRepoCreds(t *testing.T) {
for _, testCase := range testCases {
t.Run(testCase.name, func(t *testing.T) {
output, err := testee.CreateRepoCreds(context.TODO(), &testCase.repoCreds)
assert.NoError(t, err)
require.NoError(t, err)
assert.Same(t, &testCase.repoCreds, output)
secret, err := clientset.CoreV1().Secrets(testNamespace).Get(
@ -589,7 +590,7 @@ func TestSecretsRepositoryBackend_CreateRepoCreds(t *testing.T) {
metav1.GetOptions{},
)
assert.NotNil(t, secret)
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, common.AnnotationValueManagedByArgoCD, secret.Annotations[common.AnnotationKeyManagedBy])
assert.Equal(t, common.LabelValueSecretTypeRepoCreds, secret.Labels[common.LabelKeySecretType])
@ -656,14 +657,14 @@ func TestSecretsRepositoryBackend_GetRepoCreds(t *testing.T) {
}}
repoCred, err := testee.GetRepoCreds(context.TODO(), "git@github.com:argoproj")
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, repoCred)
assert.Equal(t, "git@github.com:argoproj", repoCred.URL)
assert.Equal(t, "someUsername", repoCred.Username)
assert.Equal(t, "somePassword", repoCred.Password)
repoCred, err = testee.GetRepoCreds(context.TODO(), "git@gitlab.com")
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, repoCred)
assert.Equal(t, "git@gitlab.com", repoCred.URL)
assert.Equal(t, "someOtherUsername", repoCred.Username)
@ -707,7 +708,7 @@ func TestSecretsRepositoryBackend_ListRepoCreds(t *testing.T) {
}}
repoCreds, err := testee.ListRepoCreds(context.TODO())
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, repoCreds, 2)
assert.Contains(t, repoCreds, "git@github.com:argoproj")
assert.Contains(t, repoCreds, "git@gitlab.com")
@ -769,32 +770,32 @@ func TestSecretsRepositoryBackend_UpdateRepoCreds(t *testing.T) {
managedCreds.Username = "newUsername"
updateRepoCreds, err := testee.UpdateRepoCreds(context.TODO(), managedCreds)
assert.NoError(t, err)
require.NoError(t, err)
assert.NotSame(t, managedCreds, updateRepoCreds)
assert.Equal(t, managedCreds.Username, updateRepoCreds.Username)
secret, err := clientset.CoreV1().Secrets(testNamespace).Get(context.TODO(), managedCredsName, metav1.GetOptions{})
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, secret)
assert.Equal(t, "newUsername", string(secret.Data["username"]))
userProvidedCreds.Username = "newOtherUsername"
updateRepoCreds, err = testee.UpdateRepoCreds(context.TODO(), userProvidedCreds)
assert.NoError(t, err)
require.NoError(t, err)
assert.NotSame(t, userProvidedCreds, updateRepoCreds)
assert.Equal(t, userProvidedCreds.Username, updateRepoCreds.Username)
secret, err = clientset.CoreV1().Secrets(testNamespace).Get(context.TODO(), "user-managed", metav1.GetOptions{})
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, secret)
assert.Equal(t, "newOtherUsername", string(secret.Data["username"]))
updateRepoCreds, err = testee.UpdateRepoCreds(context.TODO(), newCreds)
assert.NoError(t, err)
require.NoError(t, err)
assert.Same(t, newCreds, updateRepoCreds)
secret, err = clientset.CoreV1().Secrets(testNamespace).Get(context.TODO(), newCredsName, metav1.GetOptions{})
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, secret)
assert.Equal(t, "foo", string(secret.Data["username"]))
}
@ -837,16 +838,16 @@ func TestSecretsRepositoryBackend_DeleteRepoCreds(t *testing.T) {
}}
err := testee.DeleteRepoCreds(context.TODO(), "git@github.com:argoproj")
assert.NoError(t, err)
require.NoError(t, err)
_, err = clientset.CoreV1().Secrets(testNamespace).Get(context.TODO(), managedSecretName, metav1.GetOptions{})
assert.Error(t, err)
require.Error(t, err)
err = testee.DeleteRepoCreds(context.TODO(), "git@gitlab.com")
assert.NoError(t, err)
require.NoError(t, err)
secret, err := clientset.CoreV1().Secrets(testNamespace).Get(context.TODO(), "user-managed", metav1.GetOptions{})
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, secret)
assert.Empty(t, secret.Labels[common.LabelValueSecretTypeRepoCreds])
}
@ -891,7 +892,7 @@ func TestSecretsRepositoryBackend_GetAllHelmRepoCreds(t *testing.T) {
}}
repoCreds, err := testee.GetAllHelmRepoCreds(context.TODO())
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, repoCreds, 1)
}

39
util/db/repository_test.go
View file

@ -5,6 +5,7 @@ import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
corev1 "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@ -64,12 +65,12 @@ func TestDb_CreateRepository(t *testing.T) {
// The repository was indeed created successfully
output, err := testee.CreateRepository(context.TODO(), input)
assert.NoError(t, err)
require.NoError(t, err)
assert.Same(t, input, output)
// New repositories should not be stored in the settings anymore
settingRepositories, err := settingsManager.GetRepositories()
assert.NoError(t, err)
require.NoError(t, err)
assert.Empty(t, settingRepositories)
// New repositories should be now stored as secrets
@ -79,7 +80,7 @@ func TestDb_CreateRepository(t *testing.T) {
metav1.GetOptions{},
)
assert.NotNil(t, secret)
assert.NoError(t, err)
require.NoError(t, err)
}
func TestDb_GetRepository(t *testing.T) {
@ -92,17 +93,17 @@ func TestDb_GetRepository(t *testing.T) {
}
repository, err := testee.GetRepository(context.TODO(), "git@github.com:argoproj/argoproj.git", "")
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, repository)
assert.Equal(t, "OtherRepo", repository.Name)
repository, err = testee.GetRepository(context.TODO(), "git@github.com:argoproj/argo-cd.git", "")
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, repository)
assert.Equal(t, "SomeRepo", repository.Name)
repository, err = testee.GetRepository(context.TODO(), "git@github.com:argoproj/not-existing.git", "")
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, repository)
assert.Equal(t, "git@github.com:argoproj/not-existing.git", repository.Repo)
}
@ -117,7 +118,7 @@ func TestDb_ListRepositories(t *testing.T) {
}
repositories, err := testee.ListRepositories(context.TODO())
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, repositories, 2)
}
@ -148,7 +149,7 @@ func TestDb_UpdateRepository(t *testing.T) {
// Verify that legacy repository can still be updated
settingRepository.Username = "OtherUpdatedUsername"
repository, err := testee.UpdateRepository(context.TODO(), settingRepository)
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, repository)
assert.Same(t, settingRepository, repository)
@ -157,14 +158,14 @@ func TestDb_UpdateRepository(t *testing.T) {
"managed-secret",
metav1.GetOptions{},
)
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, secret)
assert.Equal(t, "OtherUpdatedUsername", string(secret.Data["username"]))
// Verify that secret-based repository can be updated
secretRepository.Username = "UpdatedUsername"
repository, err = testee.UpdateRepository(context.TODO(), secretRepository)
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, repository)
assert.Same(t, secretRepository, repository)
@ -173,7 +174,7 @@ func TestDb_UpdateRepository(t *testing.T) {
"some-repo-secret",
metav1.GetOptions{},
)
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, secret)
assert.Equal(t, "UpdatedUsername", string(secret.Data["username"]))
}
@ -188,17 +189,17 @@ func TestDb_DeleteRepository(t *testing.T) {
}
err := testee.DeleteRepository(context.TODO(), "git@github.com:argoproj/argoproj.git", "")
assert.NoError(t, err)
require.NoError(t, err)
repositories, err := settingsManager.GetRepositories()
assert.NoError(t, err)
require.NoError(t, err)
assert.Empty(t, repositories)
err = testee.DeleteRepository(context.TODO(), "git@github.com:argoproj/argo-cd.git", "")
assert.NoError(t, err)
require.NoError(t, err)
_, err = clientset.CoreV1().Secrets(testNamespace).Get(context.TODO(), "some-repo-secret", metav1.GetOptions{})
assert.Error(t, err)
require.Error(t, err)
}
func TestDb_GetRepositoryCredentials(t *testing.T) {
@ -232,17 +233,17 @@ func TestDb_GetRepositoryCredentials(t *testing.T) {
testee := NewDB(testNamespace, settings.NewSettingsManager(context.TODO(), clientset, testNamespace), clientset)
repoCreds, err := testee.GetRepositoryCredentials(context.TODO(), "git@github.com:argoproj/argoproj.git")
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, repoCreds)
assert.Equal(t, "git@github.com:argoproj", repoCreds.URL)
repoCreds, err = testee.GetRepositoryCredentials(context.TODO(), "git@gitlab.com:someorg/foobar.git")
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, repoCreds)
assert.Equal(t, "git@gitlab.com", repoCreds.URL)
repoCreds, err = testee.GetRepositoryCredentials(context.TODO(), "git@github.com:example/not-existing.git")
assert.NoError(t, err)
require.NoError(t, err)
assert.Nil(t, repoCreds)
}
@ -357,7 +358,7 @@ func Test_GetProjectRepositories(t *testing.T) {
argoDB := NewDB(testNamespace, settings.NewSettingsManager(context.TODO(), clientset, testNamespace), clientset)
repos, err := argoDB.GetProjectRepositories(context.TODO(), "some-project")
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, repos, 1)
assert.Equal(t, "git@github.com:argoproj/argo-cd", repos[0].Repo)
}

35
util/dex/dex_test.go
View file

@ -10,6 +10,7 @@ import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"sigs.k8s.io/yaml"
// "github.com/argoproj/argo-cd/common"
@ -155,7 +156,7 @@ func Test_GenerateDexConfig(t *testing.T) {
t.Run("Empty settings", func(t *testing.T) {
s := settings.ArgoCDSettings{}
config, err := GenerateDexConfigYAML(&s, false)
assert.NoError(t, err)
require.NoError(t, err)
assert.Nil(t, config)
})
@ -165,7 +166,7 @@ func Test_GenerateDexConfig(t *testing.T) {
DexConfig: goodDexConfig,
}
config, err := GenerateDexConfigYAML(&s, false)
assert.Error(t, err)
require.Error(t, err)
assert.Nil(t, config)
})
@ -175,7 +176,7 @@ func Test_GenerateDexConfig(t *testing.T) {
DexConfig: "invalidyaml",
}
config, err := GenerateDexConfigYAML(&s, false)
assert.NoError(t, err)
require.NoError(t, err)
assert.Nil(t, config)
})
@ -185,7 +186,7 @@ func Test_GenerateDexConfig(t *testing.T) {
DexConfig: "invalidyaml",
}
config, err := GenerateDexConfigYAML(&s, false)
assert.NoError(t, err)
require.NoError(t, err)
assert.Nil(t, config)
})
@ -195,7 +196,7 @@ func Test_GenerateDexConfig(t *testing.T) {
DexConfig: malformedDexConfig,
}
config, err := GenerateDexConfigYAML(&s, false)
assert.Error(t, err)
require.Error(t, err)
assert.Nil(t, config)
})
@ -205,7 +206,7 @@ func Test_GenerateDexConfig(t *testing.T) {
DexConfig: badDexConfig,
}
config, err := GenerateDexConfigYAML(&s, false)
assert.Error(t, err)
require.Error(t, err)
assert.Nil(t, config)
})
@ -215,7 +216,7 @@ func Test_GenerateDexConfig(t *testing.T) {
DexConfig: goodDexConfig,
}
config, err := GenerateDexConfigYAML(&s, false)
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, config)
})
@ -226,7 +227,7 @@ func Test_GenerateDexConfig(t *testing.T) {
Secrets: goodSecrets,
}
config, err := GenerateDexConfigYAML(&s, false)
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, config)
var dexCfg map[string]interface{}
err = yaml.Unmarshal(config, &dexCfg)
@ -252,7 +253,7 @@ func Test_GenerateDexConfig(t *testing.T) {
Secrets: goodSecretswithCRLF,
}
config, err := GenerateDexConfigYAML(&s, false)
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, config)
var dexCfg map[string]interface{}
err = yaml.Unmarshal(config, &dexCfg)
@ -286,7 +287,7 @@ func Test_GenerateDexConfig(t *testing.T) {
Secrets: goodSecretswithCRLF,
}
config, err := GenerateDexConfigYAML(&s, false)
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, config)
var dexCfg map[string]interface{}
err = yaml.Unmarshal(config, &dexCfg)
@ -308,7 +309,7 @@ func Test_GenerateDexConfig(t *testing.T) {
Secrets: goodSecretswithCRLF,
}
config, err := GenerateDexConfigYAML(&s, false)
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, config)
var dexCfg map[string]interface{}
err = yaml.Unmarshal(config, &dexCfg)
@ -328,7 +329,7 @@ func Test_GenerateDexConfig(t *testing.T) {
DexConfig: goodDexConfigWithOauthOverrides,
}
config, err := GenerateDexConfigYAML(&s, false)
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, config)
var dexCfg map[string]interface{}
err = yaml.Unmarshal(config, &dexCfg)
@ -351,7 +352,7 @@ func Test_GenerateDexConfig(t *testing.T) {
DexConfig: goodDexConfigWithEnabledApprovalScreen,
}
config, err := GenerateDexConfigYAML(&s, false)
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, config)
var dexCfg map[string]interface{}
err = yaml.Unmarshal(config, &dexCfg)
@ -385,7 +386,7 @@ func Test_DexReverseProxy(t *testing.T) {
target, _ := url.Parse(fakeDex.URL)
resp, err := http.Get(server.URL)
assert.NotNil(t, resp)
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, http.StatusOK, resp.StatusCode)
assert.Equal(t, host, target.Host)
fmt.Printf("%s\n", resp.Status)
@ -407,7 +408,7 @@ func Test_DexReverseProxy(t *testing.T) {
}
resp, err := client.Get(server.URL)
assert.NotNil(t, resp)
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, http.StatusSeeOther, resp.StatusCode)
location, _ := resp.Location()
fmt.Printf("%s %s\n", resp.Status, location.RequestURI())
@ -429,9 +430,9 @@ func Test_DexReverseProxy(t *testing.T) {
rt := NewDexRewriteURLRoundTripper(server.URL, http.DefaultTransport)
assert.NotNil(t, rt)
req, err := http.NewRequest(http.MethodGet, "/", bytes.NewBuffer([]byte("")))
assert.NoError(t, err)
require.NoError(t, err)
_, err = rt.RoundTrip(req)
assert.NoError(t, err)
require.NoError(t, err)
target, _ := url.Parse(server.URL)
assert.Equal(t, req.Host, target.Host)
})

26
util/git/client_test.go
View file

@ -46,7 +46,7 @@ func Test_nativeGitClient_Fetch(t *testing.T) {
require.NoError(t, err)
err = client.Fetch("")
assert.NoError(t, err)
require.NoError(t, err)
}
func Test_nativeGitClient_Fetch_Prune(t *testing.T) {
@ -63,7 +63,7 @@ func Test_nativeGitClient_Fetch_Prune(t *testing.T) {
require.NoError(t, err)
err = client.Fetch("")
assert.NoError(t, err)
require.NoError(t, err)
err = runCmd(tempDir, "git", "branch", "-d", "test/foo")
require.NoError(t, err)
@ -71,7 +71,7 @@ func Test_nativeGitClient_Fetch_Prune(t *testing.T) {
require.NoError(t, err)
err = client.Fetch("")
assert.NoError(t, err)
require.NoError(t, err)
}
func Test_IsAnnotatedTag(t *testing.T) {
@ -109,9 +109,9 @@ func Test_IsAnnotatedTag(t *testing.T) {
assert.True(t, atag)
err = runCmd(client.Root(), "git", "rm", "README")
assert.NoError(t, err)
require.NoError(t, err)
err = runCmd(client.Root(), "git", "commit", "-m", "remove README", "-a")
assert.NoError(t, err)
require.NoError(t, err)
// We moved on, so tag doesn't point to HEAD anymore
atag = client.IsAnnotatedTag("HEAD")
@ -216,28 +216,28 @@ func Test_nativeGitClient_Submodule(t *testing.T) {
require.NoError(t, err)
err = client.Fetch("")
assert.NoError(t, err)
require.NoError(t, err)
commitSHA, err := client.LsRemote("HEAD")
assert.NoError(t, err)
require.NoError(t, err)
// Call Checkout() with submoduleEnabled=false.
err = client.Checkout(commitSHA, false)
assert.NoError(t, err)
require.NoError(t, err)
// Check if submodule url does not exist in .git/config
err = runCmd(client.Root(), "git", "config", "submodule.bar.url")
assert.Error(t, err)
require.Error(t, err)
// Call Submodule() via Checkout() with submoduleEnabled=true.
err = client.Checkout(commitSHA, true)
assert.NoError(t, err)
require.NoError(t, err)
// Check if the .gitmodule URL is reflected in .git/config
cmd := exec.Command("git", "config", "submodule.bar.url")
cmd.Dir = client.Root()
result, err := cmd.Output()
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, bar+"\n", string(result))
// Change URL of submodule bar
@ -246,13 +246,13 @@ func Test_nativeGitClient_Submodule(t *testing.T) {
// Call Submodule()
err = client.Submodule()
assert.NoError(t, err)
require.NoError(t, err)
// Check if the URL change in .gitmodule is reflected in .git/config
cmd = exec.Command("git", "config", "submodule.bar.url")
cmd.Dir = client.Root()
result, err = cmd.Output()
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, bar+"baz\n", string(result))
}

16
util/git/creds_test.go
View file

@ -187,18 +187,18 @@ func TestHTTPSCreds_Environ_clientCert(t *testing.T) {
assert.NotEmpty(t, key)
certBytes, err := os.ReadFile(cert)
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, "clientCertData", string(certBytes))
keyBytes, err := os.ReadFile(key)
assert.Equal(t, "clientCertKey", string(keyBytes))
assert.NoError(t, err)
require.NoError(t, err)
io.Close(closer)
_, err = os.Stat(cert)
assert.ErrorIs(t, err, os.ErrNotExist)
require.ErrorIs(t, err, os.ErrNotExist)
_, err = os.Stat(key)
assert.ErrorIs(t, err, os.ErrNotExist)
require.ErrorIs(t, err, os.ErrNotExist)
}
func Test_SSHCreds_Environ(t *testing.T) {
@ -364,16 +364,16 @@ func TestNewGoogleCloudCreds_invalidJSON(t *testing.T) {
token, err := googleCloudCreds.getAccessToken()
assert.Equal(t, "", token)
assert.Error(t, err)
require.Error(t, err)
username, err := googleCloudCreds.getUsername()
assert.Equal(t, "", username)
assert.Error(t, err)
require.Error(t, err)
closer, envStringSlice, err := googleCloudCreds.Environ()
assert.Equal(t, NopCloser{}, closer)
assert.Equal(t, []string(nil), envStringSlice)
assert.Error(t, err)
require.Error(t, err)
}
func TestGoogleCloudCreds_Environ_cleanup(t *testing.T) {
@ -386,7 +386,7 @@ func TestGoogleCloudCreds_Environ_cleanup(t *testing.T) {
}, store}
closer, env, err := googleCloudCreds.Environ()
assert.NoError(t, err)
require.NoError(t, err)
var nonce string
for _, envVar := range env {
if strings.HasPrefix(envVar, ASKPASS_NONCE_ENV) {

107
util/git/git_test.go
View file

@ -9,6 +9,7 @@ import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/argoproj/argo-cd/v2/common"
"github.com/argoproj/argo-cd/v2/test/fixture/log"
@ -118,19 +119,19 @@ func TestSameURL(t *testing.T) {
func TestCustomHTTPClient(t *testing.T) {
certFile, err := filepath.Abs("../../test/fixture/certs/argocd-test-client.crt")
assert.NoError(t, err)
require.NoError(t, err)
assert.NotEqual(t, "", certFile)
keyFile, err := filepath.Abs("../../test/fixture/certs/argocd-test-client.key")
assert.NoError(t, err)
require.NoError(t, err)
assert.NotEqual(t, "", keyFile)
certData, err := os.ReadFile(certFile)
assert.NoError(t, err)
require.NoError(t, err)
assert.NotEqual(t, "", string(certData))
keyData, err := os.ReadFile(keyFile)
assert.NoError(t, err)
require.NoError(t, err)
assert.NotEqual(t, "", string(keyData))
// Get HTTPSCreds with client cert creds specified, and insecure connection
@ -147,7 +148,7 @@ func TestCustomHTTPClient(t *testing.T) {
assert.Nil(t, transport.TLSClientConfig.RootCAs)
if transport.TLSClientConfig.GetClientCertificate != nil {
cert, err := transport.TLSClientConfig.GetClientCertificate(nil)
assert.NoError(t, err)
require.NoError(t, err)
if err == nil {
assert.NotNil(t, cert)
assert.NotEmpty(t, cert.Certificate)
@ -155,7 +156,7 @@ func TestCustomHTTPClient(t *testing.T) {
}
}
proxy, err := transport.Proxy(nil)
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, "http://proxy:5000", proxy.String())
}
@ -175,7 +176,7 @@ func TestCustomHTTPClient(t *testing.T) {
assert.Nil(t, transport.TLSClientConfig.RootCAs)
if transport.TLSClientConfig.GetClientCertificate != nil {
cert, err := transport.TLSClientConfig.GetClientCertificate(nil)
assert.NoError(t, err)
require.NoError(t, err)
if err == nil {
assert.NotNil(t, cert)
assert.Empty(t, cert.Certificate)
@ -183,18 +184,18 @@ func TestCustomHTTPClient(t *testing.T) {
}
}
req, err := http.NewRequest(http.MethodGet, "http://proxy-from-env:7878", nil)
assert.NoError(t, err)
require.NoError(t, err)
proxy, err := transport.Proxy(req)
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, "http://proxy-from-env:7878", proxy.String())
}
// GetRepoHTTPClient with root ca
cert, err := os.ReadFile("../../test/fixture/certs/argocd-test-server.crt")
assert.NoError(t, err)
require.NoError(t, err)
temppath := t.TempDir()
defer os.RemoveAll(temppath)
err = os.WriteFile(filepath.Join(temppath, "127.0.0.1"), cert, 0o666)
assert.NoError(t, err)
require.NoError(t, err)
t.Setenv(common.EnvVarTLSDataPath, temppath)
client = GetRepoHTTPClient("https://127.0.0.1", false, creds, "")
assert.NotNil(t, client)
@ -210,7 +211,7 @@ func TestCustomHTTPClient(t *testing.T) {
func TestLsRemote(t *testing.T) {
clnt, err := NewClientExt("https://github.com/argoproj/argo-cd.git", "/tmp", NopCreds{}, false, false, "")
assert.NoError(t, err)
require.NoError(t, err)
testCases := []struct {
name string
@ -273,7 +274,7 @@ func TestLsRemote(t *testing.T) {
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
commitSHA, err := clnt.LsRemote(tc.revision)
assert.NoError(t, err)
require.NoError(t, err)
assert.True(t, IsCommitSHA(commitSHA))
if tc.expectedCommit != "" {
assert.Equal(t, tc.expectedCommit, commitSHA)
@ -284,7 +285,7 @@ func TestLsRemote(t *testing.T) {
// We do not resolve truncated git hashes and return the commit as-is if it appears to be a commit
t.Run("truncated commit", func(t *testing.T) {
commitSHA, err := clnt.LsRemote("4e22a3c")
assert.NoError(t, err)
require.NoError(t, err)
assert.False(t, IsCommitSHA(commitSHA))
assert.True(t, IsTruncatedCommitSHA(commitSHA))
})
@ -311,35 +312,35 @@ func TestLFSClient(t *testing.T) {
tempDir := t.TempDir()
client, err := NewClientExt("https://github.com/argoproj-labs/argocd-testrepo-lfs", tempDir, NopCreds{}, false, true, "")
assert.NoError(t, err)
require.NoError(t, err)
commitSHA, err := client.LsRemote("HEAD")
assert.NoError(t, err)
require.NoError(t, err)
assert.NotEqual(t, "", commitSHA)
err = client.Init()
assert.NoError(t, err)
require.NoError(t, err)
err = client.Fetch("")
assert.NoError(t, err)
require.NoError(t, err)
err = client.Checkout(commitSHA, true)
assert.NoError(t, err)
require.NoError(t, err)
largeFiles, err := client.LsLargeFiles()
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, largeFiles, 3)
fileHandle, err := os.Open(fmt.Sprintf("%s/test3.yaml", tempDir))
assert.NoError(t, err)
require.NoError(t, err)
if err == nil {
defer func() {
if err = fileHandle.Close(); err != nil {
assert.NoError(t, err)
require.NoError(t, err)
}
}()
text, err := io.ReadAll(fileHandle)
assert.NoError(t, err)
require.NoError(t, err)
if err == nil {
assert.Equal(t, "This is not a YAML, sorry.\n", string(text))
}
@ -350,25 +351,25 @@ func TestVerifyCommitSignature(t *testing.T) {
p := t.TempDir()
client, err := NewClientExt("https://github.com/argoproj/argo-cd.git", p, NopCreds{}, false, false, "")
assert.NoError(t, err)
require.NoError(t, err)
err = client.Init()
assert.NoError(t, err)
require.NoError(t, err)
err = client.Fetch("")
assert.NoError(t, err)
require.NoError(t, err)
commitSHA, err := client.LsRemote("HEAD")
assert.NoError(t, err)
require.NoError(t, err)
err = client.Checkout(commitSHA, true)
assert.NoError(t, err)
require.NoError(t, err)
// 28027897aad1262662096745f2ce2d4c74d02b7f is a commit that is signed in the repo
// It doesn't matter whether we know the key or not at this stage
{
out, err := client.VerifyCommitSignature("28027897aad1262662096745f2ce2d4c74d02b7f")
assert.NoError(t, err)
require.NoError(t, err)
assert.NotEmpty(t, out)
assert.Contains(t, out, "gpg: Signature made")
}
@ -376,7 +377,7 @@ func TestVerifyCommitSignature(t *testing.T) {
// 85d660f0b967960becce3d49bd51c678ba2a5d24 is a commit that is not signed
{
out, err := client.VerifyCommitSignature("85d660f0b967960becce3d49bd51c678ba2a5d24")
assert.NoError(t, err)
require.NoError(t, err)
assert.Empty(t, out)
}
}
@ -404,25 +405,25 @@ func TestNewFactory(t *testing.T) {
dirName := t.TempDir()
client, err := NewClientExt(tt.args.url, dirName, NopCreds{}, tt.args.insecureIgnoreHostKey, false, "")
assert.NoError(t, err)
require.NoError(t, err)
commitSHA, err := client.LsRemote("HEAD")
assert.NoError(t, err)
require.NoError(t, err)
err = client.Init()
assert.NoError(t, err)
require.NoError(t, err)
err = client.Fetch("")
assert.NoError(t, err)
require.NoError(t, err)
// Do a second fetch to make sure we can treat `already up-to-date` error as not an error
err = client.Fetch("")
assert.NoError(t, err)
require.NoError(t, err)
err = client.Checkout(commitSHA, true)
assert.NoError(t, err)
require.NoError(t, err)
revisionMetadata, err := client.RevisionMetadata(commitSHA)
assert.NoError(t, err)
require.NoError(t, err)
assert.NotNil(t, revisionMetadata)
assert.Regexp(t, "^.*<.*>$", revisionMetadata.Author)
assert.Empty(t, revisionMetadata.Tags)
@ -430,7 +431,7 @@ func TestNewFactory(t *testing.T) {
assert.NotEmpty(t, revisionMetadata.Message)
commitSHA2, err := client.CommitSHA()
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, commitSHA, commitSHA2)
}
@ -441,10 +442,10 @@ func TestListRevisions(t *testing.T) {
repoURL := "https://github.com/argoproj/argo-cd.git"
client, err := NewClientExt(repoURL, dir, NopCreds{}, false, false, "")
assert.NoError(t, err)
require.NoError(t, err)
lsResult, err := client.LsRefs()
assert.NoError(t, err)
require.NoError(t, err)
testBranch := "master"
testTag := "v1.0.0"
@ -460,48 +461,48 @@ func TestLsFiles(t *testing.T) {
tmpDir2 := t.TempDir()
client, err := NewClientExt("", tmpDir1, NopCreds{}, false, false, "")
assert.NoError(t, err)
require.NoError(t, err)
err = runCmd(tmpDir1, "git", "init")
assert.NoError(t, err)
require.NoError(t, err)
// Prepare files
a, err := os.Create(filepath.Join(tmpDir1, "a.yaml"))
assert.NoError(t, err)
require.NoError(t, err)
a.Close()
err = os.MkdirAll(filepath.Join(tmpDir1, "subdir"), 0o755)
assert.NoError(t, err)
require.NoError(t, err)
b, err := os.Create(filepath.Join(tmpDir1, "subdir", "b.yaml"))
assert.NoError(t, err)
require.NoError(t, err)
b.Close()
err = os.MkdirAll(filepath.Join(tmpDir2, "subdir"), 0o755)
assert.NoError(t, err)
require.NoError(t, err)
c, err := os.Create(filepath.Join(tmpDir2, "c.yaml"))
assert.NoError(t, err)
require.NoError(t, err)
c.Close()
err = os.Symlink(filepath.Join(tmpDir2, "c.yaml"), filepath.Join(tmpDir1, "link.yaml"))
assert.NoError(t, err)
require.NoError(t, err)
err = runCmd(tmpDir1, "git", "add", ".")
assert.NoError(t, err)
require.NoError(t, err)
err = runCmd(tmpDir1, "git", "commit", "-m", "Initial commit")
assert.NoError(t, err)
require.NoError(t, err)
// Old and default globbing
expectedResult := []string{"a.yaml", "link.yaml", "subdir/b.yaml"}
lsResult, err := client.LsFiles("*.yaml", false)
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, expectedResult, lsResult)
// New and safer globbing, do not return symlinks resolving outside of the repo
expectedResult = []string{"a.yaml"}
lsResult, err = client.LsFiles("*.yaml", true)
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, expectedResult, lsResult)
// New globbing, do not return files outside of the repo
var nilResult []string
lsResult, err = client.LsFiles(filepath.Join(tmpDir2, "*.yaml"), true)
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, nilResult, lsResult)
}

82
util/gpg/gpg_test.go
View file

@ -67,11 +67,11 @@ func Test_GPG_InitializeGnuPG(t *testing.T) {
// First run should initialize fine
err := InitializeGnuPG()
assert.NoError(t, err)
require.NoError(t, err)
// We should have exactly one public key with ultimate trust (our own) in the keyring
keys, err := GetInstalledPGPKeys(nil)
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, keys, 1)
assert.Equal(t, "ultimate", keys[0].Trust)
@ -86,19 +86,19 @@ func Test_GPG_InitializeGnuPG(t *testing.T) {
err = InitializeGnuPG()
require.NoError(t, err)
keys, err = GetInstalledPGPKeys(nil)
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, keys, 1)
assert.Equal(t, "ultimate", keys[0].Trust)
t.Run("GNUPGHOME is a file", func(t *testing.T) {
f, err := os.CreateTemp("", "gpg-test")
assert.NoError(t, err)
require.NoError(t, err)
defer os.Remove(f.Name())
// we need to error out
t.Setenv(common.EnvGnuPGHome, f.Name())
err = InitializeGnuPG()
assert.Error(t, err)
require.Error(t, err)
assert.Contains(t, err.Error(), "does not point to a directory")
})
@ -114,7 +114,7 @@ func Test_GPG_InitializeGnuPG(t *testing.T) {
}
t.Setenv(common.EnvGnuPGHome, fp)
err := InitializeGnuPG()
assert.Error(t, err)
require.Error(t, err)
// Restore permissions so path can be deleted
err = os.Chmod(fp, 0o700)
if err != nil {
@ -132,7 +132,7 @@ func Test_GPG_InitializeGnuPG(t *testing.T) {
}
t.Setenv(common.EnvGnuPGHome, p)
err = InitializeGnuPG()
assert.NoError(t, err)
require.NoError(t, err)
})
}
@ -140,11 +140,11 @@ func Test_GPG_KeyManagement(t *testing.T) {
initTempDir(t)
err := InitializeGnuPG()
assert.NoError(t, err)
require.NoError(t, err)
// Import a single good key
keys, err := ImportPGPKeys("testdata/github.asc")
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, keys, 1)
assert.Equal(t, "4AEE18F83AFDEB23", keys[0].KeyID)
assert.Contains(t, keys[0].Owner, "noreply@github.com")
@ -157,14 +157,14 @@ func Test_GPG_KeyManagement(t *testing.T) {
// We should have a total of 2 keys in the keyring now
{
keys, err := GetInstalledPGPKeys(nil)
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, keys, 2)
}
// We should now have that key in our keyring with unknown trust (trustdb not updated)
{
keys, err := GetInstalledPGPKeys([]string{importedKeyId})
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, keys, 1)
assert.Equal(t, "4AEE18F83AFDEB23", keys[0].KeyID)
assert.Contains(t, keys[0].Owner, "noreply@github.com")
@ -178,9 +178,9 @@ func Test_GPG_KeyManagement(t *testing.T) {
// Set trust level for our key and check the result
{
err := SetPGPTrustLevelById(kids, "ultimate")
assert.NoError(t, err)
require.NoError(t, err)
keys, err := GetInstalledPGPKeys(kids)
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, keys, 1)
assert.Equal(t, kids[0], keys[0].Fingerprint)
assert.Equal(t, "ultimate", keys[0].Trust)
@ -188,35 +188,35 @@ func Test_GPG_KeyManagement(t *testing.T) {
// Import garbage - error expected
keys, err = ImportPGPKeys("testdata/garbage.asc")
assert.Error(t, err)
require.Error(t, err)
assert.Empty(t, keys)
// We should still have a total of 2 keys in the keyring now
{
keys, err := GetInstalledPGPKeys(nil)
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, keys, 2)
}
// Delete previously imported public key
{
err := DeletePGPKey(importedKeyId)
assert.NoError(t, err)
require.NoError(t, err)
keys, err := GetInstalledPGPKeys(nil)
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, keys, 1)
}
// Delete non-existing key
{
err := DeletePGPKey(importedKeyId)
assert.Error(t, err)
require.Error(t, err)
}
// Import multiple keys
{
keys, err := ImportPGPKeys("testdata/multi.asc")
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, keys, 2)
assert.Contains(t, keys[0].Owner, "john.doe@example.com")
assert.Contains(t, keys[1].Owner, "jane.doe@example.com")
@ -225,7 +225,7 @@ func Test_GPG_KeyManagement(t *testing.T) {
// Check if they were really imported
{
keys, err := GetInstalledPGPKeys(nil)
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, keys, 3)
}
}
@ -234,11 +234,11 @@ func Test_ImportPGPKeysFromString(t *testing.T) {
initTempDir(t)
err := InitializeGnuPG()
assert.NoError(t, err)
require.NoError(t, err)
// Import a single good key
keys, err := ImportPGPKeysFromString(test.MustLoadFileToString("testdata/github.asc"))
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, keys, 1)
assert.Equal(t, "4AEE18F83AFDEB23", keys[0].KeyID)
assert.Contains(t, keys[0].Owner, "noreply@github.com")
@ -250,19 +250,19 @@ func Test_ValidateGPGKeysFromString(t *testing.T) {
initTempDir(t)
err := InitializeGnuPG()
assert.NoError(t, err)
require.NoError(t, err)
{
keyData := test.MustLoadFileToString("testdata/github.asc")
keys, err := ValidatePGPKeysFromString(keyData)
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, keys, 1)
}
{
keyData := test.MustLoadFileToString("testdata/multi.asc")
keys, err := ValidatePGPKeysFromString(keyData)
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, keys, 2)
}
}
@ -271,12 +271,12 @@ func Test_ValidateGPGKeys(t *testing.T) {
initTempDir(t)
err := InitializeGnuPG()
assert.NoError(t, err)
require.NoError(t, err)
// Validation good case - 1 key
{
keys, err := ValidatePGPKeys("testdata/github.asc")
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, keys, 1)
assert.Contains(t, keys, "4AEE18F83AFDEB23")
}
@ -284,14 +284,14 @@ func Test_ValidateGPGKeys(t *testing.T) {
// Validation bad case
{
keys, err := ValidatePGPKeys("testdata/garbage.asc")
assert.Error(t, err)
require.Error(t, err)
assert.Empty(t, keys)
}
// We should still have a total of 1 keys in the keyring now
{
keys, err := GetInstalledPGPKeys(nil)
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, keys, 1)
}
}
@ -300,10 +300,10 @@ func Test_GPG_ParseGitCommitVerification(t *testing.T) {
initTempDir(t)
err := InitializeGnuPG()
assert.NoError(t, err)
require.NoError(t, err)
keys, err := ImportPGPKeys("testdata/github.asc")
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, keys, 1)
// Good case
@ -519,23 +519,23 @@ func Test_IsSecretKey(t *testing.T) {
// First run should initialize fine
err := InitializeGnuPG()
assert.NoError(t, err)
require.NoError(t, err)
// We should have exactly one public key with ultimate trust (our own) in the keyring
keys, err := GetInstalledPGPKeys(nil)
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, keys, 1)
assert.Equal(t, "ultimate", keys[0].Trust)
{
secret, err := IsSecretKey(keys[0].KeyID)
assert.NoError(t, err)
require.NoError(t, err)
assert.True(t, secret)
}
{
secret, err := IsSecretKey("invalid")
assert.NoError(t, err)
require.NoError(t, err)
assert.False(t, secret)
}
}
@ -545,13 +545,13 @@ func Test_SyncKeyRingFromDirectory(t *testing.T) {
// First run should initialize fine
err := InitializeGnuPG()
assert.NoError(t, err)
require.NoError(t, err)
tempDir := t.TempDir()
{
new, removed, err := SyncKeyRingFromDirectory(tempDir)
assert.NoError(t, err)
require.NoError(t, err)
assert.Empty(t, new)
assert.Empty(t, removed)
}
@ -576,12 +576,12 @@ func Test_SyncKeyRingFromDirectory(t *testing.T) {
}
new, removed, err := SyncKeyRingFromDirectory(tempDir)
assert.NoError(t, err)
require.NoError(t, err)
assert.Len(t, new, 3)
assert.Empty(t, removed)
installed, err := GetInstalledPGPKeys(new)
assert.NoError(t, err)
require.NoError(t, err)
for _, k := range installed {
assert.Contains(t, new, k.KeyID)
}
@ -593,12 +593,12 @@ func Test_SyncKeyRingFromDirectory(t *testing.T) {
panic(err.Error())
}
new, removed, err := SyncKeyRingFromDirectory(tempDir)
assert.NoError(t, err)
require.NoError(t, err)
assert.Empty(t, new)
assert.Len(t, removed, 1)
installed, err := GetInstalledPGPKeys(new)
assert.NoError(t, err)
require.NoError(t, err)
for _, k := range installed {
assert.NotEqual(t, k.KeyID, removed[0])
}