code.gitea.io/gitea@v1.19.3/modules/lfs/transferadapter_test.go (about)

     1  // Copyright 2021 The Gitea Authors. All rights reserved.
     2  // SPDX-License-Identifier: MIT
     3  
     4  package lfs
     5  
     6  import (
     7  	"bytes"
     8  	"context"
     9  	"io"
    10  	"net/http"
    11  	"strings"
    12  	"testing"
    13  
    14  	"code.gitea.io/gitea/modules/json"
    15  
    16  	"github.com/stretchr/testify/assert"
    17  )
    18  
    19  func TestBasicTransferAdapterName(t *testing.T) {
    20  	a := &BasicTransferAdapter{}
    21  
    22  	assert.Equal(t, "basic", a.Name())
    23  }
    24  
    25  func TestBasicTransferAdapter(t *testing.T) {
    26  	p := Pointer{Oid: "b5a2c96250612366ea272ffac6d9744aaf4b45aacd96aa7cfcb931ee3b558259", Size: 5}
    27  
    28  	roundTripHandler := func(req *http.Request) *http.Response {
    29  		assert.Equal(t, MediaType, req.Header.Get("Accept"))
    30  		assert.Equal(t, "test-value", req.Header.Get("test-header"))
    31  
    32  		url := req.URL.String()
    33  		if strings.Contains(url, "download-request") {
    34  			assert.Equal(t, "GET", req.Method)
    35  
    36  			return &http.Response{StatusCode: http.StatusOK, Body: io.NopCloser(bytes.NewBufferString("dummy"))}
    37  		} else if strings.Contains(url, "upload-request") {
    38  			assert.Equal(t, "PUT", req.Method)
    39  			assert.Equal(t, "application/octet-stream", req.Header.Get("Content-Type"))
    40  
    41  			b, err := io.ReadAll(req.Body)
    42  			assert.NoError(t, err)
    43  			assert.Equal(t, "dummy", string(b))
    44  
    45  			return &http.Response{StatusCode: http.StatusOK}
    46  		} else if strings.Contains(url, "verify-request") {
    47  			assert.Equal(t, "POST", req.Method)
    48  			assert.Equal(t, MediaType, req.Header.Get("Content-Type"))
    49  
    50  			var vp Pointer
    51  			err := json.NewDecoder(req.Body).Decode(&vp)
    52  			assert.NoError(t, err)
    53  			assert.Equal(t, p.Oid, vp.Oid)
    54  			assert.Equal(t, p.Size, vp.Size)
    55  
    56  			return &http.Response{StatusCode: http.StatusOK}
    57  		} else if strings.Contains(url, "error-response") {
    58  			er := &ErrorResponse{
    59  				Message: "Object not found",
    60  			}
    61  			payload := new(bytes.Buffer)
    62  			json.NewEncoder(payload).Encode(er)
    63  
    64  			return &http.Response{StatusCode: http.StatusNotFound, Body: io.NopCloser(payload)}
    65  		} else {
    66  			t.Errorf("Unknown test case: %s", url)
    67  			return nil
    68  		}
    69  	}
    70  
    71  	hc := &http.Client{Transport: RoundTripFunc(roundTripHandler)}
    72  	a := &BasicTransferAdapter{hc}
    73  
    74  	t.Run("Download", func(t *testing.T) {
    75  		cases := []struct {
    76  			link          *Link
    77  			expectederror string
    78  		}{
    79  			// case 0
    80  			{
    81  				link: &Link{
    82  					Href:   "https://download-request.io",
    83  					Header: map[string]string{"test-header": "test-value"},
    84  				},
    85  				expectederror: "",
    86  			},
    87  			// case 1
    88  			{
    89  				link: &Link{
    90  					Href:   "https://error-response.io",
    91  					Header: map[string]string{"test-header": "test-value"},
    92  				},
    93  				expectederror: "Object not found",
    94  			},
    95  		}
    96  
    97  		for n, c := range cases {
    98  			_, err := a.Download(context.Background(), c.link)
    99  			if len(c.expectederror) > 0 {
   100  				assert.True(t, strings.Contains(err.Error(), c.expectederror), "case %d: '%s' should contain '%s'", n, err.Error(), c.expectederror)
   101  			} else {
   102  				assert.NoError(t, err, "case %d", n)
   103  			}
   104  		}
   105  	})
   106  
   107  	t.Run("Upload", func(t *testing.T) {
   108  		cases := []struct {
   109  			link          *Link
   110  			expectederror string
   111  		}{
   112  			// case 0
   113  			{
   114  				link: &Link{
   115  					Href:   "https://upload-request.io",
   116  					Header: map[string]string{"test-header": "test-value"},
   117  				},
   118  				expectederror: "",
   119  			},
   120  			// case 1
   121  			{
   122  				link: &Link{
   123  					Href:   "https://error-response.io",
   124  					Header: map[string]string{"test-header": "test-value"},
   125  				},
   126  				expectederror: "Object not found",
   127  			},
   128  		}
   129  
   130  		for n, c := range cases {
   131  			err := a.Upload(context.Background(), c.link, p, bytes.NewBufferString("dummy"))
   132  			if len(c.expectederror) > 0 {
   133  				assert.True(t, strings.Contains(err.Error(), c.expectederror), "case %d: '%s' should contain '%s'", n, err.Error(), c.expectederror)
   134  			} else {
   135  				assert.NoError(t, err, "case %d", n)
   136  			}
   137  		}
   138  	})
   139  
   140  	t.Run("Verify", func(t *testing.T) {
   141  		cases := []struct {
   142  			link          *Link
   143  			expectederror string
   144  		}{
   145  			// case 0
   146  			{
   147  				link: &Link{
   148  					Href:   "https://verify-request.io",
   149  					Header: map[string]string{"test-header": "test-value"},
   150  				},
   151  				expectederror: "",
   152  			},
   153  			// case 1
   154  			{
   155  				link: &Link{
   156  					Href:   "https://error-response.io",
   157  					Header: map[string]string{"test-header": "test-value"},
   158  				},
   159  				expectederror: "Object not found",
   160  			},
   161  		}
   162  
   163  		for n, c := range cases {
   164  			err := a.Verify(context.Background(), c.link, p)
   165  			if len(c.expectederror) > 0 {
   166  				assert.True(t, strings.Contains(err.Error(), c.expectederror), "case %d: '%s' should contain '%s'", n, err.Error(), c.expectederror)
   167  			} else {
   168  				assert.NoError(t, err, "case %d", n)
   169  			}
   170  		}
   171  	})
   172  }