public void GetAsync_Allows_No_GetOptions()
        {
            var mockBucket = new Mock <FakeBucket>();
            var collection = new CouchbaseCollection(mockBucket.Object, new ClusterContext(), 0, "_default");

            collection.GetAsync("key").GetAwaiter().GetResult();
        }
        protected void LoadManifest()
        {
            //The server supports collections so build them from the manifest
            if (SupportsCollections)
            {
                //warmup the scopes/collections and cache them
                foreach (var scopeDef in Manifest.scopes)
                {
                    var collections = new List <ICollection>();
                    foreach (var collectionDef in scopeDef.collections)
                    {
                        collections.Add(new CouchbaseCollection(this, Context,
                                                                Convert.ToUInt32(collectionDef.uid, 16), collectionDef.name));
                    }

                    Scopes.TryAdd(scopeDef.name, new Scope(scopeDef.name, scopeDef.uid, collections, this));
                }
            }
            else
            {
                //build a fake scope and collection for pre-6.5 clusters
                var defaultCollection = new CouchbaseCollection(this, Context, null, "_default");
                var defaultScope      = new Scope("_default", "0", new List <ICollection> {
                    defaultCollection
                }, this);
                Scopes.TryAdd("_default", defaultScope);
            }
        }
        public void Dictionary_Factory_Test()
        {
            var mockBucket = new Mock <FakeBucket>();
            var collection = new CouchbaseCollection(mockBucket.Object, new ClusterContext(), 0, "_default");

            var dict = collection.Dictionary <string, dynamic>("theDocId");

            Assert.NotNull(dict);
        }
        public void List_Factory_Test()
        {
            var mockBucket = new Mock <FakeBucket>();
            var collection = new CouchbaseCollection(mockBucket.Object, new ClusterContext(), 0, "_default");

            var list = collection.List <dynamic>("theDocId");

            Assert.NotNull(list);
        }
        public void Get_Timed_Out_Throw_TimeoutException()
        {
            var mockBucket = new Mock <FakeBucket>();
            var collection = new CouchbaseCollection(mockBucket.Object, new ClusterContext(), 0, "_default");

            Assert.ThrowsAsync <TimeoutException>(async() => await collection.GetAsync("key", options =>
            {
                options.WithTimeout(TimeSpan.FromMilliseconds(1d));
            }));
        }
Example #6
0
        //[InlineData(ResponseStatus.CasMismatch)] TODO
        // [InlineData(ResponseStatus.KeyDeleted)] TODO
        public async Task Get_Fails_Throw_KeyValueException(ResponseStatus responseStatus)
        {
            var bucket     = new FakeBucket(responseStatus);
            var collection = new CouchbaseCollection(bucket, 0, "_default");

            try
            {
                var result = await collection.Get("key");
            }
            catch (KeyValueException e)
            {
                Assert.Equal(responseStatus, e.ResponseStatus);
            }
        }
        public async Task SubDoc_More_Than_One_XAttr_Throws_ArgumentException()
        {
            var mockBucket = new Mock <FakeBucket>();
            var collection = new CouchbaseCollection(mockBucket.Object, new ClusterContext(), 0, "_default");

            await Assert.ThrowsAsync <ArgumentException>(async() =>
            {
                await collection.LookupInAsync("docId", builder =>
                {
                    builder.Get("doc.path", isXattr: true);
                    builder.Count("path", isXattr: true);
                }, new LookupInOptions {
                    Timeout = TimeSpan.FromHours(1)
                });
            });
        }
        //[InlineData(ResponseStatus.CasMismatch)] TODO
        // [InlineData(ResponseStatus.KeyDeleted)] TODO
        public async Task Get_Fails_Throw_KeyValueException(ResponseStatus responseStatus, Type exceptionType)
        {
            var bucket     = new FakeBucket(responseStatus);
            var collection = new CouchbaseCollection(bucket, new ClusterContext(), 0, "_default");

            try
            {
                using (await collection.GetAsync("key"))
                {
                }
            }
            catch (Exception e)
            {
                Assert.IsType(exceptionType, e);
            }
        }