public void InvalidModelStateWhenEditingClientDoesntEditClients()
{
var clientRepositoryMoq = new Mock <IRepository <Client> >();
var consultantRepository = new LocalRepository <InsideUser>();
var userManager = new Mock <IIdentityMembershipProvider>();
var labelRepository = new LocalRepository <Label>();
var consultant = new InsideUser()
{
Id = "Id1"
};
//consultantRepositoryMoq.Setup(m => m.All()).Returns(consultants.AsQueryable);
consultantRepository.Add(consultant);
var clientController = new ClientController(clientRepositoryMoq.Object, labelRepository, consultantRepository, userManager.Object);
var clientToEdit = ModelHelper.TestClient1AllDataNoReferences;
clientToEdit.ConsultantId = "Id1";
clientToEdit.Consultant = consultant;
clientToEdit.Consultant.Role = new Collection <InsideRole> {
ModelHelper.TestConsultantRole
};
var clientViewModel = new ClientViewModel(clientToEdit);
var clilientPageViewModel = new ClientPageViewModel(new List <string>(), clientViewModel);
clientController.ModelState.AddModelError("key", "error message");
var result = clientController.Edit(clilientPageViewModel) as ViewResult;
//var consultants = result.ViewBag.Consultant as SelectList;
Assert.AreEqual(1 + 1, clilientPageViewModel.Consultant.Count(), "+1 is for not to count Null consultant");
clientRepositoryMoq.Verify(r => r.Attach(It.IsAny <Client>()), Times.Never());
}
public void CanCreateNewClientWithRespectedConsultant()
{
var clientRepositoryMoq = new Mock <IRepository <Client> >();
var consultantRepository = new LocalRepository <InsideUser>();
var userManager = new Mock <IIdentityMembershipProvider>();
var labelRepository = new LocalRepository <Label>();
var consultant = new InsideUser()
{
Id = "Id1"
};
consultantRepository.Add(consultant);
var clientController = new ClientController(clientRepositoryMoq.Object, labelRepository, consultantRepository, userManager.Object);
var clientToCreate = ModelHelper.TestClient1AllDataNoReferences;
clientToCreate.ConsultantId = "Id1";
clientToCreate.Consultant = consultant;
var clientViewModel = new ClientViewModel(clientToCreate);
var clilientPageViewModel = new ClientPageLoggedViewModel(new List <string>(), clientViewModel);
var result = clientController.Create(clilientPageViewModel);
Assert.IsTrue(clientController.ViewData.ModelState.Count == 0, "Excpected no validation errors.");
clientRepositoryMoq.Verify(r => r.Add(It.IsAny <Client>()), "Expected client add");
clientRepositoryMoq.Verify(r => r.SaveChanges(), "Expected call to save changes");
Assert.IsInstanceOfType(result, typeof(RedirectToRouteResult), "Expected redirection reslut");
}
public ActionResult Create(UserViewModel user)
{
if (user.Password == null)
{
ModelState.AddModelError("password", "Saknade lösenord.");
return(Create(user.ClientId));
}
var newUser = new InsideUser
{
Email = user.Name,
ClientId = user.ClientId,
ReceiveEmail = user.ReceiveEmail,
ReceiveSms = user.ReceiveSms,
UserName = user.Name,
Phone = user.Phone,
IsLockedOut = user.IsLockedOut
};
var newUserMembershipSuccess = userManager.Create(newUser, user.Password);
if (newUserMembershipSuccess)
{
userManager.AddToRole(newUser.Id, "client");
}
else
{
ModelState.AddModelError("name", "Misslyckades skapa användare.");
return(Create(user.ClientId));
}
return(RedirectToAction("List", new { clientId = user.ClientId }));
}
public UserViewModel(InsideUser user)
{
IsEditingExcisting = true;
this.IsLockedOut = user.IsLockedOut;
this.Name = user.Email;
this.Phone = user.Phone;
this.Id = user.Id;
if (user.ReceiveEmail.HasValue)
{
this.ReceiveEmail = user.ReceiveEmail.Value;
}
else
{
this.ReceiveEmail = false;
}
if (user.ReceiveSms.HasValue)
{
this.ReceiveSms = user.ReceiveSms.Value;
}
else
{
this.ReceiveSms = false;
}
if (user.Client != null)
{
ClientId = user.Client.Id;
ClientName = user.Client.Name;
}
}
public void ValidateExistingAndNotExistingToken()
{
var tokenRepository = new LocalRepository <Token>();
var userRepository = new Mock <IRepository <InsideUser> >();
var provider = new AccessTokenProvider(tokenRepository, userRepository.Object);
var client = new Client()
{
Id = 1
};
var user = new InsideUser()
{
Id = "Id2",
ClientId = client.Id,
Client = client
};
var validToken = new Token()
{
Id = 2,
UserId = user.Id,
AccessToken = "Some Random Generated String 2",
ExpirationDate = DateTime.Today.AddDays(1),
InsideUser = user
};
tokenRepository.Add(validToken);
var validResult = provider.Validate((int)validToken.InsideUser.ClientId, validToken.AccessToken);
var inValidResult = provider.Validate((int)validToken.InsideUser.ClientId, "Some Invalid Random String");
Assert.IsTrue(validResult);
Assert.IsFalse(inValidResult);
}
private void SignIn(InsideUser user, bool isPersistent)
{
AuthenticationManager.SignOut(DefaultAuthenticationTypes.ExternalCookie);
var identity = userManager.CreateIdentity(user);
AuthenticationManager.SignIn(new AuthenticationProperties()
{
IsPersistent = isPersistent
}, identity);
}
public void ShowOnlyActiveClientsOfCertainConsultant()
{
var clientRepository = new LocalRepository <Client>();
var clientInRepository1 = ModelHelper.TestClient1AllDataNoReferences;
var clientInRepository2 = ModelHelper.TestClient2AllDataNoReferences;
var consultantMembershipProviderId1 = Guid.NewGuid().ToString();
var consultantMembershipProviderId2 = Guid.NewGuid().ToString();
var userManager = new Mock <IIdentityMembershipProvider>();
var consultantRepository = new LocalRepository <InsideUser>();
var labelRepository = new LocalRepository <Label>();
var consultant1 = new InsideUser()
{
Id = consultantMembershipProviderId1,
Role = new Collection <InsideRole> {
ModelHelper.TestConsultantRole
}
};
clientInRepository1.IsActive = true;
clientInRepository1.ConsultantId = consultant1.Id;
clientInRepository1.Consultant = consultant1;
consultantRepository.Add(consultant1);
clientRepository.Add(clientInRepository1);
var consultant2 = new InsideUser()
{
Id = consultantMembershipProviderId2
};
consultantRepository.Add(consultant2);
clientInRepository2.IsActive = true;
clientInRepository2.ConsultantId = consultant2.Id;
clientInRepository2.Consultant = consultant2;
clientRepository.Add(clientInRepository2);
userManager.Setup(um => um.GetRoles(consultant1.Id)).Returns(new List <string> {
"consultant"
});
var clientController = new ClientController(clientRepository, labelRepository, consultantRepository, userManager.Object);
var claim = new Claim("test", consultant1.Id);
ModelHelper.SetClaimAsCurrentUserForController(claim, clientController);
var result = clientController.Index(false, null) as ViewResult;
var clients = result.Model as ClientsViewModel;
Assert.AreEqual(1, clients.Clients.Count());
}
public void ThrowsExceptionIfCurrentUserDoesNotHaveAccess()
{
var contactRepository = new LocalRepository <Contact>();
var userRepository = new LocalRepository <InsideUser>();
var emailSender = new Mock <IEmailSender>();
var serverTime = new ServerTime();
var client = new Client();
client.Name = "Kund";
client.Id = 8;
var client2 = new Client();
client2.Name = "Kund 2";
client2.Id = 18;
var contact = new Contact();
contact.LeadType = "Chat";
contact.Id = 14;
contact.Date = new DateTime(2014, 6, 13, 14, 22, 9);
contact.Client = client;
contact.ClientId = 8;
var currentUser = new InsideUser();
currentUser.Email = "*****@*****.**";
currentUser.Name = "Linus Lind";
currentUser.Id = "currentUserId";
currentUser.Client = client2;
currentUser.ClientId = 18;
contactRepository.Add(contact);
userRepository.Add(currentUser);
var controller = new SocialController(
contactRepository,
userRepository,
emailSender.Object,
serverTime);
GenericIdentity genericIdentity = new GenericIdentity("user");
genericIdentity.AddClaim(new Claim(ClaimTypes.NameIdentifier, "currentUserId"));
controller.User = new ClaimsPrincipal(
new GenericPrincipal(genericIdentity, null));
var results = controller.SendContact(14, "*****@*****.**", "08 123 456", "Message\non two rows") as UnauthorizedResult;
Assert.IsInstanceOfType(results, typeof(UnauthorizedResult));
}
public void EmailAddressInBadFormatDoesntCreateDefenitionThrowsException()
{
var contactRepository = new LocalRepository <Contact>();
var adminRepository = new LocalRepository <InsideUser>();
var accessTokenProvider = new Mock <IAccessTokenProvider>();
var contact = new Contact()
{
Id = 1,
Date = new DateTime(2014, 01, 01),
LeadType = "Phone",
ClientId = 1
};
var client = ModelHelper.TestClient1AllDataNoReferences;
contact.Client = client;
var guidId = Guid.NewGuid();
var insideUser = new InsideUser()
{
Id = guidId.ToString(),
ReceiveEmail = true,
Email = "badFormatEmail"
};
contact.Client.InsideUserSets = new Collection <InsideUser>();
contact.Client.InsideUserSets.Add(insideUser);
contactRepository.Add(contact);
var role = new InsideRole()
{
Name = "consultant"
};
//adminRepository.Setup(ar=>ar.Where(a=>a.ConsultantsForClients.Any(c=>c.Id==client.Id)).Single()).Returns(new Admin(){AdminRole = "Consultant"});
adminRepository.Add(new InsideUser()
{
Role = new Collection <InsideRole> {
role
},
ConsultantsForClients = new Collection <Client> {
client
}
});
var newContactDefinitionBuilder = new NotificationEmailDefenitionBuilder(
adminRepository,
contactRepository,
accessTokenProvider.Object
);
var result = newContactDefinitionBuilder.GetDefinition(contact.Id, insideUser.Id);
Assert.IsNull(result);
}
public void IsAddingLabelsToModel()
{
var labelRepository = new LocalRepository <Label>();
labelRepository.Add(new Label()
{
Id = 1, Name = "Label 1"
});
labelRepository.Add(new Label()
{
Id = 2, Name = "Label 2"
});
var clientRepository = new LocalRepository <Client>();
var clientInRepository = ModelHelper.TestClient1AllDataNoReferences;
var consultantMembershipProviderId = Guid.NewGuid().ToString();
var userManager = new Mock <IIdentityMembershipProvider>();
var consultantRepository = new LocalRepository <InsideUser>();
var consultant = new InsideUser()
{
Id = consultantMembershipProviderId,
Role = new Collection <InsideRole> {
ModelHelper.TestConsultantRole
}
};
consultantRepository.Add(consultant);
clientInRepository.IsActive = false;
clientInRepository.Consultant = consultant;
clientRepository.Add(clientInRepository);
userManager.Setup(um => um.GetRoles(consultant.Id)).Returns(new List <string> {
"mockRole"
});
var clientController = new ClientController(clientRepository, labelRepository, consultantRepository, userManager.Object);
var claim = new Claim("test", consultant.Id);
ModelHelper.SetClaimAsCurrentUserForController(claim, clientController);
var result = clientController.Index(true, null) as ViewResult;
var resultModel = result.Model as ClientsViewModel;
Assert.AreEqual(2, resultModel.Labels.Count());
Assert.IsTrue(resultModel.Labels.Any(l => l.Name == "Label 1" && l.Id == 1));
Assert.IsTrue(resultModel.Labels.Any(l => l.Name == "Label 2" && l.Id == 2));
}
public void CanGetAccessToken()
{
var userRepository = new LocalRepository <InsideUser>();
var contactRepository = new Mock <IRepository <Contact> >();
var userManager = new Mock <IIdentityMembershipProvider>();
var tokenGenerator = new Mock <IAccessTokenProvider>();
var budgetRepositoryMock = new Mock <IRepository <Budget> >();
var clientRepositoryMock = new Mock <IRepository <Client> >();
var serverTimeMock = new Mock <IServerTime>();
var username = "******";
var password = "******";
var membershipProviderId = new Guid();
var memebershipUser = new Mock <MembershipUser>();
memebershipUser.Setup(mu => mu.ProviderUserKey).Returns(membershipProviderId);
var userInRepository = new InsideUser()
{
UserId = 1,
ClientId = 1,
Id = membershipProviderId.ToString()
};
userRepository.Add(userInRepository);
userManager.Setup(mp => mp.ValidateAndReturnUser(username, password)).Returns(userInRepository);
tokenGenerator.Setup(tg => tg.GetToken(It.IsAny <string>())).Returns(new Token()
{
AccessToken = "TokenGenerated"
});
var controller = new ExternalController(
userRepository,
contactRepository.Object,
tokenGenerator.Object,
userManager.Object,
budgetRepositoryMock.Object,
clientRepositoryMock.Object,
serverTimeMock.Object);
var result = controller.GetAccessToken(username, password) as OkNegotiatedContentResult <AcccessTokenForClient>;
Assert.AreEqual("TokenGenerated", result.Content.AccessToken);
}
public void IndexReturnsmultipleItems()
{
var adminRepository = new LocalRepository <InsideUser>();
var userManager = new Mock <IIdentityMembershipProvider>();
var claim = new Claim("test", "AnyId");
userManager.Setup(um => um.GetRoles(It.IsAny <string>())).Returns(new List <string> {
"mockRole"
});
var controller = new AccountManagerController(adminRepository, userManager.Object);
ModelHelper.SetClaimAsCurrentUserForController(claim, controller);
var adminInRepository1 = new InsideUser()
{
Role = new Collection <InsideRole> {
ModelHelper.TestSalesRole
},
Id = "Id1",
Name = "Test Admin 1"
};
var adminInRepository2 = new InsideUser()
{
Role = new Collection <InsideRole> {
ModelHelper.TestSalesRole
},
Id = "Id2",
Name = "Test Admin 2"
};
adminRepository.Add(adminInRepository1);
adminRepository.Add(adminInRepository2);
userManager.Setup(um => um.GetUsers()).Returns(adminRepository.All());
var result = controller.Index() as ViewResult;
var model = result.Model as AccountManagerListViewModel;
Assert.AreEqual(2, model.Collection.Count);
Assert.AreEqual("Test Admin 1", model.Collection.Single(a => a.Id == "Id1").Name);
Assert.AreEqual("Test Admin 2", model.Collection.Single(a => a.Id == "Id2").Name);
}
public ActionResult Create(AccountManagerViewModel admin)
{
if (String.IsNullOrEmpty(admin.Password))
{
ModelState.AddModelError("password", "Ange lösenord");
}
if (!ModelState.IsValid)
{
return(View(admin));
}
try
{
var newAccountManager = new InsideUser
{
Email = admin.Email,
UserName = admin.Email,
/*LoweredUserName = admin.Name.ToLower(),*/
Name = admin.Name,
ImageUrl = admin.ImageUrl,
Phone = admin.Phone
};
var newUserCreateSuccess = userManager.Create(newAccountManager, admin.Password);
if (newUserCreateSuccess)
{
userManager.AddToRole(newAccountManager.Id, "sales");
}
else
{
ModelState.AddModelError("Email", "Kontoansvarig finns redan.");
return(View(admin));
}
/* adminRepository.Add(newAccountManager);
* adminRepository.SaveChanges();*/
return(RedirectToAction("Index"));
}
catch (Exception e)
{
ModelState.AddModelError("Email", "Kontoansvarig finns redan.");
return(View(admin));
}
}
public void ShowOnlyInActiveClients()
{
var clientRepository = new LocalRepository <Client>();
var clientInRepository = ModelHelper.TestClient1AllDataNoReferences;
var activeClientInDb = ModelHelper.TestClient1AllDataNoReferences;
var consultantMembershipProviderId = Guid.NewGuid().ToString();
var userManager = new Mock <IIdentityMembershipProvider>();
var consultantRepository = new LocalRepository <InsideUser>();
var labelRepository = new LocalRepository <Label>();
var consultant = new InsideUser()
{
Id = consultantMembershipProviderId,
Role = new Collection <InsideRole> {
ModelHelper.TestConsultantRole
}
};
consultantRepository.Add(consultant);
clientInRepository.IsActive = false;
clientInRepository.Consultant = consultant;
activeClientInDb.Consultant = consultant;
clientRepository.Add(clientInRepository);
clientRepository.Add(activeClientInDb);
userManager.Setup(um => um.GetRoles(consultant.Id)).Returns(new List <string> {
"mockRole"
});
var clientController = new ClientController(clientRepository, labelRepository, consultantRepository, userManager.Object);
var claim = new Claim("test", consultant.Id);
ModelHelper.SetClaimAsCurrentUserForController(claim, clientController);
var result = clientController.Index(false, true) as ViewResult;
var clients = result.Model as ClientsViewModel;
Assert.AreEqual(1, clients.Clients.Count());
}
public void BadAccessTokenReturnsNotAutorized()
{
var userRepository = new LocalRepository <InsideUser>();
var contactRepository = new Mock <IRepository <Contact> >();
var tokenProvider = new Mock <IAccessTokenProvider>();
var userManager = new Mock <IIdentityMembershipProvider>();
var budgetRepositoryMock = new Mock <IRepository <Budget> >();
var clientRepositoryMock = new Mock <IRepository <Client> >();
var serverTimeMock = new Mock <IServerTime>();
var controller = new ExternalController(
userRepository,
contactRepository.Object,
tokenProvider.Object,
userManager.Object,
budgetRepositoryMock.Object,
clientRepositoryMock.Object,
serverTimeMock.Object);
InsideUser testUser1 = ModelHelper.TestUser1AllDataNoReferences;
InsideUser testUser2 = ModelHelper.TestUser1AllDataNoReferences;
testUser1.Role.Add(new InsideRole()
{
Name = "consultant"
});
testUser1.Token.Add(new Token()
{
AccessToken = "abc123"
});
userRepository.Add(testUser1);
userRepository.Add(testUser2);
var result = controller.GetBudgetSummary("bad acces token");
Assert.IsInstanceOfType(result, typeof(UnauthorizedResult));
}
public void ReturnsNotFoundForMissingContact()
{
var contactRepository = new LocalRepository <Contact>();
var userRepository = new LocalRepository <InsideUser>();
var emailSender = new Mock <IEmailSender>();
var serverTime = new ServerTime();
var contact = new Contact();
contact.LeadType = "Chat";
contact.Id = 14;
contact.Date = new DateTime(2014, 6, 13, 14, 22, 9);
var currentUser = new InsideUser();
currentUser.Email = "*****@*****.**";
currentUser.Name = "Linus Lind";
currentUser.Id = "currentUserId";
contactRepository.Add(contact);
userRepository.Add(currentUser);
var controller = new SocialController(
contactRepository,
userRepository,
emailSender.Object,
serverTime);
GenericIdentity genericIdentity = new GenericIdentity("user");
genericIdentity.AddClaim(new Claim(ClaimTypes.NameIdentifier, "currentUserId"));
controller.User = new ClaimsPrincipal(
new GenericPrincipal(genericIdentity, null));
var results = controller.SendContact(15, "*****@*****.**", "08 123 456", "Message\non two rows");
Assert.IsInstanceOfType(results, typeof(NotFoundResult));
}
public void GoodAccessTokenReturnsResult()
{
var userRepository = new LocalRepository <InsideUser>();
var contactRepository = new Mock <IRepository <Contact> >();
var tokenProvider = new Mock <IAccessTokenProvider>();
var userManager = new Mock <IIdentityMembershipProvider>();
var budgetRepository = new LocalRepository <Budget>();
var clientRepository = new LocalRepository <Client>();
var serverTimeMock = new Mock <IServerTime>();
var controller = new ExternalController(
userRepository,
contactRepository.Object,
tokenProvider.Object,
userManager.Object,
budgetRepository,
clientRepository,
serverTimeMock.Object);
InsideUser testUser1 = ModelHelper.TestUser1AllDataNoReferences;
InsideUser testUser2 = ModelHelper.TestUser1AllDataNoReferences;
var client = ModelHelper.TestClient1AllDataNoReferences;
client.Labels.Add(new Label()
{
Name = "Kampanjplaneras"
});
client.Consultant = ModelHelper.TestConsultant;
var client2 = ModelHelper.TestClient2AllDataNoReferences;
client2.Consultant = ModelHelper.TestConsultant;
testUser1.Role.Add(new InsideRole()
{
Name = "consultant"
});
testUser1.Token.Add(new Token()
{
AccessToken = "good acces token"
});
userRepository.Add(testUser1);
userRepository.Add(testUser2);
var jan = new DateTime(2014, 1, 1);
var feb = new DateTime(2014, 2, 1);
var mars = new DateTime(2014, 3, 1);
serverTimeMock.Setup(s => s.RequestStarted).Returns(jan.AddDays(10));
Budget budget1 = new Budget()
{
Month = feb, Value = 1500
};;
Budget budget2 = new Budget()
{
Month = jan, Value = 2000
};
budget1.Client = client;
budget2.Client = client;
budgetRepository.Add(budget1);
budgetRepository.Add(budget2);
clientRepository.Add(client);
clientRepository.Add(client2);
client.Budgets.Add(budget1);
client.Budgets.Add(budget2);
Budget budget3 = new Budget()
{
Month = feb, Value = 1000
};
Budget budget4 = new Budget()
{
Month = jan, Value = 3000
};
client.Budgets.Add(budget3);
client.Budgets.Add(budget4);
budget3.Client = client2;
budgetRepository.Add(budget4);
budgetRepository.Add(budget3);
var result = controller.GetBudgetSummary("good acces token") as OkNegotiatedContentResult <BudgetMonthSummary>;
Assert.AreEqual(-500, result.Content.diff);
Assert.AreEqual(1, result.Content.numClients);
Assert.AreEqual(1, result.Content.TotalClients);
}
public void GetContactListReturnsContactsBasedOnPageNumber()
{
var userRepository = new Mock <IRepository <InsideUser> >();
var contactRepository = new LocalRepository <Contact>();
var userManager = new Mock <IIdentityMembershipProvider>();
var tokenGenerator = new Mock <IAccessTokenProvider>();
var budgetRepositoryMock = new Mock <IRepository <Budget> >();
var clientRepositoryMock = new Mock <IRepository <Client> >();
var serverTimeMock = new Mock <IServerTime>();
var accessToken = "AccessToken";
var insideUser = new InsideUser()
{
UserId = 1,
ClientId = 1,
};
var client = new Client()
{
Id = 1,
};
client.InsideUserSets.Add(insideUser);
var startDate = new DateTime(2014, 1, 1, 12, 0, 0);
for (int i = 1; i <= 23; i++)
{
var contact = new Contact()
{
Id = i,
ClientId = client.Id,
Client = client,
Date = startDate.AddHours(-10 * i)
};
contactRepository.Add(contact);
}
tokenGenerator.Setup(tg => tg.Validate((int)insideUser.ClientId, accessToken)).Returns(true);
var controller = new ExternalController(
userRepository.Object,
contactRepository,
tokenGenerator.Object,
userManager.Object,
budgetRepositoryMock.Object,
clientRepositoryMock.Object,
serverTimeMock.Object);
var result = controller.GetContactList((int)insideUser.ClientId, accessToken, 20, 0) as OkNegotiatedContentResult <List <Contact> >;
Assert.AreEqual(20, result.Content.Count());
Assert.AreEqual(1, result.Content.ToArray()[0].Id);
Assert.AreEqual(10, result.Content.ToArray()[9].Id);
var result2 = controller.GetContactList((int)insideUser.ClientId, accessToken, 10, 0) as OkNegotiatedContentResult <List <Contact> >;
Assert.AreEqual(10, result2.Content.Count());
Assert.AreEqual(1, result2.Content.ToArray()[0].Id);
Assert.AreEqual(10, result2.Content.ToArray()[9].Id);
var result3 = controller.GetContactList((int)insideUser.ClientId, accessToken, 10, 5) as OkNegotiatedContentResult <List <Contact> >;
Assert.AreEqual(10, result3.Content.Count());
Assert.AreEqual(6, result3.Content.ToArray()[0].Id);
Assert.AreEqual(15, result3.Content.ToArray()[9].Id);
}
public bool Update(InsideUser user)
{
return(userManager.Update(user).Succeeded);
}
public ClaimsIdentity CreateIdentity(InsideUser user)
{
return(userManager.CreateIdentity(user, DefaultAuthenticationTypes.ApplicationCookie));
}
public bool Delete(InsideUser user)
{
return(userManager.Delete(user).Succeeded);
}
public void DontCreateUserSmsTaskForExistingTaskInDatabase()
{
var generationDate = new DateTime(2013, 1, 17);
var contactRepository = new LocalRepository <Contact>();
var taskCreator = new Mock <ITaskManager>();
var client = ModelHelper.TestClient1AllDataNoReferences;
var lableForClient = new Label()
{
Id = 1,
Name = "Helloypaket"
};
var contactForUser = new Contact()
{
Id = 1
};
client.Labels = new Collection <Label>();
client.Labels.Add(lableForClient);
contactForUser.Client = client;
var insideUser = new InsideUser
{
Id = "UserId1",
ReceiveSms = true,
Phone = "0123456"
};
client.InsideUserSets = new List <InsideUser>
{
insideUser
};
contactRepository.Add(contactForUser);
var serverTime = new Mock <IServerTime>();
var taskRepository = new Mock <IRepository <InsideModel.Models.Task> >();
var taskQueueStorage = new Mock <ITaskQueueStorage>();
var newContactEmailSender = new SmsNotificationTaskPerformer(
contactRepository,
taskCreator.Object,
serverTime.Object, taskRepository.Object,
taskQueueStorage.Object);
var now = new DateTime(2013, 01, 01);
serverTime.Setup(st => st.RequestStarted).Returns(now);
var taskMessage = JsonConvert.SerializeObject(new SmsNotificationTaskMessage()
{
ContactId = contactForUser.Id
});
taskCreator.Setup(
tc =>
tc.HasTaskInRepository("{\"ContactId\":1,\"UserId\":\"UserId1\"}",
TaskType.SendNewContactSmsNotificationToUser, now, now.AddDays(1))).Returns(true);
newContactEmailSender.PerformTask(new InsideModel.Models.Task()
{
Message = taskMessage, EarliestExecution = generationDate
});
taskRepository.Verify(es => es.Add(It.IsAny <InsideModel.Models.Task>()), Times.Never);
taskQueueStorage.Verify(es => es.Add(It.IsAny <InsideModel.Models.Task>()), Times.Never);
}
public void CreateUserEmailTaskForEveryUser()
{
var generationDate = new DateTime(2013, 1, 17);
var contactRepository = new LocalRepository <Contact>();
var taskCreator = new Mock <ITaskManager>();
var client = ModelHelper.TestClient1AllDataNoReferences;
var lableForClient = new Label()
{
Id = 1,
Name = "Helloypaket"
};
var contactForUser = new Contact()
{
Id = 1
};
client.Labels = new Collection <Label>();
client.Labels.Add(lableForClient);
contactForUser.Client = client;
var insideUser = new InsideUser
{
Id = "UserId1",
ReceiveEmail = true
};
var insideUser2 = new InsideUser
{
Id = "UserId2",
ReceiveEmail = true
};
client.InsideUserSets = new List <InsideUser>
{
insideUser, insideUser2
};
contactRepository.Add(contactForUser);
var serverTime = new Mock <IServerTime>();
var taskRepository = new LocalRepository <InsideModel.Models.Task>();
var taskQueueStorage = new Mock <ITaskQueueStorage>();
var newContactEmailSender = new NotificationEmailSender(
contactRepository,
taskCreator.Object,
serverTime.Object, taskRepository,
taskQueueStorage.Object);
var now = new DateTime(2013, 01, 01);
serverTime.Setup(st => st.RequestStarted).Returns(now);
var taskMessage = JsonConvert.SerializeObject(new NotificationTaskMessage()
{
ContactId = contactForUser.Id
});
newContactEmailSender.PerformTask(new InsideModel.Models.Task()
{
Message = taskMessage, EarliestExecution = generationDate
});
taskQueueStorage.Verify(es => es.Add(It.Is <InsideModel.Models.Task>(t => t.Message == "{\"ContactId\":1,\"UserId\":\"UserId1\"}" && t.Type == "SendNewContactEmailNotificationToUser")), Times.Exactly(1));
taskQueueStorage.Verify(es => es.Add(It.Is <InsideModel.Models.Task>(t => t.Message == "{\"ContactId\":1,\"UserId\":\"UserId2\"}" && t.Type == "SendNewContactEmailNotificationToUser")), Times.Exactly(1));
}
public void GeneratesAndSendsEmail()
{
var contactRepository = new LocalRepository <Contact>();
var userRepository = new LocalRepository <InsideUser>();
var emailSender = new Mock <IEmailSender>(MockBehavior.Strict);
var serverTime = new ServerTime();
var client = new Client();
client.Name = "Kund";
client.Id = 8;
var contact = new Contact();
contact.LeadType = "Chat";
contact.Id = 14;
contact.Date = new DateTime(2014, 6, 13, 14, 22, 9);
contact.Client = client;
contact.ClientId = client.Id;
var currentUser = new InsideUser();
currentUser.Email = "*****@*****.**";
currentUser.Name = "Linus Lind";
currentUser.Id = "currentUserId";
currentUser.Client = client;
currentUser.ClientId = client.Id;
contactRepository.Add(contact);
userRepository.Add(currentUser);
var controller = new SocialController(
contactRepository,
userRepository,
emailSender.Object,
serverTime);
GenericIdentity genericIdentity = new GenericIdentity("user");
genericIdentity.AddClaim(new Claim(ClaimTypes.NameIdentifier, "currentUserId"));
controller.User = new ClaimsPrincipal(
new GenericPrincipal(genericIdentity, null));
Expression <Action <IEmailSender> > emailMatch = es => es.Send(
It.Is <EmailMessage>(
em =>
em.html.Contains(
"Linus Lind har delat en kundkontakt från Helloy med dig"
) && em.html.Contains(
"08 123 456 den 13 juni 2014 16:22"
) && em.html.Contains(
"Message<br/>on two rows"
) && em.to.Any(t => t.email == "*****@*****.**") &&
em.from_email == "*****@*****.**"
));
emailSender.Setup(emailMatch);
var sendEmail = controller.SendContact(14, "*****@*****.**", "08 123 456", "Message\non two rows");
emailSender.Verify(emailMatch, Times.Once);
}
public void CreatesValidDefintionForOkDataForPhone()
{
var contactRepository = new LocalRepository <Contact>();
var adminRepository = new LocalRepository <InsideUser>();
var accessTokenProvider = new Mock <IAccessTokenProvider>();
var contact = new Contact()
{
Id = 1,
Date = new DateTime(2014, 01, 01, 12, 30, 00),
LeadType = "Phone",
ClientId = 1
};
var contactProperty = new ContactProperty()
{
Id = 1,
ContactId = 1,
Type = "CallerNumber",
Value = "08123456"
};
var contactProperty2 = new ContactProperty()
{
Id = 2,
ContactId = 1,
Type = "Duration",
Value = "90"
};
contact.Property.Add(contactProperty);
contact.Property.Add(contactProperty2);
var clientLable = new Label()
{
Id = 1,
Name = "Helloypaket"
};
var client = ModelHelper.TestClient1AllDataNoReferences;
client.Labels.Add(clientLable);
contact.Client = client;
contact.Client.InsideUserSets = new Collection <InsideUser>();
var user1 = ModelHelper.TestUser1AllDataNoReferences;
user1.Email = "*****@*****.**";
contact.Client.InsideUserSets.Add(user1);
contactRepository.Add(contact);
var consultantInfo = new InsideUser();
consultantInfo.Email = "*****@*****.**";
consultantInfo.Name = "consultant name";
consultantInfo.Phone = "08654321";
consultantInfo.ImageUrl = "http://path.to/image.jpg";
consultantInfo.ConsultantsForClients.Add(client);
consultantInfo.Role = new Collection <InsideRole> {
ModelHelper.TestConsultantRole
};
adminRepository.Add(consultantInfo);
accessTokenProvider.Setup(at => at.GenerateAccessUrl(user1.Id, "/report/" + client.Id + "/contact/" + contact.Id)).Returns("http://inside.helloy.se/Account/AuthenticateToken?token=Aa1Bb2Cc3Dd4Ee5%26returnUrl=%2freport%2f1%2fcontact%2f1");
var newContactDefinitionBuilder = new NotificationEmailDefenitionBuilder(
adminRepository,
contactRepository,
accessTokenProvider.Object
);
var contactId = contact.Id;
var result = newContactDefinitionBuilder.GetDefinition(contactId, user1.Id);
Assert.AreEqual("2014-01-01 13:30", result.Date);
Assert.AreEqual("*****@*****.**", result.ConsultantEmail);
Assert.AreEqual("http://path.to/image.jpg", result.ConsultantImage);
Assert.AreEqual("consultant name", result.ConsultantName);
Assert.AreEqual("08654321", result.ConsultantPhone);
Assert.AreEqual("08123456", result.From);
Assert.AreEqual("http://inside.helloy.se/Account/AuthenticateToken?token=Aa1Bb2Cc3Dd4Ee5%26returnUrl=%2freport%2f1%2fcontact%2f1", result.InsideUrl);
Assert.AreEqual("1:30", result.SubjectOrDuration);
Assert.AreEqual("*****@*****.**", result.UserEmail);
}
public bool Create(InsideUser user, string password)
{
IdentityResult identityResult = userManager.Create(user, password);
return(identityResult.Succeeded);
}
