github.com/aavshr/aws-sdk-go@v1.41.3/aws/client/logger_test.go (about)

     1  package client
     2  
     3  import (
     4  	"bytes"
     5  	"fmt"
     6  	"io"
     7  	"io/ioutil"
     8  	"net/http"
     9  	"reflect"
    10  	"testing"
    11  
    12  	"github.com/aavshr/aws-sdk-go/aws"
    13  	"github.com/aavshr/aws-sdk-go/aws/client/metadata"
    14  	"github.com/aavshr/aws-sdk-go/aws/corehandlers"
    15  	"github.com/aavshr/aws-sdk-go/aws/credentials"
    16  	"github.com/aavshr/aws-sdk-go/aws/request"
    17  )
    18  
    19  type mockCloser struct {
    20  	closed bool
    21  }
    22  
    23  func (closer *mockCloser) Read(b []byte) (int, error) {
    24  	return 0, io.EOF
    25  }
    26  
    27  func (closer *mockCloser) Close() error {
    28  	closer.closed = true
    29  	return nil
    30  }
    31  
    32  func TestTeeReaderCloser(t *testing.T) {
    33  	expected := "FOO"
    34  	buf := bytes.NewBuffer([]byte(expected))
    35  	lw := bytes.NewBuffer(nil)
    36  	c := &mockCloser{}
    37  	closer := teeReaderCloser{
    38  		io.TeeReader(buf, lw),
    39  		c,
    40  	}
    41  
    42  	b := make([]byte, len(expected))
    43  	_, err := closer.Read(b)
    44  	closer.Close()
    45  
    46  	if expected != lw.String() {
    47  		t.Errorf("Expected %q, but received %q", expected, lw.String())
    48  	}
    49  
    50  	if err != nil {
    51  		t.Errorf("Expected 'nil', but received %v", err)
    52  	}
    53  
    54  	if !c.closed {
    55  		t.Error("Expected 'true', but received 'false'")
    56  	}
    57  }
    58  
    59  func TestLogWriter(t *testing.T) {
    60  	expected := "FOO"
    61  	lw := &logWriter{nil, bytes.NewBuffer(nil)}
    62  	lw.Write([]byte(expected))
    63  
    64  	if expected != lw.buf.String() {
    65  		t.Errorf("Expected %q, but received %q", expected, lw.buf.String())
    66  	}
    67  }
    68  
    69  func TestLogRequest(t *testing.T) {
    70  	cases := []struct {
    71  		Body       io.ReadSeeker
    72  		ExpectBody []byte
    73  		LogLevel   aws.LogLevelType
    74  	}{
    75  		{
    76  			Body:       aws.ReadSeekCloser(bytes.NewBuffer([]byte("body content"))),
    77  			ExpectBody: []byte("body content"),
    78  		},
    79  		{
    80  			Body:       aws.ReadSeekCloser(bytes.NewBuffer([]byte("body content"))),
    81  			LogLevel:   aws.LogDebugWithHTTPBody,
    82  			ExpectBody: []byte("body content"),
    83  		},
    84  		{
    85  			Body:       bytes.NewReader([]byte("body content")),
    86  			ExpectBody: []byte("body content"),
    87  		},
    88  		{
    89  			Body:       bytes.NewReader([]byte("body content")),
    90  			LogLevel:   aws.LogDebugWithHTTPBody,
    91  			ExpectBody: []byte("body content"),
    92  		},
    93  	}
    94  
    95  	for i, c := range cases {
    96  		logW := bytes.NewBuffer(nil)
    97  		req := request.New(
    98  			aws.Config{
    99  				Credentials: credentials.AnonymousCredentials,
   100  				Logger:      &bufLogger{w: logW},
   101  				LogLevel:    aws.LogLevel(c.LogLevel),
   102  			},
   103  			metadata.ClientInfo{
   104  				Endpoint: "https://mock-service.mock-region.amazonaws.com",
   105  			},
   106  			testHandlers(),
   107  			nil,
   108  			&request.Operation{
   109  				Name:       "APIName",
   110  				HTTPMethod: "POST",
   111  				HTTPPath:   "/",
   112  			},
   113  			struct{}{}, nil,
   114  		)
   115  		req.SetReaderBody(c.Body)
   116  		req.Build()
   117  
   118  		logRequest(req)
   119  
   120  		b, err := ioutil.ReadAll(req.HTTPRequest.Body)
   121  		if err != nil {
   122  			t.Fatalf("%d, expect to read SDK request Body", i)
   123  		}
   124  
   125  		if e, a := c.ExpectBody, b; !reflect.DeepEqual(e, a) {
   126  			t.Errorf("%d, expect %v body, got %v", i, e, a)
   127  		}
   128  	}
   129  }
   130  
   131  func TestLogResponse(t *testing.T) {
   132  	cases := []struct {
   133  		Body       *bytes.Buffer
   134  		ExpectBody []byte
   135  		ReadBody   bool
   136  		LogLevel   aws.LogLevelType
   137  		ExpectLog  bool
   138  	}{
   139  		{
   140  			Body:       bytes.NewBuffer([]byte("body content")),
   141  			ExpectBody: []byte("body content"),
   142  		},
   143  		{
   144  			Body:       bytes.NewBuffer([]byte("body content")),
   145  			LogLevel:   aws.LogDebug,
   146  			ExpectLog:  true,
   147  			ExpectBody: []byte("body content"),
   148  		},
   149  		{
   150  			Body:       bytes.NewBuffer([]byte("body content")),
   151  			LogLevel:   aws.LogDebugWithHTTPBody,
   152  			ExpectLog:  true,
   153  			ReadBody:   true,
   154  			ExpectBody: []byte("body content"),
   155  		},
   156  	}
   157  
   158  	for i, c := range cases {
   159  		var logW bytes.Buffer
   160  		req := request.New(
   161  			aws.Config{
   162  				Credentials: credentials.AnonymousCredentials,
   163  				Logger:      &bufLogger{w: &logW},
   164  				LogLevel:    aws.LogLevel(c.LogLevel),
   165  			},
   166  			metadata.ClientInfo{
   167  				Endpoint: "https://mock-service.mock-region.amazonaws.com",
   168  			},
   169  			testHandlers(),
   170  			nil,
   171  			&request.Operation{
   172  				Name:       "APIName",
   173  				HTTPMethod: "POST",
   174  				HTTPPath:   "/",
   175  			},
   176  			struct{}{}, nil,
   177  		)
   178  		req.HTTPResponse = &http.Response{
   179  			StatusCode: 200,
   180  			Status:     "OK",
   181  			Header: http.Header{
   182  				"ABC": []string{"123"},
   183  			},
   184  			Body: ioutil.NopCloser(c.Body),
   185  		}
   186  
   187  		logResponse(req)
   188  		req.Handlers.Unmarshal.Run(req)
   189  
   190  		if c.ReadBody {
   191  			if e, a := len(c.ExpectBody), c.Body.Len(); e != a {
   192  				t.Errorf("%d, expect original body not to of been read", i)
   193  			}
   194  		}
   195  
   196  		if c.ExpectLog && logW.Len() == 0 {
   197  			t.Errorf("%d, expect HTTP Response headers to be logged", i)
   198  		} else if !c.ExpectLog && logW.Len() != 0 {
   199  			t.Errorf("%d, expect no log, got,\n%v", i, logW.String())
   200  		}
   201  
   202  		b, err := ioutil.ReadAll(req.HTTPResponse.Body)
   203  		if err != nil {
   204  			t.Fatalf("%d, expect to read SDK request Body", i)
   205  		}
   206  
   207  		if e, a := c.ExpectBody, b; !bytes.Equal(e, a) {
   208  			t.Errorf("%d, expect %v body, got %v", i, e, a)
   209  		}
   210  	}
   211  }
   212  
   213  type bufLogger struct {
   214  	w *bytes.Buffer
   215  }
   216  
   217  func (l *bufLogger) Log(args ...interface{}) {
   218  	fmt.Fprintln(l.w, args...)
   219  }
   220  
   221  func testHandlers() request.Handlers {
   222  	var handlers request.Handlers
   223  
   224  	handlers.Build.PushBackNamed(corehandlers.SDKVersionUserAgentHandler)
   225  
   226  	return handlers
   227  }