public async Task ReturnAttchmentsType_Successfully()
{
var options = TestUtils.GetOptions(nameof(ReturnAttchmentsType_Successfully));
var testAttachmentId = "Attachment";
var newAttachment = new EmailAttachments()
{
Id = testAttachmentId
};
using (var arrangeContext = new EmailManagerDbContext(options))
{
await arrangeContext.EmailAttachments.AddAsync(newAttachment);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new EmailManagerDbContext(options))
{
var sut = new AttachmentsService(assertContext);
var result = await sut.GetEmailAttachmentsByEmailIdAsync(testAttachmentId);
Assert.IsInstanceOfType(result, typeof(ICollection <EmailAttachmentsDTO>));
}
}
public async Task ReturnRoles_Successfully()
{
var options = TestUtils.GetOptions(nameof(ReturnRoles_Successfully));
var testUserRole = "Manager";
var testRoleId = "TestRoleId";
using (var arrangeContext = new EmailManagerDbContext(options))
{
await arrangeContext.Roles.AddAsync(new IdentityRole { Id = testRoleId, Name = testUserRole });
await arrangeContext.SaveChangesAsync();
}
var userStoreMock = new Mock <IUserStore <User> >();
var mockUserManager = new Mock <UserManager <User> >(userStoreMock.Object, null, null, null, null, null, null, null, null);
using (var assertContext = new EmailManagerDbContext(options))
{
var sut = new UsersService(assertContext, mockUserManager.Object);
var roles = await sut.GetRolesAsync();
Assert.AreEqual(testRoleId, roles.First().Id);
}
}
public async Task ReturnClientDataType_Successfully()
{
var firstName = "FirstName";
var lastName = "LastName";
var egn = "1234567899";
var options = TestUtils.GetOptions(nameof(FindClient_Successfully));
var clientData = new ClientData()
{
FirstName = firstName, LastName = lastName, EGN = egn
};
var mockValidation = new Mock <IValidation>().Object;
var mockEncryption = new Mock <IEncryptingHelper>();
using (var arrangeContext = new EmailManagerDbContext(options))
{
await arrangeContext.ClientDatas.AddAsync(clientData);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new EmailManagerDbContext(options))
{
var sut = new ClientService(assertContext, mockValidation, mockEncryption.Object);
mockEncryption.Setup(e => e.Encrypt(lastName)).Returns(lastName);
mockEncryption.Setup(e => e.Encrypt(egn)).Returns(egn);
mockEncryption.Setup(e => e.Decrypt(lastName)).Returns(lastName);
mockEncryption.Setup(e => e.Decrypt(egn)).Returns(egn);
var data = await sut.FindClientAsync(firstName, lastName, egn);
Assert.IsInstanceOfType(data, typeof(ClientDataDTO));
}
}
public async Task ReturnCorrectEmailStatusById_WhenPassedValueIsCorrect()
{
var testStatus = "TestStatus";
var options = TestUtils.GetOptions(nameof(ReturnCorrectEmailStatusById_WhenPassedValueIsCorrect));
var status = new StatusEmail()
{
StatusType = testStatus
};
using (var arrangeContext = new EmailManagerDbContext(options))
{
await arrangeContext.StatusEmails.AddAsync(status);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new EmailManagerDbContext(options))
{
var sut = new EmailStatusService(assertContext);
var result = await sut.GetEmailStatusByIdAsync(status.Id);
Assert.AreEqual(status.Id, result.Id);
}
}
public async Task ReturnCorrectEmailById_WhenPassedValueIsCorrect()
{
var testBody = "TestBody";
var options = TestUtils.GetOptions(nameof(ReturnCorrectEmailById_WhenPassedValueIsCorrect));
var email = new ClientEmail()
{
Body = testBody
};
var mockEmailFactory = new Mock <IEmailFactory>().Object;
var mockEmailStatus = new Mock <IEmailStatusService>().Object;
var mockEncryptHelper = new Mock <IEncryptingHelper>();
using (var arrangeContext = new EmailManagerDbContext(options))
{
await arrangeContext.Emails.AddAsync(email);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new EmailManagerDbContext(options))
{
var sut = new EmailService(assertContext, mockEmailFactory, mockEncryptHelper.Object, mockEmailStatus);
mockEncryptHelper.Setup(e => e.Encrypt("")).Returns("");
mockEncryptHelper.Setup(e => e.Encrypt("")).Returns("");
mockEncryptHelper.Setup(e => e.Decrypt("")).Returns("");
mockEncryptHelper.Setup(e => e.Decrypt("")).Returns("");
var result = await sut.GetEmailByIdAsync(email.Id);
Assert.AreEqual(email.Id, result.Id);
}
}
public async Task ReturnEmailsType_Successfully()
{
var testBody = "TestBody";
var options = TestUtils.GetOptions(nameof(ReturnEmailsType_Successfully));
var firstEmail = new ClientEmail()
{
Body = testBody
};
var mockEmailFactory = new Mock <IEmailFactory>().Object;
var mockEmailStatus = new Mock <IEmailStatusService>().Object;
var mockEncryptHelper = new Mock <EncryptingHelper>().Object;
using (var arrangeContext = new EmailManagerDbContext(options))
{
await arrangeContext.Emails.AddAsync(firstEmail);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new EmailManagerDbContext(options))
{
var sut = new EmailService(assertContext, mockEmailFactory, mockEncryptHelper, mockEmailStatus);
var result = await sut.GetAllEmailsAsync();
Assert.IsInstanceOfType(result, typeof(ICollection <EmailDTO>));
}
}
public async Task ReturnCorrectUser_WhenPassedValueIsCorrect()
{
var testUsername = "******";
var newUser = new User()
{
UserName = testUsername
};
var options = TestUtils.GetOptions(nameof(ReturnCorrectUser_WhenPassedValueIsCorrect));
using (var arrangeContext = new EmailManagerDbContext(options))
{
await arrangeContext.Users.AddAsync(newUser);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new EmailManagerDbContext(options))
{
var userStoreMock = new Mock <IUserStore <User> >();
var mockUserManager = new Mock <UserManager <User> >(userStoreMock.Object, null, null, null, null, null, null, null, null);
var sut = new UsersService(assertContext, mockUserManager.Object);
var result = await sut.GetUserByIdAsync(newUser.Id);
Assert.AreEqual(newUser.Id, result.Id);
}
}
public async Task ReturnClientDataNull_WhenPassedValueNotMatch()
{
var testFirstName = "TestName";
var options = TestUtils.GetOptions(nameof(ReturnClientDataNull_WhenPassedValueNotMatch));
var clientData = new ClientData()
{
FirstName = testFirstName
};
var mockValidation = new Mock <IValidation>().Object;
var mockEncryption = new Mock <IEncryptingHelper>().Object;
using (var arrangeContext = new EmailManagerDbContext(options))
{
await arrangeContext.ClientDatas.AddAsync(clientData);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new EmailManagerDbContext(options))
{
var sut = new ClientService(assertContext, mockValidation, mockEncryption);
var result = await sut.GetClientDataByIdAsync("invalid");
Assert.IsNull(result);
}
}
public async Task ReturnCorrectEmail_WhenExists()
{
var testId = "TestId";
var options = TestUtils.GetOptions(nameof(ReturnCorrectEmail_WhenExists));
var email = new ClientEmail()
{
OriginalMailId = testId
};
var mockEmailFactory = new Mock <IEmailFactory>().Object;
var mockEmailStatus = new Mock <IEmailStatusService>().Object;
var mockEncryptHelper = new Mock <EncryptingHelper>().Object;
using (var arrangeContext = new EmailManagerDbContext(options))
{
await arrangeContext.Emails.AddAsync(email);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new EmailManagerDbContext(options))
{
var sut = new EmailService(assertContext, mockEmailFactory, mockEncryptHelper, mockEmailStatus);
var result = await sut.CheckIfEmailExists(testId);
Assert.AreEqual(true, result);
}
}
public EmailService(EmailManagerDbContext context,
IEmailFactory emailFactory,
IEncryptingHelper encryptingHelper,
IEmailStatusService emailStatusService)
{
this.context = context;
this.emailFactory = emailFactory;
this.encrypting = encryptingHelper;
this.emailStatusService = emailStatusService;
}
public async Task ReturnAttachments_WhenValuIsNull()
{
var options = TestUtils.GetOptions(nameof(ReturnAttachments_WhenValuIsNull));
using (var assertContext = new EmailManagerDbContext(options))
{
var sut = new AttachmentsService(assertContext);
var result = await sut.GetEmailAttachmentsByEmailIdAsync("test");
Assert.AreEqual(0, result.Count());
}
}
public async Task Return_Null()
{
var options = TestUtils.GetOptions(nameof(Return_Null));
using (var assertContext = new EmailManagerDbContext(options))
{
var mockValidation = new Mock <IValidation>().Object;
var mockEncryption = new Mock <IEncryptingHelper>().Object;
var sut = new ClientService(assertContext, mockValidation, mockEncryption);
var data = await sut.FindClientAsync("FirstName", "LastName", "1231231231");
Assert.IsNull(data);
}
}
public async Task ReturnEmails_WhenValuIsNull()
{
var options = TestUtils.GetOptions(nameof(ReturnEmails_WhenValuIsNull));
var mockEmailFactory = new Mock <IEmailFactory>().Object;
var mockEmailStatus = new Mock <IEmailStatusService>().Object;
var mockEncryptHelper = new Mock <EncryptingHelper>().Object;
using (var assertContext = new EmailManagerDbContext(options))
{
var sut = new EmailService(assertContext, mockEmailFactory, mockEncryptHelper, mockEmailStatus);
var result = await sut.GetAllEmailsAsync();
Assert.AreEqual(0, result.Count());
}
}
public async Task ReturnRoles_WhenValuIsNull()
{
var options = TestUtils.GetOptions(nameof(ReturnRoles_WhenValuIsNull));
var userStoreMock = new Mock <IUserStore <User> >();
var mockUserManager = new Mock <UserManager <User> >(userStoreMock.Object, null, null, null, null, null, null, null, null);
using (var assertContext = new EmailManagerDbContext(options))
{
var sut = new UsersService(assertContext, mockUserManager.Object);
var roles = await sut.GetRolesAsync();
Assert.AreEqual(0, roles.Count());
}
}
public async Task ReturnEmailNull_WhenPassedValueNotMatch()
{
var options = TestUtils.GetOptions(nameof(ReturnEmailNull_WhenPassedValueNotMatch));
var mockEmailFactory = new Mock <IEmailFactory>().Object;
var mockEmailStatus = new Mock <IEmailStatusService>().Object;
var mockEncryptHelper = new Mock <IEncryptingHelper>().Object;
using (var assertContext = new EmailManagerDbContext(options))
{
var sut = new EmailService(assertContext, mockEmailFactory, mockEncryptHelper, mockEmailStatus);
var result = await sut.GetEmailByIdAsync("test");
Assert.IsNull(result);
}
}
public async Task ReturnEmails_WhenExistsIsNull()
{
var options = TestUtils.GetOptions(nameof(ReturnEmails_WhenExistsIsNull));
var mockEmailFactory = new Mock <IEmailFactory>().Object;
var mockEmailStatus = new Mock <IEmailStatusService>().Object;
var mockEncryptHelper = new Mock <IEncryptingHelper>().Object;
using (var assertContext = new EmailManagerDbContext(options))
{
var sut = new EmailService(assertContext, mockEmailFactory, mockEncryptHelper, mockEmailStatus);
var result = await sut.CheckIfEmailExists("TestId");
Assert.AreEqual(false, result);
}
}
public async Task ReturnCollectionOfEmail()
{
var testBody = "TestBody";
var options = TestUtils.GetOptions(nameof(ReturnCollectionOfEmail));
var firstEmail = new ClientEmail()
{
Body = testBody
};
var secondEmail = new ClientEmail()
{
Body = "SecondBodyName"
};
var thirdEmail = new ClientEmail()
{
Body = "ThirdBodyName"
};
var mockEmailFactory = new Mock <IEmailFactory>().Object;
var mockEmailStatus = new Mock <IEmailStatusService>().Object;
var mockEncryptHelper = new Mock <EncryptingHelper>().Object;
using (var arrangeContext = new EmailManagerDbContext(options))
{
await arrangeContext.Emails.AddAsync(firstEmail);
await arrangeContext.Emails.AddAsync(secondEmail);
await arrangeContext.Emails.AddAsync(thirdEmail);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new EmailManagerDbContext(options))
{
var sut = new EmailService(assertContext, mockEmailFactory, mockEncryptHelper, mockEmailStatus);
var result = await sut.GetAllEmailsAsync();
Assert.AreEqual(3, result.Count);
}
}
public async Task ReturnNull_WhenPassedValueNotMatch()
{
var options = TestUtils.GetOptions(nameof(ReturnNull_WhenPassedValueNotMatch));
var testUserId = "testUserId";
using (var assertContext = new EmailManagerDbContext(options))
{
var userStoreMock = new Mock <IUserStore <User> >();
var mockUserManager = new Mock <UserManager <User> >(
userStoreMock.Object, null, null, null, null, null, null, null, null);
var usersService = new UsersService(assertContext, mockUserManager.Object);
var sut = await usersService.GetUserByIdAsync(testUserId);
Assert.IsNull(sut);
}
}
public UsersService(EmailManagerDbContext context, UserManager <User> userManager)
{
this.context = context;
this.userManager = userManager;
}
public LoanApplicationService(EmailManagerDbContext context)
{
this.context = context;
}
public AttachmentsService(EmailManagerDbContext context)
{
this.context = context;
}
public ClientService(EmailManagerDbContext context, IValidation validation, IEncryptingHelper encrypting)
{
this.context = context;
this.validation = validation;
this.encrypting = encrypting;
}
public EmailStatusService(EmailManagerDbContext context)
{
this.context = context;
}
