github.com/lingyao2333/mo-zero@v1.4.1/rest/httpc/responses_test.go (about)

     1  package httpc
     2  
     3  import (
     4  	"errors"
     5  	"net/http"
     6  	"net/http/httptest"
     7  	"testing"
     8  
     9  	"github.com/lingyao2333/mo-zero/rest/internal/header"
    10  	"github.com/stretchr/testify/assert"
    11  )
    12  
    13  func TestParse(t *testing.T) {
    14  	var val struct {
    15  		Foo   string `header:"foo"`
    16  		Name  string `json:"name"`
    17  		Value int    `json:"value"`
    18  	}
    19  	svr := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    20  		w.Header().Set("foo", "bar")
    21  		w.Header().Set(header.ContentType, header.JsonContentType)
    22  		w.Write([]byte(`{"name":"kevin","value":100}`))
    23  	}))
    24  	defer svr.Close()
    25  	req, err := http.NewRequest(http.MethodGet, svr.URL, nil)
    26  	assert.Nil(t, err)
    27  	resp, err := DoRequest(req)
    28  	assert.Nil(t, err)
    29  	assert.Nil(t, Parse(resp, &val))
    30  	assert.Equal(t, "bar", val.Foo)
    31  	assert.Equal(t, "kevin", val.Name)
    32  	assert.Equal(t, 100, val.Value)
    33  }
    34  
    35  func TestParseHeaderError(t *testing.T) {
    36  	var val struct {
    37  		Foo int `header:"foo"`
    38  	}
    39  	svr := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    40  		w.Header().Set("foo", "bar")
    41  		w.Header().Set(header.ContentType, header.JsonContentType)
    42  	}))
    43  	defer svr.Close()
    44  	req, err := http.NewRequest(http.MethodGet, svr.URL, nil)
    45  	assert.Nil(t, err)
    46  	resp, err := DoRequest(req)
    47  	assert.Nil(t, err)
    48  	assert.NotNil(t, Parse(resp, &val))
    49  }
    50  
    51  func TestParseNoBody(t *testing.T) {
    52  	var val struct {
    53  		Foo string `header:"foo"`
    54  	}
    55  	svr := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    56  		w.Header().Set("foo", "bar")
    57  		w.Header().Set(header.ContentType, header.JsonContentType)
    58  	}))
    59  	defer svr.Close()
    60  	req, err := http.NewRequest(http.MethodGet, svr.URL, nil)
    61  	assert.Nil(t, err)
    62  	resp, err := DoRequest(req)
    63  	assert.Nil(t, err)
    64  	assert.Nil(t, Parse(resp, &val))
    65  	assert.Equal(t, "bar", val.Foo)
    66  }
    67  
    68  func TestParseWithZeroValue(t *testing.T) {
    69  	var val struct {
    70  		Foo int `header:"foo"`
    71  		Bar int `json:"bar"`
    72  	}
    73  	svr := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    74  		w.Header().Set("foo", "0")
    75  		w.Header().Set(header.ContentType, header.JsonContentType)
    76  		w.Write([]byte(`{"bar":0}`))
    77  	}))
    78  	defer svr.Close()
    79  	req, err := http.NewRequest(http.MethodGet, svr.URL, nil)
    80  	assert.Nil(t, err)
    81  	resp, err := DoRequest(req)
    82  	assert.Nil(t, err)
    83  	assert.Nil(t, Parse(resp, &val))
    84  	assert.Equal(t, 0, val.Foo)
    85  	assert.Equal(t, 0, val.Bar)
    86  }
    87  
    88  func TestParseWithNegativeContentLength(t *testing.T) {
    89  	var val struct {
    90  		Bar int `json:"bar"`
    91  	}
    92  	svr := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    93  		w.Header().Set(header.ContentType, header.JsonContentType)
    94  		w.Write([]byte(`{"bar":0}`))
    95  	}))
    96  	defer svr.Close()
    97  	req, err := http.NewRequest(http.MethodGet, svr.URL, nil)
    98  	assert.Nil(t, err)
    99  
   100  	tests := []struct {
   101  		name   string
   102  		length int64
   103  	}{
   104  		{
   105  			name:   "negative",
   106  			length: -1,
   107  		},
   108  		{
   109  			name:   "zero",
   110  			length: 0,
   111  		},
   112  	}
   113  	for _, test := range tests {
   114  		t.Run(test.name, func(t *testing.T) {
   115  			resp, err := DoRequest(req)
   116  			resp.ContentLength = test.length
   117  			assert.Nil(t, err)
   118  			assert.Nil(t, Parse(resp, &val))
   119  			assert.Equal(t, 0, val.Bar)
   120  		})
   121  	}
   122  }
   123  
   124  func TestParseWithNegativeContentLengthNoBody(t *testing.T) {
   125  	var val struct{}
   126  	svr := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   127  		w.Header().Set(header.ContentType, header.JsonContentType)
   128  	}))
   129  	defer svr.Close()
   130  	req, err := http.NewRequest(http.MethodGet, svr.URL, nil)
   131  	assert.Nil(t, err)
   132  
   133  	tests := []struct {
   134  		name   string
   135  		length int64
   136  	}{
   137  		{
   138  			name:   "negative",
   139  			length: -1,
   140  		},
   141  		{
   142  			name:   "zero",
   143  			length: 0,
   144  		},
   145  	}
   146  	for _, test := range tests {
   147  		t.Run(test.name, func(t *testing.T) {
   148  			resp, err := DoRequest(req)
   149  			resp.ContentLength = test.length
   150  			assert.Nil(t, err)
   151  			assert.Nil(t, Parse(resp, &val))
   152  		})
   153  	}
   154  }
   155  
   156  func TestParseJsonBody_BodyError(t *testing.T) {
   157  	var val struct{}
   158  	svr := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   159  		w.Header().Set(header.ContentType, header.JsonContentType)
   160  	}))
   161  	defer svr.Close()
   162  	req, err := http.NewRequest(http.MethodGet, svr.URL, nil)
   163  	assert.Nil(t, err)
   164  
   165  	resp, err := DoRequest(req)
   166  	resp.ContentLength = -1
   167  	resp.Body = mockedReader{}
   168  	assert.Nil(t, err)
   169  	assert.NotNil(t, Parse(resp, &val))
   170  }
   171  
   172  type mockedReader struct{}
   173  
   174  func (m mockedReader) Close() error {
   175  	return nil
   176  }
   177  
   178  func (m mockedReader) Read(p []byte) (n int, err error) {
   179  	return 0, errors.New("dummy")
   180  }