Add IsSubstringOf assertion

README.md

@@ -95,5 +95,5 @@ For the following types basic assertions are supported
     * [x] IsLowerCase
     * [x] IsNotEqualToIgnoringCase
     * [x] IsNotEqualToIgnoringWhitespace
-    * [ ] IsSubstringOf
+    * [x] IsSubstringOf
     * [x] IsUpperCase

assert/error_messages.go

@@ -113,6 +113,10 @@ func shouldNotContain(actual types.Assertable, elements interface{}) string {
 	return fmt.Sprintf("assertion failed: containable [%v] should not contain [%+v], but it does", actual.Value(), elements)
 }
 
+func shouldBeSubstringOf(actual types.Assertable, elements interface{}) string {
+	return fmt.Sprintf("assertion failed: containable [%v] should be substring of [%+v], but it does", actual.Value(), elements)
+}
+
 func shouldBeMap(actual types.Assertable) string {
 	return fmt.Sprintf("assertion failed: assertable should be a map but it is %T", reflect.ValueOf(actual.Value()).Kind())
 }

assert/string.go

@@ -195,6 +195,16 @@ func (a AssertableString) DoesNotContain(substring string) AssertableString {
 	return a
 }
 
+// IsSubstringOf asserts if the assertable string is a substring of the given element
+// It errors the test if it does not contain it.
+func (a AssertableString) IsSubstringOf(someString string) AssertableString {
+	a.t.Helper()
+	if !a.actual.IsSubstringOf(someString) {
+		a.t.Error(shouldBeSubstringOf(a.actual, someString))
+	}
+	return a
+}
+
 // StartsWith asserts if the assertable string starts with the given substring
 // It errors the test if it doesn't start with the given substring.
 func (a AssertableString) StartsWith(substring string) AssertableString {

assert/string_test.go

@@ -527,6 +527,50 @@ func TestAssertableString_DoesNotContain(t *testing.T) {
 	}
 }
 
+func TestAssertableString_IsSubstringOf(t *testing.T) {
+	tests := []struct {
+		name            string
+		actual          string
+		containerString string
+		shouldFail      bool
+		stringOpts      []StringOpt
+	}{
+		{
+			name:            "should succeed if it does not contain the expected sub-string",
+			actual:          "happy man",
+			containerString: "I'm a happy man",
+			shouldFail:      false,
+		},
+		{
+			name:            "should fail if it is substring of the containerString",
+			actual:          "I'M a HAPPY",
+			containerString: "I'm a happy man",
+			shouldFail:      true,
+		},
+		{
+			name:            "should succeed if it is substring of the containerString with ignoring case",
+			actual:          "I'M a HAPPY",
+			containerString: "I'm a happy man",
+			shouldFail:      false,
+			stringOpts:      []StringOpt{IgnoringCase()},
+		},
+		{
+			name:            "should succeed if is is an empty string",
+			actual:          "",
+			containerString: "I'm a happy man",
+			shouldFail:      false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			test := &testing.T{}
+			ft := NewFluentT(test)
+			ft.AssertThatString(tt.actual, tt.stringOpts...).IsSubstringOf(tt.containerString)
+			ThatBool(t, test.Failed()).IsEqualTo(tt.shouldFail)
+		})
+	}
+}
+
 func TestAssertableString_StartsWith(t *testing.T) {
 	tests := []struct {
 		name       string

internal/pkg/values/string_value.go

@@ -75,6 +75,11 @@ func (s StringValue) DoesNotContain(expected interface{}) bool {
 	return !s.Contains(s.decoratedValue(expected))
 }
 
+// IsSubstringOf returns true if the string is substring of the given string.
+func (s StringValue) IsSubstringOf(expected interface{}) bool {
+	return strings.Contains(NewStringValue(s.decoratedValue(expected)).value, s.DecoratedValue())
+}
+
 // HasSize returns true if the string has the expected size else false.
 func (s StringValue) HasSize(length int) bool {
 	return s.Size() == length