Support matchers on integers in integration tests

Author: jesseduffield

pkg/integration/components/alert_driver.go

@@ -11,7 +11,7 @@ func (self *AlertDriver) getViewDriver() *ViewDriver {
 }
 
 // asserts that the alert view has the expected title
-func (self *AlertDriver) Title(expected *Matcher) *AlertDriver {
+func (self *AlertDriver) Title(expected *TextMatcher) *AlertDriver {
 self.getViewDriver().Title(expected)
 
 self.hasCheckedTitle = true
@@ -20,7 +20,7 @@ func (self *AlertDriver) Title(expected *Matcher) *AlertDriver {
 }
 
 // asserts that the alert view has the expected content
-func (self *AlertDriver) Content(expected *Matcher) *AlertDriver {
+func (self *AlertDriver) Content(expected *TextMatcher) *AlertDriver {
 self.getViewDriver().Content(expected)
 
 self.hasCheckedContent = true

pkg/integration/components/assertion_helper.go

@@ -22,7 +22,7 @@ func retryWaitTimes() []int {
 }
 }
 
-func (self *assertionHelper) matchString(matcher *Matcher, context string, getValue func() string) {
+func (self *assertionHelper) matchString(matcher *TextMatcher, context string, getValue func() string) {
 self.assertWithRetries(func() (bool, string) {
 value := getValue()
 return matcher.context(context).test(value)

pkg/integration/components/commit_message_panel_driver.go

@@ -9,19 +9,19 @@ func (self *CommitMessagePanelDriver) getViewDriver() *ViewDriver {
 }
 
 // asserts on the text initially present in the prompt
-func (self *CommitMessagePanelDriver) InitialText(expected *Matcher) *CommitMessagePanelDriver {
+func (self *CommitMessagePanelDriver) InitialText(expected *TextMatcher) *CommitMessagePanelDriver {
 return self.Content(expected)
 }
 
 // asserts on the current context in the prompt
-func (self *CommitMessagePanelDriver) Content(expected *Matcher) *CommitMessagePanelDriver {
+func (self *CommitMessagePanelDriver) Content(expected *TextMatcher) *CommitMessagePanelDriver {
 self.getViewDriver().Content(expected)
 
 return self
 }
 
 // asserts that the confirmation view has the expected title
-func (self *CommitMessagePanelDriver) Title(expected *Matcher) *CommitMessagePanelDriver {
+func (self *CommitMessagePanelDriver) Title(expected *TextMatcher) *CommitMessagePanelDriver {
 self.getViewDriver().Title(expected)
 
 return self

pkg/integration/components/common.go

@@ -39,7 +39,7 @@ func (self *Common) ConfirmDiscardLines() {
 Confirm()
 }
 
-func (self *Common) SelectPatchOption(matcher *Matcher) {
+func (self *Common) SelectPatchOption(matcher *TextMatcher) {
 self.t.GlobalPress(self.t.keys.Universal.CreatePatchOptionsMenu)
 
 self.t.ExpectPopup().Menu().Title(Equals("Patch options")).Select(matcher).Confirm()

pkg/integration/components/confirmation_driver.go

@@ -11,7 +11,7 @@ func (self *ConfirmationDriver) getViewDriver() *ViewDriver {
 }
 
 // asserts that the confirmation view has the expected title
-func (self *ConfirmationDriver) Title(expected *Matcher) *ConfirmationDriver {
+func (self *ConfirmationDriver) Title(expected *TextMatcher) *ConfirmationDriver {
 self.getViewDriver().Title(expected)
 
 self.hasCheckedTitle = true
@@ -20,7 +20,7 @@ func (self *ConfirmationDriver) Title(expected *Matcher) *ConfirmationDriver {
 }
 
 // asserts that the confirmation view has the expected content
-func (self *ConfirmationDriver) Content(expected *Matcher) *ConfirmationDriver {
+func (self *ConfirmationDriver) Content(expected *TextMatcher) *ConfirmationDriver {
 self.getViewDriver().Content(expected)
 
 self.hasCheckedContent = true

pkg/integration/components/file_system.go

@@ -26,7 +26,7 @@ func (self *FileSystem) PathNotPresent(path string) {
 }
 
 // Asserts that the file at the given path has the given content
-func (self *FileSystem) FileContent(path string, matcher *Matcher) {
+func (self *FileSystem) FileContent(path string, matcher *TextMatcher) {
 self.assertWithRetries(func() (bool, string) {
 _, err := os.Stat(path)
 if os.IsNotExist(err) {

pkg/integration/components/matcher.go

@@ -8,39 +8,42 @@ import (
 "github.com/samber/lo"
 )
 
+type TextMatcher struct {
+*Matcher[string]
+}
+
+type IntMatcher struct {
+*Matcher[int]
+}
+
 // for making assertions on string values
-type Matcher struct {
-rules []matcherRule
+type Matcher[T any] struct {
+rules []matcherRule[T]
 
 // this is printed when there's an error so that it's clear what the context of the assertion is
 prefix string
 }
 
-type matcherRule struct {
+type matcherRule[T any] struct {
 // e.g. "contains 'foo'"
 name string
 // returns a bool that says whether the test passed and if it returns false, it
 // also returns a string of the error message
-testFn func(string) (bool, string)
-}
-
-func NewMatcher(name string, testFn func(string) (bool, string)) *Matcher {
-rules := []matcherRule{{name: name, testFn: testFn}}
-return &Matcher{rules: rules}
+testFn func(T) (bool, string)
 }
 
-func (self *Matcher) name() string {
+func (self *Matcher[T]) name() string {
 if len(self.rules) == 0 {
 return "anything"
 }
 
 return strings.Join(
-lo.Map(self.rules, func(rule matcherRule, _ int) string { return rule.name }),
+lo.Map(self.rules, func(rule matcherRule[T], _ int) string { return rule.name }),
 ", ",
 )
 }
 
-func (self *Matcher) test(value string) (bool, string) {
+func (self *Matcher[T]) test(value T) (bool, string) {
 for _, rule := range self.rules {
 ok, message := rule.testFn(value)
 if ok {
@@ -57,8 +60,8 @@ func (self *Matcher) test(value string) (bool, string) {
 return true, ""
 }
 
-func (self *Matcher) Contains(target string) *Matcher {
-return self.appendRule(matcherRule{
+func (self *TextMatcher) Contains(target string) *TextMatcher {
+self.appendRule(matcherRule[string]{
 name: fmt.Sprintf("contains '%s'", target),
 testFn: func(value string) (bool, string) {
 // everything contains the empty string so we unconditionally return true here
@@ -69,19 +72,23 @@ func (self *Matcher) Contains(target string) *Matcher {
 return strings.Contains(value, target), fmt.Sprintf("Expected '%s' to be found in '%s'", target, value)
 },
 })
+
+return self
 }
 
-func (self *Matcher) DoesNotContain(target string) *Matcher {
-return self.appendRule(matcherRule{
+func (self *TextMatcher) DoesNotContain(target string) *TextMatcher {
+self.appendRule(matcherRule[string]{
 name: fmt.Sprintf("does not contain '%s'", target),
 testFn: func(value string) (bool, string) {
 return !strings.Contains(value, target), fmt.Sprintf("Expected '%s' to NOT be found in '%s'", target, value)
 },
 })
+
+return self
 }
 
-func (self *Matcher) MatchesRegexp(target string) *Matcher {
-return self.appendRule(matcherRule{
+func (self *TextMatcher) MatchesRegexp(target string) *TextMatcher {
+self.appendRule(matcherRule[string]{
 name: fmt.Sprintf("matches regular expression '%s'", target),
 testFn: func(value string) (bool, string) {
 matched, err := regexp.MatchString(target, value)
@@ -91,75 +98,130 @@ func (self *Matcher) MatchesRegexp(target string) *Matcher {
 return matched, fmt.Sprintf("Expected '%s' to match regular expression /%s/", value, target)
 },
 })
+
+return self
 }
 
-func (self *Matcher) Equals(target string) *Matcher {
-return self.appendRule(matcherRule{
+func (self *TextMatcher) Equals(target string) *TextMatcher {
+self.appendRule(matcherRule[string]{
 name: fmt.Sprintf("equals '%s'", target),
 testFn: func(value string) (bool, string) {
 return target == value, fmt.Sprintf("Expected '%s' to equal '%s'", value, target)
 },
 })
+
+return self
 }
 
 const IS_SELECTED_RULE_NAME = "is selected"
 
 // special rule that is only to be used in the TopLines and Lines methods, as a way of
 // asserting that a given line is selected.
-func (self *Matcher) IsSelected() *Matcher {
-return self.appendRule(matcherRule{
+func (self *TextMatcher) IsSelected() *TextMatcher {
+self.appendRule(matcherRule[string]{
 name: IS_SELECTED_RULE_NAME,
 testFn: func(value string) (bool, string) {
 panic("Special IsSelected matcher is not supposed to have its testFn method called. This rule should only be used within the .Lines() and .TopLines() method on a ViewAsserter.")
 },
 })
+
+return self
 }
 
-func (self *Matcher) appendRule(rule matcherRule) *Matcher {
+func (self *Matcher[T]) appendRule(rule matcherRule[T]) *Matcher[T] {
 self.rules = append(self.rules, rule)
 
 return self
 }
 
 // adds context so that if the matcher test(s) fails, we understand what we were trying to test.
 // E.g. prefix: "Unexpected content in view 'files'."
-func (self *Matcher) context(prefix string) *Matcher {
+func (self *Matcher[T]) context(prefix string) *Matcher[T] {
 self.prefix = prefix
 
 return self
 }
 
 // if the matcher has an `IsSelected` rule, it returns true, along with the matcher after that rule has been removed
-func (self *Matcher) checkIsSelected() (bool, *Matcher) {
+func (self *TextMatcher) checkIsSelected() (bool, *TextMatcher) {
 // copying into a new matcher in case we want to re-use the original later
-newMatcher := &Matcher{}
+newMatcher := &TextMatcher{}
 *newMatcher = *self
 
-check := lo.ContainsBy(newMatcher.rules, func(rule matcherRule) bool { return rule.name == IS_SELECTED_RULE_NAME })
+check := lo.ContainsBy(newMatcher.rules, func(rule matcherRule[string]) bool { return rule.name == IS_SELECTED_RULE_NAME })
 
-newMatcher.rules = lo.Filter(newMatcher.rules, func(rule matcherRule, _ int) bool { return rule.name != IS_SELECTED_RULE_NAME })
+newMatcher.rules = lo.Filter(newMatcher.rules, func(rule matcherRule[string], _ int) bool { return rule.name != IS_SELECTED_RULE_NAME })
 
 return check, newMatcher
 }
 
+func (self *IntMatcher) EqualsInt(target int) *IntMatcher {
+self.appendRule(matcherRule[int]{
+name: fmt.Sprintf("equals '%d'", target),
+testFn: func(value int) (bool, string) {
+return value == target, fmt.Sprintf("Expected '%d' to equal '%d'", value, target)
+},
+})
+
+return self
+}
+
+func (self *IntMatcher) GreaterThan(target int) *IntMatcher {
+self.appendRule(matcherRule[int]{
+name: fmt.Sprintf("greater than '%d'", target),
+testFn: func(value int) (bool, string) {
+return value > target, fmt.Sprintf("Expected '%d' to greater than '%d'", value, target)
+},
+})
+
+return self
+}
+
+func (self *IntMatcher) LessThan(target int) *IntMatcher {
+self.appendRule(matcherRule[int]{
+name: fmt.Sprintf("less than '%d'", target),
+testFn: func(value int) (bool, string) {
+return value < target, fmt.Sprintf("Expected '%d' to less than '%d'", value, target)
+},
+})
+
+return self
+}
+
 // this matcher has no rules meaning it always passes the test. Use this
 // when you don't care what value you're dealing with.
-func Anything() *Matcher {
-return &Matcher{}
+func AnyString() *TextMatcher {
+return &TextMatcher{Matcher: &Matcher[string]{}}
+}
+
+func Contains(target string) *TextMatcher {
+return AnyString().Contains(target)
+}
+
+func DoesNotContain(target string) *TextMatcher {
+return AnyString().DoesNotContain(target)
+}
+
+func MatchesRegexp(target string) *TextMatcher {
+return AnyString().MatchesRegexp(target)
+}
+
+func Equals(target string) *TextMatcher {
+return AnyString().Equals(target)
 }
 
-func Contains(target string) *Matcher {
-return Anything().Contains(target)
+func AnyInt() *IntMatcher {
+return &IntMatcher{Matcher: &Matcher[int]{}}
 }
 
-func DoesNotContain(target string) *Matcher {
-return Anything().DoesNotContain(target)
+func EqualsInt(target int) *IntMatcher {
+return AnyInt().EqualsInt(target)
 }
 
-func MatchesRegexp(target string) *Matcher {
-return Anything().MatchesRegexp(target)
+func GreaterThan(target int) *IntMatcher {
+return AnyInt().GreaterThan(target)
 }
 
-func Equals(target string) *Matcher {
-return Anything().Equals(target)
+func LessThan(target int) *IntMatcher {
+return AnyInt().LessThan(target)
 }

pkg/integration/components/menu_driver.go

@@ -10,7 +10,7 @@ func (self *MenuDriver) getViewDriver() *ViewDriver {
 }
 
 // asserts that the popup has the expected title
-func (self *MenuDriver) Title(expected *Matcher) *MenuDriver {
+func (self *MenuDriver) Title(expected *TextMatcher) *MenuDriver {
 self.getViewDriver().Title(expected)
 
 self.hasCheckedTitle = true
@@ -30,19 +30,19 @@ func (self *MenuDriver) Cancel() {
 self.getViewDriver().PressEscape()
 }
 
-func (self *MenuDriver) Select(option *Matcher) *MenuDriver {
+func (self *MenuDriver) Select(option *TextMatcher) *MenuDriver {
 self.getViewDriver().NavigateToLine(option)
 
 return self
 }
 
-func (self *MenuDriver) Lines(matchers ...*Matcher) *MenuDriver {
+func (self *MenuDriver) Lines(matchers ...*TextMatcher) *MenuDriver {
 self.getViewDriver().Lines(matchers...)
 
 return self
 }
 
-func (self *MenuDriver) TopLines(matchers ...*Matcher) *MenuDriver {
+func (self *MenuDriver) TopLines(matchers ...*TextMatcher) *MenuDriver {
 self.getViewDriver().TopLines(matchers...)
 
 return self