public void ExistsAsync_AnyKeyState_ReturnsExpectedResult(KeyState keyState, bool expectedResult)
{
// Arrange
var operationResult = new Mock<IOperationResult<ObserveState>>();
operationResult.SetupGet(m => m.Success).Returns(true);
operationResult.SetupGet(m => m.Status).Returns(ResponseStatus.Success);
operationResult.SetupGet(m => m.Value).Returns(new ObserveState()
{
KeyState = keyState
});
var mockRequestExecuter = new Mock<IRequestExecuter>();
mockRequestExecuter.Setup(m => m.SendWithRetryAsync(It.IsAny<Observe>(), null, null)).Returns(Task.FromResult(operationResult.Object));
// Act
bool result;
using (var bucket = new CouchbaseBucket(mockRequestExecuter.Object, new DefaultConverter(), new DefaultTranscoder()))
{
result = bucket.ExistsAsync("key").Result;
}
// Assert
Assert.AreEqual(expectedResult, result);
}
public void UpsertKeyValueCasExpirationTSReplicateToPersistTo_DisposedBucket_ThrowsObjectDisposedException()
{
// Arrange
var mockRequestExecuter = new Mock <IRequestExecuter>();
var bucket = new CouchbaseBucket(mockRequestExecuter.Object, new DefaultConverter(), new DefaultTranscoder());
bucket.Dispose();
// Act
Assert.Throws <ObjectDisposedException>(() => bucket.Upsert("key", new FakeDocument(), 0UL, TimeSpan.Zero, ReplicateTo.One, PersistTo.One));
}
public void UpsertKeyValueExpiration_DisposedBucket_ThrowsObjectDisposedException()
{
// Arrange
var mockRequestExecuter = new Mock <IRequestExecuter>();
var bucket = new CouchbaseBucket(mockRequestExecuter.Object, new DefaultConverter(), new DefaultTranscoder());
bucket.Dispose();
// Act
Assert.Throws <ObjectDisposedException>(() => bucket.Upsert("key", new FakeDocument(), 0U));
}
public void Scope_Indexer_NotFound_Throws_ScopeNotFoundException()
{
var bucket = new CouchbaseBucket("default",
new ClusterContext(),
new Mock <IScopeFactory>().Object,
new Mock <IRetryOrchestrator>().Object,
new Mock <IVBucketKeyMapperFactory>().Object,
new Mock <ILogger <CouchbaseBucket> >().Object,
new Mock <IRedactor>().Object,
new Mock <IBootstrapperFactory>().Object);
Assert.Throws <ScopeNotFoundException>(() => bucket["doesnotexist"]);
}
public void Scope_NotFound_Throws_ScopeNoteFoundException( )
{
var bucket = new CouchbaseBucket("default",
new ClusterContext
{
SupportsCollections = true
},
new Mock <IScopeFactory>().Object,
new Mock <IRetryOrchestrator>().Object,
new Mock <IVBucketKeyMapperFactory>().Object,
new Mock <ILogger <CouchbaseBucket> >().Object);
Assert.Throws <ScopeNotFoundException>(() => bucket.Scope("doesnotexist"));
}
public void InsertAsync_Does_Not_Throw_StackOverFlowException()
{
var operationResult = new Mock <IOperationResult <dynamic> >();
operationResult.SetupGet(m => m.Success).Returns(true);
operationResult.SetupGet(m => m.Status).Returns(ResponseStatus.Success);
var mockRequestExecutor = new Mock <IRequestExecuter>();
mockRequestExecutor.Setup(x => x.SendWithRetryAsync(It.IsAny <IOperation <dynamic> >(), null, null))
.Returns(Task.FromResult(operationResult.Object));
var bucket = new CouchbaseBucket(mockRequestExecutor.Object, new DefaultConverter(), new DefaultTranscoder());
var result = bucket.InsertAsync <dynamic>("itskey", TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(10));
}
public void UpsertDictionary_DisposedBucket_ThrowsObjectDisposedException()
{
// Arrange
var mockRequestExecuter = new Mock <IRequestExecuter>();
var bucket = new CouchbaseBucket(mockRequestExecuter.Object, new DefaultConverter(), new DefaultTranscoder());
bucket.Dispose();
// Act
Assert.Throws <ObjectDisposedException>(() => bucket.Upsert(new Dictionary <string, FakeDocument>
{
{ "key", new FakeDocument() }
}));
}
public void UpsertDocument_DisposedBucket_ThrowsObjectDisposedException()
{
// Arrange
var mockRequestExecuter = new Mock <IRequestExecuter>();
var bucket = new CouchbaseBucket(mockRequestExecuter.Object, new DefaultConverter(), new DefaultTranscoder());
bucket.Dispose();
// Act
bucket.Upsert(new Document <FakeDocument>
{
Id = "key",
Content = new FakeDocument()
});
}
public void UpsertDocumentReplicateToPersistTo_DisposedBucket_ThrowsObjectDisposedException()
{
// Arrange
var mockRequestExecuter = new Mock <IRequestExecuter>();
var bucket = new CouchbaseBucket(mockRequestExecuter.Object, new DefaultConverter(), new DefaultTranscoder());
bucket.Dispose();
// Act
Assert.Throws <ObjectDisposedException>(() => bucket.Upsert(new Document <FakeDocument>
{
Id = "key",
Content = new FakeDocument()
},
ReplicateTo.One, PersistTo.One));
}
public void QueueSize_Returns_Error_Result_If_Document_Does_Not_Exists()
{
var mockExecutor = new Mock <IRequestExecuter>();
mockExecutor.Setup(x => x.SendWithRetry(It.IsAny <Get <List <object> > >()))
.Returns(new OperationResult <List <object> > {
Success = false
})
.Verifiable();
var bucket = new CouchbaseBucket(mockExecutor.Object, new DefaultConverter(), new DefaultTranscoder());
var result = bucket.QueueSize("my_queue");
Assert.IsNotNull(result);
Assert.IsFalse(result.Success);
mockExecutor.Verify();
}
public async Task <IBucket> BootstrapBucketAsync(string name, Uri uri, BucketType type)
{
var node = GetUnassignedNode(uri, ClusterOptions.EnableIPV6Addressing);
if (node == null)
{
var endpoint = uri.GetIpEndPoint(ClusterOptions.KvPort, ClusterOptions.UseInterNetworkV6Addresses);
node = await ClusterNode.CreateAsync(this, endpoint);
node.BootstrapUri = uri;
AddNode(node);
}
BucketBase bucket = null;
switch (type)
{
case BucketType.Couchbase:
case BucketType.Ephemeral:
bucket = new CouchbaseBucket(name, this);
break;
case BucketType.Memcached:
bucket = new MemcachedBucket(name, this);
break;
default:
throw new ArgumentOutOfRangeException(nameof(type), type, null);
}
try
{
await bucket.BootstrapAsync(node);
RegisterBucket(bucket);
return(bucket);
}
catch (Exception e)
{
Log.LogError(e, @"Could not bootstrap {name}");
UnRegisterBucket(bucket);
throw;
}
}
public void Scope_NotFound_Throws_ScopeNoteFoundException( )
{
var bucket = new CouchbaseBucket("default",
new ClusterContext
{
SupportsCollections = true
},
new Mock <IScopeFactory>().Object,
new Mock <IRetryOrchestrator>().Object,
new Mock <IVBucketKeyMapperFactory>().Object,
new Mock <ILogger <CouchbaseBucket> >().Object,
new Mock <IRedactor>().Object,
new Mock <IBootstrapperFactory>().Object,
NoopRequestTracer.Instance,
new Mock <IOperationConfigurator>().Object,
new BestEffortRetryStrategy());
Assert.ThrowsAsync <ScopeNotFoundException>(async() => await bucket.ScopeAsync("doesnotexist"));
}
public static bool LoadFile(string path, CouchbaseBucket bucket) {
if (File.Exists (path) ){
var fi = new FileInfo (path);
var byteArray = File.ReadAllBytes(path);
var document = new Document<dynamic> () {
Id = fi.Name,
Content = byteArray,
Expiry = uint.MaxValue //1.6 months in milliseconds, can be renewed
};
var upsert = bucket.Upsert(document);
if (upsert.Success) {
return true;
}
}
return false;
}
// tag::Create[]
public static IIntentProcessor Create(string intentName = "FallbackIntent")
{
switch (intentName)
{
case "MongodbComparisonIntent":
return(new MongoDbComparisonIntentProcessor(CouchbaseBucket.GetBucket()));
case "WhatIsCouchbaseIntent":
return(new WhatIsCouchbaseIntentProcessor(CouchbaseBucket.GetBucket()));
case "CouchDbIntent":
return(new CouchDbIntentProcessor());
case "FallbackIntent":
return(new FallbackIntentProcessor());
default:
return(new FallbackIntentProcessor());
}
}
public static void init(string hn, string bn)
{
defaultTimeSpan = new TimeSpan(0, 0, 0, 30);
string myurl = "http://" + hn + ":8091";
Console.WriteLine("About to init Cluster Helper: " + myurl);
ClusterHelper.Initialize(new ClientConfiguration
{
Servers = new List<Uri>
{
new Uri(myurl)
}
});
Console.WriteLine("About to get bucket: " + bn);
defaultBucket = (CouchbaseBucket) ClusterHelper.GetBucket(bn);
initDone = true;
}
public async Task QueueSizeAsync_Returns_Size_If_Document_Exists()
{
var items = new List <object> {
1, 2, 3
};
var mockExecutor = new Mock <IRequestExecuter>();
mockExecutor.Setup(x => x.SendWithRetryAsync(It.IsAny <Get <List <object> > >(), null, null))
.ReturnsAsync(new OperationResult <List <object> > {
Success = true, Value = items
})
.Verifiable();
var bucket = new CouchbaseBucket(mockExecutor.Object, new DefaultConverter(), new DefaultTranscoder());
var result = await bucket.QueueSizeAsync("my_queue");
Assert.IsNotNull(result);
Assert.IsTrue(result.Success);
Assert.AreEqual(items.Count, result.Value);
mockExecutor.Verify();
}
public static bool LoadFile(string path, CouchbaseBucket bucket)
{
if (File.Exists(path))
{
var fi = new FileInfo(path);
var byteArray = File.ReadAllBytes(path);
var document = new Document <dynamic> ()
{
Id = fi.Name,
Content = byteArray,
Expiry = uint.MaxValue //1.6 months in milliseconds, can be renewed
};
var upsert = bucket.Upsert(document);
if (upsert.Success)
{
return(true);
}
}
return(false);
}
public async Task Executing_MutateInAsync_With_XATTR_Throw_ServiceNotSupportedException_When_SubdocXAttributes_Is_False_And()
{
var mockController = new Mock <IClusterController>();
mockController.Setup(x => x.Configuration).Returns(new ClientConfiguration());
var mockCredentials = new Mock <IClusterCredentials>();
var mockConfig = new Mock <IConfigInfo>();
mockConfig.Setup(x => x.BucketConfig).Returns(new BucketConfig());
mockConfig.Setup(x => x.ClientConfig).Returns(new ClientConfiguration());
mockConfig.Setup(x => x.SupportsSubdocXAttributes).Returns(false);
var couchbaseBucket = new CouchbaseBucket(mockController.Object, "default", new DefaultConverter(), new DefaultTranscoder(), mockCredentials.Object);
(couchbaseBucket as IConfigObserver).NotifyConfigChanged(mockConfig.Object);
var result = await couchbaseBucket.MutateIn <dynamic>("key")
.Upsert("username", "value", SubdocMutateFlags.AttributePath)
.ExecuteAsync();
Assert.IsFalse(result.Success);
Assert.IsInstanceOf <FeatureNotAvailableException>(result.Exception, ExceptionUtil.XAttriburesNotAvailableMessage);
}
public void UpsertKeyValueCasExpiration_DisposedBucket_ThrowsObjectDisposedException()
{
// Arrange
var mockRequestExecuter = new Mock<IRequestExecuter>();
var bucket = new CouchbaseBucket(mockRequestExecuter.Object, new DefaultConverter(), new DefaultTranscoder());
bucket.Dispose();
// Act
bucket.Upsert("key", new FakeDocument(), 0UL, 0U);
}
public async Task QueueSizeAsync_Returns_Error_Result_If_Document_Does_Not_Exists()
{
var mockExecutor = new Mock<IRequestExecuter>();
mockExecutor.Setup(x => x.SendWithRetryAsync(It.IsAny<Get<List<object>>>(), null, null))
.ReturnsAsync(new OperationResult<List<object>> { Success = false })
.Verifiable();
var bucket = new CouchbaseBucket(mockExecutor.Object, new DefaultConverter(), new DefaultTranscoder());
var result = await bucket.QueueSizeAsync("my_queue");
Assert.IsNotNull(result);
Assert.IsFalse(result.Success);
mockExecutor.Verify();
}
public void UpsertKeyValueCasExpirationReplicateToPersistTo_DisposedBucket_ThrowsObjectDisposedException()
{
// Arrange
var mockRequestExecuter = new Mock<IRequestExecuter>();
var bucket = new CouchbaseBucket(mockRequestExecuter.Object, new DefaultConverter(), new DefaultTranscoder());
bucket.Dispose();
// Act
Assert.Throws<ObjectDisposedException>(() => bucket.Upsert("key", new FakeDocument(), 0UL, 0U, ReplicateTo.One, PersistTo.One));
}
public void UpsertKeyValueExpirationTS_DisposedBucket_ThrowsObjectDisposedException()
{
// Arrange
var mockRequestExecuter = new Mock<IRequestExecuter>();
var bucket = new CouchbaseBucket(mockRequestExecuter.Object, new DefaultConverter(), new DefaultTranscoder());
bucket.Dispose();
// Act
Assert.Throws<ObjectDisposedException>(() => bucket.Upsert("key", new FakeDocument(), TimeSpan.Zero));
}
public void UpsertDictionaryParallelOptionsRangeSize_DisposedBucket_ThrowsObjectDisposedException()
{
// Arrange
var mockRequestExecuter = new Mock<IRequestExecuter>();
var bucket = new CouchbaseBucket(mockRequestExecuter.Object, new DefaultConverter(), new DefaultTranscoder());
bucket.Dispose();
// Act
Assert.Throws<ObjectDisposedException>(() => bucket.Upsert(new Dictionary<string, FakeDocument>
{
{ "key", new FakeDocument() }
},
new ParallelOptions(), 0));
}
public async Task QueueSizeAsync_Returns_Size_If_Document_Exists()
{
var items = new List<object> { 1, 2, 3 };
var mockExecutor = new Mock<IRequestExecuter>();
mockExecutor.Setup(x => x.SendWithRetryAsync(It.IsAny<Get<List<object>>>(), null, null))
.ReturnsAsync(new OperationResult<List<object>> { Success = true, Value = items })
.Verifiable();
var bucket = new CouchbaseBucket(mockExecutor.Object, new DefaultConverter(), new DefaultTranscoder());
var result = await bucket.QueueSizeAsync("my_queue");
Assert.IsNotNull(result);
Assert.IsTrue(result.Success);
Assert.AreEqual(items.Count, result.Value);
mockExecutor.Verify();
}
public IBucket CreateBucket(string bucketName, string password)
{
var success = false;
IBucket bucket = null;
foreach (var provider in _configProviders)
{
try
{
Log.DebugFormat("Trying to boostrap with {0}.", provider);
var config = provider.GetConfig(bucketName, password);
switch (config.NodeLocator)
{
case NodeLocatorEnum.VBucket:
bucket = new CouchbaseBucket(this, bucketName, _converter, _serializer);
bucket.AddRef();
break;
case NodeLocatorEnum.Ketama:
bucket = new MemcachedBucket(this, bucketName, _converter, _serializer);
bucket.AddRef();
break;
default:
throw new ArgumentOutOfRangeException();
}
var configObserver = bucket as IConfigObserver;
if (provider.ObserverExists(configObserver))
{
Log.DebugFormat("Using existing bootstrap {0}.", provider);
configObserver.NotifyConfigChanged(config);
success = true;
break;
}
if (provider.RegisterObserver(configObserver) &&
_buckets.TryAdd(bucket.Name, bucket))
{
Log.DebugFormat("Successfully boostrap using {0}.", provider);
configObserver.NotifyConfigChanged(config);
success = true;
break;
}
configObserver.NotifyConfigChanged(config);
success = true;
break;
}
catch (BucketNotFoundException e)
{
Log.Warn(e);
}
catch (ConfigException e)
{
Log.Warn(e);
}
catch (AuthenticationException e)
{
Log.Warn(e);
break;
}
}
if (!success)
{
throw new ConfigException("Could not bootstrap {0}. See log for details.", bucketName);
}
return(bucket);
}
public void UpsertDocumentReplicateToPersistTo_DisposedBucket_ThrowsObjectDisposedException()
{
// Arrange
var mockRequestExecuter = new Mock<IRequestExecuter>();
var bucket = new CouchbaseBucket(mockRequestExecuter.Object, new DefaultConverter(), new DefaultTranscoder());
bucket.Dispose();
// Act
bucket.Upsert(new Document<FakeDocument>
{
Id = "key",
Content = new FakeDocument()
},
ReplicateTo.One, PersistTo.One);
}
public void UpsertDocument_DisposedBucket_ThrowsObjectDisposedException()
{
// Arrange
var mockRequestExecuter = new Mock<IRequestExecuter>();
var bucket = new CouchbaseBucket(mockRequestExecuter.Object, new DefaultConverter(), new DefaultTranscoder());
bucket.Dispose();
// Act
Assert.Throws<ObjectDisposedException>(() => bucket.Upsert(new Document<FakeDocument>
{
Id = "key",
Content = new FakeDocument()
}));
}
