public void RTableDeleteSync()
{
string firstName = "FirstName04";
string lastName = "LastName04";
string email = "*****@*****.**";
string phone = "1-800-123-0004";
// Insert entity
CustomerEntity newCustomer = new CustomerEntity(firstName, lastName);
newCustomer.Email = email;
newCustomer.PhoneNumber = phone;
TableOperation operation = TableOperation.InsertOrReplace(newCustomer);
TableResult result = repTable.Execute(operation);
Assert.AreNotEqual(null, result, "result = null");
ReplicatedTableEntity row = (ReplicatedTableEntity)result.Result;
Assert.AreNotEqual(result, null);
Assert.AreNotEqual(result.HttpStatusCode, 503);
Assert.AreNotEqual(result.Result, null);
Assert.AreEqual(result.Etag, "1");
Assert.AreEqual(row._rtable_RowLock, false);
Assert.AreEqual(row._rtable_Version, 1);
Assert.AreEqual(row._rtable_Tombstone, false);
Assert.AreEqual(row._rtable_ViewId, this.rtableTestConfiguration.RTableInformation.ViewId);
Assert.AreEqual((int)HttpStatusCode.NoContent, result.HttpStatusCode, "result.HttpStatusCode mismatch");
Assert.AreNotEqual(null, result.Result, "result.Result = null");
Assert.AreEqual("1", result.Etag, "result.Etag mismatch");
Assert.AreEqual(false, row._rtable_RowLock, "row._rtable_RowLock mismatch");
Assert.AreEqual(1, row._rtable_Version, "row._rtable_Version mismatch");
Assert.AreEqual(false, row._rtable_Tombstone, "row._rtable_Tombstone mismatch");
Assert.AreEqual(this.rtableTestConfiguration.RTableInformation.ViewId, row._rtable_ViewId, "row._rtable_ViewId mismatch");
// Delete operation
Console.WriteLine("Calling TableOperation.Delete(newCustomer)...");
newCustomer = new CustomerEntity(firstName, lastName);
newCustomer.ETag = result.Etag;
operation = TableOperation.Delete(newCustomer);
TableResult deleteResult = repTable.Execute(operation);
Assert.AreNotEqual(null, deleteResult, "deleteResult = null");
Assert.AreEqual((int)HttpStatusCode.NoContent, deleteResult.HttpStatusCode, "deleteResult.HttpStatusCode mismatch");
Assert.IsNotNull(deleteResult.Result, "deleteResult.Result = null");
// Retrieve
Console.WriteLine("Calling TableOperation.Retrieve() after Delete() was called...");
operation = TableOperation.Retrieve<CustomerEntity>(firstName, lastName);
TableResult retrievedResult2 = repTable.Execute(operation);
Assert.AreEqual((int)HttpStatusCode.NotFound, retrievedResult2.HttpStatusCode, "retrievedResult2.HttpStatusCode mismatch");
Assert.IsNull(retrievedResult2.Result, "retrievedResult2.Result != null");
}
public void ReplaceUsingLargerViewId()
{
long currentViewId = 100;
long futureViewId = currentViewId + 1;
this.UpdateConfiguration(replicas, 0, false, currentViewId);
string firstName = "FirstName02";
string lastName = "LastName02";
string email = "*****@*****.**";
string phone = "1-800-123-0001";
// Insert entity
CustomerEntity newCustomer = new CustomerEntity(firstName, lastName);
newCustomer.Email = email;
newCustomer.PhoneNumber = phone;
TableOperation operation = TableOperation.Insert(newCustomer);
TableResult result = this.repTable.Execute(operation);
Assert.AreNotEqual(null, result, "result = null");
ReplicatedTableEntity row = (ReplicatedTableEntity)result.Result;
Assert.AreEqual((int)HttpStatusCode.NoContent, result.HttpStatusCode, "result.HttpStatusCode mismatch");
Assert.AreNotEqual(null, result.Result, "result.Result = null");
Assert.AreEqual("1", result.Etag, "result.Etag mismatch");
Assert.AreEqual(false, row._rtable_RowLock, "row._rtable_RowLock mismatch");
Assert.AreEqual(1, row._rtable_Version, "row._rtable_Version mismatch");
Assert.AreEqual(false, row._rtable_Tombstone, "row._rtable_Tombstone mismatch");
Assert.AreEqual(currentViewId, row._rtable_ViewId, "row._rtable_ViewId mismatch");
Console.WriteLine("Successfully created an entity");
// Retrieve entity
operation = TableOperation.Retrieve<CustomerEntity>(firstName, lastName);
TableResult retrievedResult = this.repTable.Execute(operation);
Assert.AreNotEqual(null, retrievedResult, "retrievedResult = null");
CustomerEntity customer = (CustomerEntity)retrievedResult.Result;
Assert.AreEqual((int)HttpStatusCode.OK, retrievedResult.HttpStatusCode, "retrievedResult.HttpStatusCode mismatch");
Assert.AreNotEqual(null, retrievedResult.Result, "retrievedResult.Result = null");
Assert.AreEqual("1", retrievedResult.Etag, "retrievedResult.Etag mismatch");
Assert.AreEqual(false, customer._rtable_RowLock, "customer._rtable_RowLock mismatch");
Assert.AreEqual(1, customer._rtable_Version, "customer._rtable_Version mismatch");
Assert.AreEqual(false, customer._rtable_Tombstone, "customer._rtable_Tombstone mismatch");
Assert.AreEqual(currentViewId, customer._rtable_ViewId, "customer._rtable_ViewId mismatch");
Assert.AreEqual(newCustomer.PhoneNumber, customer.PhoneNumber, "customer.PhoneNumber mismatch");
Assert.AreEqual(newCustomer.Email, customer.Email, "customer.Email mismatch");
Console.WriteLine("Successfully retrieved the entity");
//
// Call ModifyConfigurationBlob to change the viewId of the wrapper to a larger value
//
Console.WriteLine("Changing the viewId to futureViewId {0}", futureViewId);
this.UpdateConfiguration(replicas, 0, false, futureViewId);
//
// Replace entity
//
Console.WriteLine("\nCalling Replace with larger viewId...");
email = "*****@*****.**";
phone = "1-800-123-0002";
customer.Email = email;
customer.PhoneNumber = phone;
operation = TableOperation.Replace(customer);
result = repTable.Execute(operation);
Assert.AreNotEqual(null, result, "result = null");
Assert.AreEqual((int)HttpStatusCode.NoContent, result.HttpStatusCode, "result.HttpStatusCode mismatch");
Assert.AreNotEqual(null, result.Result, "result.Result = null");
// Retrieve Entity
Console.WriteLine("\nCalling Retrieve() with larger viewId...");
operation = TableOperation.Retrieve<CustomerEntity>(firstName, lastName);
retrievedResult = repTable.Execute(operation);
Assert.AreNotEqual(null, retrievedResult, "retrievedResult = null");
CustomerEntity customer2 = (CustomerEntity)retrievedResult.Result;
Assert.AreEqual((int)HttpStatusCode.OK, retrievedResult.HttpStatusCode, "retrievedResult.HttpStatusCode mismatch");
Assert.AreNotEqual(null, retrievedResult.Result, "retrievedResult.Result = null");
Assert.AreEqual("2", retrievedResult.Etag, "retrievedResult.Etag mismatch");
Assert.AreEqual(false, customer2._rtable_RowLock, "customer2._rtable_RowLock mismatch");
Assert.AreEqual(2, customer2._rtable_Version, "customer2._rtable_Version mismatch");
Assert.AreEqual(false, customer2._rtable_Tombstone, "customer2._rtable_Tombstone mismatch");
Assert.AreEqual(futureViewId, customer2._rtable_ViewId, "customer2._rtable_ViewId mismatch");
Assert.AreEqual(phone, customer2.PhoneNumber, "customer2.PhoneNumber mismatch");
Assert.AreEqual(email, customer2.Email, "customer2.Email mismatch");
Console.WriteLine("Successfully retrieved the entity");
//
// Delete entity
//
Console.WriteLine("\nCalling Delete with larger viewId...");
operation = TableOperation.Delete(customer);
TableResult deleteResult = repTable.Execute(operation);
Assert.AreNotEqual(null, deleteResult, "deleteResult = null");
Assert.AreEqual((int)HttpStatusCode.NoContent, deleteResult.HttpStatusCode, "deleteResult.HttpStatusCode mismatch");
Assert.IsNotNull(deleteResult.Result, "deleteResult.Result = null");
// Retrieve
Console.WriteLine("Calling TableOperation.Retrieve() after Delete() was called...");
operation = TableOperation.Retrieve<CustomerEntity>(firstName, lastName);
TableResult retrievedResult2 = repTable.Execute(operation);
Assert.AreEqual((int)HttpStatusCode.NotFound, retrievedResult2.HttpStatusCode, "retrievedResult2.HttpStatusCode mismatch");
Assert.IsNull(retrievedResult2.Result, "retrievedResult2.Result != null");
}
public void ExceptionWhenUsingSmallerViewId()
{
long currentViewId = 100;
long badViewId = currentViewId - 1;
this.UpdateConfiguration(replicas, 0, false, currentViewId);
string firstName = "FirstName01";
string lastName = "LastName01";
string email = "*****@*****.**";
string phone = "1-800-123-0001";
// Insert entity
CustomerEntity newCustomer = new CustomerEntity(firstName, lastName);
newCustomer.Email = email;
newCustomer.PhoneNumber = phone;
TableOperation operation = TableOperation.Insert(newCustomer);
TableResult result = this.repTable.Execute(operation);
Assert.AreNotEqual(null, result, "result = null");
ReplicatedTableEntity row = (ReplicatedTableEntity)result.Result;
Assert.AreEqual((int)HttpStatusCode.NoContent, result.HttpStatusCode, "result.HttpStatusCode mismatch");
Assert.AreNotEqual(null, result.Result, "result.Result = null");
Assert.AreEqual("1", result.Etag, "result.Etag mismatch");
Assert.AreEqual(false, row._rtable_RowLock, "row._rtable_RowLock mismatch");
Assert.AreEqual(1, row._rtable_Version, "row._rtable_Version mismatch");
Assert.AreEqual(false, row._rtable_Tombstone, "row._rtable_Tombstone mismatch");
Assert.AreEqual(currentViewId, row._rtable_ViewId, "row._rtable_ViewId mismatch");
Console.WriteLine("Successfully created an entity");
// Retrieve entity
operation = TableOperation.Retrieve<CustomerEntity>(firstName, lastName);
TableResult retrievedResult = this.repTable.Execute(operation);
Assert.AreNotEqual(null, retrievedResult, "retrievedResult = null");
CustomerEntity customer = (CustomerEntity)retrievedResult.Result;
Assert.AreEqual((int)HttpStatusCode.OK, retrievedResult.HttpStatusCode, "retrievedResult.HttpStatusCode mismatch");
Assert.AreNotEqual(null, retrievedResult.Result, "retrievedResult.Result = null");
Assert.AreEqual("1", retrievedResult.Etag, "retrievedResult.Etag mismatch");
Assert.AreEqual(false, customer._rtable_RowLock, "customer._rtable_RowLock mismatch");
Assert.AreEqual(1, customer._rtable_Version, "customer._rtable_Version mismatch");
Assert.AreEqual(false, customer._rtable_Tombstone, "customer._rtable_Tombstone mismatch");
Assert.AreEqual(currentViewId, customer._rtable_ViewId, "customer._rtable_ViewId mismatch");
Assert.AreEqual(newCustomer.PhoneNumber, customer.PhoneNumber, "customer.PhoneNumber mismatch");
Assert.AreEqual(newCustomer.Email, customer.Email, "customer.Email mismatch");
Console.WriteLine("Successfully retrieved the entity");
//
// Call RefreshRTableEnvJsonConfigBlob to change the viewId of the wrapper to an older value
//
Console.WriteLine("Changing the viewId to badViewId {0}", badViewId);
this.UpdateConfiguration(replicas, 0, false, badViewId);
//
// Retrieve with bad viewId
//
Console.WriteLine("\nCalling Retrieve with badViewId...");
operation = TableOperation.Retrieve<CustomerEntity>(firstName, lastName);
try
{
retrievedResult = this.repTable.Execute(operation);
Assert.Fail("Retrieve() is expected to get an RTableStaleViewException but did not get it.");
}
catch (ReplicatedTableStaleViewException ex)
{
Console.WriteLine("Get this RTableStaleViewException: {0}", ex.Message);
Assert.IsTrue(ex.Message.Contains(string.Format("current _rtable_ViewId {0} is smaller than", badViewId)), "Got unexpected exception message");
}
//
// Replace with bad viewId
//
Console.WriteLine("\nCalling Replace with badViewId...");
operation = TableOperation.Replace(customer);
try
{
retrievedResult = this.repTable.Execute(operation);
Assert.Fail("Replace() is expected to get an RTableStaleViewException but did not get it.");
}
catch (ReplicatedTableStaleViewException ex)
{
Console.WriteLine("Get this RTableStaleViewException: {0}", ex.Message);
Assert.IsTrue(ex.Message.Contains(string.Format("current _rtable_ViewId {0} is smaller than", badViewId)), "Got unexpected exception message");
}
//
// InsertOrMerge with bad viewId
//
Console.WriteLine("\nCalling InsertOrMerge with badViewId...");
operation = TableOperation.InsertOrMerge(customer);
try
{
retrievedResult = this.repTable.Execute(operation);
Assert.Fail("InsertOrMerge() is expected to get an RTableStaleViewException but did not get it.");
}
catch (ReplicatedTableStaleViewException ex)
{
Console.WriteLine("Get this RTableStaleViewException: {0}", ex.Message);
Assert.IsTrue(ex.Message.Contains(string.Format("current _rtable_ViewId {0} is smaller than", badViewId)), "Got unexpected exception message");
}
//
// InsertOrReplace with bad viewId
//
Console.WriteLine("\nCalling InsertOrReplace with badViewId...");
operation = TableOperation.InsertOrReplace(customer);
try
{
retrievedResult = this.repTable.Execute(operation);
Assert.Fail("InsertOrReplace() is expected to get an RTableStaleViewException but did not get it.");
}
catch (ReplicatedTableStaleViewException ex)
{
Console.WriteLine("Get this RTableStaleViewException: {0}", ex.Message);
Assert.IsTrue(ex.Message.Contains(string.Format("current _rtable_ViewId {0} is smaller than", badViewId)), "Got unexpected exception message");
}
//
// Merge with bad viewId
//
Console.WriteLine("\nCalling Merge with badViewId...");
operation = TableOperation.Merge(customer);
try
{
retrievedResult = this.repTable.Execute(operation);
Assert.Fail("Merge() is expected to get an RTableStaleViewException but did not get it.");
}
catch (ReplicatedTableStaleViewException ex)
{
Console.WriteLine("Get this RTableStaleViewException: {0}", ex.Message);
Assert.IsTrue(ex.Message.Contains(string.Format("current _rtable_ViewId {0} is smaller than", badViewId)), "Got unexpected exception message");
}
//
// Delete with bad viewId
//
Console.WriteLine("\nCalling Delete with badViewId...");
operation = TableOperation.Delete(customer);
try
{
retrievedResult = this.repTable.Execute(operation);
Assert.Fail("Delete() is expected to get an RTableStaleViewException but did not get it.");
}
catch (ReplicatedTableStaleViewException ex)
{
Console.WriteLine("Get this RTableStaleViewException: {0}", ex.Message);
Assert.IsTrue(ex.Message.Contains(string.Format("current _rtable_ViewId {0} is smaller than", badViewId)), "Got unexpected exception message");
}
}
public void XStoreCRUDTest()
{
CloudTableClient tableClient = this.cloudTableClients[0];
CloudTable table = tableClient.GetTableReference(this.repTable.TableName);
string firstName = "FirstNameXStore";
string lastName = "LastNameXStore";
string email = "*****@*****.**";
string phone = "1-800-123-0001";
CustomerEntity newCustomer = new CustomerEntity(firstName, lastName);
newCustomer.Email = email;
newCustomer.PhoneNumber = phone;
// XStore Insert
Console.WriteLine("Calling XStore Insert...");
TableOperation insertOperation = TableOperation.Insert(newCustomer);
TableResult insertResult = table.Execute(insertOperation);
Assert.IsNotNull(insertResult, "insertResult = null");
Console.WriteLine("insertResult.HttpStatusCode = {0}", insertResult.HttpStatusCode);
Console.WriteLine("insertResult.ETag = {0}", insertResult.Etag);
Assert.AreEqual((int)HttpStatusCode.NoContent, insertResult.HttpStatusCode, "insertResult.HttpStatusCode mismatch");
Assert.IsFalse(string.IsNullOrEmpty(insertResult.Etag), "insertResult.ETag = null or empty");
ITableEntity row = (ITableEntity)insertResult.Result;
Assert.IsNotNull(row, "insertResult.Result = null");
Console.WriteLine("row.PartitionKey = {0}", row.PartitionKey);
Console.WriteLine("row.RowKey = {0}", row.RowKey);
CustomerEntity customer = (CustomerEntity)insertResult.Result;
Assert.IsNotNull(customer, "Insert: customer = null");
Console.WriteLine("Insert: customer.Email = {0}", customer.Email);
Console.WriteLine("Insert: customer.PhoneNumber = {0}", customer.PhoneNumber);
Assert.AreEqual(newCustomer.Email, customer.Email, "Insert: customer.Email mismatch");
Assert.AreEqual(newCustomer.PhoneNumber, customer.PhoneNumber, "Insert: customer.PhoneNumber mismatch");
// Retrieve
Console.WriteLine("Calling XStore Retrieve...");
TableOperation retrieveOperation = TableOperation.Retrieve<CustomerEntity>(row.PartitionKey, row.RowKey);
TableResult retrieveResult = table.Execute(retrieveOperation);
Assert.IsNotNull(retrieveResult, "retrieveResult = null");
Console.WriteLine("retrieveResult.HttpStatusCode = {0}", retrieveResult.HttpStatusCode);
Assert.AreEqual((int)HttpStatusCode.OK, retrieveResult.HttpStatusCode, "retrieveResult.HttpStatusCode mismatch");
customer = (CustomerEntity)retrieveResult.Result;
Assert.IsNotNull(customer, "Retrieve: customer = null");
Console.WriteLine("Retrieve: customer.Email = {0}", customer.Email);
Console.WriteLine("Retrieve: customer.PhoneNumber = {0}", customer.PhoneNumber);
Assert.AreEqual(newCustomer.Email, customer.Email, "Retrieve: customer.Email mismatch");
Assert.AreEqual(newCustomer.PhoneNumber, customer.PhoneNumber, "Retrieve: customer.PhoneNumber mismatch");
// Replace entity
Console.WriteLine("Calling XStore Replace...");
string email2 = "*****@*****.**";
string phone2 = "1-800-123-0002";
customer.PhoneNumber = phone2;
customer.Email = email2;
TableOperation updateOperation = TableOperation.Replace(customer);
TableResult updateResult = table.Execute(updateOperation);
Assert.IsNotNull(updateResult, "updateResult = null");
Console.WriteLine("updateResult.HttpStatusCode = {0}", updateResult.HttpStatusCode);
Assert.AreEqual((int)HttpStatusCode.NoContent, updateResult.HttpStatusCode, "updateResult.HttpStatusCode mismatch");
// Retrieve after Replace
Console.WriteLine("Calling XStore Retrieve after Replace was called...");
retrieveOperation = TableOperation.Retrieve<CustomerEntity>(row.PartitionKey, row.RowKey);
retrieveResult = table.Execute(retrieveOperation);
Assert.IsNotNull(retrieveResult, "RetrieveAfterReplace: retrieveResult = null");
Console.WriteLine("RetrieveAfterReplace: retrieveResult.HttpStatusCode = {0}", retrieveResult.HttpStatusCode);
Assert.AreEqual((int)HttpStatusCode.OK, retrieveResult.HttpStatusCode, "RetrieveAfterReplace: retrieveResult.HttpStatusCode mismatch");
CustomerEntity customer2 = (CustomerEntity)retrieveResult.Result;
Assert.IsNotNull(customer2, "RetrieveAfterReplace: customer2 = null");
Console.WriteLine("RetrieveAfterReplace: customer2.Email = {0}", customer2.Email);
Console.WriteLine("RetrieveAfterReplace: customer2.PhoneNumber = {0}", customer2.PhoneNumber);
Assert.AreEqual(email2, customer2.Email, "RetrieveAfterReplace: customer2.Email mismatch");
Assert.AreEqual(phone2, customer2.PhoneNumber, "RetrieveAfterReplace: customer2.PhoneNumber mismatch");
// Delete
Console.WriteLine("Calling XStore Delete...");
TableOperation deleteOperation = TableOperation.Delete(customer2);
TableResult deleteResult = table.Execute(deleteOperation);
Assert.IsNotNull(deleteResult, "deleteResult = null");
Console.WriteLine("deleteResult.HttpStatusCode = {0}", deleteResult.HttpStatusCode);
Assert.AreEqual((int)HttpStatusCode.NoContent, deleteResult.HttpStatusCode, "deleteResult.HttpStatusCode mismatch");
// Retrieve after Delete
Console.WriteLine("Calling XStore Retrieve after Delete was called...");
retrieveOperation = TableOperation.Retrieve<CustomerEntity>(row.PartitionKey, row.RowKey);
retrieveResult = table.Execute(retrieveOperation);
Assert.IsNotNull(retrieveResult, "RetrieveAfterDelete: retrieveResult = null");
Console.WriteLine("RetrieveAfterDelete: retrieveResult.HttpStatusCode = {0}", retrieveResult.HttpStatusCode);
Assert.AreEqual((int)HttpStatusCode.NotFound, retrieveResult.HttpStatusCode, "RetrieveAfterDelete: retrieveResult.HttpStatusCode mismatch");
CustomerEntity customer3 = (CustomerEntity)retrieveResult.Result;
Assert.IsNull(customer3, "RetrieveAfterDelete: customer3 != null");
// Replace after Delete
Console.WriteLine("Calling XStore Replace after Delete...");
updateOperation = TableOperation.Replace(customer2);
try
{
updateResult = table.Execute(updateOperation);
Assert.Fail("RetrieveAfterDelete: table.Execute() should throw.");
}
catch (Exception ex)
{
WebException webEx = ex.InnerException as WebException;
if (webEx != null)
{
Console.WriteLine("webEx.Message = {0}", webEx.Message);
HttpWebResponse webResponse = webEx.Response as HttpWebResponse;
if (webResponse != null)
{
Console.WriteLine("webResponse.StatusCode = {0}", webResponse.StatusCode);
Assert.AreEqual(HttpStatusCode.NotFound.ToString(), webResponse.StatusCode.ToString(), "RetrieveAfterDelete: webResponse.StatusCode mismatch");
}
Assert.NotNull(webResponse, "RetrieveAfterDelete: WebResponse is null");
}
Assert.NotNull(webEx, "RetrieveAfterDelete: StorageException was not a WebException");
}
}
public void RTableReplaceWithStarEtagSync()
{
// Insert entity
string firstName = "FirstName03_star";
string lastName = "LastName03_star";
string email = "*****@*****.**";
string phone = "1-800-123-0003";
CustomerEntity newCustomer = new CustomerEntity(firstName, lastName);
newCustomer.Email = email;
newCustomer.PhoneNumber = phone;
TableOperation operation = TableOperation.Insert(newCustomer);
TableResult result = repTable.Execute(operation);
Assert.AreNotEqual(null, result, "result = null");
ReplicatedTableEntity row = (ReplicatedTableEntity)result.Result;
Assert.AreEqual((int)HttpStatusCode.NoContent, result.HttpStatusCode, "result.HttpStatusCode mismatch");
Assert.AreNotEqual(null, result.Result, "result.Result = null");
Assert.AreEqual("1", result.Etag, "result.Etag mismatch");
Assert.AreEqual(false, row._rtable_RowLock, "row._rtable_RowLock mismatch");
Assert.AreEqual(1, row._rtable_Version, "row._rtable_Version mismatch");
Assert.AreEqual(false, row._rtable_Tombstone, "row._rtable_Tombstone mismatch");
Assert.AreEqual(this.rtableTestConfiguration.RTableInformation.ViewId, row._rtable_ViewId, "row._rtable_ViewId mismatch");
// Replace entity
Console.WriteLine("Calling TableOperation.Replace(newCustomer)...");
email = "*****@*****.**";
phone = "1-800-456-0003";
newCustomer = new CustomerEntity(firstName, lastName);
newCustomer.Email = email;
newCustomer.PhoneNumber = phone;
newCustomer.ETag = "*";
operation = TableOperation.Replace(newCustomer);
result = repTable.Execute(operation);
Assert.AreNotEqual(null, result, "result = null");
Assert.AreEqual((int)HttpStatusCode.NoContent, result.HttpStatusCode, "result.HttpStatusCode mismatch");
Assert.AreNotEqual(null, result.Result, "result.Result = null");
// Retrieve Entity
Console.WriteLine("Calling TableOperation.Retrieve<CustomerEntity>(firstName, lastName)...");
operation = TableOperation.Retrieve<CustomerEntity>(firstName, lastName);
TableResult retrievedResult = repTable.Execute(operation);
Assert.AreNotEqual(null, retrievedResult, "retrievedResult = null");
CustomerEntity customer = (CustomerEntity)retrievedResult.Result;
Assert.AreEqual((int)HttpStatusCode.OK, retrievedResult.HttpStatusCode, "retrievedResult.HttpStatusCode mismatch");
Assert.AreNotEqual(null, retrievedResult.Result, "retrievedResult.Result = null");
Assert.AreEqual("2", retrievedResult.Etag, "retrievedResult.Etag mismatch");
Assert.AreEqual(false, customer._rtable_RowLock, "customer._rtable_RowLock mismatch");
Assert.AreEqual(2, customer._rtable_Version, "customer._rtable_Version mismatch");
Assert.AreEqual(false, customer._rtable_Tombstone, "customer._rtable_Tombstone mismatch");
Assert.AreEqual(this.rtableTestConfiguration.RTableInformation.ViewId, customer._rtable_ViewId, "customer._rtable_ViewId mismatch");
Assert.AreEqual(newCustomer.PhoneNumber, customer.PhoneNumber, "customer.PhoneNumber mismatch");
Assert.AreEqual(newCustomer.Email, customer.Email, "customer.Email mismatch");
customer.Email = "*****@*****.**";
// Replace again
Console.WriteLine("Calling TableOperation.Replace after Retrieve...");
operation = TableOperation.Replace(customer);
result = repTable.Execute(operation);
Assert.AreNotEqual(null, result, "result = null");
Assert.IsTrue(result.HttpStatusCode == (int)HttpStatusCode.NoContent || result.HttpStatusCode == (int)HttpStatusCode.OK,
"result.HttpStatusCode mismatch");
//Non-gen Retrieve and Replace with star
Console.WriteLine("Calling TableOperation.Retrieve(firstName, lastName)...");
operation = TableOperation.Retrieve(firstName, lastName);
retrievedResult = repTable.Execute(operation);
Assert.AreNotEqual(null, retrievedResult, "retrievedResult = null");
DynamicReplicatedTableEntity dynCustomer = (DynamicReplicatedTableEntity)retrievedResult.Result;
Assert.AreEqual((int)HttpStatusCode.OK, retrievedResult.HttpStatusCode, "retrievedResult.HttpStatusCode mismatch");
Assert.AreNotEqual(null, retrievedResult.Result, "retrievedResult.Result = null");
Assert.AreEqual("3", retrievedResult.Etag, "retrievedResult.Etag mismatch");
Assert.AreEqual(false, dynCustomer._rtable_RowLock, "dynCustomer._rtable_RowLock mismatch");
Assert.AreEqual(3, dynCustomer._rtable_Version, "dynCustomer._rtable_Version mismatch");
Assert.AreEqual(false, dynCustomer._rtable_Tombstone, "dynCustomer._rtable_Tombstone mismatch");
Assert.AreEqual(this.rtableTestConfiguration.RTableInformation.ViewId, dynCustomer._rtable_ViewId, "customer._rtable_ViewId mismatch");
Assert.AreEqual(customer.PhoneNumber, dynCustomer.Properties["PhoneNumber"].StringValue, "dynCustomer.PhoneNumber mismatch");
Assert.AreEqual(customer.Email, dynCustomer.Properties["Email"].StringValue, "dynCustomer.Email mismatch");
dynCustomer.Properties["Email"] = EntityProperty.CreateEntityPropertyFromObject("*****@*****.**");
dynCustomer.ETag = "*";
// Replace again
Console.WriteLine("Calling TableOperation.Replace after Retrieve...");
operation = TableOperation.Replace(dynCustomer);
result = repTable.Execute(operation);
Assert.AreNotEqual(null, result, "result = null");
Console.WriteLine("Foo - returned status: {0}", result.HttpStatusCode);
Assert.IsTrue(result.HttpStatusCode == (int)HttpStatusCode.NoContent || result.HttpStatusCode == (int)HttpStatusCode.OK,
"result.HttpStatusCode mismatch");
}
public void RTableInsertOrReplaceSync()
{
string firstName = "FirstName01";
string lastName = "LastName01";
string email = "*****@*****.**";
string phone = "1-800-123-0001";
string dynamicFirstName = "DynFirstName01";
string dynamicLastName = "DynLastName01";
string dynamicEmail = "*****@*****.**";
string dynamicPhone = "1-800-123-0002";
// Insert entity
CustomerEntity newCustomer = new CustomerEntity(firstName, lastName);
newCustomer.Email = email;
newCustomer.PhoneNumber = phone;
TableOperation operation = TableOperation.Insert(newCustomer);
TableResult result = repTable.Execute(operation);
Assert.AreNotEqual(null, result, "result = null");
ReplicatedTableEntity row = (ReplicatedTableEntity)result.Result;
Assert.AreEqual((int)HttpStatusCode.NoContent, result.HttpStatusCode, "result.HttpStatusCode mismatch");
Assert.AreNotEqual(null, result.Result, "result.Result = null");
Assert.AreEqual("1", result.Etag, "result.Etag mismatch");
Assert.AreEqual(false, row._rtable_RowLock, "row._rtable_RowLock mismatch");
Assert.AreEqual(1, row._rtable_Version, "row._rtable_Version mismatch");
Assert.AreEqual(false, row._rtable_Tombstone, "row._rtable_Tombstone mismatch");
Assert.AreEqual(this.rtableTestConfiguration.RTableInformation.ViewId, row._rtable_ViewId, "row._rtable_ViewId mismatch");
//Non-generic retrieve
operation = TableOperation.Retrieve(firstName, lastName);
TableResult retrievedResult = this.repTable.Execute(operation);
Assert.AreNotEqual(null, retrievedResult, "retrievedResult = null");
Assert.IsTrue(retrievedResult.Result is IReplicatedTableEntity, "Expected entity to be of type IReplicatedTableEntity");
DynamicReplicatedTableEntity readRow = retrievedResult.Result as DynamicReplicatedTableEntity;
Assert.IsTrue(readRow.ETag == "1", "Returned etag is not zero");
Assert.IsTrue(readRow.Properties.ContainsKey("Email"), "DynamicRTableEntity returned didnt contain Email");
Assert.IsTrue(readRow.Properties.ContainsKey("PhoneNumber"), "DynamicRTableEntity returned didnt contain PhoneNumber");
Assert.IsTrue(readRow.Properties.Count == 2, "DynamicRTableEntity returned contained diff number of properties");
////Dynamic insert entity
DynamicReplicatedTableEntity newDynamicCustomer = new DynamicReplicatedTableEntity(dynamicFirstName, dynamicLastName);
newDynamicCustomer.Properties["Email"] = EntityProperty.CreateEntityPropertyFromObject(dynamicEmail);
newDynamicCustomer.Properties["PhoneNumber"] = EntityProperty.CreateEntityPropertyFromObject(dynamicPhone);
operation = TableOperation.Insert(newDynamicCustomer);
result = repTable.Execute(operation);
Assert.AreNotEqual(null, result, "result = null");
row = (DynamicReplicatedTableEntity)result.Result;
Assert.AreEqual((int)HttpStatusCode.NoContent, result.HttpStatusCode, "result.HttpStatusCode mismatch");
Assert.AreNotEqual(null, result.Result, "result.Result = null");
Assert.AreEqual("1", result.Etag, "result.Etag mismatch");
Assert.AreEqual(false, row._rtable_RowLock, "row._rtable_RowLock mismatch");
Assert.AreEqual(1, row._rtable_Version, "row._rtable_Version mismatch");
Assert.AreEqual(false, row._rtable_Tombstone, "row._rtable_Tombstone mismatch");
Assert.AreEqual(this.rtableTestConfiguration.RTableInformation.ViewId, row._rtable_ViewId, "row._rtable_ViewId mismatch");
//Non-generic retrieve for dynamic entity
operation = TableOperation.Retrieve(dynamicFirstName, dynamicLastName);
retrievedResult = this.repTable.Execute(operation);
Assert.AreNotEqual(null, retrievedResult, "retrievedResult = null");
Assert.IsTrue(retrievedResult.Result is IReplicatedTableEntity, "Expected entity to be of type IReplicatedTableEntity");
readRow = retrievedResult.Result as DynamicReplicatedTableEntity;
Assert.IsTrue(readRow.ETag == "1", "Returned etag is not zero");
Assert.IsTrue(readRow.Properties.ContainsKey("Email"), "DynamicRTableEntity returned didnt contain Email");
Assert.IsTrue(readRow.Properties.ContainsKey("PhoneNumber"), "DynamicRTableEntity returned didnt contain PhoneNumber");
Assert.IsTrue(readRow.Properties.Count == 2, "DynamicRTableEntity returned contained diff number of properties");
// Retrieve entity
operation = TableOperation.Retrieve<CustomerEntity>(firstName, lastName);
retrievedResult = this.repTable.Execute(operation);
Assert.AreNotEqual(null, retrievedResult, "retrievedResult = null");
CustomerEntity customer = (CustomerEntity)retrievedResult.Result;
Assert.AreEqual((int)HttpStatusCode.OK, retrievedResult.HttpStatusCode, "retrievedResult.HttpStatusCode mismatch");
Assert.AreNotEqual(null, retrievedResult.Result, "retrievedResult.Result = null");
Assert.AreEqual("1", retrievedResult.Etag, "retrievedResult.Etag mismatch");
Assert.AreEqual(false, customer._rtable_RowLock, "customer._rtable_RowLock mismatch");
Assert.AreEqual(1, customer._rtable_Version, "customer._rtable_Version mismatch");
Assert.AreEqual(false, customer._rtable_Tombstone, "customer._rtable_Tombstone mismatch");
Assert.AreEqual(this.rtableTestConfiguration.RTableInformation.ViewId, customer._rtable_ViewId, "customer._rtable_ViewId mismatch");
Assert.AreEqual(newCustomer.PhoneNumber, customer.PhoneNumber, "customer.PhoneNumber mismatch");
Assert.AreEqual(newCustomer.Email, customer.Email, "customer.Email mismatch");
// Update the entity
email = "*****@*****.**";
phone = "1-800-456-0001";
newCustomer = new CustomerEntity(firstName, lastName);
newCustomer.Email = email;
newCustomer.PhoneNumber = phone;
// InsertOrReplace
Console.WriteLine("Calling TableOperation.InsertOrReplace(newCustomer)...");
operation = TableOperation.InsertOrReplace(newCustomer);
result = this.repTable.Execute(operation);
Assert.AreNotEqual(result, null);
row = (ReplicatedTableEntity)result.Result;
Assert.AreEqual((int)HttpStatusCode.NoContent, result.HttpStatusCode, "result.HttpStatusCode mismatch");
Assert.AreNotEqual(null, result.Result, "result.Result = null");
Assert.AreEqual("2", result.Etag, "result.Etag mismatch");
Assert.AreEqual(false, row._rtable_RowLock, "row._rtable_RowLock mismatch");
Assert.AreEqual(2, row._rtable_Version, "row._rtable_Version mismatch");
Assert.AreEqual(false, row._rtable_Tombstone, "row._rtable_Tombstone mismatch");
Assert.AreEqual(this.rtableTestConfiguration.RTableInformation.ViewId, row._rtable_ViewId, "row._rtable_ViewId mismatch");
// Retrieve entity
Console.WriteLine("Calling Retrieve...");
operation = TableOperation.Retrieve<CustomerEntity>(firstName, lastName);
retrievedResult = this.repTable.Execute(operation);
Assert.AreNotEqual(null, retrievedResult, "retrievedResult = null");
customer = (CustomerEntity)retrievedResult.Result;
Assert.AreEqual((int)HttpStatusCode.OK, retrievedResult.HttpStatusCode, "retrievedResult.HttpStatusCode mismatch");
Assert.AreNotEqual(null, retrievedResult.Result, "retrievedResult.Result = null");
Assert.AreEqual("2", retrievedResult.Etag, "retrievedResult.Etag mismatch");
Assert.AreEqual(false, customer._rtable_RowLock, "customer._rtable_RowLock mismatch");
Assert.AreEqual(2, customer._rtable_Version, "customer._rtable_Version mismatch");
Assert.AreEqual(false, customer._rtable_Tombstone, "customer._rtable_Tombstone mismatch");
Assert.AreEqual(this.rtableTestConfiguration.RTableInformation.ViewId, customer._rtable_ViewId, "customer._rtable_ViewId mismatch");
Assert.AreEqual(newCustomer.PhoneNumber, customer.PhoneNumber, "customer.PhoneNumber mismatch");
Assert.AreEqual(newCustomer.Email, customer.Email, "customer.Email mismatch");
}
public void RTableInsertRetrieveSync()
{
string firstName = "FirstName02";
string lastName = "LastName02";
string email = "*****@*****.**";
string phone = "1-800-123-0002";
// Insert entity
CustomerEntity newCustomer = new CustomerEntity(firstName, lastName);
newCustomer.Email = email;
newCustomer.PhoneNumber = phone;
TableOperation operation = TableOperation.Insert(newCustomer);
TableResult result = repTable.Execute(operation);
Assert.AreNotEqual(null, result, "result = null");
ReplicatedTableEntity row = (ReplicatedTableEntity)result.Result;
Assert.AreEqual((int)HttpStatusCode.NoContent, result.HttpStatusCode, "result.HttpStatusCode mismatch");
Assert.AreNotEqual(null, result.Result, "result.Result = null");
Assert.AreEqual("1", result.Etag, "result.Etag mismatch");
Assert.AreEqual(false, row._rtable_RowLock, "row._rtable_RowLock mismatch");
Assert.AreEqual(1, row._rtable_Version, "row._rtable_Version mismatch");
Assert.AreEqual(false, row._rtable_Tombstone, "row._rtable_Tombstone mismatch");
Assert.AreEqual(this.rtableTestConfiguration.RTableInformation.ViewId, row._rtable_ViewId, "row._rtable_ViewId mismatch");
// Retrieve entity
operation = TableOperation.Retrieve<CustomerEntity>(firstName, lastName);
TableResult retrievedResult = repTable.Execute(operation);
Assert.AreNotEqual(retrievedResult, null, "retrievedResult = null");
CustomerEntity customer = (CustomerEntity)retrievedResult.Result;
Assert.AreEqual((int)HttpStatusCode.OK, retrievedResult.HttpStatusCode, "retrievedResult.HttpStatusCode mismatch");
Assert.AreNotEqual(null, retrievedResult.Result, "retrievedResult.Result = null");
Assert.AreEqual("1", retrievedResult.Etag, "retrievedResult.Etag mismatch");
Assert.AreEqual(false, customer._rtable_RowLock, "customer._rtable_RowLock mismatch");
Assert.AreEqual(1, customer._rtable_Version, "customer._rtable_Version mismatch");
Assert.AreEqual(customer._rtable_Version.ToString(), customer.ETag, "customer.Etag mismatch");
Assert.AreEqual(false, customer._rtable_Tombstone, "customer._rtable_Tombstone mismatch");
Assert.AreEqual(this.rtableTestConfiguration.RTableInformation.ViewId, customer._rtable_ViewId, "customer._rtable_ViewId mismatch");
Assert.AreEqual(newCustomer.PhoneNumber, customer.PhoneNumber, "customer.PhoneNumber mismatch");
Assert.AreEqual(newCustomer.Email, customer.Email, "customer.Email mismatch");
Console.WriteLine("Duplicate insert...");
// try insert again and it should fail
result = repTable.Execute(TableOperation.Insert(customer));
Assert.AreNotEqual(result, null, "result null for dup insert");
Assert.AreEqual(result.HttpStatusCode, (int) HttpStatusCode.Conflict, "Duplicate insert should result in a conflict error. Error = {0}", result.HttpStatusCode);
Console.WriteLine("Insert Dynamic entity...");
// Insert Dynamic entity
// Add insert
string pk = Guid.NewGuid().ToString();
DynamicReplicatedTableEntity sendEnt = GenerateRandomEnitity(pk);
// generate a set of properties for all supported Types
sendEnt.Properties = new ComplexIEntity().WriteEntity(null);
result = repTable.Execute(TableOperation.Insert(sendEnt));
Assert.AreNotEqual(result, null);
DynamicReplicatedTableEntity currentRow = (DynamicReplicatedTableEntity)result.Result;
Assert.AreEqual((int)HttpStatusCode.NoContent, result.HttpStatusCode, "result.HttpStatusCode mismatch");
Assert.AreNotEqual(null, currentRow, "currentRow = null");
Assert.AreEqual("1", result.Etag, "result.Result mismatch");
Assert.AreEqual(false, currentRow._rtable_RowLock, "currentRow._rtable_RowLock mismatch");
Assert.AreEqual(1, currentRow._rtable_Version, "currentRow._rtable_Version mismatch");
Assert.AreEqual(false, currentRow._rtable_Tombstone, "currentRow._rtable_Tombstone mismatch");
Assert.AreEqual(this.rtableTestConfiguration.RTableInformation.ViewId, currentRow._rtable_ViewId, "currentRow._rtable_ViewId mismatch");
// Retrieve Dynamic entity
operation = TableOperation.Retrieve<DynamicReplicatedTableEntity>(sendEnt.PartitionKey, sendEnt.RowKey);
retrievedResult = repTable.Execute(operation);
Assert.AreNotEqual(null, retrievedResult, "retrievedResult = null");
DynamicReplicatedTableEntity retrievedEntity = retrievedResult.Result as DynamicReplicatedTableEntity;
Assert.AreNotEqual(null, retrievedEntity, "retrievedEntity = null");
// Validate entity
Assert.AreEqual(sendEnt["String"], retrievedEntity["String"], "[String] mismatch");
Assert.AreEqual(sendEnt["Int64"], retrievedEntity["Int64"], "[Int64] mismatch");
Assert.AreEqual(sendEnt["Int64N"], retrievedEntity["Int64N"], "[Int64N] mismatch");
Assert.AreEqual(sendEnt["LongPrimitive"], retrievedEntity["LongPrimitive"], "[LongPrimitive] mismatch");
Assert.AreEqual(sendEnt["LongPrimitiveN"], retrievedEntity["LongPrimitiveN"], "[LongPrimitiveN] mismatch");
Assert.AreEqual(sendEnt["Int32"], retrievedEntity["Int32"], "[Int32] mismatch");
Assert.AreEqual(sendEnt["Int32N"], retrievedEntity["Int32N"], "[Int32N] mismatch");
Assert.AreEqual(sendEnt["IntegerPrimitive"], retrievedEntity["IntegerPrimitive"], "[IntegerPrimitive] mismatch");
Assert.AreEqual(sendEnt["IntegerPrimitiveN"], retrievedEntity["IntegerPrimitiveN"], "[IntegerPrimitiveN] mismatch");
Assert.AreEqual(sendEnt["Guid"], retrievedEntity["Guid"], "[Guid] mismatch");
Assert.AreEqual(sendEnt["GuidN"], retrievedEntity["GuidN"], "[GuidN] mismatch");
Assert.AreEqual(sendEnt["Double"], retrievedEntity["Double"], "[Double] mismatch");
Assert.AreEqual(sendEnt["DoubleN"], retrievedEntity["DoubleN"], "[DoubleN] mismatch");
Assert.AreEqual(sendEnt["DoublePrimitive"], retrievedEntity["DoublePrimitive"], "[DoublePrimitive] mismatch");
Assert.AreEqual(sendEnt["DoublePrimitiveN"], retrievedEntity["DoublePrimitiveN"], "[DoublePrimitiveN] mismatch");
Assert.AreEqual(sendEnt["BinaryPrimitive"], retrievedEntity["BinaryPrimitive"], "[BinaryPrimitive] mismatch");
Assert.AreEqual(sendEnt["Binary"], retrievedEntity["Binary"], "[Binary] mismatch");
Assert.AreEqual(sendEnt["BoolPrimitive"], retrievedEntity["BoolPrimitive"], "[BoolPrimitive] mismatch");
Assert.AreEqual(sendEnt["BoolPrimitiveN"], retrievedEntity["BoolPrimitiveN"], "[BoolPrimitiveN] mismatch");
Assert.AreEqual(sendEnt["Bool"], retrievedEntity["Bool"], "[Bool] mismatch");
Assert.AreEqual(sendEnt["BoolN"], retrievedEntity["BoolN"], "[BoolN] mismatch");
Assert.AreEqual(sendEnt["DateTimeOffsetN"], retrievedEntity["DateTimeOffsetN"], "[DateTimeOffsetN] mismatch");
Assert.AreEqual(sendEnt["DateTimeOffset"], retrievedEntity["DateTimeOffset"], "[DateTimeOffset] mismatch");
Assert.AreEqual(sendEnt["DateTime"], retrievedEntity["DateTime"], "[DateTime] mismatch");
Assert.AreEqual(sendEnt["DateTimeN"], retrievedEntity["DateTimeN"], "[DateTimeN] mismatch");
}
public void RepairTableWontRepairRowsWithHigherViewIdWhenIgnoreHigherViewIdRowsFlagIsSet()
{
TableOperation operation;
TableResult result;
CustomerEntity customer;
// - View has 2 replicas ?
View view = this.configurationWrapper.GetWriteView();
Assert.IsTrue(view.Chain.Count == 2, "expects 2 replicas only!");
// - Remove the Head, [None]->[RW]
RemoveHeadFromView(view.Name, 600, this.configurationService);
// 1 - Insert entries in old viewId
var rtable = new ReplicatedTable(this.repTable.TableName, this.configurationService);
string firstName = "FirstName";
string lastName = "LastName";
for (int i = 0; i < 10; i++)
{
customer = new CustomerEntity(firstName + i, lastName + i);
operation = TableOperation.Insert(customer);
rtable.Execute(operation);
}
// 2 - Increase viewId => so we can create rows with higher viewId
// - Update entry #5 and #8 in new viewId
ReplicatedTableConfiguration config;
ReplicatedTableQuorumReadResult readStatus = this.configurationService.RetrieveConfiguration(out config);
Assert.IsTrue(readStatus.Code == ReplicatedTableQuorumReadCode.Success);
ReplicatedTableConfigurationStore viewConfg = config.GetView(view.Name);
viewConfg.ViewId += 100;
this.configurationService.UpdateConfiguration(config);
foreach (int entryId in new int[] { 5, 8 })
{
operation = TableOperation.Retrieve <CustomerEntity>(firstName + entryId, lastName + entryId);
result = rtable.Execute(operation);
Assert.IsTrue(result != null && result.HttpStatusCode == (int)HttpStatusCode.OK && (CustomerEntity)result.Result != null, "Retrieve customer failed");
customer = (CustomerEntity)result.Result;
customer.Email = "*****@*****.**";
operation = TableOperation.Replace(customer);
result = rtable.Execute(operation);
Assert.IsTrue(result != null && result.HttpStatusCode == (int)HttpStatusCode.NoContent, "Update customer failed");
}
// 3 - Restore previous viewId, and,
// - Set 'IgnoreHigherViewIdRows' flag so we ignore rows with higher viewIds
readStatus = this.configurationService.RetrieveConfiguration(out config);
Assert.IsTrue(readStatus.Code == ReplicatedTableQuorumReadCode.Success);
viewConfg = config.GetView(view.Name);
viewConfg.ViewId -= 100;
config.SetIgnoreHigherViewIdRowsFlag(true);
this.configurationService.UpdateConfiguration(config);
try
{
// Check Retrieve of row #5 and #8 returns NotFound
foreach (int entryId in new int[] { 5, 8 })
{
operation = TableOperation.Retrieve <CustomerEntity>(firstName + entryId, lastName + entryId);
var retrievedResult = rtable.Execute(operation);
Assert.AreNotEqual(null, retrievedResult, "retrievedResult = null");
Assert.AreEqual((int)HttpStatusCode.NotFound, retrievedResult.HttpStatusCode, "retrievedResult.HttpStatusCode mismatch");
}
}
catch (ReplicatedTableStaleViewException)
{
Assert.Fail("Retrieve() is expected to NotFound the row, but got RTableStaleViewException !");
}
// 4 - Now insert a Head [WO]->[RW]
// - Then, call RepairTable ...
InsertHeadInView(view.Name, 600, this.configurationService);
ReconfigurationStatus status = rtable.RepairTable(0, null);
Assert.AreEqual(status, ReconfigurationStatus.PARTIAL_FAILURE, "rows with higher viewId should not be repaired");
// 5 - Check rows with higher viewId still NotFound, even after repair ...
try
{
// Check Retrieve of row #5 and #8 returns NotFound
foreach (int entryId in new int[] { 5, 8 })
{
operation = TableOperation.Retrieve <CustomerEntity>(firstName + entryId, lastName + entryId);
var retrievedResult = rtable.Execute(operation);
Assert.AreNotEqual(null, retrievedResult, "retrievedResult = null");
Assert.AreEqual((int)HttpStatusCode.NotFound, retrievedResult.HttpStatusCode, "retrievedResult.HttpStatusCode mismatch");
}
}
catch (ReplicatedTableStaleViewException)
{
Assert.Fail("Retrieve() is expected to NotFound the row, but got RTableStaleViewException !");
}
}
public void CaseNoRepair_ReadRowFromNewViewCutOffTailUpdateRow()
{
string firstName = "FirstName";
string lastName = "LastName";
TableOperation operation;
TableResult result;
CustomerEntity customer;
// - View has 2 replicas ?
View view = this.configurationWrapper.GetWriteView();
Assert.IsTrue(view.Chain.Count == 2, "expects 2 replicas only!");
// 1 - [None]->[RW]
ReplicatedTableConfiguration config;
this.configurationService.RetrieveConfiguration(out config);
ReplicatedTableConfigurationStore viewConfg = config.GetView(view.Name);
viewConfg.ReplicaChain[0].Status = ReplicaStatus.None;
viewConfg.ViewId++;
this.configurationService.UpdateConfiguration(config);
// *** - Insert entries in old viewId
var rtable = new ReplicatedTable(this.repTable.TableName, this.configurationService);
for (int i = 0; i < 3; i++)
{
customer = new CustomerEntity(firstName + i, lastName + i);
operation = TableOperation.Insert(customer);
rtable.Execute(operation);
}
// 2 - Insert Head => [WO]->[RW]
this.configurationService.RetrieveConfiguration(out config);
viewConfg = config.GetView(view.Name);
viewConfg.ReplicaChain[0].Status = ReplicaStatus.WriteOnly;
viewConfg.ViewId++;
this.configurationService.UpdateConfiguration(config);
// *** - Insert entries in new viewId
rtable = new ReplicatedTable(this.repTable.TableName, this.configurationService);
for (int i = 10; i < 13; i++)
{
customer = new CustomerEntity(firstName + i, lastName + i);
operation = TableOperation.Insert(customer);
rtable.Execute(operation);
}
// => Read old entry - from Tail -
int entryId = 10;
operation = TableOperation.Retrieve <CustomerEntity>(firstName + entryId, lastName + entryId);
result = rtable.Execute(operation);
// 3 - Cut-off Tail without repairing replicas
configurationService.RetrieveConfiguration(out config);
viewConfg = config.GetView(view.Name);
viewConfg.ReplicaChain[0].Status = ReplicaStatus.ReadWrite;
viewConfg.ReplicaChain[1].Status = ReplicaStatus.None;
viewConfg.ViewId++;
this.configurationService.UpdateConfiguration(config);
// => Update the row
customer = (CustomerEntity)result.Result;
customer.Email = "*****@*****.**";
operation = TableOperation.Replace(customer);
result = rtable.Execute(operation);
Assert.IsTrue(result != null && result.HttpStatusCode == (int)HttpStatusCode.NoContent, "Update customer failed");
}
public void InsertInStaleViewConflictingWithInsertInNewView()
{
ReplicatedTableConfigurationServiceV2 configServiceOne, configServiceTwo;
// setup: Acc0 Acc1
// stale view = [None] -> [RW]
// new view = [WO] -> [RW]
SetupStaleViewAndNewView(out configServiceOne, out configServiceTwo);
long staleViewId = configServiceOne.GetTableView(this.repTable.TableName).ViewId;
long latestViewId = configServiceTwo.GetTableView(this.repTable.TableName).ViewId;
string firstName = "FirstName01";
string lastName = "LastName01";
var workerOne = new ReplicatedTable(this.repTable.TableName, configServiceOne);
var workerTwo = new ReplicatedTable(this.repTable.TableName, configServiceTwo);
string accountNameToTamper = this.rtableTestConfiguration.StorageInformation.AccountNames[1];
Console.WriteLine("RunHttpManglerBehaviorHelper(): accountNameToTamper={0}", accountNameToTamper);
TableResult oldInsertResult = null;
TableResult newInsertResult = null;
bool triggerInsertWithNewView = false;
bool oldInsertResume = false;
// Start new newInsertTask in wait
var newInsertTask = Task.Run(() =>
{
while (!triggerInsertWithNewView)
{
Thread.Sleep(100);
}
/*
* 2 - Executes after step 1 below:
* WorkerTwo => Insert a new row using new view
*/
var customer = new CustomerEntity(firstName, lastName);
customer.Email = "workerTwo";
TableOperation operation = TableOperation.Insert(customer);
newInsertResult = workerTwo.Execute(operation);
// Signal old Insert to resume
oldInsertResume = true;
});
// Delay behavior
ProxyBehavior[] behaviors =
{
TamperBehaviors.TamperAllRequestsIf(
(session =>
{
// => trigger new insert to start
triggerInsertWithNewView = true;
// Delaying commit to the Tail by stale view Update
while (!oldInsertResume)
{
Thread.Sleep(100);
}
}),
(session =>
{
var body = session.GetRequestBodyAsString();
// Commit to Tail by stale view
if (session.hostname.Contains(accountNameToTamper + ".") &&
session.HTTPMethodIs("PUT") &&
body.Contains("\"Email\":\"workerOne\"") &&
body.Contains(string.Format("\"_rtable_ViewId\":\"{0}\"", staleViewId)) &&
body.Contains("\"_rtable_RowLock\":false"))
{
return(true);
}
return(false);
})),
};
/*
* 1 - WorkerOne => update an entry using the stale View
*/
using (new HttpMangler(false, behaviors))
{
var customer = new CustomerEntity(firstName, lastName);
customer.Email = "workerOne";
TableOperation operation = TableOperation.Insert(customer);
oldInsertResult = workerOne.Execute(operation);
}
// Wait on new Insert to finish
newInsertTask.Wait();
// Expected behavior:
// Thread_1 (stale ViewId)
Assert.IsNotNull(oldInsertResult, "oldInsertResult = null");
Assert.AreEqual((int)HttpStatusCode.NoContent, oldInsertResult.HttpStatusCode, "oldInsertResult.HttpStatusCode mismatch");
Console.WriteLine("Insert in stale View Succeeded with HttpStatus={0}", oldInsertResult.HttpStatusCode);
// Thread_2 (new ViewId)
Assert.IsNotNull(newInsertResult, "newInsertResult = null");
Assert.AreEqual((int)HttpStatusCode.Conflict, newInsertResult.HttpStatusCode, "newUpdateResult.HttpStatusCode mismatch");
Console.WriteLine("Insert in new View failed with HttpStatus={0}", newInsertResult.HttpStatusCode);
var currCustomer = RetrieveCustomer(firstName, lastName, workerTwo);
Assert.AreEqual(staleViewId, currCustomer._rtable_ViewId, "customer._rtable_ViewId mismatch");
Assert.AreEqual("workerOne", currCustomer.Email, "customer.Email mismatch");
Console.WriteLine("workerOne write Succeeded");
Console.WriteLine("workerTwo got Conflict because row was lock.");
}
public void ConfigurationChangeNotificationAfterDetectingStaleView()
{
ReplicatedTableConfigurationServiceV2 configServiceOne, configServiceTwo;
// setup:
// stale view = [None] -> [RW]
// new view = [WO] -> [RW]
SetupStaleViewAndNewView(out configServiceOne, out configServiceTwo);
long staleViewId = configServiceOne.GetTableView(this.repTable.TableName).ViewId;
long latestViewId = configServiceTwo.GetTableView(this.repTable.TableName).ViewId;
string firstName = "FirstName01";
string lastName = "LastName01";
/*
* 1 - WorkerOne => inserts an entry using the stale View
*/
var workerOne = new ReplicatedTable(this.repTable.TableName, configServiceOne);
var customer = new CustomerEntity(firstName, lastName);
customer.Email = "*****@*****.**";
InsertCustormer(customer, workerOne);
customer = RetrieveCustomer(firstName, lastName, workerOne);
Assert.AreEqual(staleViewId, customer._rtable_ViewId, "customer._rtable_ViewId mismatch");
Assert.AreEqual("*****@*****.**", customer.Email, "customer.Email mismatch");
Console.WriteLine("workerOne inserted a customer in ViewId={0}", staleViewId);
/*
* 2 - WorkerTwo => updates the entry using latest View
*/
var workerTwo = new ReplicatedTable(this.repTable.TableName, configServiceTwo);
customer = RetrieveCustomer(firstName, lastName, workerTwo);
customer.Email = "*****@*****.**";
UpdateCustomer(customer, workerTwo);
customer = RetrieveCustomer(firstName, lastName, workerTwo);
Assert.AreEqual(latestViewId, customer._rtable_ViewId, "customer._rtable_ViewId mismatch");
Assert.AreEqual("*****@*****.**", customer.Email, "customer.Email mismatch");
Console.WriteLine("workerTwo updated the customer in ViewId={0}", latestViewId);
/*
* 3 - WorkerOne => access existing entry using "the stale View"
*/
try
{
customer = RetrieveCustomer(firstName, lastName, workerOne);
Assert.Fail("Retrieve() is expected to get an RTableStaleViewException but did not get it.");
}
catch (ReplicatedTableStaleViewException ex)
{
Console.WriteLine("workerOne got exception: {0}", ex.Message);
Assert.IsTrue(ex.ErrorCode == ReplicatedTableViewErrorCodes.ViewIdSmallerThanEntryViewId);
Assert.IsTrue(ex.Message.Contains(string.Format("current _rtable_ViewId {0} is smaller than _rtable_ViewId of existing row {1}", staleViewId, latestViewId)), "Got unexpected exception message");
}
// Note:
// No need to test all table APIs since already covered by UT:
// => "Microsoft.Azure.Toolkit.Replication.Test.RTableViewIdTests.ExceptionWhenUsingSmallerViewId()"
/*
* 4 - Notify "configServiceOne" instance of config change
*/
Assert.AreEqual(configServiceOne.GetTableView(this.repTable.TableName).ViewId, staleViewId, "we should see old View!!!");
{
configServiceOne.ConfigurationChangeNotification();
}
Assert.AreEqual(configServiceOne.GetTableView(this.repTable.TableName).ViewId, latestViewId, "we should see latest View!!!");
/*
* 5 - WorkerOne => updates the entry using latest View
*/
customer = RetrieveCustomer(firstName, lastName, workerTwo);
customer.Email = "*****@*****.**";
UpdateCustomer(customer, workerTwo);
customer = RetrieveCustomer(firstName, lastName, workerTwo);
Assert.AreEqual(latestViewId, customer._rtable_ViewId, "customer._rtable_ViewId mismatch");
Assert.AreEqual("*****@*****.**", customer.Email, "customer.Email mismatch");
Console.WriteLine("workerOne updated the customer in ViewId={0}", latestViewId);
}
public void ExceptionWhenUsingSmallerViewId()
{
long currentViewId = 100;
long badViewId = currentViewId - 1;
this.UpdateConfiguration(replicas, 0, false, currentViewId);
string firstName = "FirstName01";
string lastName = "LastName01";
string email = "*****@*****.**";
string phone = "1-800-123-0001";
// Insert entity
CustomerEntity newCustomer = new CustomerEntity(firstName, lastName);
newCustomer.Email = email;
newCustomer.PhoneNumber = phone;
TableOperation operation = TableOperation.Insert(newCustomer);
TableResult result = this.repTable.Execute(operation);
Assert.AreNotEqual(null, result, "result = null");
ReplicatedTableEntity row = (ReplicatedTableEntity)result.Result;
Assert.AreEqual((int)HttpStatusCode.NoContent, result.HttpStatusCode, "result.HttpStatusCode mismatch");
Assert.AreNotEqual(null, result.Result, "result.Result = null");
Assert.AreEqual("1", result.Etag, "result.Etag mismatch");
Assert.AreEqual(false, row._rtable_RowLock, "row._rtable_RowLock mismatch");
Assert.AreEqual(1, row._rtable_Version, "row._rtable_Version mismatch");
Assert.AreEqual(false, row._rtable_Tombstone, "row._rtable_Tombstone mismatch");
Assert.AreEqual(currentViewId, row._rtable_ViewId, "row._rtable_ViewId mismatch");
Console.WriteLine("Successfully created an entity");
// Retrieve entity
operation = TableOperation.Retrieve <CustomerEntity>(firstName, lastName);
TableResult retrievedResult = this.repTable.Execute(operation);
Assert.AreNotEqual(null, retrievedResult, "retrievedResult = null");
CustomerEntity customer = (CustomerEntity)retrievedResult.Result;
Assert.AreEqual((int)HttpStatusCode.OK, retrievedResult.HttpStatusCode, "retrievedResult.HttpStatusCode mismatch");
Assert.AreNotEqual(null, retrievedResult.Result, "retrievedResult.Result = null");
Assert.AreEqual("1", retrievedResult.Etag, "retrievedResult.Etag mismatch");
Assert.AreEqual(false, customer._rtable_RowLock, "customer._rtable_RowLock mismatch");
Assert.AreEqual(1, customer._rtable_Version, "customer._rtable_Version mismatch");
Assert.AreEqual(false, customer._rtable_Tombstone, "customer._rtable_Tombstone mismatch");
Assert.AreEqual(currentViewId, customer._rtable_ViewId, "customer._rtable_ViewId mismatch");
Assert.AreEqual(newCustomer.PhoneNumber, customer.PhoneNumber, "customer.PhoneNumber mismatch");
Assert.AreEqual(newCustomer.Email, customer.Email, "customer.Email mismatch");
Console.WriteLine("Successfully retrieved the entity");
//
// Call RefreshRTableEnvJsonConfigBlob to change the viewId of the wrapper to an older value
//
Console.WriteLine("Changing the viewId to badViewId {0}", badViewId);
this.UpdateConfiguration(replicas, 0, false, badViewId);
//
// Retrieve with bad viewId
//
Console.WriteLine("\nCalling Retrieve with badViewId...");
operation = TableOperation.Retrieve <CustomerEntity>(firstName, lastName);
try
{
retrievedResult = this.repTable.Execute(operation);
Assert.Fail("Retrieve() is expected to get an RTableStaleViewException but did not get it.");
}
catch (ReplicatedTableStaleViewException ex)
{
Console.WriteLine("Get this RTableStaleViewException: {0}", ex.Message);
Assert.IsTrue(ex.ErrorCode == ReplicatedTableViewErrorCodes.ViewIdSmallerThanEntryViewId);
Assert.IsTrue(ex.Message.Contains(string.Format("current _rtable_ViewId {0} is smaller than", badViewId)), "Got unexpected exception message");
}
//
// Replace with bad viewId
//
Console.WriteLine("\nCalling Replace with badViewId...");
operation = TableOperation.Replace(customer);
try
{
retrievedResult = this.repTable.Execute(operation);
Assert.Fail("Replace() is expected to get an RTableStaleViewException but did not get it.");
}
catch (ReplicatedTableStaleViewException ex)
{
Console.WriteLine("Get this RTableStaleViewException: {0}", ex.Message);
Assert.IsTrue(ex.ErrorCode == ReplicatedTableViewErrorCodes.ViewIdSmallerThanEntryViewId);
Assert.IsTrue(ex.Message.Contains(string.Format("current _rtable_ViewId {0} is smaller than", badViewId)), "Got unexpected exception message");
}
//
// InsertOrMerge with bad viewId
//
Console.WriteLine("\nCalling InsertOrMerge with badViewId...");
operation = TableOperation.InsertOrMerge(customer);
try
{
retrievedResult = this.repTable.Execute(operation);
Assert.Fail("InsertOrMerge() is expected to get an RTableStaleViewException but did not get it.");
}
catch (ReplicatedTableStaleViewException ex)
{
Console.WriteLine("Get this RTableStaleViewException: {0}", ex.Message);
Assert.IsTrue(ex.ErrorCode == ReplicatedTableViewErrorCodes.ViewIdSmallerThanEntryViewId);
Assert.IsTrue(ex.Message.Contains(string.Format("current _rtable_ViewId {0} is smaller than", badViewId)), "Got unexpected exception message");
}
//
// InsertOrReplace with bad viewId
//
Console.WriteLine("\nCalling InsertOrReplace with badViewId...");
operation = TableOperation.InsertOrReplace(customer);
try
{
retrievedResult = this.repTable.Execute(operation);
Assert.Fail("InsertOrReplace() is expected to get an RTableStaleViewException but did not get it.");
}
catch (ReplicatedTableStaleViewException ex)
{
Console.WriteLine("Get this RTableStaleViewException: {0}", ex.Message);
Assert.IsTrue(ex.ErrorCode == ReplicatedTableViewErrorCodes.ViewIdSmallerThanEntryViewId);
Assert.IsTrue(ex.Message.Contains(string.Format("current _rtable_ViewId {0} is smaller than", badViewId)), "Got unexpected exception message");
}
//
// Merge with bad viewId
//
Console.WriteLine("\nCalling Merge with badViewId...");
operation = TableOperation.Merge(customer);
try
{
retrievedResult = this.repTable.Execute(operation);
Assert.Fail("Merge() is expected to get an RTableStaleViewException but did not get it.");
}
catch (ReplicatedTableStaleViewException ex)
{
Console.WriteLine("Get this RTableStaleViewException: {0}", ex.Message);
Assert.IsTrue(ex.ErrorCode == ReplicatedTableViewErrorCodes.ViewIdSmallerThanEntryViewId);
Assert.IsTrue(ex.Message.Contains(string.Format("current _rtable_ViewId {0} is smaller than", badViewId)), "Got unexpected exception message");
}
//
// Delete with bad viewId
//
Console.WriteLine("\nCalling Delete with badViewId...");
operation = TableOperation.Delete(customer);
try
{
retrievedResult = this.repTable.Execute(operation);
Assert.Fail("Delete() is expected to get an RTableStaleViewException but did not get it.");
}
catch (ReplicatedTableStaleViewException ex)
{
Console.WriteLine("Get this RTableStaleViewException: {0}", ex.Message);
Assert.IsTrue(ex.ErrorCode == ReplicatedTableViewErrorCodes.ViewIdSmallerThanEntryViewId);
Assert.IsTrue(ex.Message.Contains(string.Format("current _rtable_ViewId {0} is smaller than", badViewId)), "Got unexpected exception message");
}
}
public void ReplaceUsingLargerViewId()
{
long currentViewId = 100;
long futureViewId = currentViewId + 1;
this.UpdateConfiguration(replicas, 0, false, currentViewId);
string firstName = "FirstName02";
string lastName = "LastName02";
string email = "*****@*****.**";
string phone = "1-800-123-0001";
// Insert entity
CustomerEntity newCustomer = new CustomerEntity(firstName, lastName);
newCustomer.Email = email;
newCustomer.PhoneNumber = phone;
TableOperation operation = TableOperation.Insert(newCustomer);
TableResult result = this.repTable.Execute(operation);
Assert.AreNotEqual(null, result, "result = null");
ReplicatedTableEntity row = (ReplicatedTableEntity)result.Result;
Assert.AreEqual((int)HttpStatusCode.NoContent, result.HttpStatusCode, "result.HttpStatusCode mismatch");
Assert.AreNotEqual(null, result.Result, "result.Result = null");
Assert.AreEqual("1", result.Etag, "result.Etag mismatch");
Assert.AreEqual(false, row._rtable_RowLock, "row._rtable_RowLock mismatch");
Assert.AreEqual(1, row._rtable_Version, "row._rtable_Version mismatch");
Assert.AreEqual(false, row._rtable_Tombstone, "row._rtable_Tombstone mismatch");
Assert.AreEqual(currentViewId, row._rtable_ViewId, "row._rtable_ViewId mismatch");
Console.WriteLine("Successfully created an entity");
// Retrieve entity
operation = TableOperation.Retrieve <CustomerEntity>(firstName, lastName);
TableResult retrievedResult = this.repTable.Execute(operation);
Assert.AreNotEqual(null, retrievedResult, "retrievedResult = null");
CustomerEntity customer = (CustomerEntity)retrievedResult.Result;
Assert.AreEqual((int)HttpStatusCode.OK, retrievedResult.HttpStatusCode, "retrievedResult.HttpStatusCode mismatch");
Assert.AreNotEqual(null, retrievedResult.Result, "retrievedResult.Result = null");
Assert.AreEqual("1", retrievedResult.Etag, "retrievedResult.Etag mismatch");
Assert.AreEqual(false, customer._rtable_RowLock, "customer._rtable_RowLock mismatch");
Assert.AreEqual(1, customer._rtable_Version, "customer._rtable_Version mismatch");
Assert.AreEqual(false, customer._rtable_Tombstone, "customer._rtable_Tombstone mismatch");
Assert.AreEqual(currentViewId, customer._rtable_ViewId, "customer._rtable_ViewId mismatch");
Assert.AreEqual(newCustomer.PhoneNumber, customer.PhoneNumber, "customer.PhoneNumber mismatch");
Assert.AreEqual(newCustomer.Email, customer.Email, "customer.Email mismatch");
Console.WriteLine("Successfully retrieved the entity");
//
// Call ModifyConfigurationBlob to change the viewId of the wrapper to a larger value
//
Console.WriteLine("Changing the viewId to futureViewId {0}", futureViewId);
this.UpdateConfiguration(replicas, 0, false, futureViewId);
//
// Replace entity
//
Console.WriteLine("\nCalling Replace with larger viewId...");
email = "*****@*****.**";
phone = "1-800-123-0002";
customer.Email = email;
customer.PhoneNumber = phone;
operation = TableOperation.Replace(customer);
result = repTable.Execute(operation);
Assert.AreNotEqual(null, result, "result = null");
Assert.AreEqual((int)HttpStatusCode.NoContent, result.HttpStatusCode, "result.HttpStatusCode mismatch");
Assert.AreNotEqual(null, result.Result, "result.Result = null");
// Retrieve Entity
Console.WriteLine("\nCalling Retrieve() with larger viewId...");
operation = TableOperation.Retrieve <CustomerEntity>(firstName, lastName);
retrievedResult = repTable.Execute(operation);
Assert.AreNotEqual(null, retrievedResult, "retrievedResult = null");
CustomerEntity customer2 = (CustomerEntity)retrievedResult.Result;
Assert.AreEqual((int)HttpStatusCode.OK, retrievedResult.HttpStatusCode, "retrievedResult.HttpStatusCode mismatch");
Assert.AreNotEqual(null, retrievedResult.Result, "retrievedResult.Result = null");
Assert.AreEqual("2", retrievedResult.Etag, "retrievedResult.Etag mismatch");
Assert.AreEqual(false, customer2._rtable_RowLock, "customer2._rtable_RowLock mismatch");
Assert.AreEqual(2, customer2._rtable_Version, "customer2._rtable_Version mismatch");
Assert.AreEqual(false, customer2._rtable_Tombstone, "customer2._rtable_Tombstone mismatch");
Assert.AreEqual(futureViewId, customer2._rtable_ViewId, "customer2._rtable_ViewId mismatch");
Assert.AreEqual(phone, customer2.PhoneNumber, "customer2.PhoneNumber mismatch");
Assert.AreEqual(email, customer2.Email, "customer2.Email mismatch");
Console.WriteLine("Successfully retrieved the entity");
//
// Delete entity
//
Console.WriteLine("\nCalling Delete with larger viewId...");
operation = TableOperation.Delete(customer);
TableResult deleteResult = repTable.Execute(operation);
Assert.AreNotEqual(null, deleteResult, "deleteResult = null");
Assert.AreEqual((int)HttpStatusCode.NoContent, deleteResult.HttpStatusCode, "deleteResult.HttpStatusCode mismatch");
Assert.IsNotNull(deleteResult.Result, "deleteResult.Result = null");
// Retrieve
Console.WriteLine("Calling TableOperation.Retrieve() after Delete() was called...");
operation = TableOperation.Retrieve <CustomerEntity>(firstName, lastName);
TableResult retrievedResult2 = repTable.Execute(operation);
Assert.AreEqual((int)HttpStatusCode.NotFound, retrievedResult2.HttpStatusCode, "retrievedResult2.HttpStatusCode mismatch");
Assert.IsNull(retrievedResult2.Result, "retrievedResult2.Result != null");
}
public void RowsWithHigherViewIdNotFoundWhenIgnoreHigherViewIdRowsFlagIsSet()
{
long higherViewId = 200;
// Configure RTable with a higher ViewId
this.UpdateConfiguration(replicas, 0, false, higherViewId);
string firstName = "FirstName02";
string lastName = "LastName02";
string email = "*****@*****.**";
string phone = "1-800-123-0001";
// Insert entity
CustomerEntity newCustomer = new CustomerEntity(firstName, lastName);
newCustomer.Email = email;
newCustomer.PhoneNumber = phone;
TableOperation operation = TableOperation.Insert(newCustomer);
TableResult result = this.repTable.Execute(operation);
Assert.AreNotEqual(null, result, "result = null");
Assert.AreEqual((int)HttpStatusCode.NoContent, result.HttpStatusCode, "result.HttpStatusCode mismatch");
// Retrieve entity
operation = TableOperation.Retrieve <CustomerEntity>(firstName, lastName);
TableResult retrievedResult = this.repTable.Execute(operation);
Assert.AreNotEqual(null, retrievedResult, "retrievedResult = null");
Assert.AreEqual((int)HttpStatusCode.OK, retrievedResult.HttpStatusCode, "retrievedResult.HttpStatusCode mismatch");
Assert.AreNotEqual(null, retrievedResult.Result, "retrievedResult.Result = null");
CustomerEntity customer = (CustomerEntity)retrievedResult.Result;
Assert.AreEqual(higherViewId, customer._rtable_ViewId, "customer._rtable_ViewId mismatch");
Assert.AreEqual(newCustomer.PhoneNumber, customer.PhoneNumber, "customer.PhoneNumber mismatch");
Assert.AreEqual(newCustomer.Email, customer.Email, "customer.Email mismatch");
Console.WriteLine("Successfully retrieved the entity");
//
// Change RTable config to a lower viewId, and force RTable to ignore rows with higher viewId
//
long currentViewId = 10;
Assert.IsTrue(currentViewId < higherViewId, "expected currentViewId < higherViewId !");
Console.WriteLine("Changing the viewId to currentViewId {0}", currentViewId);
ReplicatedTableConfiguration config;
ReplicatedTableQuorumReadResult readStatus = this.configurationService.RetrieveConfiguration(out config);
Assert.IsTrue(readStatus.Code == ReplicatedTableQuorumReadCode.Success);
ReplicatedTableConfigurationStore viewConfg = config.GetView(this.configurationWrapper.GetWriteView().Name);
viewConfg.ViewId = currentViewId;
config.SetIgnoreHigherViewIdRowsFlag(true);
this.configurationService.UpdateConfiguration(config);
//
// Retrieve with lower viewId
//
Console.WriteLine("\nCalling Retrieve with lower ViewId...");
operation = TableOperation.Retrieve <CustomerEntity>(firstName, lastName);
try
{
retrievedResult = this.repTable.Execute(operation);
Assert.AreNotEqual(null, retrievedResult, "retrievedResult = null");
Assert.AreEqual((int)HttpStatusCode.NotFound, retrievedResult.HttpStatusCode, "retrievedResult.HttpStatusCode mismatch");
}
catch (ReplicatedTableStaleViewException)
{
Assert.Fail("Retrieve() is expected to NotFound the row, but got RTableStaleViewException !");
}
//
// Replace with lower viewId
//
Console.WriteLine("\nCalling Replace with lower ViewId...");
operation = TableOperation.Replace(customer);
try
{
retrievedResult = this.repTable.Execute(operation);
Assert.AreNotEqual(null, retrievedResult, "retrievedResult = null");
Assert.AreEqual((int)HttpStatusCode.NotFound, retrievedResult.HttpStatusCode, "retrievedResult.HttpStatusCode mismatch");
}
catch (ReplicatedTableStaleViewException)
{
Assert.Fail("Replace() is expected to NotFound the row, but got RTableStaleViewException !");
}
//
// InsertOrMerge with lower viewId
//
Console.WriteLine("\nCalling InsertOrMerge with lower ViewId...");
operation = TableOperation.InsertOrMerge(customer);
try
{
retrievedResult = this.repTable.Execute(operation);
Assert.AreNotEqual(null, retrievedResult, "retrievedResult = null");
Assert.AreEqual((int)HttpStatusCode.Conflict, retrievedResult.HttpStatusCode, "retrievedResult.HttpStatusCode mismatch");
}
catch (ReplicatedTableStaleViewException)
{
Assert.Fail("InsertOrMerge() is expected to get Conflict, but got RTableStaleViewException !");
}
//
// InsertOrReplace with lower viewId
//
Console.WriteLine("\nCalling InsertOrReplace with lower ViewId...");
operation = TableOperation.InsertOrReplace(customer);
try
{
retrievedResult = this.repTable.Execute(operation);
Assert.AreNotEqual(null, retrievedResult, "retrievedResult = null");
Assert.AreEqual((int)HttpStatusCode.Conflict, retrievedResult.HttpStatusCode, "retrievedResult.HttpStatusCode mismatch");
}
catch (ReplicatedTableStaleViewException)
{
Assert.Fail("InsertOrReplace() is expected to get Conflict, but got RTableStaleViewException !");
}
//
// Merge with lower viewId
//
Console.WriteLine("\nCalling Merge with lower ViewId...");
operation = TableOperation.Merge(customer);
try
{
retrievedResult = this.repTable.Execute(operation);
Assert.AreNotEqual(null, retrievedResult, "retrievedResult = null");
Assert.AreEqual((int)HttpStatusCode.NotFound, retrievedResult.HttpStatusCode, "retrievedResult.HttpStatusCode mismatch");
}
catch (ReplicatedTableStaleViewException)
{
Assert.Fail("Merge() is expected to NotFound the row, but got RTableStaleViewException !");
}
//
// Delete with lower viewId
//
Console.WriteLine("\nCalling Delete with lower ViewId...");
operation = TableOperation.Delete(customer);
try
{
retrievedResult = this.repTable.Execute(operation);
Assert.AreNotEqual(null, retrievedResult, "retrievedResult = null");
Assert.AreEqual((int)HttpStatusCode.NotFound, retrievedResult.HttpStatusCode, "retrievedResult.HttpStatusCode mismatch");
}
catch (ReplicatedTableStaleViewException)
{
Assert.Fail("Delete() is expected to NotFound the row, but got RTableStaleViewException !");
}
}
