github.com/aavshr/aws-sdk-go@v1.41.3/private/model/api/eventstream_tmpl_tests.go (about)

     1  //go:build codegen
     2  // +build codegen
     3  
     4  package api
     5  
     6  import (
     7  	"bytes"
     8  	"fmt"
     9  	"strings"
    10  )
    11  
    12  // APIEventStreamTestGoCode generates Go code for EventStream operation tests.
    13  func (a *API) APIEventStreamTestGoCode() string {
    14  	var buf bytes.Buffer
    15  
    16  	a.resetImports()
    17  	a.AddImport("bytes")
    18  	a.AddImport("io/ioutil")
    19  	a.AddImport("net/http")
    20  	a.AddImport("reflect")
    21  	a.AddImport("testing")
    22  	a.AddImport("time")
    23  	a.AddImport("context")
    24  	a.AddImport("strings")
    25  	a.AddImport("sync")
    26  	a.AddSDKImport("aws")
    27  	a.AddSDKImport("aws/corehandlers")
    28  	a.AddSDKImport("aws/request")
    29  	a.AddSDKImport("aws/awserr")
    30  	a.AddSDKImport("awstesting/unit")
    31  	a.AddSDKImport("private/protocol")
    32  	a.AddSDKImport("private/protocol/", a.ProtocolPackage())
    33  	a.AddSDKImport("private/protocol/eventstream")
    34  	a.AddSDKImport("private/protocol/eventstream/eventstreamapi")
    35  	a.AddSDKImport("private/protocol/eventstream/eventstreamtest")
    36  
    37  	unused := `
    38  	var _ time.Time
    39  	var _ awserr.Error
    40  	var _ context.Context
    41  	var _ sync.WaitGroup
    42  	var _ strings.Reader
    43  	`
    44  
    45  	if err := eventStreamReaderTestTmpl.Execute(&buf, a); err != nil {
    46  		panic(err)
    47  	}
    48  
    49  	if err := eventStreamWriterTestTmpl.Execute(&buf, a); err != nil {
    50  		panic(err)
    51  	}
    52  
    53  	return a.importsGoCode() + unused + strings.TrimSpace(buf.String())
    54  }
    55  
    56  func templateMap(args ...interface{}) map[string]interface{} {
    57  	if len(args)%2 != 0 {
    58  		panic(fmt.Sprintf("invalid map call, non-even args %v", args))
    59  	}
    60  
    61  	m := map[string]interface{}{}
    62  	for i := 0; i < len(args); i += 2 {
    63  		k, ok := args[i].(string)
    64  		if !ok {
    65  			panic(fmt.Sprintf("invalid map call, arg is not string, %T, %v", args[i], args[i]))
    66  		}
    67  		m[k] = args[i+1]
    68  	}
    69  
    70  	return m
    71  }
    72  
    73  func valueForType(s *Shape, visited []string) string {
    74  	if isShapeVisited(visited, s.ShapeName) {
    75  		return "nil"
    76  	}
    77  
    78  	visited = append(visited, s.ShapeName)
    79  
    80  	switch s.Type {
    81  	case "blob":
    82  		return `[]byte("blob value goes here")`
    83  	case "string":
    84  		return `aws.String("string value goes here")`
    85  	case "boolean":
    86  		return `aws.Bool(true)`
    87  	case "byte":
    88  		return `aws.Int64(1)`
    89  	case "short":
    90  		return `aws.Int64(12)`
    91  	case "integer":
    92  		return `aws.Int64(123)`
    93  	case "long":
    94  		return `aws.Int64(1234)`
    95  	case "float":
    96  		return `aws.Float64(123.4)`
    97  	case "double":
    98  		return `aws.Float64(123.45)`
    99  	case "timestamp":
   100  		return `aws.Time(time.Unix(1396594860, 0).UTC())`
   101  	case "structure":
   102  		w := bytes.NewBuffer(nil)
   103  		fmt.Fprintf(w, "&%s{\n", s.ShapeName)
   104  		if s.Exception {
   105  			fmt.Fprintf(w, `RespMetadata: protocol.ResponseMetadata{
   106  	StatusCode: 200,
   107  },
   108  `)
   109  		}
   110  		for _, refName := range s.MemberNames() {
   111  			fmt.Fprintf(w, "%s: %s,\n", refName, valueForType(s.MemberRefs[refName].Shape, visited))
   112  		}
   113  		fmt.Fprintf(w, "}")
   114  		return w.String()
   115  	case "list":
   116  		w := bytes.NewBuffer(nil)
   117  		fmt.Fprintf(w, "%s{\n", s.GoType())
   118  		if !isShapeVisited(visited, s.MemberRef.Shape.ShapeName) {
   119  			for i := 0; i < 3; i++ {
   120  				fmt.Fprintf(w, "%s,\n", valueForType(s.MemberRef.Shape, visited))
   121  			}
   122  		}
   123  		fmt.Fprintf(w, "}")
   124  		return w.String()
   125  
   126  	case "map":
   127  		w := bytes.NewBuffer(nil)
   128  		fmt.Fprintf(w, "%s{\n", s.GoType())
   129  		if !isShapeVisited(visited, s.ValueRef.Shape.ShapeName) {
   130  			for _, k := range []string{"a", "b", "c"} {
   131  				fmt.Fprintf(w, "%q: %s,\n", k, valueForType(s.ValueRef.Shape, visited))
   132  			}
   133  		}
   134  		fmt.Fprintf(w, "}")
   135  		return w.String()
   136  
   137  	default:
   138  		panic(fmt.Sprintf("valueForType does not support %s, %s", s.ShapeName, s.Type))
   139  	}
   140  }
   141  
   142  func isShapeVisited(visited []string, name string) bool {
   143  	for _, v := range visited {
   144  		if v == name {
   145  			return true
   146  		}
   147  	}
   148  	return false
   149  }