func()

in pkg/targettesting/targettest.go [180:267]

• 73 lines of code
• 15 McCabe index (conditional complexity)

func (tc *ReviewTestcase) run(t *testing.T) {
	// matching_constraints needs differing constraints for the match blocks,
	// to get test coverage, this gets exercised on calls to client.Review
	ctx := context.Background()

	var logOutput bytes.Buffer
	log.SetOutput(&logOutput)
	defer func() {
		log.SetOutput(os.Stderr)
	}()

	// create client
	cfClient := createClient(t, tc.newTargetHandler)

	// add template
	resp, err := cfClient.AddTemplate(ctx, tc.constraintTemplate)
	if err != nil {
		t.Fatalf("loading template %v: %v", tc.constraintTemplate, err)
	}
	if !resp.Handled[tc.targetName] {
		t.Fatal("expected target name")
	}

	// Create synthetic constraint
	constraintSpec := map[string]interface{}{
		"parameters": map[string]interface{}{
			"fail": true,
			"msg":  "it matched",
		},
	}
	if tc.Match != nil {
		constraintSpec["match"] = tc.Match
	}
	constraint := map[string]interface{}{
		"apiVersion": "constraints.gatekeeper.sh/v1beta1",
		"kind":       testConstraintKind,
		"metadata": map[string]interface{}{
			"name": strings.ToLower(testConstraintKind),
		},
		"spec": constraintSpec,
	}

	resp, err = cfClient.AddConstraint(ctx, &unstructured.Unstructured{Object: constraint})

	if tc.WantConstraintError {
		if err == nil {
			t.Fatal("expected constraint add error, got none")
		}
		return
	}
	if err != nil {
		t.Fatal(err)
	}
	if !resp.Handled[tc.targetName] {
		t.Fatal("expected target name")
	}

	// create review from tc, input needs to be GCP hierarchy path
	reviewObj := tc.Object(t)
	resp, err = cfClient.Review(ctx, reviewObj, drivers.Tracing(true))
	if err != nil {
		t.Fatal(err)
	}
	review, ok := resp.ByTarget[tc.targetName]
	if !ok {
		t.Fatal("expected target name in reviews")
	}

	if tc.WantMatch {
		if len(review.Results) != 1 {
			unitTestTraceDump(t, review)
			t.Logf("match block: %v", tc.Match)
			t.Fatalf("expected exactly one results in review, got %d", len(review.Results))
		}
	} else {
		if len(review.Results) != 0 {
			unitTestTraceDump(t, review)
			t.Logf("match block: %v", tc.Match)
			t.Fatalf("unexpected results in review")
		}
	}

	if tc.WantLogged != nil {
		if !tc.WantLogged.Match(logOutput.Bytes()) {
			t.Fatalf("expected log output to match %s; got %s", tc.WantLogged.String(), logOutput.String())
		}
	}
}