github.com/stffabi/git-lfs@v2.3.5-0.20180214015214-8eeaa8d88902+incompatible/lfsapi/stats_test.go (about)

     1  package lfsapi
     2  
     3  import (
     4  	"bytes"
     5  	"encoding/json"
     6  	"io"
     7  	"io/ioutil"
     8  	"net/http"
     9  	"net/http/httptest"
    10  	"strings"
    11  	"sync/atomic"
    12  	"testing"
    13  
    14  	"github.com/stretchr/testify/assert"
    15  	"github.com/stretchr/testify/require"
    16  )
    17  
    18  func TestStatsWithKey(t *testing.T) {
    19  	var called uint32
    20  	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    21  		atomic.AddUint32(&called, 1)
    22  		t.Logf("srv req %s %s", r.Method, r.URL.Path)
    23  		assert.Equal(t, "POST", r.Method)
    24  
    25  		assert.Equal(t, "Basic ABC", r.Header.Get("Authorization"))
    26  		body := &verboseTest{}
    27  		err := json.NewDecoder(r.Body).Decode(body)
    28  		assert.Nil(t, err)
    29  		assert.Equal(t, "Verbose", body.Test)
    30  		w.Header().Set("Content-Type", "application/json")
    31  		w.Write([]byte(`{"Status":"Ok"}`))
    32  	}))
    33  	defer srv.Close()
    34  
    35  	out := &bytes.Buffer{}
    36  	c, _ := NewClient(nil)
    37  	c.ConcurrentTransfers = 5
    38  	c.LogHTTPStats(nopCloser(out))
    39  
    40  	req, err := http.NewRequest("POST", srv.URL, nil)
    41  	req = c.LogRequest(req, "stats-test")
    42  	req.Header.Set("Authorization", "Basic ABC")
    43  	req.Header.Set("Content-Type", "application/json")
    44  	require.Nil(t, err)
    45  	require.Nil(t, MarshalToRequest(req, verboseTest{"Verbose"}))
    46  
    47  	res, err := c.Do(req)
    48  	require.Nil(t, err)
    49  
    50  	io.Copy(ioutil.Discard, res.Body)
    51  	res.Body.Close()
    52  	assert.Nil(t, c.Close())
    53  
    54  	assert.Equal(t, 200, res.StatusCode)
    55  	assert.EqualValues(t, 1, called)
    56  
    57  	stats := strings.TrimSpace(out.String())
    58  	t.Log(stats)
    59  	lines := strings.Split(stats, "\n")
    60  	require.Equal(t, 3, len(lines))
    61  	assert.True(t, strings.Contains(lines[0], "concurrent=5"))
    62  	expected := []string{
    63  		"key=stats-test",
    64  		"event=request",
    65  		"body=18",
    66  		"url=" + srv.URL,
    67  	}
    68  
    69  	for _, substr := range expected {
    70  		assert.True(t, strings.Contains(lines[1], substr), "missing: "+substr)
    71  	}
    72  
    73  	expected = []string{
    74  		"key=stats-test",
    75  		"event=response",
    76  		"url=" + srv.URL,
    77  	}
    78  
    79  	for _, substr := range expected {
    80  		assert.True(t, strings.Contains(lines[2], substr), "missing: "+substr)
    81  	}
    82  }
    83  
    84  func TestStatsWithoutKey(t *testing.T) {
    85  	var called uint32
    86  	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    87  		atomic.AddUint32(&called, 1)
    88  		t.Logf("srv req %s %s", r.Method, r.URL.Path)
    89  		assert.Equal(t, "POST", r.Method)
    90  
    91  		assert.Equal(t, "Basic ABC", r.Header.Get("Authorization"))
    92  		body := &verboseTest{}
    93  		err := json.NewDecoder(r.Body).Decode(body)
    94  		assert.Nil(t, err)
    95  		assert.Equal(t, "Verbose", body.Test)
    96  		w.Header().Set("Content-Type", "application/json")
    97  		w.Write([]byte(`{"Status":"Ok"}`))
    98  	}))
    99  	defer srv.Close()
   100  
   101  	out := &bytes.Buffer{}
   102  	c, _ := NewClient(nil)
   103  	c.ConcurrentTransfers = 5
   104  	c.LogHTTPStats(nopCloser(out))
   105  
   106  	req, err := http.NewRequest("POST", srv.URL, nil)
   107  	req.Header.Set("Authorization", "Basic ABC")
   108  	req.Header.Set("Content-Type", "application/json")
   109  	require.Nil(t, err)
   110  	require.Nil(t, MarshalToRequest(req, verboseTest{"Verbose"}))
   111  
   112  	res, err := c.Do(req)
   113  	require.Nil(t, err)
   114  	io.Copy(ioutil.Discard, res.Body)
   115  	res.Body.Close()
   116  	assert.Nil(t, c.Close())
   117  
   118  	assert.Equal(t, 200, res.StatusCode)
   119  	assert.EqualValues(t, 1, called)
   120  
   121  	stats := strings.TrimSpace(out.String())
   122  	t.Log(stats)
   123  	assert.True(t, strings.Contains(stats, "concurrent=5"))
   124  	assert.Equal(t, 1, len(strings.Split(stats, "\n")))
   125  }
   126  
   127  func TestStatsDisabled(t *testing.T) {
   128  	var called uint32
   129  	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   130  		atomic.AddUint32(&called, 1)
   131  		t.Logf("srv req %s %s", r.Method, r.URL.Path)
   132  		assert.Equal(t, "POST", r.Method)
   133  
   134  		assert.Equal(t, "Basic ABC", r.Header.Get("Authorization"))
   135  		body := &verboseTest{}
   136  		err := json.NewDecoder(r.Body).Decode(body)
   137  		assert.Nil(t, err)
   138  		assert.Equal(t, "Verbose", body.Test)
   139  		w.Header().Set("Content-Type", "application/json")
   140  		w.Write([]byte(`{"Status":"Ok"}`))
   141  	}))
   142  	defer srv.Close()
   143  
   144  	c, _ := NewClient(nil)
   145  	c.ConcurrentTransfers = 5
   146  
   147  	req, err := http.NewRequest("POST", srv.URL, nil)
   148  	req = c.LogRequest(req, "stats-test")
   149  
   150  	req.Header.Set("Authorization", "Basic ABC")
   151  	req.Header.Set("Content-Type", "application/json")
   152  	require.Nil(t, err)
   153  	require.Nil(t, MarshalToRequest(req, verboseTest{"Verbose"}))
   154  
   155  	res, err := c.Do(req)
   156  	require.Nil(t, err)
   157  
   158  	io.Copy(ioutil.Discard, res.Body)
   159  	res.Body.Close()
   160  
   161  	assert.Equal(t, 200, res.StatusCode)
   162  	assert.EqualValues(t, 1, called)
   163  
   164  	out := &bytes.Buffer{}
   165  	c.LogStats(out)
   166  	assert.Equal(t, 0, out.Len())
   167  }
   168  
   169  func nopCloser(w io.Writer) io.WriteCloser {
   170  	return nopWCloser{w}
   171  }
   172  
   173  type nopWCloser struct {
   174  	io.Writer
   175  }
   176  
   177  func (w nopWCloser) Close() error {
   178  	return nil
   179  }