test improvements

lingrino · Mar 25, 2020 · 8edde4e · 8edde4e
1 parent c6b190f
commit 8edde4e
Show file tree

Hide file tree

Showing 8 changed files with 80 additions and 232 deletions.
diff --git a/vaku2/path_copy.go b/vaku2/path_copy.go
@@ -14,11 +14,13 @@ var (
 func (c *Client) PathCopy(source, dest string) error {
 	secret, err := c.PathRead(source)
 	if err != nil {
+		// fmt.Println(err)
 		return fmt.Errorf("read: %w", ErrPathCopy)
 	}
 
 	err = c.PathWriteDest(dest, secret)
 	if err != nil {
+		// fmt.Println(err)
 		return fmt.Errorf("write: %w", ErrPathCopy)
 	}
 

diff --git a/vaku2/path_copy_test.go b/vaku2/path_copy_test.go
@@ -74,48 +74,27 @@ func TestPathCopy(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 
-			// Tests with the same source/destination
-			ln, client := testClient(t, tt.giveOptions...)
-			defer ln.Close()
-			readbackClient := cloneCLient(t, client)
-
-			updateLogical(t, client, tt.giveLogical)
-
-			for _, ver := range kvMountVersions {
-				pathS := addMountToPath(t, tt.giveSource, ver)
-				pathD := addMountToPath(t, tt.giveDest, ver)
-
-				err := client.PathCopy(pathS, pathD)
-				assert.True(t, errors.Is(err, tt.wantErr), err)
-
-				readBackS, errS := readbackClient.PathRead(pathS)
-				readBackD, errD := readbackClient.PathRead(pathD)
-				assert.NoError(t, errS)
-				assert.NoError(t, errD)
-
-				if tt.wantNilDest {
-					assert.Nil(t, readBackD)
-				} else {
-					assert.Equal(t, readBackS, readBackD)
-				}
+			versionProduct := [][2]string{
+				{"1", "1"},
+				{"2", "2"},
+				{"1", "2"},
+				{"2", "1"},
 			}
 
-			// Tests with different source/destination
-			lnS, lnD, client := testClientDiffDest(t, tt.giveOptions...)
-			defer lnS.Close()
-			defer lnD.Close()
+			for _, ver := range versionProduct {
+				ln, client := testClient(t, tt.giveOptions...)
+				defer ln.Close()
+				readbackClient := cloneCLient(t, client)
+				updateLogical(t, client, tt.giveLogical)
 
-			updateLogical(t, client, tt.giveLogical)
-
-			for _, ver := range kvMountVersions {
-				pathS := addMountToPath(t, tt.giveSource, ver)
-				pathD := addMountToPath(t, tt.giveDest, ver)
+				pathS := addMountToPath(t, tt.giveSource, ver[0])
+				pathD := addMountToPath(t, tt.giveDest, ver[1])
 
 				err := client.PathCopy(pathS, pathD)
 				assert.True(t, errors.Is(err, tt.wantErr), err)
 
 				readBackS, errS := readbackClient.PathRead(pathS)
-				readBackD, errD := readbackClient.PathRead(pathD)
+				readBackD, errD := readbackClient.PathReadDest(pathD)
 				assert.NoError(t, errS)
 				assert.NoError(t, errD)
 
@@ -125,54 +104,6 @@ func TestPathCopy(t *testing.T) {
 					assert.Equal(t, readBackS, readBackD)
 				}
 			}
-
-			// Tests with different source/destination and ver 1 -> 2
-			lnS, lnD, client = testClientDiffDest(t, tt.giveOptions...)
-			defer lnS.Close()
-			defer lnD.Close()
-
-			updateLogical(t, client, tt.giveLogical)
-
-			pathS := addMountToPath(t, tt.giveSource, "1")
-			pathD := addMountToPath(t, tt.giveDest, "2")
-
-			err := client.PathCopy(pathS, pathD)
-			assert.True(t, errors.Is(err, tt.wantErr), err)
-
-			readBackS, errS := readbackClient.PathRead(pathS)
-			readBackD, errD := readbackClient.PathRead(pathD)
-			assert.NoError(t, errS)
-			assert.NoError(t, errD)
-
-			if tt.wantNilDest {
-				assert.Nil(t, readBackD)
-			} else {
-				assert.Equal(t, readBackS, readBackD)
-			}
-
-			// Tests with different source/destination and ver 2 -> 1
-			lnS, lnD, client = testClientDiffDest(t, tt.giveOptions...)
-			defer lnS.Close()
-			defer lnD.Close()
-
-			updateLogical(t, client, tt.giveLogical)
-
-			pathS = addMountToPath(t, tt.giveSource, "2")
-			pathD = addMountToPath(t, tt.giveDest, "1")
-
-			err = client.PathCopy(pathS, pathD)
-			assert.True(t, errors.Is(err, tt.wantErr), err)
-
-			readBackS, errS = readbackClient.PathRead(pathS)
-			readBackD, errD = readbackClient.PathRead(pathD)
-			assert.NoError(t, errS)
-			assert.NoError(t, errD)
-
-			if tt.wantNilDest {
-				assert.Nil(t, readBackD)
-			} else {
-				assert.Equal(t, readBackS, readBackD)
-			}
 		})
 	}
 }
diff --git a/vaku2/path_delete_test.go b/vaku2/path_delete_test.go
@@ -50,23 +50,24 @@ func TestPathDelete(t *testing.T) {
 			ln, client := testClient(t, tt.giveOptions...)
 			defer ln.Close()
 			readbackClient := cloneCLient(t, client)
-
 			updateLogical(t, client, tt.giveLogical)
 
+			funcs := []func(string) error{
+				client.PathDelete,
+				client.PathDeleteDest,
+			}
+
 			for _, ver := range kvMountVersions {
-				path := addMountToPath(t, tt.give, ver)
+				for _, f := range funcs {
+					path := addMountToPath(t, tt.give, ver)
 
-				err := client.PathDelete(path)
-				errD := client.PathDeleteDest(path)
-				assert.True(t, errors.Is(err, tt.wantErr), err)
-				assert.True(t, errors.Is(errD, tt.wantErr), err)
+					err := f(path)
+					assert.True(t, errors.Is(err, tt.wantErr), err)
 
-				readBack, err := readbackClient.PathRead(path)
-				readBackD, errD := readbackClient.PathReadDest(path)
-				assert.NoError(t, err)
-				assert.NoError(t, errD)
-				assert.Nil(t, readBack)
-				assert.Nil(t, readBackD)
+					readBack, err := readbackClient.PathRead(path)
+					assert.NoError(t, err)
+					assert.Nil(t, readBack)
+				}
 			}
 		})
 	}

diff --git a/vaku2/path_list_test.go b/vaku2/path_list_test.go
@@ -130,22 +130,23 @@ func TestPathList(t *testing.T) {
 
 			ln, client := testClient(t, tt.giveOptions...)
 			defer ln.Close()
-
 			updateLogical(t, client, tt.giveLogical)
 
-			for _, ver := range kvMountVersions {
-				path := addMountToPath(t, tt.give, ver)
+			funcs := []func(string) ([]string, error){
+				client.PathList,
+				client.PathListDest,
+			}
 
-				list, err := client.PathList(path)
-				listD, errD := client.PathListDest(path)
-				TrimListPrefix(list, ver)
-				TrimListPrefix(listD, ver)
+			for _, ver := range kvMountVersions {
+				for _, f := range funcs {
+					path := addMountToPath(t, tt.give, ver)
 
-				assert.True(t, errors.Is(err, tt.wantErr), err)
-				assert.True(t, errors.Is(errD, tt.wantErr), err)
+					list, err := f(path)
+					TrimListPrefix(list, ver)
 
-				assert.Equal(t, tt.want, list)
-				assert.Equal(t, tt.want, listD)
+					assert.True(t, errors.Is(err, tt.wantErr), err)
+					assert.Equal(t, tt.want, list)
+				}
 			}
 		})
 	}

diff --git a/vaku2/path_move_test.go b/vaku2/path_move_test.go
@@ -89,59 +89,30 @@ func TestPathMove(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 
-			// Tests with the same source/destination
-			ln, client := testClient(t, tt.giveOptions...)
-			defer ln.Close()
-			readbackClient := cloneCLient(t, client)
-
-			updateLogical(t, client, tt.giveLogical)
-
-			for _, ver := range kvMountVersions {
-				pathS := addMountToPath(t, tt.giveSource, ver)
-				pathD := addMountToPath(t, tt.giveDest, ver)
-
-				origS, err := readbackClient.PathRead(pathS)
-				assert.NoError(t, err)
-
-				err = client.PathMove(pathS, pathD)
-				assert.True(t, errors.Is(err, tt.wantErr), err)
-
-				readBackS, errS := readbackClient.PathRead(pathS)
-				readBackD, errD := readbackClient.PathRead(pathD)
-				assert.NoError(t, errS)
-				assert.NoError(t, errD)
-
-				if tt.wantNilSource {
-					assert.Nil(t, readBackS)
-				} else {
-					assert.Equal(t, origS, readBackS)
-				}
-				if tt.wantNilDest {
-					assert.Nil(t, readBackD)
-				} else {
-					assert.Equal(t, origS, readBackD)
-				}
+			versionProduct := [][2]string{
+				{"1", "1"},
+				{"2", "2"},
+				{"1", "2"},
+				{"2", "1"},
 			}
 
-			// Tests with different source/destination
-			lnS, lnD, clientD := testClientDiffDest(t, tt.giveOptions...)
-			defer lnS.Close()
-			defer lnD.Close()
+			for _, ver := range versionProduct {
+				ln, client := testClient(t, tt.giveOptions...)
+				defer ln.Close()
+				readbackClient := cloneCLient(t, client)
+				updateLogical(t, client, tt.giveLogical)
 
-			updateLogical(t, clientD, tt.giveLogical)
-
-			for _, ver := range kvMountVersions {
-				pathS := addMountToPath(t, tt.giveSource, ver)
-				pathD := addMountToPath(t, tt.giveDest, ver)
+				pathS := addMountToPath(t, tt.giveSource, ver[0])
+				pathD := addMountToPath(t, tt.giveDest, ver[1])
 
 				origS, err := readbackClient.PathRead(pathS)
 				assert.NoError(t, err)
 
-				err = clientD.PathMove(pathS, pathD)
+				err = client.PathMove(pathS, pathD)
 				assert.True(t, errors.Is(err, tt.wantErr), err)
 
 				readBackS, errS := readbackClient.PathRead(pathS)
-				readBackD, errD := readbackClient.PathRead(pathD)
+				readBackD, errD := readbackClient.PathReadDest(pathD)
 				assert.NoError(t, errS)
 				assert.NoError(t, errD)
 
@@ -156,70 +127,6 @@ func TestPathMove(t *testing.T) {
 					assert.Equal(t, origS, readBackD)
 				}
 			}
-
-			// 	// Tests with different source/destination and ver 1 -> 2
-			// 	lnS, lnD, client = testClientDiffDest(t, tt.giveOptions...)
-			// 	defer lnS.Close()
-			// 	defer lnD.Close()
-
-			// 	updateLogical(t, client, tt.giveLogical)
-
-			// 	pathS := addMountToPath(t, tt.giveSource, "1")
-			// 	pathD := addMountToPath(t, tt.giveDest, "2")
-
-			// 	origS, err := readbackClient.PathRead(pathS)
-			// 	assert.NoError(t, err)
-
-			// 	err = client.PathMove(pathS, pathD)
-			// 	assert.True(t, errors.Is(err, tt.wantErr), err)
-
-			// 	readBackS, errS := readbackClient.PathRead(pathS)
-			// 	readBackD, errD := readbackClient.PathRead(pathD)
-			// 	assert.NoError(t, errS)
-			// 	assert.NoError(t, errD)
-
-			// 	if tt.wantNilSource {
-			// 		assert.Nil(t, readBackS)
-			// 	} else {
-			// 		assert.Equal(t, origS, readBackS)
-			// 	}
-			// 	if tt.wantNilDest {
-			// 		assert.Nil(t, readBackD)
-			// 	} else {
-			// 		assert.Equal(t, origS, readBackD)
-			// 	}
-
-			// 	// Tests with different source/destination and ver 2 -> 1
-			// 	lnS, lnD, client = testClientDiffDest(t, tt.giveOptions...)
-			// 	defer lnS.Close()
-			// 	defer lnD.Close()
-
-			// 	updateLogical(t, client, tt.giveLogical)
-
-			// 	pathS = addMountToPath(t, tt.giveSource, "2")
-			// 	pathD = addMountToPath(t, tt.giveDest, "1")
-
-			// 	origS, err = readbackClient.PathRead(pathS)
-			// 	assert.NoError(t, err)
-
-			// 	err = client.PathMove(pathS, pathD)
-			// 	assert.True(t, errors.Is(err, tt.wantErr), err)
-
-			// 	readBackS, errS = readbackClient.PathRead(pathS)
-			// 	readBackD, errD = readbackClient.PathRead(pathD)
-			// 	assert.NoError(t, errS)
-			// 	assert.NoError(t, errD)
-
-			// 	if tt.wantNilSource {
-			// 		assert.Nil(t, readBackS)
-			// 	} else {
-			// 		assert.Equal(t, origS, readBackS)
-			// 	}
-			// 	if tt.wantNilDest {
-			// 		assert.Nil(t, readBackD)
-			// 	} else {
-			// 		assert.Equal(t, origS, readBackD)
-			// 	}
 		})
 	}
 }
diff --git a/vaku2/path_read_test.go b/vaku2/path_read_test.go
@@ -66,19 +66,22 @@ func TestPathRead(t *testing.T) {
 
 			ln, client := testClient(t, tt.giveOptions...)
 			defer ln.Close()
-
 			updateLogical(t, client, tt.giveLogical)
 
+			funcs := []func(string) (map[string]interface{}, error){
+				client.PathRead,
+				client.PathReadDest,
+			}
+
 			for _, ver := range kvMountVersions {
-				path := addMountToPath(t, tt.give, ver)
+				for _, f := range funcs {
+					path := addMountToPath(t, tt.give, ver)
 
-				read, err := client.PathRead(path)
-				readD, errD := client.PathReadDest(path)
+					read, err := f(path)
 
-				assert.True(t, errors.Is(err, tt.wantErr), err)
-				assert.True(t, errors.Is(errD, tt.wantErr), err)
-				assert.Equal(t, tt.want, read)
-				assert.Equal(t, tt.want, readD)
+					assert.True(t, errors.Is(err, tt.wantErr), err)
+					assert.Equal(t, tt.want, read)
+				}
 			}
 		})
 	}

diff --git a/vaku2/path_write.go b/vaku2/path_write.go
@@ -21,8 +21,10 @@ func (c *Client) PathWriteDest(p string, d map[string]interface{}) error {
 
 // pathWrite writes data to a path.
 func (c *Client) pathWrite(apiL logical, p string, d map[string]interface{}) error {
+	fmt.Printf("%+v\n", d)
 	_, err := apiL.Write(p, d)
 	if err != nil {
+		fmt.Println(err)
 		return fmt.Errorf("%q: %w", p, ErrVaultWrite)
 	}