chore: refactor shoulds to remove the need for explicit negated condi…

…tions, introducing should.Not()

internal/arch/file/rule_one_test.go

@@ -70,7 +70,7 @@ func Test_It_Checks_A_File_Does_Not_Exist(t *testing.T) {
 	for _, tC := range testCases {
 		t.Run(tC.desc, func(t *testing.T) {
 			vs, errs := file.One(tC.filename).
-				Should(fs.NotExist()).
+				Should(fs.Not(fs.Exist())).
 				Because("testing reasons")
 
 			if !cmp.Equal(vs, tC.wantViolations, cmp.AllowUnexported(rule.Violation{}), cmpopts.EquateEmpty()) {

internal/arch/file/rule_set_test.go

@@ -96,7 +96,7 @@ func Test_It_Checks_A_Set_Of_Files_Do_Not_Exist(t *testing.T) {
 	for _, tC := range testCases {
 		t.Run(tC.desc, func(t *testing.T) {
 			vs, errs := file.Set(tC.filenames...).
-				Should(fs.NotExist()).
+				Should(fs.Not(fs.Exist())).
 				Because("testing reasons")
 
 			if !cmp.Equal(vs, tC.wantViolations, cmp.AllowUnexported(rule.Violation{}), cmpopts.EquateEmpty()) {

internal/arch/file/should/end_with.go

@@ -17,13 +17,14 @@ func EndWith(suffix string) *Expression {
 
 			return ls <= lf && fileName[lf-ls:] != suffix
 		},
-		getViolation: func(filePath string) rule.Violation {
+		getViolation: func(filePath string, negated bool) rule.Violation {
+			format := "file's name '%s' does not end with '%s'"
+			if negated {
+				format = "file's name '%s' does end with '%s'"
+			}
+
 			return rule.NewViolation(
-				fmt.Sprintf(
-					"file's name '%s' does not end with '%s'",
-					filepath.Base(filePath),
-					suffix,
-				),
+				fmt.Sprintf(format, filepath.Base(filePath), suffix),
 			)
 		},
 	}

internal/arch/file/should/end_with_test.go

@@ -36,6 +36,41 @@ func Test_EndWith(t *testing.T) {
 		t.Run(tC.desc, func(t *testing.T) {
 			ew := should.EndWith(tC.suffix)
 			got := ew.Evaluate(tC.ruleBuilder)
+
+			if !cmp.Equal(got, tC.want, cmp.AllowUnexported(rule.Violation{}), cmpopts.EquateEmpty()) {
+				t.Errorf("want = %+v, got = %+v", tC.want, got)
+			}
+		})
+	}
+}
+
+func Test_NotEndWith(t *testing.T) {
+	testCases := []struct {
+		desc        string
+		ruleBuilder *file.RuleBuilder
+		suffix      string
+		want        []rule.Violation
+	}{
+		{
+			desc:        "foobar does not end with baz",
+			ruleBuilder: file.One("foobar"),
+			suffix:      "baz",
+			want:        nil,
+		},
+		{
+			desc:        "foobar ends with bar",
+			ruleBuilder: file.One("foobar"),
+			suffix:      "bar",
+			want: []rule.Violation{
+				rule.NewViolation("file's name 'foobar' does end with 'bar'"),
+			},
+		},
+	}
+	for _, tC := range testCases {
+		t.Run(tC.desc, func(t *testing.T) {
+			ew := should.Not(should.EndWith(tC.suffix))
+			got := ew.Evaluate(tC.ruleBuilder)
+
 			if !cmp.Equal(got, tC.want, cmp.AllowUnexported(rule.Violation{}), cmpopts.EquateEmpty()) {
 				t.Errorf("want = %+v, got = %+v", tC.want, got)
 			}

internal/arch/file/should/exist.go

@@ -11,21 +11,23 @@ func Exist() *Expression {
 	return &Expression{
 		evaluate: func(rb rule.Builder, filePath string) bool {
 			if _, err := os.Stat(filePath); err != nil {
-				if os.IsNotExist(err) {
-					return true
+				if !os.IsNotExist(err) {
+					rb.AddError(err)
 				}
 
-				rb.AddError(err)
+				return true
 			}
 
 			return false
 		},
-		getViolation: func(filePath string) rule.Violation {
+		getViolation: func(filePath string, negated bool) rule.Violation {
+			format := "file '%s' does not exist"
+			if negated {
+				format = "file '%s' does exist"
+			}
+
 			return rule.NewViolation(
-				fmt.Sprintf(
-					"file '%s' does not exist",
-					filepath.Base(filePath),
-				),
+				fmt.Sprintf(format, filepath.Base(filePath)),
 			)
 		},
 	}

internal/arch/file/should/exist_test.go

@@ -34,6 +34,37 @@ func Test_Exist(t *testing.T) {
 		t.Run(tC.desc, func(t *testing.T) {
 			e := should.Exist()
 			got := e.Evaluate(tC.ruleBuilder)
+
+			if !cmp.Equal(got, tC.want, cmp.AllowUnexported(rule.Violation{}), cmpopts.EquateEmpty()) {
+				t.Errorf("want = %+v, got = %+v", tC.want, got)
+			}
+		})
+	}
+}
+
+func Test_NotExist(t *testing.T) {
+	testCases := []struct {
+		desc        string
+		ruleBuilder *file.RuleBuilder
+		want        []rule.Violation
+	}{
+		{
+			desc:        "exist.go exists",
+			ruleBuilder: file.One("exist.go"),
+			want: []rule.Violation{
+				rule.NewViolation("file 'exist.go' does exist"),
+			},
+		},
+		{
+			desc:        "abc.xyz does not exist",
+			ruleBuilder: file.One("abc.xyz"),
+		},
+	}
+	for _, tC := range testCases {
+		t.Run(tC.desc, func(t *testing.T) {
+			e := should.Not(should.Exist())
+			got := e.Evaluate(tC.ruleBuilder)
+
 			if !cmp.Equal(got, tC.want, cmp.AllowUnexported(rule.Violation{}), cmpopts.EquateEmpty()) {
 				t.Errorf("want = %+v, got = %+v", tC.want, got)
 			}

internal/arch/file/should/match_glob.go

@@ -16,10 +16,15 @@ func MatchGlob(glob string, basePath string) *Expression {
 
 			return !match
 		},
-		getViolation: func(filePath string) rule.Violation {
+		getViolation: func(filePath string, negated bool) rule.Violation {
+			format := "file's path '%s' does not match glob pattern '%s'"
+			if negated {
+				format = "file's path '%s' does match glob pattern '%s'"
+			}
+
 			return rule.NewViolation(
 				fmt.Sprintf(
-					"file's path '%s' does not match glob pattern '%s'",
+					format,
 					filepath.Base(filePath),
 					glob,
 				),

internal/arch/file/should/match_glob_test.go

@@ -59,6 +59,7 @@ func Test_MatchGlob(t *testing.T) {
 		t.Run(tC.desc, func(t *testing.T) {
 			mg := should.MatchGlob(tC.glob, basePath)
 			got := mg.Evaluate(tC.ruleBuilder)
+
 			if !cmp.Equal(got, tC.want, cmp.AllowUnexported(rule.Violation{}), cmpopts.EquateEmpty()) {
 				t.Errorf("want = %+v, got = %+v", tC.want, got)
 			}

internal/arch/file/should/match_regex.go

@@ -16,10 +16,15 @@ func MatchRegex(res string) *Expression {
 				filepath.Base(filePath),
 			)
 		},
-		getViolation: func(filePath string) rule.Violation {
+		getViolation: func(filePath string, negated bool) rule.Violation {
+			format := "file's name '%s' does not match regex '%s'"
+			if negated {
+				format = "file's name '%s' does match regex '%s'"
+			}
+
 			return rule.NewViolation(
 				fmt.Sprintf(
-					"file's name '%s' does not match regex '%s'",
+					format,
 					filepath.Base(filePath),
 					res,
 				),

internal/arch/file/should/match_regex_test.go

@@ -42,6 +42,49 @@ func Test_MatchRegex(t *testing.T) {
 		t.Run(tC.desc, func(t *testing.T) {
 			ew := should.MatchRegex(tC.regexp)
 			got := ew.Evaluate(tC.ruleBuilder)
+
+			if !cmp.Equal(got, tC.want, cmp.AllowUnexported(rule.Violation{}), cmpopts.EquateEmpty()) {
+				t.Errorf("want = %+v, got = %+v", tC.want, got)
+			}
+		})
+	}
+}
+
+func Test_NotMatchRegex(t *testing.T) {
+	testCases := []struct {
+		desc        string
+		ruleBuilder *file.RuleBuilder
+		regexp      string
+		want        []rule.Violation
+	}{
+		{
+			desc:        "foobar matches '[a-z]+'",
+			ruleBuilder: file.One("foobar"),
+			regexp:      "[a-z]+",
+			want: []rule.Violation{
+				rule.NewViolation("file's name 'foobar' does match regex '[a-z]+'"),
+			},
+		},
+		{
+			desc:        "foobar matches 'foobar'",
+			ruleBuilder: file.One("foobar"),
+			regexp:      "foobar",
+			want: []rule.Violation{
+				rule.NewViolation("file's name 'foobar' does match regex 'foobar'"),
+			},
+		},
+		{
+			desc:        "foobar does not match '[0-9]+'",
+			ruleBuilder: file.One("foobar"),
+			regexp:      "[0-9]+",
+			want:        nil,
+		},
+	}
+	for _, tC := range testCases {
+		t.Run(tC.desc, func(t *testing.T) {
+			nmr := should.Not(should.MatchRegex(tC.regexp))
+			got := nmr.Evaluate(tC.ruleBuilder)
+
 			if !cmp.Equal(got, tC.want, cmp.AllowUnexported(rule.Violation{}), cmpopts.EquateEmpty()) {
 				t.Errorf("want = %+v, got = %+v", tC.want, got)
 			}