public void Models_AvatarItemModel_Update_With_Valid_Data_Should_Pass()
{
// Arrange
var expectUri = "uri";
var expectDescription = "Description";
var expectTokens = 1000;
var expectQuantities = 2000;
var expectCategory = AvatarItemCategoryEnum.Accessory;
var data = new AvatarItemModel();
var test = new AvatarItemModel
{
Uri = expectUri,
Description = expectDescription,
Tokens = expectTokens,
Quantities = expectQuantities,
Category = expectCategory
};
// Act
data.Update(test);
var result = data;
// Assert
Assert.AreEqual(expectUri, result.Uri, "Uri " + TestContext.TestName);
Assert.AreEqual(expectDescription, result.Description, "Description " + TestContext.TestName);
Assert.AreEqual(expectTokens, result.Tokens, "Tokens " + TestContext.TestName);
Assert.AreEqual(expectQuantities, result.Quantities, "Quantities " + TestContext.TestName);
Assert.AreEqual(expectCategory, result.Category, "Category " + TestContext.TestName);
}
public void Backend_AvatarItemBackend_Update_Valid_Data_Should_Pass()
{
//arrange
var test = AvatarItemBackend.Instance;
var data = new AvatarItemModel();
var createResult = test.Create(data);
data.Name = "GoodTestName";
data.Description = "Good Test Description";
data.Uri = "GoodTestUri";
data.Tokens = 100;
data.Category = AvatarItemCategoryEnum.Accessory;
var expect = data;
//act
var updateResult = test.Update(data);
var result = test.Read(data.Id);
//reset
test.Reset();
//assert
Assert.IsNotNull(result, "Updated " + TestContext.TestName);
Assert.AreEqual(expect.Name, result.Name, "Name " + TestContext.TestName);
Assert.AreEqual(expect.Description, result.Description, "Description " + TestContext.TestName);
Assert.AreEqual(expect.Uri, result.Uri, "URI " + TestContext.TestName);
Assert.AreEqual(expect.Tokens, result.Tokens, "Tokens " + TestContext.TestName);
Assert.AreEqual(expect.Category, result.Category, "Category " + TestContext.TestName);
}
public ActionResult Delete([Bind(Include =
"Id," +
"")] AvatarItemModel data)
{
var CurrentId = DataSourceBackend.Instance.IdentityBackend.GetCurrentStudentID(HttpContext);
if (DataSourceBackend.Instance.IdentityBackend.BlockExecptForRole(CurrentId, UserRoleEnum.TeacherUser))
{
return(RedirectToAction("Login", "Admin"));
}
if (!ModelState.IsValid)
{
// Send back for edit
return(View(data));
}
if (data == null)
{
// Send to Error Page
return(RedirectToAction("Error", "Home"));
}
if (string.IsNullOrEmpty(data.Id))
{
// Send back for Edit
return(View(data));
}
DataSourceBackend.Instance.AvatarItemBackend.Delete(data.Id);
return(RedirectToAction("Index"));
}
public void Controller_Avatar_Create_Post_Valid_Should_Return_Index_Page()
{
// Arrange
AvatarItemController controller = new AvatarItemController();
var data = new AvatarItemModel
{
Description = "description",
Id = "abc",
Name = "Name",
Uri = "picture"
};
var context = CreateMoqSetupForCookie();
controller.ControllerContext = new ControllerContext(context, new RouteData(), controller);
// Act
var result = (RedirectToRouteResult)controller.Create(data);
var resultAvatar = AvatarItemBackend.Instance.Read("abc");
// Reset the Avatars
AvatarItemBackend.Instance.Reset();
// Assert
Assert.AreEqual("Index", result.RouteValues["action"], TestContext.TestName);
// Check that the item is created
Assert.AreEqual(data.Id, resultAvatar.Id, TestContext.TestName);
// No need to check the route, Assert.AreEqual("Avatar", result.RouteValues["route"], TestContext.TestName);
}
public void Controller_Avatar_Update_Get_Should_Return_New_Model()
{
// Arrange (from create)
AvatarItemController controller = new AvatarItemController();
var context = CreateMoqSetupForCookie();
controller.ControllerContext = new ControllerContext(context, new RouteData(), controller);
var data = new AvatarItemModel
{
Description = "description",
Id = "abc",
Name = "Name",
Uri = "picture"
};
// create test avatar
var result = (RedirectToRouteResult)controller.Create(data);
// Check that the item is created (from create)
var resultAvatar = AvatarItemBackend.Instance.Read("abc");
Assert.AreEqual(data.Id, resultAvatar.Id, TestContext.TestName);
// Act
var updateResult = controller.Update(data.Id) as ViewResult;
resultAvatar = updateResult.Model as AvatarItemModel;
// Assert
Assert.AreNotEqual(null, resultAvatar.Id, TestContext.TestName);
// Reset the Avatars
AvatarItemBackend.Instance.Reset();
}
public void Controller_Avatar_Delete_Post_Valid_Data_Should_Delete_Pass()
{
// Arrange
AvatarItemController controller = new AvatarItemController();
var data = new AvatarItemModel
{
Description = "description",
Name = "Name",
Uri = "picture"
};
var id = data.Id;
bool isFound = true;
// Make an avatar
AvatarItemBackend.Instance.Create(data);
var context = CreateMoqSetupForCookie();
controller.ControllerContext = new ControllerContext(context, new RouteData(), controller);
// Act
ViewResult result = controller.Delete(data) as ViewResult;
var dataRead = AvatarItemBackend.Instance.Read(id);
if (dataRead == null)
{
isFound = false;
}
// Assert
Assert.AreEqual(false, isFound, TestContext.TestName);
}
public void Backend_DataSourceBackendTable_ConvertFromEntityList_Valid_List_Should_Return()
{
// Arrange
DataSourceBackend.SetTestingMode(true);
var backend = DataSourceBackendTable.Instance;
var temp = new DataSourceBackendTableEntity
{
PartitionKey = "pk",
RowKey = "rk"
};
var tempblob = new AvatarItemModel();
var entity = backend.ConvertToEntity <AvatarItemModel>(tempblob, temp.PartitionKey, temp.RowKey);
var data = new List <DataSourceBackendTableEntity>
{
entity
};
// Act
var result = backend.ConvertFromEntityList <AvatarItemModel>(data);
// Reset
DataSourceBackend.Instance.Reset();
DataSourceBackend.SetTestingMode(false);
// Assert
Assert.IsNotNull(result, TestContext.TestName);
}
public void Models_AvatarItemModel_Default_Instantiate_Should_Pass()
{
// Act
var result = new AvatarItemModel();
// Assert
Assert.IsNotNull(result, TestContext.TestName);
}
/// <summary>
/// Makes a new AvatarItem
/// </summary>
/// <param name="data"></param>
/// <returns>AvatarItem Passed In</returns>
public AvatarItemModel Create(AvatarItemModel data, DataSourceEnum dataSourceEnum = DataSourceEnum.Unknown)
{
DataList.Add(data);
// Add to Storage
var myResult = DataSourceBackendTable.Instance.Create<AvatarItemModel>(tableName, partitionKey, data.Id, data, dataSourceEnum);
return data;
}
/// <summary>
/// Update all attributes to be what is passed in
/// </summary>
/// <param name="data"></param>
/// <returns>Null or updated data</returns>
public AvatarItemModel Update(AvatarItemModel data)
{
if (data == null)
{
return(null);
}
var myReturn = DataSource.Update(data);
return(myReturn);
}
public void Models_AvatarItemModel_Instantiate_Valid_Get_Catagory_Should_Pass()
{
// Arrange
var result = new AvatarItemModel();
// Act
var expect = result.Category;
// Assert
Assert.AreEqual(expect, result.Category, TestContext.TestName);
}
/// <summary>
/// This opens up the make a new AvatarItem screen
/// </summary>
/// <returns></returns>
// GET: AvatarItem/Create
public ActionResult Create()
{
var CurrentId = DataSourceBackend.Instance.IdentityBackend.GetCurrentStudentID(HttpContext);
if (DataSourceBackend.Instance.IdentityBackend.BlockExecptForRole(CurrentId, UserRoleEnum.TeacherUser))
{
return(RedirectToAction("Login", "Admin"));
}
var myData = new AvatarItemModel();
return(View(myData));
}
public void Backend_AvatarItemBackend_GetAvatarItemUri_Invalid_ID_Should_Fail()
{
//arrange
var data = new AvatarItemModel();
var test = AvatarItemBackend.Instance;
data.Id = "bogus";
//act
var result = test.GetAvatarItemUri(data.Id);
//assert
Assert.IsNull(result, TestContext.TestName);
}
public void Backend_AvatarItemDataSourceMock_Update_Invalid_Data_Shop_Item_Does_Not_Exist_Should_Fail()
{
// Arrange
var backend = AvatarItemDataSourceMock.Instance;
var expectShopModel = new AvatarItemModel();
// Act
var result = backend.Update(expectShopModel);
//reset
backend.Reset();
// Assert
Assert.IsNull(result, TestContext.TestName);
}
public void Backend_AvatarItemBackend_Create_Valid_Data_Should_Pass()
{
//arrange
var test = AvatarItemBackend.Instance;
var data = new AvatarItemModel();
//act
var result = test.Create(data);
//reset
test.Reset();
//assert
Assert.IsNotNull(result, TestContext.TestName);
Assert.AreEqual(data.Id, result.Id, TestContext.TestName);
}
/// <summary>
/// Update all attributes to be what is passed in
/// </summary>
/// <param name="data"></param>
/// <returns>Null or updated data</returns>
public AvatarItemModel Update(AvatarItemModel data)
{
if (data == null)
{
return(null);
}
var myReturn = DataList.Find(n => n.Id == data.Id);
if (myReturn == null)
{
return(null);
}
myReturn.Update(data);
return(myReturn);
}
public void Backend_AvatarItemBackend_Delete_Valid_Data_Should_Pass()
{
//arrange
var test = AvatarItemBackend.Instance;
var data = new AvatarItemModel();
var createResult = test.Create(data);
var expect = true;
//act
var deleteResult = test.Delete(data.Id);
//reset
test.Reset();
//assert
Assert.AreEqual(expect, deleteResult, TestContext.TestName);
}
public void Models_AvatarItemModel_Instantiate_Valid_Should_Pass()
{
// Arrange
var uri = "uri";
var name = "name";
var description = "description";
AvatarItemCategoryEnum category = AvatarItemCategoryEnum.Accessory;
int tokens = 10;
int quantities = 10;
bool isLimitSupply = true;
var expect = uri;
// Act
var result = new AvatarItemModel(uri, name, description, category, tokens, quantities, isLimitSupply);
// Assert
Assert.AreEqual(expect, result.Uri, TestContext.TestName);
}
public void Backend_AvatarItemDataSourceTable_Update_Invalid_Data_Shop_Item_Does_Not_Exist_Should_Fail()
{
// Arrange
DataSourceBackend.SetTestingMode(true);
var backend = AvatarItemDataSourceTable.Instance;
var expectShopModel = new AvatarItemModel();
// Act
var result = backend.Update(expectShopModel);
// Reset
DataSourceBackend.Instance.Reset();
DataSourceBackend.SetTestingMode(false);
// Assert
Assert.IsNull(result, TestContext.TestName);
}
public void Models_AvatarItemModel_Update_With_Invalid_Data_Null_Should_Fail()
{
// Arrange
var expect = "test";
var data = new AvatarItemModel
{
Id = "test"
};
// Act
data.Update(null);
var result = data.Id;
// Assert
Assert.AreEqual(expect, result, TestContext.TestName);
}
/// <summary>
/// Update all attributes to be what is passed in
/// </summary>
/// <param name="data"></param>
/// <returns>Null or updated data</returns>
public AvatarItemModel Update(AvatarItemModel data)
{
if (data == null)
{
return null;
}
var myReturn = DataList.Find(n => n.Id == data.Id);
if (myReturn == null)
{
return null;
}
myReturn.Update(data);
// Update Storage
var myResult = DataSourceBackendTable.Instance.Create<AvatarItemModel>(tableName, partitionKey, data.Id, data);
return data;
}
public void Backend_DataSourceBackendTable_ConvertToEntity_Valid_Should_Return()
{
// Arrange
DataSourceBackend.SetTestingMode(true);
var backend = DataSourceBackendTable.Instance;
var data = new AvatarItemModel();
var table = "AvatarItemModel".ToLower();
var pk = table;
var rk = "rk";
// Act
var result = backend.ConvertToEntity <AvatarItemModel>(data, pk, rk);
// Reset
DataSourceBackend.Instance.Reset();
DataSourceBackend.SetTestingMode(false);
// Assert
Assert.IsNotNull(result, TestContext.TestName);
}
public void Backend_DataSourceBackendTable_DeleteDirect_Valid_Should_Return()
{
// Arrange
DataSourceBackend.SetTestingMode(true);
var backend = DataSourceBackendTable.Instance;
var data = new AvatarItemModel();
var table = "AvatarItemModel".ToLower();
var pk = table;
var rk = "rk";
// Act
var result = backend.DeleteDirect <AvatarItemModel>(table, pk, rk);
// Reset
DataSourceBackend.Instance.Reset();
DataSourceBackend.SetTestingMode(false);
// Assert
Assert.AreEqual(true, result, TestContext.TestName);
}
public void Backend_DataSourceBackendTable_Load_Invalid_pk_Null_Should_Fail()
{
// Arrange
DataSourceBackend.SetTestingMode(true);
var backend = DataSourceBackendTable.Instance;
var data = new AvatarItemModel();
var table = "AvatarItemModel".ToLower();
var pk = table;
var rk = "rk";
// Act
var result = backend.Load <AvatarItemModel>(table, null, rk);
// Reset
DataSourceBackend.Instance.Reset();
DataSourceBackend.SetTestingMode(false);
// Assert
Assert.IsNull(result, TestContext.TestName);
}
public void Controller_Avatar_Delete_Post_InValid_Model_Should_Return_Error()
{
// Arrange
var controller = new AvatarItemController();
var data = new AvatarItemModel
{
Description = "description"
};
// Make a model error then try to send it as a Avatar
controller.ModelState.AddModelError("test", "test");
var context = CreateMoqSetupForCookie();
controller.ControllerContext = new ControllerContext(context, new RouteData(), controller);
// Act
ViewResult result = controller.Delete(data) as ViewResult;
// Assert
Assert.AreEqual(controller.ModelState.IsValid, false, TestContext.TestName);
}
public void Controller_Avatar_Delete_Post_Invalid_Null_Id_Should_Return_Model()
{
// Arrange
AvatarItemController controller = new AvatarItemController();
var data = new AvatarItemModel
{
Description = "description",
Id = null,
Name = "Name",
Uri = "picture"
};
var context = CreateMoqSetupForCookie();
controller.ControllerContext = new ControllerContext(context, new RouteData(), controller);
// Act
ViewResult result = controller.Delete(data) as ViewResult;
var resultAvatar = result.Model as AvatarItemModel;
// Assert
Assert.AreEqual(data.Description, resultAvatar.Description, TestContext.TestName);
}
public void Controller_Avatar_Update_Post_Valid_Data_Should_Pass()
{
// Arrange
var controller = new AvatarItemController();
var data = new AvatarItemModel();
// Add to the backend
AvatarItemBackend.Instance.Create(data);
data.Description = "Updated Description";
var context = CreateMoqSetupForCookie();
controller.ControllerContext = new ControllerContext(context, new RouteData(), controller);
// Act
ViewResult result = controller.Update(data) as ViewResult;
var dataResult = AvatarItemBackend.Instance.Read(data.Id);
AvatarItemBackend.Instance.Reset();
// Assert
Assert.AreEqual(data.Description, dataResult.Description, TestContext.TestName);
}
/// <summary>
/// Makes a new AvatarItem
/// </summary>
/// <param name="data"></param>
/// <returns>AvatarItem Passed In</returns>
public AvatarItemModel Create(AvatarItemModel data)
{
//DataSource.Create(data);
return(data);
}
public AvatarSelectShopViewModel GetAvatarShopViewModel(StudentModel studentData, AvatarItemModel item)
{
var data = new AvatarSelectShopViewModel
{
Student = studentData,
data = GetAvatarItemShopViewModel(studentData.Id, item.Id)
};
return(data);
}
/// <summary>
/// Makes a new AvatarItem
/// </summary>
/// <param name="data"></param>
/// <returns>AvatarItem Passed In</returns>
public AvatarItemModel Create(AvatarItemModel data, DataSourceEnum dataSourceEnum = DataSourceEnum.Unknown)
{
DataList.Add(data);
return(data);
}
