add new option for created features with parsing from byte slices

internal/flags/options.go

@@ -64,4 +64,9 @@ type Options struct {
 
 	// TestingT runs scenarios as subtests.
 	TestingT *testing.T
+
+	// FeatureContents allows passing in each feature manually
+	// where the contents of each feature is stored as a byte slice
+	// in a map entry
+	FeatureContents map[string][]byte
 }

internal/parser/parser.go

@@ -53,6 +53,22 @@ func parseFeatureFile(path string, newIDFunc func() string) (*models.Feature, er
 	return &f, nil
 }
 
+func parseBytes(path string, feature []byte, newIDFunc func() string) (*models.Feature, error) {
+	reader := bytes.NewReader(feature)
+
+	var buf bytes.Buffer
+	gherkinDocument, err := gherkin.ParseGherkinDocument(io.TeeReader(reader, &buf), newIDFunc)
+	if err != nil {
+		return nil, fmt.Errorf("%s - %v", path, err)
+	}
+
+	gherkinDocument.Uri = path
+	pickles := gherkin.Pickles(*gherkinDocument, path, newIDFunc)
+
+	f := models.Feature{GherkinDocument: gherkinDocument, Pickles: pickles, Content: buf.Bytes()}
+	return &f, nil
+}
+
 func parseFeatureDir(dir string, newIDFunc func() string) ([]*models.Feature, error) {
 	var features []*models.Feature
 	return features, filepath.Walk(dir, func(p string, f os.FileInfo, err error) error {
@@ -162,6 +178,39 @@ func ParseFeatures(filter string, paths []string) ([]*models.Feature, error) {
 	return features, nil
 }
 
+func ParseFromBytes(filter string, featuresInputs map[string][]byte) ([]*models.Feature, error) {
+	var order int
+
+	featureIdxs := make(map[string]int)
+	uniqueFeatureURI := make(map[string]*models.Feature)
+	newIDFunc := (&messages.Incrementing{}).NewId
+	for path, feature := range featuresInputs {
+		ft, err := parseBytes(path, feature, newIDFunc)
+		if err != nil {
+			return nil, err
+		}
+
+		if _, duplicate := uniqueFeatureURI[ft.Uri]; duplicate {
+			continue
+		}
+
+		uniqueFeatureURI[ft.Uri] = ft
+		featureIdxs[ft.Uri] = order
+
+		order++
+	}
+
+	var features = make([]*models.Feature, len(uniqueFeatureURI))
+	for uri, feature := range uniqueFeatureURI {
+		idx := featureIdxs[uri]
+		features[idx] = feature
+	}
+
+	features = filterFeatures(filter, features)
+
+	return features, nil
+}
+
 func filterFeatures(filter string, features []*models.Feature) (result []*models.Feature) {
 	for _, ft := range features {
 		ft.Pickles = tags.ApplyTagFilter(filter, ft.Pickles)

internal/parser/parser_test.go

@@ -37,6 +37,43 @@ func Test_FeatureFilePathParser(t *testing.T) {
 	}
 }
 
+func Test_ParseFromBytes_FromMultipleFeatures(t *testing.T) {
+	featureFileName := "godogs.feature"
+	eatGodogContents := `
+Feature: eat godogs
+  In order to be happy
+  As a hungry gopher
+  I need to be able to eat godogs
+
+  Scenario: Eat 5 out of 12
+    Given there are 12 godogs
+    When I eat 5
+    Then there should be 7 remaining`
+
+	baseDir := filepath.Join(os.TempDir(), t.Name(), "godogs")
+	errA := os.MkdirAll(baseDir+"/a", 0755)
+	defer os.RemoveAll(baseDir)
+
+	require.Nil(t, errA)
+
+	err := ioutil.WriteFile(filepath.Join(baseDir, featureFileName), []byte(eatGodogContents), 0644)
+	require.Nil(t, err)
+
+	featureFromFile, err := parser.ParseFeatures("", []string{baseDir})
+	require.NoError(t, err)
+	require.Len(t, featureFromFile, 1)
+
+	input := map[string][]byte{
+		filepath.Join(baseDir, featureFileName): []byte(eatGodogContents),
+	}
+
+	featureFromBytes, err := parser.ParseFromBytes("", input)
+	require.NoError(t, err)
+	require.Len(t, featureFromBytes, 1)
+
+	assert.Equal(t, featureFromFile, featureFromBytes)
+}
+
 func Test_ParseFeatures_FromMultiplePaths(t *testing.T) {
 	const featureFileName = "godogs.feature"
 	const featureFileContents = `Feature: eat godogs

run.go

@@ -227,7 +227,12 @@ func runWithOptions(suiteName string, runner runner, opt Options) int {
 	runner.fmt = multiFmt.FormatterFunc(suiteName, output)
 
 	var err error
-	if runner.features, err = parser.ParseFeatures(opt.Tags, opt.Paths); err != nil {
+	if len(opt.FeatureContents) > 0 {
+		runner.features, err = parser.ParseFromBytes(opt.Tags, opt.FeatureContents)
+	} else {
+		runner.features, err = parser.ParseFeatures(opt.Tags, opt.Paths)
+	}
+	if err != nil {
 		fmt.Fprintln(os.Stderr, err)
 		return exitOptionError
 	}

run_test.go

@@ -263,6 +263,46 @@ func Test_ByDefaultRunsFeaturesPath(t *testing.T) {
 	assert.Equal(t, exitSuccess, status)
 }
 
+func Test_RunsWithFeatureContentsOption(t *testing.T) {
+	items, err := ioutil.ReadDir("./features")
+	require.NoError(t, err)
+
+	featureContents := make(map[string][]byte)
+	for _, item := range items {
+		if !item.IsDir() && strings.Contains(item.Name(), ".feature"){
+			contents, err := os.ReadFile("./features/"+item.Name())
+			require.NoError(t, err)
+			featureContents[item.Name()] = contents
+		}
+	}
+
+	opts := Options{
+		Format: "progress",
+		Output: ioutil.Discard,
+		Strict: true,
+		FeatureContents: featureContents,
+	}
+
+	status := TestSuite{
+		Name:                "fails",
+		ScenarioInitializer: func(_ *ScenarioContext) {},
+		Options:             &opts,
+	}.Run()
+
+	// should fail in strict mode due to undefined steps
+	assert.Equal(t, exitFailure, status)
+
+	opts.Strict = false
+	status = TestSuite{
+		Name:                "succeeds",
+		ScenarioInitializer: func(_ *ScenarioContext) {},
+		Options:             &opts,
+	}.Run()
+
+	// should succeed in non strict mode due to undefined steps
+	assert.Equal(t, exitSuccess, status)
+}
+
 func bufErrorPipe(t *testing.T) (io.ReadCloser, func()) {
 	stderr := os.Stderr
 	r, w, err := os.Pipe()