public void EquipmentTypeManager_DeleteEquipmentType_Equipment_Values()
{
var saveTask = Task <EquipmentType> .Factory.StartNew(() => { return(new EquipmentType()); });
var equipmentSave = Task <Equipment> .Factory.StartNew(() => { return(new Equipment()); });
EquipmentTypeAccessor.Arrange(x => x.GetEquipmentType(Arg.IsAny <long>()))
.Returns(Task.FromResult(new EquipmentType()))
.OccursOnce();
EquipmentTypeAccessor.Arrange(x => x.SaveEquipmentType(Arg.IsAny <EquipmentType>()))
.Returns(saveTask)
.OccursOnce();
EquipmentAccessor.Arrange(x => x.GetEquipmentByType(Arg.IsAny <long>()))
.Returns(Task.FromResult(new List <Equipment> {
new Equipment {
EquipmentTypeId = 5
}, new Equipment()
}.AsEnumerable()))
.OccursOnce();
EquipmentAccessor.Arrange(x => x.SaveEquipment(Arg.Matches <Equipment>(y => y.EquipmentTypeId == 1)))
.Returns(equipmentSave)
.Occurs(2);
var res = manager.DeleteEquipmentType(5).Result;
saveTask.Wait();
equipmentSave.Wait();
EquipmentTypeAccessor.Assert();
EquipmentAccessor.Assert();
Assert.IsNotNull(res);
Assert.IsTrue(res);
}
public async Task <bool> DeleteEquipmentType(long equipmentTypeId)
{
var equipmentType = await EquipmentTypeAccessor.GetEquipmentType(equipmentTypeId);
equipmentType.Deleted = true;
try
{
await EquipmentTypeAccessor.SaveEquipmentType(equipmentType);
Logger.Log(string.Format("Equipment type deleted - Id: {0}", equipmentTypeId), TraceEventType.Information);
// update the equipment type for existing equipment with the deleted type
var equipments = await EquipmentAccessor.GetEquipmentByType(equipmentTypeId);
foreach (var equipment in equipments)
{
try
{
equipment.EquipmentTypeId = 1;
await EquipmentAccessor.SaveEquipment(equipment);
}
catch (Exception ex)
{
Logger.Log(string.Format("Could not reassign equipment Type - EquipmentId: {0}", equipment.EquipmentId), TraceEventType.Error, ex);
}
}
return(true);
}
catch (Exception ex)
{
Logger.Log("Could not delete equipment type", TraceEventType.Error, ex);
return(false);
}
}
public void EquipmentAccessor_GetEquipment_Null()
{
accessor = GetAccessor();
var res = accessor.GetEquipment(99).Result;
Assert.IsNull(res);
}
public void EquipmentAccessor_GetEquipmentByType_Empty()
{
accessor = GetAccessor();
var res = accessor.GetEquipmentByType(99).Result;
Assert.IsNotNull(res);
Assert.AreEqual(0, res.Count());
}
public void EquipmentAccessor_Init()
{
accessor = GetAccessor();
Assert.IsNotNull(accessor);
Assert.IsNotNull(MockDatabaseContext);
Assert.IsNotNull(MockDatabaseContext.Equipment);
Assert.IsNotNull(MockDatabaseContext.EquipmentTypes);
}
public void EquipmentAccessor_GetEquipment()
{
accessor = GetAccessor();
var res = accessor.GetEquipment(2).Result;
Assert.IsNotNull(res);
Assert.AreEqual(typeof(Equipment), res.GetType());
Assert.AreEqual("Name 2", res.Name);
}
public void EquipmentManager_GetEquipmentSchedule()
{
EquipmentAccessor.Arrange(x => x.GetEquipmentSchedule(Arg.IsAny <long>()))
.Returns(Task.FromResult(Enumerable.Empty <EquipmentSchedule>()))
.OccursOnce();
var res = manager.GetEquipmentSchedule(5).Result;
Assert.IsNotNull(res);
EquipmentAccessor.Assert();
}
public void EquipmentManager_SaveEquipment()
{
EquipmentAccessor.Arrange(x => x.SaveEquipment(Arg.IsAny <Equipment>()))
.Returns(Task.FromResult(new Equipment()))
.OccursOnce();
var res = manager.SaveEquipment(new Equipment()).Result;
Assert.IsNotNull(res);
EquipmentAccessor.Assert();
}
public void EquipmentAccessor_GetEquipmentByType()
{
accessor = GetAccessor();
var res = accessor.GetEquipmentByType(1).Result;
Assert.IsNotNull(res);
Assert.AreEqual(3, res.Count());
Assert.AreEqual(typeof(List <Equipment>), res.GetType());
Assert.AreEqual("Name 1", res.First().Name);
}
public void EquipmentManager_GetAllEquipment()
{
EquipmentAccessor.Arrange(x => x.GetAllEquipment())
.Returns(Task.FromResult(Enumerable.Empty <Equipment>()))
.OccursOnce();
var res = manager.GetAllEquipment().Result;
Assert.IsNotNull(res);
EquipmentAccessor.Assert();
}
public void EquipmentAccessor_GetEquipmentSchedule()
{
accessor = GetAccessor();
var res = accessor.GetEquipmentSchedule(1).Result;
Assert.IsNotNull(res);
Assert.AreEqual(2, res.Count());
Assert.AreEqual(typeof(List <EquipmentSchedule>), res.GetType());
Assert.AreEqual(new DateTime(2016, 11, 11), res.First().StartDate);
}
public void EquipmentManager_GetEquipment_Values()
{
EquipmentAccessor.Arrange(x => x.GetEquipment(5))
.Returns(Task.FromResult(new Equipment {
Name = "test"
}))
.OccursOnce();
var res = manager.GetEquipment(5).Result;
Assert.IsNotNull(res);
Assert.AreEqual("test", res.Name);
EquipmentAccessor.Assert();
}
public void EquipmentManager_GetEquipmentSchedule_Values()
{
EquipmentAccessor.Arrange(x => x.GetEquipmentSchedule(5))
.Returns(Task.FromResult(new List <EquipmentSchedule> {
new EquipmentSchedule(), new EquipmentSchedule()
}.AsEnumerable()))
.OccursOnce();
var res = manager.GetEquipmentSchedule(5).Result;
Assert.IsNotNull(res);
Assert.AreEqual(2, res.Count());
EquipmentAccessor.Assert();
}
public void EquipmentManager_SaveEquipment_Values()
{
var equip = new Equipment {
EquipmentId = 5
};
var saveTask = Task <Equipment> .Factory.StartNew(() => { return(equip); });
EquipmentAccessor.Arrange(x => x.SaveEquipment(equip))
.Returns(saveTask)
.OccursOnce();
var res = manager.SaveEquipment(equip).Result;
saveTask.Wait();
Assert.IsNotNull(res);
EquipmentAccessor.Assert();
}
public async Task <bool> DeleteEquipment(long equipmentId)
{
var equipment = await EquipmentAccessor.GetEquipment(equipmentId);
equipment.Deleted = true;
try
{
await EquipmentAccessor.SaveEquipment(equipment);
return(true);
}
catch (Exception ex)
{
Logger.Log("Could not delete equipment", TraceEventType.Error, ex);
return(false);
}
}
public void EquipmentAccessor_SaveEquipment()
{
accessor = GetAccessor();
var equipment = new Equipment
{
Name = "New Equipment",
Description = "New Description",
DateAquired = new DateTime(2016, 11, 11),
EquipmentTypeId = 1
};
var res = accessor.SaveEquipment(equipment).Result;
Assert.IsNotNull(res);
Assert.AreEqual(5, MockDatabaseContext.Equipment.Count());
Assert.AreEqual("New Equipment", MockDatabaseContext.Equipment.Last().Name);
}
public void EquipmentManager_DeleteEquipment()
{
var saveTask = Task <Equipment> .Factory.StartNew(() => { return(new Equipment()); });
EquipmentAccessor.Arrange(x => x.GetEquipment(Arg.IsAny <long>()))
.Returns(Task.FromResult(new Equipment()))
.OccursOnce();
EquipmentAccessor.Arrange(x => x.SaveEquipment(Arg.IsAny <Equipment>()))
.Returns(saveTask)
.OccursOnce();
var res = manager.DeleteEquipment(5).Result;
saveTask.Wait();
Assert.IsNotNull(res);
Assert.IsTrue(res);
EquipmentAccessor.Assert();
}
public void EquipmentManager_DeleteEquipment_CatchException()
{
var saveTask = Task <Equipment> .Factory.StartNew(() => { return(new Equipment()); });
EquipmentAccessor.Arrange(x => x.GetEquipment(5))
.Returns(Task.FromResult(new Equipment {
Deleted = false
}))
.OccursOnce();
EquipmentAccessor.Arrange(x => x.SaveEquipment(Arg.Matches <Equipment>(y => y.Deleted)))
.Throws(new Exception())
.OccursOnce();
var res = manager.DeleteEquipment(5).Result;
saveTask.Wait();
Assert.IsNotNull(res);
Assert.IsFalse(res);
EquipmentAccessor.Assert();
}
public void EquipmentAccessor_SaveEquipment_Update()
{
accessor = GetAccessor();
var equipment = new Equipment
{
EquipmentId = 3,
Name = "New Equipment",
Description = "New Description",
DateAquired = new DateTime(2015, 11, 11),
EquipmentTypeId = 99,
Deleted = true
};
var res = accessor.SaveEquipment(equipment).Result;
Assert.IsNotNull(res);
Assert.AreEqual(5, MockDatabaseContext.Equipment.Count());
Assert.AreEqual("New Equipment", MockDatabaseContext.Equipment.First(x => x.EquipmentId == 3).Name);
Assert.AreEqual("New Description", MockDatabaseContext.Equipment.First(x => x.EquipmentId == 3).Description);
Assert.AreEqual(new DateTime(2015, 11, 11), MockDatabaseContext.Equipment.First(x => x.EquipmentId == 3).DateAquired);
Assert.AreEqual(99, MockDatabaseContext.Equipment.First(x => x.EquipmentId == 3).EquipmentTypeId);
}
public async Task <IEnumerable <Equipment> > GetAllEquipment()
{
return(await EquipmentAccessor.GetAllEquipment());
}
public async Task <Equipment> GetEquipment(long equipmentId)
{
return(await EquipmentAccessor.GetEquipment(equipmentId));
}
public async Task <Equipment> SaveEquipment(Equipment equipment)
{
return(await EquipmentAccessor.SaveEquipment(equipment));
}
public async Task <IEnumerable <Equipment> > GetEquipmentByType(long equipmentTypeId)
{
return(await EquipmentAccessor.GetEquipmentByType(equipmentTypeId));
}
public async Task <IEnumerable <EquipmentSchedule> > GetEquipmentSchedule(long equipmentId)
{
return(await EquipmentAccessor.GetEquipmentSchedule(equipmentId));
}
