public IActionResult Create(
[Bind("" +
"ID," +
"Date," +
"PhoneID," +
"VersionAppID",
// TODO, Add your attributes here. Make sure to include the comma , after the attribute name
"")] HistoryAppModel data)
{
if (!ModelState.IsValid)
{
return(RedirectToAction("Error", "Home"));
}
// Todo Save Change
var result = Backend.Create(data);
if (result == null)
{
return(RedirectToAction("Error", "Home"));
}
return(RedirectToAction(nameof(Index)));
}
public void HistoryApp_Update_Valid_Data_Good_Should_Pass()
{
// Arrange
var myData = new HistoryAppModel();
var myDataNew = new HistoryAppModel
{
PhoneID = "NewPhone",
VersionAppID = "NewVersion",
// TODO: Add your atttrbutes here
ID = myData.ID
};
// Act
myData.Update(myDataNew);
myData.Date = myData.Date.AddSeconds(-5);
// Assert
Assert.AreEqual("NewPhone", myData.PhoneID);
Assert.AreEqual("NewVersion", myData.VersionAppID);
// TODO: Add an Assert for each attribute that should change
Assert.AreNotEqual(myData.Date, myDataNew.Date);
// TODO: Add an Assert for each attribute that thould Not change
}
public IActionResult Update(
[Bind("" +
"ID," +
"Date," +
"PhoneID," +
"VersionAppID",
// TODO, Add your attributes here. Make sure to include the comma , after the attribute name
"")] HistoryAppModel data)
{
if (!ModelState.IsValid)
{
return(NotFound());
}
//Look up the ID
var dataExist = Backend.Read(data.ID);
if (dataExist == null)
{
return(NotFound());
}
var dataResult = Backend.Update(data);
if (dataResult == null)
{
return(NotFound());
}
return(RedirectToAction(nameof(Index)));
}
public IActionResult Create()
{
var data = new HistoryAppModel();
ViewData["PhoneIDList"] = BiliWeb.Backend.PhoneHelper.ToSelectListItems(BiliWeb.Backend.PhoneBackend.Instance.Index(), null);
ViewData["VersionAppIDList"] = BiliWeb.Backend.PhoneHelper.ToSelectListItems(BiliWeb.Backend.PhoneBackend.Instance.Index(), null);
return(View(data));
}
/// <summary>
/// Add the HistoryApp item to the data store
/// </summary>
/// <param name="data">
/// The new HistoryApp item to add to the data store
/// </param>
/// <returns>return the passed in HistoryApp item</returns>
public HistoryAppModel Create(HistoryAppModel data, DataSourceEnum dataSourceEnum = DataSourceEnum.Unknown)
{
if (data == null)
{
return(null);
}
dataset.Add(data);
return(data);
}
public void HistoryApp_Default_Should_Pass()
{
// Arrange
// Act
var result = new HistoryAppModel();
// Assert
Assert.IsNotNull(result);
}
public void HistoryApp_Update_InValid_Data_Null_Should_Fail()
{
// Arrange
var myData = new HistoryAppModel();
// Act
var result = myData.Update(null);
// Assert
Assert.AreEqual(false, result);
}
public void HistoryApp_Get_Should_Pass()
{
// Arrange
var myData = new HistoryAppModel();
// Act
// Assert
Assert.IsNull(myData.PhoneID);
Assert.IsNull(myData.VersionAppID);
// TODO: Add an Assert for each attribute
}
public void HistoryApp_Constructor_Data_Valid_Should_Pass()
{
// Arrange
var myData = new HistoryAppModel
{
PhoneID = "NewPhone"
};
// Act
var myNewData = new HistoryAppModel(myData);
// Assert
Assert.AreEqual("NewPhone", myNewData.PhoneID);
}
public void HistoryApp_Create_Post_Default_Should_Pass()
{
// Arrange
var myController = new HistoryAppController();
var myData = new HistoryAppModel();
// Act
var result = myController.Create(myData);
// Reset
// Assert
Assert.IsNotNull(result);
}
/// <summary>
/// Makes a new AvatarItem
/// </summary>
/// <param name="data"></param>
/// <returns>AvatarItem Passed In</returns>
public HistoryAppModel Create(HistoryAppModel data, DataSourceEnum dataSourceEnum = DataSourceEnum.Unknown)
{
if (data == null)
{
return(null);
}
dataset.Add(data);
// Add to Storage
var myResult = DataSourceBackendTable.Instance.Create <HistoryAppModel>(tableName, partitionKey, data.ID, data, dataSourceEnum);
return(data);
}
public void HistoryApp_Create_Post_Invalid_Model_Should_Send_Back_For_Edit()
{
// Arrange
var controller = new HistoryAppController();
var data = new HistoryAppModel();
// Make ModelState Invalid
controller.ModelState.AddModelError("test", "test");
// Act
var result = controller.Create(data) as RedirectToActionResult;
// Assert
Assert.AreEqual("Error", result.ActionName);
}
public void HistoryApp_Delete_Post_Invalid_Model_Should_Send_Back_For_Edit()
{
// Arrange
var controller = new HistoryAppController();
var data = new HistoryAppModel();
// Make ModelState Invalid
controller.ModelState.AddModelError("test", "test");
// Act
var result = controller.DeleteConfirmed(data.ID) as NotFoundResult;
// Assert
Assert.AreEqual(404, result.StatusCode);
}
public void HistoryApp_Create_InValid_Null_Should_Fail()
{
// Arrange
var myBackend = HistoryAppRepositoryMock.Instance;
var myData = new HistoryAppModel();
// Act
var result = myBackend.Create(null);
// Reset
myBackend.Reset();
// Assert
Assert.IsNull(result);
}
public void HistoryApp_Create_Default_Should_Pass()
{
// Arrange
var myBackend = HistoryAppRepositoryMock.Instance;
var myData = new HistoryAppModel();
// Act
var result = myBackend.Create(myData);
// Reset
myBackend.Reset();
// Assert
Assert.IsNotNull(result);
}
public void HistoryApp_Create_Post_Default_Should_Pass()
{
// Arrange
var myBackend = HistoryAppBackend.Instance;
var myData = new HistoryAppModel();
// Act
var result = myBackend.Create(myData);
// Reset
BiliWeb.Backend.DataSourceBackend.Instance.Reset();
// Assert
Assert.IsNotNull(result);
}
public void HistoryApp_Set_Should_Pass()
{
// Arrange
var myData = new HistoryAppModel();
// Act
myData.PhoneID = "NewPhone";
myData.VersionAppID = "NewVersion";
// TODO: Add each attribute here
// Assert
Assert.AreEqual("NewPhone", myData.PhoneID);
Assert.AreEqual("NewVersion", myData.VersionAppID);
// TODO: Add an Assert for each attribute
}
public void HistoryApp_Delete_Post_Empty_Id_Should_Send_Back_For_Edit()
{
// Arrange
var controller = new HistoryAppController();
HistoryAppModel dataEmpty = new HistoryAppModel
{
// Make data.Id empty
ID = ""
};
// Act
var result = controller.DeleteConfirmed(dataEmpty.ID) as RedirectToActionResult;
// Assert
Assert.AreEqual("Error", result.ActionName);
}
public void HistoryApp_Create_InValid_Null_Should_Fail()
{
// Arrange
DataSourceBackend.Instance.SetDataSource(DataSourceEnum.Local);
var myBackend = DataSourceBackend.Instance.HistoryAppBackend;
var myData = new HistoryAppModel();
// Act
var result = myBackend.Create(null);
// Reset
DataSourceBackend.Instance.Reset();
DataSourceBackend.Instance.SetDataSource(DataSourceEnum.Mock);
// Assert
Assert.IsNull(result);
}
public void HistoryApp_Create_Default_Should_Pass()
{
// Arrange
DataSourceBackend.Instance.SetDataSource(DataSourceEnum.Local);
var myBackend = DataSourceBackend.Instance.HistoryAppBackend;
var myData = new HistoryAppModel();
// Act
var result = myBackend.Create(myData);
// Reset
DataSourceBackend.Instance.Reset();
DataSourceBackend.Instance.SetDataSource(DataSourceEnum.Mock);
// Assert
Assert.IsNotNull(result);
}
public void HistoryApp_Delete_Post_Default_Should_Return_Index_Page()
{
// Arrange
var controller = new HistoryAppController();
// Get default student
var defaultData = BiliWeb.Backend.DataSourceBackend.Instance.HistoryAppBackend.Index().FirstOrDefault();
HistoryAppModel data = new HistoryAppModel(defaultData);
// Act
var result = controller.DeleteConfirmed(data.ID) as NotFoundResult;
// Reset
BiliWeb.Backend.DataSourceBackend.Instance.Reset();
// Assert
Assert.AreEqual(404, result.StatusCode);
}
public void HistoryApp_Update_InValid_Bogus_Should_Fail()
{
// Arrange
var myBackend = HistoryAppRepositoryMock.Instance;
var myDataCopy = new HistoryAppModel
{
ID = "bogus"
};
// Act
var result = myBackend.Update(myDataCopy);
// Reset
myBackend.Reset();
// Assert
Assert.AreEqual(null, result);
}
/// <summary>
/// Update the item in the data store
/// use the ID from the item passed in to find the item and then update it
/// </summary>
/// <param name="data">the item to update</param>
/// <returns>the updated item</returns>
public HistoryAppModel Update(HistoryAppModel data)
{
// Get the first instance of the record
if (data == null)
{
return(null);
}
var myData = Read(data.ID);
if (myData == null)
{
return(null);
}
myData.Update(data);
return(data);
}
public void HistoryAppHelper_ConvertIDtoString_Valid_Should_Pass()
{
// Arrange
var data = new HistoryAppModel
{
PhoneID = "NewPhone"
};
DataSourceBackend.Instance.HistoryAppBackend.Create(data);
// Act
var result = HistoryAppHelper.ConvertIDtoString(data.ID);
// Reset
DataSourceBackend.Instance.Reset();
// Assert
Assert.AreEqual("NewPhone", result);
}
public void HistoryApp_Update_Post_Valid_Data_Should_Pass()
{
// Arrange
var myController = new HistoryAppController();
var myData = BiliWeb.Backend.HistoryAppBackend.Instance.Index().FirstOrDefault();
var resultData = new HistoryAppModel(myData)
{
PhoneID = "NewPhone",
ID = myData.ID
};
// Act
var result = myController.Update(resultData) as RedirectToActionResult;
//Reset
BiliWeb.Backend.DataSourceBackend.Instance.Reset();
// Assert
Assert.AreEqual("Index", result.ActionName);
}
public void HistoryApp_Update_InValid_Bogus_Should_Fail()
{
// Arrange
DataSourceBackend.Instance.SetDataSource(DataSourceEnum.Local);
var myBackend = DataSourceBackend.Instance.HistoryAppBackend;
var myDataCopy = new HistoryAppModel
{
ID = "bogus"
};
// Act
var result = myBackend.Update(myDataCopy);
// Reset
DataSourceBackend.Instance.Reset();
DataSourceBackend.Instance.SetDataSource(DataSourceEnum.Mock);
// Assert
Assert.AreEqual(null, result);
}
public void HistoryApp_Update_Default_Should_Pass()
{
// Arrange
var myBackend = HistoryAppRepositoryMock.Instance;
var myData = myBackend.Index().FirstOrDefault();
// Make a Copy of the Data and update an aspect of it
var myDataCopy = new HistoryAppModel(myData);
myDataCopy.ID = myData.ID; // Force the ID to match for this test.
myDataCopy.PhoneID = "NewPhone";
// Act
var result = myBackend.Update(myDataCopy);
// Reset
myBackend.Reset();
// Assert
Assert.AreEqual("NewPhone", result.PhoneID);
}
/// <summary>
/// Update all attributes to be what is passed in
/// </summary>
/// <param name="data"></param>
/// <returns>Null or updated data</returns>
public HistoryAppModel Update(HistoryAppModel data)
{
if (data == null)
{
return(null);
}
var myReturn = Read(data.ID);
if (myReturn == null)
{
return(null);
}
myReturn.Update(data);
// Update Storage
var myResult = DataSourceBackendTable.Instance.Create <HistoryAppModel>(tableName, partitionKey, data.ID, data);
return(data);
}
/// <summary>
/// Update
/// </summary>
/// <param name="data">The record passed in.</param>
/// <returns>The updated record.</returns>
public HistoryAppModel Update(HistoryAppModel data)
{
var myData = repository.Update(data);
return(myData);
}
