Monorail client in Go

go/src/infra/monorail/validation.go

Index: go/src/infra/monorail/validation.go
diff --git a/go/src/infra/monorail/validation.go b/go/src/infra/monorail/validation.go
new file mode 100644
index 0000000000000000000000000000000000000000..645599f0972b0589eff662b4c41e916f808edebc
--- /dev/null
+++ b/go/src/infra/monorail/validation.go
@@ -0,0 +1,81 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package monorail
+
+import "fmt"
+
+// Validate checks the message for errors.
+func (i *IssueRef) Validate() error {

[seanmccullough1, 2016/06/03 18:45:33]

I see. This could be annoying to do without adding funcs to the generated types.
You'd wouldn't have to write ValidateFoo for every $Foo though.

You could write it as one func Validate(i interface{}) error {...}, switch on
i's type inside it to do each of these validations, and return an error for
unrecognized types.

Or (cutting the Gordian knot here) you could just leave all of this validation
up to the server, which has its own notion of what is valid and what isn't. Just
send whatever the user of the client library has given you, and let the server
report back validation errors.

[nodir, 2016/06/03 18:56:12]

yeah, we use this approach a lot in luci-go.
 
This is not type safe.
I did that and server replied with very weird error messages that used internal
terms.

+	if i == nil {
+		return fmt.Errorf("is nil")
+	}
+	if i.ProjectId == "" {
+		return fmt.Errorf("no projectId")
+	}
+	if i.IssueId == 0 {
+		return fmt.Errorf("no issueId")
+	}
+	return nil
+}
+
+// Validate checks the message for errors.
+func (a *AtomPerson) Validate() error {
+	if a == nil {
+		return fmt.Errorf("is nil")
+	}
+	if a.Name == "" {
+		return fmt.Errorf("no name")
+	}
+	return nil
+}
+
+// Validate checks the message for errors.
+func (i *Issue) Validate() error {
+	if i == nil {
+		return fmt.Errorf("is nil")
+	}
+	if i.Status == "" {
+		return fmt.Errorf("no status")
+	}
+	for _, ref := range i.BlockedOn {
+		if err := ref.Validate(); err != nil {
+			return fmt.Errorf("blockedOn: %s", err)
+		}
+	}
+
+	seen := map[string]struct{}{}
+	for _, cc := range i.Cc {
+		if err := cc.Validate(); err != nil {
+			return fmt.Errorf("cc: %s", err)
+		}
+		// Monorail does not like duplicates in CC list.
+		if _, saw := seen[cc.Name]; saw {
+			return fmt.Errorf("cc: duplicate %s", cc.Name)
+		}
+		seen[cc.Name] = struct{}{}
+	}
+
+	if i.Owner != nil {
+		if err := i.Owner.Validate(); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// Validate checks the message for errors.
+func (i *InsertIssueRequest) Validate() error {
+	if i.ProjectId == "" {
+		return fmt.Errorf("no projectId")
+	}
+	if err := i.Issue.Validate(); err != nil {
+		return fmt.Errorf("issue: %s", err)
+	}
+	if i.Issue.Id != 0 {
+		return fmt.Errorf("issue: must not have id")
+	}
+	return nil
+}