Created internal packages for formatters, storage and models

Author: lonnblad

.circleci/config.yml

@@ -36,7 +36,7 @@ commands:
   go_test:
     description: "Run go test"
     steps:
-      - run: sed -i 's#github.com/cucumber/godog_test#_test#g' formatter-tests/*/*
+      - run: sed -i 's#github.com/cucumber/godog/internal/formatters_test#/internal/formatters_test#g' internal/formatters/formatter-tests/*/*
       - run: go test -v -race -coverprofile=coverage.txt -covermode=atomic ./...
   godog:
     description: "Run godog"

flags.go

@@ -10,8 +10,12 @@ import (
 	"time"
 
 	"github.com/cucumber/godog/colors"
+	"github.com/cucumber/godog/internal/utils"
 )
 
+// repeats a space n times
+var s = utils.S
+
 var descFeaturesArgument = "Optional feature(s) to run. Can be:\n" +
 	s(4) + "- dir " + colors.Yellow("(features/)") + "\n" +
 	s(4) + "- feature " + colors.Yellow("(*.feature)") + "\n" +

flags_test.go

@@ -8,6 +8,7 @@ import (
 	"testing"
 
 	"github.com/cucumber/godog/colors"
+	"github.com/cucumber/godog/internal/formatters"
 )
 
 func TestFlagsShouldRandomizeAndGenerateSeed(t *testing.T) {
@@ -61,7 +62,7 @@ func TestFlagsUsageShouldIncludeFormatDescriptons(t *testing.T) {
 	output := colors.Uncolored(&buf)
 
 	// register some custom formatter
-	Format("custom", "custom format description", junitFunc)
+	Format("custom", "custom format description", formatters.JUnitFormatterFunc)
 
 	var opt Options
 	flags := FlagSet(&opt)

fmt.go

@@ -6,53 +6,33 @@ import (
 	"strings"
 	"unicode/utf8"
 
-	"github.com/cucumber/messages-go/v10"
+	"github.com/cucumber/godog/colors"
+	"github.com/cucumber/godog/formatters"
+	internal_fmt "github.com/cucumber/godog/internal/formatters"
+	"github.com/cucumber/godog/internal/models"
+	"github.com/cucumber/godog/internal/storage"
 )
 
-type registeredFormatter struct {
-	name        string
-	description string
-	fmt         FormatterFunc
-}
-
-var formatters []*registeredFormatter
-
 // FindFmt searches available formatters registered
 // and returns FormaterFunc matched by given
 // format name or nil otherwise
 func FindFmt(name string) FormatterFunc {
-	for _, el := range formatters {
-		if el.name == name {
-			return el.fmt
-		}
-	}
-
-	return nil
+	return formatters.FindFmt(name)
 }
 
 // Format registers a feature suite output
 // formatter by given name, description and
 // FormatterFunc constructor function, to initialize
 // formatter with the output recorder.
 func Format(name, description string, f FormatterFunc) {
-	formatters = append(formatters, &registeredFormatter{
-		name:        name,
-		fmt:         f,
-		description: description,
-	})
+	formatters.Format(name, description, f)
 }
 
 // AvailableFormatters gives a map of all
 // formatters registered with their name as key
 // and description as value
 func AvailableFormatters() map[string]string {
-	fmts := make(map[string]string, len(formatters))
-
-	for _, f := range formatters {
-		fmts[f.name] = f.description
-	}
-
-	return fmts
+	return formatters.AvailableFormatters()
 }
 
 // Formatter is an interface for feature runner
@@ -62,32 +42,17 @@ func AvailableFormatters() map[string]string {
 // suite results in different ways. These new
 // formatters needs to be registered with a
 // godog.Format function call
-type Formatter interface {
-	TestRunStarted()
-	Feature(*messages.GherkinDocument, string, []byte)
-	Pickle(*messages.Pickle)
-	Defined(*messages.Pickle, *messages.Pickle_PickleStep, *StepDefinition)
-	Failed(*messages.Pickle, *messages.Pickle_PickleStep, *StepDefinition, error)
-	Passed(*messages.Pickle, *messages.Pickle_PickleStep, *StepDefinition)
-	Skipped(*messages.Pickle, *messages.Pickle_PickleStep, *StepDefinition)
-	Undefined(*messages.Pickle, *messages.Pickle_PickleStep, *StepDefinition)
-	Pending(*messages.Pickle, *messages.Pickle_PickleStep, *StepDefinition)
-	Summary()
-}
+type Formatter = formatters.Formatter
 
 type storageFormatter interface {
-	setStorage(*storage)
+	SetStorage(*storage.Storage)
 }
 
 // FormatterFunc builds a formatter with given
 // suite name and io.Writer to record output
-type FormatterFunc func(string, io.Writer) Formatter
-
-func isLastStep(pickle *messages.Pickle, step *messages.Pickle_PickleStep) bool {
-	return pickle.Steps[len(pickle.Steps)-1].Id == step.Id
-}
+type FormatterFunc = formatters.FormatterFunc
 
-func printStepDefinitions(steps []*StepDefinition, w io.Writer) {
+func printStepDefinitions(steps []*models.StepDefinition, w io.Writer) {
 	var longest int
 	for _, def := range steps {
 		n := utf8.RuneCountInString(def.Expr.String())
@@ -98,9 +63,11 @@ func printStepDefinitions(steps []*StepDefinition, w io.Writer) {
 
 	for _, def := range steps {
 		n := utf8.RuneCountInString(def.Expr.String())
-		location := def.definitionID()
+		location := internal_fmt.DefinitionID(def)
 		spaces := strings.Repeat(" ", longest-n)
-		fmt.Fprintln(w, yellow(def.Expr.String())+spaces, blackb("# "+location))
+		fmt.Fprintln(w,
+			colors.Yellow(def.Expr.String())+spaces,
+			colors.Bold(colors.Black)("# "+location))
 	}
 
 	if len(steps) == 0 {

formatters/fmt.go

@@ -0,0 +1,79 @@
+package formatters
+
+import (
+	"io"
+
+	"github.com/cucumber/messages-go/v10"
+
+	"github.com/cucumber/godog/internal/models"
+)
+
+type registeredFormatter struct {
+	name        string
+	description string
+	fmt         FormatterFunc
+}
+
+var registeredFormatters []*registeredFormatter
+
+// FindFmt searches available formatters registered
+// and returns FormaterFunc matched by given
+// format name or nil otherwise
+func FindFmt(name string) FormatterFunc {
+	for _, el := range registeredFormatters {
+		if el.name == name {
+			return el.fmt
+		}
+	}
+
+	return nil
+}
+
+// Format registers a feature suite output
+// formatter by given name, description and
+// FormatterFunc constructor function, to initialize
+// formatter with the output recorder.
+func Format(name, description string, f FormatterFunc) {
+	registeredFormatters = append(registeredFormatters, &registeredFormatter{
+		name:        name,
+		fmt:         f,
+		description: description,
+	})
+}
+
+// AvailableFormatters gives a map of all
+// formatters registered with their name as key
+// and description as value
+func AvailableFormatters() map[string]string {
+	fmts := make(map[string]string, len(registeredFormatters))
+
+	for _, f := range registeredFormatters {
+		fmts[f.name] = f.description
+	}
+
+	return fmts
+}
+
+// Formatter is an interface for feature runner
+// output summary presentation.
+//
+// New formatters may be created to represent
+// suite results in different ways. These new
+// formatters needs to be registered with a
+// godog.Format function call
+type Formatter interface {
+	TestRunStarted()
+	Feature(*messages.GherkinDocument, string, []byte)
+	Pickle(*messages.Pickle)
+	Defined(*messages.Pickle, *messages.Pickle_PickleStep, *models.StepDefinition)
+	Failed(*messages.Pickle, *messages.Pickle_PickleStep, *models.StepDefinition, error)
+	Passed(*messages.Pickle, *messages.Pickle_PickleStep, *models.StepDefinition)
+	Skipped(*messages.Pickle, *messages.Pickle_PickleStep, *models.StepDefinition)
+	Undefined(*messages.Pickle, *messages.Pickle_PickleStep, *models.StepDefinition)
+	Pending(*messages.Pickle, *messages.Pickle_PickleStep, *models.StepDefinition)
+	Summary()
+}
+
+// FormatterFunc builds a formatter with given
+// suite name and io.Writer to record output
+type FormatterFunc func(string, io.Writer) Formatter

formatters/fmt_test.go

@@ -0,0 +1,65 @@
+package formatters_test
+
+import (
+	"io"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/cucumber/godog"
+)
+
+func Test_FindFmt(t *testing.T) {
+	cases := map[string]bool{
+		"cucumber": true,
+		"events":   true,
+		"junit":    true,
+		"pretty":   true,
+		"progress": true,
+		"unknown":  false,
+		"undef":    false,
+	}
+
+	for name, expected := range cases {
+		t.Run(
+			name,
+			func(t *testing.T) {
+				actual := godog.FindFmt(name)
+
+				if expected {
+					assert.NotNilf(t, actual, "expected %s formatter should be available", name)
+				} else {
+					assert.Nilf(t, actual, "expected %s formatter should be available", name)
+				}
+			},
+		)
+	}
+}
+
+func Test_AvailableFormatters(t *testing.T) {
+	expected := map[string]string{
+		"cucumber": "Produces cucumber JSON format output.",
+		"events":   "Produces JSON event stream, based on spec: 0.1.0.",
+		"junit":    "Prints junit compatible xml to stdout",
+		"pretty":   "Prints every feature with runtime statuses.",
+		"progress": "Prints a character per step.",
+	}
+
+	actual := godog.AvailableFormatters()
+	assert.Equal(t, expected, actual)
+}
+
+func Test_Format(t *testing.T) {
+	actual := godog.FindFmt("Test_Format")
+	require.Nil(t, actual)
+
+	godog.Format("Test_Format", "...", testFormatterFunc)
+	actual = godog.FindFmt("Test_Format")
+
+	assert.NotNil(t, actual)
+}
+
+func testFormatterFunc(suiteName string, out io.Writer) godog.Formatter {
+	return nil
+}