C# BucketContext类代码示例

        public void CreateQueryRequest_Any_ReturnsQueryWrappedInQueryRequest()
        {
            // Arrange

            var bucket = new Mock<IBucket>();
            bucket.Setup(m => m.Name).Returns("default");
            bucket.Setup(m => m.Configuration).Returns(new BucketConfiguration()
            {
                PoolConfiguration = new PoolConfiguration(new ClientConfiguration())
            });

            var context = new BucketContext(bucket.Object);
            var query = context.Query<Brewery>();

            // Act

            var result = LinqQueryRequest.CreateQueryRequest(query, p => p.Any(q => q.Name == "name"));

            // Assert

            const string queryStr = "SELECT true as result FROM `default` as `Extent1` WHERE (`Extent1`.`name` = 'name') LIMIT 1";

            Assert.NotNull(result);
            Assert.AreEqual(queryStr, result.GetOriginalStatement());
            Assert.True(result.ScalarResultBehavior.ResultExtractionRequired);
            Assert.AreEqual(false, result.ScalarResultBehavior.NoRowsResult);
        }

        public void BeginChangeTracking_DoesNotClear_Modified_List()
        {
            var db = new BucketContext(ClusterHelper.GetBucket("beer-sample"));

            db.BeginChangeTracking();

            var query = from x in db.Query<Beer>()
                        where x.Type == "beer"
                        select x;

            db.BeginChangeTracking();

            var context = db as IChangeTrackableContext;

            Assert.AreEqual(0, context.ModifiedCount);

            var brewery = query.First();
            brewery.Abv = 10;

            Assert.AreEqual(1, context.ModifiedCount);

            db.BeginChangeTracking();

            Assert.AreEqual(1, context.ModifiedCount);
        }

 public void GetDocumentId_When_Id_Field_DoesNotExist_Throw_KeyAttributeMissingException()
 {
     var route = new Route();
     var bucket = new Mock<IBucket>();
     var ctx = new BucketContext(bucket.Object);
     Assert.Throws<KeyAttributeMissingException>(()=>ctx.GetDocumentId(route));
 }

 public void GetDocumentId_When_DocId_Exists_Use_It()
 {
     var beer = new Beer {Name = "beer1"};
     var bucket = new Mock<IBucket>();
     var ctx = new BucketContext(bucket.Object);
     var id = ctx.GetDocumentId(beer);
     Assert.AreEqual("beer1", id);
 }

 public void Save_When_KeyAttribute_Is_Not_Defined_Throw_DocumentIdMissingException()
 {
     var brewery = new Brewery();
        var bucket = new Mock<IBucket>();
        var result = new Mock<IOperationResult<Brewery>>();
        result.Setup(x => x.Status).Returns(ResponseStatus.Success);
        bucket.Setup(x => x.Upsert(It.IsAny<string>(), It.IsAny<Brewery>())).Returns(result.Object);
        var ctx = new BucketContext(bucket.Object);
        Assert.Throws<KeyAttributeMissingException>(()=>ctx.Save(brewery));
 }

 public void Remove_When_Write_Is_Not_Succesful_Throw_CouchbaseWriteException()
 {
     var beer = new Beer();
        var bucket = new Mock<IBucket>();
        var result = new Mock<IOperationResult<Beer>>();
        result.Setup(x => x.Success).Returns(false);
        bucket.Setup(x => x.Remove(It.IsAny<string>())).Returns(result.Object);
        var ctx = new BucketContext(bucket.Object);
        Assert.Throws<CouchbaseWriteException>(() => ctx.Remove(beer));
 }

        internal virtual void InitTest(Settings settings)
        {
            s3 = new S3Service()
            {
                AccessKeyID = settings.AccessKeyID,
                SecretAccessKey = settings.SecretAccessKey
            };

            bucket = new BucketContext() { BucketName = settings.TestBucketName, Service = s3 };
        }

 public void Remove_When_Write_Is_Succesful_Return_Success()
 {
     var beer = new Beer();
        var bucket = new Mock<IBucket>();
        var result = new Mock<IOperationResult<Beer>>();
        result.Setup(x => x.Status).Returns(ResponseStatus.Success);
        result.Setup(x => x.Success).Returns(true);
        bucket.Setup(x => x.Remove(It.IsAny<string>())).Returns(result.Object);
        var ctx = new BucketContext(bucket.Object);
        ctx.Remove(beer);
 }

        public async Task ExecuteAsync_WithAvg_ReturnsAvg()
        {
            var bucket = ClusterHelper.GetBucket("beer-sample");
            var context = new BucketContext(bucket);

            var beers = from b in context.Query<Beer>()
                        select b;

            var result = await beers.ExecuteAsync(p => p.Average(q => q.Abv));
            Console.WriteLine(result);
        }

        public void Test_Basic_Query()
        {
            var db = new BucketContext(ClusterHelper.GetBucket("beer-sample"));
            var query = from x in db.Query<Beer>()
                where x.Type == "beer"
                select x;

            foreach (var beer in query)
            {
                Console.WriteLine(beer.Name);
            }
        }

        public async Task ExecuteAsync_Any_ReturnsTrue()
        {
            var bucket = ClusterHelper.GetBucket("beer-sample");
            var context = new BucketContext(bucket);

            var beers = from b in context.Query<Beer>()
                        where b.Type == "beer" && b.Name == "21A IPA"
                        select b;

            var result = await beers.ExecuteAsync(p => p.Any());

            Assert.True(result);
        }

        public async Task ExecuteAsync_FirstOrDefaultNoValues_ReturnsDefault()
        {
            var bucket = ClusterHelper.GetBucket("beer-sample");
            var context = new BucketContext(bucket);

            var beers = from b in context.Query<Beer>()
                        where b.Name == "abcdefg"
                        select b.Abv;

            var result = await beers.ExecuteAsync(p => p.FirstOrDefault());

            Assert.AreEqual(0M, result);
        }

        public async Task ExecuteAsync_First_ReturnsFirst()
        {
            var bucket = ClusterHelper.GetBucket("beer-sample");
            var context = new BucketContext(bucket);

            var beers = from b in context.Query<Beer>()
                        select b;

            var result = await beers.ExecuteAsync(p => p.First());

            Assert.NotNull(result);
            Console.WriteLine(result.Name);
        }

        public async Task ExecuteAsync_NoParameters_ReturnsList()
        {
            var bucket = ClusterHelper.GetBucket("beer-sample");
            var context = new BucketContext(bucket);

            var beers = from b in context.Query<Beer>()
                select b;

            var results = (await beers.Take(1).ExecuteAsync()).ToList();
            Assert.AreEqual(1, results.Count);

            foreach (var beer in results)
            {
                Console.WriteLine(beer.Name);
            }
        }

        public void Query_DisableProxyGeneration_ReturnsNoProxy()
        {
            var db = new BucketContext(ClusterHelper.GetBucket("beer-sample"));

            const string documentId = "21st_amendment_brewery_cafe-21a_ipa";

            var query = from x in db.Query<Beer>().UseKeys(new[] { documentId })
                        where x.Type == "beer"
                        select x;

            var beer = query.First();

            // ReSharper disable once SuspiciousTypeConversion.Global
            var status = beer as ITrackedDocumentNode;

            Assert.Null(status);
        }