ignored_ruleset_test.go

// Copyright 2017 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package pkgtree

import "testing"

func TestIgnoredRuleset(t *testing.T) {
	type tfixm []struct {
		path string
		wild bool
	}
	cases := []struct {
		name            string
		inputs          []string
		wantInTree      tfixm
		wantEmptyTree   bool
		shouldIgnore    []string
		shouldNotIgnore []string
	}{
		{
			name:          "only skip global ignore",
			inputs:        []string{"*"},
			wantEmptyTree: true,
		},
		{
			name: "ignores without ignore suffix",
			inputs: []string{
				"x/y/z",
				"*a/b/c",
				"gophers",
			},
			wantInTree: tfixm{
				{path: "x/y/z", wild: false},
				{path: "*a/b/c", wild: false},
				{path: "gophers", wild: false},
			},
			shouldIgnore: []string{
				"x/y/z",
				"gophers",
			},
			shouldNotIgnore: []string{
				"x/y/z/q",
				"x/y",
				"gopher",
				"gopherss",
			},
		},
		{
			name: "ignores with ignore suffix",
			inputs: []string{
				"x/y/z*",
				"a/b/c",
				"gophers",
			},
			wantInTree: tfixm{
				{path: "x/y/z", wild: true},
				{path: "a/b/c", wild: false},
				{path: "gophers", wild: false},
			},
			shouldIgnore: []string{
				"x/y/z",
				"x/y/zz",
				"x/y/z/",
				"x/y/z/q",
			},
			shouldNotIgnore: []string{
				"x/y",
				"gopher",
			},
		},
		{
			name: "global ignore with other strings",
			inputs: []string{
				"*",
				"gophers*",
				"x/y/z*",
				"a/b/c",
			},
			wantInTree: tfixm{
				{path: "x/y/z", wild: true},
				{path: "a/b/c", wild: false},
				{path: "gophers", wild: true},
			},
			shouldIgnore: []string{
				"x/y/z",
				"x/y/z/",
				"x/y/z/q",
				"gophers",
				"gopherss",
				"gophers/foo",
			},
			shouldNotIgnore: []string{
				"x/y",
				"gopher",
			},
		},
		{
			name: "ineffectual ignore with wildcard",
			inputs: []string{
				"a/b*",
				"a/b/c*",
				"a/b/x/y",
				"a/c*",
			},
			wantInTree: tfixm{
				{path: "a/c", wild: true},
				{path: "a/b", wild: true},
			},
			shouldIgnore: []string{
				"a/cb",
			},
			shouldNotIgnore: []string{
				"a/",
				"a/d",
			},
		},
		{
			name: "same path with and without wildcard",
			inputs: []string{
				"a/b*",
				"a/b",
			},
			wantInTree: tfixm{
				{path: "a/b", wild: true},
			},
			shouldIgnore: []string{
				"a/b",
				"a/bb",
			},
			shouldNotIgnore: []string{
				"a/",
				"a/d",
			},
		},
		{
			name: "empty paths",
			inputs: []string{
				"",
				"a/b*",
			},
			wantInTree: tfixm{
				{path: "a/b", wild: true},
			},
			shouldNotIgnore: []string{
				"",
			},
		},
		{
			name: "single wildcard",
			inputs: []string{
				"a/b*",
			},
			wantInTree: tfixm{
				{path: "a/b", wild: true},
			},
			shouldIgnore: []string{
				"a/b/c",
			},
		},
	}

	for _, c := range cases {
		igm := NewIgnoredRuleset(c.inputs)
		f := func(t *testing.T) {

			if c.wantEmptyTree {
				if igm.Len() != 0 {
					t.Fatalf("wanted empty tree, but had %v elements", igm.Len())
				}
			}

			// Check if the wildcard suffix ignores are in the tree.
			for _, p := range c.wantInTree {
				wildi, has := igm.t.Get(p.path)
				if !has {
					t.Fatalf("expected %q to be in the tree", p.path)
				} else if wildi.(bool) != p.wild {
					if p.wild {
						t.Fatalf("expected %q to be a wildcard matcher, but it was not", p.path)
					} else {
						t.Fatalf("expected %q not to be a wildcard matcher, but it was", p.path)
					}
				}
			}

			for _, p := range c.shouldIgnore {
				if !igm.IsIgnored(p) {
					t.Fatalf("%q should be ignored, but it was not", p)
				}
			}
			for _, p := range c.shouldNotIgnore {
				if igm.IsIgnored(p) {
					t.Fatalf("%q should not be ignored, but it was", p)
				}
			}
		}
		t.Run(c.name, f)

		igm = NewIgnoredRuleset(igm.ToSlice())
		t.Run(c.name+"/inandout", f)
	}
}