Refactors detector codepath

- renames detector pkg -> detection
- splits up detector.Detector into 2 parts:
  - detection.GetNodeVersion which parses the node version number out of
    a package.json
  - detection.NewPlan which will return a buildplan.Plan

[#166687251]

Author: Ryan Moran

cmd/build/main.go

@@ -17,32 +17,28 @@ func main() {
 		os.Exit(100)
 	}
 
-	code, err := runBuild(context)
-	if err != nil {
-		context.Logger.Info(err.Error())
-	}
-
-	os.Exit(code)
-}
-
-func runBuild(context build.Build) (int, error) {
 	context.Logger.FirstLine(context.Logger.PrettyIdentity(context.Buildpack))
 
-	packageManager := npm.NPM{
+	contributor, willContribute, err := modules.NewContributor(context, npm.NPM{
 		Runner: utils.Command{},
 		Logger: context.Logger,
-	}
-
-	contributor, willContribute, err := modules.NewContributor(context, packageManager)
+	})
 	if err != nil {
-		return context.Failure(102), err
+		context.Logger.Info(err.Error())
+		os.Exit(context.Failure(102))
 	}
 
 	if willContribute {
 		if err := contributor.Contribute(); err != nil {
-			return context.Failure(103), err
+			context.Logger.Info(err.Error())
+			os.Exit(context.Failure(103))
 		}
 	}
 
-	return context.Success()
+	code, err := context.Success()
+	if err != nil {
+		context.Logger.Info(err.Error())
+	}
+
+	os.Exit(code)
 }

cmd/build/main_test.go

@@ -3,20 +3,29 @@ package main
 import (
 	"fmt"
 	"os"
+	"path/filepath"
 
 	"github.com/cloudfoundry/libcfbuildpack/detect"
-	"github.com/cloudfoundry/npm-cnb/detector"
+	"github.com/cloudfoundry/npm-cnb/detection"
 )
 
 func main() {
 	context, err := detect.DefaultDetect()
 	if err != nil {
-		_, _ = fmt.Fprintf(os.Stderr, "failed to create default detect context: %s", err)
+		fmt.Fprintf(os.Stderr, "failed to create default detect context: %s", err)
 		os.Exit(100)
 	}
 
-	d := detector.Detector{}
-	code, err := d.RunDetect(context)
+	version, err := detection.GetNodeVersion(filepath.Join(context.Application.Root, "package.json"))
+	if err != nil {
+		if !os.IsNotExist(err) {
+			context.Logger.Info(err.Error())
+		}
+
+		os.Exit(detect.FailStatusCode)
+	}
+
+	code, err := context.Pass(detection.NewPlan(version))
 	if err != nil {
 		context.Logger.Info(err.Error())
 	}

cmd/detect/main.go

@@ -0,0 +1,17 @@
+package detection_test
+
+import (
+	"testing"
+
+	"github.com/sclevine/spec"
+	"github.com/sclevine/spec/report"
+)
+
+func TestUnitDetection(t *testing.T) {
+	suite := spec.New("detection", spec.Report(report.Terminal{}))
+
+	suite("GetNodeVersion", testNodeVersion)
+	suite("Plan", testPlan)
+
+	suite.Run(t)
+}

detection/init_test.go

@@ -0,0 +1,26 @@
+package detection
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+)
+
+func GetNodeVersion(path string) (string, error) {
+	file, err := os.Open(path)
+	if err != nil {
+		return "", err
+	}
+	defer file.Close()
+
+	var pkg struct {
+		Engines struct {
+			Node string `json:"node"`
+		} `json:"engines"`
+	}
+	if err := json.NewDecoder(file).Decode(&pkg); err != nil {
+		return "", fmt.Errorf("unable to parse package.json: %s", err)
+	}
+
+	return pkg.Engines.Node, nil
+}

detection/node_version.go

@@ -0,0 +1,65 @@
+package detection_test
+
+import (
+	"io/ioutil"
+	"os"
+	"testing"
+
+	"github.com/cloudfoundry/npm-cnb/detection"
+	"github.com/sclevine/spec"
+
+	. "github.com/onsi/gomega"
+)
+
+func testNodeVersion(t *testing.T, when spec.G, it spec.S) {
+	when("GetNodeVersion", func() {
+		var path string
+
+		it.Before(func() {
+			RegisterTestingT(t)
+
+			file, err := ioutil.TempFile("", "package.json")
+			Expect(err).NotTo(HaveOccurred())
+			defer file.Close()
+
+			path = file.Name()
+
+			_, err = file.WriteString(`{
+				"engines": {
+					"node": "1.2.3"
+				}
+			}`)
+			Expect(err).NotTo(HaveOccurred())
+		})
+
+		it.After(func() {
+			Expect(os.Remove(path)).To(Succeed())
+		})
+
+		it("parses the node engine version out of a package.json file", func() {
+			version, err := detection.GetNodeVersion(path)
+			Expect(err).NotTo(HaveOccurred())
+			Expect(version).To(Equal("1.2.3"))
+		})
+
+		when("the package.json file does not exist", func() {
+			it("returns an error", func() {
+				_, err := detection.GetNodeVersion("/no/such/path/package.json")
+				Expect(err).To(MatchError(ContainSubstring("no such file or directory")))
+			})
+		})
+
+		when("the package.json is malformed", func() {
+			it.Before(func() {
+				err := ioutil.WriteFile(path, []byte("%%%"), 0644)
+				Expect(err).NotTo(HaveOccurred())
+			})
+
+			it("returns an error", func() {
+				_, err := detection.GetNodeVersion(path)
+				Expect(err).To(MatchError(ContainSubstring("unable to parse package.json")))
+				Expect(err).To(MatchError(ContainSubstring("invalid character '%'")))
+			})
+		})
+	})
+}

detection/node_version_test.go

@@ -0,0 +1,36 @@
+package detection
+
+import (
+	"github.com/buildpack/libbuildpack/buildplan"
+	"github.com/cloudfoundry/npm-cnb/modules"
+)
+
+func NewPlan(version string) buildplan.Plan {
+	var source string
+	if version != "" {
+		source = "package.json"
+	}
+
+	return buildplan.Plan{
+		Provides: []buildplan.Provided{
+			{Name: modules.Dependency},
+		},
+		Requires: []buildplan.Required{
+			{
+				Name:    modules.NodeDependency,
+				Version: version,
+				Metadata: buildplan.Metadata{
+					"build":          true,
+					"launch":         true,
+					"version-source": source,
+				},
+			},
+			{
+				Name: modules.Dependency,
+				Metadata: buildplan.Metadata{
+					"launch": true,
+				},
+			},
+		},
+	}
+}

detection/plan.go

@@ -0,0 +1,73 @@
+package detection_test
+
+import (
+	"testing"
+
+	"github.com/buildpack/libbuildpack/buildplan"
+	"github.com/cloudfoundry/npm-cnb/detection"
+	"github.com/cloudfoundry/npm-cnb/modules"
+	"github.com/sclevine/spec"
+
+	. "github.com/onsi/gomega"
+)
+
+func testPlan(t *testing.T, when spec.G, it spec.S) {
+	when("Plan", func() {
+		it.Before(func() {
+			RegisterTestingT(t)
+		})
+
+		it("returns a plan for the node modules dependency", func() {
+			plan := detection.NewPlan("1.2.3")
+			Expect(plan).To(Equal(buildplan.Plan{
+				Provides: []buildplan.Provided{
+					{Name: modules.Dependency},
+				},
+				Requires: []buildplan.Required{
+					{
+						Name:    modules.NodeDependency,
+						Version: "1.2.3",
+						Metadata: buildplan.Metadata{
+							"build":          true,
+							"launch":         true,
+							"version-source": "package.json",
+						},
+					},
+					{
+						Name: modules.Dependency,
+						Metadata: buildplan.Metadata{
+							"launch": true,
+						},
+					},
+				},
+			}))
+		})
+
+		when("the version number is empty", func() {
+			it("returns a plan with an empty version-source", func() {
+				plan := detection.NewPlan("")
+				Expect(plan).To(Equal(buildplan.Plan{
+					Provides: []buildplan.Provided{
+						{Name: modules.Dependency},
+					},
+					Requires: []buildplan.Required{
+						{
+							Name: modules.NodeDependency,
+							Metadata: buildplan.Metadata{
+								"build":          true,
+								"launch":         true,
+								"version-source": "",
+							},
+						},
+						{
+							Name: modules.Dependency,
+							Metadata: buildplan.Metadata{
+								"launch": true,
+							},
+						},
+					},
+				}))
+			})
+		})
+	})
+}