public async void MountRemountUnmountBackend()
        {
            using (var client = new VaultClient(TestVaultAddress))
            {
                client.VaultToken = TestRootToken;

                var list = await client.ListMountedBackendsAsync();

                Assert.DoesNotContain("test-generic/", list.Data.Keys);

                await client.MountBackendAsync("test-generic", "generic", "TEST GENERIC MOUNT");

                list = await client.ListMountedBackendsAsync();

                Assert.Contains("test-generic/", list.Data.Keys);
                Assert.Equal("generic", list.Data["test-generic/"].Type);

                await client.RemountBackendAsync("test-generic", "new-test-generic");

                list = await client.ListMountedBackendsAsync();

                Assert.DoesNotContain("test-generic/", list.Data.Keys);
                Assert.Contains("new-test-generic/", list.Data.Keys);
                Assert.Equal("generic", list.Data["new-test-generic/"].Type);

                await client.UnmountBackendAsync("new-test-generic");

                list = await client.ListMountedBackendsAsync();

                Assert.DoesNotContain("test-generic/", list.Data.Keys);
                Assert.DoesNotContain("new-test-generic/", list.Data.Keys);
            }
        }
        public async void MountOverlapPrevented()
        {
            using (var client = new VaultClient(TestVaultAddress))
            {
                client.VaultToken = TestRootToken;

                var mounts = await client.ListMountedBackendsAsync();

                Assert.DoesNotContain("a/", mounts.Data.Keys);
                Assert.DoesNotContain("a/b/", mounts.Data.Keys);
                Assert.DoesNotContain("a/b/c/", mounts.Data.Keys);
                Assert.DoesNotContain("a/b/c/d/", mounts.Data.Keys);
                Assert.DoesNotContain("a/b/c/d/e/", mounts.Data.Keys);
                Assert.DoesNotContain("a/b/c/d/e/f/", mounts.Data.Keys);

                try
                {
                    await client.MountBackendAsync("a/b/c", "generic");

                    mounts = await client.ListMountedBackendsAsync();

                    Assert.Contains("a/b/c/", mounts.Data.Keys);


                    var ex = await Assert.ThrowsAsync <VaultClientException>(
                        async() => await client.MountBackendAsync("a/b/c/d", "generic"));

                    Assert.Equal(HttpStatusCode.BadRequest, ex.StatusCode);
                    Assert.Equal("existing mount at a/b/c/", ex.Errors.Errors.First());

                    mounts = await client.ListMountedBackendsAsync();

                    Assert.DoesNotContain("a/b/c/d/", mounts.Data.Keys);
                }
                finally
                {
                    await client.UnmountBackendAsync("a/b/c/d");

                    await client.UnmountBackendAsync("a/b/c");
                }

                mounts = await client.ListMountedBackendsAsync();

                Assert.DoesNotContain("a/b/c/d/", mounts.Data.Keys);
                Assert.DoesNotContain("a/b/c/", mounts.Data.Keys);
            }
        }
        public async void ListMounts()
        {
            using (var client = new VaultClient(TestVaultAddress))
            {
                client.VaultToken = TestRootToken;

                var list = await client.ListMountedBackendsAsync();

                // Some of the mounts we expect to be there in a default setup
                Assert.Superset(new[]
                {
                    "sys/",
                    "cubbyhole/",
                    "secret/",
                }.ToHashSet(),
                                list.Data.Keys.ToHashSet());
            }
        }
        public async void LongestMountWins()
        {
            using (var client = new VaultClient(TestVaultAddress))
            {
                client.VaultToken = TestRootToken;

                var mounts = await client.ListMountedBackendsAsync();

                Assert.DoesNotContain("a/", mounts.Data.Keys);
                Assert.DoesNotContain("a/b/", mounts.Data.Keys);
                Assert.DoesNotContain("a/b/c/", mounts.Data.Keys);
                Assert.DoesNotContain("a/b/c/d/", mounts.Data.Keys);
                Assert.DoesNotContain("a/b/c/d/e/", mounts.Data.Keys);
                Assert.DoesNotContain("a/b/c/d/e/f/", mounts.Data.Keys);

                try
                {
                    await client.MountBackendAsync("a/b/c/d/", "generic");

                    mounts = await client.ListMountedBackendsAsync();

                    Assert.Contains("a/b/c/d/", mounts.Data.Keys);

                    await client.WriteAsync("a/b/c/d/e/f", new TestClass1 { Key1 = "val1" });

                    var read = await client.ReadAsync <ReadResponse <TestClass1> >("a/b/c/d/e/f");

                    Assert.Equal("val1", read.Data.Key1);

                    await client.MountBackendAsync("a/b", "generic");

                    mounts = await client.ListMountedBackendsAsync();

                    Assert.Contains("a/b/", mounts.Data.Keys);

                    await client.WriteAsync("a/b/c/d/e/f", new TestClass1 { Key1 = "val1" });

                    read = await client.ReadAsync <ReadResponse <TestClass1> >("a/b/c/d/e/f");

                    Assert.Equal("val1", read.Data.Key1);

                    await client.UnmountBackendAsync("a/b/c/d");

                    mounts = await client.ListMountedBackendsAsync();

                    Assert.DoesNotContain("a/b/c/d/", mounts.Data.Keys);

                    var ex = await Assert.ThrowsAsync <VaultClientException>(async() =>
                                                                             read = await client.ReadAsync <ReadResponse <TestClass1> >("a/b/c/d/e/f"));

                    Assert.Equal(HttpStatusCode.NotFound, ex.StatusCode);

                    await client.WriteAsync("a/b/c/d/e/f", new TestClass1 { Key1 = "VAL2" });

                    read = await client.ReadAsync <ReadResponse <TestClass1> >("a/b/c/d/e/f");

                    Assert.Equal("VAL2", read.Data.Key1);
                }
                finally
                {
                    await client.UnmountBackendAsync("a/b/c/d");

                    await client.UnmountBackendAsync("a/b");
                }

                mounts = await client.ListMountedBackendsAsync();

                Assert.DoesNotContain("a/b/c/d/", mounts.Data.Keys);
                Assert.DoesNotContain("a/b/", mounts.Data.Keys);
            }
        }