public async Task Test_Pauses_And_Resumes_Function()
        {
            await SetupTests();

            var funcName = "deployPauseResumeTestFunc";
            var function = new EventingFunction
            {
                Name             = funcName,
                Code             = "function OnUpdate(doc, meta) {}",
                SourceKeySpace   = new EventingFunctionKeyspace(_bucketName, ScopeName, _sourceCollection.Name),
                MetaDataKeySpace = new EventingFunctionKeyspace(_bucketName, ScopeName, _metaCollection.Name),
            };

            await _eventingFunctionManager.UpsertFunctionAsync(function);

            var read = await _eventingFunctionManager.GetFunctionAsync(funcName);

            Assert.Equal(EventingFunctionProcessingStatus.Paused, read.Settings.ProcessingStatus);

            await Assert.ThrowsAsync <EventingFunctionNotBootstrappedException>(async() =>
                                                                                await _eventingFunctionManager.PauseFunctionAsync(funcName));

            await Assert.ThrowsAsync <EventingFunctionNotDeployedException>(async() =>
                                                                            await _eventingFunctionManager.ResumeFunctionAsync(funcName));

            await _eventingFunctionManager.DeployFunctionAsync(funcName);

            //Wait until deployed
            await Retry.DoUntilAsync(() => IsState(funcName, EventingFunctionStatus.Deployed));

            read = await _eventingFunctionManager.GetFunctionAsync(funcName);

            Assert.Equal(EventingFunctionProcessingStatus.Running, read.Settings.ProcessingStatus);

            await _eventingFunctionManager.PauseFunctionAsync(funcName);

            await Retry.DoUntilAsync(() => IsState(funcName, EventingFunctionStatus.Paused));

            read = await _eventingFunctionManager.GetFunctionAsync(funcName);

            Assert.Equal(EventingFunctionProcessingStatus.Paused, read.Settings.ProcessingStatus);

            await _eventingFunctionManager.UndeployFunctionAsync(funcName);

            //Wait until undeployed
            await Retry.DoUntilAsync(() => IsState(funcName, EventingFunctionStatus.Undeployed));

            await _eventingFunctionManager.DropFunctionAsync(funcName);
        }
        [CouchbaseVersionDependentFact(MaxVersion = "7.0.0")]//Memcached buckets deprecated
        public async Task Can_get_memcached_document()
        {
            var cluster = await _fixture.GetCluster();

            var bucketName = Guid.NewGuid().ToString();

            try
            {
                var bucketSettings = new BucketSettings
                {
                    Name       = bucketName,
                    BucketType = BucketType.Memcached,
                    RamQuotaMB = 200
                };
                await cluster.Buckets.CreateBucketAsync(bucketSettings);

                await Retry.DoUntilAsync(() => CheckBucketExists(cluster, bucketName));

                var bucket = await cluster.BucketAsync(bucketName);

                var collection = await bucket.DefaultCollectionAsync().ConfigureAwait(false);

                var key = Guid.NewGuid().ToString();

                try
                {
                    await collection.InsertAsync(key, new { name = "mike" }).ConfigureAwait(false);

                    using (var result = await collection.GetAsync(key).ConfigureAwait(false))
                    {
                        var content = result.ContentAs <dynamic>();

                        Assert.Equal("mike", (string)content.name);
                    }
                }
                finally
                {
                    await collection.RemoveAsync(key).ConfigureAwait(false);
                }
            }
            finally
            {
                await cluster.Buckets.DropBucketAsync(bucketName);
            }
        }
        public async Task Test_Deploys_And_Undeploys_Function()
        {
            await SetupTests();

            var funcName = "deployUndeployTestFunc";
            var function = new EventingFunction
            {
                Name             = funcName,
                Code             = "function OnUpdate(doc, meta) {}",
                SourceKeySpace   = new EventingFunctionKeyspace(_bucketName, ScopeName, _sourceCollection.Name),
                MetaDataKeySpace = new EventingFunctionKeyspace(_bucketName, ScopeName, _metaCollection.Name),
            };

            await _eventingFunctionManager.UpsertFunctionAsync(function);

            var read = await _eventingFunctionManager.GetFunctionAsync(funcName);

            Assert.Equal(EventingFunctionDeploymentStatus.Undeployed, read.Settings.DeploymentStatus);

            await Assert.ThrowsAsync <EventingFunctionNotDeployedException>(async() =>
                                                                            await _eventingFunctionManager.UndeployFunctionAsync(funcName));

            await _eventingFunctionManager.DeployFunctionAsync(funcName);

            //Wait until status is deployed
            await Retry.DoUntilAsync(() => IsState(funcName, EventingFunctionStatus.Deployed));

            read = await _eventingFunctionManager.GetFunctionAsync(funcName);

            Assert.Equal(EventingFunctionDeploymentStatus.Deployed, read.Settings.DeploymentStatus);

            await _eventingFunctionManager.UndeployFunctionAsync(funcName);

            //Wait until status is undeployed
            await Retry.DoUntilAsync(() => IsState(funcName, EventingFunctionStatus.Undeployed));

            read = await _eventingFunctionManager.GetFunctionAsync(funcName);

            Assert.Equal(EventingFunctionDeploymentStatus.Undeployed, read.Settings.DeploymentStatus);

            await _eventingFunctionManager.DropFunctionAsync(funcName);
        }