Add timestamp support for SDK's generated API smoke tests (#477)

Author: jasdel

models/apis/marketplacecommerceanalytics/2015-07-01/smoke.json

@@ -0,0 +1,17 @@
+{
+    "version": 1,
+    "defaultRegion": "us-east-1",
+    "testCases": [
+        {
+            "operationName": "GenerateDataSet",
+            "input": {
+                "dataSetType": "fake-type",
+                "dataSetPublicationDate": 0,
+                "roleNameArn": "fake-arn",
+                "destinationS3BucketName": "fake-bucket",
+                "snsTopicArn": "fake-arn"
+            },
+            "errorExpectedFromService": true
+        }
+    ]
+}

private/model/api/api.go

@@ -27,6 +27,8 @@ type API struct {
 	Examples      Examples
 	SmokeTests    SmokeTestSuite
 
+	KeepUnsupportedAPIs bool
+
 	// Set to true to avoid removing unused shapes
 	NoRemoveUnusedShapes bool
 

private/model/api/docstring.go

@@ -28,30 +28,29 @@ type shapeDocumentation struct {
 }
 
 // AttachDocs attaches documentation from a JSON filename.
-func (a *API) AttachDocs(filename string) {
+func (a *API) AttachDocs(filename string) error {
 	var d apiDocumentation
 
 	f, err := os.Open(filename)
 	defer f.Close()
 	if err != nil {
-		panic(err)
+		return err
 	}
 	err = json.NewDecoder(f).Decode(&d)
 	if err != nil {
-		panic(err)
+		return fmt.Errorf("failed to decode %s, err: %v", filename, err)
 	}
 
-	d.setup(a)
+	return d.setup(a)
 }
 
-func (d *apiDocumentation) setup(a *API) {
+func (d *apiDocumentation) setup(a *API) error {
 	a.Documentation = docstring(d.Service)
 
 	for opName, doc := range d.Operations {
 		if _, ok := a.Operations[opName]; !ok {
-			panic(fmt.Sprintf("%s, doc op %q not found in API op set",
-				a.ServiceID(), opName),
-			)
+			return fmt.Errorf("%s, doc op %q not found in API op set",
+				a.ServiceID(), opName)
 		}
 		a.Operations[opName].Documentation = docstring(doc)
 	}
@@ -80,6 +79,8 @@ func (d *apiDocumentation) setup(a *API) {
 			}
 		}
 	}
+
+	return nil
 }
 
 var reNewline = regexp.MustCompile(`\r?\n`)

private/model/api/eventstream.go

@@ -2,27 +2,43 @@
 
 package api
 
-func (a *API) suppressEventStreams() {
-	const eventStreamMemberName = "EventStream"
+import (
+	"fmt"
+	"os"
+)
 
-	for name, op := range a.Operations {
-		outbound := hasEventStream(op.InputRef.Shape)
-		inbound := hasEventStream(op.OutputRef.Shape)
+func (a *API) suppressEventStreams() error {
+	for opName, op := range a.Operations {
+		inputRef := getEventStreamMember(op.InputRef.Shape)
+		outputRef := getEventStreamMember(op.OutputRef.Shape)
 
-		if !(outbound || inbound) {
+		if inputRef == nil && outputRef == nil {
 			continue
 		}
 
-		a.removeOperation(name)
+		if !a.KeepUnsupportedAPIs {
+			fmt.Fprintf(os.Stderr,
+				"removing unsupported eventstream operation, %s\n",
+				opName)
+			a.removeOperation(opName)
+			continue
+		}
+		return UnsupportedAPIModelError{
+			Err: fmt.Errorf("eventstream support not implemented, %s",
+				op.ExportedName),
+		}
 	}
+
+	return nil
 }
 
-func hasEventStream(topShape *Shape) bool {
+func getEventStreamMember(topShape *Shape) *ShapeRef {
 	for _, ref := range topShape.MemberRefs {
-		if ref.Shape.IsEventStream {
-			return true
+		if !ref.Shape.IsEventStream {
+			continue
 		}
+		return ref
 	}
 
-	return false
+	return nil
 }

private/model/api/example.go

@@ -14,7 +14,41 @@ import (
 	"github.com/aws/aws-sdk-go-v2/private/util"
 )
 
-type Examples map[string][]Example
+// ExamplesGoCode will return a code representation of the entry within the
+// examples.json file.
+func (a *API) ExamplesGoCode() string {
+	a.resetImports()
+	a.AddImport("context")
+	a.AddImport("fmt")
+
+	a.AddSDKImport("aws")
+	a.AddSDKImport("aws/awserr")
+	a.AddSDKImport("aws/external")
+	a.AddImport(a.ImportPath())
+
+	var extra = `
+var _ aws.Config
+`
+
+	code := a.Examples.GoCode()
+	if len(code) == 0 {
+		return ""
+	}
+	if a.Examples.UsedTimestamp() {
+		a.AddImport("time")
+		extra += `
+func parseTime(layout, value string) time.Time {
+   t, err := time.Parse(layout, value)
+   if err != nil {
+	   panic(err)
+   }
+   return t
+}
+`
+	}
+
+	return a.importsGoCode() + extra + code
+}
 
 // ExamplesDefinition is the structural representation of the examples-1.json file
 type ExamplesDefinition struct {
@@ -28,7 +62,7 @@ type Example struct {
 	Operation     *Operation             `json:"-"`
 	OperationName string                 `json:"-"`
 	Index         string                 `json:"-"`
-	Builder       examplesBuilder        `json:"-"`
+	Builder       *ExamplesBuilder       `json:"-"`
 	VisitedErrors map[string]struct{}    `json:"-"`
 	Title         string                 `json:"title"`
 	Description   string                 `json:"description"`
@@ -91,6 +125,20 @@ func Example{{ .API.StructName }}_{{ .MethodName }}() {
 }
 `))
 
+type Examples map[string][]Example
+
+func (exs Examples) UsedTimestamp() bool {
+	for _, es := range exs {
+		for _, e := range es {
+			if e.Builder.HasTimestamp {
+				return true
+			}
+		}
+	}
+
+	return false
+}
+
 // Names will return the name of the example. This will also be the name of the operation
 // that is to be tested.
 func (exs Examples) Names() []string {
@@ -175,10 +223,6 @@ func correctType(memName string, t string, value interface{}, asValue bool) stri
 	return convertToCorrectType(memName, t, v, asValue)
 }
 
-func convertToCorrectType(memName, t, v string, asValue bool) string {
-	return fmt.Sprintf("%s: %s,\n", memName, getValue(t, v, asValue))
-}
-
 func getValue(t, v string, asValue bool) string {
 	if t[0] == '*' {
 		t = t[1:]
@@ -211,24 +255,24 @@ func getValue(t, v string, asValue bool) string {
 
 // AttachExamples will create a new ExamplesDefinition from the examples file
 // and reference the API object.
-func (a *API) AttachExamples(filename string) {
+func (a *API) AttachExamples(filename string) error {
 	p := ExamplesDefinition{API: a}
 
 	f, err := os.Open(filename)
 	defer f.Close()
 	if err != nil {
-		panic(err)
+		return err
 	}
 	err = json.NewDecoder(f).Decode(&p)
 	if err != nil {
-		panic(err)
+		return fmt.Errorf("failed to decode %s, err: %v", filename, err)
 	}
 
-	p.setup()
+	return p.setup()
 }
 
-func (p *ExamplesDefinition) setup() {
-	builder := defaultExamplesBuilder{}
+func (p *ExamplesDefinition) setup() error {
+	builder := NewExamplesBuilder()
 	keys := p.Examples.Names()
 	for _, n := range keys {
 		examples := p.Examples[n]
@@ -249,74 +293,17 @@ func (p *ExamplesDefinition) setup() {
 	}
 
 	p.API.Examples = p.Examples
-}
 
-var exampleHeader = template.Must(template.New("exampleHeader").Parse(`
-import (
-	{{ .Builder.Imports .API }}
-)
-
-var _ time.Duration
-var _ strings.Reader
-var _ aws.Config
-
-func parseTime(layout, value string) *time.Time {
-	t, err := time.Parse(layout, value)
-	if err != nil {
-		panic(err)
-	}
-	return &t
-}
-
-`))
-
-type exHeader struct {
-	Builder examplesBuilder
-	API     *API
-}
-
-// ExamplesGoCode will return a code representation of the entry within the
-// examples.json file.
-func (a *API) ExamplesGoCode() string {
-	var buf bytes.Buffer
-	builder := defaultExamplesBuilder{}
-	if err := exampleHeader.ExecuteTemplate(&buf, "exampleHeader", &exHeader{builder, a}); err != nil {
-		panic(err)
-	}
-
-	code := a.Examples.GoCode()
-	if len(code) == 0 {
-		return ""
-	}
-
-	buf.WriteString(code)
-	return buf.String()
+	return nil
 }
 
-// TODO: In the operation docuentation where we list errors, this needs to be done
-// there as well.
 func (ex *Example) HasVisitedError(errRef *ShapeRef) bool {
 	errName := errRef.Shape.ErrorCodeName()
 	_, ok := ex.VisitedErrors[errName]
 	ex.VisitedErrors[errName] = struct{}{}
 	return ok
 }
 
-func parseTimeString(ref *ShapeRef, memName, v string) string {
-	if ref.Location == "header" {
-		return fmt.Sprintf("%s: parseTime(%q, %q),\n", memName, "Mon, 2 Jan 2006 15:04:05 GMT", v)
-	} else {
-		switch ref.API.Metadata.Protocol {
-		case "json", "rest-json":
-			return fmt.Sprintf("%s: parseTime(%q, %q),\n", memName, "2006-01-02T15:04:05Z", v)
-		case "rest-xml", "ec2", "query":
-			return fmt.Sprintf("%s: parseTime(%q, %q),\n", memName, "2006-01-02T15:04:05Z", v)
-		default:
-			panic("Unsupported time type: " + ref.API.Metadata.Protocol)
-		}
-	}
-}
-
 func (ex *Example) MethodName() string {
 	return fmt.Sprintf("%sRequest_%s", ex.OperationName, ex.Index)
 }

private/model/api/example_test.go

@@ -4,8 +4,9 @@ package api
 
 import (
 	"encoding/json"
-	"github.com/google/go-cmp/cmp"
 	"testing"
+
+	"github.com/google/go-cmp/cmp"
 )
 
 func buildAPI() (*API, error) {
@@ -126,32 +127,18 @@ func TestExampleGeneration(t *testing.T) {
 	def.API = a
 
 	def.setup()
-	expected := `
-import (
-	"fmt"
+	expected := `import (
 	"context"
-	"strings"
-	"time"
+	"fmt"
 
 	"github.com/aws/aws-sdk-go-v2/aws"
 	"github.com/aws/aws-sdk-go-v2/aws/awserr"
 	"github.com/aws/aws-sdk-go-v2/aws/external"
 	"github.com/aws/aws-sdk-go-v2/service/fooservice"
-	
 )
 
-var _ time.Duration
-var _ strings.Reader
-var _ aws.Config
-
-func parseTime(layout, value string) *time.Time {
-	t, err := time.Parse(layout, value)
-	if err != nil {
-		panic(err)
-	}
-	return &t
-}
 
+var _ aws.Config
 // I pity the foo
 //
 // Foo bar baz qux
@@ -215,7 +202,7 @@ func TestBuildShape(t *testing.T) {
 
 	for _, c := range cases {
 		ref := a.Operations["Foo"].InputRef
-		shapeStr := defaultExamplesBuilder{}.BuildShape(&ref, c.defs, false, false)
+		shapeStr := NewExamplesBuilder().BuildShape(&ref, c.defs, false, false)
 		if c.expected != shapeStr {
 			t.Errorf("Expected:\n%s\nReceived:\n%s", c.expected, shapeStr)
 		}