public async Task CreateAsync_ShouldReturn_EmailDTO()
{
var options = TestUtilities.GetOptions(nameof(CreateAsync_ShouldReturn_EmailDTO));
var mockDecodeService = new Mock <IDecodeService>().Object;
var mockEncryptService = new Mock <IEncryptService>().Object;
var mockLogger = new Mock <ILogger <EmailService> >().Object;
var mockUserStore = new Mock <IUserStore <User> >();
var mockUserManager = new Mock <UserManager <User> >(mockUserStore.Object, null, null, null, null, null, null, null).Object;
var mockEmailDTOMapper = new Mock <IEmailDTOMapper>();
var mockEmail = new Mock <Email>().Object;
var mockEmailDTO = new Mock <EmailDTO>().Object;
mockEmailDTOMapper.Setup(x => x.MapFrom(mockEmailDTO)).Returns(mockEmail);
mockEmailDTOMapper.Setup(x => x.MapFrom(mockEmail)).Returns(mockEmailDTO);
using (var assertContext = new TBIAppDbContext(options))
{
var mockEmailService = new EmailService(assertContext, mockEmailDTOMapper.Object,
mockDecodeService, mockLogger, mockUserManager, mockEncryptService);
var sut = await mockEmailService.CreateAsync(mockEmailDTO);
Assert.IsInstanceOfType(sut, typeof(EmailDTO));
}
}
public async Task GetCurrentPageEmailsAsync_ThrowEx_True()
{
var options = TestUtilities.GetOptions(nameof(GetCurrentPageEmailsAsync_ThrowEx_True));
var mockEmailDTOMapper = new Mock <IEmailDTOMapper>().Object;
var decodeService = new Mock <IDecodeService>().Object;
var mockUserStore = new Mock <IUserStore <User> >();
var mockUserManager = new Mock <UserManager <User> >(
new Mock <IUserStore <User> >().Object,
new Mock <IOptions <IdentityOptions> >().Object,
new Mock <IPasswordHasher <User> >().Object,
new IUserValidator <User> [0],
new IPasswordValidator <User> [0],
new Mock <ILookupNormalizer>().Object,
new Mock <IdentityErrorDescriber>().Object,
new Mock <IServiceProvider>().Object,
new Mock <ILogger <UserManager <User> > >().Object);
var mockLogger = new Mock <ILogger <EmailService> >().Object;
var mockEncryptService = new Mock <IEncryptService>().Object;
var mockUser = new Mock <User>().Object;
var statusOfEmail = EmailStatusesEnum.NotReviewed;
var page = 1;
using (var assertContext = new TBIAppDbContext(options))
{
var sut = new EmailService(assertContext, mockEmailDTOMapper,
decodeService, mockLogger, mockUserManager.Object, mockEncryptService);
var result = await sut.GetCurrentPageEmailsAsync(page, statusOfEmail, mockUser);
Assert.IsNull(result);
};
}
public async Task CreateAsync_ShouldCreateEmail()
{
var options = TestUtilities.GetOptions(nameof(CreateAsync_ShouldCreateEmail));
var mockDecodeService = new Mock <IDecodeService>().Object;
var mockEncryptService = new Mock <IEncryptService>().Object;
var mockLogger = new Mock <ILogger <EmailService> >().Object;
var mockUserStore = new Mock <IUserStore <User> >();
var mockUserManager = new Mock <UserManager <User> >(mockUserStore.Object, null,
null, null, null, null, null, null).Object;
var mockEmailDTOMapper = new Mock <IEmailDTOMapper>();
var mockEmail = new Mock <Email>().Object;
var mockEmailDTO = new Mock <EmailDTO>().Object;
mockEmailDTOMapper.Setup(x => x.MapFrom(mockEmailDTO)).Returns(mockEmail);
var expectedResult = 1;
using (var assertContext = new TBIAppDbContext(options))
{
var emailService = new EmailService(assertContext,
mockEmailDTOMapper.Object, mockDecodeService,
mockLogger, null, mockEncryptService);
var sut = await emailService.CreateAsync(mockEmailDTO);
Assert.AreEqual(expectedResult, assertContext.Emails.Count());
}
}
public async Task GetAllEmailsPagesAsync_ShouldGet_True()
{
var options = TestUtilities.GetOptions(nameof(GetAllEmailsPagesAsync_ShouldGet_True));
var mockEmailDTOMapper = new Mock <IEmailDTOMapper>().Object;
var mockDecodeService = new Mock <IDecodeService>().Object;
var mockUserStore = new Mock <IUserStore <User> >();
var mockUserManager = new Mock <UserManager <User> >(mockUserStore.Object, null, null, null, null, null, null, null).Object;
var mockEncryptService = new Mock <IEncryptService>().Object;
var mockLogger = new Mock <ILogger <EmailService> >().Object;
var expectedCount = 1;
using (var actContext = new TBIAppDbContext(options))
{
await actContext.Emails.AddAsync(new Email());
await actContext.Emails.AddAsync(new Email());
await actContext.SaveChangesAsync();
}
using (var assertContext = new TBIAppDbContext(options))
{
var sut = new EmailService(assertContext, mockEmailDTOMapper,
mockDecodeService, mockLogger, null, mockEncryptService);
var result = await sut.GetAllEmailsPagesAsync();
Assert.AreEqual(expectedCount, result);
}
}
public async Task UnLockButtonAsync_ShouldThrow_ArgumentNullEx()
{
var options = TestUtilities.GetOptions(nameof(UnLockButtonAsync_ShouldThrow_ArgumentNullEx));
var mockEmailDTOMapper = new Mock <IEmailDTOMapper>().Object;
var mockDecodeService = new Mock <IDecodeService>().Object;
var mockEncryptService = new Mock <IEncryptService>().Object;
var mockUserStore = new Mock <IUserStore <User> >();
var mockUserManager = new Mock <UserManager <User> >(mockUserStore.Object, null, null, null, null, null, null, null).Object;
var mockLogger = new Mock <ILogger <EmailService> >().Object;
var mockEmail = new Mock <Email>().Object;
var testId = "testId";
mockEmail.Id = testId;
mockEmail.IsOpne = true;
using (var assertContext = new TBIAppDbContext(options))
{
var sut = new EmailService(assertContext, mockEmailDTOMapper, mockDecodeService,
mockLogger, mockUserManager, mockEncryptService);
await sut.UnLockButtonAsync(testId);
}
}
public async Task IsOpenAsync_ShouldGet_True()
{
var options = TestUtilities.GetOptions(nameof(IsOpenAsync_ShouldGet_True));
var mockEmailDTOMapper = new Mock <IEmailDTOMapper>().Object;
var mockDecodeService = new Mock <IDecodeService>().Object;
var mockEncryptService = new Mock <IEncryptService>().Object;
var mockLogger = new Mock <ILogger <EmailService> >().Object;
var mockEmail = new Mock <Email>().Object;
var testId = "testId";
mockEmail.Id = testId;
mockEmail.IsOpne = true;
var expectedResult = true;
using (var actContext = new TBIAppDbContext(options))
{
await actContext.Emails.AddAsync(mockEmail);
await actContext.SaveChangesAsync();
}
using (var assertContext = new TBIAppDbContext(options))
{
var emailService = new EmailService(assertContext, mockEmailDTOMapper,
mockDecodeService, mockLogger, null, mockEncryptService);
var sut = await emailService.IsOpenAsync(testId);
Assert.AreEqual(expectedResult, sut);
}
}
public async Task GetCurrentPageEmailsAsync_ThrowEx_True()
{
var options = TestUtilities.GetOptions(nameof(GetCurrentPageEmailsAsync_ThrowEx_True));
var mockEmailDTOMapper = new Mock <IEmailDTOMapper>().Object;
var decodeService = new Mock <IDecodeService>().Object;
var mockUserStore = new Mock <IUserStore <User> >();
var mockUserManager = new Mock <UserManager <User> >(mockUserStore.Object, null, null, null, null, null, null, null).Object;
var mockLogger = new Mock <ILogger <EmailService> >().Object;
var mockEncryptService = new Mock <IEncryptService>().Object;
var mockUser = new Mock <User>().Object;
var statusOfEmail = EmailStatusesEnum.NotReviewed;
var page = 1;
using (var assertContext = new TBIAppDbContext(options))
{
var sut = new EmailService(assertContext, mockEmailDTOMapper,
decodeService, mockLogger, mockUserManager, mockEncryptService);
var result = await sut.GetCurrentPageEmailsAsync(page, statusOfEmail, mockUser);
Assert.IsNull(result);
};
}
public async Task UnLockButtonAsync_ShouldBeCalledOnce()
{
var options = TestUtilities.GetOptions(nameof(UnLockButtonAsync_ShouldBeCalledOnce));
var mockEmailDTOMapper = new Mock <IEmailDTOMapper>().Object;
var mockDecodeService = new Mock <IDecodeService>().Object;
var mockEncryptService = new Mock <IEncryptService>().Object;
var mockLogger = new Mock <ILogger <EmailService> >().Object;
var mockEmail = new Mock <Email>().Object;
var testId = "testId";
mockEmail.Id = testId;
mockEmail.IsOpne = true;
using (var assertContext = new TBIAppDbContext(options))
{
var mockEmailService = new Mock <IEmailService>();
mockEmailService.Setup(x => x.UnLockButtonAsync(testId));
await mockEmailService.Object.UnLockButtonAsync(testId);
mockEmailService.Verify(x => x.UnLockButtonAsync(testId), Times.Once);
}
}
public async Task CreateAsync_ShouldCreateWithValidParams()
{
var options = TestUtilities.GetOptions(nameof(CreateAsync_ShouldCreateWithValidParams));
var mockAttachment = new Mock <Attachment>().Object;
mockAttachment.FileName = "TestPictureName";
mockAttachment.SizeKb = 100.00;
mockAttachment.SizeMb = 200.00;
var mockAttachmentDTO = new Mock <AttachmentDTO>().Object;
mockAttachmentDTO.FileName = "TestPictureName";
mockAttachmentDTO.SizeKb = 100.00;
mockAttachmentDTO.SizeMb = 200.00;
var mockAttachmentDTOMapper = new Mock <IAttachmentDTOMapper>();
mockAttachmentDTOMapper.Setup(a => a.MapFrom(mockAttachmentDTO)).Returns(mockAttachment);
mockAttachmentDTOMapper.Setup(a => a.MapFrom(mockAttachment)).Returns(mockAttachmentDTO);
using (var assertContext = new TBIAppDbContext(options))
{
var attachmentService = new AttachmentService(assertContext, mockAttachmentDTOMapper.Object);
await attachmentService.CreateAsync(mockAttachmentDTO);
var sut = await assertContext.Attachments.FirstOrDefaultAsync();
Assert.AreEqual(mockAttachmentDTO.FileName, sut.FileName);
Assert.AreEqual(mockAttachmentDTO.SizeKb, sut.SizeKb);
Assert.AreEqual(mockAttachmentDTO.SizeMb, sut.SizeMb);
}
}
public async Task CreateAsync_ShouldThrow_ArgumentNullEx()
{
var options = TestUtilities.GetOptions(nameof(CreateAsync_ShouldThrow_ArgumentNullEx));
var mockDecodeService = new Mock <IDecodeService>().Object;
var mockEncryptService = new Mock <IEncryptService>().Object;
var mockLogger = new Mock <ILogger <EmailService> >().Object;
var mockUserStore = new Mock <IUserStore <User> >();
var mockUserManager = new Mock <UserManager <User> >(
new Mock <IUserStore <User> >().Object,
new Mock <IOptions <IdentityOptions> >().Object,
new Mock <IPasswordHasher <User> >().Object,
new IUserValidator <User> [0],
new IPasswordValidator <User> [0],
new Mock <ILookupNormalizer>().Object,
new Mock <IdentityErrorDescriber>().Object,
new Mock <IServiceProvider>().Object,
new Mock <ILogger <UserManager <User> > >().Object);
var mockEmailDTOMapper = new Mock <IEmailDTOMapper>();
var mockEmail = new Mock <Email>().Object;
var mockEmailDTO = new Mock <EmailDTO>().Object;
mockEmailDTOMapper.Setup(x => x.MapFrom(mockEmailDTO)).Returns(mockEmail);
mockEmailDTOMapper.Setup(x => x.MapFrom(mockEmail)).Returns(mockEmailDTO);
using (var assertContext = new TBIAppDbContext(options))
{
var mockEmailService = new EmailService(assertContext, mockEmailDTOMapper.Object,
mockDecodeService, mockLogger, mockUserManager.Object, mockEncryptService);
var sut = await mockEmailService.CreateAsync(null);
}
}
public async Task IsOpenAsync_ShouldThrowArgumentNullEx()
{
var options = TestUtilities.GetOptions(nameof(IsOpenAsync_ShouldThrowArgumentNullEx));
var mockEmailDTOMapper = new Mock <IEmailDTOMapper>().Object;
var mockDecodeService = new Mock <IDecodeService>().Object;
var mockEncryptService = new Mock <IEncryptService>().Object;
var mockUserStore = new Mock <IUserStore <User> >();
var mockUserManager = new Mock <UserManager <User> >(mockUserStore.Object, null, null, null, null, null, null, null).Object;
var mockLogger = new Mock <ILogger <EmailService> >().Object;
var mockEmail = new Mock <Email>().Object;
var testId = string.Empty;
mockEmail.Id = "correctTestId";
mockEmail.IsOpne = true;
using (var actContext = new TBIAppDbContext(options))
{
await actContext.Emails.AddAsync(mockEmail);
await actContext.SaveChangesAsync();
}
using (var assertContext = new TBIAppDbContext(options))
{
var emailService = new EmailService(assertContext, mockEmailDTOMapper,
mockDecodeService, mockLogger, mockUserManager, mockEncryptService);
var sut = await emailService.IsOpenAsync(testId);
}
}
public async Task UnLockButtonAsync_ShouldThrow_ArgumentNullEx()
{
var options = TestUtilities.GetOptions(nameof(UnLockButtonAsync_ShouldThrow_ArgumentNullEx));
var mockEmailDTOMapper = new Mock <IEmailDTOMapper>().Object;
var mockDecodeService = new Mock <IDecodeService>().Object;
var mockEncryptService = new Mock <IEncryptService>().Object;
var mockUserStore = new Mock <IUserStore <User> >();
var mockUserManager = new Mock <UserManager <User> >(
new Mock <IUserStore <User> >().Object,
new Mock <IOptions <IdentityOptions> >().Object,
new Mock <IPasswordHasher <User> >().Object,
new IUserValidator <User> [0],
new IPasswordValidator <User> [0],
new Mock <ILookupNormalizer>().Object,
new Mock <IdentityErrorDescriber>().Object,
new Mock <IServiceProvider>().Object,
new Mock <ILogger <UserManager <User> > >().Object);
var mockLogger = new Mock <ILogger <EmailService> >().Object;
var mockEmail = new Mock <Email>().Object;
var testId = "testId";
mockEmail.Id = testId;
mockEmail.IsOpne = true;
using (var assertContext = new TBIAppDbContext(options))
{
var sut = new EmailService(assertContext, mockEmailDTOMapper, mockDecodeService,
mockLogger, mockUserManager.Object, mockEncryptService);
await sut.UnLockButtonAsync(testId);
}
}
public async Task ChangeStatusAsync_ShouldThrow_ArgumentNullExs()
{
var options = TestUtilities.GetOptions(nameof(ChangeStatusAsync_ShouldThrow_ArgumentNullExs));
var mockEmailDTOMapper = new Mock <IEmailDTOMapper>().Object;
var mockDecodeService = new Mock <IDecodeService>().Object;
var mockEncryptService = new Mock <IEncryptService>().Object;
var mockUserStore = new Mock <IUserStore <User> >();
var mockUserManager = new Mock <UserManager <User> >(
new Mock <IUserStore <User> >().Object,
new Mock <IOptions <IdentityOptions> >().Object,
new Mock <IPasswordHasher <User> >().Object,
new IUserValidator <User> [0],
new IPasswordValidator <User> [0],
new Mock <ILookupNormalizer>().Object,
new Mock <IdentityErrorDescriber>().Object,
new Mock <IServiceProvider>().Object,
new Mock <ILogger <UserManager <User> > >().Object);
var mockLogger = new Mock <ILogger <EmailService> >().Object;
var testId = "testId";
var mockUser = new Mock <User>().Object;
var newEmailStatus = EmailStatusesEnum.Open;
using (var assertContext = new TBIAppDbContext(options))
{
var sut = new EmailService(assertContext, mockEmailDTOMapper,
mockDecodeService, mockLogger, mockUserManager.Object, mockEncryptService);
await sut.ChangeStatusAsync(testId, newEmailStatus, mockUser);
}
}
public UserService(TBIAppDbContext dbcontext,
ILogger <UserService> logger,
UserManager <User> userManager)
{
this.dbcontext = dbcontext ?? throw new ArgumentNullException(nameof(dbcontext));
this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
this.userManager = userManager ?? throw new ArgumentNullException(nameof(userManager));
}
public async Task CreateAsync_ShouldCreateWithValidParams()
{
var options = TestUtilities.GetOptions(nameof(CreateAsync_ShouldCreateWithValidParams));
var mockDecodeService = new Mock <IDecodeService>().Object;
var mockEncryptService = new Mock <IEncryptService>().Object;
var mockLogger = new Mock <ILogger <EmailService> >().Object;
var mockAttachment = new Mock <Attachment>().Object;
var mockAttachmentDTO = new Mock <AttachmentDTO>().Object;
var mockUserStore = new Mock <IUserStore <User> >();
var mockUserManager = new Mock <UserManager <User> >(mockUserStore.Object, null, null, null, null, null, null, null).Object;
var testDate = DateTime.Now;
var mockEmail = new Mock <Email>().Object;
mockEmail.Id = "TestId";
mockEmail.IsOpne = true;
mockEmail.LastOpen = testDate;
mockEmail.LastStatusUpdate = testDate;
mockEmail.RegisteredInDataBase = testDate;
mockEmail.Sender = "TestSender";
var mockEmailDTO = new Mock <EmailDTO>().Object;
mockEmailDTO.Id = "TestId";
mockEmailDTO.IsOpne = true;
mockEmailDTO.LastOpen = testDate;
mockEmailDTO.LastStatusUpdate = testDate;
mockEmailDTO.RegisteredInDataBase = testDate;
mockEmailDTO.Sender = "TestSender";
var mockEmailDTOMapper = new Mock <IEmailDTOMapper>();
mockEmailDTOMapper.Setup(x => x.MapFrom(mockEmailDTO)).Returns(mockEmail);
mockEmailDTOMapper.Setup(x => x.MapFrom(mockEmail)).Returns(mockEmailDTO);
using (var assertContext = new TBIAppDbContext(options))
{
var mockEmailService = new EmailService(assertContext, mockEmailDTOMapper.Object,
mockDecodeService, mockLogger, mockUserManager, mockEncryptService);
await mockEmailService.CreateAsync(mockEmailDTO);
var sut = assertContext.Emails.FirstOrDefault();
Assert.AreEqual(mockEmail.Id, sut.Id);
Assert.AreEqual(mockEmail.IsOpne, sut.IsOpne);
Assert.AreEqual(mockEmail.LastOpen, sut.LastOpen);
Assert.AreEqual(mockEmail.LastStatusUpdate, sut.LastStatusUpdate);
Assert.AreEqual(mockEmail.RegisteredInDataBase, sut.RegisteredInDataBase);
Assert.AreEqual(mockEmail.Sender, sut.Sender);
}
}
public async Task ChangeStatusAsync_ShouldChangeStatus()
{
var options = TestUtilities.GetOptions(nameof(ChangeStatusAsync_ShouldChangeStatus));
var mockEmailDTOMapper = new Mock <IEmailDTOMapper>().Object;
var mockDecodeService = new Mock <IDecodeService>().Object;
var mockEncryptService = new Mock <IEncryptService>().Object;
var mockUserStore = new Mock <IUserStore <User> >();
var mockUserManager = new Mock <UserManager <User> >(
new Mock <IUserStore <User> >().Object,
new Mock <IOptions <IdentityOptions> >().Object,
new Mock <IPasswordHasher <User> >().Object,
new IUserValidator <User> [0],
new IPasswordValidator <User> [0],
new Mock <ILookupNormalizer>().Object,
new Mock <IdentityErrorDescriber>().Object,
new Mock <IServiceProvider>().Object,
new Mock <ILogger <UserManager <User> > >().Object);
var mockLogger = new Mock <ILogger <EmailService> >().Object;
var mockEmail = new Mock <Email>().Object;
var testId = "testId";
var testStatus = EmailStatusesEnum.New;
mockEmail.Id = testId;
mockEmail.Status = testStatus;
var mockUser = new Mock <User>().Object;
var newEmailStatus = EmailStatusesEnum.Open;
var expectedResult = newEmailStatus;
using (var actContext = new TBIAppDbContext(options))
{
await actContext.Emails.AddAsync(mockEmail);
await actContext.SaveChangesAsync();
}
using (var assertContext = new TBIAppDbContext(options))
{
var emailService = new EmailService(assertContext, mockEmailDTOMapper,
mockDecodeService, mockLogger, mockUserManager.Object, mockEncryptService);
await emailService.ChangeStatusAsync(testId, newEmailStatus, mockUser);
var sut = assertContext.Emails.FirstOrDefault();
Assert.AreEqual(expectedResult, sut.Status);
}
}
public EmailService(TBIAppDbContext dbcontext,
IEmailDTOMapper emailDTOMapper,
IDecodeService decodeService,
ILogger <EmailService> logger,
UserManager <User> userManager,
IEncryptService encryptService)
{
this.dbcontext = dbcontext ?? throw new ArgumentNullException(nameof(dbcontext));
this.emailDTOMapper = emailDTOMapper ?? throw new ArgumentNullException(nameof(emailDTOMapper));
this.decodeService = decodeService ?? throw new ArgumentNullException(nameof(decodeService));
this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
this.userManager = userManager;
this.encryptService = encryptService ?? throw new ArgumentNullException(nameof(encryptService));
}
public async Task UnLockButtonAsync_ShouldReturnTypeOfBool()
{
var options = TestUtilities.GetOptions(nameof(UnLockButtonAsync_ShouldReturnTypeOfBool));
var mockEmailDTOMapper = new Mock <IEmailDTOMapper>().Object;
var mockDecodeService = new Mock <IDecodeService>().Object;
var mockEncryptService = new Mock <IEncryptService>().Object;
var userStoreMock = new Mock <IUserStore <User> >();
var mockUserManager = new Mock <UserManager <User> >(
new Mock <IUserStore <User> >().Object,
new Mock <IOptions <IdentityOptions> >().Object,
new Mock <IPasswordHasher <User> >().Object,
new IUserValidator <User> [0],
new IPasswordValidator <User> [0],
new Mock <ILookupNormalizer>().Object,
new Mock <IdentityErrorDescriber>().Object,
new Mock <IServiceProvider>().Object,
new Mock <ILogger <UserManager <User> > >().Object);
var mockLogger = new Mock <ILogger <EmailService> >().Object;
var mockEmail = new Mock <Email>().Object;
var testId = "testId";
mockEmail.Id = testId;
mockEmail.IsOpne = true;
using (var actContext = new TBIAppDbContext(options))
{
await actContext.Emails.AddAsync(mockEmail);
await actContext.SaveChangesAsync();
}
using (var assertContext = new TBIAppDbContext(options))
{
var emailService = new EmailService(assertContext, mockEmailDTOMapper,
mockDecodeService, mockLogger, mockUserManager.Object, mockEncryptService);
await emailService.UnLockButtonAsync(testId);
var email = assertContext.Emails.FirstOrDefault();
var sut = email.IsOpne;
Assert.IsInstanceOfType(sut, typeof(bool));
}
}
public async Task CreateAsync_ShouldThrow_ArgumentNullEx()
{
var options = TestUtilities.GetOptions(nameof(CreateAsync_ShouldThrow_ArgumentNullEx));
var mockApplication = new Mock <LoanApplication>().Object;
var mockApplicationDTO = new Mock <LoanApplicationDTO>().Object;
var mockLoanApplicationDTOMapper = new Mock <ILoanApplicationDTOMapper>();
mockLoanApplicationDTOMapper.Setup(am => am.MapFrom(mockApplicationDTO)).Returns(mockApplication);
using (var assertContext = new TBIAppDbContext(options))
{
var applicationService = new ApplicationService(assertContext, mockLoanApplicationDTOMapper.Object);
var sut = await applicationService.CreateAsync(null);
}
}
public async Task IsOpenAsync_ShouldGet_False()
{
var options = TestUtilities.GetOptions(nameof(IsOpenAsync_ShouldGet_False));
var mockEmailDTOMapper = new Mock <IEmailDTOMapper>().Object;
var mockDecodeService = new Mock <IDecodeService>().Object;
var mockEncryptService = new Mock <IEncryptService>().Object;
var mockUserStore = new Mock <IUserStore <User> >();
var mockUserManager = new Mock <UserManager <User> >(
new Mock <IUserStore <User> >().Object,
new Mock <IOptions <IdentityOptions> >().Object,
new Mock <IPasswordHasher <User> >().Object,
new IUserValidator <User> [0],
new IPasswordValidator <User> [0],
new Mock <ILookupNormalizer>().Object,
new Mock <IdentityErrorDescriber>().Object,
new Mock <IServiceProvider>().Object,
new Mock <ILogger <UserManager <User> > >().Object);
var mockLogger = new Mock <ILogger <EmailService> >().Object;
var mockEmail = new Mock <Email>().Object;
var testId = "testId";
mockEmail.Id = testId;
mockEmail.IsOpne = false;
var expectedResult = false;
using (var actContext = new TBIAppDbContext(options))
{
await actContext.Emails.AddAsync(mockEmail);
await actContext.SaveChangesAsync();
}
using (var assertContext = new TBIAppDbContext(options))
{
var emailService = new EmailService(assertContext, mockEmailDTOMapper,
mockDecodeService, mockLogger, mockUserManager.Object, mockEncryptService);
var sut = await emailService.IsOpenAsync(testId);
Assert.AreEqual(expectedResult, sut);
}
}
public async Task CreateAsync_ShouldThrow_ArgumentNullEx()
{
var options = TestUtilities.GetOptions(nameof(CreateAsync_ShouldThrow_ArgumentNullEx));
var mockAttachment = new Mock <Attachment>().Object;
var mockAttachmentDTO = new Mock <AttachmentDTO>().Object;
var mockAttachmentDTOMapper = new Mock <IAttachmentDTOMapper>();
mockAttachmentDTOMapper.Setup(a => a.MapFrom(mockAttachmentDTO)).Returns(mockAttachment);
mockAttachmentDTOMapper.Setup(a => a.MapFrom(mockAttachment)).Returns(mockAttachmentDTO);
using (var assertContext = new TBIAppDbContext(options))
{
var attachmentService = new AttachmentService(assertContext, mockAttachmentDTOMapper.Object);
await attachmentService.CreateAsync(null);
}
}
public async Task GetEmailsPagesByTypeAsync_ShouldGet_True()
{
var options = TestUtilities.GetOptions(nameof(GetEmailsPagesByTypeAsync_ShouldGet_True));
var mockEmailDTOMapper = new Mock <IEmailDTOMapper>().Object;
var decodeService = new Mock <IDecodeService>().Object;
var mockUserStore = new Mock <IUserStore <User> >();
var mockUserManager = new Mock <UserManager <User> >(
new Mock <IUserStore <User> >().Object,
new Mock <IOptions <IdentityOptions> >().Object,
new Mock <IPasswordHasher <User> >().Object,
new IUserValidator <User> [0],
new IPasswordValidator <User> [0],
new Mock <ILookupNormalizer>().Object,
new Mock <IdentityErrorDescriber>().Object,
new Mock <IServiceProvider>().Object,
new Mock <ILogger <UserManager <User> > >().Object);
var mockLogger = new Mock <ILogger <EmailService> >().Object;
var mockEncryptService = new Mock <IEncryptService>().Object;
var status = 1;
using (var actContext = new TBIAppDbContext(options))
{
await actContext.Emails.AddAsync(
new Email
{
Status = (EmailStatusesEnum)status
});
await actContext.SaveChangesAsync();
}
using (var assertContext = new TBIAppDbContext(options))
{
var sut = new EmailService(assertContext, mockEmailDTOMapper,
decodeService, mockLogger, mockUserManager.Object, mockEncryptService);
var result = await sut.GetEmailsPagesByTypeAsync((EmailStatusesEnum)status);
Assert.AreEqual(1, result);
};
}
public async Task CreateAsync_ShouldReturnType_LoanApplicationDTO()
{
var options = TestUtilities.GetOptions(nameof(CreateAsync_ShouldReturnType_LoanApplicationDTO));
var mockApplication = new Mock <LoanApplication>().Object;
var mockApplicationDTO = new Mock <LoanApplicationDTO>().Object;
var mockLoanApplicationDTOMapper = new Mock <ILoanApplicationDTOMapper>();
mockLoanApplicationDTOMapper.Setup(am => am.MapFrom(mockApplicationDTO)).Returns(mockApplication);
using (var assertContext = new TBIAppDbContext(options))
{
var applicationService = new ApplicationService(assertContext, mockLoanApplicationDTOMapper.Object);
var sut = await applicationService.CreateAsync(mockApplicationDTO);
Assert.IsInstanceOfType(sut, typeof(LoanApplicationDTO));
}
}
public async Task CreateAsync_ShouldCreate_WithValidParams()
{
var options = TestUtilities.GetOptions(nameof(CreateAsync_ShouldCreate_WithValidParams));
var mockApplicationDTO = new Mock <LoanApplicationDTO>().Object;
mockApplicationDTO.FirstName = "Michail";
mockApplicationDTO.LastName = "Ivanov";
mockApplicationDTO.EGN = "8809277777";
mockApplicationDTO.PhoneNumber = "123151232";
mockApplicationDTO.Status = LoanApplicationStatus.NotReviewed;
mockApplicationDTO.CardId = "876123123";
var mockApplication = new Mock <LoanApplication>().Object;
mockApplication.FirstName = "Michail";
mockApplication.LastName = "Ivanov";
mockApplication.EGN = "8809277777";
mockApplication.PhoneNumber = "123151232";
mockApplication.Status = LoanApplicationStatus.NotReviewed;
mockApplication.CardId = "876123123";
var mockLoanApplicationDTOMapper = new Mock <ILoanApplicationDTOMapper>();
mockLoanApplicationDTOMapper.Setup(am => am.MapFrom(mockApplicationDTO)).Returns(mockApplication);
using (var assertContext = new TBIAppDbContext(options))
{
var applicationService = new ApplicationService(assertContext, mockLoanApplicationDTOMapper.Object);
await applicationService.CreateAsync(mockApplicationDTO);
var sut = await assertContext.LoanApplications.FirstOrDefaultAsync();
Assert.AreEqual(mockApplication.FirstName, sut.FirstName);
Assert.AreEqual(mockApplication.LastName, sut.LastName);
Assert.AreEqual(mockApplication.EGN, sut.EGN);
Assert.AreEqual(mockApplication.PhoneNumber, sut.PhoneNumber);
Assert.AreEqual(mockApplication.Status, sut.Status);
Assert.AreEqual(mockApplication.CardId, sut.CardId);
}
}
public async Task CreateAsync_ShouldReturn_AttachmentDTO()
{
var options = TestUtilities.GetOptions(nameof(CreateAsync_ShouldReturn_AttachmentDTO));
var mockAttachmentDTO = new Mock <AttachmentDTO>().Object;
var mockAttachment = new Mock <Attachment>().Object;
var mockAttachmentDTOMapper = new Mock <IAttachmentDTOMapper>();
mockAttachmentDTOMapper.Setup(a => a.MapFrom(mockAttachmentDTO)).Returns(mockAttachment);
mockAttachmentDTOMapper.Setup(a => a.MapFrom(mockAttachment)).Returns(mockAttachmentDTO);
using (var assertContext = new TBIAppDbContext(options))
{
var attachmentService = new AttachmentService(assertContext, mockAttachmentDTOMapper.Object);
var sut = await attachmentService.CreateAsync(mockAttachmentDTO);
Assert.IsInstanceOfType(sut, typeof(AttachmentDTO));
};
}
public async Task CreateAsync_ShoulCreate()
{
var options = TestUtilities.GetOptions(nameof(CreateAsync_ShoulCreate));
var mockAttachmentDTO = new Mock <AttachmentDTO>().Object;
var mockAttachment = new Mock <Attachment>().Object;
var mockAttachmentDTOMapper = new Mock <IAttachmentDTOMapper>();
mockAttachmentDTOMapper.Setup(a => a.MapFrom(mockAttachmentDTO)).Returns(mockAttachment);
var expectedResult = 1;
using (var assertContext = new TBIAppDbContext(options))
{
var attachmentService = new AttachmentService(assertContext, mockAttachmentDTOMapper.Object);
var sut = await attachmentService.CreateAsync(mockAttachmentDTO);
Assert.AreEqual(expectedResult, assertContext.Attachments.Count());
};
}
public async Task CreateAsync_ShouldCreate()
{
var options = TestUtilities.GetOptions(nameof(CreateAsync_ShouldCreate));
var mockApplication = new Mock <LoanApplication>().Object;
var mockApplicationDTO = new Mock <LoanApplicationDTO>().Object;
var mockLoanApplicationDTOMapper = new Mock <ILoanApplicationDTOMapper>();
mockLoanApplicationDTOMapper.Setup(am => am.MapFrom(mockApplicationDTO)).Returns(mockApplication);
var expected = 1;
using (var assertContext = new TBIAppDbContext(options))
{
var applicationService = new ApplicationService(assertContext, mockLoanApplicationDTOMapper.Object);
var sut = await applicationService.CreateAsync(mockApplicationDTO);
var count = assertContext.LoanApplications.Count();
Assert.AreEqual(expected, count);
}
}
public async Task LockButtonAsync_ShouldReturnTypeOfBool()
{
var options = TestUtilities.GetOptions(nameof(LockButtonAsync_ShouldReturnTypeOfBool));
var mockEmailDTOMapper = new Mock <IEmailDTOMapper>().Object;
var mockDecodeService = new Mock <IDecodeService>().Object;
var mockEncryptService = new Mock <IEncryptService>().Object;
var mockUserStore = new Mock <IUserStore <User> >();
var mockUserManager = new Mock <UserManager <User> >(mockUserStore.Object, null, null, null, null, null, null, null).Object;
var mockLogger = new Mock <ILogger <EmailService> >().Object;
var mockEmail = new Mock <Email>().Object;
var testId = "testId";
mockEmail.Id = testId;
mockEmail.IsOpne = false;
using (var actContext = new TBIAppDbContext(options))
{
await actContext.Emails.AddAsync(mockEmail);
await actContext.SaveChangesAsync();
}
using (var assertContext = new TBIAppDbContext(options))
{
var emailService = new EmailService(assertContext, mockEmailDTOMapper,
mockDecodeService, mockLogger, mockUserManager, mockEncryptService);
await emailService.LockButtonAsync(testId);
var email = assertContext.Emails.FirstOrDefault();
var sut = email.IsOpne;
Assert.IsInstanceOfType(sut, typeof(bool));
}
}
public async Task UnLockButtonAsync_ShouldSetIsOpenToFalse()
{
var options = TestUtilities.GetOptions(nameof(UnLockButtonAsync_ShouldSetIsOpenToFalse));
var mockEmailDTOMapper = new Mock <IEmailDTOMapper>().Object;
var mockDecodeService = new Mock <IDecodeService>().Object;
var mockEncryptService = new Mock <IEncryptService>().Object;
var mockUserStore = new Mock <IUserStore <User> >();
var mockUserManager = new Mock <UserManager <User> >(mockUserStore.Object, null, null, null, null, null, null, null).Object;
var mockLogger = new Mock <ILogger <EmailService> >().Object;
var mockEmail = new Mock <Email>().Object;
var testId = "testId";
mockEmail.Id = testId;
mockEmail.IsOpne = true;
var expectedResult = false;
using (var actContext = new TBIAppDbContext(options))
{
await actContext.Emails.AddAsync(mockEmail);
await actContext.SaveChangesAsync();
}
using (var assertContext = new TBIAppDbContext(options))
{
var emailService = new EmailService(assertContext, mockEmailDTOMapper,
mockDecodeService, mockLogger, mockUserManager, mockEncryptService);
await emailService.UnLockButtonAsync(testId);
var sut = assertContext.Emails.FirstOrDefault();
Assert.AreEqual(expectedResult, sut.IsOpne);
}
}
public async Task ChangeStatusAsync_ShouldThrow_ArgumentNullExs()
{
var options = TestUtilities.GetOptions(nameof(ChangeStatusAsync_ShouldThrow_ArgumentNullExs));
var mockEmailDTOMapper = new Mock <IEmailDTOMapper>().Object;
var mockDecodeService = new Mock <IDecodeService>().Object;
var mockEncryptService = new Mock <IEncryptService>().Object;
var mockUserStore = new Mock <IUserStore <User> >();
var mockUserManager = new Mock <UserManager <User> >(mockUserStore.Object, null, null, null, null, null, null, null).Object;
var mockLogger = new Mock <ILogger <EmailService> >().Object;
var testId = "testId";
var mockUser = new Mock <User>().Object;
var newEmailStatus = EmailStatusesEnum.Open;
using (var assertContext = new TBIAppDbContext(options))
{
var sut = new EmailService(assertContext, mockEmailDTOMapper,
mockDecodeService, mockLogger, null, mockEncryptService);
await sut.ChangeStatusAsync(testId, newEmailStatus, mockUser);
}
}
