public async Task <ActionResult <IEnumerable <ItemDto> > > SalvageEquipment([FromBody] EquipmentDto dto, [FromServices] IEquipmentSalvager equipmentSalvager)
{
var userId = User.Claims.GetUserId();
if (userId == null)
{
return(Forbid());
}
var equipment = await Context.Equipment
.Where(o => o.UserId == userId)
.FirstOrDefaultAsync(o => o.Id == dto.Id);
if (equipment == null)
{
return(BadRequest());
}
var items = equipmentSalvager.Salvage(equipment, userId.Value).ToList();
Context.Remove(equipment);
Context.AddRange(items);
await Context.SaveChangesAsync();
return(Ok(Mapper.Map <IEnumerable <ItemDto> >(items)));
}
public async Task <Guid> CreateAsync(CharacterCreateDto entityDto)
{
using (var uow = UnitOfWorkProvider.Create())
{
//attributes, inventory, equipment
var inv = new InventoryDto()
{
Id = Guid.NewGuid(), MaxSize = 12
};
var attr = GenerateAttributesAccordingToCharacter(entityDto);
var eq = new EquipmentDto()
{
Id = Guid.NewGuid()
};
entityDto.CurrentHp = 10 * attr.Hp;
entityDto.Inventory = inv;
entityDto.Equipment = eq;
entityDto.Attributes = attr;
entityDto.Id = _characterService.Create(entityDto);
await uow.Commit();
return(entityDto.Id);
}
}
public async Task <IActionResult> AddEquipment([FromBody] EquipmentDto equipmentDto)
{
//nieuwzglenianie case sensitivity
equipmentDto.EqName = equipmentDto.EqName.ToLower();
if (await _repo.ValidateEquipmentName(equipmentDto.EqName, equipmentDto.UserId))
{
return(BadRequest("Taka nazwa ekwipunku już istnieje"));
}
var eqToCreate = new Equipments
{
EqName = equipmentDto.EqName,
UserId = equipmentDto.UserId,
HeroId = equipmentDto.HeroId,
FirtItemId = equipmentDto.FirtItemId,
SecondItemId = equipmentDto.SecondItemId,
ThirdItemId = equipmentDto.ThirdItemId,
FourthItemId = equipmentDto.FourthItemId,
FifthItemId = equipmentDto.FifthItemId,
SixthItemId = equipmentDto.SixthItemId,
GameId = equipmentDto.GameId
};
var createdEquipment = await _repo.AddEquipment(eqToCreate, equipmentDto.HeroLvl);
return(StatusCode(201));
}
public ActionResult Edit(EquipmentDto equipmentDto, HttpPostedFileBase ImageEquip)
{
if (ModelState.IsValid)
{
if (ImageEquip != null && ImageEquip.ContentLength > 0)
{
equipmentDto.Image = new byte[ImageEquip.ContentLength]; // ImageEquip to store image in binary formate
ImageEquip.InputStream.Read(equipmentDto.Image, 0, ImageEquip.ContentLength);
}
/* Other Method : Insert image into folder and insert image path into database and display image in
* view from image folder based on path given(stored) in database. */
//if (ImageEquip == null)
//{
// string ImageName = System.IO.Path.GetFileName(ImageEquip.FileName); //file2 to store path and url
// string physicalPath = Server.MapPath("~/img/" + ImageName);
// // save image in folder
// ImageEquip.SaveAs(physicalPath);
// equip.PathPhoto = "img/" + ImageName;
//}
var updated = equipmentService.Update(equipmentDto);
return(RedirectToAction("Index"));
}
return(View(equipmentDto));
}
public async Task <IActionResult> PutEquipment(int id, EquipmentDto entry)
{
if (id != entry.Id)
{
return(BadRequest("Payload does not match identifier"));
}
var dbEntry = _mapper.Map <Equipment>(entry);
_context.Entry(dbEntry).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EquipmentExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(Ok());
}
public List <SearchResultDTO> GetSearchResult()
{
IEnumerable <EquipmentDto> searchResult = new EquipmentServerController().GetEquipmentByRoomId(schedulingDto.SourceRoomId);
List <SearchResultDTO> retVal = new List <SearchResultDTO>();
IMapObjectController mapObjectController = new MapObjectController();
IEquipmentServerController equipmentServerController = new EquipmentServerController();
for (int i = 0; i < searchResult.Count(); i++)
{
EquipmentDto equipmentDto = searchResult.ElementAt(i);
MapObject mo = mapObjectController.GetMapObjectById(equipmentDto.RoomId);
string amount = "0";
string timeInterval = schedulingDto.TimeInterval.Start.ToString() + "-" + schedulingDto.TimeInterval.End.ToString();
EquipmentSeparationDto equipmentSeparationDto = new EquipmentSeparationDto()
{
SourceRoomId = schedulingDto.SourceRoomId,
SourceQuantity = equipmentDto.Quantity,
DestinationRoomId = schedulingDto.DestinationRoomId,
DestinationQuantity = 0,
Name = equipmentDto.Name
};
EquipmentSeparationSearchResultDTO searchResultDTO = new EquipmentSeparationSearchResultDTO()
{
Content = equipmentDto.Name + AllConstants.ContentSeparator
+ equipmentDto.Quantity + AllConstants.ContentSeparator
+ equipmentDto.Name + AllConstants.ContentSeparator
+ amount,
EquipmentSeparationDto = equipmentSeparationDto
};
retVal.Add(searchResultDTO);
}
return(retVal);
}
[HttpPost("updateEquipment")] //, ActionName("addEquipment")]
public async Task <IActionResult> UpdateEquipment([FromBody] EquipmentDto equipmentDto)
{
//nieuwzglenianie case sensitivity
equipmentDto.EqName = equipmentDto.EqName.ToLower();
if (await _repo.ValidateEquipmentNameForUpdate(equipmentDto.EqName, equipmentDto.UserId, equipmentDto.EquipmentId))
{
return(BadRequest("Inny z Twoich ekwipunków posiada już taką nazwę"));
}
var eqToCreate = new Equipments
{
EqName = equipmentDto.EqName,
UserId = equipmentDto.UserId,
HeroId = equipmentDto.HeroId,
FirtItemId = equipmentDto.FirtItemId,
SecondItemId = equipmentDto.SecondItemId,
ThirdItemId = equipmentDto.ThirdItemId,
FourthItemId = equipmentDto.FourthItemId,
FifthItemId = equipmentDto.FifthItemId,
SixthItemId = equipmentDto.SixthItemId
};
var createdEquipment = await _repo.UpdateEquipment(eqToCreate, equipmentDto.HeroLvl, equipmentDto.EquipmentId);
return(StatusCode(201));
}
public async Task <IActionResult> Edit(int id, [Bind("EquipmentId,EquipmentName,EquipmentType,DaysOfHire,ProcessingMessage")] EquipmentDto equipment)
{
if (id != equipment.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(equipment);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EquipmentExists(equipment.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(equipment));
}
public async Task <EquipmentDto> CreateAsync(EquipmentDto equipment)
{
var result = _mapper.Map <Equipment>(equipment);
result = await _repository.CreateAsync(result);
return(_mapper.Map <EquipmentDto>(result));
}
public async Task <EquipmentDto> Update(EquipmentDto input)
{
var entity = input.MapTo <Equipment>();
entity = await _repository.UpdateAsync(entity);
return(entity.MapTo <EquipmentDto>());
}
public async Task <ActionResult <Equipment> > PostEquipment(EquipmentDto entry)
{
var dbEntry = _mapper.Map <Equipment>(entry);
_context.Equipments.Add(dbEntry);
await _context.SaveChangesAsync();
return(CreatedAtAction("Post", new { id = entry.Id }, entry));
}
public ActionResult Edit(EquipmentDto eqDto)
{
if (ModelState.IsValid)
{
_equipmentService.Edit(eqDto);
return(RedirectToAction("getAllRoom", "Room"));
}
return(View(eqDto));
}
public int Add(EquipmentDto dto)
{
var model = Mapper.Map <EquipmentDto, Equipment>(dto);
model.Room = _unitOfWork.RoomRepository.FindById(dto.Room_id);
_unitOfWork.EquipmentRepository.Add(model);
_unitOfWork.SaveChanges();
return(model.Id);
}
public async Task UpdateAsync(EquipmentDto equipment)
{
var result = _mapper.Map <Equipment>(equipment);
var find = await _repository.FindByIDAsync(result.Id);
if (result != null)
{
await _repository.UpdateAsync(find, result);
}
}
public async Task <IActionResult> Put(EquipmentDto equipment)
{
if (equipment == null)
{
return(null);
}
await _entityService.UpdateAsync(equipment);
return(this.StatusCode(StatusCodes.Status200OK));
}
public async Task <Guid> CreateEquipment(EquipmentDto eq)
{
using (var uow = UnitOfWorkProvider.Create())
{
eq.Id = _equipmentService.Create(eq);
await uow.Commit();
return(eq.Id);
}
}
public ActionResult AddEquipment(EquipmentDto dto, int rid)
{
dto.Room_id = rid;
int i = _equipmentService.Add(dto);
ViewBag.Rid = rid;
return(RedirectToAction("AddEquipment", new { rid = rid }));
}
public async Task <IActionResult> Create([Bind("EquipmentId,EquipmentName,EquipmentType,DaysOfHire,ProcessingMessage")] EquipmentDto equipment)
{
if (ModelState.IsValid)
{
_context.Add(equipment);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(equipment));
}
public IActionResult GetAllEquipments()
{
var equip = _service.GetAllEquipments();
List <EquipmentDto> Dto = new List <EquipmentDto>();
foreach (var item in equip)
{
EquipmentDto Dtos = _mapper.Map <EquipmentDto>(item);
Dto.Add(Dtos);
}
return(Ok(Dto));
}
public void CreateEquipment_ModelIsValid_ReturnCreated()
{
var equipmentDto = new EquipmentDto();
var equipment = Mapper.Map <EquipmentDto, Equipment>(equipmentDto);
unitOfWork.Setup(uow => uow.Equipment.Add(equipment));
unitOfWork.Setup(uow => uow.Complete());
var result = controller.CreateEquipment(equipmentDto);
Assert.That(result, Is.InstanceOf(typeof(CreatedNegotiatedContentResult <EquipmentDto>)));
}
public void MapToEquipmentExportDtoCorrectly()
{
var expect = new EquipmentDto
{
EquipmentId = 10,
EquipmentName = "equipment",
};
var mapper = CreateMapper();
var actual = mapper.Map <EquipmentExportDto>(expect);
Assert.Equal(expect.EquipmentId.ToString(), actual.EquipmentId);
Assert.Equal(expect.EquipmentName, actual.EquipmentName);
}
public void Execute(EquipmentDto request)
{
var equipment = new Equipment();
if (Context.Equipment.Any(e => e.Name.ToLower() == request.Name.ToLower()))
{
throw new EntityAlreadyExistsException("Equipment");
}
equipment.Name = request.Name;
Context.Equipment.Add(equipment);
Context.SaveChanges();
}
public int Update(EquipmentDto equipmentDto)
{
var equipment = new Equipment()
{
Id = equipmentDto.Id,
SerialNumber = equipmentDto.SerialNumber,
Name = equipmentDto.Name,
NextControlDate = equipmentDto.NextControlDate,
Image = equipmentDto.Image
};
int rows = _equipmentRepository.SaveChanges();
return(rows);
}
public IActionResult UpdateEquipment(int id, [FromBody] EquipmentDto equipDto)
{
var equipment = _mapper.Map <Equipment>(equipDto);
try
{
_service.Update(equipment, id);
return(Ok());
}
catch (AppException ex)
{
return(BadRequest(new { message = ex.Message }));
}
}
public bool Edit(EquipmentDto dto)
{
Equipment n = _unitOfWork.EquipmentRepository.FindById(dto.Id);
n.Id = dto.Id;
n.Name = dto.Name;
n.Description = dto.Description;
n.Stauts = dto.Stauts;
n.needfix = dto.needfix;
n.ishere = dto.ishere;
_unitOfWork.SaveChanges();
return(true);
}
public EquipmentDto GetById(int id)
{
var equipment = _equipmentRepository.GetById(id);
var equipmentDto = new EquipmentDto()
{
Id = equipment.Id,
SerialNumber = equipment.SerialNumber,
Name = equipment.Name,
NextControlDate = equipment.NextControlDate,
Image = equipment.Image
};
return(equipmentDto);
}
public int Insert(EquipmentDto equipmentDto)
{
var equipment = new Equipment()
{
Id = equipmentDto.Id,
SerialNumber = equipmentDto.SerialNumber,
Name = equipmentDto.Name,
NextControlDate = equipmentDto.NextControlDate,
Image = equipmentDto.Image
};
_equipmentRepository.Insert(equipment);
_equipmentRepository.SaveChanges();
return(equipment.Id);
}
public async Task <EquipmentDto> Create(EquipmentDto input)
{
var entity = input.MapTo <Equipment>();
var count = await _repository.CountAsync(p => p.FNumber == input.FNumber);
if (count > 0)
{
throw new UserFriendlyException($"设备代码{input.FNumber}重复");
}
entity = await _repository.InsertAsync(entity);
return(entity.MapTo <EquipmentDto>());
}
/// <summary>
/// Equipment Upd
/// </summary>
public async Task <EquipmentDto> EquipmentUpd(EquipmentDto dtoItem, string userGuid, string serviceGroupGuid)
{
var item = new EquipmentEntity
{
equipment_guid = dtoItem.equipment_guid,
equipment_type_guid = dtoItem.equipment_type_guid,
equipment_info = JsonDataExtensions.EntityToJsonData(dtoItem)
};
var equipment = await EquipmentInfo.EquipmentUpd(item, userGuid, serviceGroupGuid);
var result = JsonDataExtensions.JsonToEntityData <EquipmentDto>(equipment.equipment_info);
return(result);
}
public IHttpActionResult CreateEquipment(EquipmentDto equipmentDto)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var equipment = Mapper.Map <EquipmentDto, Equipment>(equipmentDto);
_context.Equipments.Add(equipment);
_context.SaveChanges();
equipmentDto.Id = equipment.Id;
return(Created(new Uri(Request.RequestUri + "/" + equipment.Id), equipmentDto));
}
private EquipmentDto TestEquipment_TiVo()
{
var equipmentDto = new EquipmentDto
{
AssociatedSubscriberId = "associatedsubid",
BlockedServiceList = new List<ServiceDto>(),
CPE = true,
CustomFields = new List<CustomFieldDto>(),
HeadendCode = "04",
LocationId = "locationid",
SerialNumber = "tivoserialnumber",
Status = "LOST",
Type = new EquipmentTypeDto
{
Category = EquipmentCategoryDto.TiVo,
Model = "TiVo Gateway",
WirelessCapable = true
},
UnitAddress = "",
VCI = "1234",
VPI = "1234",
};
return equipmentDto;
}
public void RemoveResidentialGateway_ValidateSuccessScenario()
{
using (ShimsContext.Create())
{
//Arrange
var myContext = new SIMPLTestContext();
//Build FakeDto
var fakeUserDto = myContext.GetFakeUserDtoObject();
//Fake call to CurrentUser.AsUserDto()
ShimCurrentUser.AsUserDto = () => fakeUserDto;
// Fake the HttpContext
var context = new ShimHttpContext();
ShimHttpContext.CurrentGet = () => context;
// Fake the session state for HttpContext
var session = new ShimHttpSessionState
{
ItemGetString = s =>
{
if (s == "")
return null;
return null;
}
};
// When the Fake HttpContext is called, provide the fake session state
ShimHttpContext.AllInstances.SessionGet = (o) => session;
var fakeServiceAccount = myContext.GetFakeServiceAccountDto();
var listFakeServiceAccounts = new List<ServiceAccountDto>
{
fakeServiceAccount
};
//Expected result
const string expectedBaseModelValue = "A5550";
const string expectedSerialNumber = "PACE99999991";
const string expectedLocationId = "locId";
ShimCurrentSubscriber.AllInstances.PhoneServicesListGet = (o) => listFakeServiceAccounts;
ShimCurrentSubscriber.AllInstances.ServiceAccountListGet = (myTest) => listFakeServiceAccounts;
ShimCurrentSubscriber.AllInstances.CurrentServiceAccountGet = (myTest) => fakeServiceAccount;
ShimCurrentSubscriber.AllInstances.SubIdGet = (o) => "89451";
ShimCurrentSubscriber.AllInstances.LocationIdGet = (o) => expectedLocationId;
// set WanIpAddress
ShimCurrentSubscriber.AllInstances.WanIpAddressGet = o => "12:12:12:12";
ShimRosettianClient.AllInstances.LoadSubscriberStringUserDto = (client, subId, userDto) => new SubscriberDto();
ShimCurrentSubscriber.UpdateWanIpAddressString = (myWanIpAddress) => { };
var RgType = new EquipmentTypeDto
{
ONTModel = new ONTModelDto
{
BaseModel = expectedBaseModelValue
},
Category = EquipmentCategoryDto.RGDataPort
};
var equipmentDataDto = new EquipmentDto
{
SerialNumber = expectedSerialNumber + "D01",
LocationId = expectedLocationId,
Type = RgType,
Status = "ACTIVE"
};
var equipmentPhoneDto01 = new EquipmentDto
{
SerialNumber = expectedSerialNumber + "P01",
LocationId = expectedLocationId,
Type = RgType,
Status = "ACTIVE"
};
var equipmentPhoneDto02 = new EquipmentDto
{
SerialNumber = expectedSerialNumber + "P02",
LocationId = expectedLocationId,
Type = RgType,
Status = "ACTIVE"
};
var searchEquipmentsResult = new List<EquipmentDto>();
searchEquipmentsResult.Add(equipmentDataDto);
searchEquipmentsResult.Add(equipmentPhoneDto01);
searchEquipmentsResult.Add(equipmentPhoneDto02);
ShimRosettianClient.AllInstances.SearchEquipmentSearchFieldsDtoUserDto =
(myTestClient, mySearchFields, myUserDto) => searchEquipmentsResult;
ShimRosettianClient.AllInstances.ReturnToHeadendListOfStringUserDto = (myTestClient, mySerialNumberList, myUserDto) => true;
var compositeEquipment = new CompositeEquipment
{
ErrorDetails = new ErrorDetails()
{
Code = ResidentialGatewayErrorCode.GatewayNotFound.ToString(),
Message = @"Active RG not Found on Account. Provide the RG serial number and click the button below to associate."
}
};
ShimBusinessFacade.AllInstances.LoadCompositeEquipmentSearchFieldsDtoUserDto =
(myFacade, mySearchFields, arg3) => compositeEquipment;
// First Act
var residentialController = DependencyResolver.Current.GetService<ResidentialGatewayController>();
var result = residentialController.RemoveResidentialGateway("deviceID");
// First Assert
Assert.IsNotNull(result, "Returned Json result with rendered partial view is null.");
Assert.IsTrue(result is JsonResult, "result is not a JsonResult");
// Second Act
var resultJson = result as JsonResult;
// Second Assert
Assert.IsNotNull(resultJson, "Returned Json result is null.");
dynamic resultData = resultJson.Data;
var status = resultData.status as string;
var errorMessage = string.Empty;
if (status == "error")
{
errorMessage = resultData.errorMessage;
}
Assert.AreEqual("valid", status, "RemoveResidentialGateway_HappyPath() - unexpected status from RemoveResidentialGateway() - {0}", errorMessage);
var renderedPartial = resultData.returnedPartial as string;
Assert.IsNotNull(renderedPartial, "Prerendered partial is null.");
}
}
public void SwapIpVideoDevice_SwapOutVAPForAnotherVAP()
{
using (ShimsContext.Create())
{
//Arrange
const string selectedRoomConst = "testroom";
var myContext = new SIMPLTestContext();
var fakeUserDto = myContext.GetFakeUserDtoObject();
ShimCurrentUser.AsUserDto = () => fakeUserDto;
ShimCurrentUser.AllInstances.RolesGet = x =>
{
return new List<int>();
};
var context = new ShimHttpContext();
ShimHttpContext.CurrentGet = () => context;
ShimResidentialGatewayController.AllInstances.ValidateDeviceEquipmentDto = (controller, dto) =>
{
return new RozResponseDto { Code = "200", Message = String.Empty };
};
var session = new ShimHttpSessionState
{
ItemGetString = s =>
{
if (s == "")
return null;
return null;
}
};
ShimHttpContext.AllInstances.SessionGet = o => session;
// VAP device to test
EquipmentDto VAPDevice1 = new EquipmentDto();
VAPDevice1.Type.Category = EquipmentCategoryDto.VideoAccessPoint;
CustomFieldDto cf = new CustomFieldDto();
cf.Label = "ROOM_LOCATION";
VAPDevice1.CustomFields.Add(cf);
// Another VAP device to test
EquipmentDto VAPDevice2 = new EquipmentDto();
VAPDevice2.Type.Category = EquipmentCategoryDto.VideoAccessPoint;
VAPDevice2.CustomFields.Add(cf);
// Shim Equipment Search
ShimRosettianClient.AllInstances.SearchEquipmentSearchFieldsDtoUserDto = (client, dto, arg3) =>
{
List<EquipmentDto> lst = new List<EquipmentDto>();
lst.Add(VAPDevice1);
lst.Add(VAPDevice2);
return lst;
};
ShimRosettianClient.AllInstances.ReturnToHeadendListOfStringUserDto = (client, list, arg3) =>
{
return true;
};
// current location
const string currentLocationId = "LOCIDWITHANYVALUE";
// set location Id
ShimCurrentSubscriber.AllInstances.LocationIdGet = o => currentLocationId;
// get service for ResidentialGatewayController
var residentialController = DependencyResolver.Current.GetService<ResidentialGatewayController>();
// Test for s
string selectedRoomValue = "testroom";
ShimRosettianClient.AllInstances.UpdateEquipmentEquipmentDtoUserDto = (client, dto, arg3) =>
{
return true;
};
ShimRosettianClient.AllInstances.PerformEquipmentOperationListOfEquipmentOperationDtoUserDto = (client, dtos, arg3) =>
{
return true;
};
// Try to replace VAP device with another VAP device
string result =
residentialController.SwapIpVideoDevices(VAPDevice1, VAPDevice2, selectedRoomValue).ToJSON();
XmlDictionaryReader jsonReader = JsonReaderWriterFactory.CreateJsonReader(
Encoding.UTF8.GetBytes(result), new XmlDictionaryReaderQuotas());
XElement root = XElement.Load(jsonReader);
int code = Convert.ToInt32(root.XPathSelectElement(@"//code").Value);
string status = root.XPathSelectElement(@"//status").Value.ToString();
string selectedRoomReturned = root.XPathSelectElement(@"//sRoom").Value.ToString();
string errorString = root.XPathSelectElement(@"//errorMessage").Value.ToString();
if ((code == 200 || code == 202) && status == "valid")
{
Assert.IsTrue(true);
}
else if ((code == 200 || code == 202) && status == "error")
{
Assert.Inconclusive("Device untestable as validation failed.");
}
else if (code == 400 && errorString.Contains("Error swapping old video device"))
{
Assert.Inconclusive("Device untestable because endpoint failed.");
}
else
{
Assert.Fail("Swap of two VAP devices failed.");
}
Assert.AreEqual(selectedRoomConst, selectedRoomReturned, "Selected room changed.");
}
}
public void SwapIpVideoDevice_SwapOutVAPForNonVAP()
{
using (ShimsContext.Create())
{
//Arrange
const string selectedRoomConst = "testroom";
var myContext = new SIMPLTestContext();
var fakeUserDto = myContext.GetFakeUserDtoObject();
ShimCurrentUser.AsUserDto = () => fakeUserDto;
ShimCurrentUser.AllInstances.RolesGet = x =>
{
return new List<int>();
};
var context = new ShimHttpContext();
ShimHttpContext.CurrentGet = () => context;
ShimResidentialGatewayController.AllInstances.ValidateDeviceEquipmentDto = (controller, dto) =>
{
return new RozResponseDto { Code = "200", Message = String.Empty };
};
var session = new ShimHttpSessionState
{
ItemGetString = s =>
{
if (s == "")
return null;
return null;
}
};
ShimHttpContext.AllInstances.SessionGet = o => session;
// VAP device to test
EquipmentDto VAPDevice = new EquipmentDto();
VAPDevice.Type.Category = EquipmentCategoryDto.VideoAccessPoint;
// Non-VAP device to test
EquipmentDto NonVAPDevice = new EquipmentDto();
NonVAPDevice.Type.Category = EquipmentCategoryDto.DVR;
// current location
const string currentLocationId = "LOCIDWITHANYVALUE";
// set location Id
ShimCurrentSubscriber.AllInstances.LocationIdGet = o => currentLocationId;
// get service for ResidentialGatewayController
var residentialController = DependencyResolver.Current.GetService<ResidentialGatewayController>();
// Test room
string selectedRoomValue = "testroom";
// Try to replace VAP device with a Non-VAP device
string result =
residentialController.SwapIpVideoDevices(VAPDevice, NonVAPDevice, selectedRoomValue).ToJSON();
XmlDictionaryReader jsonReader = JsonReaderWriterFactory.CreateJsonReader(
Encoding.UTF8.GetBytes(result), new XmlDictionaryReaderQuotas());
XElement root = XElement.Load(jsonReader);
int code = Convert.ToInt32(root.XPathSelectElement(@"//code").Value);
string status = root.XPathSelectElement(@"//status").Value.ToString();
string selectedRoomReturned = root.XPathSelectElement(@"//sRoom").Value.ToString();
string errorString = root.XPathSelectElement(@"//errorMessage").Value.ToString();
if (code != 400 && code != 200 && code != 202)
{
Assert.Inconclusive("Unknown Error.");
}
if ((code == 200 || code == 202) && status == "error")
{
Assert.Inconclusive("Device untestable as validation failed.");
}
if (code == 400 && status == "error" && errorString == "Cannot swap out a VAP device for a non-VAP device.")
{
Assert.IsTrue(true);
}
Assert.AreEqual(selectedRoomConst, selectedRoomReturned, "Selected room changed.");
}
}
private EquipmentDto TestEquipment_SetTopBox()
{
var equipmentDto = new EquipmentDto
{
AssociatedSubscriberId = "associatedsubid",
BlockedServiceList = new List<ServiceDto>(),
CPE = true,
CustomFields = new List<CustomFieldDto>(),
HeadendCode = "04",
LocationId = "locationid",
SerialNumber = "stbserialnumber",
Status = "LOST",
Type = new EquipmentTypeDto
{
Category = EquipmentCategoryDto.SetTopBox,
Model = "QIP2708"
},
UnitAddress = "unitaddress",
VCI = "1234",
VPI = "1234"
};
return equipmentDto;
}
public void Index_User_Is_Shown_Index2_View_With_A_Single_ONT_And_A_Single_RG()
{
using (ShimsContext.Create())
{
// Arrange
ShimRosettianClient.AllInstances.LoadLocationStringUserDto = delegate { return new LocationDto(); };
ShimRosettianClient.AllInstances.GetServicesUserDto = delegate { return new ServiceCollectionDto(); };
const string subscriberID = "999999999999";
const string subscriberContactPhone = "9999999999";
const string firstName = "Test";
const string lastName = "Account";
const string deviceID = "11111111";
var myContext = new SIMPLTestContext();
// Build Fake UserDto
var fakeUserDto = myContext.GetFakeUserDtoObject();
// Fake call to CurrentUser.AsUserDto()
ShimCurrentUser.AsUserDto = () => fakeUserDto;
ShimCurrentUser.GetInstance = () => new ShimCurrentUser
{
UniqueIdGet = () => "abc123",
};
ShimCurrentUser.AllInstances.RolesGet = delegate { return new List<int> { 1 }; };
// Shim Permissions.UserHasGrant
ShimPermissions.UserHasGrantGrant = delegate { return true; };
// Shim feature flag
ShimFeatureFlags.IsEnabledString = delegate { return true; };
// Build Fake AccountDto
var fakeAccountDto = myContext.GetFakeAccountDtoObject();
// Build Fake CustomFieldDto
var fakeCustomFieldDto = myContext.GetFakeCustomFieldDto();
// Build Fake SubscriberDto
var fakeSubscriberDto = myContext.GetFakeSubscriberDto(subscriberID, firstName, lastName, subscriberContactPhone, fakeCustomFieldDto, fakeAccountDto);
// Build Fake PhoneNumberAsIdDto (internally builds the Fake TelephoneNumberDto)
var fakePhoneNumberAsIdDto = myContext.GetFakePhoneNumberAsIdDto(subscriberContactPhone);
// Build Fake BillingAccountIdDto
var fakeBillingAccountIdDto = myContext.GetFakeBillingAccountIdDto(subscriberID, fakePhoneNumberAsIdDto);
// Build Fake CustomerAccountIdDto
var fakeCustomerAccountIdDto = myContext.GetFakeCustomerAccountIdDto(subscriberID, fakePhoneNumberAsIdDto);
// Build Fake CustomerAccountDto (internaly builds the Fake IndividualNameDto,
// the Fake IndividualDto, and the Fake CustomerDto)
var fakeCustomerAccountDto = myContext.GetFakeCustomerAccountDto(firstName, lastName, subscriberID, fakeBillingAccountIdDto, fakeCustomerAccountIdDto);
// A single ONT
var fakeEquipmentTypeDtoONT = new EquipmentTypeDto
{
ONTModel = new ONTModelDto(),
Category = EquipmentCategoryDto.ONTDataPort
};
var myEquipmentDto1 = new EquipmentDto()
{
Type = fakeEquipmentTypeDtoONT
};
// A single ONT
var fakeEquipmentTypeDtoRG = new EquipmentTypeDto
{
ONTModel = new ONTModelDto(),
Category = EquipmentCategoryDto.RGDataPort
};
var myEquipmentDto2 = new EquipmentDto()
{
Type = fakeEquipmentTypeDtoRG
};
// A single Video Device
var fakeEquipmentTypeDtoVideoDevice = new EquipmentTypeDto
{
ONTModel = null
};
var myEquipmentDto3 = new EquipmentDto()
{
Type = fakeEquipmentTypeDtoVideoDevice
};
fakeSubscriberDto.Accounts[0].Equipment = new EquipmentCollectionDto();
fakeSubscriberDto.Accounts[0].Equipment.Add(myEquipmentDto1);
fakeSubscriberDto.Accounts[0].Equipment.Add(myEquipmentDto2);
fakeSubscriberDto.Accounts[0].Equipment.Add(myEquipmentDto3);
// Build Fake CompositeSubscriber
var fakeCompositeSubscriber = new CompositeSubscriber()
{
SubscriberTriad = fakeSubscriberDto,
SubscriberDpi = fakeCustomerAccountDto
};
// Fake the BusinessFacade.LoadCompositeSubscriber call
ShimBusinessFacade.AllInstances.LoadCompositeSubscriberStringStringUserDto =
delegate { return fakeCompositeSubscriber; };
// Build Fake fakeEquipmentDto
var fakeEquipmentDto = new List<EquipmentDto>();
fakeEquipmentDto.Add(myEquipmentDto1);
fakeEquipmentDto.Add(myEquipmentDto2);
fakeEquipmentDto.Add(myEquipmentDto3);
// Fake the RosettianClient.SearchEquipment call
ShimRosettianClient.AllInstances.SearchEquipmentSearchFieldsDtoUserDto =
(myRosettianClient, mySubscriberID, myUserObject) => fakeEquipmentDto;
// A single ONT
var fakeONT = new ONT
{
Type = fakeEquipmentTypeDtoONT
};
// A single RG
var fakeRG = new ONT
{
Type = fakeEquipmentTypeDtoRG
};
var fakeONTAndRGList = new List<ONT>();
fakeONTAndRGList.Add(fakeONT);
fakeONTAndRGList.Add(fakeRG);
var fakeONTList = new List<ONT>();
fakeONTList.Add(fakeONT);
var fakeRGList = new List<ONT>();
fakeRGList.Add(fakeRG);
// Fake the EquipmentExtension.ToONTList call
SIMPL.Areas.Common.Extensions.Fakes.ShimEquipmentExtension.ToONTListIEnumerableOfEquipmentDto =
(myEquipmentList) =>
{
if (myEquipmentList != null)
{
var items = myEquipmentList.ToList();
if (items.Any())
{
if (items.Count == 2)
{
return fakeONTAndRGList;
}
if (items[0].Type.Category == EquipmentCategoryDto.ONTDataPort)
{
return fakeONTList;
}
if (items[0].Type.Category == EquipmentCategoryDto.RGDataPort)
{
return fakeRGList;
}
}
}
return new List<ONT>();
};
// A single Video Device
var fakeVideoDevice = new SerializableVideoDevice();
var fakeVideoDeviceList = new List<SerializableVideoDevice>();
fakeVideoDeviceList.Add(fakeVideoDevice);
// Fake the EquipmentExtension.ToVideoDeviceList call
ShimEquipmentExtension.ToVideoDeviceListIEnumerableOfEquipmentDto =
(myVideoDeviceList) => fakeVideoDeviceList;
var currentSubscriber = new ShimCurrentSubscriber
{
SubIdGet = () => "SubId",
ProvisionedServicesListGet = () => new List<ServiceDto>()
};
ShimCurrentSubscriber.GetInstance = () => currentSubscriber;
// Fake the CurrentSubscriber.SetInstance call
ShimCurrentSubscriber.SetInstanceCompositeSubscriberSubscriberModel = (myCompositeSubscriber, mySubscriberModel) => { };
// Fake the CurrentSubscriber.DataProductType call
ShimCurrentSubscriber.AllInstances.DataProductTypeGet = (myResult) => SubscriberEnums.DataProductType.Ftth;
// Fake the CurrentSubscriber.VideoProductType call
ShimCurrentSubscriber.AllInstances.VideoProductTypeGet = (myResult) => SubscriberEnums.VideoProductType.FiberRf;
// Fake the CurrentSubscriber.DataProductType call
ShimCurrentSubscriber.AllInstances.VoiceProductTypeGet = (myResult) => SubscriberEnums.VoiceProductType.FiberPots;
// Fake the CurrentSubscriber.DataProductType call
ShimCurrentSubscriber.AllInstances.StateGet = (myResult) => "CT";
ShimCurrentUser.RetrieveUserRolesString = (myUniqueId) => new List<int>() { 1 };
//Fake DB call to get Headends
var headends = new List<HeadEnd>()
{
new HeadEnd()
{
EntityKey = new EntityKey(),
headend_code = "1",
headend_loc = "1",
headend_name = "1",
headend_nbr = 1,
location_id = "1",
location_nbr = 1
}
};
ShimDBCache.HeadEndCodesGet = delegate { return headends; };
//Fake Line Results DB Call.
var testResultsDbSet = new ShimDbSet<test_results>();
testResultsDbSet.Bind(new List<test_results>().AsQueryable());
ShimLineTestEntities.AllInstances.test_resultsGet = delegate { return testResultsDbSet; };
// 1st Act
var result = SubscriberControllerForTests.Index(subscriberID, deviceID) as ViewResult;
// 1st set of Asserts
Assert.IsNotNull(result, "SubscriberController Index method returned null");
Assert.IsNotNull(result.ViewName, "result.ViewName method is null");
const string expectedViewName = "Index2";
Assert.IsTrue(expectedViewName == result.ViewName, "Expected: " + expectedViewName + ", Actual: " + result.ViewName);
Assert.IsTrue(result.ViewName.Equals(expectedViewName));
Assert.IsTrue(result.Model is SubscriberModel, "Not SubscriberModel");
// 2nd Act
var testSubscriberModel = result.Model as SubscriberModel;
// 2nd set of Asserts
var successCode = "200";
Assert.AreEqual(successCode, testSubscriberModel.ActionResponse.Code, "Test threw an exception {0}{0}{1}", Environment.NewLine, testSubscriberModel.ActionResponse.Message);
var jss = new JavaScriptSerializer();
var expectedModel = fakeCompositeSubscriber.MapToSubscriberModel();
expectedModel.SubEquipmentModel = new SubscriberEquipmentModel
{
ONTList = fakeONTAndRGList,
ONTOnlyList = fakeONTList,
RGOnlyList = fakeRGList,
VideoDeviceList = fakeVideoDeviceList,
AccessDeviceList = fakeONTAndRGList,
LoadedSubID = subscriberID,
LoadedLocID = expectedModel.SubLocationModel.LocationID,
WanIpAddress = string.Empty,
MaxStb = string.Empty
};
expectedModel.SubLocationModel.LoadedDeviceID = deviceID;
Assert.AreEqual(jss.Serialize(expectedModel.ActionResponse), jss.Serialize(testSubscriberModel.ActionResponse), "SubscriberModel");
Assert.AreEqual(jss.Serialize(expectedModel.SubDetailsModel), jss.Serialize(testSubscriberModel.SubDetailsModel), "SubscriberDetailsModel");
Assert.AreEqual(jss.Serialize(expectedModel.SubLocationModel), jss.Serialize(testSubscriberModel.SubLocationModel), "SubscriberLocationModel");
// Since deviceID is not null, check to verify that LoadedDeviceID has the expected value
Assert.AreEqual(deviceID, expectedModel.SubLocationModel.LoadedDeviceID, "LoadedDeviceID should not be string.Empty is deviceID is {0}", deviceID);
Assert.AreEqual(jss.Serialize(expectedModel.SubServicesModel), jss.Serialize(testSubscriberModel.SubServicesModel), "SubscriberServicesModel");
Assert.AreEqual(jss.Serialize(expectedModel.SubEquipmentModel.ONTList), jss.Serialize(testSubscriberModel.SubEquipmentModel.ONTList), "SubscriberEquipmentModel ONTList");
Assert.AreEqual(jss.Serialize(expectedModel.SubEquipmentModel.ONTOnlyList), jss.Serialize(testSubscriberModel.SubEquipmentModel.ONTOnlyList), "SubscriberEquipmentModel ONTOnlyList");
Assert.AreEqual(jss.Serialize(expectedModel.SubEquipmentModel.RGOnlyList), jss.Serialize(testSubscriberModel.SubEquipmentModel.RGOnlyList), "SubscriberEquipmentModel RGOnlyList");
Assert.AreEqual(jss.Serialize(expectedModel.SubEquipmentModel.VideoDeviceList), jss.Serialize(testSubscriberModel.SubEquipmentModel.VideoDeviceList), "SubscriberEquipmentModel VideoDeviceList");
Assert.AreEqual(jss.Serialize(expectedModel.SubEquipmentModel), jss.Serialize(testSubscriberModel.SubEquipmentModel), "SubscriberEquipmentModel entire object");
}
}
public void RefreshDevices_HappyPath()
{
//Setup
var myContext = new SIMPLTestContext();
using (ShimsContext.Create())
{
// Given a user
var fakeUserDto = myContext.GetFakeUserDtoObject();
ShimCurrentUser.AsUserDto = () => fakeUserDto;
ShimCurrentSubscriber.AllInstances.LocationIdGet = (currentSubscriber) => "FakeLocationId";
ShimCurrentSubscriber.AllInstances.MaxStbGet = (currentSubscriber) => "4";
// Fake the HttpContext
var context = new ShimHttpContext();
ShimHttpContext.CurrentGet = () => context;
// Fake the session state for HttpContext
var session = new ShimHttpSessionState
{
ItemGetString = s =>
{
if (s == "")
return null;
return null;
}
};
// When the Fake HttpContext is called, provide the fake session state
ShimHttpContext.AllInstances.SessionGet = (o) => session;
ShimCurrentSubscriber.SessionInstanceGet = () => new ShimCurrentSubscriber();
// A single ONT
EquipmentDto myEquipmentDto1 = new EquipmentDto();
myEquipmentDto1.Status = "ACTIVE";
myEquipmentDto1.Type = new EquipmentTypeDto();
myEquipmentDto1.Type.ONTModel = new ONTModelDto();
myEquipmentDto1.Type.ONTModel.Model = "Model";
myEquipmentDto1.SerialNumber = "SerialNumber1";
// A single Video Device
EquipmentDto myEquipmentDto2 = new EquipmentDto();
myEquipmentDto2.Status = "IGNORE";
myEquipmentDto2.Type = new EquipmentTypeDto();
myEquipmentDto2.Type.ONTModel = null;
myEquipmentDto2.SerialNumber = "SerialNumber2";
var equipments = new List<EquipmentDto>();
equipments.Add(myEquipmentDto1);
equipments.Add(myEquipmentDto2);
// Fake the RosettianClient.SearchEquipment call
ShimRosettianClient.AllInstances.SearchEquipmentSearchFieldsDtoUserDto =
(myRosettianClient, mySubscriberID, myUserObject) => equipments;
// When loading that device
var actionResult = SubscriberControllerForTests.RefreshDevices() as PartialViewResult;
Assert.IsNotNull(actionResult, "ViewResult is null.");
var equipmentModel = actionResult.Model as SubscriberEquipmentModel;
Assert.IsNotNull(equipmentModel, "ViewModel is null.");
Assert.IsNotNull(equipmentModel.ONTList, "ONTList is null");
Assert.IsTrue(equipmentModel.ONTList.Count >= 0);
Assert.IsNotNull(equipmentModel.VideoDeviceList, "VideoDeviceList is null");
Assert.IsTrue(equipmentModel.VideoDeviceList.Count >= 0);
}
}
/// <summary>
/// RestoreEquip - returns EquipmentDto - calls either Rosettian CreateEquipment or UpdateEquipment
/// </summary>
/// <param name="equip"></param>
/// <returns></returns>
protected static EquipmentDto RestoreEquip(EquipmentDto equip)
{
using (var client = new RosettianClient())
{
if (!client.EquipmentExists(equip.SerialNumber, user))
{
client.CreateEquipment(equip, user);
}
else
{
client.UpdateEquipment(equip, user);
}
return equip;
}
}
public void Index_HappyPath()
{
using (ShimsContext.Create())
{
//Arrange
var myContext = new SIMPLTestContext();
//Build FakeDto
var fakeUserDto = myContext.GetFakeUserDtoObject();
//Fake call to CurrentUser.AsUserDto()
ShimCurrentUser.AsUserDto = () => fakeUserDto;
// Fake the HttpContext
var context = new ShimHttpContext();
ShimHttpContext.CurrentGet = () => context;
// SIMPL.Session.Fakes.ShimCurrentSubscriber.SessionInstanceGet = () => new ShimCurrentSubscriber();
// Fake the session state for HttpContext
var session = new ShimHttpSessionState
{
ItemGetString = s =>
{
if (s == "")
return null;
return null;
}
};
// When the Fake HttpContext is called, provide the fake session state
ShimHttpContext.AllInstances.SessionGet = o => session;
//Expected result
const string expectedIpAddressLabel = "WAN_IP_ADDR";
const string expectedIpAddressValue = "10.143.22.1";
const string expectedBaseModelValue = "A5550";
const string expectedSerialNumber = "PACE99999991";
const string expectedUnitAddress = "0D-U9-M6-D2-D7";
const string expectedLocationId = "locId";
const string expectedRoomLocationLabel = "ROOM_LOCATION";
const string expectedRoomLocationValue = "TEST ROOM";
const string expectedMacAddressLable = "ENET_MAC_ADDR";
const string expectedMacAddressValue = "A0B1C2D3E4F5";
var customFieldsDto = new List<CustomFieldDto>();
var expectedIpAddressCustomField = new CustomFieldDto
{
Label = expectedIpAddressLabel,
Value = expectedIpAddressValue,
};
customFieldsDto.Add(expectedIpAddressCustomField);
var expectedRoomLocationCustomField = new CustomFieldDto
{
Label = expectedRoomLocationLabel,
Value = expectedRoomLocationValue
};
customFieldsDto.Add(expectedRoomLocationCustomField);
var expectedMacAddressCustomField = new CustomFieldDto
{
Label = expectedMacAddressLable,
Value = expectedMacAddressValue
};
customFieldsDto.Add(expectedMacAddressCustomField);
var customFieldsCollection = new CustomFieldCollectionDto
{
expectedIpAddressCustomField,
expectedRoomLocationCustomField,
expectedMacAddressCustomField
};
var RgType = new EquipmentTypeDto
{
ONTModel = new ONTModelDto
{
BaseModel = expectedBaseModelValue
},
Category = EquipmentCategoryDto.RGDataPort
};
var IPVideoType = new EquipmentTypeDto
{
ONTModel = new ONTModelDto
{
BaseModel = expectedBaseModelValue
},
Category = EquipmentCategoryDto.DVR,
IptvCapable = true
};
var equipmentDataDto = new EquipmentDto
{
SerialNumber = expectedSerialNumber + "D01",
CustomFields = customFieldsDto,
UnitAddress = expectedUnitAddress,
LocationId = expectedLocationId,
Type = RgType,
Status = "ACTIVE"
};
var equipmentPhoneDto = new EquipmentDto
{
SerialNumber = expectedSerialNumber + "P01",
CustomFields = customFieldsDto,
UnitAddress = expectedUnitAddress,
LocationId = expectedLocationId,
Type = RgType,
Status = "ACTIVE"
};
var ipVideoDevice = new EquipmentDto
{
SerialNumber = expectedSerialNumber + "P01",
CustomFields = customFieldsDto,
UnitAddress = expectedUnitAddress,
LocationId = expectedLocationId,
Type = IPVideoType,
Status = "ACTIVE"
};
var searchEquipmentsResult = new List<EquipmentDto>();
searchEquipmentsResult.Add(equipmentDataDto);
searchEquipmentsResult.Add(equipmentPhoneDto);
searchEquipmentsResult.Add(ipVideoDevice);
var loadSubscriberPhonesResult = new List<PhoneDto>();
// shim CurrentSubscriber WanIpAddress
ShimCurrentSubscriber.GetInstance = () => new ShimCurrentSubscriber
{
WanIpAddressGet = () => expectedIpAddressValue,
ProvisionedPhonesListGet = () => loadSubscriberPhonesResult
};
ShimRosettianClient.AllInstances.SearchEquipmentSearchFieldsDtoUserDto =
(myTestClient, mySearchFields, myUserDto) => searchEquipmentsResult;
equipmentDataDto.CustomFields = customFieldsDto;
ShimRosettianClient.AllInstances.LoadEquipmentStringBooleanUserDto =
(myTestClient, myEquipmentId, returnExtraData, myUserDto) => equipmentDataDto;
ShimRosettianClient.AllInstances.GetCustomFieldsUserDto =
(myTestClient, myUserDto) => customFieldsCollection;
ShimVirtualPathUtility.ToAbsoluteString =
(myTestString) => @"http://testapp/images/DVR.png";
ShimDBCache.LocationsGet = delegate { return new List<Location>(); };
var residentialController = DependencyResolver.Current.GetService<ResidentialGatewayController>();
var result = residentialController.Index("subID", "locID", "devID") as PartialViewResult ?? new PartialViewResult();
Assert.IsNotNull(result, "Partial view result returned is null.");
Assert.IsTrue(result.ViewName.Equals("Index"), "View names do not match.");
Assert.AreEqual(expectedIpAddressValue, ((ResidentialGatewayModel)(result.Model)).IPAddress, "Expected IP does not match with actual IP.");
Assert.AreEqual(expectedUnitAddress, ((ResidentialGatewayModel)(result.Model)).UnitAddress, "Expected UnitAddress does not match with actual Unit Address.");
Assert.AreEqual(expectedMacAddressValue, ((ResidentialGatewayModel)(result.Model)).MacAddress, "Expected MacAddress does not match with actual Mac Address.");
Assert.AreEqual(expectedBaseModelValue, ((ResidentialGatewayModel)(result.Model)).Model, "Expected Model number does not match with actual Model number.");
Assert.AreEqual(expectedSerialNumber, ((ResidentialGatewayModel)(result.Model)).ID, "Expected serial number does not match with actual serial number.");
Assert.IsTrue(((ResidentialGatewayModel)(result.Model)).VideoDevices.Any(), "No video devices found.");
Assert.IsTrue(((ResidentialGatewayModel)(result.Model)).VideoDevices.First().Type.Equals("DVR"), "IP Video device type mismatch.");
Assert.IsTrue(((ResidentialGatewayModel)(result.Model)).VideoDevices.First().RoomLocation.Any(), "No Room locations found.");
}
}
public void EditBlockedServices_SubServicesAreBlockedOnDevice_ValidateUserAbleToLoadEditBlockedServicesCorrectly()
{
using (ShimsContext.Create())
{
// Given a user
ShimCurrentUser.AsUserDto = () => new UserDto();
// And a valid subscriber id
const string subId = "sub12345";
// And the subscriber has a provisioned location
const string locId = "loc12345";
// And the subscriber has a list of services
var services = new ServiceCollectionDto
{
new ServiceDto {ClassName = "DATA - FTTH SPEED", Name = "F10M02M", Description = "10M DOWN 2M UP"},
new ServiceDto {ClassName = "DATA - ONT PORT", Name = "ENET", Description = "RJ-45 ETHERNET PORT"},
new ServiceDto {ClassName = "VOICE", Name = "VOICE", Description = "FTTH VOICE SERVICE"},
new ServiceDto {ClassName = "RF - BASICS", Name = "FIOS", Description = "FIOS VIDEO SERVICE"},
new ServiceDto {ClassName = "RF - PREMIUMS", Name = "FIHBO", Description = "HBO"}
};
// And the subscriber has an equipment which has all above services blocked
var equip = new EquipmentDto
{
SerialNumber = "equip12345",
LocationId = locId,
AssociatedSubscriberId = subId,
BlockedServiceList = services
};
// And the subscriber has a valid account with above location, services, and equipment
var subscriberDto = new SubscriberDto
{
ID = subId,
Accounts = new List<AccountDto>
{
new AccountDto
{
Location = new LocationDto {ID = locId},
Services = services,
Equipment = new EquipmentCollectionDto {equip}
}
}
};
ShimRosettianClient.AllInstances.LoadSubscriberStringUserDto =
(myTestClient, mySubId, myUserDto) => subscriberDto;
ShimServices.ProvisioningServicesGet = () => services;
// And the blocked service list AsCategorizedServiceDictionary
var expectedBlockedServices = equip.BlockedServiceList.AsCategorizedServiceDictionary();
// And the blockedServicesAsJson
var blockedServicesAsJson = ServicesControllerHelper.ConvertServicesToJSON(equip.BlockedServiceList);
// When loading that EditBlockedServices for the subscriber id and device id
var servicesController = DependencyResolver.Current.GetService<ServicesController>();
var result = servicesController.EditBlockedServices(blockedServicesAsJson, subId, equip.SerialNumber, "") as PartialViewResult;
// Then the user receives a response
Assert.IsNotNull(result, "ServiceController EditBlockedServices method returned null");
// And the response is successful
Assert.AreEqual("EditBlockedServices_Partial", result.ViewName, "ViewName does not match");
var actualServicesModel = result.Model as ServicesModel;
Assert.IsNotNull(actualServicesModel, "actualServicesModel");
// And the subscriber matches the requested subscriber
Assert.AreEqual(subId, actualServicesModel.SubscriberID, "SubscriberID does not match");
// And the device matches the requested device
Assert.AreEqual(equip.SerialNumber, actualServicesModel.DeviceID, "DeviceID does not match");
// And the blocked services list matches the requested blocked services list
var jss = new JavaScriptSerializer();
Assert.AreEqual(jss.Serialize(expectedBlockedServices), jss.Serialize(actualServicesModel.BlockedServicesList), "BlockedServiceList does not match");
// And the ServicesAsJSON result matches the blockedServicesAsJson
Assert.AreEqual(blockedServicesAsJson, actualServicesModel.ServicesAsJSON, "ServiceAsJSON does not match");
// And the subscriber services list is empty since all subscriber services are blocked on the device
Assert.AreEqual(0, actualServicesModel.SubscriberServicesList.Count, "SubscriberServiceList is not empty");
}
}
private EquipmentDto TestEquipment_ONTPort()
{
var equipmentDto = new EquipmentDto
{
AssociatedSubscriberId = "associatedsubid",
BlockedServiceList = new List<ServiceDto>(),
CPE = true,
CustomFields = new List<CustomFieldDto>(),
HeadendCode = "04",
LocationId = "locationid",
SerialNumber = "ontserialnumber",
Status = "FIELD RETURN",
Type = new EquipmentTypeDto
{
Category = EquipmentCategoryDto.ONTDataPort,
Model = "ONT612"
},
UnitAddress = "unitaddress",
VCI = "1234",
VPI = "1234"
};
return equipmentDto;
}
private static EquipmentDto RgTestData_IpVideoDevice2(CustomFieldCollectionDto customFieldsDto, string expectedLocationId)
{
var ipVideoType = new EquipmentTypeDto
{
Model = "ISP7005",
Category = EquipmentCategoryDto.DVR,
IptvCapable = true
};
// ip video device
var ipVideoDevice = new EquipmentDto
{
SerialNumber = "STBTEST3457",
CustomFields = customFieldsDto.Where(x => x.Label == "ROOM_LOCATION" || x.Label == "SELECTED_ROOM").ToList(),
UnitAddress = null,
LocationId = expectedLocationId,
Type = ipVideoType,
Status = "ACTIVE"
};
return ipVideoDevice;
}
/// <summary>
/// NewEquipment - creates EquipmentDto based on the values passed in
/// </summary>
/// <param name="category"></param>
/// <param name="manufacturer"></param>
/// <returns></returns>
public static EquipmentDto NewEquipment(EquipmentCategoryDto category, string manufacturer = null)
{
var equipTypes = EquipmentTypes().Where(e => e.Category == category).ToArray();
var statuses = Enum.GetValues(typeof (SIMPLDbEnums.EquipStatusEnum));
var rand = new Random();
var equip = new EquipmentDto();
var sub = NewSubscriberData();
var loc = NewLocationData();
equip.AssociatedSubscriberId = sub.ID;
equip.BlockedServiceList = new ServiceCollectionDto();
equip.CPE = true;
equip.CustomFields = new List<CustomFieldDto>();
equip.HeadendCode = "04";
equip.LocationId = loc.ID;
equip.SerialNumber = GenerateEquipmentSerial(category, manufacturer);
equip.Status = ((SIMPLDbEnums.EquipStatusEnum) statuses.GetValue(rand.Next(statuses.Length))).GetStringValue();
equip.Type = (EquipmentTypeDto) equipTypes.GetValue(rand.Next(equipTypes.Length));
equip.UnitAddress = rand.Next(100000000, 999999999).ToString();
equip.VCI = rand.Next(9999).ToString();
equip.VPI = rand.Next(9999).ToString();
return equip;
}
public void Index_When_Subscriber_Has_CopperFacility_And_Should_Be_Redirected_To_CopperFacility_Page_One_XBox_Multiple_DropTerm_Not_In_The_Correct_Order()
{
using (ShimsContext.Create())
{
const string subscriberID = "999000795553";
const string locationID = "";
const string deviceID = "";
var session = GetShimmedSession();
// Fake the HttpContext
var context = new ShimHttpContext();
ShimHttpContext.CurrentGet = () => context;
var mySIMPLTestContext = new SIMPLTestContext();
var expectedTDMSwitch = mySIMPLTestContext.GetFakeTDMSwitch();
var expectedGWR = mySIMPLTestContext.GetFakeGWRDto();
var expectedDSLAM = mySIMPLTestContext.GetFakeDSLAM();
const int numberOfXConnectItems = 1;
var previousXConnectTerminalNames = new string[]
{
"TerminalAssignmentDtoXbox0{0}_PreviousTerminalNameValue"
};
var currentXConnectTerminalNames = new string[]
{
"TerminalAssignmentDtoXbox0{0}_TerminalNameValue"
};
var expectedXConnectList = mySIMPLTestContext.GetFakeListXConnect(numberOfXConnectItems, previousXConnectTerminalNames, currentXConnectTerminalNames);
const int numberOfDropTermItems = 3;
var previousDropTermTerminalNames = new string[]
{
"TerminalAssignmentDtoXbox01_TerminalNameValue",
"TerminalAssignmentDtoDropTerm01_TerminalNameValue",
"TerminalAssignmentDtoDropTerm02_TerminalNameValue"
};
var currentDropTermTerminalNames = new string[]
{
"TerminalAssignmentDtoDropTerm01_TerminalNameValue",
"TerminalAssignmentDtoDropTerm02_TerminalNameValue",
"TerminalAssignmentDtoDropTerm03_TerminalNameValue",
};
var expectedDropTermList = mySIMPLTestContext.GetFakeListDropTerm(numberOfDropTermItems, previousDropTermTerminalNames, currentDropTermTerminalNames);
var expectedDropTermSequenceList = new List<List<DropTerm>>
{
expectedDropTermList
};
var expectedFacilityAddress = mySIMPLTestContext.GetFakeFacilityAddress();
var localServicePathList = mySIMPLTestContext.GetFakeListServicePath();
var expectedServiceLocation = mySIMPLTestContext.GetFakeServiceLocation(expectedFacilityAddress, localServicePathList, subscriberID);
var expectedMappedData = new CopperFacilityViewModel
{
Environment = "Parent_Environment",
TDMSwitch = expectedTDMSwitch,
GWR = expectedGWR,
DSLAM = expectedDSLAM,
XConnectList = expectedXConnectList,
DropTermSequenceList = expectedDropTermSequenceList,
ServiceLocation = expectedServiceLocation
};
// When the Fake HttpContext is called, provide the fake session state
ShimHttpContext.AllInstances.SessionGet = (o) => session;
// Fake the CurrentSubscriber.SubId call
ShimCurrentSubscriber.AllInstances.SubIdGet = (myProperty) => subscriberID;
// Fake the CurrentSubscriber.SubId call
ShimCurrentSubscriber.AllInstances.LocationIdGet = (myProperty) => locationID;
ShimCurrentSubscriber.AllInstances.DpiRegionGet = delegate { return "CT"; };
var numberOfXBoxItems = numberOfXConnectItems;
var previousXBoxTerminalNames = previousXConnectTerminalNames;
var currentXBoxTerminalNames = currentXConnectTerminalNames;
var fakeListTerminalAssignmentDtoForXBox = mySIMPLTestContext.GetFakeListTerminalAssignmentDtoForXBox(numberOfXBoxItems, previousXBoxTerminalNames, currentXBoxTerminalNames);
var fakeListTerminalAssignmentDto = fakeListTerminalAssignmentDtoForXBox.ToList();
var fakeListTerminalAssignmentDtoForDropTerm = mySIMPLTestContext.GetFakeListTerminalAssignmentDtoForDropTerm(numberOfDropTermItems, previousDropTermTerminalNames, currentDropTermTerminalNames);
// swamp all of the items in the fakeListTerminalAssignmentDtoForDropTerm
var tempDropTermTerminalAssignmentDto = fakeListTerminalAssignmentDtoForDropTerm[0];
fakeListTerminalAssignmentDtoForDropTerm[0] = fakeListTerminalAssignmentDtoForDropTerm[1];
fakeListTerminalAssignmentDtoForDropTerm[1] = fakeListTerminalAssignmentDtoForDropTerm[2];
fakeListTerminalAssignmentDtoForDropTerm[2] = tempDropTermTerminalAssignmentDto;
fakeListTerminalAssignmentDto.AddRange(fakeListTerminalAssignmentDtoForDropTerm);
var fakePairAssignmentDto = mySIMPLTestContext.GetFakePairAssignmentDto(fakeListTerminalAssignmentDto);
var fakeListPairAssignmentDto = new List<PairAssignmentDto>
{
fakePairAssignmentDto
};
var fakeCopperPlantDataDto = mySIMPLTestContext.GetFakeCopperPlantDataDto(fakeListPairAssignmentDto);
var fakePlantDataDto = new PlantDataDto
{
CopperPlantData = fakeCopperPlantDataDto
};
var fakeServiceAddressDto = mySIMPLTestContext.GetFakeServiceAddressDto();
var fakeGetFacilitiesResponseDto = mySIMPLTestContext.GetFakeGetFacilitiesResponseDto(subscriberID, fakeServiceAddressDto, fakePlantDataDto);
ShimEnterpriseClient.AllInstances.GetFacilitiesDataGetFacilitiesRequestDtoHeaderArgs =
delegate { return fakeGetFacilitiesResponseDto; };
ShimCurrentSubscriber.AllInstances.FacilitiesDataGet = (myProperty) => fakeGetFacilitiesResponseDto;
// Fake the FacilityViewModel.ShouldShowFiber call
ShimFacilityViewModel.AllInstances.GetFacilityTypeStringString = delegate { return FacilityType.Copper; };
// A single ONT
EquipmentDto myEquipmentDto1 = new EquipmentDto();
myEquipmentDto1.Type = new EquipmentTypeDto();
myEquipmentDto1.Type.ONTModel = new ONTModelDto();
myEquipmentDto1.SerialNumber = "123456";
// A single Video Device
EquipmentDto myEquipmentDto2 = new EquipmentDto();
myEquipmentDto2.Type = new EquipmentTypeDto();
myEquipmentDto2.Type.ONTModel = null;
myEquipmentDto2.SerialNumber = "123456";
// Build Fake fakeEquipmentDto
var fakeEquipmentDto = new List<EquipmentDto>();
fakeEquipmentDto.Add(myEquipmentDto1);
fakeEquipmentDto.Add(myEquipmentDto2);
var fakeUserDto = new UserDto()
{
Email = "FakeEmail",
Name = "FakeName",
Role = "FakeRole"
};
// Fake the RosettianClient.SearchEquipment call
ShimRosettianClient.AllInstances.SearchEquipmentSearchFieldsDtoUserDto =
(myRosettianClient, mySubscriberID, myUserObject) => fakeEquipmentDto;
//Fake call to CurrentUser.AsUserDto()
ShimCurrentUser.AsUserDto = () => fakeUserDto;
// 1st Act
var result = EquipmentControllerForTests.Index(subscriberID, locationID, deviceID);
// 1st set of Asserts
Assert.IsNotNull(result, "EquipmentController Index returned null");
Assert.IsTrue(result is PartialViewResult, "Not a PartialViewResult");
// 2nd Act
var resultPartialViewResult = (PartialViewResult)result;
// 2nd set of Asserts
Assert.IsNotNull(resultPartialViewResult, "Cast to PartialViewResult is null");
Assert.IsNotNull(resultPartialViewResult.Model, "Model is null");
Assert.IsTrue(resultPartialViewResult.Model is CopperFacilityViewModel, "Model not CopperFacilityViewModel");
// 3rd Act
var resultPartialViewResultModel = (CopperFacilityViewModel)resultPartialViewResult.Model;
// 3rd set of Asserts
var successCode = "200";
Assert.AreEqual(successCode, resultPartialViewResultModel.ActionResponse.Code, "Test threw an exception {0}{0}{1}", Environment.NewLine, resultPartialViewResultModel.ActionResponse.Message);
// 4th Act
var jss = new JavaScriptSerializer();
// 4th set of Asserts
Assert.AreEqual(jss.Serialize(expectedMappedData.DropTermSequenceList), jss.Serialize(resultPartialViewResultModel.DropTermSequenceList), "DropTermSequenceList didn't match");
Assert.AreEqual(jss.Serialize(expectedMappedData.DSLAM), jss.Serialize(resultPartialViewResultModel.DSLAM), "DSLAM didn't match");
Assert.AreEqual(jss.Serialize(expectedMappedData.Environment), jss.Serialize(resultPartialViewResultModel.Environment), "Enviroment didn't match");
Assert.AreEqual(jss.Serialize(expectedMappedData.GWR), jss.Serialize(resultPartialViewResultModel.GWR), "GWR didn't match");
Assert.AreEqual(jss.Serialize(expectedMappedData.PathCount), jss.Serialize(resultPartialViewResultModel.PathCount), "PathCount didn't match");
Assert.AreEqual(jss.Serialize(expectedMappedData.ServiceLocation), jss.Serialize(resultPartialViewResultModel.ServiceLocation), "ServiceLocation didn't match");
Assert.AreEqual(jss.Serialize(expectedMappedData.TDMSwitch), jss.Serialize(resultPartialViewResultModel.TDMSwitch), "TDMSwitch didn't match");
Assert.AreEqual(jss.Serialize(expectedMappedData.XConnectList), jss.Serialize(resultPartialViewResultModel.XConnectList), "XConnectList didn't match");
}
}
public void ActivateResidentialGateway_hasNoMainRg_hasListOtherRgs_hasIpVideoDevice_ValidateSuccessScenario()
{
using (ShimsContext.Create())
{
//Arrange
var myContext = new SIMPLTestContext();
//Build FakeDto
var fakeUserDto = myContext.GetFakeUserDtoObject();
//Fake call to CurrentUser.AsUserDto()
ShimCurrentUser.AsUserDto = () => fakeUserDto;
// Fake the HttpContext
var context = new ShimHttpContext();
ShimHttpContext.CurrentGet = () => context;
// Fake the session state for HttpContext
var session = new ShimHttpSessionState
{
ItemGetString = s =>
{
if (s == "")
return null;
return null;
}
};
// When the Fake HttpContext is called, provide the fake session state
ShimHttpContext.AllInstances.SessionGet = o => session;
//Expected result
const string expectedIpAddressLabel = "WAN_IP_ADDR";
const string expectedIpAddressValue = "10.143.22.1";
const string expectedBaseModelValue = "A5550";
const string expectedSerialNumber = "PACE99999991";
const string expectedUnitAddress = "001E46";
const string expectedLocationId = "123456789";
const string expectedRoomLocationLabel = "ROOM_LOCATION";
const string expectedRoomLocationValue = "TEST ROOM";
const string expectedMacAddressLable = "ENET_MAC_ADDR";
const string expectedMacAddressValue = "A0B1C2D3E4F5";
const string expectedSelectedRoomLabel = "SELECTED_ROOM";
const string expectedSelectedRoomValue = "MASTER BED ROOM";
var customFieldsDto = new List<CustomFieldDto>();
// RG custom fields
var expectedIpAddressCustomField = new CustomFieldDto
{
Label = expectedIpAddressLabel,
Value = expectedIpAddressValue,
};
customFieldsDto.Add(expectedIpAddressCustomField);
var expectedMacAddressCustomField = new CustomFieldDto
{
Label = expectedMacAddressLable,
Value = expectedMacAddressValue
};
customFieldsDto.Add(expectedMacAddressCustomField);
// ip video device custom fields
var expectedRoomLocationCustomField = new CustomFieldDto
{
Label = expectedRoomLocationLabel,
Value = expectedRoomLocationValue
};
customFieldsDto.Add(expectedRoomLocationCustomField);
var expectedSelectedRoomCustomField = new CustomFieldDto
{
Label = expectedSelectedRoomLabel,
Value = expectedSelectedRoomValue
};
customFieldsDto.Add(expectedSelectedRoomCustomField);
var customFieldsCollection = new CustomFieldCollectionDto
{
expectedIpAddressCustomField,
expectedRoomLocationCustomField,
expectedMacAddressCustomField
};
var rgType = new EquipmentTypeDto
{
ONTModel = new ONTModelDto
{
BaseModel = expectedBaseModelValue
},
Category = EquipmentCategoryDto.RGDataPort
};
var ipVideoType = new EquipmentTypeDto
{
Model = "ISP7500",
Category = EquipmentCategoryDto.DVR,
IptvCapable = true
};
// main active RG
var equipmentDataDto = new EquipmentDto
{
SerialNumber = expectedSerialNumber + "D01",
CustomFields = customFieldsDto,
UnitAddress = expectedUnitAddress,
LocationId = expectedLocationId,
Type = rgType,
Status = "ACTIVE"
};
var mainRg = new List<EquipmentDto>
{
equipmentDataDto,
new EquipmentDto
{
SerialNumber = expectedSerialNumber + "P01",
CustomFields = customFieldsDto,
UnitAddress = expectedUnitAddress,
LocationId = expectedLocationId,
Type = rgType,
Status = "ACTIVE"
},
new EquipmentDto
{
SerialNumber = expectedSerialNumber + "P02",
CustomFields = customFieldsDto,
UnitAddress = expectedUnitAddress,
LocationId = expectedLocationId,
Type = rgType,
Status = "ACTIVE"
}
};
// ip video device
var ipVideoDevice = new EquipmentDto
{
SerialNumber = "STBTEST1234",
CustomFields = new List<CustomFieldDto> { expectedRoomLocationCustomField },
UnitAddress = "1234567890",
LocationId = expectedLocationId,
Type = ipVideoType,
Status = "ACTIVE"
};
// other RGs on the account
var otherRgs = new List<EquipmentDto>
{
new EquipmentDto
{
SerialNumber = "RGCREATE1234" + "D01",
CustomFields = customFieldsDto,
UnitAddress = expectedUnitAddress,
LocationId = expectedLocationId,
Type = rgType,
Status = "IGNORE"
},
new EquipmentDto
{
SerialNumber = "RGCREATE2345" + "D01",
CustomFields = customFieldsDto,
UnitAddress = expectedUnitAddress,
LocationId = expectedLocationId,
Type = rgType,
Status = "IGNORE"
},
new EquipmentDto
{
SerialNumber = "RGCREATE3456" + "D01",
CustomFields = customFieldsDto,
UnitAddress = expectedUnitAddress,
LocationId = expectedLocationId,
Type = rgType,
Status = "IGNORE"
},
};
// set location
ShimCurrentSubscriber.AllInstances.LocationIdGet = o => expectedLocationId;
// set WanIpAddress
ShimCurrentSubscriber.AllInstances.SubIdGet = o => "1234567";
ShimCurrentSubscriber.AllInstances.WanIpAddressGet = o => "12:12:12:12";
ShimRosettianClient.AllInstances.LoadSubscriberStringUserDto = (client, subId, userDto) => new SubscriberDto();
ShimCurrentSubscriber.UpdateWanIpAddressString = (myWanIpAddress) => { };
// set activate residential gateway to true
ShimRosettianClient.AllInstances.ActivateResidentialGatewayStringStringUserDto =
(myTestclient, mylocationId, myDeviceId, userDto) => true;
// expected search results after Activate RG
var searchEquipmentsResult = new List<EquipmentDto>();
searchEquipmentsResult.AddRange(mainRg);
searchEquipmentsResult.AddRange(otherRgs);
searchEquipmentsResult.Add(ipVideoDevice);
// set search results to expected
ShimRosettianClient.AllInstances.SearchEquipmentSearchFieldsDtoUserDto =
(myTestClient, mySearchFields, myUserDto) => searchEquipmentsResult;
// expected custom fields
equipmentDataDto.CustomFields = customFieldsDto;
// set load eqiupment for main RG
ShimRosettianClient.AllInstances.LoadEquipmentStringBooleanUserDto =
(myTestClient, myEquipmentId, returnExtraData, myUserDto) => equipmentDataDto;
// set custom fields
ShimRosettianClient.AllInstances.GetCustomFieldsUserDto = (myTestClient, myUserDto) => customFieldsCollection;
// set ip video device path
ShimVirtualPathUtility.ToAbsoluteString = (myTestString) => @"http://testapp/images/DVR.png";
// get service for ResidentialGatewayController
var residentialController = DependencyResolver.Current.GetService<ResidentialGatewayController>();
// call ActivateResidentialGateway of ResidentialGatewayController
var result = residentialController.ActivateResidentialGateway(expectedSerialNumber, expectedLocationId) as JsonResult;
// validate json result
Assert.IsNotNull(result, "Returned Json result is null");
dynamic resultData = result.Data;
var status = resultData.status as string;
var errorMessage = string.Empty;
if (status == "error")
{
errorMessage = resultData.errorMessage;
}
Assert.AreEqual("valid", status, "status is not valid - {0}", errorMessage);
var renderedPartial = resultData.returnedPartial as string;
Assert.IsNotNull(renderedPartial, "Prerendered partial is null.");
}
}
private EquipmentDto TestEquipment_VideoAccessPoint()
{
var equipmentDto = new EquipmentDto
{
AssociatedSubscriberId = "associatedsubid",
BlockedServiceList = new List<ServiceDto>(),
CPE = true,
CustomFields = new List<CustomFieldDto>(),
HeadendCode = "04",
LocationId = "locationid",
SerialNumber = "vapserialnumber",
Status = "LOST",
Type = new EquipmentTypeDto
{
Category = EquipmentCategoryDto.VideoAccessPoint,
Model = "VAP2500",
WirelessCapable = true
},
UnitAddress = "unitaddress",
VCI = "1234",
VPI = "1234",
};
return equipmentDto;
}
