nits: letter casing and test table names

Signed-off-by: Ibrahim AshShohail <[email protected]>

Author: ibrasho

manifest.go

@@ -67,7 +67,7 @@ func validateManifest(s string) ([]error, error) {
 	// Load the TomlTree from string
 	tree, err := toml.Load(s)
 	if err != nil {
-		return warns, errors.Wrap(err, "Unable to load TomlTree from string")
+		return warns, errors.Wrap(err, "unable to load TomlTree from string")
 	}
 	// Convert tree to a map
 	manifest := tree.ToMap()
@@ -114,7 +114,7 @@ func validateManifest(s string) ([]error, error) {
 								}
 							default:
 								// unknown/invalid key
-								warns = append(warns, fmt.Errorf("Invalid key %q in %q", key, prop))
+								warns = append(warns, fmt.Errorf("invalid key %q in %q", key, prop))
 							}
 						}
 					}
@@ -152,7 +152,7 @@ func validateManifest(s string) ([]error, error) {
 				}
 			}
 		default:
-			warns = append(warns, fmt.Errorf("Unknown field in manifest: %v", prop))
+			warns = append(warns, fmt.Errorf("unknown field in manifest: %v", prop))
 		}
 	}
 
@@ -206,18 +206,18 @@ func readManifest(r io.Reader) (*Manifest, []error, error) {
 	buf := &bytes.Buffer{}
 	_, err := buf.ReadFrom(r)
 	if err != nil {
-		return nil, nil, errors.Wrap(err, "Unable to read byte stream")
+		return nil, nil, errors.Wrap(err, "unable to read byte stream")
 	}
 
 	warns, err := validateManifest(buf.String())
 	if err != nil {
-		return nil, warns, errors.Wrap(err, "Manifest validation failed")
+		return nil, warns, errors.Wrap(err, "manifest validation failed")
 	}
 
 	raw := rawManifest{}
 	err = toml.Unmarshal(buf.Bytes(), &raw)
 	if err != nil {
-		return nil, warns, errors.Wrap(err, "Unable to parse the manifest as TOML")
+		return nil, warns, errors.Wrap(err, "unable to parse the manifest as TOML")
 	}
 
 	m, err := fromRawManifest(raw)

manifest_test.go

@@ -25,7 +25,7 @@ func TestReadManifest(t *testing.T) {
 	defer mf.Close()
 	got, _, err := readManifest(mf)
 	if err != nil {
-		t.Fatalf("Should have read Manifest correctly, but got err %q", err)
+		t.Fatalf("should have read manifest correctly, but got err %q", err)
 	}
 
 	c, _ := gps.NewSemverConstraint("^0.12.0")
@@ -80,7 +80,7 @@ func TestWriteManifest(t *testing.T) {
 
 	got, err := m.MarshalTOML()
 	if err != nil {
-		t.Fatalf("Error while marshaling valid manifest to TOML: %q", err)
+		t.Fatalf("error while marshaling valid manifest to TOML: %q", err)
 	}
 
 	if string(got) != want {
@@ -89,7 +89,7 @@ func TestWriteManifest(t *testing.T) {
 				t.Fatal(err)
 			}
 		} else {
-			t.Errorf("Valid manifest did not marshal to TOML as expected:\n\t(GOT): %s\n\t(WNT): %s", string(got), want)
+			t.Errorf("valid manifest did not marshal to TOML as expected:\n\t(GOT): %s\n\t(WNT): %s", string(got), want)
 		}
 	}
 }
@@ -113,48 +113,54 @@ func TestReadManifestErrors(t *testing.T) {
 		defer mf.Close()
 		_, _, err = readManifest(mf)
 		if err == nil {
-			t.Errorf("Reading manifest with %s should have caused error, but did not", tst.name)
+			t.Errorf("reading manifest with %s should have caused error, but did not", tst.name)
 		} else if !strings.Contains(err.Error(), tst.name) {
-			t.Errorf("Unexpected error %q; expected %s error", err, tst.name)
+			t.Errorf("unexpected error %q; expected %s error", err, tst.name)
 		}
 	}
 }
 
 func TestValidateManifest(t *testing.T) {
 	cases := []struct {
+		name       string
 		tomlString string
 		wantWarn   []error
 		wantError  error
 	}{
 		{
+			name: "valid required",
 			tomlString: `
 			required = ["github.com/foo/bar"]
 			`,
 			wantWarn:  []error{},
 			wantError: nil,
 		},
 		{
+			name: "invalid required",
 			tomlString: `
 			required = "github.com/foo/bar"
 			`,
 			wantWarn:  []error{},
 			wantError: errInvalidRequired,
 		},
 		{
+			name: "empty required",
 			tomlString: `
 			required = []
 			`,
 			wantWarn:  []error{},
 			wantError: nil,
 		},
 		{
+			name: "invalid required list",
 			tomlString: `
 			required = [1, 2, 3]
 			`,
 			wantWarn:  []error{},
 			wantError: errInvalidRequired,
 		},
 		{
+			name: "invalid required format",
 			tomlString: `
 			[[required]]
 			  name = "foo"
@@ -163,34 +169,39 @@ func TestValidateManifest(t *testing.T) {
 			wantError: errInvalidRequired,
 		},
 		{
+			name: "valid ignored",
 			tomlString: `
 			ignored = ["foo"]
 			`,
 			wantWarn:  []error{},
 			wantError: nil,
 		},
 		{
+			name: "invalid ignored",
 			tomlString: `
 			ignored = "foo"
 			`,
 			wantWarn:  []error{},
 			wantError: errInvalidIgnored,
 		},
 		{
+			name: "empty ignored",
 			tomlString: `
 			ignored = []
 			`,
 			wantWarn:  []error{},
 			wantError: nil,
 		},
 		{
+			name: "invalid ignored list",
 			tomlString: `
 			ignored = [1, 2, 3]
 			`,
 			wantWarn:  []error{},
 			wantError: errInvalidIgnored,
 		},
 		{
+			name: "invalid ignored format",
 			tomlString: `
 			[[ignored]]
 			  name = "foo"
@@ -199,6 +210,7 @@ func TestValidateManifest(t *testing.T) {
 			wantError: errInvalidIgnored,
 		},
 		{
+			name: "valid metadata",
 			tomlString: `
 			[metadata]
 			  authors = "foo"
@@ -208,6 +220,7 @@ func TestValidateManifest(t *testing.T) {
 			wantError: nil,
 		},
 		{
+			name: "invalid metadata",
 			tomlString: `
 			foo = "some-value"
 			version = 14
@@ -220,13 +233,14 @@ func TestValidateManifest(t *testing.T) {
 			  version = ""
 			`,
 			wantWarn: []error{
-				errors.New("Unknown field in manifest: foo"),
-				errors.New("Unknown field in manifest: bar"),
-				errors.New("Unknown field in manifest: version"),
+				errors.New("unknown field in manifest: foo"),
+				errors.New("unknown field in manifest: bar"),
+				errors.New("unknown field in manifest: version"),
 			},
 			wantError: nil,
 		},
 		{
+			name: "invalid metadata format",
 			tomlString: `
 			metadata = "project-name"
 
@@ -237,6 +251,7 @@ func TestValidateManifest(t *testing.T) {
 			wantError: nil,
 		},
 		{
+			name: "plain constraint",
 			tomlString: `
 			[[constraint]]
 			  name = "github.com/foo/bar"
@@ -245,27 +260,31 @@ func TestValidateManifest(t *testing.T) {
 			wantError: nil,
 		},
 		{
+			name: "empty constraint",
 			tomlString: `
 			[[constraint]]
 			`,
 			wantWarn:  []error{},
 			wantError: nil,
 		},
 		{
+			name: "invalid constraint",
 			tomlString: `
 			constraint = "foo"
 			`,
 			wantWarn:  []error{},
 			wantError: errInvalidConstraint,
 		},
 		{
+			name: "invalid constraint list",
 			tomlString: `
 			constraint = ["foo", "bar"]
 			`,
 			wantWarn:  []error{},
 			wantError: errInvalidConstraint,
 		},
 		{
+			name: "valid override",
 			tomlString: `
 			[[override]]
 			  name = "github.com/foo/bar"
@@ -274,27 +293,31 @@ func TestValidateManifest(t *testing.T) {
 			wantError: nil,
 		},
 		{
+			name: "empty override",
 			tomlString: `
 			[[override]]
 			`,
 			wantWarn:  []error{},
 			wantError: nil,
 		},
 		{
+			name: "invalid override",
 			tomlString: `
 			override = "bar"
 			`,
 			wantWarn:  []error{},
 			wantError: errInvalidOverride,
 		},
 		{
+			name: "invalid override list",
 			tomlString: `
 			override = ["foo", "bar"]
 			`,
 			wantWarn:  []error{},
 			wantError: errInvalidOverride,
 		},
 		{
+			name: "invalid fields",
 			tomlString: `
 			[[constraint]]
 			  name = "github.com/foo/bar"
@@ -306,14 +329,15 @@ func TestValidateManifest(t *testing.T) {
 			  nick = "foo"
 			`,
 			wantWarn: []error{
-				errors.New("Invalid key \"location\" in \"constraint\""),
-				errors.New("Invalid key \"link\" in \"constraint\""),
-				errors.New("Invalid key \"nick\" in \"override\""),
+				errors.New("invalid key \"location\" in \"constraint\""),
+				errors.New("invalid key \"link\" in \"constraint\""),
+				errors.New("invalid key \"nick\" in \"override\""),
 				errors.New("metadata in \"constraint\" should be a TOML table"),
 			},
 			wantError: nil,
 		},
 		{
+			name: "constraint metadata",
 			tomlString: `
 			[[constraint]]
 			  name = "github.com/foo/bar"
@@ -325,6 +349,7 @@ func TestValidateManifest(t *testing.T) {
 			wantError: nil,
 		},
 		{
+			name: "invalid revision",
 			tomlString: `
 			[[constraint]]
 			  name = "github.com/foo/bar"
@@ -334,6 +359,7 @@ func TestValidateManifest(t *testing.T) {
 			wantError: nil,
 		},
 		{
+			name: "invalid hg revision",
 			tomlString: `
 			[[constraint]]
 			  name = "foobar.com/hg"
@@ -355,24 +381,26 @@ func TestValidateManifest(t *testing.T) {
 	}
 
 	for _, c := range cases {
-		errs, err := validateManifest(c.tomlString)
+		t.Run(c.name, func(t *testing.T) {
+			errs, err := validateManifest(c.tomlString)
 
-		// compare validation errors
-		if err != c.wantError {
-			t.Fatalf("Manifest errors are not as expected: \n\t(GOT) %v \n\t(WNT) %v", err, c.wantError)
-		}
+			// compare validation errors
+			if err != c.wantError {
+				t.Fatalf("manifest errors are not as expected: \n\t(GOT) %v \n\t(WNT) %v", err, c.wantError)
+			}
 
-		// compare length of error slice
-		if len(errs) != len(c.wantWarn) {
-			t.Fatalf("Number of manifest errors are not as expected: \n\t(GOT) %v errors(%v)\n\t(WNT) %v errors(%v).", len(errs), errs, len(c.wantWarn), c.wantWarn)
-		}
+			// compare length of error slice
+			if len(errs) != len(c.wantWarn) {
+				t.Fatalf("number of manifest errors are not as expected: \n\t(GOT) %v errors(%v)\n\t(WNT) %v errors(%v).", len(errs), errs, len(c.wantWarn), c.wantWarn)
+			}
 
-		// check if the expected errors exist in actual errors slice
-		for _, er := range errs {
-			if !contains(c.wantWarn, er) {
-				t.Fatalf("Manifest errors are not as expected: \n\t(MISSING) %v\n\t(FROM) %v", er, c.wantWarn)
+			// check if the expected errors exist in actual errors slice
+			for _, er := range errs {
+				if !contains(c.wantWarn, er) {
+					t.Fatalf("manifest errors are not as expected: \n\t(MISSING) %v\n\t(FROM) %v", er, c.wantWarn)
+				}
 			}
-		}
+		})
 	}
 }
 
@@ -470,13 +498,13 @@ func TestValidateProjectRoots(t *testing.T) {
 			stderrOutput.Reset()
 			err := ValidateProjectRoots(ctx, &c.manifest, sm)
 			if err != c.wantError {
-				t.Fatalf("Unexpected error while validating project roots:\n\t(GOT): %v\n\t(WNT): %v", err, c.wantError)
+				t.Fatalf("unexpected error while validating project roots:\n\t(GOT): %v\n\t(WNT): %v", err, c.wantError)
 			}
 
 			warnings := stderrOutput.String()
 			for _, warn := range c.wantWarn {
 				if !strings.Contains(warnings, warn) {
-					t.Fatalf("Expected ValidateProjectRoot errors to contain: %q", warn)
+					t.Fatalf("expected ValidateProjectRoot errors to contain: %q", warn)
 				}
 			}
 		})