diff --git a/AGENTS.md b/AGENTS.md index 1e4db00..ca5567a 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -33,6 +33,26 @@ make release-snapshot # Local release build via goreleaser - Re-use existing patterns. Prefer refactoring over copying - `dry/log` for internal logging (`log.Warnf` for soft failures) - Humanize table cells with `dry/tui/humanize` (`Time`, `Duration`). Never a local formatter. New value shapes extend the dry package. See DEVGUIDE Output section +- Comments explain the current behaviour and its reason. No past-facing wording such as "keep the old behaviour". State the actual constraint instead +- DO NOT leak our conversation, prompt, or iteration history into code comments, pull request descriptions, or other maintainer-facing prose. Write for readers who have not seen our conversation + +## Engineering principles + +- Reuse before you build: the Go standard library, this repository, then modules already in `go.mod` (`safedep/dry`, cobra, testify). Grep for a helper before you write one +- New dependencies must be well known and maintained. Propose one before adding it when it overlaps an existing one. Bump one module with `go get @`, never `go get -u ./...` +- SOLID, DRY by the rule of three, KISS, YAGNI. No options, wrappers or config for a single caller +- Prefer guard clauses and early returns. Use the same name for the same concept everywhere +- Export the smallest surface. Define an interface where it is consumed, with only the methods that caller uses + +## Tests + +- Every test guards a behaviour a regression could break, or a bug that already happened. No smoke tests, no tests that restate the implementation, no tests that only raise coverage +- Test through the entry point a caller uses (the cobra command, the orchestration function) and assert outcomes, not the calls made inside +- Fake a dependency at its port: a small fake of the interface, or an `httptest` server for a remote API. A mock that returns fixed values for every call proves nothing +- A new test must fail when you remove the code it guards. Check that once before you commit +- Before adding a test, check that no existing test covers the behaviour. Extend an existing test before creating a new one +- For a parser or a mapping over free-form input, add a native `Fuzz` test with seeds. CI replays the seeds. Run `go test -fuzz` locally for a while before you commit +- Do not assume a failure is pre-existing. Reproduce it on `main` before calling it flaky, and file an issue For any changes in `.github/workflows/`: diff --git a/docs/cmd/project-scan-create.md b/docs/cmd/project-scan-create.md index f335671..0e52058 100644 --- a/docs/cmd/project-scan-create.md +++ b/docs/cmd/project-scan-create.md @@ -5,7 +5,7 @@ Submit scans for one or more SafeDep projects to SafeDep Cloud-hosted scanners. ## Synopsis ``` -safedep project scan create [PROJECT_NAME...] [--project-id ID] [--output table|plain|json] +safedep project scan create [PROJECT_NAME...] [--project-id ID] [--branch NAME | --tag NAME | --ref REF] [--output table|plain|json] ``` ## Arguments @@ -27,9 +27,36 @@ does not scan the project locally or invoke `vet`. | Flag | Description | |------|-------------| | `--project-id ` | Project ID to scan instead of a name. Repeat the flag to select multiple projects by ID. | +| `--branch ` | Branch to scan in every selected project. | +| `--tag ` | Tag to scan in every selected project. | +| `--ref ` | Full ref to scan in every selected project, such as `refs/tags/v1.2.0`. A plain name is a branch. | Inherits root flags `--output` and `--profile`. +## Choose a branch or tag + +Pass at most one of these flags. Without any of them, each project scans the +default branch that its repository reports at admission. + +| Flag | Example | Scans | +|------|---------|-------| +| `--branch ` | `--branch release/1.2` | The branch `release/1.2`. | +| `--tag ` | `--tag v1.2.0` | The tag `v1.2.0`. | +| `--ref ` | `--ref refs/tags/v1.2.0` | Exactly that ref, which must start with `refs/heads/` or `refs/tags/`. Use it when you already have a full ref. A plain name is a branch: `--ref main` scans `refs/heads/main`. | + +`--branch` and `--tag` take a short name. Pass a full ref with `--ref`. + +Control Tower resolves the ref to a commit at admission, and the scan reads that +commit even if the branch moves later. Results are stored under the short name, +for example `release/1.2`. A name that is both a branch and a tag is rejected, +because the two would share that short name. + +The ref applies to every selected project. If one repository does not have the +ref, Control Tower rejects the whole batch and the error names the project. + +Only GitHub projects take a ref today. A batch with a ref that selects a +Bitbucket project fails as not scannable. + ## Discover project IDs List GitHub-backed projects with the query service: @@ -63,6 +90,36 @@ safedep project scan create safedep/control-tower safedep/cli \ --project-id 01K88WX3G9RGAK8T3N5YJMFQN1 ``` +Scan a release branch in two projects: + +```bash +safedep project scan create safedep/control-tower safedep/cli --branch release/1.2 +``` + +Scan a tag: + +```bash +safedep project scan create safedep/cli --tag v1.2.0 +``` + +Scan the branch or tag that a GitHub Actions push or tag workflow runs on: + +```bash +safedep project scan create safedep/cli --ref "$GITHUB_REF" +``` + +In a GitHub Actions pull request workflow, `GITHUB_REF` is +`refs/pull//merge`, a merge commit that GitHub builds for the pull request. +It is not a branch or a tag, so the CLI rejects it. Scan the pull request's +source branch instead: + +```bash +safedep project scan create safedep/cli --branch "$GITHUB_HEAD_REF" +``` + +This works when the source branch is in the scanned repository. A branch in a +fork is not, and the scan fails as not found. + Submit a batch and receive JSON: ```bash @@ -102,8 +159,8 @@ header and one tab-separated row per admitted scan. ## All-or-nothing admission -The CLI validates batch size and empty or duplicate selectors, then resolves -every exact project name before admission. A missing or ambiguous name fails +The CLI validates batch size, the ref flags, and empty or duplicate +selectors, then resolves every exact project name before admission. A missing or ambiguous name fails the command without submitting any scans. When multiple projects share a name, the error lists their IDs, sources, and origin URLs so the caller can retry with a project ID. @@ -116,7 +173,9 @@ and quota errors preserve their gRPC status details internally. The CLI uses typed SafeDep error reasons when available and prints a concise message, stable error code, and recovery guidance instead of raw nested gRPC text. Expected local selector and project-name resolution failures use the same -presentation, including a recovery action. +presentation, including a recovery action. A ref that a repository does not +have, or a name that is both a branch and a tag, fails with the server's message +naming the project and the ref. ## Authentication diff --git a/internal/cmd/project/create.go b/internal/cmd/project/create.go index fdbdc2d..a0180f2 100644 --- a/internal/cmd/project/create.go +++ b/internal/cmd/project/create.go @@ -20,6 +20,7 @@ const ( type createInput struct { ProjectIDs []string ProjectNames []string + Refs refFlags } type createdScan struct { @@ -52,9 +53,11 @@ func createCmd(a *app.App) *cobra.Command { Short: "Submit project scans to SafeDep Cloud-hosted scanners", Long: "Atomically submit on-demand scans for one to 100 SafeDep projects by exact name or ID " + "to SafeDep Cloud-hosted scanners. The command returns after cloud admission while scan " + - "execution continues asynchronously in SafeDep Cloud.", - Args: func(_ *cobra.Command, args []string) error { + "execution continues asynchronously in SafeDep Cloud. Each project scans its default branch, " + + "or the branch or tag that --branch, --tag or --ref names.", + Args: func(cmd *cobra.Command, args []string) error { in.ProjectNames = args + in.Refs.Set = changedFlags(cmd, refFlag, branchFlag, tagFlag) return validateCreateInput(in) }, RunE: func(cmd *cobra.Command, args []string) error { @@ -82,6 +85,14 @@ func createCmd(a *app.App) *cobra.Command { nil, "project ID to scan instead of a name; repeat for multiple projects", ) + cmd.Flags().StringVar(&in.Refs.Branch, branchFlag, "", "branch to scan in every selected project") + cmd.Flags().StringVar(&in.Refs.Tag, tagFlag, "", "tag to scan in every selected project") + cmd.Flags().StringVar( + &in.Refs.Ref, + refFlag, + "", + "full ref to scan in every selected project, such as refs/tags/v1.2.0; a plain name is a branch", + ) return cmd } @@ -97,7 +108,21 @@ func validateCreateInput(in createInput) error { if err := validateUniqueValues(in.ProjectIDs, "project ID"); err != nil { return err } - return validateUniqueValues(in.ProjectNames, "project name") + if err := validateUniqueValues(in.ProjectNames, "project name"); err != nil { + return err + } + _, err := in.Refs.qualified() + return err +} + +func changedFlags(cmd *cobra.Command, names ...string) []string { + var changed []string + for _, name := range names { + if cmd.Flags().Changed(name) { + changed = append(changed, name) + } + } + return changed } func validateProjectIDs(projectIDs []string) error { diff --git a/internal/cmd/project/create_test.go b/internal/cmd/project/create_test.go index ec39c08..ea0b242 100644 --- a/internal/cmd/project/create_test.go +++ b/internal/cmd/project/create_test.go @@ -108,7 +108,7 @@ func TestCreateProjectScans_SendsOneOrderedBatch(t *testing.T) { ), } - result, err := createProjectScans(context.Background(), client, []string{"project-1", "project-2"}) + result, err := createProjectScans(context.Background(), client, []string{"project-1", "project-2"}, "") require.NoError(t, err) assert.Equal(t, 1, client.calls) @@ -135,7 +135,7 @@ func TestCreateProjectScans_ConvertsCreatedAtToUTC(t *testing.T) { ), } - result, err := createProjectScans(context.Background(), client, []string{"project-1", "project-2"}) + result, err := createProjectScans(context.Background(), client, []string{"project-1", "project-2"}, "") require.NoError(t, err) require.Len(t, result.scans, 2) require.NotNil(t, result.scans[0].CreatedAt) @@ -147,7 +147,7 @@ func TestCreateProjectScans_RejectsInvalidInputBeforeRPC(t *testing.T) { t.Parallel() client := &fakeCreateProjectScansClient{} - _, err := createProjectScans(context.Background(), client, []string{"duplicate", "duplicate"}) + _, err := createProjectScans(context.Background(), client, []string{"duplicate", "duplicate"}, "") require.Error(t, err) assert.Zero(t, client.calls) } @@ -204,7 +204,7 @@ func TestCreateProjectScans_RejectsMalformedResponses(t *testing.T) { t.Run(tt.name, func(t *testing.T) { t.Parallel() client := &fakeCreateProjectScansClient{res: tt.res} - _, err := createProjectScans(context.Background(), client, []string{"project-1"}) + _, err := createProjectScans(context.Background(), client, []string{"project-1"}, "") require.Error(t, err) assert.Contains(t, err.Error(), "project scan create: invalid response") assert.Contains(t, err.Error(), tt.wantErr) @@ -221,7 +221,7 @@ func TestCreateProjectScans_PreservesGRPCStatusAndDetails(t *testing.T) { require.NoError(t, err) client := &fakeCreateProjectScansClient{err: rpcStatus.Err()} - _, err = createProjectScans(context.Background(), client, []string{"project-1"}) + _, err = createProjectScans(context.Background(), client, []string{"project-1"}, "") require.Error(t, err) assert.Contains(t, err.Error(), "project scan create") assert.Equal(t, codes.ResourceExhausted, status.Code(err)) diff --git a/internal/cmd/project/grpc.go b/internal/cmd/project/grpc.go index f7548c7..f255981 100644 --- a/internal/cmd/project/grpc.go +++ b/internal/cmd/project/grpc.go @@ -6,8 +6,11 @@ import ( controltowerv1grpc "buf.build/gen/go/safedep/api/grpc/go/safedep/services/controltower/v1/controltowerv1grpc" messagescontroltowerv1 "buf.build/gen/go/safedep/api/protocolbuffers/go/safedep/messages/controltower/v1" + scmv1 "buf.build/gen/go/safedep/api/protocolbuffers/go/safedep/messages/scm/v1" controltowerv1 "buf.build/gen/go/safedep/api/protocolbuffers/go/safedep/services/controltower/v1" "google.golang.org/grpc" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" "github.com/safedep/cli/internal/paging" "github.com/safedep/cli/internal/tui" @@ -147,23 +150,34 @@ func createProjectScans( ctx context.Context, client createProjectScansClient, projectIDs []string, + ref string, ) (*createResult, error) { if err := validateProjectIDs(projectIDs); err != nil { return nil, err } - res, err := client.CreateProjectScans(ctx, newCreateRequest(projectIDs)) + res, err := client.CreateProjectScans(ctx, newCreateRequest(projectIDs, ref)) if err != nil { + if ref != "" && status.Code(err) == codes.InvalidArgument { + return nil, refRejectedError(err, ref) + } return nil, fmt.Errorf("project scan create: %w", err) } return translateCreateResponse(res, len(projectIDs)) } -func newCreateRequest(projectIDs []string) *controltowerv1.CreateProjectScansRequest { +// newCreateRequest takes a full ref. It leaves the ref unset when ref is empty, +// so the server scans the default branch that the forge reports at admission. +func newCreateRequest(projectIDs []string, ref string) *controltowerv1.CreateProjectScansRequest { targets := make([]*controltowerv1.CreateProjectScansRequest_ProjectScanTarget, 0, len(projectIDs)) for _, projectID := range projectIDs { target := &controltowerv1.CreateProjectScansRequest_ProjectScanTarget{} target.SetProjectId(projectID) + if ref != "" { + gitRef := &scmv1.GitRef{} + gitRef.SetRef(ref) + target.SetRef(gitRef) + } targets = append(targets, target) } req := &controltowerv1.CreateProjectScansRequest{} diff --git a/internal/cmd/project/ref.go b/internal/cmd/project/ref.go new file mode 100644 index 0000000..d3fc434 --- /dev/null +++ b/internal/cmd/project/ref.go @@ -0,0 +1,107 @@ +package project + +import ( + "fmt" + "strings" + + "github.com/safedep/dry/usefulerror" + "google.golang.org/grpc/status" +) + +const ( + refPrefix = "refs/" + branchRefPrefix = "refs/heads/" + tagRefPrefix = "refs/tags/" + + refFlag = "ref" + branchFlag = "branch" + tagFlag = "tag" +) + +// refFlags holds the three ways to name the ref to scan. Set records which +// flags the user passed, so an empty value is told apart from an absent flag. +type refFlags struct { + Ref string + Branch string + Tag string + Set []string +} + +// qualified is the full ref the API requires, or "" to scan the default +// branch. --branch and --tag name the namespace, so the CLI never guesses. +// A plain --ref name is a branch, as in "git switch ". A full branch or +// tag ref goes through unchanged, so the server owns the ref name rules. +func (f refFlags) qualified() (string, error) { + switch len(f.Set) { + case 0: + return "", nil + case 1: + default: + return "", invalidRefError( + fmt.Errorf("--%s cannot be combined", strings.Join(f.Set, ", --")), + "Pass only one of --branch, --tag or --ref.", + ) + } + + switch f.Set[0] { + case branchFlag: + return shortRef(branchFlag, f.Branch, branchRefPrefix) + case tagFlag: + return shortRef(tagFlag, f.Tag, tagRefPrefix) + } + if f.Ref == "" { + return "", invalidRefError( + fmt.Errorf("--ref must not be empty"), + "Pass a branch name, refs/heads/ or refs/tags/, or omit --ref to scan the default branch.", + ) + } + if strings.HasPrefix(f.Ref, branchRefPrefix) || strings.HasPrefix(f.Ref, tagRefPrefix) { + return f.Ref, nil + } + // The API scans only branches and tags. Another ref, such as a pull + // request ref, fails here with advice instead of as a ref the repository + // does not have. + if strings.HasPrefix(f.Ref, refPrefix) { + return "", invalidRefError( + fmt.Errorf("--ref %q is not a branch or a tag", f.Ref), + "Only branches and tags can be scanned. Pass --branch, --tag, or a ref under refs/heads/ or refs/tags/.", + ) + } + return branchRefPrefix + f.Ref, nil +} + +func shortRef(flag, name, prefix string) (string, error) { + if name == "" { + return "", invalidRefError( + fmt.Errorf("--%s must not be empty", flag), + fmt.Sprintf("Pass a %s name, or omit --%s to scan the default branch.", flag, flag), + ) + } + if strings.HasPrefix(name, refPrefix) { + return "", invalidRefError( + fmt.Errorf("--%s takes a short name, not %q", flag, name), + fmt.Sprintf("Pass the name without refs/, or pass the full ref with --ref %s.", name), + ) + } + return prefix + name, nil +} + +func invalidRefError(cause error, help string) error { + return newProjectError(usefulerror.ErrBadRequest, "Invalid ref", help, cause) +} + +// refRejectedError explains a server rejection of the requested ref. The +// generic InvalidArgument rendering hides the server message behind +// --verbose, and that message names the project and the ref that failed. +func refRejectedError(err error, ref string) error { + help := fmt.Sprintf("%s. Check that %s exists in every selected repository.", status.Convert(err).Message(), ref) + if name, ok := strings.CutPrefix(ref, branchRefPrefix); ok { + help += fmt.Sprintf(" If %s is a tag, pass --tag %s.", name, name) + } + return newProjectError( + usefulerror.ErrBadRequest, + "Ref cannot be scanned", + help, + fmt.Errorf("project scan create: %w", err), + ) +} diff --git a/internal/cmd/project/ref_test.go b/internal/cmd/project/ref_test.go new file mode 100644 index 0000000..4a2feea --- /dev/null +++ b/internal/cmd/project/ref_test.go @@ -0,0 +1,276 @@ +package project + +import ( + "context" + "strings" + "testing" + "time" + + messagescontroltowerv1 "buf.build/gen/go/safedep/api/protocolbuffers/go/safedep/messages/controltower/v1" + errorv1 "buf.build/gen/go/safedep/api/protocolbuffers/go/safedep/messages/error/v1" + "github.com/safedep/dry/usefulerror" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" +) + +func twoQueuedScans() *fakeCreateProjectScansClient { + return &fakeCreateProjectScansClient{ + res: createResponse( + projectScan("project-1", "session-1", messagescontroltowerv1.ScanStatus_SCAN_STATUS_QUEUED, time.Time{}), + projectScan("project-2", "session-2", messagescontroltowerv1.ScanStatus_SCAN_STATUS_QUEUED, time.Time{}), + ), + } +} + +func TestRunCreate_SendsTheRefForEveryProject(t *testing.T) { + t.Parallel() + + tests := []struct { + name string + refs refFlags + want string + }{ + { + name: "branch", + refs: refFlags{Branch: "release/1.2", Set: []string{branchFlag}}, + want: "refs/heads/release/1.2", + }, + {name: "tag", refs: refFlags{Tag: "v1.2.0", Set: []string{tagFlag}}, want: "refs/tags/v1.2.0"}, + {name: "plain ref is a branch", refs: refFlags{Ref: "main", Set: []string{refFlag}}, want: "refs/heads/main"}, + { + name: "plain ref that looks like a tag is still a branch", + refs: refFlags{Ref: "v1.2.0", Set: []string{refFlag}}, + want: "refs/heads/v1.2.0", + }, + { + name: "full branch ref", + refs: refFlags{Ref: "refs/heads/develop", Set: []string{refFlag}}, + want: "refs/heads/develop", + }, + { + name: "full tag ref", + refs: refFlags{Ref: "refs/tags/v1.2.0", Set: []string{refFlag}}, + want: "refs/tags/v1.2.0", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + t.Parallel() + scanner := twoQueuedScans() + + _, err := runCreate(context.Background(), scanner, &fakeListProjectsClient{}, createInput{ + ProjectIDs: []string{"project-1", "project-2"}, + Refs: tt.refs, + }) + + require.NoError(t, err) + require.Len(t, scanner.req.GetTargets(), 2) + for _, target := range scanner.req.GetTargets() { + require.True(t, target.HasRef(), target.GetProjectId()) + assert.Equal(t, tt.want, target.GetRef().GetRef(), target.GetProjectId()) + } + }) + } +} + +func TestRunCreate_WithoutRefScansTheDefaultBranch(t *testing.T) { + t.Parallel() + scanner := twoQueuedScans() + + _, err := runCreate(context.Background(), scanner, &fakeListProjectsClient{}, createInput{ + ProjectIDs: []string{"project-1", "project-2"}, + }) + + require.NoError(t, err) + require.Len(t, scanner.req.GetTargets(), 2) + for _, target := range scanner.req.GetTargets() { + assert.False(t, target.HasRef(), target.GetProjectId()) + } +} + +func TestCreateCmd_RejectsABadRefSelectionBeforeAnyRequest(t *testing.T) { + t.Parallel() + + tests := []struct { + name string + flags []string + wantHelp string + }{ + { + name: "empty ref", + flags: []string{"--ref", ""}, + wantHelp: "Pass a branch name, refs/heads/ or refs/tags/, or omit --ref to scan the default branch.", + }, + { + name: "empty branch", + flags: []string{"--branch", ""}, + wantHelp: "Pass a branch name, or omit --branch to scan the default branch.", + }, + { + name: "empty tag", + flags: []string{"--tag", ""}, + wantHelp: "Pass a tag name, or omit --tag to scan the default branch.", + }, + { + name: "full ref given to branch", + flags: []string{"--branch", "refs/heads/main"}, + wantHelp: "Pass the name without refs/, or pass the full ref with --ref refs/heads/main.", + }, + { + name: "full ref given to tag", + flags: []string{"--tag", "refs/tags/v1"}, + wantHelp: "Pass the name without refs/, or pass the full ref with --ref refs/tags/v1.", + }, + { + name: "pull request ref", + flags: []string{"--ref", "refs/pull/123/merge"}, + wantHelp: "Only branches and tags can be scanned. Pass --branch, --tag, or a ref under refs/heads/ or refs/tags/.", + }, + { + name: "branch and tag", + flags: []string{"--branch", "main", "--tag", "v1"}, + wantHelp: "Pass only one of --branch, --tag or --ref.", + }, + { + name: "ref and branch", + flags: []string{"--ref", "refs/heads/main", "--branch", "main"}, + wantHelp: "Pass only one of --branch, --tag or --ref.", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + t.Parallel() + cmd := createCmd(nil) + require.NoError(t, cmd.ParseFlags(append(tt.flags, "--project-id", "project-1"))) + + err := cmd.Args(cmd, cmd.Flags().Args()) + + requireUsefulError(t, err, usefulerror.ErrBadRequest, "Invalid ref", tt.wantHelp) + }) + } +} + +func TestRunCreate_ExplainsARefTheServerRejects(t *testing.T) { + t.Parallel() + + tests := []struct { + name string + refs refFlags + wantHelp string + }{ + { + name: "a branch suggests --tag", + refs: refFlags{Branch: "v1.2.0", Set: []string{branchFlag}}, + wantHelp: "project project-2 cannot scan refs/heads/v1.2.0: git ref not found. " + + "Check that refs/heads/v1.2.0 exists in every selected repository. If v1.2.0 is a tag, pass --tag v1.2.0.", + }, + { + name: "a tag does not suggest --tag", + refs: refFlags{Tag: "v1.2.0", Set: []string{tagFlag}}, + wantHelp: "project project-2 cannot scan refs/tags/v1.2.0: git ref not found. " + + "Check that refs/tags/v1.2.0 exists in every selected repository.", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + t.Parallel() + serverMessage, _, _ := strings.Cut(tt.wantHelp, ". Check") + scanner := &fakeCreateProjectScansClient{err: status.Error(codes.InvalidArgument, serverMessage)} + + _, err := runCreate(context.Background(), scanner, &fakeListProjectsClient{}, createInput{ + ProjectIDs: []string{"project-1", "project-2"}, + Refs: tt.refs, + }) + + requireUsefulError(t, err, usefulerror.ErrBadRequest, "Ref cannot be scanned", tt.wantHelp) + assert.Equal(t, codes.InvalidArgument, status.Code(err)) + }) + } +} + +func TestRunCreate_DoesNotBlameARefThatWasNotRequested(t *testing.T) { + t.Parallel() + + scanner := &fakeCreateProjectScansClient{err: status.Error(codes.InvalidArgument, "at least one target is required")} + + _, err := runCreate(context.Background(), scanner, &fakeListProjectsClient{}, createInput{ + ProjectIDs: []string{"project-1"}, + }) + + require.Error(t, err) + usefulErr, ok := usefulerror.AsUsefulError(err) + require.True(t, ok) + assert.NotEqual(t, "Ref cannot be scanned", usefulErr.HumanError()) + assert.Equal(t, codes.InvalidArgument, status.Code(err)) +} + +func TestRunCreate_KeepsOtherServerErrorsWhenARefIsSet(t *testing.T) { + t.Parallel() + + rejection := usefulerror.NewStatus(codes.FailedPrecondition, "service execution failed"). + WithReason(errorv1.ErrorReason_ERROR_REASON_PROJECT_NOT_SCANNABLE). + Err() + scanner := &fakeCreateProjectScansClient{err: rejection} + + _, err := runCreate(context.Background(), scanner, &fakeListProjectsClient{}, createInput{ + ProjectIDs: []string{"project-1"}, + Refs: refFlags{Branch: "main", Set: []string{branchFlag}}, + }) + + require.Error(t, err) + usefulErr, ok := usefulerror.AsUsefulError(err) + require.True(t, ok) + assert.NotEqual(t, "Ref cannot be scanned", usefulErr.HumanError()) + assert.Equal(t, codes.FailedPrecondition, status.Code(err)) + reason, ok := usefulerror.ReasonOf(err) + require.True(t, ok) + assert.Equal(t, errorv1.ErrorReason_ERROR_REASON_PROJECT_NOT_SCANNABLE, reason) +} + +// FuzzRefFlags checks the rule that maps any value of each flag to the ref the +// API receives. --branch and --tag add their namespace and refuse a value that +// already has one. --ref sends a branch or tag ref as given, refuses any other +// value under refs/, and treats any other value as a branch. +func FuzzRefFlags(f *testing.F) { + for _, seed := range []string{ + "main", "release/1.2", "refs/heads/main", "refs/tags/v1.2.0", "refs/pull/1/head", "refs/pull/1/merge", + "refs/", "refs", "heads/main", "tags/v1", " refs/heads/main", "REFS/heads/main", + } { + f.Add(seed) + } + f.Fuzz(func(t *testing.T, value string) { + if value == "" { + return + } + underRefs := strings.HasPrefix(value, "refs/") + branchOrTag := strings.HasPrefix(value, "refs/heads/") || strings.HasPrefix(value, "refs/tags/") + + ref, err := refFlags{Ref: value, Set: []string{refFlag}}.qualified() + switch { + case branchOrTag: + require.NoError(t, err) + assert.Equal(t, value, ref) + case underRefs: + require.Error(t, err) + default: + require.NoError(t, err) + assert.Equal(t, "refs/heads/"+value, ref) + } + + for flag, prefix := range map[string]string{branchFlag: "refs/heads/", tagFlag: "refs/tags/"} { + flags := refFlags{Branch: value, Tag: value, Set: []string{flag}} + ref, err := flags.qualified() + if underRefs { + require.Error(t, err, flag) + continue + } + require.NoError(t, err, flag) + assert.Equal(t, prefix+value, ref, flag) + } + }) +} diff --git a/internal/cmd/project/resolver.go b/internal/cmd/project/resolver.go index c77cbaa..61c896b 100644 --- a/internal/cmd/project/resolver.go +++ b/internal/cmd/project/resolver.go @@ -47,6 +47,10 @@ func runCreate( if err := validateCreateInput(in); err != nil { return nil, err } + ref, err := in.Refs.qualified() + if err != nil { + return nil, err + } resolvedIDs, err := resolveProjectNames(ctx, resolver, in.ProjectNames) if err != nil { @@ -70,7 +74,7 @@ func runCreate( projectIDs = append(projectIDs, projectID) } - return createProjectScans(ctx, scanner, projectIDs) + return createProjectScans(ctx, scanner, projectIDs, ref) } func resolveProjectNames(