public void When_Storing_A_New_Key_Observe_Will_Fail_With_Persistence_More_Than_Available_Nodes()
{
var kv = KeyValueUtils.GenerateKeyAndValue("observe");
IStoreOperationResult storeResult = null;
var availableNodesCount = getWorkingNodes().Count();
switch (availableNodesCount)
{
case 1:
{
storeResult = _Client.ExecuteStore(StoreMode.Set, kv.Item1, kv.Item2, PersistTo.Two);
break;
}
case 2:
{
storeResult = _Client.ExecuteStore(StoreMode.Set, kv.Item1, kv.Item2, PersistTo.Three);
break;
}
case 3:
{
storeResult = _Client.ExecuteStore(StoreMode.Set, kv.Item1, kv.Item2, PersistTo.Four);
break;
}
default:
{
storeResult = _Client.ExecuteStore(StoreMode.Set, kv.Item1, kv.Item2, PersistTo.Four);
break;
}
}
Assert.That(storeResult.Success, Is.False);
}
public void When_Storing_A_New_Key_Observe_Will_Fail_When_Cluster_Has_Too_Few_Nodes_For_Replication()
{
var kv = KeyValueUtils.GenerateKeyAndValue("observe");
var storeResult = _Client.ExecuteStore(StoreMode.Set, kv.Item1, kv.Item2, ReplicateTo.Three);
Assert.That(storeResult.Success, Is.False);
}
public void When_Storing_A_New_Key_Observe_Will_Pass_With_Replication_More_Than_Available_Nodes()
{
var kv = KeyValueUtils.GenerateKeyAndValue("observe");
IStoreOperationResult storeResult = null;
var availableNodesCount = getWorkingNodes().Count();
switch (availableNodesCount)
{
case 1:
{
storeResult = _Client.ExecuteStore(StoreMode.Set, kv.Item1, kv.Item2, ReplicateTo.Two);
break;
}
case 2:
{
storeResult = _Client.ExecuteStore(StoreMode.Set, kv.Item1, kv.Item2, ReplicateTo.Three);
break;
}
default:
{
storeResult = _Client.ExecuteStore(StoreMode.Set, kv.Item1, kv.Item2, ReplicateTo.Three);
break;
}
}
StoreAssertPass(storeResult);
}
public void When_Storing_A_New_Key_Observe_Will_Succeed_With_Master_Persistence_And_Single_Node_Replication()
{
var kv = KeyValueUtils.GenerateKeyAndValue("observe");
var storeResult = Client.ExecuteStore(StoreMode.Set, kv.Item1, kv.Item2, PersistTo.One, ReplicateTo.One);
TestUtils.StoreAssertPass(storeResult);
}
public void When_Storing_A_New_Key_Observe_Will_Succeed_With_Multi_Node_Replication()
{
var kv = KeyValueUtils.GenerateKeyAndValue("observe");
var storeResult = _Client.ExecuteStore(StoreMode.Set, kv.Item1, kv.Item2, ReplicateTo.One);
StoreAssertPass(storeResult);
}
public void When_Getting_Key_With_Lock_And_Expiry_Set_Fails_Until_Lock_Expires()
{
var kv = KeyValueUtils.GenerateKeyAndValue("getl");
var storeResult = TestUtils.Store(Client, StoreMode.Set, kv.Item1, kv.Item2);
TestUtils.StoreAssertPass(storeResult);
var casResult = Client.GetWithLock(kv.Item1, TimeSpan.FromSeconds(2));
Assert.That(casResult.Result, Is.EqualTo(kv.Item2));
storeResult = Client.ExecuteStore(StoreMode.Set, kv.Item1, KeyValueUtils.GenerateValue());
Assert.That(storeResult.Success, Is.False);
Thread.Sleep(3000);
var newValue = KeyValueUtils.GenerateValue();
storeResult = Client.ExecuteStore(StoreMode.Set, kv.Item1, newValue);
Assert.That(storeResult.Success, Is.True);
var getResult = Client.ExecuteGet(kv.Item1);
TestUtils.GetAssertPass(getResult, newValue);
}
public void When_Execute_Unlocking_A_Key_With_Invalid_Cas_Key_Is_Unlocked()
{
var kv = KeyValueUtils.GenerateKeyAndValue("getl");
var storeResult = TestUtils.Store(Client, StoreMode.Set, kv.Item1, kv.Item2);
TestUtils.StoreAssertPass(storeResult);
var getlResult1 = Client.ExecuteGetWithLock <string>(kv.Item1, TimeSpan.FromSeconds(15));
Assert.That(getlResult1.Value, Is.EqualTo(kv.Item2));
Assert.That(getlResult1.Success, Is.True);
var getlResult2 = Client.ExecuteGetWithLock <string>(kv.Item1, TimeSpan.FromSeconds(15));
Assert.That(getlResult2.Success, Is.False);
var unlockResult = Client.ExecuteUnlock(kv.Item1, getlResult1.Cas - 1);
Assert.That(unlockResult.Success, Is.False);
storeResult = TestUtils.Store(Client, StoreMode.Set, kv.Item1, kv.Item2);
TestUtils.StoreAssertFail(storeResult);
var getlResult3 = Client.ExecuteGetWithLock <string>(kv.Item1, TimeSpan.FromSeconds(15));
Assert.That(getlResult3.Success, Is.False);
}
public void When_Execute_Getting_Key_With_Lock_And_Expiry_Second_Lock_Attempt_Does_Not_Change_Expiry()
{
var kv = KeyValueUtils.GenerateKeyAndValue("getl");
var storeResult = TestUtils.Store(Client, StoreMode.Set, kv.Item1, kv.Item2);
TestUtils.StoreAssertPass(storeResult);
var getlResult = Client.ExecuteGetWithLock(kv.Item1, TimeSpan.FromSeconds(6));
Assert.That(getlResult.Value, Is.EqualTo(kv.Item2));
var otherGetlResult = Client.ExecuteGetWithLock(kv.Item1, TimeSpan.FromSeconds(2));
Assert.That(otherGetlResult.Cas, Is.Not.EqualTo(getlResult.Cas));
Assert.That(otherGetlResult.StatusCode, Is.EqualTo((int)CouchbaseStatusCodeEnums.LockError));
Thread.Sleep(3000);
storeResult = Client.ExecuteStore(StoreMode.Set, kv.Item1, KeyValueUtils.GenerateValue());
Assert.That(storeResult.Success, Is.False);
Assert.That(storeResult.StatusCode.Value, Is.EqualTo((int)StatusCodeEnums.DataExistsForKey));
Thread.Sleep(4000);
var newValue = KeyValueUtils.GenerateValue();
storeResult = Client.ExecuteStore(StoreMode.Set, kv.Item1, newValue);
Assert.That(storeResult.Success, Is.True, "Failed to update item");
var getResult = Client.ExecuteGet(kv.Item1);
TestUtils.GetAssertPass(getResult, newValue);
}
public void When_Storing_A_New_Key_Observe_Will_Fail_With_Replication_More_Than_Available_Nodes()
{
var availableNodesCount = getWorkingNodes().Count();
var kv = KeyValueUtils.GenerateKeyAndValue("observe");
var storeResult = Client.ExecuteStore(StoreMode.Set, kv.Item1, kv.Item2);
switch (availableNodesCount)
{
case 1:
{
var observeResult = Client.Observe(kv.Item2, storeResult.Cas, PersistTo.Zero, ReplicateTo.Two);
Assert.That(observeResult.Success, Is.False);
break;
}
case 2:
{
var observeResult = Client.Observe(kv.Item2, storeResult.Cas, PersistTo.Zero, ReplicateTo.Three);
Assert.That(observeResult.Success, Is.False);
break;
}
default:
{
Assert.Fail("The test is applicable only when the number of nodes in cluster is either one or two.");
break;
}
}
}
public void When_Storing_A_New_Key_Observe_Will_Succeed_With_Master_Only_Persistence()
{
var kv = KeyValueUtils.GenerateKeyAndValue("observe");
var storeResult = _Client.ExecuteStore(StoreMode.Set, kv.Item1, kv.Item2, PersistTo.One);
StoreAssertPass(storeResult);
}
public void When_Storing_A_New_Key_Observe_Will_Succeed_With_Zero_Persistence_And_Zero_Replication()
{
var kv = KeyValueUtils.GenerateKeyAndValue("observe");
var storeResult = _Client.ExecuteStore(StoreMode.Set, kv.Item1, kv.Item2, PersistTo.Zero, ReplicateTo.Zero);
StoreAssertPass(storeResult);
}
public void When_Storing_A_New_Key_Observe_Will_Fail_With_Master_Persistence_And_Cas_Value_Has_Changed()
{
var kv = KeyValueUtils.GenerateKeyAndValue("observe");
var storeResult = _Client.ExecuteStore(StoreMode.Set, kv.Item1, kv.Item2);
var observeResult = _Client.Observe(kv.Item2, storeResult.Cas - 1, PersistTo.One, ReplicateTo.Zero);
Assert.That(observeResult.Success, Is.False);
Assert.That(observeResult.Message, Is.StringMatching(ObserveOperationConstants.MESSAGE_MODIFIED));
}
public void When_Timeout_Is_Set_To_Greater_Than_30_Seconds_Exception_Is_Thrown()
{
var kv = KeyValueUtils.GenerateKeyAndValue("getl");
var storeResult = TestUtils.Store(Client, StoreMode.Set, kv.Item1, kv.Item2);
TestUtils.StoreAssertPass(storeResult);
var getlResult = Client.ExecuteGetWithLock(kv.Item1, TimeSpan.FromSeconds(31));
}
public void When_Timeout_Is_Less_Than_Or_Equal_To_30_Seconds_Exception_Is_Not_Thrown()
{
var kv = KeyValueUtils.GenerateKeyAndValue("getl");
var storeResult = TestUtils.Store(Client, StoreMode.Set, kv.Item1, kv.Item2);
TestUtils.StoreAssertPass(storeResult);
Client.ExecuteGetWithLock(kv.Item1, TimeSpan.FromSeconds(30));
Client.ExecuteGetWithLock(kv.Item1, TimeSpan.FromSeconds(29));
Assert.Pass();
}
public void When_Storing_A_New_Key_Observe_Will_Succeed_With_Multi_Node_Persistence_And_Single_Node_Replication()
{
var availableNodesCount = getWorkingNodes().Count();
if (availableNodesCount > 1)
{
var kv = KeyValueUtils.GenerateKeyAndValue("observe");
var storeResult = Client.ExecuteStore(StoreMode.Set, kv.Item1, kv.Item2, PersistTo.Two, ReplicateTo.One);
TestUtils.StoreAssertPass(storeResult);
}
else
{
Assert.Ignore("This test requires more than one node in the cluster");
}
}
public void When_Storing_A_New_Key_Observe_Will_Fail_When_Cluster_Has_Too_Few_Nodes_For_Replication()
{
var availableNodesCount = getWorkingNodes().Count();
if (availableNodesCount > 1)
{
var kv = KeyValueUtils.GenerateKeyAndValue("observe");
var storeResult = Client.ExecuteStore(StoreMode.Set, kv.Item1, kv.Item2, ReplicateTo.Three);
Assert.That(storeResult.Success, Is.False);
}
else
{
Assert.Ignore("This test requires more than one node in the cluster");
}
}
public void When_Execute_Getting_Key_With_Lock_Set_Fails_While_Locked()
{
var kv = KeyValueUtils.GenerateKeyAndValue("getl");
var storeResult = TestUtils.Store(Client, StoreMode.Set, kv.Item1, kv.Item2);
TestUtils.StoreAssertPass(storeResult);
var getlResult = Client.ExecuteGetWithLock(kv.Item1);
Assert.That(getlResult.Value, Is.EqualTo(kv.Item2));
storeResult = Client.ExecuteStore(StoreMode.Set, kv.Item1, KeyValueUtils.GenerateValue());
Assert.That(storeResult.Success, Is.False);
Assert.That(storeResult.StatusCode.Value, Is.EqualTo((int)StatusCodeEnums.DataExistsForKey));
}
public void When_Getting_Key_With_Lock_And_Expiry_Set_Succeeds_With_Valid_Cas()
{
var kv = KeyValueUtils.GenerateKeyAndValue("getl");
var storeResult = TestUtils.Store(Client, StoreMode.Set, kv.Item1, kv.Item2);
TestUtils.StoreAssertPass(storeResult);
var casResult = Client.GetWithLock(kv.Item1, TimeSpan.FromSeconds(15));
Assert.That(casResult.Result, Is.EqualTo(kv.Item2));
storeResult = Client.ExecuteStore(StoreMode.Set, kv.Item1, KeyValueUtils.GenerateValue());
Assert.That(storeResult.Success, Is.False);
storeResult = Client.ExecuteCas(StoreMode.Set, kv.Item1, KeyValueUtils.GenerateValue(), casResult.Cas);
Assert.That(storeResult.Success, Is.True);
}
public void When_Using_App_Config_And_HttpClient_Factory_Is_Not_Set_Operations_Succeed()
{
var config = ConfigurationManager.GetSection("min-config") as CouchbaseClientSection;
Assert.That(config, Is.Not.Null, "min-config section missing from app.config");
Assert.That(config.HttpClientFactory, Is.InstanceOf <ProviderElement <IHttpClientFactory> >());
var client = new CouchbaseClient(config);
var kv = KeyValueUtils.GenerateKeyAndValue("default_config");
var result = client.ExecuteStore(StoreMode.Add, kv.Item1, kv.Item2);
Assert.That(result.Success, Is.True, "Store failed: " + result.Message);
var value = client.Get(kv.Item1);
Assert.That(value, Is.StringMatching(kv.Item2));
}
public void When_Generic_Execute_Getting_Key_With_Lock_And_Expiry_Set_Succeeds_With_Valid_Cas()
{
var kv = KeyValueUtils.GenerateKeyAndValue("getl");
var storeResult = Store(StoreMode.Set, kv.Item1, kv.Item2);
StoreAssertPass(storeResult);
var getlResult = _Client.ExecuteGetWithLock <string>(kv.Item1, TimeSpan.FromSeconds(15));
Assert.That(getlResult.Value, Is.EqualTo(kv.Item2));
storeResult = _Client.ExecuteStore(StoreMode.Set, kv.Item1, KeyValueUtils.GenerateValue());
Assert.That(storeResult.Success, Is.False);
storeResult = _Client.ExecuteCas(StoreMode.Set, kv.Item1, KeyValueUtils.GenerateValue(), getlResult.Cas);
Assert.That(storeResult.Success, Is.True);
}
public void When_Using_Code_Config_And_HttpClient_Factory_Is_Not_Set_Operations_Succeed()
{
var config = new CouchbaseClientConfiguration();
config.Urls.Add(new Uri("http://localhost:8091/pools"));
Assert.That(config.HttpClientFactory, Is.InstanceOf <DefaultHttpClientFactory>());
Assert.That(config, Is.Not.Null, "min-config section missing from app.config");
Assert.That(config.HttpClientFactory, Is.InstanceOf <DefaultHttpClientFactory>());
var client = new CouchbaseClient(config);
var kv = KeyValueUtils.GenerateKeyAndValue("default_config");
var result = client.ExecuteStore(StoreMode.Add, kv.Item1, kv.Item2);
Assert.That(result.Success, Is.True, "Store failed: " + result.Message);
var value = client.Get(kv.Item1);
Assert.That(value, Is.StringMatching(kv.Item2));
}
