Example #1
0
        public async Task testWatchesTriggered()
        {
            var zk = await createClient();

            HasTriggeredWatcher watcher = new HasTriggeredWatcher();
            await zk.getChildrenAsync("/", watcher);

            await multiAsync(zk, Arrays.asList(
                                 Op.create("/t", new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT),
                                 Op.delete("/t", -1)
                                 ));

            Assert.assertTrue(await watcher.triggered.WaitAsync().WithTimeout(CONNECTION_TIMEOUT));
        }
Example #2
0
        private async Task multiHavingErrors(ZooKeeper zk, List <Op> ops, List <KeeperException.Code> expectedResultCodes)
        {
            try
            {
                await multiAsync(zk, ops);

                Assert.fail("Shouldn't have validated in ZooKeeper client!");
            }
            catch (KeeperException e)
            {
                var results = e.getResults();
                for (int i = 0; i < results.Count; i++)
                {
                    OpResult opResult = results[i];
                    Assert.assertTrue("Did't recieve proper error response", opResult is OpResult.ErrorResult);
                    OpResult.ErrorResult errRes = (OpResult.ErrorResult)opResult;
                    Assert.assertEquals("Did't recieve proper error code", expectedResultCodes[i], errRes.getErr());
                }
            }
        }
Example #3
0
        public async Task testNoWatchesTriggeredForFailedMultiRequest()
        {
            var zk = await createClient();

            HasTriggeredWatcher watcher = new HasTriggeredWatcher();
            await zk.getChildrenAsync("/", watcher);

            try
            {
                await multiAsync(zk, Arrays.asList(
                                     Op.create("/t", new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT),
                                     Op.delete("/nonexisting", -1)
                                     ));

                Assert.fail("expected previous multi op to fail!");
            }
            catch (KeeperException.NoNodeException)
            {
                // expected
            }

            // by waiting for the callback we're assured that the event queue is flushed
            Assert.assertTrue(await zk.sync("/").WithTimeout(CONNECTION_TIMEOUT));
        }
Example #4
0
        public async Task testTransactionBuilder()
        {
            var zk = await createClient();

            List <OpResult> results = await commitAsync(zk.transaction()
                                                        .create("/t1", new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT)
                                                        .create("/t1/child", new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT)
                                                        .create("/t2", null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL));

            Assert.assertEquals(3, results.Count);
            foreach (OpResult r in results)
            {
                OpResult.CreateResult c = (OpResult.CreateResult)r;
                Assert.assertTrue(c.getPath().StartsWith("/t"));
                Assert.assertNotNull(c.ToString());
            }
            Assert.assertNotNull(await zk.existsAsync("/t1", false));
            Assert.assertNotNull(await zk.existsAsync("/t1/child", false));
            Assert.assertNotNull(await zk.existsAsync("/t2", false));

            results = await commitAsync(zk.transaction()
                                        .check("/t1", 0)
                                        .check("/t1/child", 0)
                                        .check("/t2", 0));

            Assert.assertEquals(3, results.Count);
            foreach (OpResult r in results)
            {
                OpResult.CheckResult c = (OpResult.CheckResult)r;
                Assert.assertNotNull(c.ToString());
            }

            try
            {
                await commitAsync(zk.transaction()
                                  .check("/t1", 0)
                                  .check("/t1/child", 0)
                                  .check("/t2", 1));

                Assert.fail();
            }
            catch (KeeperException.BadVersionException)
            {
                // expected
            }

            results = await commitAsync(zk.transaction()
                                        .check("/t1", 0)
                                        .setData("/t1", new byte[0], 0));

            Assert.assertEquals(2, results.Count);
            foreach (OpResult r in results)
            {
                Assert.assertNotNull(r.ToString());
            }

            try
            {
                results = await commitAsync(zk.transaction()
                                            .check("/t1", 1)
                                            .setData("/t1", new byte[0], 2));

                Assert.fail();
            }
            catch (KeeperException.BadVersionException)
            {
                // expected
            }

            results = await commitAsync(zk.transaction()
                                        .check("/t1", 1)
                                        .check("/t1/child", 0)
                                        .check("/t2", 0));

            Assert.assertEquals(3, results.Count);

            results = await commitAsync(zk.transaction()
                                        .delete("/t2", -1)
                                        .delete("/t1/child", -1));

            Assert.assertEquals(2, results.Count);
            foreach (OpResult r in results)
            {
                OpResult.DeleteResult d = (OpResult.DeleteResult)r;
                Assert.assertNotNull(d.ToString());
            }
            Assert.assertNotNull(await zk.existsAsync("/t1", false));
            Assert.assertNull(await zk.existsAsync("/t1/child", false));
            Assert.assertNull(await zk.existsAsync("/t2", false));
        }