Merge pull request #4 from a-hilaly/runnable-remove

Remove `Runnable` interface.

Author: jaypipes

porcelain.go

@@ -15,7 +15,6 @@ import (
 	_ "github.com/gdt-dev/gdt/plugin/exec"
 	"github.com/gdt-dev/gdt/scenario"
 	"github.com/gdt-dev/gdt/suite"
-	gdttypes "github.com/gdt-dev/gdt/types"
 )
 
 var (
@@ -27,7 +26,7 @@ var (
 	// RegisterFixture registers a named fixtures with the context
 	RegisterFixture = gdtcontext.RegisterFixture
 	// NewContext returns a new `context.Context` that can be passed to a
-	// `Runnable` (a `Suite` or `Scenario` returned from the `From` function).
+	// `scenario.Run` or `suite.Run` pointer receivers.
 	NewContext = gdtcontext.New
 	// WithFixtures sets a context's Fixtures
 	WithFixtures = gdtcontext.WithFixtures
@@ -90,18 +89,19 @@ var (
 	NewJSONFixture = jsonfix.New
 )
 
-// From returns a new Runnable thing from an `io.Reader`, a string file or
+// From returns a new suite.Suite from an `io.Reader`, a string file or
 // directory path, or the raw bytes of YAML content describing a scenario or
 // suite.
-func From(source interface{}) (gdttypes.Runnable, error) {
-	switch source.(type) {
+func From(source interface{}) (*suite.Suite, error) {
+	switch src := source.(type) {
 	case io.Reader:
-		return scenario.FromReader(
-			source.(io.Reader),
-		)
+		s, err := scenario.FromReader(src)
+		if err != nil {
+			return nil, err
+		}
+		return suite.FromScenario(s), nil
 	case string:
-		path := source.(string)
-		f, err := os.Open(path)
+		f, err := os.Open(src)
 		if err != nil {
 			return nil, err
 		}
@@ -110,12 +110,19 @@ func From(source interface{}) (gdttypes.Runnable, error) {
 			return nil, err
 		}
 		if fi.IsDir() {
-			return suite.FromDir(path)
-		} else {
-			return scenario.FromReader(f, scenario.WithPath(path))
+			return suite.FromDir(src)
 		}
+		s, err := scenario.FromReader(f, scenario.WithPath(src))
+		if err != nil {
+			return nil, err
+		}
+		return suite.FromScenario(s), nil
 	case []byte:
-		return scenario.FromBytes(source.([]byte))
+		s, err := scenario.FromBytes(src)
+		if err != nil {
+			return nil, err
+		}
+		return suite.FromScenario(s), nil
 	default:
 		return nil, gdterrors.UnknownSourceType(source)
 	}

porcelain_test.go

@@ -12,8 +12,6 @@ import (
 
 	"github.com/gdt-dev/gdt"
 	gdterrors "github.com/gdt-dev/gdt/errors"
-	"github.com/gdt-dev/gdt/scenario"
-	"github.com/gdt-dev/gdt/suite"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -46,12 +44,9 @@ func TestFromSuite(t *testing.T) {
 	require := require.New(t)
 
 	fp := filepath.Join("suite", "testdata", "exec")
-	s, err := gdt.From(fp)
+	suite, err := gdt.From(fp)
 	require.Nil(err)
-	require.NotNil(s)
-
-	suite, ok := s.(*suite.Suite)
-	require.True(ok, "gdt.From() did not return a Suite")
+	require.NotNil(suite)
 
 	assert.Equal(fp, suite.Path)
 	assert.Len(suite.Scenarios, 2)
@@ -66,11 +61,10 @@ func TestFromScenarioPath(t *testing.T) {
 	require.Nil(err)
 	require.NotNil(s)
 
-	sc, ok := s.(*scenario.Scenario)
-	assert.True(ok, "gdt.From() with dir path did not return a Scenario")
-
-	assert.Equal(fp, sc.Path)
-	assert.Len(sc.Tests, 1)
+	assert.Equal(fp, s.Path)
+	assert.Len(s.Scenarios, 1)
+	assert.Len(s.Scenarios[0].Tests, 1)
+	assert.Equal("exec", s.Name)
 }
 
 func TestFromScenarioReader(t *testing.T) {
@@ -80,38 +74,33 @@ func TestFromScenarioReader(t *testing.T) {
 	fp := filepath.Join("suite", "testdata", "exec", "ls.yaml")
 	f, err := os.Open(fp)
 	require.Nil(err)
-	s, err := gdt.From(f)
-	require.Nil(err)
-	require.NotNil(s)
-
-	sc, ok := s.(*scenario.Scenario)
-	assert.True(ok, "gdt.From() from file path did not return a Scenario")
+	suite, err := gdt.From(f)
+	assert.Nil(err)
+	assert.NotNil(suite)
 
 	// The scenario's path isn't set because we didn't supply a filepath...
-	assert.Equal("", sc.Path)
-	assert.Len(sc.Tests, 1)
+	assert.Equal("", suite.Path)
+	assert.Len(suite.Scenarios, 1)
+	assert.Len(suite.Scenarios[0].Tests, 1)
 }
 
 func TestFromScenarioBytes(t *testing.T) {
 	assert := assert.New(t)
-	require := require.New(t)
 
 	raw := `name: foo
 description: simple foo test
 tests:
  - exec: echo foo
 `
 	b := []byte(raw)
-	s, err := gdt.From(b)
-	require.Nil(err)
-	require.NotNil(s)
-
-	sc, ok := s.(*scenario.Scenario)
-	assert.True(ok, "gdt.From() with []byte did not return a Scenario")
+	suite, err := gdt.From(b)
+	assert.Nil(err)
+	assert.NotNil(suite)
 
 	// The scenario's path isn't set because we didn't supply a filepath...
-	assert.Equal("", sc.Path)
-	assert.Len(sc.Tests, 1)
+	assert.Equal("", suite.Path)
+	assert.Len(suite.Scenarios, 1)
+	assert.Len(suite.Scenarios[0].Tests, 1)
 }
 
 func TestRunExecSuite(t *testing.T) {

suite/from.go

@@ -58,3 +58,22 @@ func FromDir(
 	}
 	return s, nil
 }
+
+// FromScenario encapsulates a given scenario in a fresh suite and returns it.
+func FromScenario(s *scenario.Scenario) *Suite {
+	return &Suite{
+		Path:        s.Path,
+		Name:        suiteNameFromScenarioPath(s.Path),
+		Description: s.Description,
+		// NOTE: require needs to be named to fixture?
+		Require:   s.Fixtures,
+		Defaults:  s.Defaults,
+		Scenarios: []*scenario.Scenario{s},
+	}
+}
+
+func suiteNameFromScenarioPath(p string) string {
+	dir := filepath.Dir(p)
+	parent := filepath.Base(dir)
+	return parent
+}

suite/suite.go

@@ -8,7 +8,7 @@ import (
 	"github.com/gdt-dev/gdt/scenario"
 )
 
-// Suite contains zero or more Runnable things, one for each YAML file
+// Suite contains zero or more scenarios, one for each YAML file
 // representing a Scenario in a given directory
 type Suite struct {
 	// Path is the filepath to the test suite directory.
@@ -77,7 +77,7 @@ func New(mods ...SuiteModifier) *Suite {
 	return s
 }
 
-// Append appends a runnable test element to the test suite
+// Append appends a test element to the test suite
 func (s *Suite) Append(sc *scenario.Scenario) {
 	s.Scenarios = append(s.Scenarios, sc)
 }