implements string assertion has less size than (#33)

* implements string assertion has less size than

* update docs

README.md

@@ -83,11 +83,11 @@ For the following types basic assertions are supported
     * [x] DoesNotStartWith
     * [x] EndsWith
     * [ ] HasLineCount
-    * [ ] HasSameSizeAs
+    * [x] HasSameSizeAs
     * [ ] HasSizeBetween
     * [ ] HasSizeGreaterThan
     * [ ] HasSizeGreaterThanOrEqualTo
-    * [ ] HasSizeLessThan
+    * [x] HasSizeLessThan
     * [ ] HasSizeLessThanOrEqualTo
     * [x] IsEqualToIgnoringCase
     * [ ] IsEqualToIgnoringNewLines

assert/error_messages.go

@@ -161,6 +161,10 @@ func shouldHaveSameSizeAs(actual types.Assertable, substr string) string {
 	return fmt.Sprintf("assertion failed: expected size of [%v] should be same as the size of [%+v], but it isn't", actual.Value(), substr)
 }
 
+func shouldHaveLessSizeThan(actual types.Assertable, substr string) string {
+	return fmt.Sprintf("assertion failed: expected size of [%v] should be less than the size of [%+v], but it isn't", actual.Value(), substr)
+}
+
 func shouldHaveType(actual types.Assertable, value interface{}) string {
 	return fmt.Sprintf("assertion failed: expected value of = %+v, to have type of %T but it hasn't", actual.Value(), value)
 }

assert/string.go

@@ -219,12 +219,21 @@ func (a AssertableString) DoesNotEndWith(substring string) AssertableString {
 // HasSameSizeAs asserts if the assertable string has the same size with the given string
 // It errors the test if they don't have the same size.
 func (a AssertableString) HasSameSizeAs(substring string) AssertableString {
-	if !(a.actual.Size() == len(substring)) {
+	if !(a.actual.HasSize(len(substring))) {
 		a.t.Error(shouldHaveSameSizeAs(a.actual, substring))
 	}
 	return a
 }
 
+// HasSizeLessThan asserts if the assertable string's length is less than the size of the given string
+// It errors the test if they don't have the same size.
+func (a AssertableString) HasSizeLessThan(substring string) AssertableString {
+	if !(a.actual.HasSizeLessThan(len(substring))) {
+		a.t.Error(shouldHaveLessSizeThan(a.actual, substring))
+	}
+	return a
+}
+
 // ContainsOnlyDigits asserts if the expected string contains only digits
 // It errors the tests if the string has other characters than digits.
 func (a AssertableString) ContainsOnlyDigits() AssertableString {

assert/string_test.go

@@ -645,6 +645,42 @@ func TestAssertableString_HasSameSizeAs(t *testing.T) {
 	}
 }
 
+func TestAssertableString_HasSizeLessThan(t *testing.T) {
+	tests := []struct {
+		name       string
+		actual     string
+		substring  string
+		shouldFail bool
+	}{
+		{
+			name:       "should fail if it has the same size",
+			actual:     "I'm a happy man",
+			substring:  "I'm a happy orc",
+			shouldFail: true,
+		},
+		{
+			name:       "should fail if it has bigger size",
+			actual:     "I'm a happy big man",
+			substring:  "I'm a happy orc",
+			shouldFail: true,
+		},
+		{
+			name:       "should succeed if it has less size",
+			actual:     "I'm a happy man",
+			substring:  "I'm a happy woman",
+			shouldFail: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			test := &testing.T{}
+			ft := NewFluentT(test)
+			ft.AssertThatString(tt.actual).HasSizeLessThan(tt.substring)
+			ThatBool(t, test.Failed()).IsEqualTo(tt.shouldFail)
+		})
+	}
+}
+
 func TestAssertableString_ContainsOnlyDigits(t *testing.T) {
 	tests := []struct {
 		name       string

internal/pkg/values/string_value.go

@@ -80,6 +80,11 @@ func (s StringValue) HasSize(length int) bool {
 	return s.Size() == length
 }
 
+// HasSizeLessThan returns true if the string has size less than the given value else false.
+func (s StringValue) HasSizeLessThan(length int) bool {
+	return s.Size() < length
+}
+
 // Size returns the string size.
 func (s StringValue) Size() int {
 	return len(s.value)