update test

file_system/file_system.go

@@ -65,57 +65,13 @@ func (fs *FileSystem) Get(keyPath string, recusive bool, index uint64, term uint
 	return e, nil
 }
 
-func (fs *FileSystem) Update(keyPath string, value string, expireTime time.Time, index uint64, term uint64) (*Event, error) {
-	n, err := fs.InternalGet(keyPath, index, term)
-
-	if err != nil { // if node does not exist, return error
-		return nil, err
-	}
-
-	e := newEvent(Set, keyPath, fs.Index, fs.Term)
-
-	if n.IsDir() { // if the node is a directory, we can only update ttl
-
-		if len(value) != 0 {
-			return nil, etcdErr.NewError(102, keyPath)
-		}
-
-		if n.ExpireTime != Permanent && expireTime != Permanent {
-			n.stopExpire <- true
-		}
-
-	} else { // if the node is a file, we can update value and ttl
-		e.PrevValue = n.Value
-
-		if len(value) != 0 {
-			e.Value = value
-		}
-
-		n.Write(value, index, term)
-
-		if n.ExpireTime != Permanent && expireTime != Permanent {
-			n.stopExpire <- true
-		}
-
-	}
-
-	// update ttl
-	if expireTime != Permanent {
-		go n.Expire()
-		e.Expiration = &n.ExpireTime
-		e.TTL = int64(expireTime.Sub(time.Now()) / time.Second)
-	}
-
-	return e, nil
-}
-
-func (fs *FileSystem) Create(keyPath string, value string, expireTime time.Time, create bool, index uint64, term uint64) (*Event, error) {
+func (fs *FileSystem) Create(keyPath string, value string, expireTime time.Time, index uint64, term uint64) (*Event, error) {
 	keyPath = path.Clean("/" + keyPath)
 
 	// make sure we can create the node
 	_, err := fs.InternalGet(keyPath, index, term)
 
-	if err != nil { // key already exists
+	if err == nil { // key already exists
 		return nil, etcdErr.NewError(105, keyPath)
 	}
 
@@ -155,6 +111,50 @@ func (fs *FileSystem) Create(keyPath string, value string, expireTime time.Time,
 	return e, nil
 }
 
+func (fs *FileSystem) Update(keyPath string, value string, expireTime time.Time, index uint64, term uint64) (*Event, error) {
+	n, err := fs.InternalGet(keyPath, index, term)
+
+	if err != nil { // if node does not exist, return error
+		return nil, err
+	}
+
+	e := newEvent(Set, keyPath, fs.Index, fs.Term)
+
+	if n.IsDir() { // if the node is a directory, we can only update ttl
+
+		if len(value) != 0 {
+			return nil, etcdErr.NewError(102, keyPath)
+		}
+
+		if n.ExpireTime != Permanent && expireTime != Permanent {
+			n.stopExpire <- true
+		}
+
+	} else { // if the node is a file, we can update value and ttl
+		e.PrevValue = n.Value
+
+		if len(value) != 0 {
+			e.Value = value
+		}
+
+		n.Write(value, index, term)
+
+		if n.ExpireTime != Permanent && expireTime != Permanent {
+			n.stopExpire <- true
+		}
+
+	}
+
+	// update ttl
+	if expireTime != Permanent {
+		go n.Expire()
+		e.Expiration = &n.ExpireTime
+		e.TTL = int64(expireTime.Sub(time.Now()) / time.Second)
+	}
+
+	return e, nil
+}
+
 func (fs *FileSystem) TestAndSet(keyPath string, prevValue string, prevIndex uint64, value string, expireTime time.Time, index uint64, term uint64) (*Event, error) {
 	f, err := fs.InternalGet(keyPath, index, term)
 

file_system/file_system_test.go

@@ -5,26 +5,43 @@ import (
 	"time"
 )
 
-func TestSetAndGet(t *testing.T) {
+func TestCreateAndGet(t *testing.T) {
 	fs := New()
-	setAndGet(fs, "/foobar", t)
-	setAndGet(fs, "/foo/bar", t)
-	setAndGet(fs, "/foo/foo/bar", t)
+
+	// this should create successfully
+	createAndGet(fs, "/foobar", t)
+	createAndGet(fs, "/foo/bar", t)
+	createAndGet(fs, "/foo/foo/bar", t)
+
+	// already exist, create should fail
+	_, err := fs.Create("/foobar", "bar", Permanent, 1, 1)
+
+	if err == nil {
+		t.Fatal("Create should fail")
+	}
+
+	// meet file, create should fail
+	_, err = fs.Create("/foo/bar/bar", "bar", Permanent, 1, 1)
+
+	if err == nil {
+		t.Fatal("Create should fail")
+	}
+
 }
 
 func TestUpdateFile(t *testing.T) {
 	fs := New()
 
-	_, err := fs.Set("/foo/bar", "bar", Permanent, 1, 1)
+	_, err := fs.Create("/foo/bar", "bar", Permanent, 1, 1)
 
 	if err != nil {
-		t.Fatalf("cannot set %s=bar [%s]", "/foo/bar", err.Error())
+		t.Fatalf("cannot update %s=bar [%s]", "/foo/bar", err.Error())
 	}
 
-	_, err = fs.Set("/foo/bar", "barbar", Permanent, 2, 1)
+	_, err = fs.Update("/foo/bar", "barbar", Permanent, 2, 1)
 
 	if err != nil {
-		t.Fatalf("cannot set %s=barbar [%s]", "/foo/bar", err.Error())
+		t.Fatalf("cannot update %s=barbar [%s]", "/foo/bar", err.Error())
 	}
 
 	e, err := fs.Get("/foo/bar", false, 2, 1)
@@ -43,11 +60,11 @@ func TestListDirectory(t *testing.T) {
 
 	// create dir /foo
 	// set key-value /foo/foo=bar
-	fs.Set("/foo/foo", "bar", Permanent, 1, 1)
+	fs.Create("/foo/foo", "bar", Permanent, 1, 1)
 
 	// create dir /foo/fooDir
 	// set key-value /foo/fooDir/foo=bar
-	fs.Set("/foo/fooDir/foo", "bar", Permanent, 2, 1)
+	fs.Create("/foo/fooDir/foo", "bar", Permanent, 2, 1)
 
 	e, err := fs.Get("/foo", true, 2, 1)
 
@@ -74,7 +91,7 @@ func TestListDirectory(t *testing.T) {
 
 	// create dir /foo/_hidden
 	// set key-value /foo/_hidden/foo -> bar
-	fs.Set("/foo/_hidden/foo", "bar", Permanent, 3, 1)
+	fs.Create("/foo/_hidden/foo", "bar", Permanent, 3, 1)
 
 	e, _ = fs.Get("/foo", false, 2, 1)
 
@@ -86,7 +103,7 @@ func TestListDirectory(t *testing.T) {
 func TestRemove(t *testing.T) {
 	fs := New()
 
-	fs.Set("/foo", "bar", Permanent, 1, 1)
+	fs.Create("/foo", "bar", Permanent, 1, 1)
 	_, err := fs.Delete("/foo", false, 1, 1)
 
 	if err != nil {
@@ -99,9 +116,9 @@ func TestRemove(t *testing.T) {
 		t.Fatalf("can get the node after deletion")
 	}
 
-	fs.Set("/foo/bar", "bar", Permanent, 1, 1)
-	fs.Set("/foo/car", "car", Permanent, 1, 1)
-	fs.Set("/foo/dar/dar", "dar", Permanent, 1, 1)
+	fs.Create("/foo/bar", "bar", Permanent, 1, 1)
+	fs.Create("/foo/car", "car", Permanent, 1, 1)
+	fs.Create("/foo/dar/dar", "dar", Permanent, 1, 1)
 
 	_, err = fs.Delete("/foo", false, 1, 1)
 
@@ -128,7 +145,7 @@ func TestExpire(t *testing.T) {
 
 	expire := time.Now().Add(time.Second)
 
-	fs.Set("/foo", "bar", expire, 1, 1)
+	fs.Create("/foo", "bar", expire, 1, 1)
 
 	_, err := fs.InternalGet("/foo", 1, 1)
 
@@ -144,7 +161,7 @@ func TestExpire(t *testing.T) {
 		t.Fatalf("can get the node after expiration time")
 	}
 
-	fs.Set("/foo", "bar", expire, 1, 1)
+	fs.Create("/foo", "bar", expire, 1, 1)
 
 	time.Sleep(time.Millisecond * 50)
 	_, err = fs.InternalGet("/foo", 1, 1)
@@ -155,14 +172,14 @@ func TestExpire(t *testing.T) {
 
 	expire = time.Now().Add(time.Second)
 
-	fs.Set("/foo", "bar", expire, 1, 1)
+	fs.Create("/foo", "bar", expire, 1, 1)
 	fs.Delete("/foo", false, 1, 1)
 
 }
 
 func TestTestAndSet(t *testing.T) {
 	fs := New()
-	fs.Set("/foo", "bar", Permanent, 1, 1)
+	fs.Create("/foo", "bar", Permanent, 1, 1)
 
 	// test on wrong previous value
 	_, err := fs.TestAndSet("/foo", "barbar", 0, "car", Permanent, 2, 1)
@@ -191,23 +208,13 @@ func TestTestAndSet(t *testing.T) {
 	if e.PrevValue != "car" || e.Value != "bar" {
 		t.Fatalf("[%v/%v] [%v/%v]", e.PrevValue, "car", e.Value, "bar")
 	}
-
-	// test on empty previous value
-	e, err = fs.TestAndSet("/fooDir/foo", "", 0, "bar", Permanent, 4, 1)
-	if err != nil {
-		t.Fatal("test on empty node should be succeeded")
-	}
-
-	if e.Key != "/fooDir/foo" || e.PrevValue != "" || e.Value != "bar" {
-		t.Fatalf("[%v/%v] [%v/%v] [%v/%v]", e.Key, "/fooDir/foo", e.PrevValue, "", e.Value, "bar")
-	}
 }
 
-func setAndGet(fs *FileSystem, path string, t *testing.T) {
-	_, err := fs.Set(path, "bar", Permanent, 1, 1)
+func createAndGet(fs *FileSystem, path string, t *testing.T) {
+	_, err := fs.Create(path, "bar", Permanent, 1, 1)
 
 	if err != nil {
-		t.Fatalf("cannot set %s=bar [%s]", path, err.Error())
+		t.Fatalf("cannot create %s=bar [%s]", path, err.Error())
 	}
 
 	e, err := fs.Get(path, false, 1, 1)
@@ -219,4 +226,5 @@ func setAndGet(fs *FileSystem, path string, t *testing.T) {
 	if e.Value != "bar" {
 		t.Fatalf("expect value of %s is bar [%s]", path, e.Value)
 	}
+
 }