From 662c4eb9b09d7a886684bc690c12143234c89957 Mon Sep 17 00:00:00 2001 From: koodeex Date: Fri, 12 Aug 2022 02:24:14 +0300 Subject: [PATCH 01/12] [ISSUE-20] add Exactly, Same, NotSame, EqualValues, NotEqualValues, EqualError, ErrorAs, NotSubset, ElementsMatch, DirExists, Condition, Zero, NotZero asserts --- .../asserts_wrapper/asserts/asserts.go | 66 +++++ .../asserts_wrapper/helper/helper.go | 65 +++++ .../asserts_wrapper/require/require.go | 66 +++++ .../asserts_wrapper/wrapper/interfaces.go | 19 +- .../asserts_wrapper/wrapper/wrapper.go | 233 ++++++++++++++++++ pkg/framework/provider/test.go | 14 ++ 6 files changed, 462 insertions(+), 1 deletion(-) diff --git a/pkg/framework/asserts_wrapper/asserts/asserts.go b/pkg/framework/asserts_wrapper/asserts/asserts.go index 0ea945e..0734c24 100644 --- a/pkg/framework/asserts_wrapper/asserts/asserts.go +++ b/pkg/framework/asserts_wrapper/asserts/asserts.go @@ -5,6 +5,7 @@ import ( "github.com/ozontech/allure-go/pkg/allure" "github.com/ozontech/allure-go/pkg/framework/asserts_wrapper/wrapper" + "github.com/stretchr/testify/assert" ) type ProviderT interface { @@ -13,6 +14,21 @@ type ProviderT interface { FailNow() } +// Exactly ... +func Exactly(t ProviderT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) { + wrapper.NewAsserts(t).Exactly(t, expected, actual, msgAndArgs...) +} + +// Same ... +func Same(t ProviderT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) { + wrapper.NewAsserts(t).Same(t, expected, actual, msgAndArgs...) +} + +// NotSame ... +func NotSame(t ProviderT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) { + wrapper.NewAsserts(t).NotSame(t, expected, actual, msgAndArgs...) +} + // Equal ... func Equal(t ProviderT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) { wrapper.NewAsserts(t).Equal(t, expected, actual, msgAndArgs...) @@ -23,6 +39,16 @@ func NotEqual(t ProviderT, expected interface{}, actual interface{}, msgAndArgs wrapper.NewAsserts(t).NotEqual(t, expected, actual, msgAndArgs...) } +// EqualValues ... +func EqualValues(t ProviderT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) { + wrapper.NewAsserts(t).EqualValues(t, expected, actual, msgAndArgs) +} + +// NotEqualValues ... +func NotEqualValues(t ProviderT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) { + wrapper.NewAsserts(t).NotEqualValues(t, expected, actual, msgAndArgs) +} + // Error ... func Error(t ProviderT, err error, msgAndArgs ...interface{}) { wrapper.NewAsserts(t).Error(t, err, msgAndArgs...) @@ -33,6 +59,16 @@ func NoError(t ProviderT, err error, msgAndArgs ...interface{}) { wrapper.NewAsserts(t).NoError(t, err, msgAndArgs...) } +// EqualError ... +func EqualError(t ProviderT, theError error, errString string, msgAndArgs ...interface{}) { + wrapper.NewAsserts(t).EqualError(t, theError, errString, msgAndArgs...) +} + +// ErrorAs ... +func ErrorAs(t ProviderT, err error, target interface{}, msgAndArgs ...interface{}) { + wrapper.NewAsserts(t).ErrorAs(t, err, target, msgAndArgs...) +} + // NotNil ... func NotNil(t ProviderT, object interface{}, msgAndArgs ...interface{}) { wrapper.NewAsserts(t).NotNil(t, object, msgAndArgs...) @@ -113,6 +149,11 @@ func Subset(t ProviderT, list, subset interface{}, msgAndArgs ...interface{}) { wrapper.NewAsserts(t).Subset(t, list, subset, msgAndArgs...) } +// NotSubset ... +func NotSubset(t ProviderT, list, subset interface{}, msgAndArgs ...interface{}) { + wrapper.NewAsserts(t).NotSubset(t, list, subset, msgAndArgs...) +} + // IsType ... func IsType(t ProviderT, expectedType interface{}, object interface{}, msgAndArgs ...interface{}) { wrapper.NewAsserts(t).IsType(t, expectedType, object, msgAndArgs...) @@ -132,3 +173,28 @@ func False(t ProviderT, value bool, msgAndArgs ...interface{}) { func Regexp(t ProviderT, rx interface{}, str interface{}, msgAndArgs ...interface{}) { wrapper.NewAsserts(t).Regexp(t, rx, str, msgAndArgs...) } + +// ElementsMatch ... +func ElementsMatch(t ProviderT, listA interface{}, listB interface{}, msgAndArgs ...interface{}) { + wrapper.NewAsserts(t).Regexp(t, listA, listB, msgAndArgs...) +} + +// DirExists ... +func DirExists(t ProviderT, path string, msgAndArgs ...interface{}) { + wrapper.NewAsserts(t).DirExists(t, path, msgAndArgs...) +} + +// Condition ... +func Condition(t ProviderT, condition assert.Comparison, msgAndArgs ...interface{}) { + wrapper.NewAsserts(t).Condition(t, condition, msgAndArgs...) +} + +// Zero ... +func Zero(t ProviderT, i interface{}, msgAndArgs ...interface{}) { + wrapper.NewAsserts(t).Zero(t, i, msgAndArgs...) +} + +// NotZero ... +func NotZero(t ProviderT, i interface{}, msgAndArgs ...interface{}) { + wrapper.NewAsserts(t).NotZero(t, i, msgAndArgs...) +} diff --git a/pkg/framework/asserts_wrapper/helper/helper.go b/pkg/framework/asserts_wrapper/helper/helper.go index 51bb440..d904024 100644 --- a/pkg/framework/asserts_wrapper/helper/helper.go +++ b/pkg/framework/asserts_wrapper/helper/helper.go @@ -4,6 +4,7 @@ import ( "time" "github.com/ozontech/allure-go/pkg/framework/asserts_wrapper/wrapper" + "github.com/stretchr/testify/assert" ) type a struct { @@ -11,6 +12,21 @@ type a struct { asserts wrapper.AssertsWrapper } +// Exactly ... +func (a *a) Exactly(expected interface{}, actual interface{}, msgAndArgs ...interface{}) { + a.asserts.Exactly(a.t, expected, actual, msgAndArgs...) +} + +// Same ... +func (a *a) Same(expected interface{}, actual interface{}, msgAndArgs ...interface{}) { + a.asserts.Same(a.t, expected, actual, msgAndArgs...) +} + +// NotSame ... +func (a *a) NotSame(expected interface{}, actual interface{}, msgAndArgs ...interface{}) { + a.asserts.NotSame(a.t, expected, actual, msgAndArgs...) +} + // Equal ... func (a *a) Equal(expected interface{}, actual interface{}, msgAndArgs ...interface{}) { a.asserts.Equal(a.t, expected, actual, msgAndArgs...) @@ -21,6 +37,16 @@ func (a *a) NotEqual(expected interface{}, actual interface{}, msgAndArgs ...int a.asserts.NotEqual(a.t, expected, actual, msgAndArgs...) } +// EqualValues ... +func (a *a) EqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) { + a.asserts.EqualValues(a.t, expected, actual, msgAndArgs...) +} + +// NotEqualValues ... +func (a *a) NotEqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) { + a.asserts.NotEqualValues(a.t, expected, actual, msgAndArgs...) +} + // Error ... func (a *a) Error(err error, msgAndArgs ...interface{}) { a.asserts.Error(a.t, err, msgAndArgs...) @@ -31,6 +57,16 @@ func (a *a) NoError(err error, msgAndArgs ...interface{}) { a.asserts.NoError(a.t, err, msgAndArgs...) } +// EqualError ... +func (a *a) EqualError(theError error, errString string, msgAndArgs ...interface{}) { + a.asserts.EqualError(a.t, theError, errString, msgAndArgs...) +} + +// ErrorAs ... +func (a *a) ErrorAs(err error, target interface{}, msgAndArgs ...interface{}) { + a.asserts.ErrorAs(a.t, err, target, msgAndArgs...) +} + // Nil ... func (a *a) Nil(object interface{}, msgAndArgs ...interface{}) { a.asserts.Nil(a.t, object, msgAndArgs...) @@ -111,6 +147,10 @@ func (a *a) Subset(list, subset interface{}, msgAndArgs ...interface{}) { a.asserts.Subset(a.t, list, subset, msgAndArgs...) } +func (a *a) NotSubset(list, subset interface{}, msgAndArgs ...interface{}) { + a.asserts.NotSubset(a.t, list, subset, msgAndArgs...) +} + // IsType ... func (a *a) IsType(expectedType interface{}, object interface{}, msgAndArgs ...interface{}) { a.asserts.IsType(a.t, expectedType, object, msgAndArgs...) @@ -130,3 +170,28 @@ func (a *a) False(value bool, msgAndArgs ...interface{}) { func (a *a) Regexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) { a.asserts.Regexp(a.t, rx, str, msgAndArgs...) } + +// ElementsMatch ... +func (a *a) ElementsMatch(listA interface{}, listB interface{}, msgAndArgs ...interface{}) { + a.asserts.ElementsMatch(a.t, listA, listB, msgAndArgs...) +} + +// DirExists ... +func (a *a) DirExists(path string, msgAndArgs ...interface{}) { + a.asserts.DirExists(a.t, path, msgAndArgs...) +} + +// Condition ... +func (a *a) Condition(condition assert.Comparison, msgAndArgs ...interface{}) { + a.asserts.Condition(a.t, condition, msgAndArgs...) +} + +// Zero ... +func (a *a) Zero(i interface{}, msgAndArgs ...interface{}) { + a.asserts.Zero(a.t, i, msgAndArgs...) +} + +// NotZero ... +func (a *a) NotZero(i interface{}, msgAndArgs ...interface{}) { + a.asserts.NotZero(a.t, i, msgAndArgs...) +} diff --git a/pkg/framework/asserts_wrapper/require/require.go b/pkg/framework/asserts_wrapper/require/require.go index 2cd2473..36494e6 100644 --- a/pkg/framework/asserts_wrapper/require/require.go +++ b/pkg/framework/asserts_wrapper/require/require.go @@ -5,6 +5,7 @@ import ( "github.com/ozontech/allure-go/pkg/allure" "github.com/ozontech/allure-go/pkg/framework/asserts_wrapper/wrapper" + "github.com/stretchr/testify/assert" ) type ProviderT interface { @@ -13,6 +14,21 @@ type ProviderT interface { FailNow() } +// Exactly ... +func Exactly(t ProviderT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) { + wrapper.NewRequire(t).Exactly(t, expected, actual, msgAndArgs...) +} + +// Same ... +func Same(t ProviderT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) { + wrapper.NewRequire(t).Same(t, expected, actual, msgAndArgs...) +} + +// NotSame ... +func NotSame(t ProviderT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) { + wrapper.NewRequire(t).NotSame(t, expected, actual, msgAndArgs...) +} + // Equal ... func Equal(t ProviderT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) { wrapper.NewRequire(t).Equal(t, expected, actual, msgAndArgs...) @@ -23,6 +39,16 @@ func NotEqual(t ProviderT, expected interface{}, actual interface{}, msgAndArgs wrapper.NewRequire(t).NotEqual(t, expected, actual, msgAndArgs...) } +// EqualValues ... +func EqualValues(t ProviderT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) { + wrapper.NewRequire(t).EqualValues(t, expected, actual, msgAndArgs) +} + +// NotEqualValues ... +func NotEqualValues(t ProviderT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) { + wrapper.NewRequire(t).NotEqualValues(t, expected, actual, msgAndArgs) +} + // Error ... func Error(t ProviderT, err error, msgAndArgs ...interface{}) { wrapper.NewRequire(t).Error(t, err, msgAndArgs...) @@ -33,6 +59,16 @@ func NoError(t ProviderT, err error, msgAndArgs ...interface{}) { wrapper.NewRequire(t).NoError(t, err, msgAndArgs...) } +// EqualError ... +func EqualError(t ProviderT, theError error, errString string, msgAndArgs ...interface{}) { + wrapper.NewRequire(t).EqualError(t, theError, errString, msgAndArgs...) +} + +// ErrorAs ... +func ErrorAs(t ProviderT, err error, target interface{}, msgAndArgs ...interface{}) { + wrapper.NewRequire(t).ErrorAs(t, err, target, msgAndArgs...) +} + // NotNil ... func NotNil(t ProviderT, object interface{}, msgAndArgs ...interface{}) { wrapper.NewRequire(t).NotNil(t, object, msgAndArgs...) @@ -113,6 +149,11 @@ func Subset(t ProviderT, list, subset interface{}, msgAndArgs ...interface{}) { wrapper.NewRequire(t).Subset(t, list, subset, msgAndArgs...) } +// NotSubset ... +func NotSubset(t ProviderT, list, subset interface{}, msgAndArgs ...interface{}) { + wrapper.NewRequire(t).NotSubset(t, list, subset, msgAndArgs...) +} + // IsType ... func IsType(t ProviderT, expectedType interface{}, object interface{}, msgAndArgs ...interface{}) { wrapper.NewRequire(t).IsType(t, expectedType, object, msgAndArgs...) @@ -132,3 +173,28 @@ func False(t ProviderT, value bool, msgAndArgs ...interface{}) { func Regexp(t ProviderT, rx interface{}, str interface{}, msgAndArgs ...interface{}) { wrapper.NewRequire(t).Regexp(t, rx, str, msgAndArgs...) } + +// ElementsMatch ... +func ElementsMatch(t ProviderT, listA interface{}, listB interface{}, msgAndArgs ...interface{}) { + wrapper.NewRequire(t).Regexp(t, listA, listB, msgAndArgs...) +} + +// DirExists ... +func DirExists(t ProviderT, path string, msgAndArgs ...interface{}) { + wrapper.NewRequire(t).DirExists(t, path, msgAndArgs...) +} + +// Condition ... +func Condition(t ProviderT, condition assert.Comparison, msgAndArgs ...interface{}) { + wrapper.NewRequire(t).Condition(t, condition, msgAndArgs...) +} + +// Zero ... +func Zero(t ProviderT, i interface{}, msgAndArgs ...interface{}) { + wrapper.NewRequire(t).Zero(t, i, msgAndArgs...) +} + +// NotZero ... +func NotZero(t ProviderT, i interface{}, msgAndArgs ...interface{}) { + wrapper.NewRequire(t).NotZero(t, i, msgAndArgs...) +} diff --git a/pkg/framework/asserts_wrapper/wrapper/interfaces.go b/pkg/framework/asserts_wrapper/wrapper/interfaces.go index 61463b4..545c9e6 100644 --- a/pkg/framework/asserts_wrapper/wrapper/interfaces.go +++ b/pkg/framework/asserts_wrapper/wrapper/interfaces.go @@ -1,13 +1,24 @@ package wrapper -import "time" +import ( + "time" + + "github.com/stretchr/testify/assert" +) // AssertsWrapper ... type AssertsWrapper interface { + Exactly(provider Provider, expected interface{}, actual interface{}, msgAndArgs ...interface{}) + Same(provider Provider, expected interface{}, actual interface{}, msgAndArgs ...interface{}) + NotSame(provider Provider, expected interface{}, actual interface{}, msgAndArgs ...interface{}) Equal(provider Provider, expected interface{}, actual interface{}, msgAndArgs ...interface{}) NotEqual(provider Provider, expected interface{}, actual interface{}, msgAndArgs ...interface{}) + EqualValues(provider Provider, expected interface{}, actual interface{}, msgAndArgs ...interface{}) + NotEqualValues(provider Provider, expected interface{}, actual interface{}, msgAndArgs ...interface{}) Error(provider Provider, err error, msgAndArgs ...interface{}) NoError(provider Provider, err error, msgAndArgs ...interface{}) + EqualError(provider Provider, theError error, errString string, msgAndArgs ...interface{}) + ErrorAs(provider Provider, err error, target interface{}, msgAndArgs ...interface{}) NotNil(provider Provider, object interface{}, msgAndArgs ...interface{}) Nil(provider Provider, object interface{}, msgAndArgs ...interface{}) Len(provider Provider, object interface{}, length int, msgAndArgs ...interface{}) @@ -24,8 +35,14 @@ type AssertsWrapper interface { JSONEq(provider Provider, expected, actual string, msgAndArgs ...interface{}) JSONContains(provider Provider, expected, actual string, msgAndArgs ...interface{}) Subset(provider Provider, list, subset interface{}, msgAndArgs ...interface{}) + NotSubset(provider Provider, list, subset interface{}, msgAndArgs ...interface{}) IsType(provider Provider, expectedType interface{}, object interface{}, msgAndArgs ...interface{}) True(provider Provider, value bool, msgAndArgs ...interface{}) False(provider Provider, value bool, msgAndArgs ...interface{}) Regexp(provider Provider, rx interface{}, str interface{}, msgAndArgs ...interface{}) + ElementsMatch(provider Provider, listA interface{}, listB interface{}, msgAndArgs ...interface{}) + DirExists(provider Provider, path string, msgAndArgs ...interface{}) + Condition(provider Provider, condition assert.Comparison, msgAndArgs ...interface{}) + Zero(provider Provider, i interface{}, msgAndArgs ...interface{}) + NotZero(provider Provider, i interface{}, msgAndArgs ...interface{}) } diff --git a/pkg/framework/asserts_wrapper/wrapper/wrapper.go b/pkg/framework/asserts_wrapper/wrapper/wrapper.go index 751d5f9..93a630a 100644 --- a/pkg/framework/asserts_wrapper/wrapper/wrapper.go +++ b/pkg/framework/asserts_wrapper/wrapper/wrapper.go @@ -39,6 +39,57 @@ func NewRequire(t TestingT) AssertsWrapper { } } +// Exactly ... +func (a *asserts) Exactly(provider Provider, expected interface{}, actual interface{}, msgAndArgs ...interface{}) { + assertName := "Exactly" + expString, actString := formatUnequalValues(expected, actual) + success := a.resultHelper.withNewStep( + a.t, + provider, + assertName, + func(t TestingT) bool { return assert.Exactly(a.t, expected, actual, msgAndArgs...) }, + allure.NewParameters("Expected", expString, "Actual", actString), + msgAndArgs..., + ) + if !success && a.resultHelper.required { + a.t.FailNow() + } +} + +// Same ... +func (a *asserts) Same(provider Provider, expected interface{}, actual interface{}, msgAndArgs ...interface{}) { + assertName := "Same" + expString, actString := formatUnequalValues(expected, actual) + success := a.resultHelper.withNewStep( + a.t, + provider, + assertName, + func(t TestingT) bool { return assert.Same(a.t, expected, actual, msgAndArgs...) }, + allure.NewParameters("Expected", expString, "Actual", actString), + msgAndArgs..., + ) + if !success && a.resultHelper.required { + a.t.FailNow() + } +} + +// NotSame ... +func (a *asserts) NotSame(provider Provider, expected interface{}, actual interface{}, msgAndArgs ...interface{}) { + assertName := "Not Same" + expString, actString := formatUnequalValues(expected, actual) + success := a.resultHelper.withNewStep( + a.t, + provider, + assertName, + func(t TestingT) bool { return assert.NotSame(a.t, expected, actual, msgAndArgs...) }, + allure.NewParameters("Expected", expString, "Actual", actString), + msgAndArgs..., + ) + if !success && a.resultHelper.required { + a.t.FailNow() + } +} + // Equal ... func (a *asserts) Equal(provider Provider, expected interface{}, actual interface{}, msgAndArgs ...interface{}) { assertName := "Equal" @@ -73,6 +124,40 @@ func (a *asserts) NotEqual(provider Provider, expected interface{}, actual inter } } +// EqualValues ... +func (a *asserts) EqualValues(provider Provider, expected interface{}, actual interface{}, msgAndArgs ...interface{}) { + assertName := "Equal Values" + expString, actString := formatUnequalValues(expected, actual) + success := a.resultHelper.withNewStep( + a.t, + provider, + assertName, + func(t TestingT) bool { return assert.EqualValues(a.t, expected, actual, msgAndArgs...) }, + allure.NewParameters("Expected", expString, "Actual", actString), + msgAndArgs..., + ) + if !success && a.resultHelper.required { + a.t.FailNow() + } +} + +// NotEqualValues ... +func (a *asserts) NotEqualValues(provider Provider, expected interface{}, actual interface{}, msgAndArgs ...interface{}) { + assertName := "Not Equal Values" + expString, actString := formatUnequalValues(expected, actual) + success := a.resultHelper.withNewStep( + a.t, + provider, + assertName, + func(t TestingT) bool { return assert.NotEqualValues(t, expected, actual, msgAndArgs...) }, + allure.NewParameters("Expected", expString, "Actual", actString), + msgAndArgs..., + ) + if !success && a.resultHelper.required { + a.t.FailNow() + } +} + // Error ... func (a *asserts) Error(provider Provider, err error, msgAndArgs ...interface{}) { assertName := "Error" @@ -106,6 +191,56 @@ func (a *asserts) NoError(provider Provider, err error, msgAndArgs ...interface{ } } +// EqualError ... +func (a *asserts) EqualError(provider Provider, theError error, errString string, msgAndArgs ...interface{}) { + var ( + actualString string + + assertName = "Equal Error" + ) + + if theError != nil { + actualString = theError.Error() + } + success := a.resultHelper.withNewStep( + a.t, + provider, + assertName, + func(t TestingT) bool { return assert.EqualError(t, theError, errString, msgAndArgs...) }, + allure.NewParameters("Actual", actualString, "Expected", errString), + msgAndArgs..., + ) + + if !success && a.resultHelper.required { + a.t.FailNow() + } +} + +// ErrorAs ... +func (a *asserts) ErrorAs(provider Provider, err error, target interface{}, msgAndArgs ...interface{}) { + var ( + actualString string + + assertName = "Equal As" + ) + + if err != nil { + actualString = err.Error() + } + success := a.resultHelper.withNewStep( + a.t, + provider, + assertName, + func(t TestingT) bool { return assert.ErrorAs(t, err, target, msgAndArgs...) }, + allure.NewParameters("Actual", actualString, "Expected", fmt.Sprintf("%+v", target)), + msgAndArgs..., + ) + + if !success && a.resultHelper.required { + a.t.FailNow() + } +} + // Nil ... func (a *asserts) Nil(provider Provider, object interface{}, msgAndArgs ...interface{}) { assertName := "Nil" @@ -376,6 +511,23 @@ func (a *asserts) Subset(provider Provider, list, subset interface{}, msgAndArgs } } +// NotSubset ... +func (a *asserts) NotSubset(provider Provider, list, subset interface{}, msgAndArgs ...interface{}) { + assertName := "Not Subset" + listString, subsetString := formatUnequalValues(list, subset) + success := a.resultHelper.withNewStep( + a.t, + provider, + assertName, + func(t TestingT) bool { return assert.NotSubset(t, list, subset, msgAndArgs...) }, + allure.NewParameters("List", listString, "Subset", subsetString), + msgAndArgs..., + ) + if !success && a.resultHelper.required { + a.t.FailNow() + } +} + // IsType ... func (a *asserts) IsType(provider Provider, expectedType interface{}, object interface{}, msgAndArgs ...interface{}) { assertName := "Is Type" @@ -444,6 +596,87 @@ func (a *asserts) Regexp(provider Provider, rx interface{}, str interface{}, msg } } +// ElementsMatch ... +func (a *asserts) ElementsMatch(provider Provider, listA interface{}, listB interface{}, msgAndArgs ...interface{}) { + assertName := "Elements Match" + listAString, listBString := formatUnequalValues(listA, listB) + success := a.resultHelper.withNewStep( + a.t, + provider, + assertName, + func(t TestingT) bool { return assert.ElementsMatch(a.t, listA, listB, msgAndArgs...) }, + allure.NewParameters("ListA", listAString, "ListB", listBString), + msgAndArgs..., + ) + if !success && a.resultHelper.required { + a.t.FailNow() + } +} + +// DirExists ... +func (a *asserts) DirExists(provider Provider, path string, msgAndArgs ...interface{}) { + assertName := "Dir Exists" + success := a.resultHelper.withNewStep( + a.t, + provider, + assertName, + func(t TestingT) bool { return assert.DirExists(a.t, path, msgAndArgs...) }, + allure.NewParameters("Path", path), + msgAndArgs..., + ) + if !success && a.resultHelper.required { + a.t.FailNow() + } +} + +// Condition ... +func (a *asserts) Condition(provider Provider, condition assert.Comparison, msgAndArgs ...interface{}) { + assertName := "Condition" + success := a.resultHelper.withNewStep( + a.t, + provider, + assertName, + func(t TestingT) bool { return assert.Condition(a.t, condition, msgAndArgs...) }, + allure.NewParameters("Signature", fmt.Sprintf("%T", condition)), + msgAndArgs..., + ) + if !success && a.resultHelper.required { + a.t.FailNow() + } +} + +// Zero ... +func (a *asserts) Zero(provider Provider, i interface{}, msgAndArgs ...interface{}) { + assertName := "Zero" + success := a.resultHelper.withNewStep( + a.t, + provider, + assertName, + func(t TestingT) bool { return assert.Zero(a.t, i, msgAndArgs...) }, + allure.NewParameters("Target", i), + msgAndArgs..., + ) + if !success && a.resultHelper.required { + a.t.FailNow() + } +} + +// NotZero ... +func (a *asserts) NotZero(provider Provider, i interface{}, msgAndArgs ...interface{}) { + assertName := "Not Zero" + success := a.resultHelper.withNewStep( + a.t, + provider, + assertName, + func(t TestingT) bool { return assert.NotZero(a.t, i, msgAndArgs...) }, + allure.NewParameters("Target", i), + msgAndArgs..., + ) + if !success && a.resultHelper.required { + a.t.FailNow() + } +} + // formatUnequalValues takes two values of arbitrary types and returns string // representations appropriate to be presented to the user. // diff --git a/pkg/framework/provider/test.go b/pkg/framework/provider/test.go index 0b8b38a..b16158d 100644 --- a/pkg/framework/provider/test.go +++ b/pkg/framework/provider/test.go @@ -1,6 +1,7 @@ package provider import ( + "github.com/stretchr/testify/assert" "testing" "time" @@ -60,10 +61,17 @@ type StepCtx interface { // Asserts ... type Asserts interface { + Exactly(expected interface{}, actual interface{}, msgAndArgs ...interface{}) + Same(expected interface{}, actual interface{}, msgAndArgs ...interface{}) + NotSame(expected interface{}, actual interface{}, msgAndArgs ...interface{}) Equal(expected interface{}, actual interface{}, msgAndArgs ...interface{}) NotEqual(expected interface{}, actual interface{}, msgAndArgs ...interface{}) + EqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) + NotEqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) Error(err error, msgAndArgs ...interface{}) NoError(err error, msgAndArgs ...interface{}) + EqualError(theError error, errString string, msgAndArgs ...interface{}) + ErrorAs(err error, target interface{}, msgAndArgs ...interface{}) NotNil(object interface{}, msgAndArgs ...interface{}) Nil(object interface{}, msgAndArgs ...interface{}) Len(object interface{}, length int, msgAndArgs ...interface{}) @@ -80,8 +88,14 @@ type Asserts interface { JSONEq(expected, actual string, msgAndArgs ...interface{}) JSONContains(expected, actual string, msgAndArgs ...interface{}) Subset(list, subset interface{}, msgAndArgs ...interface{}) + NotSubset(list, subset interface{}, msgAndArgs ...interface{}) IsType(expectedType interface{}, object interface{}, msgAndArgs ...interface{}) True(value bool, msgAndArgs ...interface{}) False(value bool, msgAndArgs ...interface{}) Regexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) + ElementsMatch(listA interface{}, listB interface{}, msgAndArgs ...interface{}) + DirExists(path string, msgAndArgs ...interface{}) + Condition(condition assert.Comparison, msgAndArgs ...interface{}) + Zero(i interface{}, msgAndArgs ...interface{}) + NotZero(i interface{}, msgAndArgs ...interface{}) } From 3032b93ee9afaa7f3b1102fbd4ecbc395beec47f Mon Sep 17 00:00:00 2001 From: koodeex Date: Fri, 12 Aug 2022 02:24:44 +0300 Subject: [PATCH 02/12] [ISSUE-20] go fmt --- pkg/framework/provider/test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkg/framework/provider/test.go b/pkg/framework/provider/test.go index b16158d..1caf1f4 100644 --- a/pkg/framework/provider/test.go +++ b/pkg/framework/provider/test.go @@ -1,11 +1,11 @@ package provider import ( - "github.com/stretchr/testify/assert" "testing" "time" "github.com/ozontech/allure-go/pkg/allure" + "github.com/stretchr/testify/assert" ) type TestingT interface { From c84682003f59dad97531bf0f9177183908e678cf Mon Sep 17 00:00:00 2001 From: Sinyaev Anton Yuryevich Date: Mon, 15 Aug 2022 20:41:51 +0300 Subject: [PATCH 03/12] [ISSUE-20] add tests, fix interfaces for asserts --- .../asserts_wrapper/asserts/asserts.go | 11 +- .../asserts_wrapper/asserts/asserts_test.go | 602 +++++++- .../asserts_wrapper/helper/helper.go | 5 + .../asserts_wrapper/helper/interfaces.go | 15 + .../asserts_wrapper/require/require.go | 11 +- .../asserts_wrapper/require/requires_test.go | 597 ++++++++ .../asserts_wrapper/wrapper/interfaces.go | 1 + .../asserts_wrapper/wrapper/wrapper.go | 47 +- .../asserts_wrapper/wrapper/wrapper_test.go | 1217 ++++++++++++++++- pkg/framework/provider/test.go | 1 + 10 files changed, 2477 insertions(+), 30 deletions(-) diff --git a/pkg/framework/asserts_wrapper/asserts/asserts.go b/pkg/framework/asserts_wrapper/asserts/asserts.go index 0734c24..4b82fd8 100644 --- a/pkg/framework/asserts_wrapper/asserts/asserts.go +++ b/pkg/framework/asserts_wrapper/asserts/asserts.go @@ -41,12 +41,12 @@ func NotEqual(t ProviderT, expected interface{}, actual interface{}, msgAndArgs // EqualValues ... func EqualValues(t ProviderT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) { - wrapper.NewAsserts(t).EqualValues(t, expected, actual, msgAndArgs) + wrapper.NewAsserts(t).EqualValues(t, expected, actual, msgAndArgs...) } // NotEqualValues ... func NotEqualValues(t ProviderT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) { - wrapper.NewAsserts(t).NotEqualValues(t, expected, actual, msgAndArgs) + wrapper.NewAsserts(t).NotEqualValues(t, expected, actual, msgAndArgs...) } // Error ... @@ -64,6 +64,11 @@ func EqualError(t ProviderT, theError error, errString string, msgAndArgs ...int wrapper.NewAsserts(t).EqualError(t, theError, errString, msgAndArgs...) } +// ErrorIs ... +func ErrorIs(t ProviderT, err error, target error, msgAndArgs ...interface{}) { + wrapper.NewAsserts(t).ErrorIs(t, err, target, msgAndArgs...) +} + // ErrorAs ... func ErrorAs(t ProviderT, err error, target interface{}, msgAndArgs ...interface{}) { wrapper.NewAsserts(t).ErrorAs(t, err, target, msgAndArgs...) @@ -176,7 +181,7 @@ func Regexp(t ProviderT, rx interface{}, str interface{}, msgAndArgs ...interfac // ElementsMatch ... func ElementsMatch(t ProviderT, listA interface{}, listB interface{}, msgAndArgs ...interface{}) { - wrapper.NewAsserts(t).Regexp(t, listA, listB, msgAndArgs...) + wrapper.NewAsserts(t).ElementsMatch(t, listA, listB, msgAndArgs...) } // DirExists ... diff --git a/pkg/framework/asserts_wrapper/asserts/asserts_test.go b/pkg/framework/asserts_wrapper/asserts/asserts_test.go index ae979d9..8aa42e4 100644 --- a/pkg/framework/asserts_wrapper/asserts/asserts_test.go +++ b/pkg/framework/asserts_wrapper/asserts/asserts_test.go @@ -2,11 +2,11 @@ package asserts import ( "fmt" - "testing" - "time" - "github.com/pkg/errors" "github.com/stretchr/testify/require" + "os" + "testing" + "time" "github.com/ozontech/allure-go/pkg/allure" ) @@ -35,6 +35,146 @@ func (p *providerTMock) FailNow() { p.failNow = true } +func TestAssertExactly_Success(t *testing.T) { + mockT := newMock() + Exactly(mockT, 1, 1) + require.Len(t, mockT.steps, 1) + require.Equal(t, "ASSERT: Exactly", mockT.steps[0].Name) + require.Equal(t, allure.Passed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Expected", params[0].Name) + require.Equal(t, "1", params[0].Value) + require.Equal(t, "Actual", params[1].Name) + require.Equal(t, "1", params[1].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestAssertExactly_Fail(t *testing.T) { + mockT := newMock() + Exactly(mockT, 1, 2) + require.Len(t, mockT.steps, 1) + require.Equal(t, "ASSERT: Exactly", mockT.steps[0].Name) + require.Equal(t, allure.Failed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Expected", params[0].Name) + require.Equal(t, "1", params[0].Value) + require.Equal(t, "Actual", params[1].Name) + require.Equal(t, "2", params[1].Value) + + require.True(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + +func TestAssertSame_Success(t *testing.T) { + mockT := newMock() + type someStr struct { + } + exp := &someStr{} + act := exp + Same(mockT, exp, act) + require.Len(t, mockT.steps, 1) + require.Equal(t, "ASSERT: Same", mockT.steps[0].Name) + require.Equal(t, allure.Passed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Expected", params[0].Name) + require.Equal(t, fmt.Sprintf("%p", exp), params[0].Value) + require.Equal(t, "Actual", params[1].Name) + require.Equal(t, fmt.Sprintf("%p", act), params[1].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestAssertSame_Fail(t *testing.T) { + mockT := newMock() + type someStr struct { + someField string + } + exp := &someStr{} + act := &someStr{} + + Same(mockT, exp, act) + require.Len(t, mockT.steps, 1) + require.Equal(t, "ASSERT: Same", mockT.steps[0].Name) + require.Equal(t, allure.Failed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Expected", params[0].Name) + require.Equal(t, fmt.Sprintf("%p", exp), params[0].Value) + require.Equal(t, "Actual", params[1].Name) + require.Equal(t, fmt.Sprintf("%p", act), params[1].Value) + + require.True(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + +func TestAssertNotSame_Success(t *testing.T) { + mockT := newMock() + type someStr struct { + someField string + } + exp := &someStr{} + act := &someStr{} + + NotSame(mockT, exp, act) + require.Len(t, mockT.steps, 1) + require.Equal(t, "ASSERT: Not Same", mockT.steps[0].Name) + require.Equal(t, allure.Passed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Expected", params[0].Name) + require.Equal(t, "&asserts.someStr{someField:\"\"}", params[0].Value) + require.Equal(t, "Actual", params[1].Name) + require.Equal(t, "&asserts.someStr{someField:\"\"}", params[1].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestAssertNotSame_Fail(t *testing.T) { + mockT := newMock() + type someStr struct { + } + exp := &someStr{} + act := exp + NotSame(mockT, exp, act) + require.Len(t, mockT.steps, 1) + require.Equal(t, "ASSERT: Not Same", mockT.steps[0].Name) + require.Equal(t, allure.Failed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Expected", params[0].Name) + require.Equal(t, "&asserts.someStr{}", params[0].Value) + require.Equal(t, "Actual", params[1].Name) + require.Equal(t, "&asserts.someStr{}", params[1].Value) + + require.True(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + func TestAssertEqual_Success(t *testing.T) { mockT := newMock() Equal(mockT, 1, 1) @@ -115,6 +255,86 @@ func TestAssertNotEqual_Fail(t *testing.T) { require.Equal(t, "\n%s", mockT.errorFString) } +func TestAssertEqualValues_Success(t *testing.T) { + mockT := newMock() + EqualValues(mockT, uint32(123), int32(123)) + require.Len(t, mockT.steps, 1) + require.Equal(t, "ASSERT: Equal Values", mockT.steps[0].Name) + require.Equal(t, allure.Passed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Expected", params[0].Name) + require.Equal(t, "uint32(0x7b)", params[0].Value) + require.Equal(t, "Actual", params[1].Name) + require.Equal(t, "int32(123)", params[1].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestAssertEqualValues_Fail(t *testing.T) { + mockT := newMock() + EqualValues(mockT, 1, "test") + require.Len(t, mockT.steps, 1) + require.Equal(t, "ASSERT: Equal Values", mockT.steps[0].Name) + require.Equal(t, allure.Failed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Expected", params[0].Name) + require.Equal(t, "int(1)", params[0].Value) + require.Equal(t, "Actual", params[1].Name) + require.Equal(t, "string(\"test\")", params[1].Value) + + require.True(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + +func TestAssertNotEqualValues_Success(t *testing.T) { + mockT := newMock() + NotEqualValues(mockT, 1, "test") + require.Len(t, mockT.steps, 1) + require.Equal(t, "ASSERT: Not Equal Values", mockT.steps[0].Name) + require.Equal(t, allure.Passed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Expected", params[0].Name) + require.Equal(t, "int(1)", params[0].Value) + require.Equal(t, "Actual", params[1].Name) + require.Equal(t, "string(\"test\")", params[1].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestAssertNotEqualValues_Fail(t *testing.T) { + mockT := newMock() + NotEqualValues(mockT, uint32(123), int32(123)) + require.Len(t, mockT.steps, 1) + require.Equal(t, "ASSERT: Not Equal Values", mockT.steps[0].Name) + require.Equal(t, allure.Failed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Expected", params[0].Name) + require.Equal(t, "uint32(0x7b)", params[0].Value) + require.Equal(t, "Actual", params[1].Name) + require.Equal(t, "int32(123)", params[1].Value) + + require.True(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + func TestAssertError_Success(t *testing.T) { mockT := newMock() err := errors.New("kek") @@ -189,6 +409,151 @@ func TestAssertNoError_Fail(t *testing.T) { require.Equal(t, "\n%s", mockT.errorFString) } +func TestAssertEqualError_Success(t *testing.T) { + mockT := newMock() + exp := "testErr" + err := errors.New(exp) + EqualError(mockT, err, exp) + require.Len(t, mockT.steps, 1) + require.Equal(t, "ASSERT: Equal Error", mockT.steps[0].Name) + require.Equal(t, allure.Passed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Actual", params[0].Name) + require.Equal(t, err.Error(), params[0].Value) + require.Equal(t, "Expected", params[1].Name) + require.Equal(t, exp, params[1].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestAssertEqualError_Fail(t *testing.T) { + mockT := newMock() + exp := "testErr2" + actual := "testErr" + err := errors.New(actual) + EqualError(mockT, err, exp) + require.Len(t, mockT.steps, 1) + require.Equal(t, "ASSERT: Equal Error", mockT.steps[0].Name) + require.Equal(t, allure.Failed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Actual", params[0].Name) + require.Equal(t, err.Error(), params[0].Value) + require.Equal(t, "Expected", params[1].Name) + require.Equal(t, exp, params[1].Value) + + require.True(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + +func TestAssertErrorIs_Success(t *testing.T) { + mockT := newMock() + exp := "testErr" + err := fmt.Errorf(exp) + errNew := errors.Wrap(err, "NewMessage") + ErrorIs(mockT, errNew, err) + require.Len(t, mockT.steps, 1) + require.Equal(t, "ASSERT: Error Is", mockT.steps[0].Name) + require.Equal(t, allure.Passed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Error", params[0].Name) + require.Equal(t, errNew.Error(), params[0].Value) + require.Equal(t, "Target", params[1].Name) + require.Equal(t, exp, params[1].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +type fakeError struct { + input string +} + +func (f *fakeError) Error() string { + return fmt.Sprintf("fake error: %s", f.input) +} + +func TestAssertErrorIs_Fail(t *testing.T) { + mockT := newMock() + + var err = fakeError{"some"} + errNew := errors.Wrap(fmt.Errorf("other"), "NewMessage") + ErrorIs(mockT, errNew, &err) + require.Len(t, mockT.steps, 1) + require.Equal(t, "ASSERT: Error Is", mockT.steps[0].Name) + require.Equal(t, allure.Failed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Error", params[0].Name) + require.Equal(t, "NewMessage: other", params[0].Value) + require.Equal(t, "Target", params[1].Name) + require.Equal(t, "fake error: some", params[1].Value) + + require.True(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + +func TestAssertErrorAs_Success(t *testing.T) { + mockT := newMock() + exp := "testErr" + err := fmt.Errorf(exp) + errNew := errors.Wrap(err, "NewMessage") + ErrorAs(mockT, errNew, &err) + require.Len(t, mockT.steps, 1) + require.Equal(t, "ASSERT: Error As", mockT.steps[0].Name) + require.Equal(t, allure.Passed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Error", params[0].Name) + require.Equal(t, errNew.Error(), params[0].Value) + require.Equal(t, "Target", params[1].Name) + require.Equal(t, exp, params[1].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestAssertErrorAs_Fail(t *testing.T) { + mockT := newMock() + + var err *fakeError + errNew := errors.Wrap(fmt.Errorf("other"), "NewMessage") + ErrorAs(mockT, errNew, &err) + require.Len(t, mockT.steps, 1) + require.Equal(t, "ASSERT: Error As", mockT.steps[0].Name) + require.Equal(t, allure.Failed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Error", params[0].Name) + require.Equal(t, "NewMessage: other", params[0].Value) + require.Equal(t, "Target", params[1].Name) + require.Equal(t, fmt.Sprintf("**asserts.fakeError((**asserts.fakeError)(%+v))", &err), params[1].Value) + + require.True(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + func TestAssertNotNil_Success(t *testing.T) { mockT := newMock() object := struct{}{} @@ -1144,3 +1509,234 @@ func TestAssertRegexp_Fail(t *testing.T) { require.False(t, mockT.failNow) require.Equal(t, "\n%s", mockT.errorFString) } + +func TestAssertElementsMatch_Success(t *testing.T) { + mockT := newMock() + + listA := []int{1, 2, 3} + listB := []int{1, 2, 3} + ElementsMatch(mockT, listA, listB) + + steps := mockT.steps + require.Len(t, steps, 1) + require.Equal(t, "ASSERT: Elements Match", steps[0].Name) + require.Equal(t, allure.Passed, steps[0].Status) + + params := steps[0].Parameters + require.Len(t, params, 2) + + require.Equal(t, "ListA", params[0].Name) + require.Equal(t, fmt.Sprintf("%#v", listA), params[0].Value) + + require.Equal(t, "ListB", params[1].Name) + require.Equal(t, fmt.Sprintf("%#v", listB), params[1].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestAssertElementsMatch_Fail(t *testing.T) { + mockT := newMock() + + listA := []int{1, 2, 3} + listB := []int{4, 3} + ElementsMatch(mockT, listA, listB) + + steps := mockT.steps + require.Len(t, steps, 1) + require.Equal(t, "ASSERT: Elements Match", steps[0].Name) + require.Equal(t, allure.Failed, steps[0].Status) + + params := steps[0].Parameters + require.Len(t, params, 2) + + require.Equal(t, "ListA", params[0].Name) + require.Equal(t, fmt.Sprintf("%#v", listA), params[0].Value) + + require.Equal(t, "ListB", params[1].Name) + require.Equal(t, fmt.Sprintf("%#v", listB), params[1].Value) + + require.True(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + +func TestAssertDirExists_Success(t *testing.T) { + dirName := "test" + err := os.Mkdir(dirName, 0644) + require.NoError(t, err, "Can't create folder to begin test") + defer os.RemoveAll(dirName) + + mockT := newMock() + DirExists(mockT, dirName) + steps := mockT.steps + require.Len(t, steps, 1) + require.Equal(t, "ASSERT: Dir Exists", steps[0].Name) + require.Equal(t, allure.Passed, steps[0].Status) + + params := steps[0].Parameters + require.Len(t, params, 1) + + require.Equal(t, "Path", params[0].Name) + require.Equal(t, dirName, params[0].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestAssertDirExists_Fail(t *testing.T) { + dirName := "test" + + mockT := newMock() + DirExists(mockT, dirName) + steps := mockT.steps + require.Len(t, steps, 1) + require.Equal(t, "ASSERT: Dir Exists", steps[0].Name) + require.Equal(t, allure.Failed, steps[0].Status) + + params := steps[0].Parameters + require.Len(t, params, 1) + + require.Equal(t, "Path", params[0].Name) + require.Equal(t, dirName, params[0].Value) + + require.True(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + +func TestAssertCondition_Success(t *testing.T) { + test := false + conditionFunc := func() bool { + test = true + return test + } + mockT := newMock() + Condition(mockT, conditionFunc) + steps := mockT.steps + require.True(t, test) + require.Len(t, steps, 1) + require.Equal(t, "ASSERT: Condition", steps[0].Name) + require.Equal(t, allure.Passed, steps[0].Status) + + params := steps[0].Parameters + require.Len(t, params, 1) + + require.Equal(t, "Signature", params[0].Name) + require.Equal(t, "assert.Comparison", params[0].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestAssertCondition_Fail(t *testing.T) { + test := false + conditionFunc := func() bool { + test = true + return !test + } + mockT := newMock() + Condition(mockT, conditionFunc) + steps := mockT.steps + require.True(t, test) + require.Len(t, steps, 1) + require.Equal(t, "ASSERT: Condition", steps[0].Name) + require.Equal(t, allure.Failed, steps[0].Status) + + params := steps[0].Parameters + require.Len(t, params, 1) + + require.Equal(t, "Signature", params[0].Name) + require.Equal(t, "assert.Comparison", params[0].Value) + + require.True(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + +func TestAssertZero_Success(t *testing.T) { + mockT := newMock() + + Zero(mockT, 0) + + steps := mockT.steps + require.Len(t, steps, 1) + require.Equal(t, "ASSERT: Zero", steps[0].Name) + require.Equal(t, allure.Passed, steps[0].Status) + + params := steps[0].Parameters + require.Len(t, params, 1) + + require.Equal(t, "Target", params[0].Name) + require.Equal(t, "0", params[0].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestAssertZero_Fail(t *testing.T) { + mockT := newMock() + + Zero(mockT, 1) + + steps := mockT.steps + require.Len(t, steps, 1) + require.Equal(t, "ASSERT: Zero", steps[0].Name) + require.Equal(t, allure.Failed, steps[0].Status) + + params := steps[0].Parameters + require.Len(t, params, 1) + + require.Equal(t, "Target", params[0].Name) + require.Equal(t, "1", params[0].Value) + + require.True(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + +func TestAssertNotZero_Success(t *testing.T) { + mockT := newMock() + + NotZero(mockT, 1) + + steps := mockT.steps + require.Len(t, steps, 1) + require.Equal(t, "ASSERT: Not Zero", steps[0].Name) + require.Equal(t, allure.Passed, steps[0].Status) + + params := steps[0].Parameters + require.Len(t, params, 1) + + require.Equal(t, "Target", params[0].Name) + require.Equal(t, "1", params[0].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestAssertNotZero_Fail(t *testing.T) { + mockT := newMock() + + NotZero(mockT, 0) + + steps := mockT.steps + require.Len(t, steps, 1) + require.Equal(t, "ASSERT: Not Zero", steps[0].Name) + require.Equal(t, allure.Failed, steps[0].Status) + + params := steps[0].Parameters + require.Len(t, params, 1) + + require.Equal(t, "Target", params[0].Name) + require.Equal(t, "0", params[0].Value) + + require.True(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} diff --git a/pkg/framework/asserts_wrapper/helper/helper.go b/pkg/framework/asserts_wrapper/helper/helper.go index d904024..3448d02 100644 --- a/pkg/framework/asserts_wrapper/helper/helper.go +++ b/pkg/framework/asserts_wrapper/helper/helper.go @@ -62,6 +62,11 @@ func (a *a) EqualError(theError error, errString string, msgAndArgs ...interface a.asserts.EqualError(a.t, theError, errString, msgAndArgs...) } +// ErrorIs ... +func (a *a) ErrorIs(err error, target error, msgAndArgs ...interface{}) { + a.asserts.ErrorIs(a.t, err, target, msgAndArgs...) +} + // ErrorAs ... func (a *a) ErrorAs(err error, target interface{}, msgAndArgs ...interface{}) { a.asserts.ErrorAs(a.t, err, target, msgAndArgs...) diff --git a/pkg/framework/asserts_wrapper/helper/interfaces.go b/pkg/framework/asserts_wrapper/helper/interfaces.go index 5f07d38..98ef4aa 100644 --- a/pkg/framework/asserts_wrapper/helper/interfaces.go +++ b/pkg/framework/asserts_wrapper/helper/interfaces.go @@ -4,6 +4,7 @@ import ( "time" "github.com/ozontech/allure-go/pkg/allure" + "github.com/stretchr/testify/assert" ) type ProviderT interface { @@ -14,10 +15,18 @@ type ProviderT interface { // AssertsHelper ... type AssertsHelper interface { + Exactly(expected interface{}, actual interface{}, msgAndArgs ...interface{}) + Same(expected interface{}, actual interface{}, msgAndArgs ...interface{}) + NotSame(expected interface{}, actual interface{}, msgAndArgs ...interface{}) Equal(expected interface{}, actual interface{}, msgAndArgs ...interface{}) NotEqual(expected interface{}, actual interface{}, msgAndArgs ...interface{}) + EqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) + NotEqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) Error(err error, msgAndArgs ...interface{}) NoError(err error, msgAndArgs ...interface{}) + EqualError(theError error, errString string, msgAndArgs ...interface{}) + ErrorIs(err error, target error, msgAndArgs ...interface{}) + ErrorAs(err error, target interface{}, msgAndArgs ...interface{}) NotNil(object interface{}, msgAndArgs ...interface{}) Nil(object interface{}, msgAndArgs ...interface{}) Len(object interface{}, length int, msgAndArgs ...interface{}) @@ -34,8 +43,14 @@ type AssertsHelper interface { JSONEq(expected, actual string, msgAndArgs ...interface{}) JSONContains(expected, actual string, msgAndArgs ...interface{}) Subset(list, subset interface{}, msgAndArgs ...interface{}) + NotSubset(list, subset interface{}, msgAndArgs ...interface{}) IsType(expectedType interface{}, object interface{}, msgAndArgs ...interface{}) True(value bool, msgAndArgs ...interface{}) False(value bool, msgAndArgs ...interface{}) Regexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) + ElementsMatch(listA interface{}, listB interface{}, msgAndArgs ...interface{}) + DirExists(path string, msgAndArgs ...interface{}) + Condition(condition assert.Comparison, msgAndArgs ...interface{}) + Zero(i interface{}, msgAndArgs ...interface{}) + NotZero(i interface{}, msgAndArgs ...interface{}) } diff --git a/pkg/framework/asserts_wrapper/require/require.go b/pkg/framework/asserts_wrapper/require/require.go index 36494e6..92a8b88 100644 --- a/pkg/framework/asserts_wrapper/require/require.go +++ b/pkg/framework/asserts_wrapper/require/require.go @@ -41,12 +41,12 @@ func NotEqual(t ProviderT, expected interface{}, actual interface{}, msgAndArgs // EqualValues ... func EqualValues(t ProviderT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) { - wrapper.NewRequire(t).EqualValues(t, expected, actual, msgAndArgs) + wrapper.NewRequire(t).EqualValues(t, expected, actual, msgAndArgs...) } // NotEqualValues ... func NotEqualValues(t ProviderT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) { - wrapper.NewRequire(t).NotEqualValues(t, expected, actual, msgAndArgs) + wrapper.NewRequire(t).NotEqualValues(t, expected, actual, msgAndArgs...) } // Error ... @@ -64,6 +64,11 @@ func EqualError(t ProviderT, theError error, errString string, msgAndArgs ...int wrapper.NewRequire(t).EqualError(t, theError, errString, msgAndArgs...) } +// ErrorIs ... +func ErrorIs(t ProviderT, err error, target error, msgAndArgs ...interface{}) { + wrapper.NewRequire(t).ErrorIs(t, err, target, msgAndArgs...) +} + // ErrorAs ... func ErrorAs(t ProviderT, err error, target interface{}, msgAndArgs ...interface{}) { wrapper.NewRequire(t).ErrorAs(t, err, target, msgAndArgs...) @@ -176,7 +181,7 @@ func Regexp(t ProviderT, rx interface{}, str interface{}, msgAndArgs ...interfac // ElementsMatch ... func ElementsMatch(t ProviderT, listA interface{}, listB interface{}, msgAndArgs ...interface{}) { - wrapper.NewRequire(t).Regexp(t, listA, listB, msgAndArgs...) + wrapper.NewRequire(t).ElementsMatch(t, listA, listB, msgAndArgs...) } // DirExists ... diff --git a/pkg/framework/asserts_wrapper/require/requires_test.go b/pkg/framework/asserts_wrapper/require/requires_test.go index 20e348f..6363dc7 100644 --- a/pkg/framework/asserts_wrapper/require/requires_test.go +++ b/pkg/framework/asserts_wrapper/require/requires_test.go @@ -2,6 +2,7 @@ package require import ( "fmt" + "os" "testing" "time" @@ -35,6 +36,146 @@ func (p *providerTMock) FailNow() { p.failNow = true } +func TestRequireExactly_Success(t *testing.T) { + mockT := newMock() + Exactly(mockT, 1, 1) + require.Len(t, mockT.steps, 1) + require.Equal(t, "REQUIRE: Exactly", mockT.steps[0].Name) + require.Equal(t, allure.Passed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Expected", params[0].Name) + require.Equal(t, "1", params[0].Value) + require.Equal(t, "Actual", params[1].Name) + require.Equal(t, "1", params[1].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestRequireExactly_Fail(t *testing.T) { + mockT := newMock() + Exactly(mockT, 1, 2) + require.Len(t, mockT.steps, 1) + require.Equal(t, "REQUIRE: Exactly", mockT.steps[0].Name) + require.Equal(t, allure.Failed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Expected", params[0].Name) + require.Equal(t, "1", params[0].Value) + require.Equal(t, "Actual", params[1].Name) + require.Equal(t, "2", params[1].Value) + + require.True(t, mockT.errorF) + require.True(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + +func TestRequireSame_Success(t *testing.T) { + mockT := newMock() + type someStr struct { + } + exp := &someStr{} + act := exp + Same(mockT, exp, act) + require.Len(t, mockT.steps, 1) + require.Equal(t, "REQUIRE: Same", mockT.steps[0].Name) + require.Equal(t, allure.Passed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Expected", params[0].Name) + require.Equal(t, fmt.Sprintf("%p", exp), params[0].Value) + require.Equal(t, "Actual", params[1].Name) + require.Equal(t, fmt.Sprintf("%p", act), params[1].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestRequireSame_Fail(t *testing.T) { + mockT := newMock() + type someStr struct { + someField string + } + exp := &someStr{} + act := &someStr{} + + Same(mockT, exp, act) + require.Len(t, mockT.steps, 1) + require.Equal(t, "REQUIRE: Same", mockT.steps[0].Name) + require.Equal(t, allure.Failed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Expected", params[0].Name) + require.Equal(t, fmt.Sprintf("%p", exp), params[0].Value) + require.Equal(t, "Actual", params[1].Name) + require.Equal(t, fmt.Sprintf("%p", act), params[1].Value) + + require.True(t, mockT.errorF) + require.True(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + +func TestRequireNotSame_Success(t *testing.T) { + mockT := newMock() + type someStr struct { + someField string + } + exp := &someStr{} + act := &someStr{} + + NotSame(mockT, exp, act) + require.Len(t, mockT.steps, 1) + require.Equal(t, "REQUIRE: Not Same", mockT.steps[0].Name) + require.Equal(t, allure.Passed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Expected", params[0].Name) + require.Equal(t, "&require.someStr{someField:\"\"}", params[0].Value) + require.Equal(t, "Actual", params[1].Name) + require.Equal(t, "&require.someStr{someField:\"\"}", params[1].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestRequireNotSame_Fail(t *testing.T) { + mockT := newMock() + type someStr struct { + } + exp := &someStr{} + act := exp + NotSame(mockT, exp, act) + require.Len(t, mockT.steps, 1) + require.Equal(t, "REQUIRE: Not Same", mockT.steps[0].Name) + require.Equal(t, allure.Failed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Expected", params[0].Name) + require.Equal(t, "&require.someStr{}", params[0].Value) + require.Equal(t, "Actual", params[1].Name) + require.Equal(t, "&require.someStr{}", params[1].Value) + + require.True(t, mockT.errorF) + require.True(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + func TestRequireEqual_Success(t *testing.T) { mockT := newMock() Equal(mockT, 1, 1) @@ -115,6 +256,86 @@ func TestRequireNotEqual_Fail(t *testing.T) { require.Equal(t, "\n%s", mockT.errorFString) } +func TestRequireEqualValues_Success(t *testing.T) { + mockT := newMock() + EqualValues(mockT, uint32(123), int32(123)) + require.Len(t, mockT.steps, 1) + require.Equal(t, "REQUIRE: Equal Values", mockT.steps[0].Name) + require.Equal(t, allure.Passed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Expected", params[0].Name) + require.Equal(t, "uint32(0x7b)", params[0].Value) + require.Equal(t, "Actual", params[1].Name) + require.Equal(t, "int32(123)", params[1].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestRequireEqualValues_Fail(t *testing.T) { + mockT := newMock() + EqualValues(mockT, 1, "test") + require.Len(t, mockT.steps, 1) + require.Equal(t, "REQUIRE: Equal Values", mockT.steps[0].Name) + require.Equal(t, allure.Failed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Expected", params[0].Name) + require.Equal(t, "int(1)", params[0].Value) + require.Equal(t, "Actual", params[1].Name) + require.Equal(t, "string(\"test\")", params[1].Value) + + require.True(t, mockT.errorF) + require.True(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + +func TestRequireNotEqualValues_Success(t *testing.T) { + mockT := newMock() + NotEqualValues(mockT, 1, "test") + require.Len(t, mockT.steps, 1) + require.Equal(t, "REQUIRE: Not Equal Values", mockT.steps[0].Name) + require.Equal(t, allure.Passed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Expected", params[0].Name) + require.Equal(t, "int(1)", params[0].Value) + require.Equal(t, "Actual", params[1].Name) + require.Equal(t, "string(\"test\")", params[1].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestRequireNotEqualValues_Fail(t *testing.T) { + mockT := newMock() + NotEqualValues(mockT, uint32(123), int32(123)) + require.Len(t, mockT.steps, 1) + require.Equal(t, "REQUIRE: Not Equal Values", mockT.steps[0].Name) + require.Equal(t, allure.Failed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Expected", params[0].Name) + require.Equal(t, "uint32(0x7b)", params[0].Value) + require.Equal(t, "Actual", params[1].Name) + require.Equal(t, "int32(123)", params[1].Value) + + require.True(t, mockT.errorF) + require.True(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + func TestRequireError_Success(t *testing.T) { mockT := newMock() err := errors.New("kek") @@ -210,6 +431,151 @@ func TestRequireNotNil_Success(t *testing.T) { require.Empty(t, mockT.errorFString) } +func TestRequireEqualError_Success(t *testing.T) { + mockT := newMock() + exp := "testErr" + err := errors.New(exp) + EqualError(mockT, err, exp) + require.Len(t, mockT.steps, 1) + require.Equal(t, "REQUIRE: Equal Error", mockT.steps[0].Name) + require.Equal(t, allure.Passed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Actual", params[0].Name) + require.Equal(t, err.Error(), params[0].Value) + require.Equal(t, "Expected", params[1].Name) + require.Equal(t, exp, params[1].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestRequireEqualError_Fail(t *testing.T) { + mockT := newMock() + exp := "testErr2" + actual := "testErr" + err := errors.New(actual) + EqualError(mockT, err, exp) + require.Len(t, mockT.steps, 1) + require.Equal(t, "REQUIRE: Equal Error", mockT.steps[0].Name) + require.Equal(t, allure.Failed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Actual", params[0].Name) + require.Equal(t, err.Error(), params[0].Value) + require.Equal(t, "Expected", params[1].Name) + require.Equal(t, exp, params[1].Value) + + require.True(t, mockT.errorF) + require.True(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + +func TestRequireErrorIs_Success(t *testing.T) { + mockT := newMock() + exp := "testErr" + err := fmt.Errorf(exp) + errNew := errors.Wrap(err, "NewMessage") + ErrorIs(mockT, errNew, err) + require.Len(t, mockT.steps, 1) + require.Equal(t, "REQUIRE: Error Is", mockT.steps[0].Name) + require.Equal(t, allure.Passed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Error", params[0].Name) + require.Equal(t, errNew.Error(), params[0].Value) + require.Equal(t, "Target", params[1].Name) + require.Equal(t, exp, params[1].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +type fakeError struct { + input string +} + +func (f *fakeError) Error() string { + return fmt.Sprintf("fake error: %s", f.input) +} + +func TestRequireErrorIs_Fail(t *testing.T) { + mockT := newMock() + + var err = fakeError{"some"} + errNew := errors.Wrap(fmt.Errorf("other"), "NewMessage") + ErrorIs(mockT, errNew, &err) + require.Len(t, mockT.steps, 1) + require.Equal(t, "REQUIRE: Error Is", mockT.steps[0].Name) + require.Equal(t, allure.Failed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Error", params[0].Name) + require.Equal(t, "NewMessage: other", params[0].Value) + require.Equal(t, "Target", params[1].Name) + require.Equal(t, "fake error: some", params[1].Value) + + require.True(t, mockT.errorF) + require.True(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + +func TestRequireErrorAs_Success(t *testing.T) { + mockT := newMock() + exp := "testErr" + err := fmt.Errorf(exp) + errNew := errors.Wrap(err, "NewMessage") + ErrorAs(mockT, errNew, &err) + require.Len(t, mockT.steps, 1) + require.Equal(t, "REQUIRE: Error As", mockT.steps[0].Name) + require.Equal(t, allure.Passed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Error", params[0].Name) + require.Equal(t, errNew.Error(), params[0].Value) + require.Equal(t, "Target", params[1].Name) + require.Equal(t, exp, params[1].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestRequireErrorAs_Fail(t *testing.T) { + mockT := newMock() + + var err *fakeError + errNew := errors.Wrap(fmt.Errorf("other"), "NewMessage") + ErrorAs(mockT, errNew, &err) + require.Len(t, mockT.steps, 1) + require.Equal(t, "REQUIRE: Error As", mockT.steps[0].Name) + require.Equal(t, allure.Failed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Error", params[0].Name) + require.Equal(t, "NewMessage: other", params[0].Value) + require.Equal(t, "Target", params[1].Name) + require.Equal(t, fmt.Sprintf("**require.fakeError((**require.fakeError)(%+v))", &err), params[1].Value) + + require.True(t, mockT.errorF) + require.True(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + func TestRequireNotNil_Failed(t *testing.T) { mockT := newMock() @@ -1143,3 +1509,234 @@ func TestRequireRegexp_Failed(t *testing.T) { require.True(t, mockT.failNow) require.Equal(t, "\n%s", mockT.errorFString) } + +func TestRequireElementsMatch_Success(t *testing.T) { + mockT := newMock() + + listA := []int{1, 2, 3} + listB := []int{1, 2, 3} + ElementsMatch(mockT, listA, listB) + + steps := mockT.steps + require.Len(t, steps, 1) + require.Equal(t, "REQUIRE: Elements Match", steps[0].Name) + require.Equal(t, allure.Passed, steps[0].Status) + + params := steps[0].Parameters + require.Len(t, params, 2) + + require.Equal(t, "ListA", params[0].Name) + require.Equal(t, fmt.Sprintf("%#v", listA), params[0].Value) + + require.Equal(t, "ListB", params[1].Name) + require.Equal(t, fmt.Sprintf("%#v", listB), params[1].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestRequireElementsMatch_Fail(t *testing.T) { + mockT := newMock() + + listA := []int{1, 2, 3} + listB := []int{4, 3} + ElementsMatch(mockT, listA, listB) + + steps := mockT.steps + require.Len(t, steps, 1) + require.Equal(t, "REQUIRE: Elements Match", steps[0].Name) + require.Equal(t, allure.Failed, steps[0].Status) + + params := steps[0].Parameters + require.Len(t, params, 2) + + require.Equal(t, "ListA", params[0].Name) + require.Equal(t, fmt.Sprintf("%#v", listA), params[0].Value) + + require.Equal(t, "ListB", params[1].Name) + require.Equal(t, fmt.Sprintf("%#v", listB), params[1].Value) + + require.True(t, mockT.errorF) + require.True(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + +func TestRequireDirExists_Success(t *testing.T) { + dirName := "test" + err := os.Mkdir(dirName, 0644) + require.NoError(t, err, "Can't create folder to begin test") + defer os.RemoveAll(dirName) + + mockT := newMock() + DirExists(mockT, dirName) + steps := mockT.steps + require.Len(t, steps, 1) + require.Equal(t, "REQUIRE: Dir Exists", steps[0].Name) + require.Equal(t, allure.Passed, steps[0].Status) + + params := steps[0].Parameters + require.Len(t, params, 1) + + require.Equal(t, "Path", params[0].Name) + require.Equal(t, dirName, params[0].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestRequireDirExists_Fail(t *testing.T) { + dirName := "test" + + mockT := newMock() + DirExists(mockT, dirName) + steps := mockT.steps + require.Len(t, steps, 1) + require.Equal(t, "REQUIRE: Dir Exists", steps[0].Name) + require.Equal(t, allure.Failed, steps[0].Status) + + params := steps[0].Parameters + require.Len(t, params, 1) + + require.Equal(t, "Path", params[0].Name) + require.Equal(t, dirName, params[0].Value) + + require.True(t, mockT.errorF) + require.True(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + +func TestRequireCondition_Success(t *testing.T) { + test := false + conditionFunc := func() bool { + test = true + return test + } + mockT := newMock() + Condition(mockT, conditionFunc) + steps := mockT.steps + require.True(t, test) + require.Len(t, steps, 1) + require.Equal(t, "REQUIRE: Condition", steps[0].Name) + require.Equal(t, allure.Passed, steps[0].Status) + + params := steps[0].Parameters + require.Len(t, params, 1) + + require.Equal(t, "Signature", params[0].Name) + require.Equal(t, "assert.Comparison", params[0].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestRequireCondition_Fail(t *testing.T) { + test := false + conditionFunc := func() bool { + test = true + return !test + } + mockT := newMock() + Condition(mockT, conditionFunc) + steps := mockT.steps + require.True(t, test) + require.Len(t, steps, 1) + require.Equal(t, "REQUIRE: Condition", steps[0].Name) + require.Equal(t, allure.Failed, steps[0].Status) + + params := steps[0].Parameters + require.Len(t, params, 1) + + require.Equal(t, "Signature", params[0].Name) + require.Equal(t, "assert.Comparison", params[0].Value) + + require.True(t, mockT.errorF) + require.True(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + +func TestRequireZero_Success(t *testing.T) { + mockT := newMock() + + Zero(mockT, 0) + + steps := mockT.steps + require.Len(t, steps, 1) + require.Equal(t, "REQUIRE: Zero", steps[0].Name) + require.Equal(t, allure.Passed, steps[0].Status) + + params := steps[0].Parameters + require.Len(t, params, 1) + + require.Equal(t, "Target", params[0].Name) + require.Equal(t, "0", params[0].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestRequireZero_Fail(t *testing.T) { + mockT := newMock() + + Zero(mockT, 1) + + steps := mockT.steps + require.Len(t, steps, 1) + require.Equal(t, "REQUIRE: Zero", steps[0].Name) + require.Equal(t, allure.Failed, steps[0].Status) + + params := steps[0].Parameters + require.Len(t, params, 1) + + require.Equal(t, "Target", params[0].Name) + require.Equal(t, "1", params[0].Value) + + require.True(t, mockT.errorF) + require.True(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + +func TestRequireNotZero_Success(t *testing.T) { + mockT := newMock() + + NotZero(mockT, 1) + + steps := mockT.steps + require.Len(t, steps, 1) + require.Equal(t, "REQUIRE: Not Zero", steps[0].Name) + require.Equal(t, allure.Passed, steps[0].Status) + + params := steps[0].Parameters + require.Len(t, params, 1) + + require.Equal(t, "Target", params[0].Name) + require.Equal(t, "1", params[0].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestRequireNotZero_Fail(t *testing.T) { + mockT := newMock() + + NotZero(mockT, 0) + + steps := mockT.steps + require.Len(t, steps, 1) + require.Equal(t, "REQUIRE: Not Zero", steps[0].Name) + require.Equal(t, allure.Failed, steps[0].Status) + + params := steps[0].Parameters + require.Len(t, params, 1) + + require.Equal(t, "Target", params[0].Name) + require.Equal(t, "0", params[0].Value) + + require.True(t, mockT.errorF) + require.True(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} diff --git a/pkg/framework/asserts_wrapper/wrapper/interfaces.go b/pkg/framework/asserts_wrapper/wrapper/interfaces.go index 545c9e6..20f0dcc 100644 --- a/pkg/framework/asserts_wrapper/wrapper/interfaces.go +++ b/pkg/framework/asserts_wrapper/wrapper/interfaces.go @@ -18,6 +18,7 @@ type AssertsWrapper interface { Error(provider Provider, err error, msgAndArgs ...interface{}) NoError(provider Provider, err error, msgAndArgs ...interface{}) EqualError(provider Provider, theError error, errString string, msgAndArgs ...interface{}) + ErrorIs(provider Provider, err error, target error, msgAndArgs ...interface{}) ErrorAs(provider Provider, err error, target interface{}, msgAndArgs ...interface{}) NotNil(provider Provider, object interface{}, msgAndArgs ...interface{}) Nil(provider Provider, object interface{}, msgAndArgs ...interface{}) diff --git a/pkg/framework/asserts_wrapper/wrapper/wrapper.go b/pkg/framework/asserts_wrapper/wrapper/wrapper.go index 93a630a..3e0c46c 100644 --- a/pkg/framework/asserts_wrapper/wrapper/wrapper.go +++ b/pkg/framework/asserts_wrapper/wrapper/wrapper.go @@ -59,7 +59,8 @@ func (a *asserts) Exactly(provider Provider, expected interface{}, actual interf // Same ... func (a *asserts) Same(provider Provider, expected interface{}, actual interface{}, msgAndArgs ...interface{}) { assertName := "Same" - expString, actString := formatUnequalValues(expected, actual) + expString := fmt.Sprintf("%p", expected) + actString := fmt.Sprintf("%p", actual) success := a.resultHelper.withNewStep( a.t, provider, @@ -216,23 +217,59 @@ func (a *asserts) EqualError(provider Provider, theError error, errString string } } -// ErrorAs ... -func (a *asserts) ErrorAs(provider Provider, err error, target interface{}, msgAndArgs ...interface{}) { +// ErrorIs ... +func (a *asserts) ErrorIs(provider Provider, err error, target error, msgAndArgs ...interface{}) { var ( actualString string + targetString string - assertName = "Equal As" + assertName = "Error Is" ) + if target != nil { + targetString = target.Error() + } + if err != nil { actualString = err.Error() } + success := a.resultHelper.withNewStep( + a.t, + provider, + assertName, + func(t TestingT) bool { return assert.ErrorIs(t, err, target, msgAndArgs...) }, + allure.NewParameters("Error", actualString, "Target", targetString), + msgAndArgs..., + ) + + if !success && a.resultHelper.required { + a.t.FailNow() + } +} + +// ErrorAs ... +func (a *asserts) ErrorAs(provider Provider, err error, target interface{}, msgAndArgs ...interface{}) { + var ( + errorString string + + assertName = "Error As" + ) + + _, targetString := formatUnequalValues(nil, target) + if pErr, ok := target.(*error); ok { + cErr := *pErr + targetString = cErr.Error() + } + + if err != nil { + errorString = err.Error() + } success := a.resultHelper.withNewStep( a.t, provider, assertName, func(t TestingT) bool { return assert.ErrorAs(t, err, target, msgAndArgs...) }, - allure.NewParameters("Actual", actualString, "Expected", fmt.Sprintf("%+v", target)), + allure.NewParameters("Error", errorString, "Target", targetString), msgAndArgs..., ) diff --git a/pkg/framework/asserts_wrapper/wrapper/wrapper_test.go b/pkg/framework/asserts_wrapper/wrapper/wrapper_test.go index d5d0352..95692b8 100644 --- a/pkg/framework/asserts_wrapper/wrapper/wrapper_test.go +++ b/pkg/framework/asserts_wrapper/wrapper/wrapper_test.go @@ -2,6 +2,7 @@ package wrapper import ( "fmt" + "os" "testing" "time" @@ -41,6 +42,146 @@ func (p *providerTMock) FailNow() { p.failNow = true } +func TestAssertExactly_Success(t *testing.T) { + mockT := newMock() + NewAsserts(mockT).Exactly(mockT, 1, 1) + require.Len(t, mockT.steps, 1) + require.Equal(t, "ASSERT: Exactly", mockT.steps[0].Name) + require.Equal(t, allure.Passed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Expected", params[0].Name) + require.Equal(t, "1", params[0].Value) + require.Equal(t, "Actual", params[1].Name) + require.Equal(t, "1", params[1].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestAssertExactly_Fail(t *testing.T) { + mockT := newMock() + NewAsserts(mockT).Exactly(mockT, 1, 2) + require.Len(t, mockT.steps, 1) + require.Equal(t, "ASSERT: Exactly", mockT.steps[0].Name) + require.Equal(t, allure.Failed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Expected", params[0].Name) + require.Equal(t, "1", params[0].Value) + require.Equal(t, "Actual", params[1].Name) + require.Equal(t, "2", params[1].Value) + + require.True(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + +func TestAssertSame_Success(t *testing.T) { + mockT := newMock() + type someStr struct { + } + exp := &someStr{} + act := exp + NewAsserts(mockT).Same(mockT, exp, act) + require.Len(t, mockT.steps, 1) + require.Equal(t, "ASSERT: Same", mockT.steps[0].Name) + require.Equal(t, allure.Passed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Expected", params[0].Name) + require.Equal(t, fmt.Sprintf("%p", exp), params[0].Value) + require.Equal(t, "Actual", params[1].Name) + require.Equal(t, fmt.Sprintf("%p", act), params[1].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestAssertSame_Fail(t *testing.T) { + mockT := newMock() + type someStr struct { + someField string + } + exp := &someStr{} + act := &someStr{} + + NewAsserts(mockT).Same(mockT, exp, act) + require.Len(t, mockT.steps, 1) + require.Equal(t, "ASSERT: Same", mockT.steps[0].Name) + require.Equal(t, allure.Failed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Expected", params[0].Name) + require.Equal(t, fmt.Sprintf("%p", exp), params[0].Value) + require.Equal(t, "Actual", params[1].Name) + require.Equal(t, fmt.Sprintf("%p", act), params[1].Value) + + require.True(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + +func TestAssertNotSame_Success(t *testing.T) { + mockT := newMock() + type someStr struct { + someField string + } + exp := &someStr{} + act := &someStr{} + + NewAsserts(mockT).NotSame(mockT, exp, act) + require.Len(t, mockT.steps, 1) + require.Equal(t, "ASSERT: Not Same", mockT.steps[0].Name) + require.Equal(t, allure.Passed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Expected", params[0].Name) + require.Equal(t, "&wrapper.someStr{someField:\"\"}", params[0].Value) + require.Equal(t, "Actual", params[1].Name) + require.Equal(t, "&wrapper.someStr{someField:\"\"}", params[1].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestAssertNotSame_Fail(t *testing.T) { + mockT := newMock() + type someStr struct { + } + exp := &someStr{} + act := exp + NewAsserts(mockT).NotSame(mockT, exp, act) + require.Len(t, mockT.steps, 1) + require.Equal(t, "ASSERT: Not Same", mockT.steps[0].Name) + require.Equal(t, allure.Failed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Expected", params[0].Name) + require.Equal(t, "&wrapper.someStr{}", params[0].Value) + require.Equal(t, "Actual", params[1].Name) + require.Equal(t, "&wrapper.someStr{}", params[1].Value) + + require.True(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + func TestAssertEqual_Success(t *testing.T) { mockT := newMock() NewAsserts(mockT).Equal(mockT, 1, 1) @@ -121,6 +262,86 @@ func TestAssertNotEqual_Fail(t *testing.T) { require.Equal(t, "\n%s", mockT.errorFString) } +func TestAssertEqualValues_Success(t *testing.T) { + mockT := newMock() + NewAsserts(mockT).EqualValues(mockT, uint32(123), int32(123)) + require.Len(t, mockT.steps, 1) + require.Equal(t, "ASSERT: Equal Values", mockT.steps[0].Name) + require.Equal(t, allure.Passed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Expected", params[0].Name) + require.Equal(t, "uint32(0x7b)", params[0].Value) + require.Equal(t, "Actual", params[1].Name) + require.Equal(t, "int32(123)", params[1].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestAssertEqualValues_Fail(t *testing.T) { + mockT := newMock() + NewAsserts(mockT).EqualValues(mockT, 1, "test") + require.Len(t, mockT.steps, 1) + require.Equal(t, "ASSERT: Equal Values", mockT.steps[0].Name) + require.Equal(t, allure.Failed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Expected", params[0].Name) + require.Equal(t, "int(1)", params[0].Value) + require.Equal(t, "Actual", params[1].Name) + require.Equal(t, "string(\"test\")", params[1].Value) + + require.True(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + +func TestAssertNotEqualValues_Success(t *testing.T) { + mockT := newMock() + NewAsserts(mockT).NotEqualValues(mockT, 1, "test") + require.Len(t, mockT.steps, 1) + require.Equal(t, "ASSERT: Not Equal Values", mockT.steps[0].Name) + require.Equal(t, allure.Passed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Expected", params[0].Name) + require.Equal(t, "int(1)", params[0].Value) + require.Equal(t, "Actual", params[1].Name) + require.Equal(t, "string(\"test\")", params[1].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestAssertNotEqualValues_Fail(t *testing.T) { + mockT := newMock() + NewAsserts(mockT).NotEqualValues(mockT, uint32(123), int32(123)) + require.Len(t, mockT.steps, 1) + require.Equal(t, "ASSERT: Not Equal Values", mockT.steps[0].Name) + require.Equal(t, allure.Failed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Expected", params[0].Name) + require.Equal(t, "uint32(0x7b)", params[0].Value) + require.Equal(t, "Actual", params[1].Name) + require.Equal(t, "int32(123)", params[1].Value) + + require.True(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + func TestAssertError_Success(t *testing.T) { mockT := newMock() err := errors.New("kek") @@ -195,6 +416,151 @@ func TestAssertNoError_Fail(t *testing.T) { require.Equal(t, "\n%s", mockT.errorFString) } +func TestAssertEqualError_Success(t *testing.T) { + mockT := newMock() + exp := "testErr" + err := errors.New(exp) + NewAsserts(mockT).EqualError(mockT, err, exp) + require.Len(t, mockT.steps, 1) + require.Equal(t, "ASSERT: Equal Error", mockT.steps[0].Name) + require.Equal(t, allure.Passed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Actual", params[0].Name) + require.Equal(t, err.Error(), params[0].Value) + require.Equal(t, "Expected", params[1].Name) + require.Equal(t, exp, params[1].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestAssertEqualError_Fail(t *testing.T) { + mockT := newMock() + exp := "testErr2" + actual := "testErr" + err := errors.New(actual) + NewAsserts(mockT).EqualError(mockT, err, exp) + require.Len(t, mockT.steps, 1) + require.Equal(t, "ASSERT: Equal Error", mockT.steps[0].Name) + require.Equal(t, allure.Failed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Actual", params[0].Name) + require.Equal(t, err.Error(), params[0].Value) + require.Equal(t, "Expected", params[1].Name) + require.Equal(t, exp, params[1].Value) + + require.True(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + +func TestAssertErrorIs_Success(t *testing.T) { + mockT := newMock() + exp := "testErr" + err := fmt.Errorf(exp) + errNew := errors.Wrap(err, "NewMessage") + NewAsserts(mockT).ErrorIs(mockT, errNew, err) + require.Len(t, mockT.steps, 1) + require.Equal(t, "ASSERT: Error Is", mockT.steps[0].Name) + require.Equal(t, allure.Passed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Error", params[0].Name) + require.Equal(t, errNew.Error(), params[0].Value) + require.Equal(t, "Target", params[1].Name) + require.Equal(t, exp, params[1].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +type fakeError struct { + input string +} + +func (f *fakeError) Error() string { + return fmt.Sprintf("fake error: %s", f.input) +} + +func TestAssertErrorIs_Fail(t *testing.T) { + mockT := newMock() + + var err = fakeError{"some"} + errNew := errors.Wrap(fmt.Errorf("other"), "NewMessage") + NewAsserts(mockT).ErrorIs(mockT, errNew, &err) + require.Len(t, mockT.steps, 1) + require.Equal(t, "ASSERT: Error Is", mockT.steps[0].Name) + require.Equal(t, allure.Failed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Error", params[0].Name) + require.Equal(t, "NewMessage: other", params[0].Value) + require.Equal(t, "Target", params[1].Name) + require.Equal(t, "fake error: some", params[1].Value) + + require.True(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + +func TestAssertErrorAs_Success(t *testing.T) { + mockT := newMock() + exp := "testErr" + err := fmt.Errorf(exp) + errNew := errors.Wrap(err, "NewMessage") + NewAsserts(mockT).ErrorAs(mockT, errNew, &err) + require.Len(t, mockT.steps, 1) + require.Equal(t, "ASSERT: Error As", mockT.steps[0].Name) + require.Equal(t, allure.Passed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Error", params[0].Name) + require.Equal(t, errNew.Error(), params[0].Value) + require.Equal(t, "Target", params[1].Name) + require.Equal(t, exp, params[1].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestAssertErrorAs_Fail(t *testing.T) { + mockT := newMock() + + var err *fakeError + errNew := errors.Wrap(fmt.Errorf("other"), "NewMessage") + NewAsserts(mockT).ErrorAs(mockT, errNew, &err) + require.Len(t, mockT.steps, 1) + require.Equal(t, "ASSERT: Error As", mockT.steps[0].Name) + require.Equal(t, allure.Failed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Error", params[0].Name) + require.Equal(t, "NewMessage: other", params[0].Value) + require.Equal(t, "Target", params[1].Name) + require.Equal(t, fmt.Sprintf("**wrapper.fakeError((**wrapper.fakeError)(%+v))", &err), params[1].Value) + + require.True(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + func TestAssertNotNil_Success(t *testing.T) { mockT := newMock() object := struct{}{} @@ -1145,14 +1511,385 @@ func TestAssertRegexp_Failed(t *testing.T) { require.Equal(t, "\n%s", mockT.errorFString) } -func TestRequireEqual_Success(t *testing.T) { +func TestAssertElementsMatch_Success(t *testing.T) { mockT := newMock() - NewRequire(mockT).Equal(mockT, 1, 1) - require.Len(t, mockT.steps, 1) - require.Equal(t, "REQUIRE: Equal", mockT.steps[0].Name) - require.Equal(t, allure.Passed, mockT.steps[0].Status) - params := mockT.steps[0].Parameters + listA := []int{1, 2, 3} + listB := []int{1, 2, 3} + NewAsserts(mockT).ElementsMatch(mockT, listA, listB) + + steps := mockT.steps + require.Len(t, steps, 1) + require.Equal(t, "ASSERT: Elements Match", steps[0].Name) + require.Equal(t, allure.Passed, steps[0].Status) + + params := steps[0].Parameters + require.Len(t, params, 2) + + require.Equal(t, "ListA", params[0].Name) + require.Equal(t, fmt.Sprintf("%#v", listA), params[0].Value) + + require.Equal(t, "ListB", params[1].Name) + require.Equal(t, fmt.Sprintf("%#v", listB), params[1].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestAssertElementsMatch_Fail(t *testing.T) { + mockT := newMock() + + listA := []int{1, 2, 3} + listB := []int{4, 3} + NewAsserts(mockT).ElementsMatch(mockT, listA, listB) + + steps := mockT.steps + require.Len(t, steps, 1) + require.Equal(t, "ASSERT: Elements Match", steps[0].Name) + require.Equal(t, allure.Failed, steps[0].Status) + + params := steps[0].Parameters + require.Len(t, params, 2) + + require.Equal(t, "ListA", params[0].Name) + require.Equal(t, fmt.Sprintf("%#v", listA), params[0].Value) + + require.Equal(t, "ListB", params[1].Name) + require.Equal(t, fmt.Sprintf("%#v", listB), params[1].Value) + + require.True(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + +func TestAssertDirExists_Success(t *testing.T) { + dirName := "test" + err := os.Mkdir(dirName, 0644) + require.NoError(t, err, "Can't create folder to begin test") + defer os.RemoveAll(dirName) + + mockT := newMock() + NewAsserts(mockT).DirExists(mockT, dirName) + steps := mockT.steps + require.Len(t, steps, 1) + require.Equal(t, "ASSERT: Dir Exists", steps[0].Name) + require.Equal(t, allure.Passed, steps[0].Status) + + params := steps[0].Parameters + require.Len(t, params, 1) + + require.Equal(t, "Path", params[0].Name) + require.Equal(t, dirName, params[0].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestAssertDirExists_Fail(t *testing.T) { + dirName := "test" + + mockT := newMock() + NewAsserts(mockT).DirExists(mockT, dirName) + steps := mockT.steps + require.Len(t, steps, 1) + require.Equal(t, "ASSERT: Dir Exists", steps[0].Name) + require.Equal(t, allure.Failed, steps[0].Status) + + params := steps[0].Parameters + require.Len(t, params, 1) + + require.Equal(t, "Path", params[0].Name) + require.Equal(t, dirName, params[0].Value) + + require.True(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + +func TestAssertCondition_Success(t *testing.T) { + test := false + conditionFunc := func() bool { + test = true + return test + } + mockT := newMock() + NewAsserts(mockT).Condition(mockT, conditionFunc) + steps := mockT.steps + require.True(t, test) + require.Len(t, steps, 1) + require.Equal(t, "ASSERT: Condition", steps[0].Name) + require.Equal(t, allure.Passed, steps[0].Status) + + params := steps[0].Parameters + require.Len(t, params, 1) + + require.Equal(t, "Signature", params[0].Name) + require.Equal(t, "assert.Comparison", params[0].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestAssertCondition_Fail(t *testing.T) { + test := false + conditionFunc := func() bool { + test = true + return !test + } + mockT := newMock() + NewAsserts(mockT).Condition(mockT, conditionFunc) + steps := mockT.steps + require.True(t, test) + require.Len(t, steps, 1) + require.Equal(t, "ASSERT: Condition", steps[0].Name) + require.Equal(t, allure.Failed, steps[0].Status) + + params := steps[0].Parameters + require.Len(t, params, 1) + + require.Equal(t, "Signature", params[0].Name) + require.Equal(t, "assert.Comparison", params[0].Value) + + require.True(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + +func TestAssertZero_Success(t *testing.T) { + mockT := newMock() + + NewAsserts(mockT).Zero(mockT, 0) + + steps := mockT.steps + require.Len(t, steps, 1) + require.Equal(t, "ASSERT: Zero", steps[0].Name) + require.Equal(t, allure.Passed, steps[0].Status) + + params := steps[0].Parameters + require.Len(t, params, 1) + + require.Equal(t, "Target", params[0].Name) + require.Equal(t, "0", params[0].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestAssertZero_Fail(t *testing.T) { + mockT := newMock() + + NewAsserts(mockT).Zero(mockT, 1) + + steps := mockT.steps + require.Len(t, steps, 1) + require.Equal(t, "ASSERT: Zero", steps[0].Name) + require.Equal(t, allure.Failed, steps[0].Status) + + params := steps[0].Parameters + require.Len(t, params, 1) + + require.Equal(t, "Target", params[0].Name) + require.Equal(t, "1", params[0].Value) + + require.True(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + +func TestAssertNotZero_Success(t *testing.T) { + mockT := newMock() + + NewAsserts(mockT).NotZero(mockT, 1) + + steps := mockT.steps + require.Len(t, steps, 1) + require.Equal(t, "ASSERT: Not Zero", steps[0].Name) + require.Equal(t, allure.Passed, steps[0].Status) + + params := steps[0].Parameters + require.Len(t, params, 1) + + require.Equal(t, "Target", params[0].Name) + require.Equal(t, "1", params[0].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestAssertNotZero_Fail(t *testing.T) { + mockT := newMock() + + NewAsserts(mockT).NotZero(mockT, 0) + + steps := mockT.steps + require.Len(t, steps, 1) + require.Equal(t, "ASSERT: Not Zero", steps[0].Name) + require.Equal(t, allure.Failed, steps[0].Status) + + params := steps[0].Parameters + require.Len(t, params, 1) + + require.Equal(t, "Target", params[0].Name) + require.Equal(t, "0", params[0].Value) + + require.True(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + +func TestRequireExactly_Success(t *testing.T) { + mockT := newMock() + NewRequire(mockT).Exactly(mockT, 1, 1) + require.Len(t, mockT.steps, 1) + require.Equal(t, "REQUIRE: Exactly", mockT.steps[0].Name) + require.Equal(t, allure.Passed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Expected", params[0].Name) + require.Equal(t, "1", params[0].Value) + require.Equal(t, "Actual", params[1].Name) + require.Equal(t, "1", params[1].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestRequireExactly_Fail(t *testing.T) { + mockT := newMock() + NewRequire(mockT).Exactly(mockT, 1, 2) + require.Len(t, mockT.steps, 1) + require.Equal(t, "REQUIRE: Exactly", mockT.steps[0].Name) + require.Equal(t, allure.Failed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Expected", params[0].Name) + require.Equal(t, "1", params[0].Value) + require.Equal(t, "Actual", params[1].Name) + require.Equal(t, "2", params[1].Value) + + require.True(t, mockT.errorF) + require.True(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + +func TestRequireSame_Success(t *testing.T) { + mockT := newMock() + type someStr struct { + } + exp := &someStr{} + act := exp + NewRequire(mockT).Same(mockT, exp, act) + require.Len(t, mockT.steps, 1) + require.Equal(t, "REQUIRE: Same", mockT.steps[0].Name) + require.Equal(t, allure.Passed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Expected", params[0].Name) + require.Equal(t, fmt.Sprintf("%p", exp), params[0].Value) + require.Equal(t, "Actual", params[1].Name) + require.Equal(t, fmt.Sprintf("%p", act), params[1].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestRequireSame_Fail(t *testing.T) { + mockT := newMock() + type someStr struct { + someField string + } + exp := &someStr{} + act := &someStr{} + + NewRequire(mockT).Same(mockT, exp, act) + require.Len(t, mockT.steps, 1) + require.Equal(t, "REQUIRE: Same", mockT.steps[0].Name) + require.Equal(t, allure.Failed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Expected", params[0].Name) + require.Equal(t, fmt.Sprintf("%p", exp), params[0].Value) + require.Equal(t, "Actual", params[1].Name) + require.Equal(t, fmt.Sprintf("%p", act), params[1].Value) + + require.True(t, mockT.errorF) + require.True(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + +func TestRequireNotSame_Success(t *testing.T) { + mockT := newMock() + type someStr struct { + someField string + } + exp := &someStr{} + act := &someStr{} + + NewRequire(mockT).NotSame(mockT, exp, act) + require.Len(t, mockT.steps, 1) + require.Equal(t, "REQUIRE: Not Same", mockT.steps[0].Name) + require.Equal(t, allure.Passed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Expected", params[0].Name) + require.Equal(t, "&wrapper.someStr{someField:\"\"}", params[0].Value) + require.Equal(t, "Actual", params[1].Name) + require.Equal(t, "&wrapper.someStr{someField:\"\"}", params[1].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestRequireNotSame_Fail(t *testing.T) { + mockT := newMock() + type someStr struct { + } + exp := &someStr{} + act := exp + NewRequire(mockT).NotSame(mockT, exp, act) + require.Len(t, mockT.steps, 1) + require.Equal(t, "REQUIRE: Not Same", mockT.steps[0].Name) + require.Equal(t, allure.Failed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Expected", params[0].Name) + require.Equal(t, "&wrapper.someStr{}", params[0].Value) + require.Equal(t, "Actual", params[1].Name) + require.Equal(t, "&wrapper.someStr{}", params[1].Value) + + require.True(t, mockT.errorF) + require.True(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + +func TestRequireEqual_Success(t *testing.T) { + mockT := newMock() + NewRequire(mockT).Equal(mockT, 1, 1) + require.Len(t, mockT.steps, 1) + require.Equal(t, "REQUIRE: Equal", mockT.steps[0].Name) + require.Equal(t, allure.Passed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters require.NotEmpty(t, params) require.Len(t, params, 2) require.Equal(t, "Expected", params[0].Name) @@ -1185,40 +1922,120 @@ func TestRequireEqual_Fail(t *testing.T) { require.Equal(t, "\n%s", mockT.errorFString) } -func TestRequireNotEqual_Success(t *testing.T) { +func TestRequireNotEqual_Success(t *testing.T) { + mockT := newMock() + NewRequire(mockT).NotEqual(mockT, 1, 2) + require.Len(t, mockT.steps, 1) + require.Equal(t, "REQUIRE: Not Equal", mockT.steps[0].Name) + require.Equal(t, allure.Passed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Expected", params[0].Name) + require.Equal(t, "1", params[0].Value) + require.Equal(t, "Actual", params[1].Name) + require.Equal(t, "2", params[1].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestRequireNotEqual_Fail(t *testing.T) { + mockT := newMock() + NewRequire(mockT).NotEqual(mockT, 1, 1) + require.Len(t, mockT.steps, 1) + require.Equal(t, "REQUIRE: Not Equal", mockT.steps[0].Name) + require.Equal(t, allure.Failed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Expected", params[0].Name) + require.Equal(t, "1", params[0].Value) + require.Equal(t, "Actual", params[1].Name) + require.Equal(t, "1", params[1].Value) + + require.True(t, mockT.errorF) + require.True(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + +func TestRequireEqualValues_Success(t *testing.T) { + mockT := newMock() + NewRequire(mockT).EqualValues(mockT, uint32(123), int32(123)) + require.Len(t, mockT.steps, 1) + require.Equal(t, "REQUIRE: Equal Values", mockT.steps[0].Name) + require.Equal(t, allure.Passed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Expected", params[0].Name) + require.Equal(t, "uint32(0x7b)", params[0].Value) + require.Equal(t, "Actual", params[1].Name) + require.Equal(t, "int32(123)", params[1].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestRequireEqualValues_Fail(t *testing.T) { + mockT := newMock() + NewRequire(mockT).EqualValues(mockT, 1, "test") + require.Len(t, mockT.steps, 1) + require.Equal(t, "REQUIRE: Equal Values", mockT.steps[0].Name) + require.Equal(t, allure.Failed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Expected", params[0].Name) + require.Equal(t, "int(1)", params[0].Value) + require.Equal(t, "Actual", params[1].Name) + require.Equal(t, "string(\"test\")", params[1].Value) + + require.True(t, mockT.errorF) + require.True(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + +func TestRequireNotEqualValues_Success(t *testing.T) { mockT := newMock() - NewRequire(mockT).NotEqual(mockT, 1, 2) + NewRequire(mockT).NotEqualValues(mockT, 1, "test") require.Len(t, mockT.steps, 1) - require.Equal(t, "REQUIRE: Not Equal", mockT.steps[0].Name) + require.Equal(t, "REQUIRE: Not Equal Values", mockT.steps[0].Name) require.Equal(t, allure.Passed, mockT.steps[0].Status) params := mockT.steps[0].Parameters require.NotEmpty(t, params) require.Len(t, params, 2) require.Equal(t, "Expected", params[0].Name) - require.Equal(t, "1", params[0].Value) + require.Equal(t, "int(1)", params[0].Value) require.Equal(t, "Actual", params[1].Name) - require.Equal(t, "2", params[1].Value) + require.Equal(t, "string(\"test\")", params[1].Value) require.False(t, mockT.errorF) require.False(t, mockT.failNow) require.Empty(t, mockT.errorFString) } -func TestRequireNotEqual_Fail(t *testing.T) { +func TestRequireNotEqualValues_Fail(t *testing.T) { mockT := newMock() - NewRequire(mockT).NotEqual(mockT, 1, 1) + NewRequire(mockT).NotEqualValues(mockT, uint32(123), int32(123)) require.Len(t, mockT.steps, 1) - require.Equal(t, "REQUIRE: Not Equal", mockT.steps[0].Name) + require.Equal(t, "REQUIRE: Not Equal Values", mockT.steps[0].Name) require.Equal(t, allure.Failed, mockT.steps[0].Status) params := mockT.steps[0].Parameters require.NotEmpty(t, params) require.Len(t, params, 2) require.Equal(t, "Expected", params[0].Name) - require.Equal(t, "1", params[0].Value) + require.Equal(t, "uint32(0x7b)", params[0].Value) require.Equal(t, "Actual", params[1].Name) - require.Equal(t, "1", params[1].Value) + require.Equal(t, "int32(123)", params[1].Value) require.True(t, mockT.errorF) require.True(t, mockT.failNow) @@ -1299,6 +2116,143 @@ func TestRequireNoError_Fail(t *testing.T) { require.Equal(t, "\n%s", mockT.errorFString) } +func TestRequireEqualError_Success(t *testing.T) { + mockT := newMock() + exp := "testErr" + err := errors.New(exp) + NewRequire(mockT).EqualError(mockT, err, exp) + require.Len(t, mockT.steps, 1) + require.Equal(t, "REQUIRE: Equal Error", mockT.steps[0].Name) + require.Equal(t, allure.Passed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Actual", params[0].Name) + require.Equal(t, err.Error(), params[0].Value) + require.Equal(t, "Expected", params[1].Name) + require.Equal(t, exp, params[1].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestRequireEqualError_Fail(t *testing.T) { + mockT := newMock() + exp := "testErr2" + actual := "testErr" + err := errors.New(actual) + NewRequire(mockT).EqualError(mockT, err, exp) + require.Len(t, mockT.steps, 1) + require.Equal(t, "REQUIRE: Equal Error", mockT.steps[0].Name) + require.Equal(t, allure.Failed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Actual", params[0].Name) + require.Equal(t, err.Error(), params[0].Value) + require.Equal(t, "Expected", params[1].Name) + require.Equal(t, exp, params[1].Value) + + require.True(t, mockT.errorF) + require.True(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + +func TestRequireErrorIs_Success(t *testing.T) { + mockT := newMock() + exp := "testErr" + err := fmt.Errorf(exp) + errNew := errors.Wrap(err, "NewMessage") + NewRequire(mockT).ErrorIs(mockT, errNew, err) + require.Len(t, mockT.steps, 1) + require.Equal(t, "REQUIRE: Error Is", mockT.steps[0].Name) + require.Equal(t, allure.Passed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Error", params[0].Name) + require.Equal(t, errNew.Error(), params[0].Value) + require.Equal(t, "Target", params[1].Name) + require.Equal(t, exp, params[1].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestRequireErrorIs_Fail(t *testing.T) { + mockT := newMock() + + var err = fakeError{"some"} + errNew := errors.Wrap(fmt.Errorf("other"), "NewMessage") + NewRequire(mockT).ErrorIs(mockT, errNew, &err) + require.Len(t, mockT.steps, 1) + require.Equal(t, "REQUIRE: Error Is", mockT.steps[0].Name) + require.Equal(t, allure.Failed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Error", params[0].Name) + require.Equal(t, "NewMessage: other", params[0].Value) + require.Equal(t, "Target", params[1].Name) + require.Equal(t, "fake error: some", params[1].Value) + + require.True(t, mockT.errorF) + require.True(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + +func TestRequireErrorAs_Success(t *testing.T) { + mockT := newMock() + exp := "testErr" + err := fmt.Errorf(exp) + errNew := errors.Wrap(err, "NewMessage") + NewRequire(mockT).ErrorAs(mockT, errNew, &err) + require.Len(t, mockT.steps, 1) + require.Equal(t, "REQUIRE: Error As", mockT.steps[0].Name) + require.Equal(t, allure.Passed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Error", params[0].Name) + require.Equal(t, errNew.Error(), params[0].Value) + require.Equal(t, "Target", params[1].Name) + require.Equal(t, exp, params[1].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestRequireErrorAs_Fail(t *testing.T) { + mockT := newMock() + + var err *fakeError + errNew := errors.Wrap(fmt.Errorf("other"), "NewMessage") + NewRequire(mockT).ErrorAs(mockT, errNew, &err) + require.Len(t, mockT.steps, 1) + require.Equal(t, "REQUIRE: Error As", mockT.steps[0].Name) + require.Equal(t, allure.Failed, mockT.steps[0].Status) + + params := mockT.steps[0].Parameters + require.NotEmpty(t, params) + require.Len(t, params, 2) + require.Equal(t, "Error", params[0].Name) + require.Equal(t, "NewMessage: other", params[0].Value) + require.Equal(t, "Target", params[1].Name) + require.Equal(t, fmt.Sprintf("**wrapper.fakeError((**wrapper.fakeError)(%+v))", &err), params[1].Value) + + require.True(t, mockT.errorF) + require.True(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + func TestRequireNotNil_Success(t *testing.T) { mockT := newMock() object := struct{}{} @@ -2248,3 +3202,234 @@ func TestRequireRegexp_Failed(t *testing.T) { require.True(t, mockT.failNow) require.Equal(t, "\n%s", mockT.errorFString) } + +func TestRequireElementsMatch_Success(t *testing.T) { + mockT := newMock() + + listA := []int{1, 2, 3} + listB := []int{1, 2, 3} + NewRequire(mockT).ElementsMatch(mockT, listA, listB) + + steps := mockT.steps + require.Len(t, steps, 1) + require.Equal(t, "REQUIRE: Elements Match", steps[0].Name) + require.Equal(t, allure.Passed, steps[0].Status) + + params := steps[0].Parameters + require.Len(t, params, 2) + + require.Equal(t, "ListA", params[0].Name) + require.Equal(t, fmt.Sprintf("%#v", listA), params[0].Value) + + require.Equal(t, "ListB", params[1].Name) + require.Equal(t, fmt.Sprintf("%#v", listB), params[1].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestRequireElementsMatch_Fail(t *testing.T) { + mockT := newMock() + + listA := []int{1, 2, 3} + listB := []int{4, 3} + NewRequire(mockT).ElementsMatch(mockT, listA, listB) + + steps := mockT.steps + require.Len(t, steps, 1) + require.Equal(t, "REQUIRE: Elements Match", steps[0].Name) + require.Equal(t, allure.Failed, steps[0].Status) + + params := steps[0].Parameters + require.Len(t, params, 2) + + require.Equal(t, "ListA", params[0].Name) + require.Equal(t, fmt.Sprintf("%#v", listA), params[0].Value) + + require.Equal(t, "ListB", params[1].Name) + require.Equal(t, fmt.Sprintf("%#v", listB), params[1].Value) + + require.True(t, mockT.errorF) + require.True(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + +func TestRequireDirExists_Success(t *testing.T) { + dirName := "test" + err := os.Mkdir(dirName, 0644) + require.NoError(t, err, "Can't create folder to begin test") + defer os.RemoveAll(dirName) + + mockT := newMock() + NewRequire(mockT).DirExists(mockT, dirName) + steps := mockT.steps + require.Len(t, steps, 1) + require.Equal(t, "REQUIRE: Dir Exists", steps[0].Name) + require.Equal(t, allure.Passed, steps[0].Status) + + params := steps[0].Parameters + require.Len(t, params, 1) + + require.Equal(t, "Path", params[0].Name) + require.Equal(t, dirName, params[0].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestRequireDirExists_Fail(t *testing.T) { + dirName := "test" + + mockT := newMock() + NewRequire(mockT).DirExists(mockT, dirName) + steps := mockT.steps + require.Len(t, steps, 1) + require.Equal(t, "REQUIRE: Dir Exists", steps[0].Name) + require.Equal(t, allure.Failed, steps[0].Status) + + params := steps[0].Parameters + require.Len(t, params, 1) + + require.Equal(t, "Path", params[0].Name) + require.Equal(t, dirName, params[0].Value) + + require.True(t, mockT.errorF) + require.True(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + +func TestRequireCondition_Success(t *testing.T) { + test := false + conditionFunc := func() bool { + test = true + return test + } + mockT := newMock() + NewRequire(mockT).Condition(mockT, conditionFunc) + steps := mockT.steps + require.True(t, test) + require.Len(t, steps, 1) + require.Equal(t, "REQUIRE: Condition", steps[0].Name) + require.Equal(t, allure.Passed, steps[0].Status) + + params := steps[0].Parameters + require.Len(t, params, 1) + + require.Equal(t, "Signature", params[0].Name) + require.Equal(t, "assert.Comparison", params[0].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestRequireCondition_Fail(t *testing.T) { + test := false + conditionFunc := func() bool { + test = true + return !test + } + mockT := newMock() + NewRequire(mockT).Condition(mockT, conditionFunc) + steps := mockT.steps + require.True(t, test) + require.Len(t, steps, 1) + require.Equal(t, "REQUIRE: Condition", steps[0].Name) + require.Equal(t, allure.Failed, steps[0].Status) + + params := steps[0].Parameters + require.Len(t, params, 1) + + require.Equal(t, "Signature", params[0].Name) + require.Equal(t, "assert.Comparison", params[0].Value) + + require.True(t, mockT.errorF) + require.True(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + +func TestRequireZero_Success(t *testing.T) { + mockT := newMock() + + NewRequire(mockT).Zero(mockT, 0) + + steps := mockT.steps + require.Len(t, steps, 1) + require.Equal(t, "REQUIRE: Zero", steps[0].Name) + require.Equal(t, allure.Passed, steps[0].Status) + + params := steps[0].Parameters + require.Len(t, params, 1) + + require.Equal(t, "Target", params[0].Name) + require.Equal(t, "0", params[0].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestRequireZero_Fail(t *testing.T) { + mockT := newMock() + + NewRequire(mockT).Zero(mockT, 1) + + steps := mockT.steps + require.Len(t, steps, 1) + require.Equal(t, "REQUIRE: Zero", steps[0].Name) + require.Equal(t, allure.Failed, steps[0].Status) + + params := steps[0].Parameters + require.Len(t, params, 1) + + require.Equal(t, "Target", params[0].Name) + require.Equal(t, "1", params[0].Value) + + require.True(t, mockT.errorF) + require.True(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} + +func TestRequireNotZero_Success(t *testing.T) { + mockT := newMock() + + NewRequire(mockT).NotZero(mockT, 1) + + steps := mockT.steps + require.Len(t, steps, 1) + require.Equal(t, "REQUIRE: Not Zero", steps[0].Name) + require.Equal(t, allure.Passed, steps[0].Status) + + params := steps[0].Parameters + require.Len(t, params, 1) + + require.Equal(t, "Target", params[0].Name) + require.Equal(t, "1", params[0].Value) + + require.False(t, mockT.errorF) + require.False(t, mockT.failNow) + require.Empty(t, mockT.errorFString) +} + +func TestRequireNotZero_Fail(t *testing.T) { + mockT := newMock() + + NewRequire(mockT).NotZero(mockT, 0) + + steps := mockT.steps + require.Len(t, steps, 1) + require.Equal(t, "REQUIRE: Not Zero", steps[0].Name) + require.Equal(t, allure.Failed, steps[0].Status) + + params := steps[0].Parameters + require.Len(t, params, 1) + + require.Equal(t, "Target", params[0].Name) + require.Equal(t, "0", params[0].Value) + + require.True(t, mockT.errorF) + require.True(t, mockT.failNow) + require.Equal(t, "\n%s", mockT.errorFString) +} diff --git a/pkg/framework/provider/test.go b/pkg/framework/provider/test.go index 1caf1f4..7944a7c 100644 --- a/pkg/framework/provider/test.go +++ b/pkg/framework/provider/test.go @@ -71,6 +71,7 @@ type Asserts interface { Error(err error, msgAndArgs ...interface{}) NoError(err error, msgAndArgs ...interface{}) EqualError(theError error, errString string, msgAndArgs ...interface{}) + ErrorIs(err error, target error, msgAndArgs ...interface{}) ErrorAs(err error, target interface{}, msgAndArgs ...interface{}) NotNil(object interface{}, msgAndArgs ...interface{}) Nil(object interface{}, msgAndArgs ...interface{}) From ba1606b19d04e28b451e6924f26b2f7cc9e34df8 Mon Sep 17 00:00:00 2001 From: Sinyaev Anton Yuryevich Date: Mon, 15 Aug 2022 21:14:08 +0300 Subject: [PATCH 04/12] [ISSUE-20] disable typecheck (cause issues with typecheck) --- pkg/framework/.golangci.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkg/framework/.golangci.yaml b/pkg/framework/.golangci.yaml index 8f31dbf..357b78d 100644 --- a/pkg/framework/.golangci.yaml +++ b/pkg/framework/.golangci.yaml @@ -40,7 +40,7 @@ linters: - structcheck - varcheck - ineffassign - - typecheck +# - typecheck - dupl - goconst - gosec From 1de19e65e9d3e299ab3af3ba3ce3109ef18a808e Mon Sep 17 00:00:00 2001 From: Sinyaev Anton Yuryevich Date: Mon, 15 Aug 2022 21:22:25 +0300 Subject: [PATCH 05/12] [ISSUE-20] add comment to typecheck disabling --- pkg/framework/.golangci.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkg/framework/.golangci.yaml b/pkg/framework/.golangci.yaml index 357b78d..f046b2b 100644 --- a/pkg/framework/.golangci.yaml +++ b/pkg/framework/.golangci.yaml @@ -40,7 +40,7 @@ linters: - structcheck - varcheck - ineffassign -# - typecheck +# - typecheck Strange behaviour - dupl - goconst - gosec From 1b9fd11bf0364badc763912004de4827abaefdac Mon Sep 17 00:00:00 2001 From: Sinyaev Anton Yuryevich Date: Mon, 15 Aug 2022 21:26:35 +0300 Subject: [PATCH 06/12] [ISSUE-20] add LogStep and LogfStep to the interface provider.T, provider.StepCtx --- pkg/framework/core/common/step_context.go | 12 ++++++++++++ pkg/framework/provider/test.go | 4 ++++ 2 files changed, 16 insertions(+) diff --git a/pkg/framework/core/common/step_context.go b/pkg/framework/core/common/step_context.go index 5ac24a4..b9e049f 100644 --- a/pkg/framework/core/common/step_context.go +++ b/pkg/framework/core/common/step_context.go @@ -124,6 +124,18 @@ func (ctx *stepCtx) WithNewAttachment(name string, mimeType allure.MimeType, con ctx.currentStep.WithAttachments(allure.NewAttachment(name, mimeType, content)) } +func (ctx *stepCtx) LogStep(args ...interface{}) { + newStep := allure.NewSimpleStep(fmt.Sprintln(args...)) + ctx.currentStep.WithChild(newStep) + ctx.Log(args...) +} + +func (ctx *stepCtx) LogfStep(format string, args ...interface{}) { + newStep := allure.NewSimpleStep(fmt.Sprintf(format, args...)) + ctx.currentStep.WithChild(newStep) + ctx.Logf(format, args...) +} + func (ctx *stepCtx) Step(step *allure.Step) { ctx.currentStep.WithChild(step) } diff --git a/pkg/framework/provider/test.go b/pkg/framework/provider/test.go index 7944a7c..b95d92c 100644 --- a/pkg/framework/provider/test.go +++ b/pkg/framework/provider/test.go @@ -27,6 +27,8 @@ type T interface { Require() Asserts Run(testName string, testBody func(T), tags ...string) bool + LogStep(args ...interface{}) + LogfStep(format string, args ...interface{}) WithNewStep(stepName string, step func(sCtx StepCtx), params ...allure.Parameter) WithNewAsyncStep(stepName string, step func(sCtx StepCtx), params ...allure.Parameter) } @@ -46,6 +48,8 @@ type StepCtx interface { Assert() Asserts Require() Asserts + LogStep(args ...interface{}) + LogfStep(format string, args ...interface{}) CurrentStep() *allure.Step Broken() From 6fcc2eed3941694d78a20b7429ea0de3cb5a2db0 Mon Sep 17 00:00:00 2001 From: Sinyaev Anton Yuryevich Date: Mon, 15 Aug 2022 21:46:05 +0300 Subject: [PATCH 07/12] [ISSUE-20] fix wrong ParentSuite label setting for provider tests --- pkg/framework/core/common/common.go | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/pkg/framework/core/common/common.go b/pkg/framework/core/common/common.go index 2eacdaa..231bc63 100644 --- a/pkg/framework/core/common/common.go +++ b/pkg/framework/core/common/common.go @@ -211,8 +211,11 @@ func (c *Common) Run(testName string, testBody func(provider.T), tags ...string) WithFullName(realT.Name()). WithPackageName(packageName). WithSuiteName(suiteName). - WithParentSuite(parentSuite). WithRunner(callers[0]) + + if parentSuite != "" && parentSuite != suiteName && parentSuite != callers[len(callers)-1] { + providerCfg = providerCfg.WithParentSuite(parentSuite) + } newProvider := manager.NewProvider(providerCfg) newProvider.NewTest(testName, packageName, tags...) From 88f7a71c1f276e38f191110e050ac249ff04efb1 Mon Sep 17 00:00:00 2001 From: Sinyaev Anton Yuryevich Date: Mon, 15 Aug 2022 21:46:55 +0300 Subject: [PATCH 08/12] [ISSUE-20] fix test's FullName field duplicate test name for no-suite tests --- pkg/framework/core/allure_manager/adapter/test_adapter.go | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/pkg/framework/core/allure_manager/adapter/test_adapter.go b/pkg/framework/core/allure_manager/adapter/test_adapter.go index 1201566..5a54803 100644 --- a/pkg/framework/core/allure_manager/adapter/test_adapter.go +++ b/pkg/framework/core/allure_manager/adapter/test_adapter.go @@ -4,6 +4,7 @@ import ( "fmt" "os" "runtime" + "strings" "github.com/ozontech/allure-go/pkg/allure" "github.com/ozontech/allure-go/pkg/framework/provider" @@ -22,7 +23,10 @@ type TestAdapter struct { // NewTestMeta returns pointer to instance of TestAdapter func NewTestMeta(suiteFullName, suiteName, testName, packageName string, tags ...string) *TestAdapter { host, _ := os.Hostname() - fullName := fmt.Sprintf("%s/%s", suiteFullName, testName) + fullName := suiteFullName + if callers := strings.Split(suiteFullName, "/"); callers[len(callers)-1] != strings.ReplaceAll(testName, " ", "_") { + fullName = fmt.Sprintf("%s/%s", fullName, testName) + } var newTags []allure.Label for _, tag := range tags { From 84273ceb9b6fd96dc0dd1af92dd282e8562f02d8 Mon Sep 17 00:00:00 2001 From: Sinyaev Anton Yuryevich Date: Mon, 15 Aug 2022 22:03:20 +0300 Subject: [PATCH 09/12] [ISSUE-20] update README.md --- pkg/framework/README.md | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) diff --git a/pkg/framework/README.md b/pkg/framework/README.md index 875b04d..7a6750c 100644 --- a/pkg/framework/README.md +++ b/pkg/framework/README.md @@ -107,6 +107,8 @@ Main interfaces for test working are `provider.T` and `provider.StepCtx`. | Method | Description | |:-----------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------------------------------------------------------------------:| +| `LogStep(args ...interface{})` | Works as `t.Log(args ...interface{})`, but also creates `allure.Step` at report | +| `LogfStep(format string, args ...interface{})` | Works as `t.Logf(format string, args ...interface{})` but also creates `allure.Step` at report | | `Step(step *allure.Step)` | Adds `allure.Step` object to result. | | `NewStep(stepName string, params ...allure.Parameter)` | Creates new `allure.Step` object and adds it to result. | | `WithNewStep(stepName string, step func(sCtx StepCtx), params ...allure.Parameter)` | Creates new `allure.Step` object and run anonymous function. With `StepCtx` interface you can work with step during anonymous function execution. | @@ -140,6 +142,8 @@ Main interfaces for test working are `provider.T` and `provider.StepCtx`. | Method | Description | |:-----------------------------------------------------------------------------------------|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------:| +| `LogStep(args ...interface{})` | Works as `t.Log(args ...interface{})`, but also creates `allure.Step` at report | +| `LogfStep(format string, args ...interface{})` | Works as `t.Logf(format string, args ...interface{})` but also creates `allure.Step` at report | | `Step(step *allure.Step)` | Adds created `allure.Step` as a substep. | | `NewStep(stepName string, parameters ...allure.Parameter)` | Creates new allure.Step object and adds it as a substep. | | `WithNewStep(stepName string, step func(sCtx StepCtx), params ...allure.Parameter)` | Creates new `allure.Step` object and run anonymous function. With `StepCtx` interface you can work with step during anonymous function execution. Adds it as substep. | @@ -191,10 +195,18 @@ allure-go provides implementation of most usable [testify](https://github.com/st | Method | |:---------------------------------------------------------------------------------------------| +| `Exactly(t ProviderT, expected interface{}, actual interface{}, msgAndArgs ...interface{})` | +| `Same(t ProviderT, expected interface{}, actual interface{}, msgAndArgs ...interface{})` | +| `NotSame(t ProviderT, expected interface{}, actual interface{}, msgAndArgs ...interface{})` | | `Equal(expected interface{}, actual interface{}, msgAndArgs ...interface{})` | | `NotEqual(expected interface{}, actual interface{}, msgAndArgs ...interface{})` | +| `EqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{})` | +| `NotEqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{})` | | `Error(err error, msgAndArgs ...interface{})` | | `NoError(err error, msgAndArgs ...interface{})` | +| `EqualError(theError error, errString string, msgAndArgs ...interface{})` | +| `ErrorIs(err error, target error, msgAndArgs ...interface{})` | +| `ErrorAs(err error, target interface{}, msgAndArgs ...interface{})` | | `NotNil(object interface{}, msgAndArgs ...interface{})` | | `Nil(object interface{}, msgAndArgs ...interface{})` | | `Len(object interface{}, length int, msgAndArgs ...interface{})` | @@ -215,6 +227,11 @@ allure-go provides implementation of most usable [testify](https://github.com/st | `True(value bool, msgAndArgs ...interface{})` | | `False(value bool, msgAndArgs ...interface{})` | | `Regexp(rx interface{}, str interface{}, msgAndArgs ...interface{})` | +| `ElementsMatch(listA interface{}, listB interface{}, msgAndArgs ...interface{})` | +| `DirExists(path string, msgAndArgs ...interface{})` | +| `Condition(condition assert.Comparison, msgAndArgs ...interface{})` | +| `Zero(i interface{}, msgAndArgs ...interface{})` | +| `NotZero(i interface{}, msgAndArgs ...interface{})` | :information_desk_person: **NOTE:** allure-go supports assert/require separation. User `T.Assert()`/`T.Require()` to get asserts you need. @@ -225,10 +242,18 @@ Also, allure-go supports assert/require functionality that not attached to the ` | Method | |:----------------------------------------------------------------------------------------------------------| +| `Exactly(t ProviderT, expected interface{}, actual interface{}, msgAndArgs ...interface{})` | +| `Same(t ProviderT, expected interface{}, actual interface{}, msgAndArgs ...interface{})` | +| `NotSame(t ProviderT, expected interface{}, actual interface{}, msgAndArgs ...interface{})` | | `Equal(t ProviderT, expected interface{}, actual interface{}, msgAndArgs ...interface{})` | | `NotEqual(t ProviderT, expected interface{}, actual interface{}, msgAndArgs ...interface{})` | +| `EqualValues(t ProviderT, expected interface{}, actual interface{}, msgAndArgs ...interface{})` | +| `NotEqualValues(t ProviderT, expected interface{}, actual interface{}, msgAndArgs ...interface{})` | | `Error(t ProviderT, err error, msgAndArgs ...interface{})` | | `NoError(t ProviderT, err error, msgAndArgs ...interface{})` | +| `EqualError(t ProviderT, theError error, errString string, msgAndArgs ...interface{})` | +| `ErrorIs(t ProviderT, err error, target error, msgAndArgs ...interface{})` | +| `ErrorAs(t ProviderT, err error, target interface{}, msgAndArgs ...interface{})` | | `NotNil(t ProviderT, object interface{}, msgAndArgs ...interface{})` | | `Nil(t ProviderT, object interface{}, msgAndArgs ...interface{})` | | `Len(t ProviderT, object interface{}, length int, msgAndArgs ...interface{})` | @@ -249,6 +274,11 @@ Also, allure-go supports assert/require functionality that not attached to the ` | `True(t ProviderT, value bool, msgAndArgs ...interface{})` | | `False(t ProviderT, value bool, msgAndArgs ...interface{})` | | `Regexp(t ProviderT, rx interface{}, str interface{}, msgAndArgs ...interface{})` | +| `ElementsMatch(ProviderT, listA interface{}, listB interface{}, msgAndArgs ...interface{})` | +| `DirExists(t ProviderT, path string, msgAndArgs ...interface{})` | +| `Condition(t ProviderT, condition assert.Comparison, msgAndArgs ...interface{})` | +| `Zero(t ProviderT, i interface{}, msgAndArgs ...interface{})` | +| `NotZero(t ProviderT, i interface{}, msgAndArgs ...interface{})` | :information_desk_person: **NOTE:** `ProviderT` interface: From 2369c61ddf5dd7eeaa2c8d7554eb779467ccd187 Mon Sep 17 00:00:00 2001 From: Sinyaev Anton Yuryevich Date: Tue, 16 Aug 2022 12:03:39 +0300 Subject: [PATCH 10/12] [ISSUE-20] fix NoSame assert step parameters --- .../asserts_wrapper/asserts/asserts_test.go | 8 ++++---- .../asserts_wrapper/require/requires_test.go | 8 ++++---- pkg/framework/asserts_wrapper/wrapper/wrapper.go | 3 ++- .../asserts_wrapper/wrapper/wrapper_test.go | 16 ++++++++-------- 4 files changed, 18 insertions(+), 17 deletions(-) diff --git a/pkg/framework/asserts_wrapper/asserts/asserts_test.go b/pkg/framework/asserts_wrapper/asserts/asserts_test.go index 8aa42e4..f601ddc 100644 --- a/pkg/framework/asserts_wrapper/asserts/asserts_test.go +++ b/pkg/framework/asserts_wrapper/asserts/asserts_test.go @@ -142,9 +142,9 @@ func TestAssertNotSame_Success(t *testing.T) { require.NotEmpty(t, params) require.Len(t, params, 2) require.Equal(t, "Expected", params[0].Name) - require.Equal(t, "&asserts.someStr{someField:\"\"}", params[0].Value) + require.Equal(t, fmt.Sprintf("%p", exp), params[0].Value) require.Equal(t, "Actual", params[1].Name) - require.Equal(t, "&asserts.someStr{someField:\"\"}", params[1].Value) + require.Equal(t, fmt.Sprintf("%p", act), params[1].Value) require.False(t, mockT.errorF) require.False(t, mockT.failNow) @@ -166,9 +166,9 @@ func TestAssertNotSame_Fail(t *testing.T) { require.NotEmpty(t, params) require.Len(t, params, 2) require.Equal(t, "Expected", params[0].Name) - require.Equal(t, "&asserts.someStr{}", params[0].Value) + require.Equal(t, fmt.Sprintf("%p", exp), params[0].Value) require.Equal(t, "Actual", params[1].Name) - require.Equal(t, "&asserts.someStr{}", params[1].Value) + require.Equal(t, fmt.Sprintf("%p", act), params[1].Value) require.True(t, mockT.errorF) require.False(t, mockT.failNow) diff --git a/pkg/framework/asserts_wrapper/require/requires_test.go b/pkg/framework/asserts_wrapper/require/requires_test.go index 6363dc7..153b443 100644 --- a/pkg/framework/asserts_wrapper/require/requires_test.go +++ b/pkg/framework/asserts_wrapper/require/requires_test.go @@ -143,9 +143,9 @@ func TestRequireNotSame_Success(t *testing.T) { require.NotEmpty(t, params) require.Len(t, params, 2) require.Equal(t, "Expected", params[0].Name) - require.Equal(t, "&require.someStr{someField:\"\"}", params[0].Value) + require.Equal(t, fmt.Sprintf("%p", exp), params[0].Value) require.Equal(t, "Actual", params[1].Name) - require.Equal(t, "&require.someStr{someField:\"\"}", params[1].Value) + require.Equal(t, fmt.Sprintf("%p", act), params[1].Value) require.False(t, mockT.errorF) require.False(t, mockT.failNow) @@ -167,9 +167,9 @@ func TestRequireNotSame_Fail(t *testing.T) { require.NotEmpty(t, params) require.Len(t, params, 2) require.Equal(t, "Expected", params[0].Name) - require.Equal(t, "&require.someStr{}", params[0].Value) + require.Equal(t, fmt.Sprintf("%p", exp), params[0].Value) require.Equal(t, "Actual", params[1].Name) - require.Equal(t, "&require.someStr{}", params[1].Value) + require.Equal(t, fmt.Sprintf("%p", act), params[1].Value) require.True(t, mockT.errorF) require.True(t, mockT.failNow) diff --git a/pkg/framework/asserts_wrapper/wrapper/wrapper.go b/pkg/framework/asserts_wrapper/wrapper/wrapper.go index 3e0c46c..53a6697 100644 --- a/pkg/framework/asserts_wrapper/wrapper/wrapper.go +++ b/pkg/framework/asserts_wrapper/wrapper/wrapper.go @@ -77,7 +77,8 @@ func (a *asserts) Same(provider Provider, expected interface{}, actual interface // NotSame ... func (a *asserts) NotSame(provider Provider, expected interface{}, actual interface{}, msgAndArgs ...interface{}) { assertName := "Not Same" - expString, actString := formatUnequalValues(expected, actual) + expString := fmt.Sprintf("%p", expected) + actString := fmt.Sprintf("%p", actual) success := a.resultHelper.withNewStep( a.t, provider, diff --git a/pkg/framework/asserts_wrapper/wrapper/wrapper_test.go b/pkg/framework/asserts_wrapper/wrapper/wrapper_test.go index 95692b8..160ca88 100644 --- a/pkg/framework/asserts_wrapper/wrapper/wrapper_test.go +++ b/pkg/framework/asserts_wrapper/wrapper/wrapper_test.go @@ -149,9 +149,9 @@ func TestAssertNotSame_Success(t *testing.T) { require.NotEmpty(t, params) require.Len(t, params, 2) require.Equal(t, "Expected", params[0].Name) - require.Equal(t, "&wrapper.someStr{someField:\"\"}", params[0].Value) + require.Equal(t, fmt.Sprintf("%p", exp), params[0].Value) require.Equal(t, "Actual", params[1].Name) - require.Equal(t, "&wrapper.someStr{someField:\"\"}", params[1].Value) + require.Equal(t, fmt.Sprintf("%p", act), params[1].Value) require.False(t, mockT.errorF) require.False(t, mockT.failNow) @@ -173,9 +173,9 @@ func TestAssertNotSame_Fail(t *testing.T) { require.NotEmpty(t, params) require.Len(t, params, 2) require.Equal(t, "Expected", params[0].Name) - require.Equal(t, "&wrapper.someStr{}", params[0].Value) + require.Equal(t, fmt.Sprintf("%p", exp), params[0].Value) require.Equal(t, "Actual", params[1].Name) - require.Equal(t, "&wrapper.someStr{}", params[1].Value) + require.Equal(t, fmt.Sprintf("%p", act), params[1].Value) require.True(t, mockT.errorF) require.False(t, mockT.failNow) @@ -1849,9 +1849,9 @@ func TestRequireNotSame_Success(t *testing.T) { require.NotEmpty(t, params) require.Len(t, params, 2) require.Equal(t, "Expected", params[0].Name) - require.Equal(t, "&wrapper.someStr{someField:\"\"}", params[0].Value) + require.Equal(t, fmt.Sprintf("%p", exp), params[0].Value) require.Equal(t, "Actual", params[1].Name) - require.Equal(t, "&wrapper.someStr{someField:\"\"}", params[1].Value) + require.Equal(t, fmt.Sprintf("%p", act), params[1].Value) require.False(t, mockT.errorF) require.False(t, mockT.failNow) @@ -1873,9 +1873,9 @@ func TestRequireNotSame_Fail(t *testing.T) { require.NotEmpty(t, params) require.Len(t, params, 2) require.Equal(t, "Expected", params[0].Name) - require.Equal(t, "&wrapper.someStr{}", params[0].Value) + require.Equal(t, fmt.Sprintf("%p", exp), params[0].Value) require.Equal(t, "Actual", params[1].Name) - require.Equal(t, "&wrapper.someStr{}", params[1].Value) + require.Equal(t, fmt.Sprintf("%p", act), params[1].Value) require.True(t, mockT.errorF) require.True(t, mockT.failNow) From 7a050a97be68363ce502764f8872c40ac257df6e Mon Sep 17 00:00:00 2001 From: Sinyaev Anton Yuryevich Date: Tue, 16 Aug 2022 12:10:55 +0300 Subject: [PATCH 11/12] [ISSUE-20] add comment --- pkg/framework/core/allure_manager/adapter/test_adapter.go | 2 ++ 1 file changed, 2 insertions(+) diff --git a/pkg/framework/core/allure_manager/adapter/test_adapter.go b/pkg/framework/core/allure_manager/adapter/test_adapter.go index 5a54803..349f114 100644 --- a/pkg/framework/core/allure_manager/adapter/test_adapter.go +++ b/pkg/framework/core/allure_manager/adapter/test_adapter.go @@ -24,6 +24,8 @@ type TestAdapter struct { func NewTestMeta(suiteFullName, suiteName, testName, packageName string, tags ...string) *TestAdapter { host, _ := os.Hostname() fullName := suiteFullName + // ex: suiteFullName=TestRunner/My_Test, testName=My Test => after split and replace: My_test == My_test + // why? to avoid TestRunner/My_Test/My Test if callers := strings.Split(suiteFullName, "/"); callers[len(callers)-1] != strings.ReplaceAll(testName, " ", "_") { fullName = fmt.Sprintf("%s/%s", fullName, testName) } From 373f3e6768c7e47c6de735c73614d7c98819540c Mon Sep 17 00:00:00 2001 From: Sinyaev Anton Yuryevich Date: Tue, 16 Aug 2022 12:11:29 +0300 Subject: [PATCH 12/12] [ISSUE-20] lint ignore: dupl for same assert --- pkg/framework/asserts_wrapper/wrapper/wrapper.go | 2 ++ 1 file changed, 2 insertions(+) diff --git a/pkg/framework/asserts_wrapper/wrapper/wrapper.go b/pkg/framework/asserts_wrapper/wrapper/wrapper.go index 53a6697..cba444a 100644 --- a/pkg/framework/asserts_wrapper/wrapper/wrapper.go +++ b/pkg/framework/asserts_wrapper/wrapper/wrapper.go @@ -57,6 +57,7 @@ func (a *asserts) Exactly(provider Provider, expected interface{}, actual interf } // Same ... +// nolint: dupl func (a *asserts) Same(provider Provider, expected interface{}, actual interface{}, msgAndArgs ...interface{}) { assertName := "Same" expString := fmt.Sprintf("%p", expected) @@ -75,6 +76,7 @@ func (a *asserts) Same(provider Provider, expected interface{}, actual interface } // NotSame ... +// nolint: dupl func (a *asserts) NotSame(provider Provider, expected interface{}, actual interface{}, msgAndArgs ...interface{}) { assertName := "Not Same" expString := fmt.Sprintf("%p", expected)