github.com/git-lfs/git-lfs@v2.5.2+incompatible/lfsapi/response_test.go (about)

     1  package lfsapi
     2  
     3  import (
     4  	"net/http"
     5  	"net/http/httptest"
     6  	"strings"
     7  	"sync/atomic"
     8  	"testing"
     9  
    10  	"github.com/git-lfs/git-lfs/errors"
    11  	"github.com/stretchr/testify/assert"
    12  )
    13  
    14  func TestAuthErrWithBody(t *testing.T) {
    15  	var called uint32
    16  	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    17  		if r.URL.String() != "/test" {
    18  			w.WriteHeader(http.StatusNotFound)
    19  			return
    20  		}
    21  
    22  		atomic.AddUint32(&called, 1)
    23  		w.Header().Set("Content-Type", "application/json")
    24  		w.WriteHeader(401)
    25  		w.Write([]byte(`{"message":"custom auth error"}`))
    26  	}))
    27  	defer srv.Close()
    28  
    29  	req, err := http.NewRequest("GET", srv.URL+"/test", nil)
    30  	assert.Nil(t, err)
    31  
    32  	c, _ := NewClient(nil)
    33  	_, err = c.Do(req)
    34  	assert.NotNil(t, err)
    35  	assert.True(t, errors.IsAuthError(err))
    36  	assert.Equal(t, "Authentication required: custom auth error", err.Error())
    37  	assert.EqualValues(t, 1, called)
    38  }
    39  
    40  func TestFatalWithBody(t *testing.T) {
    41  	var called uint32
    42  	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    43  		if r.URL.String() != "/test" {
    44  			w.WriteHeader(http.StatusNotFound)
    45  			return
    46  		}
    47  
    48  		atomic.AddUint32(&called, 1)
    49  		w.Header().Set("Content-Type", "application/json")
    50  		w.WriteHeader(500)
    51  		w.Write([]byte(`{"message":"custom fatal error"}`))
    52  	}))
    53  	defer srv.Close()
    54  
    55  	req, err := http.NewRequest("GET", srv.URL+"/test", nil)
    56  	assert.Nil(t, err)
    57  
    58  	c, _ := NewClient(nil)
    59  	_, err = c.Do(req)
    60  	assert.NotNil(t, err)
    61  	assert.True(t, errors.IsFatalError(err))
    62  	assert.Equal(t, "Fatal error: custom fatal error", err.Error())
    63  	assert.EqualValues(t, 1, called)
    64  }
    65  
    66  func TestWithNonFatal500WithBody(t *testing.T) {
    67  	c, _ := NewClient(nil)
    68  
    69  	var called uint32
    70  
    71  	nonFatalCodes := map[int]string{
    72  		501: "custom 501 error",
    73  		507: "custom 507 error",
    74  		509: "custom 509 error",
    75  	}
    76  
    77  	for nonFatalCode, expectedErr := range nonFatalCodes {
    78  		srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    79  			if r.URL.String() != "/test" {
    80  				w.WriteHeader(http.StatusNotFound)
    81  				return
    82  			}
    83  
    84  			atomic.AddUint32(&called, 1)
    85  			w.Header().Set("Content-Type", "application/json")
    86  			w.WriteHeader(nonFatalCode)
    87  			w.Write([]byte(`{"message":"` + expectedErr + `"}`))
    88  		}))
    89  
    90  		req, err := http.NewRequest("GET", srv.URL+"/test", nil)
    91  		assert.Nil(t, err)
    92  
    93  		_, err = c.Do(req)
    94  		t.Logf("non fatal code %d", nonFatalCode)
    95  		assert.NotNil(t, err)
    96  		assert.Equal(t, expectedErr, err.Error())
    97  		srv.Close()
    98  	}
    99  
   100  	assert.EqualValues(t, 3, called)
   101  }
   102  
   103  func TestAuthErrWithoutBody(t *testing.T) {
   104  	var called uint32
   105  	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   106  		if r.URL.String() != "/test" {
   107  			w.WriteHeader(http.StatusNotFound)
   108  			return
   109  		}
   110  
   111  		atomic.AddUint32(&called, 1)
   112  		w.WriteHeader(401)
   113  	}))
   114  	defer srv.Close()
   115  
   116  	req, err := http.NewRequest("GET", srv.URL+"/test", nil)
   117  	assert.Nil(t, err)
   118  
   119  	c, _ := NewClient(nil)
   120  	_, err = c.Do(req)
   121  	assert.NotNil(t, err)
   122  	assert.True(t, errors.IsAuthError(err))
   123  	assert.True(t, strings.HasPrefix(err.Error(), "Authentication required: Authorization error:"), err.Error())
   124  	assert.EqualValues(t, 1, called)
   125  }
   126  
   127  func TestFatalWithoutBody(t *testing.T) {
   128  	var called uint32
   129  	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   130  		if r.URL.String() != "/test" {
   131  			w.WriteHeader(http.StatusNotFound)
   132  			return
   133  		}
   134  
   135  		atomic.AddUint32(&called, 1)
   136  		w.WriteHeader(500)
   137  	}))
   138  	defer srv.Close()
   139  
   140  	req, err := http.NewRequest("GET", srv.URL+"/test", nil)
   141  	assert.Nil(t, err)
   142  
   143  	c, _ := NewClient(nil)
   144  	_, err = c.Do(req)
   145  	assert.NotNil(t, err)
   146  	assert.True(t, errors.IsFatalError(err))
   147  	assert.True(t, strings.HasPrefix(err.Error(), "Fatal error: Server error:"), err.Error())
   148  	assert.EqualValues(t, 1, called)
   149  }
   150  
   151  func TestWithNonFatal500WithoutBody(t *testing.T) {
   152  	c, _ := NewClient(nil)
   153  
   154  	var called uint32
   155  
   156  	nonFatalCodes := map[int]string{
   157  		501: "Not Implemented:",
   158  		507: "Insufficient server storage:",
   159  		509: "Bandwidth limit exceeded:",
   160  	}
   161  
   162  	for nonFatalCode, errPrefix := range nonFatalCodes {
   163  		srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   164  			if r.URL.String() != "/test" {
   165  				w.WriteHeader(http.StatusNotFound)
   166  				return
   167  			}
   168  
   169  			atomic.AddUint32(&called, 1)
   170  			w.WriteHeader(nonFatalCode)
   171  		}))
   172  
   173  		req, err := http.NewRequest("GET", srv.URL+"/test", nil)
   174  		assert.Nil(t, err)
   175  
   176  		_, err = c.Do(req)
   177  		t.Logf("non fatal code %d", nonFatalCode)
   178  		assert.NotNil(t, err)
   179  		assert.True(t, strings.HasPrefix(err.Error(), errPrefix))
   180  		srv.Close()
   181  	}
   182  
   183  	assert.EqualValues(t, 3, called)
   184  }