Skip to content

Commit

Permalink
Merge pull request #22 from ozontech/release/issue-20
Browse files Browse the repository at this point in the history 
Release/issue 20
  • Loading branch information
@koodeex
koodeex authored Aug 16, 2022
2 parents f9a3917 + 373f3e6 commit fae7aee
Show file tree
Hide file tree
Showing 15 changed files with 2,989 additions and 23 deletions.
2 changes: 1 addition & 1 deletion pkg/framework/.golangci.yaml
View file
Original file line number Diff line number Diff line change
Expand Up @@ -40,7 +40,7 @@ linters:
- structcheck
- varcheck
- ineffassign
- typecheck
# - typecheck Strange behaviour
- dupl
- goconst
- gosec
Expand Down
30 changes: 30 additions & 0 deletions pkg/framework/README.md
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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. |
Expand Down Expand Up @@ -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. |
Expand Down Expand Up @@ -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{})` |
Expand All @@ -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.

Expand All @@ -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{})` |
Expand All @@ -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:

Expand Down
71 changes: 71 additions & 0 deletions pkg/framework/asserts_wrapper/asserts/asserts.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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 {
Expand All @@ -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...)
Expand All @@ -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...)
Expand All @@ -33,6 +59,21 @@ 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...)
}

// 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...)
}

// NotNil ...
func NotNil(t ProviderT, object interface{}, msgAndArgs ...interface{}) {
wrapper.NewAsserts(t).NotNil(t, object, msgAndArgs...)
Expand Down Expand Up @@ -113,6 +154,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...)
Expand All @@ -132,3 +178,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).ElementsMatch(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...)
}
Loading

0 comments on commit fae7aee

Please sign in to comment.