dehub/accessctl/access_control_test.go

package accessctl

import (
	"errors"
	"reflect"
	"sort"
	"testing"
)

func TestApplicableAccessControls(t *testing.T) {
	tests := []struct {
		descr                  string
		patterns, filesChanged []string
		exp                    []string
		expErrPath             string
	}{
		{
			descr: "empty input empty output",
		},
		{
			descr:        "empty patterns",
			filesChanged: []string{"foo", "bar"},
			expErrPath:   "foo",
		},
		{
			descr:    "empty filesChanged",
			patterns: []string{"patternA", "patternB"},
		},
		{
			descr:        "no applicable files",
			filesChanged: []string{"foo"},
			patterns:     []string{"bar"},
			expErrPath:   "foo",
		},
		{
			descr:        "all applicable files",
			filesChanged: []string{"foo", "bar"},
			patterns:     []string{"**"},
			exp:          []string{"**"},
		},
		{
			descr:        "pattern precedent",
			filesChanged: []string{"foo"},
			patterns:     []string{"foo", "**"},
			exp:          []string{"foo"},
		},
		{
			descr:        "pattern precedent inv",
			filesChanged: []string{"foo"},
			patterns:     []string{"**", "foo"},
			exp:          []string{"**"},
		},
		{
			descr:        "individual matches",
			filesChanged: []string{"foo", "bar/baz"},
			patterns:     []string{"foo", "bar/baz"},
			exp:          []string{"foo", "bar/baz"},
		},
		{
			descr:        "star match dir",
			filesChanged: []string{"foo", "bar/baz"},
			patterns:     []string{"foo", "bar/*"},
			exp:          []string{"foo", "bar/*"},
		},
		{
			descr:        "star not match dir",
			filesChanged: []string{"foo", "bar/baz/biz"},
			patterns:     []string{"foo", "bar/*"},
			expErrPath:   "bar/baz/biz",
		},
		{
			descr:        "doublestar match dir",
			filesChanged: []string{"foo", "bar/bar", "bar/baz/biz"},
			patterns:     []string{"foo", "bar/**"},
			exp:          []string{"foo", "bar/**"},
		},
	}

	for _, test := range tests {
		t.Run(test.descr, func(t *testing.T) {
			accessControls := make([]AccessControl, len(test.patterns))
			for i := range test.patterns {
				accessControls[i] = AccessControl{Pattern: test.patterns[i]}
			}

			out, err := ApplicableAccessControls(accessControls, test.filesChanged)
			if err != nil && test.expErrPath == "" {
				t.Fatalf("unexpected error: %v", err)
			} else if test.expErrPath != "" {
				if noAppErr := (ErrNoApplicableAccessControls{}); !errors.As(err, &noAppErr) {
					t.Fatalf("expected ErrNoApplicableAccessControls for path %q, but got %v", test.expErrPath, err)
				} else if test.expErrPath != noAppErr.Path {
					t.Fatalf("expected ErrNoApplicableAccessControls for path %q, but got one for path %q", test.expErrPath, noAppErr.Path)
				}
				return
			}

			outPatterns := make([]string, len(out))
			for i := range out {
				outPatterns[i] = out[i].Pattern
			}

			clean := func(s []string) []string {
				if len(s) == 0 {
					return nil
				}
				sort.Strings(s)
				return s
			}

			outPatterns = clean(outPatterns)
			test.exp = clean(test.exp)
			if !reflect.DeepEqual(outPatterns, test.exp) {
				t.Fatalf("expected: %+v\ngot: %+v", test.exp, outPatterns)
			}
		})
	}
}