Add more test coverage

.github/workflows/test.yml

@@ -24,4 +24,4 @@ jobs:
           go-version: '1.18'
 
       - run: |-
-          go test -count=1 -race ./...
+          go test -count=1 -shuffle=on -timeout=10m -race ./...

resolver/actions.go

@@ -53,7 +53,7 @@ func NewActions(ctx context.Context) (*Actions, error) {
 }
 
 func (g *Actions) Resolve(ctx context.Context, value string) (string, error) {
-	githubRef, err := ParseRef(value)
+	githubRef, err := ParseActionRef(value)
 	if err != nil {
 		return "", fmt.Errorf("failed to parse github ref: %w", err)
 	}
@@ -68,16 +68,16 @@ func (g *Actions) Resolve(ctx context.Context, value string) (string, error) {
 	return fmt.Sprintf("%s/%s@%s", owner, repo, sha), nil
 }
 
-func ParseRef(s string) (*GitHubRef, error) {
+func ParseActionRef(s string) (*GitHubRef, error) {
 	parts := strings.SplitN(s, "/", 2)
 	if len(parts) < 2 {
-		return nil, fmt.Errorf("bad cutset: %q", s)
+		return nil, fmt.Errorf("missing owner/repo in actions reference: %q", s)
 	}
 	owner, rest := parts[0], parts[1]
 
 	smallerParts := strings.SplitN(rest, "@", 2)
 	if len(smallerParts) < 2 {
-		return nil, fmt.Errorf("bad cutset2: %q", s)
+		return nil, fmt.Errorf("missing @ in actions reference: %q", s)
 	}
 	ref := smallerParts[1]
 

resolver/actions_test.go

@@ -0,0 +1,79 @@
+package resolver
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestParseRef(t *testing.T) {
+	t.Parallel()
+
+	cases := []struct {
+		name string
+		in   string
+		exp  *GitHubRef
+		err  string
+	}{
+		{
+			name: "empty",
+			in:   "",
+			err:  "missing owner/repo",
+		},
+		{
+			name: "no_slash",
+			in:   "foo_bar_baz@v0",
+			err:  "missing owner/repo",
+		},
+		{
+			name: "no_ref",
+			in:   "foo/bar",
+			err:  "missing @",
+		},
+		{
+			name: "ref",
+			in:   "foo/bar@v0",
+			exp: &GitHubRef{
+				owner: "foo",
+				repo:  "bar",
+				path:  "",
+				ref:   "v0",
+			},
+		},
+		{
+			name: "ref_path",
+			in:   "foo/bar/baz@v0",
+			exp: &GitHubRef{
+				owner: "foo",
+				repo:  "bar",
+				path:  "baz",
+				ref:   "v0",
+			},
+		},
+	}
+
+	for _, tc := range cases {
+		tc := tc
+
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			ref, err := ParseActionRef(tc.in)
+			if err != nil {
+				if tc.err == "" {
+					t.Fatal(err)
+				} else {
+					if str := err.Error(); !strings.Contains(str, tc.err) {
+						t.Errorf("expected %q to contain %q", str, tc.err)
+					}
+				}
+			} else if tc.err != "" {
+				t.Fatalf("expected error, but got %#v", ref)
+			}
+
+			if got, want := ref, tc.exp; !reflect.DeepEqual(got, want) {
+				t.Errorf("expected %#v to be %#v", got, want)
+			}
+		})
+	}
+}