public async Task Update_UpdateRecord_ValidateResult()
{
using (SqlYRepository repository = new SqlYRepository(_connectionString)) {
var newY = new EntityY {
Name = "Update1",
Price = 1
};
try {
await repository.CreateAsync(newY);
newY = await repository.ReadAsync(newY.Id, "user");
newY.Name = "Update2";
newY.Price = 2;
await repository.UpdateAsync(newY);
var readX = await repository.ReadAsync(newY.Id, "user");
Assert.AreEqual(newY.Name, readX.Name);
Assert.AreEqual(newY.Id, readX.Id);
Assert.AreEqual(newY.Price, readX.Price);
} finally {
await repository.DeleteAsync(newY.Id, "user");
}
}
}
public async Task GetList_ReadAllRecords_RecordsFound()
{
using (SqlYRepository repository = new SqlYRepository(_connectionString)) {
var items = (await repository.GetListAsync()).ToList();
Assert.IsTrue(items.Count > 0);
}
}
// GET: Y
public async Task <ActionResult> Index()
{
ViewBag.Message = TempData["Message"];
TempData["Message"] = string.Empty;
using (var repository = new SqlYRepository()) {
var items = (await repository.GetListAsync()).ToList();
return(View(items));
}
}
public async Task <ActionResult> Create(EntityY model)
{
try {
using (var repository = new SqlYRepository()) {
await repository.CreateAsync(model).ConfigureAwait(false);
}
TempData["Message"] = $"{model.Name} created.";
return(RedirectToAction("Index"));
} catch {
return(View());
}
}
// GET: Y/Delete/5
public async Task <ActionResult> Delete(int id)
{
using (var repository = new SqlYRepository()) {
try {
await repository.DeleteAsync(id, User.Identity.GetUserName()).ConfigureAwait(false);
TempData["Message"] = "Record deleted successfully.";
} catch (Exception ex) {
TempData["Message"] = $"There was an error deleting record: {id}";
}
}
return(RedirectToAction("Index"));
}
// GET: Y/Edit/5
public async Task <ActionResult> Edit(int id)
{
using (var repository = new SqlYRepository()) {
try {
var model = await repository.ReadAsync(id, User.Identity.GetUserName()).ConfigureAwait(false);
return(View(model));
} catch (ConcurrencyException ex) {
TempData["Message"] = ex.Message;
return(RedirectToAction("Index"));
} catch (Exception ex) {
TempData["Message"] = $"There was an error updating record: {id}";
return(RedirectToAction("Index"));
}
}
}
public async Task Update_UpdateRecordParallelPessimistic_ValidateResult()
{
var newY = new EntityY {
Name = "Update1",
Price = 1
};
using (SqlYRepository repository1 = new SqlYRepository(_connectionString))
using (SqlYRepository repository2 = new SqlYRepository(_connectionString)) {
try {
await repository1.CreateAsync(newY);
//Read Item by 1-st user
newY = await repository1.ReadAsync(newY.Id, "user1");
//read should fail here
EntityY readY2 = null;
try {
readY2 = await repository2.ReadAsync(newY.Id, "user2");
} catch (ConcurrencyException ex) {
Assert.IsTrue(ex.Message.StartsWith("Lock already set"));
} catch (Exception ex) {
Assert.Fail();
}
//Read the same item by 2-nd user, should fail here
//Modify and save updated by first user
newY.Name = "Update2";
newY.Price = 2;
newY.LockedBy = "user1";
await repository1.UpdateAsync(newY);
//the result should be from the 1-st user update
var readY = await repository1.ReadAsync(newY.Id, "user1");
Assert.AreEqual(newY.Name, readY.Name);
Assert.AreEqual(newY.Id, readY.Id);
Assert.AreEqual(newY.Price, readY.Price);
} finally {
await repository1.DeleteAsync(newY.Id, "user1");
}
}
}
public async Task CreateListRemove_Crud_Validate()
{
using (var repository = new SqlYRepository(_connectionString)) {
var newY = new EntityY {
Name = "Test",
Price = 1
};
await repository.CreateAsync(newY);
Assert.IsTrue(newY.Id > 0);
//read and set lock on this record
var readX = await repository.ReadAsync(newY.Id, "user");
Assert.AreEqual(newY.Name, readX.Name);
Assert.AreEqual(newY.Id, readX.Id);
Assert.AreEqual(newY.Price, readX.Price);
//delete record with lock
await repository.DeleteAsync(newY.Id, "user");
}
}
public async Task <ActionResult> Edit(EntityY model)
{
try {
using (var repository = new SqlYRepository()) {
try {
model.LockedBy = User.Identity.GetUserName();
await repository.UpdateAsync(model).ConfigureAwait(false);
TempData["Message"] = $"{model.Name} updated successfully.";
} catch (ConcurrencyException ex) {
TempData["Message"] = $"Record {model.Id} is locked by another user";
} catch (Exception ex) {
TempData["Message"] = $"There was an error updating record: {model.Id}";
}
}
return(RedirectToAction("Index"));
} catch (Exception ex) {
TempData["Message"] = $"Cannot update {model.Name}.";
return(RedirectToAction("Index"));
}
}
