new tests show one case fails

replicator/driver_test.go

@@ -17,7 +17,8 @@ func testDriver(t *testing.T, d Driver) {
 	defer can()
 
 	key := Key{Namespace: "x/y", Key: "z"}
-	value := ValueVersion{Value: []byte(t.Name()), Version: []byte("1")}
+	version := TimeAsVersion(time.Now())
+	value := Value([]byte(t.Name()))
 
 	t.Run("get does not exist", func(t *testing.T) {
 		v, err := d.Get(ctx, key)
@@ -30,7 +31,7 @@ func testDriver(t *testing.T, d Driver) {
 	})
 
 	t.Run("404 set get", func(t *testing.T) {
-		if err := d.Set(ctx, key, value.Value, value.Version); err != nil {
+		if err := d.Set(ctx, key, value, version); err != nil {
 			t.Fatal(err)
 		}
 
@@ -38,11 +39,11 @@ func testDriver(t *testing.T, d Driver) {
 		if err != nil {
 			t.Errorf("getting key returned an err: %v", err)
 		}
-		if !bytes.Equal(v.Value, value.Value) {
+		if !bytes.Equal(v.Value, value) {
-			t.Errorf("value didnt match set-get: want %q, got %q", value.Value, v.Value)
+			t.Errorf("value didnt match set-get: want %q, got %q", value, v.Value)
 		}
-		if !bytes.Equal(v.Version, value.Version) {
+		if !bytes.Equal(v.Version, version) {
-			t.Errorf("version didnt match set-get: want %q, got %q", value.Version, v.Version)
+			t.Errorf("version didnt match set-get: want %q, got %q", version, v.Version)
 		}
 
 		if err := d.Del(ctx, key, nil); err != nil {
@@ -61,7 +62,7 @@ func testDriver(t *testing.T, d Driver) {
 	})
 
 	t.Run("keys of one key", func(t *testing.T) {
-		if err := d.Set(ctx, key, value.Value, value.Version); err != nil {
+		if err := d.Set(ctx, key, value, version); err != nil {
 			t.Fatal(err)
 		}
 		defer d.Del(ctx, key, nil)
@@ -72,7 +73,7 @@ func testDriver(t *testing.T, d Driver) {
 			n += 1
 			if got.Key != key {
 				t.Error(got)
-			} else if !bytes.Equal(got.Version, value.Version) {
+			} else if !bytes.Equal(got.Version, version) {
 				t.Error(got)
 			}
 		}
@@ -85,34 +86,176 @@ func testDriver(t *testing.T, d Driver) {
 	})
 
 	t.Run("conditional set vs nothing", func(t *testing.T) {
-		t.Error("not impl")
+		if err := d.Set(ctx, key, value, version); err != nil {
+			t.Fatal(err)
+		}
+		defer d.Del(ctx, key, nil)
+
+		if got, err := d.Get(ctx, key); err != nil {
+			t.Fatal(err)
+		} else if !bytes.Equal(got.Value, value) {
+			t.Error(got)
+		} else if !bytes.Equal(got.Version, version) {
+			t.Error(got)
+		}
 	})
 
 	t.Run("conditional set vs older", func(t *testing.T) {
-		t.Error("not impl")
+		oldValue := []byte("teehee")
+		oldVersion := TimeAsVersion(time.Now().Add(-1 * time.Minute))
+		if err := d.Set(ctx, key, oldValue, oldVersion); err != nil {
+			t.Fatal(err)
+		}
+		defer d.Del(ctx, key, nil)
+
+		if got, err := d.Get(ctx, key); err != nil {
+			t.Fatal(err)
+		} else if !bytes.Equal(got.Value, oldValue) {
+			t.Error(got)
+		} else if !bytes.Equal(got.Version, oldVersion) {
+			t.Error(got)
+		}
+
+		if err := d.Set(ctx, key, value, version); err != nil {
+			t.Fatal(err)
+		}
+
+		if got, err := d.Get(ctx, key); err != nil {
+			t.Fatal(err)
+		} else if !bytes.Equal(got.Value, value) {
+			t.Error(got)
+		} else if !bytes.Equal(got.Version, version) {
+			t.Error(got)
+		}
 	})
 
 	t.Run("conditional set vs equal", func(t *testing.T) {
-		t.Error("not impl")
+		oldValue := []byte("teehee")
+		oldVersion := TimeAsVersion(time.Now().Add(-1 * time.Minute))
+		if err := d.Set(ctx, key, oldValue, oldVersion); err != nil {
+			t.Fatal(err)
+		}
+		defer d.Del(ctx, key, nil)
+
+		if got, err := d.Get(ctx, key); err != nil {
+			t.Fatal(err)
+		} else if !bytes.Equal(got.Value, oldValue) {
+			t.Error(got)
+		} else if !bytes.Equal(got.Version, oldVersion) {
+			t.Error(got)
+		}
+
+		if err := d.Set(ctx, key, value, oldVersion); err != nil {
+			t.Fatal(err)
+		}
+
+		if got, err := d.Get(ctx, key); err != nil {
+			t.Fatal(err)
+		} else if !bytes.Equal(got.Value, value) {
+			t.Error(got)
+		} else if !bytes.Equal(got.Version, oldVersion) {
+			t.Error(got)
+		}
 	})
 
 	t.Run("conditional set vs newer", func(t *testing.T) {
-		t.Error("not impl")
+		oldValue := []byte("teehee")
+		oldVersion := TimeAsVersion(time.Now().Add(-1 * time.Minute))
+		if err := d.Set(ctx, key, value, version); err != nil {
+			t.Fatal(err)
+		}
+		defer d.Del(ctx, key, nil)
+
+		if got, err := d.Get(ctx, key); err != nil {
+			t.Fatal(err)
+		} else if !bytes.Equal(got.Value, value) {
+			t.Error(got)
+		} else if !bytes.Equal(got.Version, version) {
+			t.Error(got)
+		}
+
+		if err := d.Set(ctx, key, oldValue, oldVersion); err != nil {
+			t.Fatal(err)
+		}
+
+		if got, err := d.Get(ctx, key); err != nil {
+			t.Fatal(err)
+		} else if !bytes.Equal(got.Value, value) {
+			t.Error(got)
+		} else if !bytes.Equal(got.Version, version) {
+			t.Error(got)
+		}
 	})
 
 	t.Run("conditional del vs nothing", func(t *testing.T) {
-		t.Error("not impl")
+		if err := d.Del(ctx, key, version); err != nil {
+			t.Fatal(err)
+		}
 	})
 
 	t.Run("conditional del vs older", func(t *testing.T) {
-		t.Error("not impl")
+		oldValue := []byte("teehee")
+		oldVersion := TimeAsVersion(time.Now().Add(-1 * time.Minute))
+		if err := d.Set(ctx, key, oldValue, oldVersion); err != nil {
+			t.Fatal(err)
+		}
+		defer d.Del(ctx, key, nil)
+
+		if err := d.Del(ctx, key, version); err != nil {
+			t.Fatal(err)
+		}
+		if got, err := d.Get(ctx, key); err != nil {
+			t.Fatal(err)
+		} else if got.Value != nil {
+			t.Error(got)
+		} else if got.Version != nil {
+			t.Error(got)
+		}
 	})
 
 	t.Run("conditional del vs equal", func(t *testing.T) {
-		t.Error("not impl")
+		if err := d.Set(ctx, key, value, version); err != nil {
+			t.Fatal(err)
+		}
+		defer d.Del(ctx, key, nil)
+
+		if err := d.Del(ctx, key, version); err != nil {
+			t.Fatal(err)
+		}
+		if got, err := d.Get(ctx, key); err != nil {
+			t.Fatal(err)
+		} else if got.Value != nil {
+			t.Error(got)
+		} else if got.Version != nil {
+			t.Error(got)
+		}
 	})
 
 	t.Run("conditional del vs newer", func(t *testing.T) {
-		t.Error("not impl")
+		oldVersion := TimeAsVersion(time.Now().Add(-1 * time.Minute))
+		if err := d.Set(ctx, key, value, version); err != nil {
+			t.Fatal(err)
+		}
+		defer d.Del(ctx, key, nil)
+
+		if got, err := d.Get(ctx, key); err != nil {
+			t.Fatal(err)
+		} else if !bytes.Equal(got.Value, value) {
+			t.Error(got)
+		} else if !bytes.Equal(got.Version, version) {
+			t.Error(got)
+		}
+
+		if err := d.Del(ctx, key, oldVersion); err != nil {
+			t.Fatal(err)
+		}
+
+		if got, err := d.Get(ctx, key); err != nil {
+			t.Fatal(err)
+		} else if !bytes.Equal(got.Value, value) {
+			t.Error(got)
+		} else if !bytes.Equal(got.Version, version) {
+			t.Error(got)
+		}
 	})
 }