test(storage): init retry conformance test scaffolding

storage/conformance_test.go

@@ -16,21 +16,337 @@ package storage
 
 import (
 	"bytes"
+	"context"
 	"encoding/base64"
 	"encoding/json"
 	"fmt"
 	"io/ioutil"
+	"net/http"
+	"net/http/httputil"
 	"net/url"
+	"os"
 	"strconv"
 	"strings"
 	"testing"
 	"time"
 
+	"cloud.google.com/go/internal/uid"
 	storage_v1_tests "cloud.google.com/go/storage/internal/test/conformance"
 	"github.com/golang/protobuf/jsonpb"
 	"github.com/google/go-cmp/cmp"
+	"google.golang.org/api/option"
+	raw "google.golang.org/api/storage/v1"
+	htransport "google.golang.org/api/transport/http"
 )
 
+var (
+	bucketIDs           = uid.NewSpace("bucket", nil)
+	objectIDs           = uid.NewSpace("object", nil)
+	notificationIDs     = uid.NewSpace("notification", nil)
+	projectID           = "my-project-id"
+	serviceAccountEmail = "my-sevice-account@my-project-id.iam.gserviceaccount.com"
+)
+
+// Holds the resources for a particular test case. Only the necessary fields will
+// be populated; others will be nil.
+type resources struct {
+	bucket       *BucketAttrs
+	object       *ObjectAttrs
+	notification *Notification
+	hmacKey      *HMACKey
+}
+
+func (fs *resources) populate(ctx context.Context, c *Client, resource storage_v1_tests.Resource) error {
+	switch resource {
+	case storage_v1_tests.Resource_BUCKET:
+		bkt := c.Bucket(bucketIDs.New())
+		if err := bkt.Create(ctx, projectID, &BucketAttrs{}); err != nil {
+			return fmt.Errorf("creating bucket: %v", err)
+		}
+		attrs, err := bkt.Attrs(ctx)
+		if err != nil {
+			return fmt.Errorf("getting bucket attrs: %v", err)
+		}
+		fs.bucket = attrs
+	case storage_v1_tests.Resource_OBJECT:
+		// Assumes bucket has been populated first.
+		obj := c.Bucket(fs.bucket.Name).Object(objectIDs.New())
+		w := obj.NewWriter(ctx)
+		if _, err := w.Write([]byte("abcdef")); err != nil {
+			return fmt.Errorf("writing object: %v", err)
+		}
+		if err := w.Close(); err != nil {
+			return fmt.Errorf("closing object: %v", err)
+		}
+		attrs, err := obj.Attrs(ctx)
+		if err != nil {
+			return fmt.Errorf("getting object attrs: %v", err)
+		}
+		fs.object = attrs
+	case storage_v1_tests.Resource_NOTIFICATION:
+		// Assumes bucket has been populated first.
+		n, err := c.Bucket(fs.bucket.Name).AddNotification(ctx, &Notification{
+			TopicProjectID: projectID,
+			TopicID:        notificationIDs.New(),
+			PayloadFormat:  JSONPayload,
+		})
+		if err != nil {
+			return fmt.Errorf("adding notification: %v", err)
+		}
+		fs.notification = n
+	case storage_v1_tests.Resource_HMAC_KEY:
+		key, err := c.CreateHMACKey(ctx, projectID, serviceAccountEmail)
+		if err != nil {
+			return fmt.Errorf("creating HMAC key: %v", err)
+		}
+		fs.hmacKey = key
+	}
+	return nil
+}
+
+type retryFunc func(ctx context.Context, c *Client, fs *resources, preconditions bool) error
+
+// Methods to retry. This is a map whose keys are a string describing a standard
+// API call (e.g. storage.objects.get) and values are a list of functions which
+// wrap library methods that implement these calls. There may be multiple values
+// because multiple library methods may use the same call (e.g. get could be a
+// read or just a metadata get).
+var methods = map[string][]retryFunc{
+	"storage.buckets.get": {
+		func(ctx context.Context, c *Client, fs *resources, _ bool) error {
+			_, err := c.Bucket(fs.bucket.Name).Attrs(ctx)
+			return err
+		},
+	},
+}
+
+func TestRetryConformance(t *testing.T) {
+	host := os.Getenv("STORAGE_EMULATOR_HOST")
+	if host == "" {
+		t.Skip("This test must use the testbench emulator; set STORAGE_EMULATOR_HOST to run.")
+	}
+
+	ctx := context.Background()
+
+	// Create non-wrapped client to use for setup steps.
+	client, err := NewClient(ctx)
+	if err != nil {
+		t.Fatalf("storage.NewClient: %v", err)
+	}
+
+	_, _, testFiles := parseFiles(t)
+
+	for _, testFile := range testFiles {
+		for _, retryTest := range testFile.RetryTests {
+			for _, instructions := range retryTest.Cases {
+				for _, method := range retryTest.Methods {
+					if len(methods[method.Name]) == 0 {
+						t.Logf("No tests for operation %v", method.Name)
+					}
+					for i, fn := range methods[method.Name] {
+						testName := fmt.Sprintf("%v-%v-%v-%v", retryTest.Id, instructions.Instructions, method.Name, i)
+						t.Run(testName, func(t *testing.T) {
+
+							// Create the retry subtest
+							subtest := &retrySubtest{T: t, name: testName}
+							err := subtest.create(host, map[string][]string{
+								method.Name: instructions.Instructions,
+							})
+							if err != nil {
+								t.Fatalf("setting up retry test: %v", err)
+							}
+
+							// Create necessary test resources in the emulator
+							fs := &resources{}
+							for _, resource := range method.Resources {
+								if err := fs.populate(ctx, client, resource); err != nil {
+									t.Fatalf("creating test resources: %v", err)
+								}
+							}
+
+							// Test
+							err = fn(ctx, subtest.wrappedClient, fs, retryTest.PreconditionProvided)
+							if retryTest.ExpectSuccess && err != nil {
+								t.Errorf("want success, got %v", err)
+							}
+							if !retryTest.ExpectSuccess && err == nil {
+								t.Errorf("want failure, got success")
+							}
+
+							// Verify that all instructions were used up during the test
+							// (indicates that the client sent the correct requests).
+							if err := subtest.check(); err != nil {
+								t.Errorf("checking instructions: %v", err)
+							}
+
+							// Close out test in emulator.
+							if err := subtest.delete(); err != nil {
+								t.Errorf("deleting retry test: %v", err)
+							}
+						})
+					}
+
+				}
+			}
+		}
+	}
+
+}
+
+type retrySubtest struct {
+	*testing.T
+	name          string
+	id            string   // ID to pass as a header in the test execution
+	host          *url.URL // set the path when using; path is not guaranteed betwen calls
+	wrappedClient *Client
+}
+
+// Create a retry test resource in the emulator
+func (rt *retrySubtest) create(host string, instructions map[string][]string) error {
+	endpoint, err := parseURL(host)
+	if err != nil {
+		return err
+	}
+	rt.host = endpoint
+
+	c := http.DefaultClient
+	data := struct {
+		Instructions map[string][]string `json:"instructions"`
+	}{
+		Instructions: instructions,
+	}
+
+	buf := new(bytes.Buffer)
+	if err := json.NewEncoder(buf).Encode(data); err != nil {
+		return fmt.Errorf("encoding request: %v", err)
+	}
+
+	rt.host.Path = "retry_test"
+	resp, err := c.Post(rt.host.String(), "application/json", buf)
+	if err != nil || resp.StatusCode != 200 {
+		return fmt.Errorf("creating retry test: err: %v, resp: %+v", err, resp)
+	}
+	defer func() {
+		closeErr := resp.Body.Close()
+		if err == nil {
+			err = closeErr
+		}
+	}()
+	testRes := struct {
+		TestID string `json:"id"`
+	}{}
+	if err := json.NewDecoder(resp.Body).Decode(&testRes); err != nil {
+		return fmt.Errorf("decoding test ID: %v", err)
+	}
+
+	rt.id = testRes.TestID
+
+	// Create wrapped client which will send emulator instructions
+	rt.host.Path = ""
+	client, err := wrappedClient(rt.T, rt.host.String(), rt.id)
+	if err != nil {
+		return fmt.Errorf("creating wrapped client: %v", err)
+	}
+	rt.wrappedClient = client
+
+	return nil
+}
+
+// Verify that all instructions for a given retry testID have been used up.
+func (rt *retrySubtest) check() error {
+	rt.host.Path = strings.Join([]string{"retry_test", rt.id}, "/")
+	c := http.DefaultClient
+	resp, err := c.Get(rt.host.String())
+	if err != nil || resp.StatusCode != 200 {
+		return fmt.Errorf("getting retry test: err: %v, resp: %+v", err, resp)
+	}
+	defer func() {
+		closeErr := resp.Body.Close()
+		if err == nil {
+			err = closeErr
+		}
+	}()
+	testRes := struct {
+		Instructions map[string][]string
+		Completed    bool
+	}{}
+	if err := json.NewDecoder(resp.Body).Decode(&testRes); err != nil {
+		return fmt.Errorf("decoding response: %v", err)
+	}
+	if !testRes.Completed {
+		return fmt.Errorf("test not completed; unused instructions: %+v", testRes.Instructions)
+	}
+	return nil
+}
+
+// Delete a retry test resource.
+func (rt *retrySubtest) delete() error {
+	rt.host.Path = strings.Join([]string{"retry_test", rt.id}, "/")
+	c := http.DefaultClient
+	req, err := http.NewRequest("DELETE", rt.host.String(), nil)
+	if err != nil {
+		return fmt.Errorf("creating request: %v", err)
+	}
+	resp, err := c.Do(req)
+	if err != nil || resp.StatusCode != 200 {
+		return fmt.Errorf("deleting test: err: %v, resp: %+v", err, resp)
+	}
+	return nil
+}
+
+type testRoundTripper struct {
+	*testing.T
+	rt     http.RoundTripper
+	testID string
+}
+
+func (wt *testRoundTripper) RoundTrip(r *http.Request) (*http.Response, error) {
+	r.Header.Set("x-retry-test-id", wt.testID)
+
+	requestDump, err := httputil.DumpRequest(r, false)
+	if err != nil {
+		wt.Logf("error creating request dump: %v", err)
+	}
+
+	resp, err := wt.rt.RoundTrip(r)
+	if err != nil {
+		wt.Logf("roundtrip error (may be expected): %v\nrequest: %s", err, requestDump)
+	}
+	return resp, err
+}
+
+// Create custom client that sends instruction
+func wrappedClient(t *testing.T, host, testID string) (*Client, error) {
+	ctx := context.Background()
+	base := http.DefaultTransport
+	trans, err := htransport.NewTransport(ctx, base, option.WithScopes(raw.DevstorageFullControlScope),
+		option.WithUserAgent("custom-user-agent"))
+	if err != nil {
+		return nil, fmt.Errorf("failed to create http client: %v", err)
+	}
+	c := http.Client{Transport: trans}
+
+	// Add RoundTripper to the created HTTP client
+	wrappedTrans := &testRoundTripper{rt: c.Transport, testID: testID, T: t}
+	c.Transport = wrappedTrans
+
+	// Supply this client to storage.NewClient
+	client, err := NewClient(ctx, option.WithHTTPClient(&c), option.WithEndpoint(host+"/storage/v1/"))
+	return client, err
+}
+
+// A url is only parsed correctly by the url package if it has a scheme,
+// so we have to check and build it ourselves if not supplied in host
+// Assumes http if not provided
+func parseURL(host string) (*url.URL, error) {
+	if strings.Contains(host, "://") {
+		return url.Parse(host)
+	} else {
+		url := &url.URL{Scheme: "http", Host: host}
+		return url, nil
+	}
+}
+
 func TestPostPolicyV4Conformance(t *testing.T) {
 	oldUTCNow := utcNow
 	defer func() {

storage/internal/test/conformance/retry_tests.json

@@ -0,0 +1,45 @@
+{
+  "retryTests": [
+    {
+      "id": 1,
+      "description": "always_idempotent",
+      "cases": [
+        {
+          "instructions": ["return-503", "return-503"]
+        },
+        {
+          "instructions": ["return-reset-connection", "return-reset-connection"]
+        },
+        {
+          "instructions": ["return-reset-connection", "return-503"]
+        }
+      ],
+      "methods": [
+        {"name": "storage.bucket_acl.get",                "resources": ["BUCKET"]},
+        {"name": "storage.bucket_acl.list",               "resources": ["BUCKET"]},
+        {"name": "storage.buckets.delete",                "resources": ["BUCKET"]},
+        {"name": "storage.buckets.get",                   "resources": ["BUCKET"]},
+        {"name": "storage.buckets.getIamPolicy",          "resources": ["BUCKET"]},
+        {"name": "storage.buckets.insert",                "resources": []},
+        {"name": "storage.buckets.list",                  "resources": ["BUCKET"]},
+        {"name": "storage.buckets.lockRetentionPolicy",   "resources": ["BUCKET"]},
+        {"name": "storage.buckets.testIamPermissions",     "resources": ["BUCKET"]},
+        {"name": "storage.default_object_acl.get",        "resources": ["BUCKET"]},
+        {"name": "storage.default_object_acl.list",       "resources": ["BUCKET"]},
+        {"name": "storage.hmacKey.delete",                "resources": ["HMAC_KEY"]},
+        {"name": "storage.hmacKey.get",                   "resources": ["HMAC_KEY"]},
+        {"name": "storage.hmacKey.list",                  "resources": []},
+        {"name": "storage.notifications.delete",           "resources": ["BUCKET", "NOTIFICATION"]},
+        {"name": "storage.notifications.get",              "resources": ["BUCKET", "NOTIFICATION"]},
+        {"name": "storage.notifications.list",             "resources": ["BUCKET", "NOTIFICATION"]},
+        {"name": "storage.object_acl.get",                "resources": ["BUCKET", "OBJECT"]},
+        {"name": "storage.object_acl.list",               "resources": ["BUCKET", "OBJECT"]},
+        {"name": "storage.objects.get",                   "resources": ["BUCKET", "OBJECT"]},
+        {"name": "storage.objects.list",                  "resources": ["BUCKET", "OBJECT"]},
+        {"name": "storage.serviceaccount.get",            "resources": []}
+      ],
+      "preconditionProvided": false,
+      "expectSuccess": true
+    }
+  ]
+}