Added support for new grouped dependencies (#54)

Co-authored-by: Bob Evans <robert.evans25@gmail.com>

Author: jsumners-nr

parse-package.go

@@ -4,6 +4,7 @@ import (
 	"errors"
 	"fmt"
 	"regexp"
+	"slices"
 	"strings"
 
 	"blitznote.com/src/semver/v3"
@@ -84,35 +85,68 @@ func findMinimumSupported(target Target, tests []TestDescription) (*semver.Range
 			continue
 		}
 
-		// We need to find the minimum version of the target module by looking
-		// through the dependencies list and the inspecting the semver range
-		// strings associated with it.
-		for key, val := range test.Dependencies {
-			if key != target.Name {
+		if test.Dependencies != nil {
+			// We need to find the minimum version of the target module by looking
+			// through the dependencies list and the inspecting the semver range
+			// strings associated with it.
+			for key, val := range test.Dependencies {
+				if key != target.Name {
+					continue
+				}
+
+				var currentVersion semver.Range
+
+				// The semver library does not parse strings like `>1.0.0 <2.0.0 || >3.0.0`.
+				// So we need to split it up and normalize the pieces into range strings
+				// it can understand.
+				rangeStrings := strings.Split(val.Versions, "||")
+				for k, v := range rangeStrings {
+					// Oh, Go, why no slices.Map?
+					rangeStrings[k] = normalizeRangeString(v)
+				}
+
+				currentVersion, err := processRangeStrings(rangeStrings)
+				if err != nil {
+					return nil, fmt.Errorf("`%s` => `%s`: %w", target, val.Versions, err)
+				}
+
+				if lastVersion == nil {
+					lastVersion = &currentVersion
+					continue
+				}
+
+				if isRangeLower(currentVersion, *lastVersion) == true {
+					lastVersion = &currentVersion
+				}
+			}
+		} else if test.GroupedDependencies != nil {
+			// As above, but for a `groupedDependencies` block instead. We should
+			// always have one or the other.
+			if slices.Contains(test.GroupedDependencies.Packages, target.Name) == false {
+				// We are trying to find the minimum version across all defined "test"
+				// blocks for the given `target`. So we cannot return an error here
+				// if the `target` is not found in the grouped packages list.
 				continue
 			}
 
 			var currentVersion semver.Range
-
-			// The semver library does not parse strings like `>1.0.0 <2.0.0 || >3.0.0`.
-			// So we need to split it up and normalize the pieces into range strings
-			// it can understand.
-			rangeStrings := strings.Split(val.Versions, "||")
+			rangeStrings := strings.Split(test.GroupedDependencies.Version, "||")
 			for k, v := range rangeStrings {
-				// Oh, Go, why no slices.Map?
 				rangeStrings[k] = normalizeRangeString(v)
 			}
-
 			currentVersion, err := processRangeStrings(rangeStrings)
 			if err != nil {
-				return nil, fmt.Errorf("`%s` => `%s`: %w", target, val.Versions, err)
+				return nil, fmt.Errorf(
+					"`%s` => `%s`: %w",
+					target,
+					test.GroupedDependencies.Version,
+					err,
+				)
 			}
-
 			if lastVersion == nil {
 				lastVersion = &currentVersion
 				continue
 			}
-
 			if isRangeLower(currentVersion, *lastVersion) == true {
 				lastVersion = &currentVersion
 			}

parse-package_test.go

@@ -1,12 +1,13 @@
 package main
 
 import (
-	"blitznote.com/src/semver/v3"
 	"encoding/json"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 	"os"
 	"testing"
+
+	"blitznote.com/src/semver/v3"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func testPkg(t *testing.T, jsonFile string, expected []PkgInfo) {
@@ -123,6 +124,21 @@ func Test_ParsePackage(t *testing.T) {
 			MinAgentVersion: "1.0.0",
 		}})
 	})
+
+	t.Run("handles both dependencies and groupedDependencies", func(t *testing.T) {
+		testPkg(t, "testdata/grouped-dependencies.json", []PkgInfo{
+			{
+				Name:            "foo",
+				MinVersion:      "4.0.0",
+				MinAgentVersion: "1.0.0",
+			},
+			{
+				Name:            "baz",
+				MinVersion:      "5.0.0",
+				MinAgentVersion: "1.0.0",
+			},
+		})
+	})
 }
 
 func Test_processRangeStrings(t *testing.T) {

testdata/grouped-dependencies.json

@@ -0,0 +1,29 @@
+{
+  "name": "baseline-test",
+  "comment": "Verifies that our tool can find targets in both `dependencies` and `groupedDependencies`.",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "targets": [
+    {"name":  "foo", "minAgentVersion": "1.0.0"},
+    {"name":  "baz", "minAgentVersion":  "1.0.0"}
+  ],
+  "tests": [
+    {
+      "dependencies": {
+        "foo": {
+          "versions": ">=4.0.0",
+          "samples": "2"
+        }
+      },
+      "files": ["test1.js"]
+    },
+    {
+      "groupedDependencies": {
+          "version": ">=5.0.0",
+          "packages": ["bar", "baz"]
+      },
+      "files": ["test2.js"]
+    }
+  ]
+}

types.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"encoding/json"
 	"fmt"
+
 	"github.com/spf13/cast"
 )
 
@@ -72,11 +73,12 @@ type VersionedTestPackageJson struct {
 }
 
 type TestDescription struct {
-	Supported    bool              `json:"supported"`
-	Comment      string            `json:"comment"`
-	Engines      EnginesBlock      `json:"engines"`
-	Dependencies DependenciesBlock `json:"dependencies"`
-	Files        FilesBlock        `json:"files"`
+	Supported           bool                    `json:"supported"`
+	Comment             string                  `json:"comment"`
+	Engines             EnginesBlock            `json:"engines"`
+	Dependencies        DependenciesBlock       `json:"dependencies"`
+	GroupedDependencies *GroupedDependencyBlock `json:"groupedDependencies"`
+	Files               FilesBlock              `json:"files"`
 }
 
 func (td *TestDescription) UnmarshalJSON(data []byte) error {
@@ -124,6 +126,13 @@ func (td *TestDescription) UnmarshalJSON(data []byte) error {
 				return err
 			}
 			td.Dependencies = deps
+		case "groupedDependencies":
+			var deps GroupedDependencyBlock
+			err := json.Unmarshal(*val, &deps)
+			if err != nil {
+				return err
+			}
+			td.GroupedDependencies = &deps
 		case "files":
 			var files FilesBlock
 			err := json.Unmarshal(*val, &files)
@@ -150,6 +159,11 @@ type DependencyBlock struct {
 	Samples  int    `json:"samples"`
 }
 
+type GroupedDependencyBlock struct {
+	Version  string   `json:"version"`
+	Packages []string `json:"packages"`
+}
+
 func (db *DependenciesBlock) UnmarshalJSON(data []byte) error {
 	if bytes.Compare(data, []byte("null")) == 0 {
 		return nil
@@ -210,3 +224,30 @@ func (db *DependencyBlock) UnmarshalJSON(data []byte) error {
 
 	return nil
 }
+
+func (gd *GroupedDependencyBlock) UnmarshalJSON(data []byte) error {
+	if bytes.Compare(data, []byte("null")) == 0 {
+		return nil
+	}
+
+	var decoded map[string]*json.RawMessage
+	_ = json.Unmarshal(data, &decoded)
+
+	version := decoded["version"]
+	if version == nil {
+		return fmt.Errorf("missing version property: %s", data)
+	}
+	strVersion := string(*version)
+	gd.Version = strVersion[1 : len(strVersion)-1]
+
+	var packages []string
+	err := json.Unmarshal(*decoded["packages"], &packages)
+	if err != nil {
+		return fmt.Errorf("failed to decode packages property: %w", err)
+	} else if packages == nil {
+		return fmt.Errorf("missing packages property: %w", err)
+	}
+	gd.Packages = packages
+
+	return nil
+}