// TestDiscoverySecondPeerFirstNoResponse ensures that if the first etcd // machine stops after heartbeating that the second machine fails too. func TestDiscoverySecondPeerFirstNoResponse(t *testing.T) { etcdtest.RunServer(func(s *server.Server) { v := url.Values{} v.Set("value", "started") resp, err := etcdtest.PutForm(fmt.Sprintf("%s%s", s.URL(), "/v2/keys/_etcd/registry/2/_state"), v) assert.Equal(t, resp.StatusCode, http.StatusCreated) v = url.Values{} v.Set("value", "http://127.0.0.1:49151") resp, err = etcdtest.PutForm(fmt.Sprintf("%s%s", s.URL(), "/v2/keys/_etcd/registry/2/ETCDTEST"), v) assert.Equal(t, resp.StatusCode, http.StatusCreated) proc, err := startServer([]string{"-retry-interval", "0.2", "-discovery", s.URL() + "/v2/keys/_etcd/registry/2"}) if err != nil { t.Fatal(err.Error()) } defer stopServer(proc) // TODO(bp): etcd will take 30 seconds to shutdown, figure this // out instead time.Sleep(1 * time.Second) client := http.Client{} _, err = client.Get("/") if err != nil && strings.Contains(err.Error(), "connection reset by peer") { t.Fatal(err.Error()) } }) }
// Ensure that the store can create a new key if it doesn't already exist. func TestStoreCreateValue(t *testing.T) { s := newStore() // Create /foo=bar e, err := s.Create("/foo", false, "bar", false, Permanent) assert.Nil(t, err, "") assert.Equal(t, e.Action, "create", "") assert.Equal(t, e.Node.Key, "/foo", "") assert.False(t, e.Node.Dir, "") assert.Equal(t, e.Node.Value, "bar", "") assert.Nil(t, e.Node.Nodes, "") assert.Nil(t, e.Node.Expiration, "") assert.Equal(t, e.Node.TTL, 0, "") assert.Equal(t, e.Node.ModifiedIndex, uint64(1), "") // Create /empty="" e, err = s.Create("/empty", false, "", false, Permanent) assert.Nil(t, err, "") assert.Equal(t, e.Action, "create", "") assert.Equal(t, e.Node.Key, "/empty", "") assert.False(t, e.Node.Dir, "") assert.Equal(t, e.Node.Value, "", "") assert.Nil(t, e.Node.Nodes, "") assert.Nil(t, e.Node.Expiration, "") assert.Equal(t, e.Node.TTL, 0, "") assert.Equal(t, e.Node.ModifiedIndex, uint64(2), "") }
// Ensure that the store can watch for key expiration. func TestStoreWatchExpire(t *testing.T) { s := newStore() stopChan := make(chan bool) defer func() { stopChan <- true }() go mockSyncService(s.DeleteExpiredKeys, stopChan) s.Create("/foo", false, "bar", false, time.Now().Add(500*time.Millisecond)) s.Create("/foofoo", false, "barbarbar", false, time.Now().Add(500*time.Millisecond)) w, _ := s.Watch("/", true, false, 0) c := w.EventChan e := nbselect(c) assert.Nil(t, e, "") time.Sleep(600 * time.Millisecond) e = nbselect(c) assert.Equal(t, e.Action, "expire", "") assert.Equal(t, e.Node.Key, "/foo", "") w, _ = s.Watch("/", true, false, 4) e = nbselect(w.EventChan) assert.Equal(t, e.Action, "expire", "") assert.Equal(t, e.Node.Key, "/foofoo", "") }
// Ensure that the store can delete a directory if recursive is specified. func TestStoreDeleteDiretory(t *testing.T) { s := newStore() // create directory /foo s.Create("/foo", true, "", false, Permanent) // delete /foo with dir = true and recursive = false // this should succeed, since the directory is empty e, err := s.Delete("/foo", true, false) assert.Nil(t, err, "") assert.Equal(t, e.Action, "delete", "") // check pervNode assert.NotNil(t, e.PrevNode, "") assert.Equal(t, e.PrevNode.Key, "/foo", "") assert.Equal(t, e.PrevNode.Dir, true, "") // create directory /foo and directory /foo/bar s.Create("/foo/bar", true, "", false, Permanent) // delete /foo with dir = true and recursive = false // this should fail, since the directory is not empty _, err = s.Delete("/foo", true, false) assert.NotNil(t, err, "") // delete /foo with dir=false and recursive = true // this should succeed, since recursive implies dir=true // and recursively delete should be able to delete all // items under the given directory e, err = s.Delete("/foo", false, true) assert.Nil(t, err, "") assert.Equal(t, e.Action, "delete", "") }
// Ensure that the store can watch for recursive key creation. func TestStoreWatchRecursiveCreate(t *testing.T) { s := newStore() w, _ := s.Watch("/foo", true, false, 0) s.Create("/foo/bar", false, "baz", false, Permanent) e := nbselect(w.EventChan) assert.Equal(t, e.Action, "create", "") assert.Equal(t, e.Node.Key, "/foo/bar", "") }
// Ensure that the store can create a new directory if it doesn't already exist. func TestStoreCreateDirectory(t *testing.T) { s := newStore() e, err := s.Create("/foo", true, "", false, Permanent) assert.Nil(t, err, "") assert.Equal(t, e.Action, "create", "") assert.Equal(t, e.Node.Key, "/foo", "") assert.True(t, e.Node.Dir, "") }
// Ensure that the store can watch for key deletions. func TestStoreWatchDelete(t *testing.T) { s := newStore() s.Create("/foo", false, "bar", false, Permanent) w, _ := s.Watch("/foo", false, false, 0) s.Delete("/foo", false, false) e := nbselect(w.EventChan) assert.Equal(t, e.Action, "delete", "") assert.Equal(t, e.Node.Key, "/foo", "") }
// Ensure that the store cannot delete a directory if both of recursive // and dir are not specified. func TestStoreDeleteDiretoryFailsIfNonRecursiveAndDir(t *testing.T) { s := newStore() s.Create("/foo", true, "", false, Permanent) e, _err := s.Delete("/foo", false, false) err := _err.(*etcdErr.Error) assert.Equal(t, err.ErrorCode, etcdErr.EcodeNotFile, "") assert.Equal(t, err.Message, "Not a file", "") assert.Nil(t, e, "") }
// Ensure that the store can watch for CAS updates. func TestStoreWatchCompareAndSwap(t *testing.T) { s := newStore() s.Create("/foo", false, "bar", false, Permanent) w, _ := s.Watch("/foo", false, false, 0) s.CompareAndSwap("/foo", "bar", 0, "baz", Permanent) e := nbselect(w.EventChan) assert.Equal(t, e.Action, "compareAndSwap", "") assert.Equal(t, e.Node.Key, "/foo", "") }
func TestConfigDeprecatedPeerKeyFileFlag(t *testing.T) { _, stderr := capture(func() { c := New() err := c.LoadFlags([]string{"-serverKey", "/tmp/peer/file.key"}) assert.NoError(t, err) assert.Equal(t, c.Peer.KeyFile, "/tmp/peer/file.key", "") }) assert.Equal(t, stderr, "[deprecated] use -peer-key-file, not -serverKey\n", "") }
func TestConfigDeprecatedNameFlag(t *testing.T) { _, stderr := capture(func() { c := New() err := c.LoadFlags([]string{"-n", "test-name"}) assert.NoError(t, err) assert.Equal(t, c.Name, "test-name", "") }) assert.Equal(t, stderr, "[deprecated] use -name, not -n\n", "") }
func TestConfigDeprecatedMaxRetryAttemptsFlag(t *testing.T) { _, stderr := capture(func() { c := New() err := c.LoadFlags([]string{"-r", "10"}) assert.NoError(t, err) assert.Equal(t, c.MaxRetryAttempts, 10, "") }) assert.Equal(t, stderr, "[deprecated] use -max-retry-attempts, not -r\n", "") }
func TestConfigDeprecatedMaxClusterSizeFlag(t *testing.T) { _, stderr := capture(func() { c := New() err := c.LoadFlags([]string{"-maxsize", "5"}) assert.NoError(t, err) assert.Equal(t, c.MaxClusterSize, 5, "") }) assert.Equal(t, stderr, "[deprecated] use -max-cluster-size, not -maxsize\n", "") }
func TestConfigDeprecatedMaxResultBufferFlag(t *testing.T) { _, stderr := capture(func() { c := New() err := c.LoadFlags([]string{"-m", "512"}) assert.NoError(t, err) assert.Equal(t, c.MaxResultBuffer, 512, "") }) assert.Equal(t, stderr, "[deprecated] use -max-result-buffer, not -m\n", "") }
func TestConfigDeprecatedPeersFlag(t *testing.T) { _, stderr := capture(func() { c := New() err := c.LoadFlags([]string{"-C", "coreos.com:4001,coreos.com:4002"}) assert.NoError(t, err) assert.Equal(t, c.Peers, []string{"coreos.com:4001", "coreos.com:4002"}, "") }) assert.Equal(t, stderr, "[deprecated] use -peers, not -C\n", "") }
func TestConfigDeprecatedPeersFileFlag(t *testing.T) { _, stderr := capture(func() { c := New() err := c.LoadFlags([]string{"-CF", "/tmp/machines"}) assert.NoError(t, err) assert.Equal(t, c.PeersFile, "/tmp/machines", "") }) assert.Equal(t, stderr, "[deprecated] use -peers-file, not -CF\n", "") }
func TestConfigDeprecatedAddrFlag(t *testing.T) { _, stderr := capture(func() { c := New() err := c.LoadFlags([]string{"-c", "127.0.0.1:4002"}) assert.NoError(t, err) assert.Equal(t, c.Addr, "127.0.0.1:4002") }) assert.Equal(t, stderr, "[deprecated] use -addr, not -c\n") }
func TestConfigDeprecatedCertFileFlag(t *testing.T) { _, stderr := capture(func() { c := New() err := c.LoadFlags([]string{"-clientCert", "/tmp/file.cert"}) assert.NoError(t, err) assert.Equal(t, c.CertFile, "/tmp/file.cert", "") }) assert.Equal(t, stderr, "[deprecated] use -cert-file, not -clientCert\n", "") }
// Ensures that a directory is created // // $ curl -X PUT localhost:4001/v2/keys/foo/bar?dir=true // func TestV2SetDirectory(t *testing.T) { tests.RunServer(func(s *server.Server) { resp, err := tests.PutForm(fmt.Sprintf("%s%s", s.URL(), "/v2/keys/foo?dir=true"), url.Values{}) assert.Equal(t, resp.StatusCode, http.StatusCreated) body := tests.ReadBody(resp) assert.Nil(t, err, "") assert.Equal(t, string(body), `{"action":"set","node":{"key":"/foo","dir":true,"modifiedIndex":2,"createdIndex":2}}`, "") }) }
func TestConfigDeprecatedPeerBindAddrFlag(t *testing.T) { _, stderr := capture(func() { c := New() err := c.LoadFlags([]string{"-sl", "127.0.0.1:4003"}) assert.NoError(t, err) assert.Equal(t, c.Peer.BindAddr, "127.0.0.1:4003", "") }) assert.Equal(t, stderr, "[deprecated] use -peer-bind-addr, not -sl\n", "") }
// Ensure that the store can retrieve an existing value. func TestStoreGetValue(t *testing.T) { s := newStore() s.Create("/foo", false, "bar", false, Permanent) e, err := s.Get("/foo", false, false) assert.Nil(t, err, "") assert.Equal(t, e.Action, "get", "") assert.Equal(t, e.Node.Key, "/foo", "") assert.Equal(t, e.Node.Value, "bar", "") }
func TestConfigDeprecatedPeerAddrFlag(t *testing.T) { _, stderr := capture(func() { c := New() err := c.LoadFlags([]string{"-s", "localhost:7002"}) assert.NoError(t, err) assert.Equal(t, c.Peer.Addr, "localhost:7002", "") }) assert.Equal(t, stderr, "[deprecated] use -peer-addr, not -s\n", "") }
// Ensure that the store cannot update a directory. func TestStoreUpdateFailsIfDirectory(t *testing.T) { s := newStore() s.Create("/foo", true, "", false, Permanent) e, _err := s.Update("/foo", "baz", Permanent) err := _err.(*etcdErr.Error) assert.Equal(t, err.ErrorCode, etcdErr.EcodeNotFile, "") assert.Equal(t, err.Message, "Not a file", "") assert.Equal(t, err.Cause, "/foo", "") assert.Nil(t, e, "") }
// Ensure that the store can watch for hidden keys as long as it's an exact path match. func TestStoreWatchCreateWithHiddenKey(t *testing.T) { s := newStore() w, _ := s.Watch("/_foo", false, false, 0) s.Create("/_foo", false, "bar", false, Permanent) e := nbselect(w.EventChan) assert.Equal(t, e.Action, "create", "") assert.Equal(t, e.Node.Key, "/_foo", "") e = nbselect(w.EventChan) assert.Nil(t, e, "") }
// Ensure that the store can delete a value. func TestStoreDeleteValue(t *testing.T) { s := newStore() s.Create("/foo", false, "bar", false, Permanent) e, err := s.Delete("/foo", false, false) assert.Nil(t, err, "") assert.Equal(t, e.Action, "delete", "") // check pervNode assert.NotNil(t, e.PrevNode, "") assert.Equal(t, e.PrevNode.Key, "/foo", "") assert.Equal(t, e.PrevNode.Value, "bar", "") }
// Ensure that the store cannot conditionally update a key if it has the wrong previous index. func TestStoreCompareAndSwapPrevIndexFailsIfNotMatch(t *testing.T) { s := newStore() s.Create("/foo", false, "bar", false, Permanent) e, _err := s.CompareAndSwap("/foo", "", 100, "baz", Permanent) err := _err.(*etcdErr.Error) assert.Equal(t, err.ErrorCode, etcdErr.EcodeTestFailed, "") assert.Equal(t, err.Message, "Compare failed", "") assert.Nil(t, e, "") e, _ = s.Get("/foo", false, false) assert.Equal(t, e.Node.Value, "bar", "") }
// Ensures that a directory is deleted when recursive is set. // // $ curl -X PUT localhost:4001/v2/keys/foo?dir=true // $ curl -X DELETE localhost:4001/v2/keys/foo?recursive=true // func TestV2DeleteDirectoryRecursiveImpliesDir(t *testing.T) { tests.RunServer(func(s *server.Server) { resp, err := tests.PutForm(fmt.Sprintf("%s%s", s.URL(), "/v2/keys/foo?dir=true"), url.Values{}) tests.ReadBody(resp) resp, err = tests.DeleteForm(fmt.Sprintf("%s%s", s.URL(), "/v2/keys/foo?recursive=true"), url.Values{}) assert.Equal(t, resp.StatusCode, http.StatusOK) body := tests.ReadBody(resp) assert.Nil(t, err, "") assert.Equal(t, string(body), `{"action":"delete","node":{"key":"/foo","dir":true,"modifiedIndex":3,"createdIndex":2},"prevNode":{"key":"/foo","dir":true,"modifiedIndex":2,"createdIndex":2}}`, "") }) }
// Ensures that a key is set to a given value. // // $ curl -X PUT localhost:4001/v2/keys/foo/bar -d value=XXX // func TestV2SetKey(t *testing.T) { tests.RunServer(func(s *server.Server) { v := url.Values{} v.Set("value", "XXX") resp, err := tests.PutForm(fmt.Sprintf("%s%s", s.URL(), "/v2/keys/foo/bar"), v) assert.Equal(t, resp.StatusCode, http.StatusCreated) body := tests.ReadBody(resp) assert.Nil(t, err, "") assert.Equal(t, string(body), `{"action":"set","node":{"key":"/foo/bar","value":"XXX","modifiedIndex":2,"createdIndex":2}}`, "") }) }
// Ensures that a key is conditionally set if it previously did not exist. // // $ curl -X PUT localhost:4001/v2/keys/foo/bar -d value=XXX -d prevExist=false // func TestV2CreateKeySuccess(t *testing.T) { tests.RunServer(func(s *server.Server) { v := url.Values{} v.Set("value", "XXX") v.Set("prevExist", "false") resp, _ := tests.PutForm(fmt.Sprintf("%s%s", s.URL(), "/v2/keys/foo/bar"), v) assert.Equal(t, resp.StatusCode, http.StatusCreated) body := tests.ReadBodyJSON(resp) node := body["node"].(map[string]interface{}) assert.Equal(t, node["value"], "XXX", "") }) }
// TestDiscoverySecondPeerUp ensures that a second peer joining a discovery // cluster works. func TestDiscoverySecondPeerUp(t *testing.T) { etcdtest.RunServer(func(s *server.Server) { v := url.Values{} v.Set("value", "started") resp, err := etcdtest.PutForm(fmt.Sprintf("%s%s", s.URL(), "/v2/keys/_etcd/registry/3/_state"), v) assert.Equal(t, resp.StatusCode, http.StatusCreated) u, ok := s.PeerURL("ETCDTEST") if !ok { t.Fatalf("Couldn't find the URL") } wc := goetcd.NewClient([]string{s.URL()}) testResp, err := wc.Set("test", "0", 0) if err != nil { t.Fatalf("Couldn't set a test key on the leader %v", err) } v = url.Values{} v.Set("value", u) resp, err = etcdtest.PutForm(fmt.Sprintf("%s%s", s.URL(), "/v2/keys/_etcd/registry/3/ETCDTEST"), v) assert.Equal(t, resp.StatusCode, http.StatusCreated) proc, err := startServer([]string{"-discovery", s.URL() + "/v2/keys/_etcd/registry/3"}) if err != nil { t.Fatal(err.Error()) } defer stopServer(proc) watch := fmt.Sprintf("%s%s%d", s.URL(), "/v2/keys/_etcd/registry/3/node1?wait=true&waitIndex=", testResp.EtcdIndex) resp, err = http.Get(watch) if err != nil { t.Fatal(err.Error()) } // TODO(bp): need to have a better way of knowing a machine is up for i := 0; i < 10; i++ { time.Sleep(1 * time.Second) etcdc := goetcd.NewClient(nil) _, err = etcdc.Set("foobar", "baz", 0) if err == nil { break } } if err != nil { t.Fatal(err.Error()) } }) }