lib9p

Go 9P library.
Log | Files | Refs | LICENSE

client_test.go (3631B)

      1 package lib9p
      2 
      3 import (
      4 	"context"
      5 	"io"
      6 	"sync"
      7 	"testing"
      8 )
      9 
     10 const (
     11 	mSize = 8192
     12 	uname = "kenji"
     13 )
     14 
     15 func newClientForTest(msize uint32, uname string, tmsgc chan<- Msg, rmsgc <-chan Msg) *Client {
     16 	ctx, cancel := context.WithCancel(context.Background())
     17 	c := &Client{
     18 		msize:     mSize,
     19 		mSizeLock: new(sync.Mutex),
     20 		uname:     uname,
     21 		fPool:     allocClientFidPool(),
     22 		errc:      make(chan error),
     23 		cancel:    cancel,
     24 		wg:        new(sync.WaitGroup),
     25 	}
     26 	c.txc = c.runMultiplexer(ctx, tmsgc, rmsgc)
     27 	return c
     28 }
     29 
     30 func TestClientVersion(t *testing.T) {
     31 	tests := []struct {
     32 		name        string
     33 		mSize       uint32
     34 		version     string
     35 		rmsg        Msg
     36 		wantmsize   uint32
     37 		wantversion string
     38 	}{
     39 		{"0", mSize, "9P2000",
     40 			&RVersion{tag: NOTAG, mSize: mSize, version: "9P2000"},
     41 			mSize, "9P2000"},
     42 		{"1", mSize, "unko",
     43 			&RVersion{tag: NOTAG, mSize: mSize, version: "unknown"},
     44 			mSize, "unknown"},
     45 	}
     46 	for _, test := range tests {
     47 		func() {
     48 			tmsgc := make(chan Msg)
     49 			rmsgc := make(chan Msg)
     50 			c := newClientForTest(mSize, uname, tmsgc, rmsgc)
     51 			tPool := newTagPool()
     52 			defer c.Stop()
     53 			bg := context.Background()
     54 			var (
     55 				gotmsize   uint32
     56 				gotversion string
     57 				goterr     error
     58 				wg         sync.WaitGroup
     59 			)
     60 			wg.Add(1)
     61 			go func() {
     62 				tag, err := tPool.add()
     63 				if err != nil {
     64 					t.Fatalf("add tag: %v", err)
     65 				}
     66 				gotmsize, gotversion, goterr = c.Version(bg, tag, test.mSize, test.version)
     67 				tPool.delete(tag)
     68 				wg.Done()
     69 			}()
     70 			gottmsg := <-tmsgc
     71 			tag := gottmsg.Tag()
     72 			test.rmsg.SetTag(tag)
     73 			rmsgc <- test.rmsg
     74 			done := make(chan struct{})
     75 			go func() { wg.Wait(); done <- struct{}{} }()
     76 			select {
     77 			case err := <-c.errc:
     78 				t.Errorf("client error: %v", err)
     79 				return
     80 			case <-done:
     81 			}
     82 			if goterr != nil {
     83 				t.Errorf("%s: goterr: %v", test.name, goterr)
     84 				return
     85 			}
     86 			if test.wantmsize != gotmsize || test.wantversion != gotversion {
     87 				t.Errorf("%s: (mSize, verion) want: %d, %s, got: %d, %s",
     88 					test.name, test.wantmsize, test.wantversion,
     89 					gotmsize, gotversion)
     90 			}
     91 		}()
     92 	}
     93 }
     94 
     95 // the following tests are test for both client and server.
     96 // should be moved to propper file.
     97 func TestTransaction(t *testing.T) {
     98 	cr, sw := io.Pipe()
     99 	sr, cw := io.Pipe()
    100 
    101 	server := NewServer(fsys, mSize, sr, sw)
    102 	//server.Chatty()
    103 	client := NewClient(mSize, uname, cr, cw)
    104 	tPool := newTagPool()
    105 	bg := context.Background()
    106 	go server.Serve(bg)
    107 	tag, err := tPool.add()
    108 	if err != nil {
    109 		t.Fatalf("add tag: %v", err)
    110 	}
    111 	rmsize, rversion, err := client.Version(bg, tag, mSize, "9P2000")
    112 	tPool.delete(tag)
    113 	if err != nil {
    114 		t.Log(err)
    115 	} else {
    116 		t.Log(&RVersion{mSize: rmsize, version: rversion})
    117 	}
    118 	tag, err = tPool.add()
    119 	if err != nil {
    120 		t.Fatalf("add tag: %v", err)
    121 	}
    122 	rauth, err := client.Auth(bg, tag, 0, "kenji", "")
    123 	tPool.delete(tag)
    124 	if err != nil {
    125 		t.Log(err)
    126 	} else {
    127 		t.Log(rauth)
    128 	}
    129 	tag, err = tPool.add()
    130 	if err != nil {
    131 		t.Fatalf("add tag: %v", err)
    132 	}
    133 	rattach, err := client.Attach(bg, tag, 0, NOFID, "kenji", "")
    134 	tPool.delete(tag)
    135 	if err != nil {
    136 		t.Log(err)
    137 	} else {
    138 		t.Log(rattach)
    139 	}
    140 }
    141 
    142 func TestClient2(t *testing.T) {
    143 	cr, sw := io.Pipe()
    144 	sr, cw := io.Pipe()
    145 
    146 	server := NewServer(fsys, mSize, sr, sw)
    147 	//server.Chatty()
    148 	go server.Serve(context.Background())
    149 
    150 	fs, err := Mount(cr, cw, "kenji", "")
    151 	if err != nil {
    152 		t.Errorf("mount: %v", err)
    153 	}
    154 
    155 	a0, err := fs.OpenFile("a", OREAD, 0)
    156 	if err != nil {
    157 		t.Errorf("open: %v", err)
    158 	}
    159 	t.Log(a0)
    160 	a := a0.(*ClientFile)
    161 
    162 	b := make([]byte, a.iounit)
    163 	n, err := a.Read(b)
    164 	if err != nil {
    165 		t.Errorf("read: %v", err)
    166 	}
    167 	t.Log(string(b[:n]))
    168 }