public IActionResult Create(
[Bind("" +
"ID," +
"Date," +
"VersionOSName," +
// TODO, Add your attributes here. Make sure to include the comma , after the attribute name
"")] VersionOSModel 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 IActionResult Update(
[Bind("" +
"ID," +
"Date," +
"VersionOSName," +
// TODO, Add your attributes here. Make sure to include the comma , after the attribute name
"")] VersionOSModel 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 void VersionOSModel_Update_Valid_Data_Good_Should_Pass()
{
// Arrange
var myData = new VersionOSModel();
var myDataNew = new VersionOSModel
{
VersionOSName = "New",
// TODO: Add your atttrbutes here
ID = myData.ID
};
// Act
myData.Update(myDataNew);
myData.Date = myData.Date.AddSeconds(-5);
// Assert
Assert.AreEqual("New", myData.VersionOSName);
// 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 void PhoneReportViewModel_Set_Should_Pass()
{
// Prepare data
PhoneModel phone = new PhoneModel();
System.DateTime install = new System.DateTime();
System.DateTime lastHeard = new System.DateTime();
VersionAppModel appVersion = new VersionAppModel();
VersionOSModel osVersion = new VersionOSModel();
List <HistoryOSModel> myOSHistoryList = new List <HistoryOSModel>();
List <HistoryAppModel> myAppHistoryList = new List <HistoryAppModel>();
var data = new PhoneReportViewModel()
{
PhoneModel = phone,
InitialInstall = install,
LastHeardFrom = lastHeard,
CurrentAppVersion = appVersion,
CurrentOSVersion = osVersion,
};
data.PhoneOSHistory = myOSHistoryList;
data.PhoneAppHistory = myAppHistoryList;
Assert.AreEqual(phone, data.PhoneModel);
Assert.AreEqual(install, data.InitialInstall);
Assert.AreEqual(lastHeard, data.LastHeardFrom);
Assert.AreEqual(appVersion, data.CurrentAppVersion);
Assert.AreEqual(osVersion, data.CurrentOSVersion);
Assert.AreEqual(myOSHistoryList, data.PhoneOSHistory);
Assert.AreEqual(myAppHistoryList, data.PhoneAppHistory);
}
/// <summary>
/// Add the VersionOS item to the data store
/// </summary>
/// <param name="data">
/// The new VersionOS item to add to the data store
/// </param>
/// <returns>return the passed in VersionOS item</returns>
public VersionOSModel Create(VersionOSModel data, DataSourceEnum dataSourceEnum = DataSourceEnum.Unknown)
{
if (data == null)
{
return(null);
}
dataset.Add(data);
return(data);
}
public void VersionOSModel_Default_Should_Pass()
{
// Arrange
// Act
var result = new VersionOSModel();
// Assert
Assert.IsNotNull(result);
}
public void VersionOSModel_Update_InValid_Data_Null_Should_Fail()
{
// Arrange
var myData = new VersionOSModel();
// Act
var result = myData.Update(null);
// Assert
Assert.AreEqual(false, result);
}
public void VersionOSModel_Get_Should_Pass()
{
// Arrange
var myData = new VersionOSModel();
// Act
// Assert
Assert.IsNull(myData.VersionOSName);
// TODO: Add an Assert for each attribute
}
/// <summary>
/// Makes a new AvatarItem
/// </summary>
/// <param name="data"></param>
/// <returns>AvatarItem Passed In</returns>
public VersionOSModel Create(VersionOSModel data, DataSourceEnum dataSourceEnum = DataSourceEnum.Unknown)
{
if (data == null)
{
return(null);
}
dataset.Add(data);
// Add to Storage
var myResult = DataSourceBackendTable.Instance.Create <VersionOSModel>(tableName, partitionKey, data.ID, data, dataSourceEnum);
return(data);
}
public void VersionOSModel_Constructor_Data_Valid_Should_Pass()
{
// Arrange
var myData = new VersionOSModel
{
VersionOSName = "New"
};
// Act
var myNewData = new VersionOSModel(myData);
// Assert
Assert.AreEqual("New", myNewData.VersionOSName);
}
public void VersionOSModel_Set_Should_Pass()
{
// Arrange
var myData = new VersionOSModel();
// Act
myData.VersionOSName = "New";
// TODO: Add each attribute here
// Assert
Assert.AreEqual("New", myData.VersionOSName);
// TODO: Add an Assert for each attribute
}
public void VersionOS_Create_Post_Default_Should_Pass()
{
// Arrange
var myController = new VersionOSController();
var myData = new VersionOSModel();
// Act
var result = myController.Create(myData);
// Reset
// Assert
Assert.IsNotNull(result);
}
public void VersionOS_Create_Default_Should_Pass()
{
// Arrange
var myBackend = VersionOSRepositoryMock.Instance;
var myData = new VersionOSModel();
// Act
var result = myBackend.Create(myData);
// Reset
myBackend.Reset();
// Assert
Assert.IsNotNull(result);
}
public void VersionOS_Create_InValid_Null_Should_Fail()
{
// Arrange
var myBackend = VersionOSRepositoryMock.Instance;
var myData = new VersionOSModel();
// Act
var result = myBackend.Create(null);
// Reset
myBackend.Reset();
// Assert
Assert.IsNull(result);
}
public void VersionOS_Create_Post_Default_Should_Pass()
{
// Arrange
var myBackend = VersionOSBackend.Instance;
var myData = new VersionOSModel();
// Act
var result = myBackend.Create(myData);
// Reset
BiliWeb.Backend.DataSourceBackend.Instance.Reset();
// Assert
Assert.IsNotNull(result);
}
public void VersionOS_Delete_Post_Invalid_Model_Should_Send_Back_For_Edit()
{
// Arrange
var controller = new VersionOSController();
var data = new VersionOSModel();
// 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 VersionOS_Create_Post_Invalid_Model_Should_Send_Back_For_Edit()
{
// Arrange
var controller = new VersionOSController();
var data = new VersionOSModel();
// Make ModelState Invalid
controller.ModelState.AddModelError("test", "test");
// Act
var result = controller.Create(data) as RedirectToActionResult;
// Assert
Assert.AreEqual("Error", result.ActionName);
}
public void VersionOS_Delete_Post_Empty_Id_Should_Send_Back_For_Edit()
{
// Arrange
var controller = new VersionOSController();
VersionOSModel dataEmpty = new VersionOSModel
{
// Make data.Id empty
ID = ""
};
// Act
var result = controller.DeleteConfirmed(dataEmpty.ID) as RedirectToActionResult;
// Assert
Assert.AreEqual("Error", result.ActionName);
}
public void VersionOS_Create_InValid_Null_Should_Fail()
{
// Arrange
DataSourceBackend.Instance.SetDataSource(DataSourceEnum.Local);
var myBackend = DataSourceBackend.Instance.VersionOSBackend;
var myData = new VersionOSModel();
// Act
var result = myBackend.Create(null);
// Reset
DataSourceBackend.Instance.Reset();
DataSourceBackend.Instance.SetDataSource(DataSourceEnum.Mock);
// Assert
Assert.IsNull(result);
}
public void VersionOS_Create_Default_Should_Pass()
{
// Arrange
DataSourceBackend.Instance.SetDataSource(DataSourceEnum.Local);
var myBackend = DataSourceBackend.Instance.VersionOSBackend;
var myData = new VersionOSModel();
// Act
var result = myBackend.Create(myData);
// Reset
DataSourceBackend.Instance.Reset();
DataSourceBackend.Instance.SetDataSource(DataSourceEnum.Mock);
// Assert
Assert.IsNotNull(result);
}
public void VersionOS_Delete_Post_Default_Should_Return_Index_Page()
{
// Arrange
var controller = new VersionOSController();
// Get default student
var defaultData = BiliWeb.Backend.DataSourceBackend.Instance.VersionOSBackend.Index().FirstOrDefault();
VersionOSModel data = new VersionOSModel(defaultData);
// Act
var result = controller.DeleteConfirmed(data.ID) as NotFoundResult;
// Reset
BiliWeb.Backend.DataSourceBackend.Instance.Reset();
// Assert
Assert.AreEqual(404, result.StatusCode);
}
public void VersionOS_Update_InValid_Bogus_Should_Fail()
{
// Arrange
var myBackend = VersionOSRepositoryMock.Instance;
var myDataCopy = new VersionOSModel
{
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 VersionOSModel Update(VersionOSModel 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 VersionOSHelper_ConvertIDtoString_Valid_Should_Pass()
{
// Arrange
var data = new VersionOSModel
{
VersionOSName = "Name"
};
DataSourceBackend.Instance.VersionOSBackend.Create(data);
// Act
var result = VersionOSHelper.ConvertIDtoString(data.ID);
// Reset
DataSourceBackend.Instance.Reset();
// Assert
Assert.AreEqual("Name", result);
}
public void VersionOS_Update_Post_Valid_Data_Should_Pass()
{
// Arrange
var myController = new VersionOSController();
var myData = BiliWeb.Backend.VersionOSBackend.Instance.Index().FirstOrDefault();
var resultData = new VersionOSModel(myData)
{
VersionOSName = "New",
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 VersionOS_Update_InValid_Bogus_Should_Fail()
{
// Arrange
DataSourceBackend.Instance.SetDataSource(DataSourceEnum.Local);
var myBackend = DataSourceBackend.Instance.VersionOSBackend;
var myDataCopy = new VersionOSModel
{
ID = "bogus"
};
// Act
var result = myBackend.Update(myDataCopy);
// Reset
DataSourceBackend.Instance.Reset();
DataSourceBackend.Instance.SetDataSource(DataSourceEnum.Mock);
// Assert
Assert.AreEqual(null, result);
}
public void VersionOS_Update_Default_Should_Pass()
{
// Arrange
var myBackend = VersionOSRepositoryMock.Instance;
var myData = myBackend.Index().FirstOrDefault();
// Make a Copy of the Data and update an aspect of it
var myDataCopy = new VersionOSModel(myData);
myDataCopy.ID = myData.ID; // Force the ID to match for this test.
myDataCopy.VersionOSName = "New3";
// Act
var result = myBackend.Update(myDataCopy);
// Reset
myBackend.Reset();
// Assert
Assert.AreEqual("New3", result.VersionOSName);
}
/// <summary>
/// Update all attributes to be what is passed in
/// </summary>
/// <param name="data"></param>
/// <returns>Null or updated data</returns>
public VersionOSModel Update(VersionOSModel 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 <VersionOSModel>(tableName, partitionKey, data.ID, data);
return(data);
}
public void VersionOS_Update_Default_Should_Pass()
{
// Arrange
DataSourceBackend.Instance.SetDataSource(DataSourceEnum.Local);
var myBackend = DataSourceBackend.Instance.VersionOSBackend;
var myData = myBackend.Index().FirstOrDefault();
// Make a Copy of the Data and update an aspect of it
var myDataCopy = new VersionOSModel(myData);
myDataCopy.ID = myData.ID; // Force the ID to match for this test.
myDataCopy.VersionOSName = "New3";
// Act
var result = myBackend.Update(myDataCopy);
// Reset
DataSourceBackend.Instance.Reset();
DataSourceBackend.Instance.SetDataSource(DataSourceEnum.Mock);
// Assert
Assert.AreEqual("New3", result.VersionOSName);
}
/// <summary>
/// Update
/// </summary>
/// <param name="data">The record passed in.</param>
/// <returns>The updated record.</returns>
public VersionOSModel Update(VersionOSModel data)
{
var myData = repository.Update(data);
return(myData);
}
