Merge pull request #103 from korableg/master

add eventually method && a bit refactor
ozontech · Dec 29, 2024 · 76a7ab8 · 76a7ab8
2 parents 0951fbc + 60d4165
commit 76a7ab8
Show file tree

Hide file tree

Showing 11 changed files with 686 additions and 106 deletions.
diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
@@ -39,7 +39,7 @@ jobs:
       - name: Run examples
         run: make examples
       - name: Archive code coverage results
-        uses: actions/upload-artifact@v2
+        uses: actions/upload-artifact@v4
         with:
           name: allure-results
           path: ./examples/allure-results
diff --git a/pkg/framework/asserts_wrapper/asserts/asserts.go b/pkg/framework/asserts_wrapper/asserts/asserts.go
@@ -203,3 +203,7 @@ func Zero(t ProviderT, i interface{}, msgAndArgs ...interface{}) {
 func NotZero(t ProviderT, i interface{}, msgAndArgs ...interface{}) {
 	wrapper.NewAsserts(t).NotZero(t, i, msgAndArgs...)
 }
+
+func Eventually(t ProviderT, condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) {
+	wrapper.NewAsserts(t).Eventually(t, condition, waitFor, tick, msgAndArgs...)
+}
diff --git a/pkg/framework/asserts_wrapper/helper/helper.go b/pkg/framework/asserts_wrapper/helper/helper.go
@@ -3,6 +3,7 @@ package helper
 import (
 	"time"
 
+	"github.com/ozontech/allure-go/pkg/allure"
 	"github.com/ozontech/allure-go/pkg/framework/asserts_wrapper/wrapper"
 	"github.com/stretchr/testify/assert"
 )
@@ -12,6 +13,13 @@ type a struct {
 	asserts wrapper.AssertsWrapper
 }
 
+func (a *a) Decorate(name string, assertFunc func(t wrapper.TestingT) bool, params []*allure.Parameter, msgAndArgs ...interface{}) {
+	dec := a.asserts.(interface {
+		Decorate(p wrapper.Provider, name string, assertFunc func(t wrapper.TestingT) bool, params []*allure.Parameter, msgAndArgs ...interface{})
+	})
+	dec.Decorate(a.t, name, assertFunc, params, msgAndArgs...)
+}
+
 // Exactly ...
 func (a *a) Exactly(expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
 	a.asserts.Exactly(a.t, expected, actual, msgAndArgs...)
@@ -205,3 +213,8 @@ func (a *a) NotZero(i interface{}, msgAndArgs ...interface{}) {
 func (a *a) InDelta(expected, actual interface{}, delta float64, msgAndArgs ...interface{}) {
 	a.asserts.InDelta(a.t, expected, actual, delta, msgAndArgs...)
 }
+
+// Eventually ...
+func (a *a) Eventually(condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) {
+	a.asserts.Eventually(a.t, condition, waitFor, tick, msgAndArgs...)
+}
diff --git a/pkg/framework/asserts_wrapper/helper/helper_test.go b/pkg/framework/asserts_wrapper/helper/helper_test.go
@@ -2,13 +2,15 @@ package helper
 
 import (
 	"fmt"
+	"sync/atomic"
 	"testing"
 	"time"
 
 	"github.com/pkg/errors"
 	"github.com/stretchr/testify/require"
 
 	"github.com/ozontech/allure-go/pkg/allure"
+	"github.com/ozontech/allure-go/pkg/framework/asserts_wrapper/wrapper"
 )
 
 type testStructSuc struct {
@@ -41,6 +43,136 @@ func (p *providerTMock) FailNow() {
 	p.failNow = true
 }
 
+func TestAssert_Decorate_Success(t *testing.T) {
+	mockT := newMock()
+	a := NewAssertsHelper(mockT)
+	dec, ok := a.(interface {
+		Decorate(name string, assertFunc func(t wrapper.TestingT) bool, params []*allure.Parameter, msgAndArgs ...interface{})
+	})
+	require.True(t, ok)
+
+	dec.Decorate("TestDecorate", func(wrapper.TestingT) bool {
+		return true
+	}, []*allure.Parameter{
+		{
+			Name:  "TestParam",
+			Value: "5",
+		},
+	})
+
+	require.Len(t, mockT.steps, 1)
+	require.Equal(t, "ASSERT: TestDecorate", 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, 1)
+	require.Equal(t, "TestParam", params[0].Name)
+	require.Equal(t, "5", params[0].GetValue())
+
+	require.False(t, mockT.errorF)
+	require.False(t, mockT.failNow)
+	require.Empty(t, mockT.errorFString)
+}
+
+func TestAssert_Decorate_Fail(t *testing.T) {
+	mockT := newMock()
+	a := NewAssertsHelper(mockT)
+	dec, ok := a.(interface {
+		Decorate(name string, assertFunc func(t wrapper.TestingT) bool, params []*allure.Parameter, msgAndArgs ...interface{})
+	})
+	require.True(t, ok)
+
+	dec.Decorate("TestDecorate", func(w wrapper.TestingT) bool {
+		w.Errorf("\n%s", "err")
+		return false
+	}, []*allure.Parameter{
+		{
+			Name:  "TestParam",
+			Value: "5",
+		},
+	})
+
+	require.Len(t, mockT.steps, 1)
+	require.Equal(t, "ASSERT: TestDecorate", 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, 1)
+	require.Equal(t, "TestParam", params[0].Name)
+	require.Equal(t, "5", params[0].GetValue())
+
+	require.True(t, mockT.errorF)
+	require.False(t, mockT.failNow)
+	require.Equal(t, "\n%s", mockT.errorFString)
+}
+
+func TestRequire_Decorate_Success(t *testing.T) {
+	mockT := newMock()
+	a := NewRequireHelper(mockT)
+	dec, ok := a.(interface {
+		Decorate(name string, assertFunc func(t wrapper.TestingT) bool, params []*allure.Parameter, msgAndArgs ...interface{})
+	})
+	require.True(t, ok)
+
+	dec.Decorate("TestDecorate", func(wrapper.TestingT) bool {
+		return true
+	}, []*allure.Parameter{
+		{
+			Name:  "TestParam",
+			Value: "5",
+		},
+	})
+
+	require.Len(t, mockT.steps, 1)
+	require.Equal(t, "REQUIRE: TestDecorate", 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, 1)
+	require.Equal(t, "TestParam", params[0].Name)
+	require.Equal(t, "5", params[0].GetValue())
+
+	require.False(t, mockT.errorF)
+	require.False(t, mockT.failNow)
+	require.Empty(t, mockT.errorFString)
+}
+
+func TestRequire_Decorate_Fail(t *testing.T) {
+	mockT := newMock()
+	a := NewRequireHelper(mockT)
+	dec, ok := a.(interface {
+		Decorate(name string, assertFunc func(t wrapper.TestingT) bool, params []*allure.Parameter, msgAndArgs ...interface{})
+	})
+	require.True(t, ok)
+
+	dec.Decorate("TestDecorate", func(w wrapper.TestingT) bool {
+		w.Errorf("\n%s", "err")
+		return false
+	}, []*allure.Parameter{
+		{
+			Name:  "TestParam",
+			Value: "5",
+		},
+	})
+
+	require.Len(t, mockT.steps, 1)
+	require.Equal(t, "REQUIRE: TestDecorate", 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, 1)
+	require.Equal(t, "TestParam", params[0].Name)
+	require.Equal(t, "5", params[0].GetValue())
+
+	require.True(t, mockT.errorF)
+	require.True(t, mockT.failNow)
+	require.Equal(t, "\n%s", mockT.errorFString)
+}
+
 func TestAssertEqual_Success(t *testing.T) {
 	mockT := newMock()
 	NewAssertsHelper(mockT).Equal(1, 1)
@@ -2248,3 +2380,140 @@ func TestRequireRegexp_Failed(t *testing.T) {
 	require.True(t, mockT.failNow)
 	require.Equal(t, "\n%s", mockT.errorFString)
 }
+
+func TestAssertsEventually_Success(t *testing.T) {
+	mockT := newMock()
+
+	var (
+		counter int32
+		waitFor = time.Second
+		tick    = 10 * time.Millisecond
+	)
+	NewAssertsHelper(mockT).Eventually(func() bool {
+
+		if atomic.AddInt32(&counter, 1) < 3 {
+			time.Sleep(20 * time.Millisecond)
+			return false
+		}
+		return true
+	}, waitFor, tick)
+
+	steps := mockT.steps
+	require.Len(t, steps, 1)
+	require.Equal(t, "ASSERT: Eventually", steps[0].Name)
+	require.Equal(t, allure.Passed, steps[0].Status)
+
+	params := steps[0].Parameters
+	require.Len(t, params, 2)
+	require.Equal(t, "WaitFor", params[0].Name)
+	require.Equal(t, fmt.Sprintf("%v", waitFor), params[0].GetValue())
+
+	require.Equal(t, "Tick", params[1].Name)
+	require.Equal(t, fmt.Sprintf("%v", tick), params[1].GetValue())
+
+	require.False(t, mockT.errorF)
+	require.False(t, mockT.failNow)
+	require.Empty(t, mockT.errorFString)
+}
+
+func TestAssertsEventually_Fail(t *testing.T) {
+	mockT := newMock()
+
+	var (
+		counter int32
+		waitFor = 10 * time.Millisecond
+		tick    = 10 * time.Millisecond
+	)
+	NewAssertsHelper(mockT).Eventually(func() bool {
+		if atomic.AddInt32(&counter, 1) < 3 {
+			time.Sleep(20 * time.Millisecond)
+			return false
+		}
+		return true
+	}, waitFor, tick)
+
+	steps := mockT.steps
+	require.Len(t, steps, 1)
+	require.Equal(t, "ASSERT: Eventually", steps[0].Name)
+	require.Equal(t, allure.Failed, steps[0].Status)
+
+	params := steps[0].Parameters
+	require.Len(t, params, 2)
+	require.Equal(t, "WaitFor", params[0].Name)
+	require.Equal(t, fmt.Sprintf("%v", waitFor), params[0].GetValue())
+
+	require.Equal(t, "Tick", params[1].Name)
+	require.Equal(t, fmt.Sprintf("%v", tick), params[1].GetValue())
+
+	require.True(t, mockT.errorF)
+	require.False(t, mockT.failNow)
+	require.Equal(t, "\n%s", mockT.errorFString)
+}
+
+func TestRequireEventually_Success(t *testing.T) {
+	mockT := newMock()
+
+	var (
+		counter int32
+		waitFor = time.Second
+		tick    = 10 * time.Millisecond
+	)
+	NewRequireHelper(mockT).Eventually(func() bool {
+		if atomic.AddInt32(&counter, 1) < 3 {
+			time.Sleep(20 * time.Millisecond)
+			return false
+		}
+		return true
+	}, waitFor, tick)
+
+	steps := mockT.steps
+	require.Len(t, steps, 1)
+	require.Equal(t, "REQUIRE: Eventually", steps[0].Name)
+	require.Equal(t, allure.Passed, steps[0].Status)
+
+	params := steps[0].Parameters
+	require.Len(t, params, 2)
+	require.Equal(t, "WaitFor", params[0].Name)
+	require.Equal(t, fmt.Sprintf("%v", waitFor), params[0].GetValue())
+
+	require.Equal(t, "Tick", params[1].Name)
+	require.Equal(t, fmt.Sprintf("%v", tick), params[1].GetValue())
+
+	require.False(t, mockT.errorF)
+	require.False(t, mockT.failNow)
+	require.Empty(t, mockT.errorFString)
+}
+
+func TestRequireEventually_Fail(t *testing.T) {
+	mockT := newMock()
+
+	var (
+		counter int32
+		waitFor = 10 * time.Millisecond
+		tick    = 10 * time.Millisecond
+	)
+	NewRequireHelper(mockT).Eventually(func() bool {
+		if atomic.AddInt32(&counter, 1) < 3 {
+			time.Sleep(20 * time.Millisecond)
+			return false
+		}
+		return true
+	}, waitFor, tick)
+
+	steps := mockT.steps
+	require.Len(t, steps, 1)
+	require.Equal(t, "REQUIRE: Eventually", steps[0].Name)
+	require.Equal(t, allure.Failed, steps[0].Status)
+
+	params := steps[0].Parameters
+	require.Len(t, params, 2)
+	require.Equal(t, "WaitFor", params[0].Name)
+	require.Equal(t, fmt.Sprintf("%v", waitFor), params[0].GetValue())
+
+	require.Equal(t, "Tick", params[1].Name)
+	require.Equal(t, fmt.Sprintf("%v", tick), params[1].GetValue())
+
+	require.True(t, mockT.errorF)
+	require.True(t, mockT.failNow)
+	require.Equal(t, "\n%s", mockT.errorFString)
+}
diff --git a/pkg/framework/asserts_wrapper/helper/interfaces.go b/pkg/framework/asserts_wrapper/helper/interfaces.go
@@ -54,4 +54,5 @@ type AssertsHelper interface {
 	Zero(i interface{}, msgAndArgs ...interface{})
 	NotZero(i interface{}, msgAndArgs ...interface{})
 	InDelta(expected, actual interface{}, delta float64, msgAndArgs ...interface{})
+	Eventually(condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{})
 }
diff --git a/pkg/framework/asserts_wrapper/wrapper/helper.go b/pkg/framework/asserts_wrapper/wrapper/helper.go
@@ -11,30 +11,26 @@ type Provider interface {
 }
 
 type assertHelper struct {
-	required bool
+	prefix string
 }
 
 func (h *assertHelper) getStepName(assertName string, msgAndArgs ...interface{}) string {
-	prefix := "ASSERT"
-	if h.required {
-		prefix = "REQUIRE"
-	}
 	if len(msgAndArgs) == 0 {
-		return fmt.Sprintf("%s: %s", prefix, assertName)
+		return fmt.Sprintf("%s: %s", h.prefix, assertName)
 	}
-	return fmt.Sprintf("%s: %s", prefix, messageFromMsgAndArgs(msgAndArgs...))
+	return fmt.Sprintf("%s: %s", h.prefix, messageFromMsgAndArgs(msgAndArgs...))
 }
 
-func (h *assertHelper) withNewStep(t TestingT, provider Provider, assertName string, assert func(t TestingT) bool, params []*allure.Parameter, msgAndArgs ...interface{}) bool {
-	var result bool
-	step := allure.NewSimpleStep(h.getStepName(assertName, msgAndArgs...), params...)
-	defer func() {
-		if !result {
-			step.Failed()
-		}
-		provider.Step(step)
-	}()
-	result = assert(t)
+func (h *assertHelper) WithNewStep(t TestingT, provider Provider, assertName string, assert func(t TestingT) bool, params []*allure.Parameter, msgAndArgs ...interface{}) bool {
+	var (
+		step   = allure.NewSimpleStep(h.getStepName(assertName, msgAndArgs...), params...)
+		result = assert(t)
+	)
+
+	provider.Step(step)
+	if !result {
+		step.Failed()
+	}
 
 	return result
 }