code.gitea.io/gitea@v1.22.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, AcceptHeader, 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  		}
    66  		t.Errorf("Unknown test case: %s", url)
    67  		return nil
    68  	}
    69  
    70  	hc := &http.Client{Transport: RoundTripFunc(roundTripHandler)}
    71  	a := &BasicTransferAdapter{hc}
    72  
    73  	t.Run("Download", func(t *testing.T) {
    74  		cases := []struct {
    75  			link          *Link
    76  			expectederror string
    77  		}{
    78  			// case 0
    79  			{
    80  				link: &Link{
    81  					Href:   "https://download-request.io",
    82  					Header: map[string]string{"test-header": "test-value"},
    83  				},
    84  				expectederror: "",
    85  			},
    86  			// case 1
    87  			{
    88  				link: &Link{
    89  					Href:   "https://error-response.io",
    90  					Header: map[string]string{"test-header": "test-value"},
    91  				},
    92  				expectederror: "Object not found",
    93  			},
    94  		}
    95  
    96  		for n, c := range cases {
    97  			_, err := a.Download(context.Background(), c.link)
    98  			if len(c.expectederror) > 0 {
    99  				assert.True(t, strings.Contains(err.Error(), c.expectederror), "case %d: '%s' should contain '%s'", n, err.Error(), c.expectederror)
   100  			} else {
   101  				assert.NoError(t, err, "case %d", n)
   102  			}
   103  		}
   104  	})
   105  
   106  	t.Run("Upload", func(t *testing.T) {
   107  		cases := []struct {
   108  			link          *Link
   109  			expectederror string
   110  		}{
   111  			// case 0
   112  			{
   113  				link: &Link{
   114  					Href:   "https://upload-request.io",
   115  					Header: map[string]string{"test-header": "test-value"},
   116  				},
   117  				expectederror: "",
   118  			},
   119  			// case 1
   120  			{
   121  				link: &Link{
   122  					Href:   "https://error-response.io",
   123  					Header: map[string]string{"test-header": "test-value"},
   124  				},
   125  				expectederror: "Object not found",
   126  			},
   127  		}
   128  
   129  		for n, c := range cases {
   130  			err := a.Upload(context.Background(), c.link, p, bytes.NewBufferString("dummy"))
   131  			if len(c.expectederror) > 0 {
   132  				assert.True(t, strings.Contains(err.Error(), c.expectederror), "case %d: '%s' should contain '%s'", n, err.Error(), c.expectederror)
   133  			} else {
   134  				assert.NoError(t, err, "case %d", n)
   135  			}
   136  		}
   137  	})
   138  
   139  	t.Run("Verify", func(t *testing.T) {
   140  		cases := []struct {
   141  			link          *Link
   142  			expectederror string
   143  		}{
   144  			// case 0
   145  			{
   146  				link: &Link{
   147  					Href:   "https://verify-request.io",
   148  					Header: map[string]string{"test-header": "test-value"},
   149  				},
   150  				expectederror: "",
   151  			},
   152  			// case 1
   153  			{
   154  				link: &Link{
   155  					Href:   "https://error-response.io",
   156  					Header: map[string]string{"test-header": "test-value"},
   157  				},
   158  				expectederror: "Object not found",
   159  			},
   160  		}
   161  
   162  		for n, c := range cases {
   163  			err := a.Verify(context.Background(), c.link, p)
   164  			if len(c.expectederror) > 0 {
   165  				assert.True(t, strings.Contains(err.Error(), c.expectederror), "case %d: '%s' should contain '%s'", n, err.Error(), c.expectederror)
   166  			} else {
   167  				assert.NoError(t, err, "case %d", n)
   168  			}
   169  		}
   170  	})
   171  }