feat: Use dependency constraints specified in configuration (#1987)

The existing configuration found in .sidekick.toml has configuration
like this:

```toml
# Default package dependency versions.
'package:google_cloud_gax' = '^0.1.0'
'package:http'             = '^1.3.0'
```

This PR honors those constraints when generating `pubspec.yaml`

Author: brianquinlan

internal/sidekick/internal/dart/annotate.go

@@ -182,16 +182,19 @@ type annotateModel struct {
 	packagePrefixes map[string]string
 	// A mapping from field IDs to fields for the fields we know to be required.
 	requiredFields map[string]*api.Field
+	// A mapping from a package name (e.g. "http") to its version constraint (e.g. "^1.3.0").
+	dependencyConstraints map[string]string
 }
 
 func newAnnotateModel(model *api.API) *annotateModel {
 	return &annotateModel{
-		model:           model,
-		state:           model.State,
-		imports:         map[string]string{},
-		packageMapping:  map[string]string{},
-		packagePrefixes: map[string]string{},
-		requiredFields:  map[string]*api.Field{},
+		model:                 model,
+		state:                 model.State,
+		imports:               map[string]string{},
+		packageMapping:        map[string]string{},
+		packagePrefixes:       map[string]string{},
+		requiredFields:        map[string]*api.Field{},
+		dependencyConstraints: map[string]string{},
 	}
 }
 
@@ -247,6 +250,14 @@ func (annotate *annotateModel) annotateModel(options map[string]string) error {
 			}
 			protoPackage := keys[1]
 			annotate.packagePrefixes[protoPackage] = definition
+		case strings.HasPrefix(key, "package:"):
+			// Version constraints for a package.
+			//
+			// Expressed as: 'package:<package name>' = '<version constraint>'
+			// For example: 'package:http' = '^1.3.0'
+			//
+			// If the package is needed as a dependency, then this constract is used.
+			annotate.dependencyConstraints[strings.TrimPrefix(key, "package:")] = definition
 		}
 	}
 
@@ -281,7 +292,7 @@ func (annotate *annotateModel) annotateModel(options map[string]string) error {
 	// Add the import for the google_cloud_gax package.
 	annotate.imports["cloud_gax"] = commonImport
 
-	packageDependencies := calculateDependencies(annotate.imports)
+	packageDependencies := calculateDependencies(annotate.imports, annotate.dependencyConstraints)
 
 	ann := &modelAnnotations{
 		Parent:         model,
@@ -336,18 +347,23 @@ func calculateRequiredFields(model *api.API) map[string]*api.Field {
 }
 
 // calculateDependencies calculates package dependencies based on `package:` imports.
-func calculateDependencies(imports map[string]string) []packageDependency {
-	var deps []packageDependency
+func calculateDependencies(imports map[string]string, constraints map[string]string) []packageDependency {
+	deps := []packageDependency{}
 
 	for _, imp := range imports {
-		if strings.HasPrefix(imp, "package:") {
-			name := strings.TrimPrefix(imp, "package:")
+		if name, hadPrefix := strings.CutPrefix(imp, "package:"); hadPrefix {
 			name = strings.Split(name, "/")[0]
 
 			if !slices.ContainsFunc(deps, func(dep packageDependency) bool {
 				return dep.Name == name
 			}) {
-				deps = append(deps, packageDependency{Name: name, Constraint: "any"})
+				constraint := constraints[name]
+				if len(constraint) == 0 {
+					// TODO(https://github.com/googleapis/librarian/issues/1989):
+					// Never emit "any" constraints.
+					constraint = "any"
+				}
+				deps = append(deps, packageDependency{Name: name, Constraint: constraint})
 			}
 		}
 	}

internal/sidekick/internal/dart/annotate_test.go

@@ -43,22 +43,64 @@ func TestAnnotateModel(t *testing.T) {
 
 func TestAnnotateModel_Options(t *testing.T) {
 	model := api.NewTestAPI([]*api.Message{}, []*api.Enum{}, []*api.Service{})
-	annotate := newAnnotateModel(model)
-	err := annotate.annotateModel(map[string]string{
-		"version":   "1.0.0",
-		"part-file": "src/test.p.dart",
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
 
-	codec := model.Codec.(*modelAnnotations)
-
-	if diff := cmp.Diff("1.0.0", codec.PackageVersion); diff != "" {
-		t.Errorf("mismatch in Codec.PackageVersion (-want, +got)\n:%s", diff)
+	var foo = []struct {
+		options map[string]string
+		verify  func(*testing.T, *annotateModel)
+	}{
+		{
+			map[string]string{"package-name-override": "google-cloud-type"},
+			func(t *testing.T, am *annotateModel) {
+				codec := model.Codec.(*modelAnnotations)
+				if diff := cmp.Diff("google-cloud-type", codec.PackageName); diff != "" {
+					t.Errorf("mismatch in Codec.PackageName (-want, +got)\n:%s", diff)
+				}
+			},
+		},
+		{
+			map[string]string{"dev-dependencies": "test,mockito"},
+			func(t *testing.T, am *annotateModel) {
+				codec := model.Codec.(*modelAnnotations)
+				if diff := cmp.Diff([]string{"test", "mockito", "lints"}, codec.DevDependencies); diff != "" {
+					t.Errorf("mismatch in Codec.PackageName (-want, +got)\n:%s", diff)
+				}
+			},
+		},
+		{
+			map[string]string{"version": "1.2.3"},
+			func(t *testing.T, am *annotateModel) {
+				codec := model.Codec.(*modelAnnotations)
+				if diff := cmp.Diff("1.2.3", codec.PackageVersion); diff != "" {
+					t.Errorf("mismatch in Codec.PackageVersion (-want, +got)\n:%s", diff)
+				}
+			},
+		},
+		{
+			map[string]string{"part-file": "src/test.p.dart"},
+			func(t *testing.T, am *annotateModel) {
+				codec := model.Codec.(*modelAnnotations)
+				if diff := cmp.Diff("src/test.p.dart", codec.PartFileReference); diff != "" {
+					t.Errorf("mismatch in Codec.PartFileReference (-want, +got)\n:%s", diff)
+				}
+			},
+		},
+		{
+			map[string]string{"package:http": "1.2.0"},
+			func(t *testing.T, am *annotateModel) {
+				if diff := cmp.Diff(map[string]string{"http": "1.2.0"}, am.dependencyConstraints); diff != "" {
+					t.Errorf("mismatch in annotateModel.dependencyConstraints (-want, +got)\n:%s", diff)
+				}
+			},
+		},
 	}
-	if diff := cmp.Diff("src/test.p.dart", codec.PartFileReference); diff != "" {
-		t.Errorf("mismatch in Codec.PartFileReference (-want, +got)\n:%s", diff)
+
+	for _, tt := range foo {
+		annotate := newAnnotateModel(model)
+		err := annotate.annotateModel(tt.options)
+		if err != nil {
+			t.Fatal(err)
+		}
+		tt.verify(t, annotate)
 	}
 }
 
@@ -111,28 +153,23 @@ func TestCalculateDependencies(t *testing.T) {
 	for _, test := range []struct {
 		name    string
 		imports []string
-		want    []string
+		want    []packageDependency
 	}{
-		{name: "empty", imports: []string{}, want: []string{}},
-		{name: "dart import", imports: []string{typedDataImport}, want: []string{}},
-		{name: "package import", imports: []string{httpImport}, want: []string{"http"}},
-		{name: "dart and package imports", imports: []string{typedDataImport, httpImport}, want: []string{"http"}},
+		{name: "empty", imports: []string{}, want: []packageDependency{}},
+		{name: "dart import", imports: []string{typedDataImport}, want: []packageDependency{}},
+		{name: "package import", imports: []string{httpImport}, want: []packageDependency{{Name: "http", Constraint: "^1.3.0"}}},
+		{name: "dart and package imports", imports: []string{typedDataImport, httpImport}, want: []packageDependency{{Name: "http", Constraint: "^1.3.0"}}},
 		{name: "package imports", imports: []string{
 			httpImport,
 			"package:google_cloud_foo/foo.dart",
-		}, want: []string{"google_cloud_foo", "http"}},
+		}, want: []packageDependency{{Name: "google_cloud_foo", Constraint: "any"}, {Name: "http", Constraint: "^1.3.0"}}},
 	} {
 		t.Run(test.name, func(t *testing.T) {
 			deps := map[string]string{}
 			for _, imp := range test.imports {
 				deps[imp] = imp
 			}
-			gotFull := calculateDependencies(deps)
-
-			got := []string{}
-			for _, dep := range gotFull {
-				got = append(got, dep.Name)
-			}
+			got := calculateDependencies(deps, map[string]string{"http": "^1.3.0"})
 
 			if diff := cmp.Diff(test.want, got); diff != "" {
 				t.Errorf("mismatch in calculateDependencies (-want, +got)\n:%s", diff)