public void Create(string tokenId, SubscriberDto subscriberDto)
{
var user = UserAdapter.BuildUser(subscriberDto);
user.Id = Guid.NewGuid();
var roleUser = _roleRepository.Find(x => x.Name.Equals(RoleConstants.Subscriber)).FirstOrDefault();
user.Roles = new List <Role> {
roleUser
};
var customerId = StripeService.StripeService.CreateCustomer(tokenId, user.Email);
var subscriberId = StripeService.StripeService.SubscribeCustomer(customerId, subscriberDto.SubscriptionPlan);
var sub = new Subscriber
{
UserId = user.Id,
StripeId = customerId,
SubscriptionPlan = subscriberDto.SubscriptionPlan.ToString(),
IsTrial = subscriberDto.IsTrial
};
_userRepository.AddUser(user);
_gSubscriberRepository.Add(sub);
var body = _email.CreateEmailBody(user.UserName, "Subscriber");
_email.SendEmail("Welcome", body, user.Email);
}
private void ThrowIfSubscriberIncorrect(SubscriberDto dto)
{
if (string.IsNullOrEmpty(dto.Lastname) || string.IsNullOrEmpty(dto.Firstname))
{
throw new SubscriberIncorrectException();
}
}
public Guid RegisterSubscription(SubscriberDto subscriberDto, string sendingApplicationName)
{
var sendingApplication =
DataContext.SendingApplications.FirstOrDefault(x => x.SendingApplicationName == sendingApplicationName);
if (sendingApplication == null)
{
var exception =
new Exception("Cannot register a subscription for a SendingApplication that is not registered.");
Logger.ErrorException(FailureMessage, exception);
throw exception;
}
Subscriber subscriber;
if (subscriberDto.SubscriberId != Guid.Empty)
{
subscriber = DataContext.Subscribers.FirstOrDefault(x => x.SubscriberId == subscriberDto.SubscriberId);
}
else
{
subscriber = subscriberDto.ToEntity();
subscriber.SubscriberId = Guid.NewGuid();
DataContext.Subscribers.Add(subscriber);
}
var port = subscriberDto.Port.HasValue ? subscriberDto.Port.Value : Settings.Default.GrowlDefaultPort;
var growlConnector = new GrowlConnector(subscriberDto.Password, subscriberDto.HostName, port);
var growlNotificationTypes = new List <Growl.Connector.NotificationType>();
foreach (var notificationType in sendingApplication.NotificationTypes)
{
var growlNotificationType = new Growl.Connector.NotificationType(notificationType.NotificationTypeName,
notificationType.NotificationTypeDisplayName);
if (notificationType.NotificationTypeIcon != null && notificationType.NotificationTypeIcon.Length > 0)
{
growlNotificationType.Icon = new BinaryData(notificationType.NotificationTypeIcon);
}
growlNotificationTypes.Add(growlNotificationType);
}
var growlApplication = new Application(sendingApplicationName);
if (sendingApplication.SendingApplicationIcon != null && sendingApplication.SendingApplicationIcon.Length > 0)
{
growlApplication.Icon = new BinaryData(sendingApplication.SendingApplicationIcon);
}
growlConnector.Register(growlApplication, growlNotificationTypes.ToArray());
if (sendingApplication.Subscribers.Contains(subscriber))
{
return(Guid.Empty);
}
Debug.Assert(subscriber != null, "subscriber != null");
subscriber.SendingApplication = sendingApplication;
DataContext.SaveChanges();
return(subscriber.SubscriberId);
}
public IHttpActionResult PutSubscriber(int id, SubscriberDto subscriberDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var subscriber = _db.Subscribers.SingleOrDefault(c => c.Id == id);
if (subscriber == null)
{
return(NotFound());
}
Mapper.Map(subscriberDto, subscriber);
try
{
_db.SaveChanges();
}
catch (DbUpdateConcurrencyException ex)
{
throw ex;
}
return(StatusCode(HttpStatusCode.NoContent));
}
private void UpdateChangesInDatabase()
{
//Update changes in the database
foreach (int id in toUpdateList)
{
//Find the row by id, where the changes took place
int rowIndex = -1;
foreach (DataGridViewRow row in dataGridView.Rows)
{
if ((int)row.Cells["Id"].Value == id)
{
rowIndex = row.Index;
break;
}
}
SubscriberDto subToUpdate = _subscriberRepo.Get(id);
subToUpdate.Id = (int)dataGridView.Rows[rowIndex].Cells["Id"].Value;
subToUpdate.FirstName = dataGridView.Rows[rowIndex].Cells["First Name"].Value?.ToString();
subToUpdate.LastName = dataGridView.Rows[rowIndex].Cells["Last Name"].Value?.ToString();
subToUpdate.PhoneNumber = dataGridView.Rows[rowIndex].Cells["Phone Number"].Value?.ToString();
subToUpdate.Details = dataGridView.Rows[rowIndex].Cells["Details"].Value?.ToString();
try
{
_subscriberRepo.Update(subToUpdate);
}
catch (Exception ex)
{
MessageBox.Show($"An error occured while trying to update the database.");
}
toUpdateList = new List <int>();
}
}
private void AddNewRowsInDatabase()
{
//Add new subscribers to the database
foreach (DataGridViewRow row in dataGridView.Rows)
{
if (!row.IsNewRow && (int)row.Cells["Id"].Value == 0)
{
SubscriberDto toAdd = new SubscriberDto
{
FirstName = dataGridView.Rows[row.Index].Cells["First Name"].Value?.ToString(),
LastName = dataGridView.Rows[row.Index].Cells["Last Name"].Value?.ToString(),
PhoneNumber = dataGridView.Rows[row.Index].Cells["Phone Number"].Value?.ToString(),
Details = dataGridView.Rows[row.Index].Cells["Details"].Value?.ToString(),
};
try
{
_subscriberRepo.Add(toAdd);
}
catch (Exception ex)
{
MessageBox.Show($"An error occured while trying to add rows to the database.");
}
}
}
}
public async Task <IHttpActionResult> PostSubscriber(Subscriber subscriber)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.Subscribers.Add(subscriber);
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (SubscriberExists(subscriber.Id))
{
return(Conflict());
}
else
{
throw;
}
}
//return CreatedAtRoute("DefaultApi", new { id = subscriber.Id }, subscriber);
var dto = new SubscriberDto()
{
Id = subscriber.Id,
Name = subscriber.Name
};
return(CreatedAtRoute("DefaultApi", new { id = subscriber.Id }, dto));
}
public void Update_IncorrectSubscriber_ShouldThrownSubscriberIncorrectException()
{
var dto = new SubscriberDto()
{
Id = DefaultData.Subscribers.Ivanov.Id
};
Assert.Throws <SubscriberIncorrectException>(async() => await SubscribersService.Update(dto.Id, dto));
}
public void CanCreateSubscriberDto()
{
// ARRANGE
// ACT
var subjectUnderTest = new SubscriberDto();
// ASSERT
Assert.That(subjectUnderTest, Is.TypeOf(typeof(SubscriberDto)));
Assert.That(subjectUnderTest, Is.InstanceOf(typeof(SubscriberDto)));
}
public void Create_ExistsSubscriber_ShouldThrownSubscriberDublicateException()
{
var dto = new SubscriberDto()
{
Lastname = DefaultData.Subscribers.Petrov.Lastname,
Firstname = DefaultData.Subscribers.Petrov.Firstname,
Middlename = DefaultData.Subscribers.Petrov.Middlename
};
Assert.Throws <SubscriberDublicateException>(async() => await SubscribersService.Create(dto));
}
private SubscriberDto _newSubscriberDto()
{
var subscriberDto = new SubscriberDto
{
ID = 7,
Email = "email",
Name = "Cat7"
};
return(subscriberDto);
}
public void CanSetId()
{
// ARRANGE
var expectedId = Guid.NewGuid();
var subjectUnderTest = new SubscriberDto();
// ACT
subjectUnderTest.Id = expectedId;
// ASSERT
Assert.That(subjectUnderTest.Id, Is.EqualTo(expectedId));
}
public void TestRegisterSubscription_ApplicationExists_SubscriberRegistered()
{
var foghornClient =
new ChannelFactory <IFoghornService>(new BasicHttpBinding(), new EndpointAddress(ServiceUrl)).CreateChannel();
var subscriberDto = new SubscriberDto {
HostName = "localhost", Password = "******", SubscriberName = "jbloggs"
};
foghornClient.RegisterSubscription(subscriberDto, ApplicationTestName);
//TODO: Add Assertions
}
public void CanSetEmailAddress()
{
// ARRANGE
var expectedEmailAddress = "*****@*****.**";
var subjectUnderTest = new SubscriberDto();
// ACT
subjectUnderTest.EmailAddress = expectedEmailAddress;
// ASSERT
Assert.That(subjectUnderTest.EmailAddress, Is.EqualTo(expectedEmailAddress));
}
public IHttpActionResult PostSubscriber(SubscriberDto subscriberDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var subscriber = Mapper.Map <SubscriberDto, Subscriber>(subscriberDto);
_db.Subscribers.Add(subscriber);
_db.SaveChanges();
return(Created(new Uri(Request.RequestUri + "/" + subscriber.Id), subscriber));
}
public async Task <GetOrCreateSubscriberOutput> GetOrCreate(GetOrCreateSubscriberInput input)
{
try
{
SubscriberDto subscriberDto = null;
bool newSubscriber = false;
string normalisedEmail = StringUtils.NormaliseEmailAddress(input.EmailAddress);
subscriberDto = await _crudServices.ReadSingleAsync <SubscriberDto>(s => s.EmailAddress == normalisedEmail);
if (subscriberDto == null)
{
string emailVerifyCode = !input.EmailAddressVerified
? Guid.NewGuid().ToString("N").ToLowerInvariant().Truncate(Subscriber.MAX_LENGTH_EMAIL_VERIFY_CODE)
: null;
subscriberDto = await _crudServices.CreateAndSaveAsync(new SubscriberDto
{
EmailAddress = normalisedEmail,
EmailAddressVerified = input.EmailAddressVerified,
EmailVerifyCode = emailVerifyCode
});
if (!_crudServices.IsValid)
{
return(new GetOrCreateSubscriberOutput
{
ErrorMessage = _crudServices.GetAllErrors()
});
}
newSubscriber = true;
}
return(new GetOrCreateSubscriberOutput
{
Subscriber = subscriberDto,
CreatedNewSubscriber = newSubscriber,
ErrorMessage = subscriberDto == null ? $"Error creating subscriber with email '{normalisedEmail}' in database" : null
});
}
catch (Exception ex)
{
Logger.LogError(ex, "EmailAddress: " + input.EmailAddress);
return(new GetOrCreateSubscriberOutput
{
ErrorMessage = ex.Message
});
}
}
private async Task ThrowIfSameSubscriberExists(SubscriberDto dto)
{
List <Expression <Func <Subscriber, bool> > > filters = new List <Expression <Func <Subscriber, bool> > >()
{
x => x.Lastname.ToLower() == dto.Lastname.ToLower(),
x => x.Firstname.ToLower() == dto.Firstname.ToLower(),
x => x.Middlename.ToLower() == dto.Middlename.ToLower()
};
var dublicates = await _unitOfWork.SubscriberRepository.GetAllAsync(filters);
if (dublicates.Any())
{
throw new SubscriberDublicateException();
}
}
public async Task <SubscriberDto> Create(SubscriberDto dto)
{
ThrowIfSubscriberIncorrect(dto);
await ThrowIfSameSubscriberExists(dto);
var subscriber = Mapper.Map <Subscriber>(dto);
if (_unitOfWork.SubscriberRepository.Create(subscriber))
{
await _unitOfWork.Save();
}
await _unitOfWork.Save();
return(Mapper.Map <SubscriberDto>(subscriber));
}
public async Task <SubscriberDto> SubscribeAsync(SubscriberDto subscriberDto)
{
SubscriberEntity subscriber;
try
{
subscriber = await _storage.CreateAsync(_mapper.Map <SubscriberEntity>(subscriberDto));
}
catch (Microsoft.EntityFrameworkCore.DbUpdateException)
{
throw new SubscriberException(ExceptionMessage.SubscriberDuplicate);
}
return(_mapper.Map <SubscriberDto>(subscriber));
}
public EventMatcherFactoryTest()
{
_mockParameterConditionRepository = new Mock <IParameterConditionRepository>();
_mockEventSubscriptionAddressRepository = new Mock <IEventSubscriptionAddressRepository>();
_mockSubscriberContractRepository = new Mock <ISubscriberContractRepository>();
_factory = new EventMatcherFactory(
_mockParameterConditionRepository.Object,
_mockEventSubscriptionAddressRepository.Object,
_mockSubscriberContractRepository.Object);
_subscriberOneConfig = new SubscriberDto {
Id = 1
};
_contractDto = new SubscriberContractDto
{
Id = 1,
SubscriberId = _subscriberOneConfig.Id,
Abi = TestData.Contracts.StandardContract.Abi,
Name = "Transfer"
};
_eventSubscriptionConfig = new EventSubscriptionDto
{
Id = 1,
SubscriberId = _subscriberOneConfig.Id,
ContractId = _contractDto.Id,
EventSignatures = new[] { TestData.Contracts.StandardContract.TransferEventSignature }.ToList()
};
_addressesConfig = new EventSubscriptionAddressDto
{
Id = 1,
Address = "",
EventSubscriptionId = _eventSubscriptionConfig.Id
};
_parameterConditionConfig = new ParameterConditionDto
{
Id = 1,
EventSubscriptionId = _eventSubscriptionConfig.Id,
ParameterOrder = 1,
Operator = ParameterConditionOperator.Equals,
Value = "xyz"
};
_mockSubscriberContractRepository.Setup(d => d.GetAsync(_subscriberOneConfig.Id, _contractDto.Id)).ReturnsAsync(_contractDto);
_mockEventSubscriptionAddressRepository.Setup(d => d.GetManyAsync(_eventSubscriptionConfig.Id)).ReturnsAsync(new[] { _addressesConfig });
_mockParameterConditionRepository.Setup(d => d.GetManyAsync(_eventSubscriptionConfig.Id)).ReturnsAsync(new[] { _parameterConditionConfig });
}
public EventSubscriptionFactoryTest()
{
_mockSubscriberRepo = new Mock <ISubscriberRepository>();
_mockEventSubscriptionRepo = new Mock <IEventSubscriptionRepository>();
_mockEventHandlerRepo = new Mock <IEventHandlerRepository>();
_mockEventSubscriptionStateRepository = new Mock <IEventSubscriptionStateRepository>();
_mockDb = new Mock <IEventProcessingConfigurationRepository>();
_mockDb.Setup(db => db.Subscribers).Returns(_mockSubscriberRepo.Object);
_mockDb.Setup(db => db.EventSubscriptions).Returns(_mockEventSubscriptionRepo.Object);
_mockDb.Setup(db => db.EventHandlers).Returns(_mockEventHandlerRepo.Object);
_mockDb.Setup(db => db.EventSubscriptionStates).Returns(_mockEventSubscriptionStateRepository.Object);
_mockEventHandlerFactory = new Mock <IEventHandlerFactory>();
_mockEventMatcherFactory = new Mock <IEventMatcherFactory>();
_factory = new EventSubscriptionFactory(_mockDb.Object, _mockEventMatcherFactory.Object, _mockEventHandlerFactory.Object);
_mockEventHandler = new Mock <IEventHandler>();
_mockEventMatcher = new Mock <IEventMatcher>();
_subscriberOneConfig = new SubscriberDto {
Id = 1
};
_eventSubscriptionConfig = new EventSubscriptionDto
{
Id = 1,
SubscriberId = _subscriberOneConfig.Id
};
_eventHandlerConfig = new EventHandlerDto
{
Id = 1,
EventSubscriptionId = _eventSubscriptionConfig.Id,
HandlerType = EventHandlerType.Queue
};
_eventSubscriptionStateConfig = new EventSubscriptionStateDto
{
Id = 1,
EventSubscriptionId = _eventSubscriptionConfig.Id
};
_mockSubscriberRepo.Setup(d => d.GetManyAsync(PARTITION_ID)).ReturnsAsync(new[] { _subscriberOneConfig });
_mockEventSubscriptionRepo.Setup(d => d.GetManyAsync(_subscriberOneConfig.Id)).ReturnsAsync(new[] { _eventSubscriptionConfig });
_mockEventHandlerRepo.Setup(d => d.GetManyAsync(_eventSubscriptionConfig.Id)).ReturnsAsync(new[] { _eventHandlerConfig });
_mockEventSubscriptionStateRepository.Setup(d => d.GetAsync(_eventSubscriptionConfig.Id)).ReturnsAsync(_eventSubscriptionStateConfig);
_mockEventHandlerFactory.Setup(f => f.LoadAsync(It.IsAny <IEventSubscription>(), _eventHandlerConfig)).ReturnsAsync(_mockEventHandler.Object);
_mockEventMatcherFactory.Setup(f => f.LoadAsync(_eventSubscriptionConfig)).ReturnsAsync(_mockEventMatcher.Object);
}
public async Task <IActionResult> Subscribe([FromBody] SubscriberDto subscribeDto)
{
ResponseDto <SubscriberDto> okResponse = new ResponseDto <SubscriberDto>(true);
ResponseDto <ErrorDto> errorResponse = new ResponseDto <ErrorDto>(false);
try
{
okResponse.Data = await _subscribe.SubscribeAsync(subscribeDto);
return(Ok(okResponse));
}
catch (SubscriberException ex)
{
errorResponse.Data = new ErrorDto(ex.Message);
return(BadRequest(errorResponse));
}
}
public void Board_CreateSubscriber_Pass()
{
try
{
var subscriberDto = new SubscriberDto
{
AsAdmin = 0,
UserId = 4939512
};
_mondayClient.CreateSubscriberOnBoard(137872223, subscriberDto).Wait();
}
catch (Exception ex)
{
Assert.Fail(ex.ToString());
}
}
public void Pulse_CreateSubscriber_Pass()
{
try
{
var subscriberDto = new SubscriberDto
{
AsAdmin = 0,
UserId = 4939512
};
_mondayClient.CreateSubscriberOnPulse(157543293, subscriberDto).Wait();
}
catch (Exception ex)
{
Assert.Fail(ex.ToString());
}
}
/// <summary>
/// From Subscriber dto To Subscriber pivot.
/// </summary>
/// <param name="subscriberDto">subscriber dto to assemble.</param>
/// <returns>Subscriberpivot result.</returns>
public static SubscriberPivot ToPivot(this SubscriberDto subscriberDto)
{
if (subscriberDto == null)
{
return(null);
}
else
{
return(new SubscriberPivot()
{
SubscriberId = subscriberDto.SubscriberId,
SubscriberFirstName = subscriberDto.SubscriberFirstName,
SubscriberLastName = subscriberDto.SubscriberLastName,
SubscriberEmail = subscriberDto.SubscriberEmail,
});
}
}
public async Task <SubscriberDto> Update(long id, SubscriberDto dto)
{
if (id == default(long) || dto.Id == default(long))
{
throw new SubscriberHasIncorrectIdException(dto.Id);
}
ThrowIfSubscriberIncorrect(dto);
await ThrowIfSameSubscriberExists(dto);
var subscriber = Mapper.Map <Subscriber>(dto);
if (_unitOfWork.SubscriberRepository.Update(subscriber))
{
await _unitOfWork.Save();
}
return(Mapper.Map <SubscriberDto>(subscriber));
}
public async Task Create_ShouldCreated()
{
var oldCount = Subscribers.Count;
var subscriber = new SubscriberDto()
{
Id = Random.Next(int.MaxValue),
Lastname = "Novoselov",
Firstname = "Oleg",
Middlename = "Middlename'ovich"
};
await SubscribersService.Create(subscriber);
Assert.That(Subscribers.Count, Is.EqualTo(oldCount + 1));
var created = Subscribers.Single(x => x.Id == subscriber.Id);
Assert.That(created.Lastname, Is.EqualTo(subscriber.Lastname));
Assert.That(created.Firstname, Is.EqualTo(subscriber.Firstname));
Assert.That(created.Middlename, Is.EqualTo(subscriber.Middlename));
}
public async Task <IActionResult> Verify([FromBody] SubscriberDto subscriber)
{
if (null == subscriber)
{
return(BadRequest());
}
try
{
var dockect = await _mediator.Send(new VerifySubscriber(subscriber.SubscriberId, subscriber.AuthToken), HttpContext.RequestAborted);
return(Ok(dockect));
}
catch (Exception e)
{
Log.Error(e, "verify error");
return(StatusCode(500, e.Message));
}
}
private async Task SendVerificationEmail(SubscriberDto subscriber)
{
string verifyUrl = GetVerifyEmailUrl(subscriber);
var message = new EmailMessage
{
BodyText = $"Hello, please click the link below to verify your email address. This is required before you can receive new album emails:\r\n\r\n{verifyUrl}\r\n\r\nThanks for using New Albums via Email.",
BodyHtml = await GetVerificationEmailHtml(verifyUrl),
Subject = "Please verify your email address",
ToAddresses = new List <EmailAddress>
{
new EmailAddress
{
Address = subscriber.EmailAddress
}
}
};
await _emailManager.SendEmail(message);
}
public void TestRegisterSubscription_ApplicationExists_SubscriberRegistered()
{
var service = new FoghornService();
if (_testApplicationId <= 0)
{
RegisterTestApplication(service);
}
var subscriberDto = new SubscriberDto
{
HostName = "localhost",
Password = "******",
SubscriberName = ApplicationTestName + "TestSubscriber",
};
var subscriberId = service.RegisterSubscription(subscriberDto, ApplicationTestName);
var dataContext = new FoghornEntities();
var subscriber = dataContext.Subscribers.FirstOrDefault(x => x.SubscriberId == subscriberId);
Assert.NotNull(subscriber);
}
/// <summary>
/// GetFakeSubscriberDto - returns SubscriberDto
/// </summary>
/// <param name="subscriberID"></param>
/// <param name="firstName"></param>
/// <param name="lastName"></param>
/// <param name="subscriberContactPhone"></param>
/// <param name="fakeCustomFieldDto"></param>
/// <param name="fakeAccountDto"></param>
/// <returns></returns>
public SubscriberDto GetFakeSubscriberDto(string subscriberID, string firstName, string lastName, string subscriberContactPhone, CustomFieldDto fakeCustomFieldDto, AccountDto fakeAccountDto)
{
// Build Fake SubscriberDto
var fakeSubscriberDto = new SubscriberDto()
{
ID = subscriberID,
Name = string.Format("{0} {1}", firstName, lastName),
SubContactPhone = subscriberContactPhone,
SubContactEmail = "*****@*****.**",
};
fakeSubscriberDto.CustomFields.Add(fakeCustomFieldDto);
fakeSubscriberDto.Accounts.Add(fakeAccountDto);
return fakeSubscriberDto;
}
public void ChangeLocation_Succeed()
{
var loc = new LocationDto();
var loc2 = new LocationDto();
var sub = new SubscriberDto();
try
{
// new sub and loc data
loc = DataHelper.NewLocationData();
loc.RateCenterName = "WASHINGTON";
loc.NetworkLocationCode = "1234567";
loc2 = DataHelper.NewLocationData();
loc2.RateCenterName = "STAMFORD";
loc2.NetworkLocationCode = "2345668";
sub = DataHelper.NewSubscriberData();
sub.Accounts[0].Location = loc;
sub.CustomFields = DataHelper.DefaultCustomFields_Sub();
DataHelper.RestoreLocation1(loc, false);
DataHelper.RestoreSubscriber1(sub, false);
DataHelper.RestoreLocation1(loc2, false);
// set current subscriber
CurrentSubscriber.SetInstance(sub);
var loc2AsJson = JavaScriptSerializerUtil.Serialize(loc2);
// call ChangeLocation action method
var actualResult = LocationController4Tests.ChangeLocation(loc2AsJson) as PartialViewResult;
// validate returned result and model are not null
Assert.IsTrue(actualResult != null && actualResult.Model != null);
// validate model
var resultModel = actualResult.Model as SubscriberLocationModel;
Assert.IsNotNull(resultModel, "Model should not be null");
// validate returned action response
var expectedActionResponse = new RozResponseDto
{
Code = "200",
Message = string.Format("Successfully changed location from [{0}] to [{1}] for subscriber [{2}]", loc.ID, loc2.ID, sub.ID)
};
Assert.IsNotNull(resultModel.ActionResponse, "ActionResponse should not be null");
Assert.AreEqual(expectedActionResponse.Code, resultModel.ActionResponse.Code);
Assert.AreEqual(expectedActionResponse.Message, resultModel.ActionResponse.Message);
// validate location changed for subscriber in db
var actualSub = DataHelper.LoadSubscriber(sub.ID);
Assert.AreEqual(loc2.ID, actualSub.Accounts[0].Location.ID, "Subscriber location id does not match");
}
catch (Exception ex)
{
Assert.IsTrue(ex is AssertFailedException, ex.ToString());
throw;
}
finally
{
DataHelper.DeleteSubscriber(sub.ID);
DataHelper.DeleteLocation(loc.ID);
DataHelper.DeleteLocation(loc2.ID);
}
}
public void UpdateLocation_ClearAddresses_ClearRateCenter_ClearNetworkLocationCode_Succeed()
{
var loc = new LocationDto();
var sub = new SubscriberDto();
try
{
// new sub and loc data
loc = DataHelper.NewLocationData();
loc.RateCenterName = "WASHINGTON";
loc.NetworkLocationCode = "1234567";
sub = DataHelper.NewSubscriberData();
sub.Accounts[0].Location = loc;
sub.CustomFields = DataHelper.DefaultCustomFields_Sub();
DataHelper.RestoreLocation1(loc, false);
DataHelper.RestoreSubscriber1(sub, false);
// set current subscriber
CurrentSubscriber.SetInstance(sub);
// edit location
loc.AddressLine1 = "";
loc.AddressLine2 += "";
loc.RateCenterName = "";
loc.NetworkLocationCode = "";
loc.CityName = "";
loc.StateName = "CT";
loc.ZipCode = "";
loc.HeadendCode = "05";
// map the loc to SubscriberLocationModel
var subLocModel = loc.MapToSubLocationModel();
// call UpdateLocation action method
var result = LocationController4Tests.UpdateLocation(subLocModel) as JsonResult;
// validate response result
Assert.IsNotNull(result, "Json result is null");
Assert.IsNotNull(result.Data, "Json result data is null");
dynamic resultStatus = result.Data;
Assert.AreEqual("valid", resultStatus.status as string, "Response status does not match!");
// validate the current subscriber session got updated
var currentSubscriber = CurrentSubscriber.GetInstance();
var actualSubLocModel = currentSubscriber.MapToSubLocationModel();
ValidateLocation(subLocModel, actualSubLocModel);
// validate location updated in db
var actualLoc = DataHelper.LoadLocation(loc.ID);
Assert.IsNotNull(actualLoc, "Location should not be null!");
ValidateLocation(loc, actualLoc);
}
catch (Exception ex)
{
Assert.IsTrue(ex is AssertFailedException, ex.ToString());
throw;
}
finally
{
DataHelper.DeleteSubscriber(sub.ID);
DataHelper.DeleteLocation(loc.ID);
}
}
public void ClearLocation_Succeed()
{
var loc = new LocationDto();
var sub = new SubscriberDto();
try
{
// new sub and loc data
loc = DataHelper.NewLocationData();
loc.RateCenterName = "WASHINGTON";
loc.NetworkLocationCode = "1234567";
sub = DataHelper.NewSubscriberData();
sub.Accounts[0].Location = loc;
sub.CustomFields = DataHelper.DefaultCustomFields_Sub();
DataHelper.RestoreLocation1(loc, false);
DataHelper.RestoreSubscriber1(sub, false);
// set current subscriber
CurrentSubscriber.SetInstance(sub);
// call ClearLocation action method
var actualResult = LocationController4Tests.ClearLocation(loc.ID) as PartialViewResult;
// validate returned result and model are not null
Assert.IsTrue(actualResult != null && actualResult.Model != null);
// validate model
var resultModel = actualResult.Model as SubscriberLocationModel;
Assert.IsNotNull(resultModel, "Model should not be null");
// validate returned action response
var expectedActionResponse = new RozResponseDto
{
Code = "200",
Message = String.Format("Successfully disassociated subscriber from location [{0}]", loc.ID)
};
Assert.IsNotNull(resultModel.ActionResponse, "ActionResponse should not be null");
Assert.AreEqual(expectedActionResponse.Code, resultModel.ActionResponse.Code);
Assert.AreEqual(expectedActionResponse.Message, resultModel.ActionResponse.Message);
// validate location cleared for subscriber in db
var actualSub = DataHelper.LoadSubscriber(sub.ID);
Assert.IsTrue(actualSub!=null && actualSub.Accounts.Any() && actualSub.Accounts[0]!=null);
Assert.IsTrue(actualSub.Accounts[0].Location == null ||
string.IsNullOrEmpty(actualSub.Accounts[0].Location.ID));
}
catch (Exception ex)
{
Assert.IsTrue(ex is AssertFailedException, ex.ToString());
throw;
}
finally
{
DataHelper.DeleteSubscriber(sub.ID);
DataHelper.DeleteLocation(loc.ID);
}
}
public void UpdatePhoneDetails_Successful()
{
using (ShimsContext.Create())
{
//Arrange
//Fake call to CurrentUser.AsUserDto()
ShimCurrentUser.AsUserDto = new SIMPLTestContext().GetFakeUserDtoObject;
// Fake the HttpContext
ShimHttpContext.CurrentGet = () => new ShimHttpContext();
// SIMPL.Session.Fakes.ShimCurrentSubscriber.SessionInstanceGet = () => new ShimCurrentSubscriber();
// When the Fake HttpContext is called, provide the fake session state
ShimHttpContext.AllInstances.SessionGet = delegate
{
return new ShimHttpSessionState
{
ItemGetString = s =>
{
if (s == "")
return null;
return null;
}
};
};
// shim CurrentSubscriber.SubId
ShimCurrentSubscriber.GetInstance = () => new ShimCurrentSubscriber
{
SubIdGet = () => "77441",
ProvisionedServicesListGet = delegate
{
return new List<DAL.DataTransfer.Provisioning.ServiceDto>();
}
};
var fakeSubscriberDto = new SubscriberDto()
{
Accounts = new[]
{
new AccountDto()
{
Services = new ServiceCollectionDto()
}
}
};
ShimSubscriberExtension.MapToSubscriberCurrentSubscriber = delegate { return fakeSubscriberDto; };
// shim LoadSubscriberPhones call
ShimRosettianClient.AllInstances.LoadSubscriberPhonesStringUserDto = delegate
{
return new List<PhoneDto>
{
new PhoneDto
{
PhoneNumber = "4252309331",
PhoneProvSpec = new PhoneProvSpecDto()
{
LocalPIC = new PICDto(),
LongDistancePIC = new PICDto(),
DSLUnitAddress = new List<DSLUnitAddressDto>()
{
new DSLUnitAddressDto() {CLLICode = "ACME", HSIPort = "01-10-10"}
},
PrimaryNumber = "4252309331",
Services = new ServiceCollectionDto()
{
new DAL.DataTransfer.Provisioning.ServiceDto()
{
ClassName = "U-VERSE VOIP",
Description = "METASWITCH SIP",
Name = "FTRCFS"
}
},
DSLAMInfo = new DslamInfoDto
{
DslamDescription = "Alcatel 7330",
BaseIPAddress = "32.222.17.35",
SID = "CRWLCT0011011345464"
}
//Please leave code - commented out for 10/25 release
//SwitchFields = new MetaSwitchFieldsDto
//{
// HuntingMasterTN = "4252309331:10",
// ConnectAfterAnnounce = "Yes",
// InterceptExpireData = "36"
//}
}
}
};
};
var phoneViewModel = new CVoipPhoneDetailsViewModel
{
TN = "4252309331",
ProvisionDetails = new CVoipPhoneProvisionDetails
{
CLLI1 = "SILLY",
Port1 = "01-01-06-09",
DSLAMInfo = new DslamInfoDto
{
DslamDescription = "Alcatel 7330",
BaseIPAddress = "32.222.17.35",
SID = "CRWLCT0011011345464"
}
},
RGSerialNumber = "PACE123456",
RGPort = "None",
//Please leave code - commented out for 10/25 release
//InterceptExpireData = DateTime.Now.AddDays(2),
// HuntingMasterTN = "4252309331",
// HuntingGroupPosition ="01"
};
// shim UpdateSubscriberPhones call
ShimRosettianClient.AllInstances.UpdateSubscriberPhoneStringPhoneDtoUserDtoBoolean = delegate { return true; };
// create phone controller instance
var phoneController = DependencyResolver.Current.GetService<CVoipPhoneController>();
// Act
var result = phoneController.UpdatePhoneDetails(phoneViewModel);
// Assert
Assert.IsNotNull(result, "CVoipController UpdatePhoneDetails returned null");
var partialViewResult = result as PartialViewResult;
Assert.IsNotNull(partialViewResult);
Assert.AreEqual("PhoneProvDetails_Partial", partialViewResult.ViewName);
var model = partialViewResult.Model as PhoneProvisionDetails;
Assert.IsNotNull(model);
}
}
private void DeleteTestSubscriber(SubscriberDto subscriber, SubscriberHelper sh)
{
if (subscriber != null)
{
try
{
sh.DeleteSubscriber(subscriber);
}
catch (System.Exception ex)
{
Assert.Fail(ex.Message);
}
}
}
public void UpdateSubscriberServiceStatus_SubNotFoundInDPI_ValidateEnableScenario()
{
var loc = new LocationDto();
var sub = new SubscriberDto();
try
{
// new sub and loc data
loc = DataHelper.NewLocationData();
sub = DataHelper.NewSubscriberData();
sub.Accounts[0].Location = loc;
sub.Accounts[0].ServiceEnabled = false;
sub.CustomFields = DataHelper.DefaultCustomFields_Sub();
DataHelper.RestoreLocation1(loc, false);
DataHelper.RestoreSubscriber1(sub, false);
// set current subscriber
CurrentSubscriber.SetInstance(sub);
// call UpdateSubscriberServiceStatus action method
var result = SubscriberControllerForTests.UpdateSubscriberServiceStatus(true) as JsonResult;
// expected subDetailsModel after UpdateSubscriberServiceStatus
sub.Accounts[0].ServiceEnabled = true;
var subDetailsModel = sub.MapToSubDetailsModel();
// validate response result
Assert.IsNotNull(result, "Json result is null");
Assert.IsNotNull(result.Data, "Json result data is null");
dynamic resultStatus = result.Data;
Assert.AreEqual("valid", resultStatus.status as string, "Response status does not match!");
// validate service enabled in db
var actualSub = DataHelper.LoadSubscriber(sub.ID);
Assert.IsNotNull(actualSub, "Subscriber should not be null!");
Assert.AreEqual(sub.ID, actualSub.ID);
Assert.AreEqual(sub.Accounts[0].ServiceEnabled, actualSub.Accounts[0].ServiceEnabled);
// validate the current subscriber session got updated
var currentSubscriber = CurrentSubscriber.GetInstance();
var actualSubDetailsModel = currentSubscriber.MapToSubDetailsModel();
// validate FoundInBilling should be false
Assert.IsFalse(actualSubDetailsModel.FoundInBilling, "FoundInBilling should be false");
// validate actualSubDetailsModel matches expectedSubDetailsModel
Assert.AreEqual(subDetailsModel.USI, actualSubDetailsModel.USI, "USI does not match");
Assert.AreEqual(subDetailsModel.Name, actualSubDetailsModel.Name, "Name does not match");
Assert.AreEqual(subDetailsModel.FoundInBilling, actualSubDetailsModel.FoundInBilling, "FoundInBilling does not match");
Assert.AreEqual(subDetailsModel.CurrentServiceStatus, actualSubDetailsModel.CurrentServiceStatus, "CurrentServiceStatus does not match");
Assert.IsTrue(actualSubDetailsModel.ServiceStatusDisplay.Contains("Enabled"), "ServiceStatusDisplay does not match");
}
catch (System.Exception ex)
{
Assert.IsTrue(ex is AssertFailedException, ex.ToString());
throw;
}
finally
{
DataHelper.DeleteSubscriber(sub.ID);
DataHelper.DeleteLocation(loc.ID);
}
}
public void LoadLocationValidLocId()
{
var loc = new LocationDto();
var sub = new SubscriberDto();
try
{
// new sub and loc data
loc = DataHelper.NewLocationData();
sub = DataHelper.NewSubscriberData();
sub.Accounts[0].Location = loc;
sub.CustomFields = DataHelper.DefaultCustomFields_Sub();
DataHelper.RestoreLocation1(loc, false);
DataHelper.RestoreSubscriber1(sub, false);
// set current subscriber
CurrentSubscriber.SetInstance(sub);
// call LoadLocation action method
var result = SubscriberControllerForTests.LoadLocation(loc.ID) as RedirectToRouteResult;
// validate response result is not null
Assert.IsNotNull(result, "RedirectToRouteResult is null");
// validate the returned RouteValues
Assert.IsNotNull(result.RouteValues, "RouteValues is null");
var routeValues = result.RouteValues;
Assert.AreEqual(2, routeValues.Count);
Assert.AreEqual("Index", routeValues["action"], "Action does not match");
Assert.AreEqual(sub.ID, routeValues["subID"], "Subscriber ID does not match");
}
catch (System.Exception ex)
{
Assert.IsTrue(ex is AssertFailedException, ex.ToString());
throw;
}
finally
{
DataHelper.DeleteSubscriber(sub.ID);
DataHelper.DeleteLocation(loc.ID);
}
}
public void Initialize()
{
testDPIService = getTestDPIServices();
testBillingData = getTestBillingData();
testProvisionData = getTestProvisionData();
}
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");
}
}
public void UpdateMaxBandwidth_ValidateUserAbleToUpdateMaxBandwidth()
{
var loc = new LocationDto();
var sub = new SubscriberDto();
try
{
// Given a user that has permission to update provisioned location
// And a valid subscriber
sub = DataHelper.NewSubscriberData();
sub.CustomFields = DataHelper.DefaultCustomFields_Sub();
// And the subscriber has a valid provisioned location
// And the provisioned location has a valid max bandwidth
loc = DataHelper.NewLocationData();
loc.MaximumBandwidth = "19";
sub.Accounts[0].Location = loc;
DataHelper.RestoreLocation1(loc, false);
DataHelper.RestoreSubscriber1(sub, false);
CurrentSubscriber.SetInstance(sub);
// And the user edits the max bandwidth to a new valid value
const string newMaximumBandwidth = "55";
loc.MaximumBandwidth = newMaximumBandwidth;
// When updating max bandwith for the subscriber
var result = ServicesControllerForTests.UpdateMaxBandwidth(loc.ID, loc.MaximumBandwidth) as JsonResult;
// Then the user receives a response
Assert.IsNotNull(result, "Json result is null");
Assert.IsNotNull(result.Data, "Json result data is null");
// And the response is successful
var jss = new JavaScriptSerializer();
var expectedResult = new
{
status = "valid",
message = string.Format("Successfully updated Max Bandwidth to {0} MB", newMaximumBandwidth)
}.ToJSON();
Assert.AreEqual(jss.Serialize(expectedResult), jss.Serialize(result.Data.ToJSON()));
// And the max bandwidth is updated in provisioning system
var actualLoc = DataHelper.LoadLocation(loc.ID);
Assert.IsNotNull(actualLoc, "Location should not be null!");
Assert.AreEqual(loc.ID, actualLoc.ID, "Location ID does not match!");
Assert.AreEqual(loc.MaximumBandwidth, actualLoc.MaximumBandwidth, "MaximumBandwidth does not match");
// And any other info on the location remains unchanges
Assert.AreEqual(loc.AddressLine1, actualLoc.AddressLine1, "Address1 does not match");
// And the max bandwidth is updated in current subscriber session
Assert.AreEqual(newMaximumBandwidth, CurrentSubscriber.GetInstance().MaxBandwidth, "Maxbandwidth does not match");
}
catch (System.Exception ex)
{
Assert.IsTrue(ex is AssertFailedException, ex.ToString());
throw;
}
finally
{
DataHelper.DeleteSubscriber(sub.ID);
DataHelper.DeleteLocation(loc.ID);
}
}
public void Index_Action_HappyPath_With_Minimal_Subscriber_And_Location()
{
// Arrange
var loc = new LocationDto();
var sub = new SubscriberDto();
try
{
// new sub data
loc = DataHelper.NewLocationData();
sub = DataHelper.NewSubscriberData();
sub.Accounts[0].Location = loc;
sub.CustomFields = DataHelper.DefaultCustomFields_Sub();
sub.Accounts[0].ServiceEnabled = true;
sub.Accounts[0].AccountType = AccountTypeDto.Residential;
DataHelper.RestoreLocation1(loc, false);
DataHelper.RestoreSubscriber1(sub, false);
// set current subscriber
CurrentSubscriber.SetInstance(sub);
var subscriber = BusinessFacadeforTests.LoadCompositeSubscriber(sub.ID, string.Empty, RosettianUser);
// Deliberately not checking to see if subscriber.SubscriberDpi is null as this test doesn't use that data
const string strExpectedViewName = "Index2";
var expectedSubscriberModel = subscriber.MapToSubscriberModel();
// Act
var actualViewResult = SubscriberControllerForTests.Index(sub.ID) as ViewResult;
// Assert
Assert.IsNotNull(actualViewResult, "SubscriberControllerForTests.Index returned null");
Assert.AreEqual(strExpectedViewName, actualViewResult.ViewName, "ViewName");
// 2nd Act
var actualSubscriberModel = (SubscriberModel) actualViewResult.Model;
// 2nd Assert
Assert.IsNotNull(actualSubscriberModel,
"Index_Action_HappyPath_With_Minimal_Subscriber_And_Location - unexpected model type");
const string successCode = "200";
Assert.AreEqual(successCode, actualSubscriberModel.ActionResponse.Code,
"Code was expected to be {0} but was {1} - error message was {2}", successCode,
actualSubscriberModel.ActionResponse.Code, actualSubscriberModel.ActionResponse.Message);
var jss = new JavaScriptSerializer();
var expectedJssSerialization = jss.Serialize(expectedSubscriberModel.SubDetailsModel);
var actualJssSerialization = jss.Serialize(actualSubscriberModel.SubDetailsModel);
Assert.AreEqual(expectedJssSerialization, actualJssSerialization);
}
catch (System.Exception ex)
{
var exceptionHelper = new ExceptionHelper();
Assert.Fail(exceptionHelper.GetAllInnerExceptionMessagesAndStackTraceForTests(ex));
}
finally
{
DataHelper.DeleteSubscriber(sub.ID);
DataHelper.DeleteLocation(loc.ID);
}
}
/// <summary>
/// RestoreSubscriber1 - calls either Rosettian CreateSubscriber or UpdateSubscriber
/// </summary>
/// <param name="sub"></param>
/// <param name="requiresUpdates"></param>
public static void RestoreSubscriber1(SubscriberDto sub, bool requiresUpdates)
{
using (var client = new RosettianClient())
{
if (!client.SubscriberExists(sub.ID, user))
{
client.CreateSubscriber(sub, user);
}
else if (requiresUpdates)
{
client.UpdateSubscriber(sub, true, user);
}
}
}
public void UpdateSubID_SubNotFoundInDPI_ValidateSuccessScenario()
{
var loc = new LocationDto();
var sub = new SubscriberDto();
// newSubId
var newSubId = DateTime.Now.ToString("MMddssff");
newSubId += new Random().Next(1000, 9999);
try
{
// new sub data
loc = DataHelper.NewLocationData();
sub = DataHelper.NewSubscriberData();
sub.Accounts[0].Location = loc;
sub.CustomFields = DataHelper.DefaultCustomFields_Sub();
sub.Accounts[0].ServiceEnabled = true;
DataHelper.RestoreLocation1(loc, false);
DataHelper.RestoreSubscriber1(sub, false);
// set current subscriber
CurrentSubscriber.SetInstance(sub);
var updateSubIdModel = new UpdateSubIDModel
{
OldSubID = sub.ID,
NewSubID = newSubId
};
// call UpdateSubID action method
var result = SubscriberControllerForTests.UpdateSubID(updateSubIdModel) as JsonResult;
// expected subDetailsModel after UpdateSubID
var subDetailsModel = sub.MapToSubDetailsModel();
subDetailsModel.USI = newSubId;
// validate response result
Assert.IsNotNull(result, "Json result is null");
Assert.IsNotNull(result.Data, "Json result data is null");
dynamic resultStatus = result.Data;
Assert.AreEqual("valid", resultStatus.status as string, "Response status does not match!");
// validate subID changed in db
var actualSub = DataHelper.LoadSubscriber(newSubId);
Assert.IsNotNull(actualSub, "Subscriber should not be null!");
Assert.AreEqual(newSubId, actualSub.ID);
Assert.AreEqual(sub.Name, actualSub.Name);
// validate the current subscriber session got updated
var currentSubscriber = CurrentSubscriber.GetInstance();
var actualSubDetailsModel = currentSubscriber.MapToSubDetailsModel();
// validate FoundInBilling should be false
Assert.IsFalse(actualSubDetailsModel.FoundInBilling, "FoundInBilling should be false");
// validate actualSubDetailsModel matches expectedSubDetailsModel
Assert.AreEqual(subDetailsModel.USI, actualSubDetailsModel.USI, "USI does not match");
sub.ID = actualSubDetailsModel.USI;
Assert.AreEqual(subDetailsModel.Name, actualSubDetailsModel.Name, "Name does not match");
Assert.AreEqual(subDetailsModel.FoundInBilling, actualSubDetailsModel.FoundInBilling, "FoundInBilling does not match");
Assert.AreEqual(subDetailsModel.CurrentServiceStatus, actualSubDetailsModel.CurrentServiceStatus, "CurrentServiceStatus does not match");
Assert.IsTrue(actualSubDetailsModel.ServiceStatusDisplay.Contains("Enabled"), "ServiceStatusDisplay does not match");
}
catch (System.Exception ex)
{
Assert.IsTrue(ex is AssertFailedException, ex.ToString());
throw;
}
finally
{
// delete sub.ID in case UpdateSubID failed
DataHelper.DeleteSubscriber(sub.ID);
// delete newSubId if UpdateSubID succeed
DataHelper.DeleteSubscriber(newSubId);
// delete location
DataHelper.DeleteLocation(loc.ID);
}
}
public void LoadEquipment_EquipmentHasSubscriber_ValidateUserAbleToLoadEquipment()
{
using (ShimsContext.Create())
{
// Given a user
ShimCurrentUser.AsUserDto = () => new SIMPLTestContext().GetFakeUserDtoObject();
// And a subscriber
const string subId = "subId";
// And the subscriber has a valid provisioned location
const string locId = "locId";
var location = new LocationDto {ID = locId};
// And the location has a valid equipment
const string equipId = "equipId";
var equip = new EquipmentCollectionDto
{
new EquipmentDto
{
AssociatedSubscriberId = subId,
LocationId = locId,
SerialNumber = equipId
}
};
var subscriber = new SubscriberDto
{
ID = subId,
Accounts = new List<AccountDto>
{
new AccountDto
{
Location = location,
Equipment = equip
}
}
};
// When loading that equipment
ShimRosettianClient.AllInstances.SearchSubscribersSearchFieldsDtoUserDto
= (myTestClient, mySearchCriteria, myUserDto) => new List<SubscriberDto> { subscriber };
ShimRosettianClient.AllInstances.SearchLocationsSearchFieldsDtoUserDto =
(myTestClient, mySearchCriteria, myUserDto) => new LocationCollectionDto {location};
var actionResponse = SubscriberControllerForTests.LoadEquipment(equipId) as RedirectToRouteResult;
// Then the user receives a response
Assert.IsNotNull(actionResponse, "SubscriberController LoadEquipment method returned null");
// And the response is successful
// And the response redirects the route values correctly to subscriber index
var jss = new JavaScriptSerializer();
var expectedRouteValues = new RouteValueDictionary
{
{"subID", subId},
{"devID", equipId},
{"action", "Index"},
};
var actualRouteValues = actionResponse.RouteValues;
Assert.AreEqual(jss.Serialize(expectedRouteValues), jss.Serialize(actualRouteValues));
}
}
public void UpdateSubscriber_UpdateName_UpdateCBR_UpdateTriadEmail_UpdateAccountType_ValidateSuccessScenario()
{
var loc = new LocationDto();
var sub = new SubscriberDto();
try
{
// Given a user
// And a subscriber
sub = DataHelper.NewSubscriberData();
sub.CustomFields = DataHelper.DefaultCustomFields_Sub();
// And the subscriber has a residential account
sub.Accounts[0].AccountType = AccountTypeDto.Residential;
// And the subscriber has service enabled
sub.Accounts[0].ServiceEnabled = true;
// And the subscriber has a location
loc = DataHelper.NewLocationData();
sub.Accounts[0].Location = loc;
// And the location is a valid provisioning location
DataHelper.RestoreLocation1(loc, false);
// And the subscriber is a valid provisioning subscriber
DataHelper.RestoreSubscriber1(sub, false);
// And the subscriber to be updated
CurrentSubscriber.SetInstance(sub);
var subDetailsModel = sub.MapToSubDetailsModel();
// And the subscriber name needs to be changed on the provisioned account
subDetailsModel.Name += " UPDATED";
// And the subscriber cbr needs to be changed on the provisioned account
subDetailsModel.CBR = new string(sub.SubContactPhone.Reverse().ToArray());
// And the subscriber triad email needs to be changed on the provisioned account
subDetailsModel.TriadEmail = sub.SubContactEmail + ".updated";
// And the subscriber account type needs to be changed on the provisioned account
subDetailsModel.AccountType = AccountTypeDto.Business;
// When updating the subscriber
var result = SubscriberControllerForTests.UpdateSubscriber(subDetailsModel) as JsonResult;
// Then the user receives a response
Assert.IsNotNull(result, "Json result is null");
Assert.IsNotNull(result.Data, "Json result data is null");
// And the response is successful
dynamic resultStatus = result.Data;
Assert.AreEqual("valid", resultStatus.status as string, "Response status does not match!");
// And the subscriber details in current subscriber session is updated properly
var currentSubscriber = CurrentSubscriber.GetInstance();
var actualSubDetailsModel = currentSubscriber.MapToSubDetailsModel();
// And the USI remains unchanged in current subscriber session
Assert.AreEqual(subDetailsModel.USI, actualSubDetailsModel.USI, "USI does not match");
// And the subscriber name is updated in current subscriber session
Assert.AreEqual(subDetailsModel.Name, actualSubDetailsModel.Name, "Name does not match");
// And the subscriber account type is updated in current subscriber session
Assert.AreEqual(subDetailsModel.AccountType, actualSubDetailsModel.AccountType, "AccountType does not match");
// And the subscriber cbr is updated in current subscriber session
Assert.AreEqual(subDetailsModel.CBR, actualSubDetailsModel.CBR, "CBR does not match");
// And the subscriber triad email is updated in current subscriber session
Assert.AreEqual(subDetailsModel.TriadEmail, actualSubDetailsModel.TriadEmail, true, "TriadEmail does not match");
// And the FoundInBilling flag remains unchanged in current subscriber session
Assert.AreEqual(subDetailsModel.FoundInBilling, actualSubDetailsModel.FoundInBilling, "FoundInBilling does not match");
// And the CurrentServiceStatus remains unchanged in current subscriber session
Assert.AreEqual(subDetailsModel.CurrentServiceStatus, actualSubDetailsModel.CurrentServiceStatus, "CurrentServiceStatus does not match");
// And the ServiceStatusDisplay remains unchanged in current subscriber session
Assert.IsTrue(actualSubDetailsModel.ServiceStatusDisplay.Contains("Enabled"), "ServiceStatusDisplay does not match");
// And Load updated subscriber
var actualSubscriber = DataHelper.LoadSubscriber(sub.ID);
Assert.IsTrue(actualSubscriber != null);
Assert.AreEqual(subDetailsModel.USI, actualSubscriber.ID, "Subscriber id does not match");
Assert.IsTrue(actualSubscriber.Accounts != null && actualSubscriber.Accounts.FirstOrDefault() != null);
// And the subscriber name is updated in provisioning system (triad)
Assert.AreEqual(subDetailsModel.Name, actualSubscriber.Name, "Name does not match");
// And the subscriber account type is updated in provisioning system (triad)
Assert.AreEqual(subDetailsModel.AccountType, actualSubscriber.Accounts.First().AccountType, "AccountType does not match");
// And the subscriber CBR is updated in provisioning system (triad)
Assert.AreEqual(subDetailsModel.CBR, actualSubscriber.SubContactPhone, "CBR does not match");
// And the subscriber triad email is updated in provisioning system (triad)
Assert.AreEqual(subDetailsModel.TriadEmail, actualSubscriber.SubContactEmail, true, "TriadEmail does not match");
}
catch (System.Exception ex)
{
Assert.IsTrue(ex is AssertFailedException, ex.ToString());
throw;
}
finally
{
DataHelper.DeleteSubscriber(sub.ID);
DataHelper.DeleteLocation(loc.ID);
}
}
/// <summary>
/// NewSubscriberData - dynamically creates a SubscriberDto
/// </summary>
/// <returns></returns>
public static SubscriberDto NewSubscriberData()
{
var controlNum = DateTime.Now.ToString("MMddssfff");
controlNum += random.Next(1000, 9999);
var sub = new SubscriberDto();
var acct = new AccountDto();
sub.Accounts = new List<AccountDto> { acct };
sub.ID = string.Format("TEST{0}", controlNum);
sub.Name = string.Format("{0} NAME", sub.ID);
sub.SubContactPhone = DateTime.Now.ToString("hhmmssfff") + random.Next(0, 9);
sub.SubContactEmail = string.Format("Test{0}@test.com", controlNum);
acct.PIN = controlNum.Substring(6, 4);
acct.PinRequired = true;
acct.ServiceEnabled = false;
acct.PPVEnabled = false;
acct.PPVPrivilege = "2";
acct.PPVResetDay = "15";
acct.PPVCap = "150.00";
return sub;
}
public void CreateSubscriber_With_BasicInfo_ContactPhone_Email_Pin_PPV_AccountType_ValidateUserAbleToCreateNewSubscriber()
{
var sub = new SubscriberDto();
try
{
// Given a user that has permission to create new subscriber
// And a new subscriber with all valid info
// And the new subscriber has a valid id
// And the new subscriber has a valid name
// And the new subscriber has a valid cbr
// And the new subscriber has a valid email
// And the new subscriber has a valid pin
sub = DataHelper.NewSubscriberData();
// And the new subscriber has a residential account
Assert.IsTrue(!string.IsNullOrWhiteSpace(sub.ID) && sub.Accounts != null && sub.Accounts.Any());
sub.Accounts.First().AccountType = AccountTypeDto.Residential;
// And the new subscriber has ppv settings
Assert.AreEqual("2", sub.Accounts.First().PPVPrivilege);
var createSubModel = new CreateSubscriberModel
{
USI = sub.ID,
Name = sub.Name,
AccountType = sub.Accounts.First().AccountType,
ServiceEnabled = false,
CBR = sub.SubContactPhone,
Email = sub.SubContactEmail,
PIN = sub.Accounts.First().PIN,
PPVCap = sub.Accounts.First().PPVCap,
PPVResetDay = sub.Accounts.First().PPVResetDay,
PPVPrivilege = SubscriberEnums.PPVPrivilegeEnum.Capped
};
// When creating new subscriber with the valid subscriber info
var result = SearchControllerForTest.CreateSubscriber(createSubModel) as JsonResult;
// Then the user receives a response
Assert.IsNotNull(result, "CreateSubscriber json result is null");
Assert.IsNotNull(result.Data, "CreateSubscriber json result data is null");
// And the response is successful
var jss = new JavaScriptSerializer();
var expectedResult = new
{
status = "valid",
isModal = false,
newSubscriberID = sub.ID
}.ToJSON();
Assert.AreEqual(jss.Serialize(expectedResult), jss.Serialize(result.Data.ToJSON()));
// And the new subscriber created in provisioning system
var actualSub = DataHelper.LoadSubscriber(sub.ID);
Assert.IsTrue(actualSub != null && actualSub.Accounts != null && actualSub.Accounts.Any(), "Subscriber account is null");
// And the new subscriber created with the requested id
Assert.AreEqual(sub.ID, actualSub.ID, "Id does not match");
// And the new subscriber created with the requested name
Assert.AreEqual(sub.Name, actualSub.Name, "Name does not match");
// And the new subscriber created with the requested cbr
Assert.AreEqual(sub.SubContactPhone, actualSub.SubContactPhone, "SubContactPhone does not match");
// And the new subscriber created with the requested email
Assert.AreEqual(sub.SubContactEmail, actualSub.SubContactEmail, "SubContactEmail does not match");
// And the new subscriber created with the requested pin
Assert.AreEqual(sub.Accounts.First().PIN, actualSub.Accounts.First().PIN, "PIN does not match");
// And the new subscriber created with the requested ppv settings
Assert.AreEqual(sub.Accounts.First().PPVCap, actualSub.Accounts.First().PPVCap, "PPVCap does not match");
Assert.AreEqual(sub.Accounts.First().PPVPrivilege, actualSub.Accounts.First().PPVPrivilege, "PPVPrivilege does not match");
Assert.AreEqual(sub.Accounts.First().PPVResetDay, actualSub.Accounts.First().PPVResetDay, "PPVPrivilege does not match");
// And the new subscriber created with the requested account type
Assert.AreEqual(sub.Accounts.First().AccountType, actualSub.Accounts.First().AccountType, "Account type does not match");
}
catch (Exception ex)
{
Assert.IsTrue(ex is AssertFailedException, ex.ToString());
throw;
}
finally
{
DataHelper.DeleteSubscriber(sub.ID);
}
}
/// <summary>
/// RestoreSubscriber - returns SubscriberDto - calls either Rosettian CreateSubscriber or UpdateSubscriber
/// </summary>
/// <param name="sub"></param>
/// <returns></returns>
protected static SubscriberDto RestoreSubscriber(SubscriberDto sub)
{
using (var client = new RosettianClient())
{
if (!client.SubscriberExists(sub.ID, user))
{
if (sub.Accounts != null && sub.Accounts.Count > 1 && sub.Accounts[0].ServiceEnabled == true)
{
sub.Accounts[0].ServiceEnabled = false;
}
client.CreateSubscriber(sub, user);
}
else
{
client.UpdateSubscriber(sub, true, user);
}
if (sub.Accounts != null && sub.Accounts.Count > 0)
{
var serviceProfiles = sub.Accounts[0].ServiceProfiles;
if (serviceProfiles != null && serviceProfiles.Count > 0)
{
var expectedPhones = ((VoiceServiceProfileDto)serviceProfiles[0]).PhoneLines;
RestorePhone(sub.ID, expectedPhones);
}
}
return sub;
}
}
