Do not use internal package

Author: tomas-novotny

assert.go

@@ -1,7 +1,7 @@
 package assert
 
 import (
-	"github.com/gravitton/assert/internal"
+	"errors"
 )
 
 // Testing is an interface wrapper around *testing.T
@@ -16,7 +16,7 @@ type Testing interface {
 func True(t Testing, condition bool) bool {
 	t.Helper()
 
-	if !internal.Assert(condition) {
+	if !condition {
 		return Fail(t, "Should be true")
 	}
 
@@ -29,7 +29,7 @@ func True(t Testing, condition bool) bool {
 func False(t Testing, condition bool) bool {
 	t.Helper()
 
-	if internal.Assert(condition) {
+	if condition {
 		return Fail(t, "Should be false")
 	}
 
@@ -45,7 +45,7 @@ func False(t Testing, condition bool) bool {
 func Equal(t Testing, actual, expected any) bool {
 	t.Helper()
 
-	if !internal.Equal(actual, expected) {
+	if !equal(actual, expected) {
 		return Failf(t, "Should be equal:\n  actual: %#v\nexpected: %#v", actual, expected)
 	}
 
@@ -61,7 +61,7 @@ func Equal(t Testing, actual, expected any) bool {
 func NotEqual(t Testing, actual, expected any) bool {
 	t.Helper()
 
-	if internal.Equal(actual, expected) {
+	if equal(actual, expected) {
 		return Failf(t, "Should not be equal\n  actual: %#v", actual)
 	}
 
@@ -72,12 +72,12 @@ func NotEqual(t Testing, actual, expected any) bool {
 //
 //	assert.Same(t, actual, expected)
 //
-// Both arguments must be pointer variables. Pointer variable sameness is
+// Both arguments must be pointer variables. Pointer variable equality is
 // determined based on the equality of both type and value.
 func Same(t Testing, actual, expected any) bool {
 	t.Helper()
 
-	if !internal.Same(expected, actual) {
+	if !same(expected, actual) {
 		return Failf(t, "Should be same\n  actual: %[1]p %#[1]v\nexpected: %[2]p %#[2]v", actual, expected)
 	}
 
@@ -88,32 +88,40 @@ func Same(t Testing, actual, expected any) bool {
 //
 //	assert.NotSame(t, actual, expected)
 //
-// Both arguments must be pointer variables. Pointer variable sameness is
+// Both arguments must be pointer variables. Pointer variable equality is
 // determined based on the equality of both type and value.
 func NotSame(t Testing, actual, expected any) bool {
 	t.Helper()
 
-	if internal.Same(expected, actual) {
+	if same(expected, actual) {
 		return Failf(t, "Should not be same\n  actual: %[1]p %#[1]v", actual)
 	}
 
 	return true
 }
 
+// Length asserts that object have given length.
+//
+//	assert.Length(t, object, expected)
 func Length(t Testing, object any, expected int) bool {
 	t.Helper()
 
-	if actual := internal.Length(object); actual != expected {
+	if actual := length(object); actual != expected {
 		return Failf(t, "Should have element length\n  object: %#v\n  actual: %d\nexpected: %d", object, actual, expected)
 	}
 
 	return true
 }
 
+// Contains asserts that object contains given element
+//
+//	assert.Contains(t, object, element)
+//
+// Works with strings, arrays, slices, maps values and channels
 func Contains(t Testing, object, element any) bool {
 	t.Helper()
 
-	if found, ok := internal.Contains(object, element); !ok {
+	if found, ok := contains(object, element); !ok {
 		return Failf(t, "Should be iterable\n  object: %#v", object)
 	} else if !found {
 		return Failf(t, "Should contain element\n  object: %#v\n element: %#v", object, element)
@@ -122,10 +130,15 @@ func Contains(t Testing, object, element any) bool {
 	return true
 }
 
+// NotContains asserts that object do NOT contains given element
+//
+//	assert.NotContains(t, object, element)
+//
+// Works with strings, arrays, slices, maps values and channels
 func NotContains(t Testing, object any, element any) bool {
 	t.Helper()
 
-	if found, ok := internal.Contains(object, element); !ok {
+	if found, ok := contains(object, element); !ok {
 		return Failf(t, "Should be iterable\n  object: %#v", object)
 	} else if found {
 		return Failf(t, "Should not contain element\n  object: %#v\n element: %#v", object, element)
@@ -134,47 +147,59 @@ func NotContains(t Testing, object any, element any) bool {
 	return true
 }
 
+// Error asserts that error is NOT nil
+//
+//	assert.Error(t, err)
 func Error(t Testing, err error) bool {
 	t.Helper()
 
-	if !internal.Error(err) {
+	if err == nil {
 		return Failf(t, "Should be error")
 	}
 
 	return true
 }
 
+// NoError asserts that error is nil
+//
+//	assert.NoError(t, err)
 func NoError(t Testing, err error) bool {
 	t.Helper()
 
-	if internal.Error(err) {
+	if err != nil {
 		return Failf(t, "Should not be error\n   error: %#v", err)
 	}
 
 	return true
 }
 
+// ErrorIs asserts that error is unwrappable to given target
+//
+//	assert.ErrorIs(t, err)
 func ErrorIs(t Testing, err error, target error) bool {
 	t.Helper()
 
-	if !internal.ErrorIs(err, target) {
+	if !errors.Is(err, target) {
 		return Failf(t, "Should be same error\n   error: %#v\n  target: %#v", err, target)
 	}
 
 	return true
 }
 
+// NotErrorIs asserts that error is NOT unwrappable to given target
+//
+//	assert.NotErrorIs(t, err)
 func NotErrorIs(t Testing, err error, target error) bool {
 	t.Helper()
 
-	if internal.ErrorIs(err, target) {
+	if errors.Is(err, target) {
 		return Failf(t, "Should not be same error\n   error: %#v", err, target)
 	}
 
 	return true
 }
 
-// Fail reports a failure through
+// Fail reports a failure message through
 func Fail(t Testing, message string) bool {
 	t.Helper()
 
@@ -183,7 +208,7 @@ func Fail(t Testing, message string) bool {
 	return false
 }
 
-// Failf reports a failure through
+// Failf reports a failure formatted message through
 func Failf(t Testing, format string, args ...any) bool {
 	t.Helper()
 

internal/assert.go internal.gointernal/assert.go renamed to internal.go

@@ -1,32 +1,27 @@
-package internal
+package assert
 
 import (
-	"errors"
 	"reflect"
 	"strings"
 )
 
-func Assert(condition bool) bool {
-	return condition
-}
-
-func Equal(actual, expected any) bool {
+func equal(actual, expected any) bool {
 	return reflect.DeepEqual(actual, expected)
 }
 
-func Same(actual, expected any) bool {
+func same(actual, expected any) bool {
 	if reflect.ValueOf(actual).Kind() != reflect.Ptr || reflect.ValueOf(expected).Kind() != reflect.Ptr {
 		return false
 	}
 
 	return actual == expected
 }
 
-func Length(object any) int {
+func length(object any) int {
 	return reflect.ValueOf(object).Len()
 }
 
-func Contains(object any, element any) (found bool, ok bool) {
+func contains(object any, element any) (found bool, ok bool) {
 	valueOf := reflect.ValueOf(object)
 	typeOf := reflect.TypeOf(object)
 	if typeOf == nil {
@@ -41,26 +36,18 @@ func Contains(object any, element any) (found bool, ok bool) {
 
 	if kind == reflect.Map {
 		for _, key := range valueOf.MapKeys() {
-			if Equal(valueOf.MapIndex(key).Interface(), element) {
+			if equal(valueOf.MapIndex(key).Interface(), element) {
 				return true, true
 			}
 		}
 		return false, true
 	}
 
 	for i := 0; i < valueOf.Len(); i++ {
-		if Equal(valueOf.Index(i).Interface(), element) {
+		if equal(valueOf.Index(i).Interface(), element) {
 			return true, true
 		}
 	}
 
 	return false, true
 }
-
-func Error(err error) bool {
-	return err != nil
-}
-
-func ErrorIs(err, target error) bool {
-	return errors.Is(err, target)
-}