Bump google.golang.org/api

vendor/github.com/google/martian/parse/parse.go

@@ -0,0 +1,147 @@
+// Copyright 2015 Google Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package parse constructs martian modifiers from JSON messages.
+package parse
+
+import (
+	"encoding/json"
+	"fmt"
+	"sync"
+
+	"github.com/google/martian"
+)
+
+// ModifierType is the HTTP message type.
+type ModifierType string
+
+const (
+	// Request modifies an HTTP request.
+	Request ModifierType = "request"
+	// Response modifies an HTTP response.
+	Response ModifierType = "response"
+)
+
+// Result holds the parsed modifier and its type.
+type Result struct {
+	reqmod martian.RequestModifier
+	resmod martian.ResponseModifier
+}
+
+// NewResult returns a new parse.Result for a given interface{} that implements a modifier
+// and a slice of scopes to generate the result for.
+//
+// Returns nil, error if a given modifier does not support a given scope
+func NewResult(mod interface{}, scope []ModifierType) (*Result, error) {
+	reqmod, reqOk := mod.(martian.RequestModifier)
+	resmod, resOk := mod.(martian.ResponseModifier)
+	result := &Result{}
+	if scope == nil {
+		result.reqmod = reqmod
+		result.resmod = resmod
+		return result, nil
+	}
+
+	for _, s := range scope {
+		switch s {
+		case Request:
+			if !reqOk {
+				return nil, fmt.Errorf("parse: invalid scope %q for modifier", "request")
+			}
+
+			result.reqmod = reqmod
+		case Response:
+			if !resOk {
+				return nil, fmt.Errorf("parse: invalid scope %q for modifier", "response")
+			}
+
+			result.resmod = resmod
+		default:
+			return nil, fmt.Errorf("parse: invalid scope: %s not in [%q, %q]", s, "request", "response")
+		}
+	}
+
+	return result, nil
+}
+
+// RequestModifier returns the parsed RequestModifier.
+//
+// Returns nil if the message has no request modifier.
+func (r *Result) RequestModifier() martian.RequestModifier {
+	return r.reqmod
+}
+
+// ResponseModifier returns the parsed ResponseModifier.
+//
+// Returns nil if the message has no response modifier.
+func (r *Result) ResponseModifier() martian.ResponseModifier {
+	return r.resmod
+}
+
+var (
+	parseMu    sync.RWMutex
+	parseFuncs = make(map[string]func(b []byte) (*Result, error))
+)
+
+// ErrUnknownModifier is the error returned when the message does not
+// contain a field representing a known modifier type.
+type ErrUnknownModifier struct {
+	name string
+}
+
+// Error returns a formatted error message for an ErrUnknownModifier.
+func (e ErrUnknownModifier) Error() string {
+	return fmt.Sprintf("parse: unknown modifier: %s", e.name)
+}
+
+// Register registers a parsing function for name that will be used to unmarshal
+// a JSON message into the appropriate modifier.
+func Register(name string, parseFunc func(b []byte) (*Result, error)) {
+	parseMu.Lock()
+	defer parseMu.Unlock()
+
+	parseFuncs[name] = parseFunc
+}
+
+// FromJSON parses a Modifier JSON message by looking up the named modifier in parseFuncs
+// and passing its modifier to the registered parseFunc. Returns a parse.Result containing
+// the top-level parsed modifier. If no parser has been registered with the given name
+// it returns an error of type ErrUnknownModifier.
+func FromJSON(b []byte) (*Result, error) {
+	msg := make(map[string]json.RawMessage)
+	if err := json.Unmarshal(b, &msg); err != nil {
+		return nil, err
+	}
+
+	if len(msg) != 1 {
+		ks := ""
+		for k := range msg {
+			ks += ", " + k
+		}
+
+		return nil, fmt.Errorf("parse: expected one modifier, received %d: %s", len(msg), ks)
+	}
+
+	parseMu.RLock()
+	defer parseMu.RUnlock()
+	for k, m := range msg {
+		parseFunc, ok := parseFuncs[k]
+		if !ok {
+			return nil, ErrUnknownModifier{name: k}
+		}
+		return parseFunc(m)
+	}
+
+	return nil, fmt.Errorf("parse: no modifiers found: %v", msg)
+}

vendor/github.com/google/martian/parse/parse_test.go

@@ -0,0 +1,176 @@
+// Copyright 2015 Google Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package parse
+
+import (
+	"encoding/json"
+	"net/http"
+	"testing"
+
+	"github.com/google/martian"
+	"github.com/google/martian/martiantest"
+)
+
+func TestFromJSON(t *testing.T) {
+	msg := []byte(`{
+		"first.Modifier": { },
+		"second.Modifier": { }
+	}`)
+
+	if _, err := FromJSON(msg); err == nil {
+		t.Error("FromJson(): got nil, want more than one key error")
+	}
+
+	Register("martiantest.Modifier", func(b []byte) (*Result, error) {
+		type testJSON struct {
+			Scope []ModifierType `json:"scope"`
+		}
+
+		msg := &testJSON{}
+		if err := json.Unmarshal(b, msg); err != nil {
+			return nil, err
+		}
+
+		tm := martiantest.NewModifier()
+		return NewResult(tm, msg.Scope)
+	})
+
+	msg = []byte(`{
+		"martiantest.Modifier": { }
+	}`)
+
+	r, err := FromJSON(msg)
+	if err != nil {
+		t.Fatalf("FromJSON(): got %v, want no error", err)
+	}
+
+	if _, ok := r.RequestModifier().(*martiantest.Modifier); !ok {
+		t.Fatal("r.RequestModifier().(*martiantest.Modifier): got !ok, want ok")
+	}
+
+	if _, ok := r.ResponseModifier().(*martiantest.Modifier); !ok {
+		t.Fatal("r.ResponseModifier().(*martiantest.Modifier): got !ok, want ok")
+	}
+
+	msg = []byte(`{
+	  "martiantest.Modifier": {
+      "scope": ["request"]
+    }
+	}`)
+
+	r, err = FromJSON(msg)
+	if err != nil {
+		t.Fatalf("FromJSON(): got %v, want no error", err)
+	}
+
+	if _, ok := r.RequestModifier().(*martiantest.Modifier); !ok {
+		t.Fatal("r.RequestModifier().(*martiantest.Modifier): got !ok, want ok")
+	}
+
+	resmod := r.ResponseModifier()
+	if resmod != nil {
+		t.Error("r.ResponseModifier(): got not nil, want nil")
+	}
+
+	msg = []byte(`{
+	  "martiantest.Modifier": {
+      "scope": ["response"]
+    }
+	}`)
+
+	r, err = FromJSON(msg)
+	if err != nil {
+		t.Fatalf("FromJSON(): got %v, want no error", err)
+	}
+
+	if _, ok := r.ResponseModifier().(*martiantest.Modifier); !ok {
+		t.Fatal("r.ResponseModifier().(*martiantest.Modifier): got !ok, want ok")
+	}
+
+	reqmod := r.RequestModifier()
+	if reqmod != nil {
+		t.Error("r.RequestModifier(): got not nil, want nil")
+	}
+}
+
+func TestNewResultMismatchedScopes(t *testing.T) {
+	reqmod := martian.RequestModifierFunc(
+		func(*http.Request) error {
+			return nil
+		})
+	resmod := martian.ResponseModifierFunc(
+		func(*http.Response) error {
+			return nil
+		})
+
+	if _, err := NewResult(reqmod, []ModifierType{Response}); err == nil {
+		t.Error("NewResult(reqmod, RESPONSE): got nil, want error")
+	}
+
+	if _, err := NewResult(resmod, []ModifierType{Request}); err == nil {
+		t.Error("NewResult(resmod, REQUEST): got nil, want error")
+	}
+
+	if _, err := NewResult(reqmod, []ModifierType{ModifierType("unknown")}); err == nil {
+		t.Error("NewResult(resmod, REQUEST): got nil, want error")
+	}
+}
+
+func TestResultModifierAccessors(t *testing.T) {
+	tm := martiantest.NewModifier()
+
+	r := &Result{
+		reqmod: tm,
+		resmod: nil,
+	}
+	if reqmod := r.RequestModifier(); reqmod == nil {
+		t.Error("r.RequestModifier: got nil, want reqmod")
+	}
+
+	if resmod := r.ResponseModifier(); resmod != nil {
+		t.Error("r.ResponseModifier: got resmod, want nil")
+	}
+
+	r = &Result{
+		reqmod: nil,
+		resmod: tm,
+	}
+	if reqmod := r.RequestModifier(); reqmod != nil {
+		t.Errorf("r.RequestModifier: got reqmod, want nil")
+	}
+
+	if resmod := r.ResponseModifier(); resmod == nil {
+		t.Error("r.ResponseModifier: got nil, want resmod")
+	}
+}
+
+func TestParseUnknownModifierReturnsError(t *testing.T) {
+	msg := []byte(`{
+	  "unknown.Key": {
+      "scope": ["request", "response"]
+		}
+	}`)
+
+	_, err := FromJSON(msg)
+
+	umerr, ok := err.(ErrUnknownModifier)
+	if !ok {
+		t.Fatalf("FromJSON(): got %v, want ErrUnknownModifier", err)
+	}
+
+	if got, want := umerr.Error(), "parse: unknown modifier: unknown.Key"; got != want {
+		t.Errorf("Error(): got %q, want %q", got, want)
+	}
+}