transport_test.go

package git

import (
"io"
"reflect"
"testing"
)

typetestSmartSubtransportstruct {
}

func (t*testSmartSubtransport) Action(urlstring, actionSmartServiceAction) (SmartSubtransportStream, error) {
return&testSmartSubtransportStream{}, nil
}

func (t*testSmartSubtransport) Close() error {
returnnil
}

func (t*testSmartSubtransport) Free() {
}

typetestSmartSubtransportStreamstruct {
}

func (s*testSmartSubtransportStream) Read(buf []byte) (int, error) {
payload:=""+
"001e# service=git-upload-pack\n"+
"0000005d0000000000000000000000000000000000000000 HEAD\x00symref=HEAD:refs/heads/master agent=libgit\n"+
"003f0000000000000000000000000000000000000000 refs/heads/master\n"+
"0000"

returncopy(buf, []byte(payload)), io.EOF
}

func (s*testSmartSubtransportStream) Write(buf []byte) (int, error) {
return0, io.EOF
}

func (s*testSmartSubtransportStream) Free() {
}

funcTestTransport(t*testing.T) {
t.Parallel()
repo:=createTestRepo(t)
defercleanupTestRepo(t, repo)

callback:=func(remote*Remote, transport*Transport) (SmartSubtransport, error) {
return&testSmartSubtransport{}, nil
 }
registeredSmartTransport, err:=NewRegisteredSmartTransport("foo", true, callback)
checkFatal(t, err)
deferregisteredSmartTransport.Free()

remote, err:=repo.Remotes.Create("test", "foo://bar")
checkFatal(t, err)
deferremote.Free()

err=remote.ConnectFetch(nil, nil, nil)
checkFatal(t, err)

remoteHeads, err:=remote.Ls()
checkFatal(t, err)

expectedRemoteHeads:= []RemoteHead{
 {&Oid{}, "HEAD"},
 {&Oid{}, "refs/heads/master"},
 }
if!reflect.DeepEqual(expectedRemoteHeads, remoteHeads) {
t.Errorf("mismatched remote heads. expected %v, got %v", expectedRemoteHeads, remoteHeads)
 }
}