GoCracow #5 Bartlomiej klimczak - GoBDD

HI THERE!HI THERE!
I'M BARTŁOMIEJ KLIMCZAKI'M BARTŁOMIEJ KLIMCZAK
#gopher #GDE #blogger

THERE'S A LIBRARY FOR IT!THERE'S A LIBRARY FOR IT!
https://github.com/DATA-DOG/godog

... AND THIS LIBRARY IS... AND THIS LIBRARY IS
AWESOME!AWESOME!

... BUT IT DOES SOME MAGIC... BUT IT DOES SOME MAGIC

it runs as an external program

creates a temporary main_test file

it parses the temporary program's output

it parses the temporary program's output
displays the ouput in gherkin's format

THERE'RE WEAKNESSES OF THISTHERE'RE WEAKNESSES OF THIS
SOLUTIONSOLUTION
doesn't use the standard testing package

SOLUTIONSOLUTION
no good code coverage

SOLUTIONSOLUTION
no debugging the test code!

SOLUTIONSOLUTION
no debugging the test code!
no built-in features like build tags

THE GLOBAL STATE!THE GLOBAL STATE!
// Godogs available to eat
var Godogs int
// somewhere in the test
func FeatureContext(s *godog.Suite) {
s.Step(`^there are (d+) godogs$`, thereAreGodogs)
s.Step(`^I eat (d+)$`, iEat)
s.Step(`^there should be (d+) remaining$`, thereShoul
s.BeforeScenario(func(interface{}) {
Godogs = 0 // clean the state before every sce
})
}

THAT'S WHYTHAT'S WHY EXISTSEXISTS
Main goals:
GOBDDGOBDD
https://github.com/go-bdd/gobdd

Main goals:
no magic
GOBDDGOBDD

Main goals:
no magic
easy to use
GOBDDGOBDD

KEY FEATURES:KEY FEATURES:
uses gherkin syntax

uses gherkin syntax
uses standard testing package

uses gherkin syntax
allows debugging and profiling the application

uses gherkin syntax
allows debugging and profiling the application
uses context between steps

QUICK STARTQUICK START
go get github.com/go-bdd/gobdd
func TestScenarios(t *testing.T) {
suite := gobdd.NewSuite(t)
suite.AddStep(`I add (d+) and (d+)`, add)
suite.AddStep(`I the result should equal (d+)`, check
suite.Run()
}
# features/my.feature
Feature: math operations
Scenario: add two digits
When I add 1 and 2
Then I the result should equal 3

THE CONTEXTTHE CONTEXT
holds the data from previous steps

holds step's parameters fetched from the step’s
definition (may change)

easier parallelism

easier parallelism
The goal: hold every required information about the
step itself to be successfully executed.

Passing information between tests
// in the first step
ctx.Set(name{}, "John")
// in the second step
fmt.Printf("Hi %sn", ctx.GetString(name{})) // prints "Hi Joh

List of functions for getting the data
Context.GetInt(key interface{}, [defaultValue]) int
Context.GetFloat32(key interface{}, [defaultValue])
float32
Context.GetFloat64(key interface{}, [defaultValue])
float64
Context.GetString(key interface{}, [defaultValue])
string

CREATING STEPSCREATING STEPS (MAY CHANGE)(MAY CHANGE)
Create a step by implementing the interface
Example:
type StepFunc func(ctx context.Context) error
func add(ctx context.Context) error {
res := ctx.GetIntParam(0) + ctx.GetIntParam(1)
ctx.Set("sumRes", res)
return nil
}

THE CHANGESTHE CHANGES
Example:
type StepFunc func(ctx context.Context, args ...interface{}) e
func add(ctx context.Context, var1, var2 int) error {
res := var1 + var2
ctx.Set("sumRes", res)
return nil
}

HANDING ERRORSHANDING ERRORS
every step returns an error
panics are always recovered and transformed to
error
if a parameter is not defined - the test fails
func (ctx Context) Get(key interface{}, defaultValue ...interf
if _, ok := ctx.values[key]; !ok {
if len(defaultValue) == 1 {
return defaultValue[0]
}
panic(fmt.Sprintf("the key %s does not exist",
}
return ctx.values[key]
}

TESTING THE API - THETESTING THE API - THE
TESTHTTP PACKAGETESTHTTP PACKAGE
Initialization
router := http.NewServeMux()
testhttp.Build(s, router)

EXAMPLEEXAMPLE
func TestHTTP(t *testing.T) {
s := NewSuite(t, NewSuiteOptions())
router := http.NewServeMux()
router.HandleFunc("/health", func(w http.ResponseWrite
w.WriteHeader(http.StatusOK)
})
router.HandleFunc("/json", func(w http.ResponseWriter,
_, _ = w.Write([]byte(`{"valid": "json"}`))
w.WriteHeader(http.StatusOK)
})
testhttp.Build(s, router)
s.Run()
}

EXAMPLEEXAMPLE
Feature: HTTP requests
Scenario: test GET request
When I make a GET request to "/health"
Then the response code equals 200
Scenario: not existing URI
When I make a GET request to "/not-exists"
Then the response code equals 404
Scenario: testing JSON validation
When I make a GET request to "/json"
Then the response contains a valid JSON
And the response is "{"valid": "json"}"

PRE-DEFINED STEPSPRE-DEFINED STEPS
I make a
(GET|POST|PUT|DELETE|OPTIONS)
request to "([^"]*)
the response code equals (d+)
the response contains a valid JSON
the response is "(.*)"

A SMALL PACKAGE -A SMALL PACKAGE -
Available assertions:
Equals
NotEquals
ObjectsAreEqual
Nil
NotNil
ASSERTASSERT

ASSERTASSERT
func TestEqual(t *testing.T) {
if err := assert.Equals(1, 2); err == nil {
t.Error(err)
}
if err := assert.Equals(1, func() {}); err == nil {
t.Error("it shouldn't validate func in the par
}
if err := assert.Equals(5, 5); err != nil {
t.Error(err)
}
}

WEAK POINTSWEAK POINTS
very limited pre-defined steps

WEAK POINTSWEAK POINTS
very limited pre-defined steps
not good compatibility with gherkin's output format

WHAT NEXT?WHAT NEXT?
improving the testhttp package

write more packages (queues, reals API calls etc)

implement output formats (TeamCity, JUnit etc)

support for concurrent test execution

command line parameters

command line parameters
whatever will come to my mind :)

GITHUB:GITHUB:
HTTPS://GITHUB.COM/GO-HTTPS://GITHUB.COM/GO-
BDD/GOBDDBDD/GOBDD

THANK YOU!THANK YOU!
Twitter:
Email: bartlomiej.klimczak88 at gmail.com
@kabanek
developer20.com

GoCracow #5 Bartlomiej klimczak - GoBDD

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (19)

Ähnlich wie GoCracow #5 Bartlomiej klimczak - GoBDD

Ähnlich wie GoCracow #5 Bartlomiej klimczak - GoBDD (20)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

GoCracow #5 Bartlomiej klimczak - GoBDD