github.com/psexton/git-lfs@v2.1.1-0.20170517224304-289a18b2bc53+incompatible/git/filter_process_scanner_test.go (about)

     1  package git
     2  
     3  import (
     4  	"bytes"
     5  	"io/ioutil"
     6  	"testing"
     7  
     8  	"github.com/stretchr/testify/assert"
     9  	"github.com/stretchr/testify/require"
    10  )
    11  
    12  func TestFilterProcessScannerInitializesWithCorrectSupportedValues(t *testing.T) {
    13  	var from, to bytes.Buffer
    14  
    15  	pl := newPktline(nil, &from)
    16  	if err := pl.writePacketText("git-filter-client"); err != nil {
    17  		t.Fatalf("expected... %v", err.Error())
    18  	}
    19  
    20  	require.Nil(t, pl.writePacketText("git-filter-client"))
    21  	require.Nil(t, pl.writePacketList([]string{"version=2"}))
    22  
    23  	fps := NewFilterProcessScanner(&from, &to)
    24  	err := fps.Init()
    25  
    26  	assert.Nil(t, err)
    27  
    28  	out, err := newPktline(&to, nil).readPacketList()
    29  	assert.Nil(t, err)
    30  	assert.Equal(t, []string{"git-filter-server", "version=2"}, out)
    31  }
    32  
    33  func TestFilterProcessScannerRejectsUnrecognizedInitializationMessages(t *testing.T) {
    34  	var from, to bytes.Buffer
    35  
    36  	pl := newPktline(nil, &from)
    37  	require.Nil(t, pl.writePacketText("git-filter-client-unknown"))
    38  	require.Nil(t, pl.writeFlush())
    39  
    40  	fps := NewFilterProcessScanner(&from, &to)
    41  	err := fps.Init()
    42  
    43  	require.NotNil(t, err)
    44  	assert.Equal(t, "invalid filter-process pkt-line welcome message: git-filter-client-unknown", err.Error())
    45  	assert.Empty(t, to.Bytes())
    46  }
    47  
    48  func TestFilterProcessScannerRejectsUnsupportedFilters(t *testing.T) {
    49  	var from, to bytes.Buffer
    50  
    51  	pl := newPktline(nil, &from)
    52  	require.Nil(t, pl.writePacketText("git-filter-client"))
    53  	// Write an unsupported version
    54  	require.Nil(t, pl.writePacketList([]string{"version=0"}))
    55  
    56  	fps := NewFilterProcessScanner(&from, &to)
    57  	err := fps.Init()
    58  
    59  	require.NotNil(t, err)
    60  	assert.Equal(t, "filter 'version=2' not supported (your Git supports: [version=0])", err.Error())
    61  	assert.Empty(t, to.Bytes())
    62  }
    63  
    64  func TestFilterProcessScannerNegotitatesSupportedCapabilities(t *testing.T) {
    65  	var from, to bytes.Buffer
    66  
    67  	pl := newPktline(nil, &from)
    68  	require.Nil(t, pl.writePacketList([]string{
    69  		"capability=clean", "capability=smudge", "capability=not-invented-yet",
    70  	}))
    71  
    72  	fps := NewFilterProcessScanner(&from, &to)
    73  	err := fps.NegotiateCapabilities()
    74  
    75  	assert.Nil(t, err)
    76  
    77  	out, err := newPktline(&to, nil).readPacketList()
    78  	assert.Nil(t, err)
    79  	assert.Equal(t, []string{"capability=clean", "capability=smudge"}, out)
    80  }
    81  
    82  func TestFilterProcessScannerDoesNotNegotitatesUnsupportedCapabilities(t *testing.T) {
    83  	var from, to bytes.Buffer
    84  
    85  	pl := newPktline(nil, &from)
    86  	// Write an unsupported capability
    87  	require.Nil(t, pl.writePacketList([]string{
    88  		"capability=unsupported",
    89  	}))
    90  
    91  	fps := NewFilterProcessScanner(&from, &to)
    92  	err := fps.NegotiateCapabilities()
    93  
    94  	require.NotNil(t, err)
    95  	assert.Equal(t, "filter 'capability=clean' not supported (your Git supports: [capability=unsupported])", err.Error())
    96  	assert.Empty(t, to.Bytes())
    97  }
    98  
    99  func TestFilterProcessScannerReadsRequestHeadersAndPayload(t *testing.T) {
   100  	var from, to bytes.Buffer
   101  
   102  	pl := newPktline(nil, &from)
   103  	// Headers
   104  	require.Nil(t, pl.writePacketList([]string{
   105  		"foo=bar", "other=woot", "crazy='sq',\\$x=.bin",
   106  	}))
   107  	// Multi-line packet
   108  	require.Nil(t, pl.writePacketText("first"))
   109  	require.Nil(t, pl.writePacketText("second"))
   110  	require.Nil(t, pl.writeFlush())
   111  
   112  	req, err := readRequest(NewFilterProcessScanner(&from, &to))
   113  
   114  	assert.Nil(t, err)
   115  	assert.Equal(t, req.Header["foo"], "bar")
   116  	assert.Equal(t, req.Header["other"], "woot")
   117  	assert.Equal(t, req.Header["crazy"], "'sq',\\$x=.bin")
   118  
   119  	payload, err := ioutil.ReadAll(req.Payload)
   120  	assert.Nil(t, err)
   121  	assert.Equal(t, []byte("first\nsecond\n"), payload)
   122  }
   123  
   124  func TestFilterProcessScannerRejectsInvalidHeaderPackets(t *testing.T) {
   125  	from := bytes.NewBuffer([]byte{
   126  		0x30, 0x30, 0x30, 0x34, // 0004 (invalid packet length)
   127  	})
   128  
   129  	req, err := readRequest(NewFilterProcessScanner(from, nil))
   130  
   131  	require.NotNil(t, err)
   132  	assert.Equal(t, "Invalid packet length.", err.Error())
   133  
   134  	assert.Nil(t, req)
   135  }
   136  
   137  // readRequest performs a single scan operation on the given
   138  // `*FilterProcessScanner`, "s", and returns: an error if there was one, or a
   139  // request if there was one.  If neither, it returns (nil, nil).
   140  func readRequest(s *FilterProcessScanner) (*Request, error) {
   141  	s.Scan()
   142  
   143  	if err := s.Err(); err != nil {
   144  		return nil, err
   145  	}
   146  
   147  	return s.Request(), nil
   148  }