vendor/github.com/go-kit/kit/sd/zk/integration_test.go

   1 // +build integration
   2
   3 package zk
   4
   5 import (
   6         "bytes"
   7         "log"
   8         "os"
   9         "testing"
  10         "time"
  11
  12         stdzk "github.com/samuel/go-zookeeper/zk"
  13 )
  14
  15 var (
  16         host []string
  17 )
  18
  19 func TestMain(m *testing.M) {
  20         zkAddr := os.Getenv("ZK_ADDR")
  21         if zkAddr == "" {
  22                 log.Fatal("ZK_ADDR is not set")
  23         }
  24         host = []string{zkAddr}
  25 }
  26
  27 func TestCreateParentNodesOnServer(t *testing.T) {
  28         payload := [][]byte{[]byte("Payload"), []byte("Test")}
  29         c1, err := NewClient(host, logger, Payload(payload))
  30         if err != nil {
  31                 t.Fatalf("Connect returned error: %v", err)
  32         }
  33         if c1 == nil {
  34                 t.Fatal("Expected pointer to client, got nil")
  35         }
  36         defer c1.Stop()
  37
  38         instancer, err := NewInstancer(c1, path, logger)
  39         if err != nil {
  40                 t.Fatalf("Unable to create Subscriber: %v", err)
  41         }
  42         defer instancer.Stop()
  43
  44         state := instancer.state()
  45         if state.Err != nil {
  46                 t.Fatal(err)
  47         }
  48         if want, have := 0, len(state.Instances); want != have {
  49                 t.Errorf("want %d, have %d", want, have)
  50         }
  51
  52         c2, err := NewClient(host, logger)
  53         if err != nil {
  54                 t.Fatalf("Connect returned error: %v", err)
  55         }
  56         defer c2.Stop()
  57         data, _, err := c2.(*client).Get(path)
  58         if err != nil {
  59                 t.Fatal(err)
  60         }
  61         // test Client implementation of CreateParentNodes. It should have created
  62         // our payload
  63         if bytes.Compare(data, payload[1]) != 0 {
  64                 t.Errorf("want %s, have %s", payload[1], data)
  65         }
  66
  67 }
  68
  69 func TestCreateBadParentNodesOnServer(t *testing.T) {
  70         c, _ := NewClient(host, logger)
  71         defer c.Stop()
  72
  73         _, err := NewInstancer(c, "invalid/path", logger)
  74
  75         if want, have := stdzk.ErrInvalidPath, err; want != have {
  76                 t.Errorf("want %v, have %v", want, have)
  77         }
  78 }
  79
  80 func TestCredentials1(t *testing.T) {
  81         acl := stdzk.DigestACL(stdzk.PermAll, "user", "secret")
  82         c, _ := NewClient(host, logger, ACL(acl), Credentials("user", "secret"))
  83         defer c.Stop()
  84
  85         _, err := NewInstancer(c, "/acl-issue-test", logger)
  86
  87         if err != nil {
  88                 t.Fatal(err)
  89         }
  90 }
  91
  92 func TestCredentials2(t *testing.T) {
  93         acl := stdzk.DigestACL(stdzk.PermAll, "user", "secret")
  94         c, _ := NewClient(host, logger, ACL(acl))
  95         defer c.Stop()
  96
  97         _, err := NewInstancer(c, "/acl-issue-test", logger)
  98
  99         if err != stdzk.ErrNoAuth {
 100                 t.Errorf("want %v, have %v", stdzk.ErrNoAuth, err)
 101         }
 102 }
 103
 104 func TestConnection(t *testing.T) {
 105         c, _ := NewClient(host, logger)
 106         c.Stop()
 107
 108         _, err := NewInstancer(c, "/acl-issue-test", logger)
 109
 110         if err != ErrClientClosed {
 111                 t.Errorf("want %v, have %v", ErrClientClosed, err)
 112         }
 113 }
 114
 115 func TestGetEntriesOnServer(t *testing.T) {
 116         var instancePayload = "10.0.3.204:8002"
 117
 118         c1, err := NewClient(host, logger)
 119         if err != nil {
 120                 t.Fatalf("Connect returned error: %v", err)
 121         }
 122
 123         defer c1.Stop()
 124
 125         c2, err := NewClient(host, logger)
 126         s, err := NewInstancer(c2, path, logger)
 127         if err != nil {
 128                 t.Fatal(err)
 129         }
 130         defer c2.Stop()
 131
 132         instance1 := &Service{
 133                 Path: path,
 134                 Name: "instance1",
 135                 Data: []byte(instancePayload),
 136         }
 137         if err = c2.Register(instance1); err != nil {
 138                 t.Fatalf("Unable to create test ephemeral znode 1: %+v", err)
 139         }
 140         instance2 := &Service{
 141                 Path: path,
 142                 Name: "instance2",
 143                 Data: []byte(instancePayload),
 144         }
 145         if err = c2.Register(instance2); err != nil {
 146                 t.Fatalf("Unable to create test ephemeral znode 2: %+v", err)
 147         }
 148
 149         time.Sleep(50 * time.Millisecond)
 150
 151         state := s.state()
 152         if state.Err != nil {
 153                 t.Fatal(state.Err)
 154         }
 155         if want, have := 2, len(state.Instances); want != have {
 156                 t.Errorf("want %d, have %d", want, have)
 157         }
 158 }
 159
 160 func TestGetEntriesPayloadOnServer(t *testing.T) {
 161         c, err := NewClient(host, logger)
 162         if err != nil {
 163                 t.Fatalf("Connect returned error: %v", err)
 164         }
 165         _, eventc, err := c.GetEntries(path)
 166         if err != nil {
 167                 t.Fatal(err)
 168         }
 169
 170         instance3 := Service{
 171                 Path: path,
 172                 Name: "instance3",
 173                 Data: []byte("just some payload"),
 174         }
 175         registrar := NewRegistrar(c, instance3, logger)
 176         registrar.Register()
 177         select {
 178         case event := <-eventc:
 179                 if want, have := stdzk.EventNodeChildrenChanged.String(), event.Type.String(); want != have {
 180                         t.Errorf("want %s, have %s", want, have)
 181                 }
 182         case <-time.After(100 * time.Millisecond):
 183                 t.Errorf("expected incoming watch event, timeout occurred")
 184         }
 185
 186         _, eventc, err = c.GetEntries(path)
 187         if err != nil {
 188                 t.Fatal(err)
 189         }
 190
 191         registrar.Deregister()
 192         select {
 193         case event := <-eventc:
 194                 if want, have := stdzk.EventNodeChildrenChanged.String(), event.Type.String(); want != have {
 195                         t.Errorf("want %s, have %s", want, have)
 196                 }
 197         case <-time.After(100 * time.Millisecond):
 198                 t.Errorf("expected incoming watch event, timeout occurred")
 199         }
 200
 201 }