func TestServer(t *testing.T) {
l := sockets.NewInmemSocket("test", 1)
testDialers[l.Addr().String()] = l.Dial
handlers := map[byte]Handler{
'1': newTestHandler(l.Addr(), '1'),
'2': newTestHandler(l.Addr(), '2'),
}
srv := NewServer(l, handlers)
defer srv.Close()
for msgType := range handlers {
conn, err := l.Dial("test", "test")
if err != nil {
t.Fatal(err)
}
defer conn.Close()
if _, err := conn.Write([]byte{byte(msgType)}); err != nil {
t.Fatal(err)
}
// the test handler just writes out the message type it uses, so let's read and compare to what we're expecting
buf := make([]byte, 1)
if _, err := conn.Read(buf); err != nil {
t.Fatal(err)
}
if buf[0] != byte(msgType) {
t.Fatalf("expected conn from %q, got %q", msgType, buf[0])
}
}
}
func newTestCluster(size int, prefixAddr string) ([]*drax.Cluster, error) {
var nodes []*drax.Cluster
for i := 0; i < size; i++ {
addr := prefixAddr + strconv.Itoa(i)
home, err := ioutil.TempDir("", addr)
if err != nil {
return nil, err
}
l := sockets.NewInmemSocket(addr, 1)
clusterDialers[addr] = l.Dial
dialer := func(addr string, timeout time.Duration) (net.Conn, error) {
h, ok := clusterDialers[addr]
if !ok {
return nil, fmt.Errorf("unreachable")
}
return h("inmem", addr)
}
var peer string
if i > 0 {
peer = nodes[i-1].Addr()
}
c, err := drax.New(l, dialer, home, addr, peer, nil)
if err != nil {
return nil, err
}
nodes = append(nodes, c)
}
return nodes, nil
}
func TestVolumeDriver(t *testing.T) {
h := NewHandlerFromVolumeDriver(testVolumeDriver{})
l := sockets.NewInmemSocket("test", 0)
go h.Serve(l)
defer l.Close()
client := &http.Client{Transport: &http.Transport{
Dial: l.Dial,
}}
resp, err := pluginRequest(client, "/VolumeDriver.Create", volumeplugin.Request{Name: "foo"})
if err != nil {
t.Fatal(err)
}
if resp.Err != "" {
t.Fatalf("error while creating volume: %v", err)
}
}
func TestHandler(t *testing.T) {
p := &testPlugin{}
h := NewHandler(p)
l := sockets.NewInmemSocket("test", 0)
go h.Serve(l)
defer l.Close()
client := &http.Client{Transport: &http.Transport{
Dial: l.Dial,
}}
// Create
resp, err := pluginRequest(client, createPath, Request{Name: "foo"})
if err != nil {
t.Fatal(err)
}
if resp.Err != "" {
t.Fatalf("error while creating volume: %v", err)
}
if p.create != 1 {
t.Fatalf("expected create 1, got %d", p.create)
}
// Get
resp, err = pluginRequest(client, getPath, Request{Name: "foo"})
if err != nil {
t.Fatal(err)
}
if resp.Err != "" {
t.Fatalf("got error getting volume: %s", resp.Err)
}
if resp.Volume.Name != "foo" {
t.Fatalf("expected volume `foo`, got %v", resp.Volume)
}
if p.get != 1 {
t.Fatalf("expected get 1, got %d", p.get)
}
// List
resp, err = pluginRequest(client, listPath, Request{Name: "foo"})
if err != nil {
t.Fatal(err)
}
if resp.Err != "" {
t.Fatalf("expected no volume, got: %s", resp.Err)
}
if len(resp.Volumes) != 1 {
t.Fatalf("expected 1 volume, got %v", resp.Volumes)
}
if resp.Volumes[0].Name != "foo" {
t.Fatalf("expected volume `foo`, got %v", resp.Volumes[0])
}
if p.list != 1 {
t.Fatalf("expected list 1, got %d", p.list)
}
// Path
if _, err := pluginRequest(client, hostVirtualPath, Request{Name: "foo"}); err != nil {
t.Fatal(err)
}
if p.path != 1 {
t.Fatalf("expected path 1, got %d", p.path)
}
// Mount
if _, err := pluginRequest(client, mountPath, Request{Name: "foo"}); err != nil {
t.Fatal(err)
}
if p.mount != 1 {
t.Fatalf("expected mount 1, got %d", p.mount)
}
// Unmount
if _, err := pluginRequest(client, unmountPath, Request{Name: "foo"}); err != nil {
t.Fatal(err)
}
if p.unmount != 1 {
t.Fatalf("expected unmount 1, got %d", p.unmount)
}
// Remove
resp, err = pluginRequest(client, removePath, Request{Name: "foo"})
if err != nil {
t.Fatal(err)
}
if resp.Err != "" {
t.Fatalf("got error removing volume: %s", resp.Err)
}
if p.remove != 1 {
t.Fatalf("expected remove 1, got %d", p.remove)
}
// Capabilities
resp, err = pluginRequest(client, capabilitiesPath, Request{})
if err != nil {
t.Fatal(err)
}
if resp.Err != "" {
t.Fatalf("got error removing volume: %s", resp.Err)
}
if p.capabilities != 1 {
t.Fatalf("expected remove 1, got %d", p.capabilities)
}
}
