simplify suite event contracts

events.go

@@ -1,103 +0,0 @@
-package godog
-
-import "github.com/DATA-DOG/godog/gherkin"
-
-// BeforeSuiteHandler can be registered
-// in Suite to be executed once before
-// running a feature suite
-type BeforeSuiteHandler interface {
-	HandleBeforeSuite()
-}
-
-// BeforeSuiteHandlerFunc is a function implementing
-// BeforeSuiteHandler interface
-type BeforeSuiteHandlerFunc func()
-
-// HandleBeforeSuite is called once before suite
-func (f BeforeSuiteHandlerFunc) HandleBeforeSuite() {
-	f()
-}
-
-// BeforeScenarioHandler can be registered
-// in Suite to be executed before every scenario
-// which will be run
-type BeforeScenarioHandler interface {
-	HandleBeforeScenario(scenario *gherkin.Scenario)
-}
-
-// BeforeScenarioHandlerFunc is a function implementing
-// BeforeScenarioHandler interface
-type BeforeScenarioHandlerFunc func(scenario *gherkin.Scenario)
-
-// HandleBeforeScenario is called with a *gherkin.Scenario argument
-// for before every scenario which is run by suite
-func (f BeforeScenarioHandlerFunc) HandleBeforeScenario(scenario *gherkin.Scenario) {
-	f(scenario)
-}
-
-// BeforeStepHandler can be registered
-// in Suite to be executed before every step
-// which will be run
-type BeforeStepHandler interface {
-	HandleBeforeStep(step *gherkin.Step)
-}
-
-// BeforeStepHandlerFunc is a function implementing
-// BeforeStepHandler interface
-type BeforeStepHandlerFunc func(step *gherkin.Step)
-
-// HandleBeforeStep is called with a *gherkin.Step argument
-// for before every step which is run by suite
-func (f BeforeStepHandlerFunc) HandleBeforeStep(step *gherkin.Step) {
-	f(step)
-}
-
-// AfterStepHandler can be registered
-// in Suite to be executed after every step
-// which will be run
-type AfterStepHandler interface {
-	HandleAfterStep(step *gherkin.Step, err error)
-}
-
-// AfterStepHandlerFunc is a function implementing
-// AfterStepHandler interface
-type AfterStepHandlerFunc func(step *gherkin.Step, err error)
-
-// HandleAfterStep is called with a *gherkin.Step argument
-// for after every step which is run by suite
-func (f AfterStepHandlerFunc) HandleAfterStep(step *gherkin.Step, err error) {
-	f(step, err)
-}
-
-// AfterScenarioHandler can be registered
-// in Suite to be executed after every scenario
-// which will be run
-type AfterScenarioHandler interface {
-	HandleAfterScenario(scenario *gherkin.Scenario, err error)
-}
-
-// AfterScenarioHandlerFunc is a function implementing
-// AfterScenarioHandler interface
-type AfterScenarioHandlerFunc func(scenario *gherkin.Scenario, err error)
-
-// HandleAfterScenario is called with a *gherkin.Scenario argument
-// for after every scenario which is run by suite
-func (f AfterScenarioHandlerFunc) HandleAfterScenario(scenario *gherkin.Scenario, err error) {
-	f(scenario, err)
-}
-
-// AfterSuiteHandler can be registered
-// in Suite to be executed once after
-// running a feature suite
-type AfterSuiteHandler interface {
-	HandleAfterSuite()
-}
-
-// AfterSuiteHandlerFunc is a function implementing
-// AfterSuiteHandler interface
-type AfterSuiteHandlerFunc func()
-
-// HandleAfterSuite is called once after suite
-func (f AfterSuiteHandlerFunc) HandleAfterSuite() {
-	f()
-}

suite.go

@@ -65,12 +65,12 @@ type StepDef struct {
 type Suite interface {
 	Step(expr Regexp, h Handler)
 	// suite events
-	BeforeSuite(h BeforeSuiteHandler)
+	BeforeSuite(f func())
-	BeforeScenario(h BeforeScenarioHandler)
+	BeforeScenario(f func(*gherkin.Scenario))
-	BeforeStep(h BeforeStepHandler)
+	BeforeStep(f func(*gherkin.Step))
-	AfterStep(h AfterStepHandler)
+	AfterStep(f func(*gherkin.Step, error))
-	AfterScenario(h AfterScenarioHandler)
+	AfterScenario(f func(*gherkin.Scenario, error))
-	AfterSuite(h AfterSuiteHandler)
+	AfterSuite(f func())
 }
 
 type suite struct {
@@ -81,12 +81,12 @@ type suite struct {
 	failed bool
 
 	// suite event handlers
-	beforeSuiteHandlers    []BeforeSuiteHandler
+	beforeSuiteHandlers    []func()
-	beforeScenarioHandlers []BeforeScenarioHandler
+	beforeScenarioHandlers []func(*gherkin.Scenario)
-	beforeStepHandlers     []BeforeStepHandler
+	beforeStepHandlers     []func(*gherkin.Step)
-	afterStepHandlers      []AfterStepHandler
+	afterStepHandlers      []func(*gherkin.Step, error)
-	afterScenarioHandlers  []AfterScenarioHandler
+	afterScenarioHandlers  []func(*gherkin.Scenario, error)
-	afterSuiteHandlers     []AfterSuiteHandler
+	afterSuiteHandlers     []func()
 }
 
 // New initializes a suite which supports the Suite
@@ -140,40 +140,40 @@ func (s *suite) Step(expr Regexp, h Handler) {
 	})
 }
 
-// BeforeSuite registers a BeforeSuiteHandler
+// BeforeSuite registers a function or method
 // to be run once before suite runner
-func (s *suite) BeforeSuite(h BeforeSuiteHandler) {
+func (s *suite) BeforeSuite(f func()) {
-	s.beforeSuiteHandlers = append(s.beforeSuiteHandlers, h)
+	s.beforeSuiteHandlers = append(s.beforeSuiteHandlers, f)
 }
 
-// BeforeScenario registers a BeforeScenarioHandler
+// BeforeScenario registers a function or method
 // to be run before every scenario
-func (s *suite) BeforeScenario(h BeforeScenarioHandler) {
+func (s *suite) BeforeScenario(f func(*gherkin.Scenario)) {
-	s.beforeScenarioHandlers = append(s.beforeScenarioHandlers, h)
+	s.beforeScenarioHandlers = append(s.beforeScenarioHandlers, f)
 }
 
-// BeforeStep registers a BeforeStepHandler
+// BeforeStep registers a function or method
 // to be run before every scenario
-func (s *suite) BeforeStep(h BeforeStepHandler) {
+func (s *suite) BeforeStep(f func(*gherkin.Step)) {
-	s.beforeStepHandlers = append(s.beforeStepHandlers, h)
+	s.beforeStepHandlers = append(s.beforeStepHandlers, f)
 }
 
-// AfterStep registers an AfterStepHandler
+// AfterStep registers an function or method
 // to be run after every scenario
-func (s *suite) AfterStep(h AfterStepHandler) {
+func (s *suite) AfterStep(f func(*gherkin.Step, error)) {
-	s.afterStepHandlers = append(s.afterStepHandlers, h)
+	s.afterStepHandlers = append(s.afterStepHandlers, f)
 }
 
-// AfterScenario registers an AfterScenarioHandler
+// AfterScenario registers an function or method
 // to be run after every scenario
-func (s *suite) AfterScenario(h AfterScenarioHandler) {
+func (s *suite) AfterScenario(f func(*gherkin.Scenario, error)) {
-	s.afterScenarioHandlers = append(s.afterScenarioHandlers, h)
+	s.afterScenarioHandlers = append(s.afterScenarioHandlers, f)
 }
 
-// AfterSuite registers a AfterSuiteHandler
+// AfterSuite registers a function or method
 // to be run once after suite runner
-func (s *suite) AfterSuite(h AfterSuiteHandler) {
+func (s *suite) AfterSuite(f func()) {
-	s.afterSuiteHandlers = append(s.afterSuiteHandlers, h)
+	s.afterSuiteHandlers = append(s.afterSuiteHandlers, f)
 }
 
 // Run - runs a godog feature suite
@@ -208,8 +208,8 @@ func (s *suite) Run() {
 
 func (s *suite) run() {
 	// run before suite handlers
-	for _, h := range s.beforeSuiteHandlers {
+	for _, f := range s.beforeSuiteHandlers {
-		h.HandleBeforeSuite()
+		f()
 	}
 	// run features
 	for _, f := range s.features {
@@ -220,8 +220,8 @@ func (s *suite) run() {
 		}
 	}
 	// run after suite handlers
-	for _, h := range s.afterSuiteHandlers {
+	for _, f := range s.afterSuiteHandlers {
-		h.HandleAfterSuite()
+		f()
 	}
 	s.fmt.Summary()
 }
@@ -276,15 +276,15 @@ func (s *suite) runSteps(steps []*gherkin.Step) (err error) {
 		}
 
 		// run before step handlers
-		for _, h := range s.beforeStepHandlers {
+		for _, f := range s.beforeStepHandlers {
-			h.HandleBeforeStep(step)
+			f(step)
 		}
 
 		err = s.runStep(step)
 
 		// run after step handlers
-		for _, h := range s.afterStepHandlers {
+		for _, f := range s.afterStepHandlers {
-			h.HandleAfterStep(step, err)
+			f(step, err)
 		}
 	}
 	return
@@ -352,8 +352,8 @@ func (s *suite) runFeature(f *gherkin.Feature) {
 
 func (s *suite) runScenario(scenario *gherkin.Scenario) (err error) {
 	// run before scenario handlers
-	for _, h := range s.beforeScenarioHandlers {
+	for _, f := range s.beforeScenarioHandlers {
-		h.HandleBeforeScenario(scenario)
+		f(scenario)
 	}
 
 	// background
@@ -374,8 +374,8 @@ func (s *suite) runScenario(scenario *gherkin.Scenario) (err error) {
 	}
 
 	// run after scenario handlers
-	for _, h := range s.afterScenarioHandlers {
+	for _, f := range s.afterScenarioHandlers {
-		h.HandleAfterScenario(scenario, err)
+		f(scenario, err)
 	}
 
 	return

suite_test.go

@@ -10,7 +10,7 @@ import (
 func SuiteContext(s Suite) {
 	c := &suiteContext{}
 
-	s.BeforeScenario(c)
+	s.BeforeScenario(c.HandleBeforeScenario)
 
 	s.Step(`^a feature path "([^"]*)"$`, c.featurePath)
 	s.Step(`^I parse features$`, c.parseFeatures)
@@ -112,24 +112,24 @@ func (s *suiteContext) followingStepsShouldHave(args ...*Arg) error {
 }
 
 func (s *suiteContext) iAmListeningToSuiteEvents(args ...*Arg) error {
-	s.testedSuite.BeforeSuite(BeforeSuiteHandlerFunc(func() {
+	s.testedSuite.BeforeSuite(func() {
 		s.events = append(s.events, &firedEvent{"BeforeSuite", []interface{}{}})
-	}))
+	})
-	s.testedSuite.AfterSuite(AfterSuiteHandlerFunc(func() {
+	s.testedSuite.AfterSuite(func() {
 		s.events = append(s.events, &firedEvent{"AfterSuite", []interface{}{}})
-	}))
+	})
-	s.testedSuite.BeforeScenario(BeforeScenarioHandlerFunc(func(scenario *gherkin.Scenario) {
+	s.testedSuite.BeforeScenario(func(scenario *gherkin.Scenario) {
 		s.events = append(s.events, &firedEvent{"BeforeScenario", []interface{}{scenario}})
-	}))
+	})
-	s.testedSuite.AfterScenario(AfterScenarioHandlerFunc(func(scenario *gherkin.Scenario, err error) {
+	s.testedSuite.AfterScenario(func(scenario *gherkin.Scenario, err error) {
 		s.events = append(s.events, &firedEvent{"AfterScenario", []interface{}{scenario, err}})
-	}))
+	})
-	s.testedSuite.BeforeStep(BeforeStepHandlerFunc(func(step *gherkin.Step) {
+	s.testedSuite.BeforeStep(func(step *gherkin.Step) {
 		s.events = append(s.events, &firedEvent{"BeforeStep", []interface{}{step}})
-	}))
+	})
-	s.testedSuite.AfterStep(AfterStepHandlerFunc(func(step *gherkin.Step, err error) {
+	s.testedSuite.AfterStep(func(step *gherkin.Step, err error) {
 		s.events = append(s.events, &firedEvent{"AfterStep", []interface{}{step, err}})
-	}))
+	})
 	return nil
 }