public async Task ThrowExeptionWhenEmailDtoIsNullChangeEmailStatusFromClose_Test()
{
var firstEmail = EmailGeneratorUtil.GenerateEmailFirst();
firstEmail.EmailStatusId = 5;
var encodeDecodeServiceMock = new Mock <IEncodeDecodeService>().Object;
var loggerMock = new Mock <ILogger <EmailService> >().Object;
var options = TestUtilities.GetOptions(nameof(ThrowExeptionWhenEmailDtoIsNullChangeEmailStatusFromClose_Test));
using (var actContext = new E_MailApplicationsManagerContext(options))
{
var email = await actContext.Emails.AddAsync(firstEmail);
await actContext.SaveChangesAsync();
var dto = new EmailDto
{
GmailId = null
};
var sut = new EmailService(actContext, loggerMock, encodeDecodeServiceMock);
var result = await sut.ChangeEmailStatusFromClose(dto);
Assert.IsNotNull(result);
}
}
public async Task ChangeStatus_Test()
{
var status = "2";
var firstEmail = EmailGeneratorUtil.GenerateEmailFirst();
var encodeDecodeServiceMock = new Mock <IEncodeDecodeService>().Object;
var loggerMock = new Mock <ILogger <EmailService> >().Object;
var options = TestUtilities.GetOptions(nameof(ChangeStatus_Test));
using (var actContext = new E_MailApplicationsManagerContext(options))
{
var email = await actContext.Emails.AddAsync(firstEmail);
await actContext.SaveChangesAsync();
var dto = new EmailStatusIdDto
{
StatusId = status,
GmailId = email.Entity.GmailId
};
var sut = new EmailService(actContext, loggerMock, encodeDecodeServiceMock);
var result = await sut.ChangeStatusAsync(dto);
Assert.IsTrue(result);
}
}
public async Task TakeBody_Test()
{
var body = "TestBody";
var firstEmail = EmailGeneratorUtil.GenerateEmailFirst();
firstEmail.Body = body;
var encodeDecodeServiceMock = new Mock <IEncodeDecodeService>().Object;
var loggerMock = new Mock <ILogger <EmailService> >().Object;
var options = TestUtilities.GetOptions(nameof(TakeBody_Test));
using (var actContext = new E_MailApplicationsManagerContext(options))
{
var email = await actContext.Emails.AddAsync(firstEmail);
await actContext.SaveChangesAsync();
var dto = new EmailContentDto
{
GmailId = email.Entity.GmailId
};
var sut = new EmailService(actContext, loggerMock, encodeDecodeServiceMock);
var result = await sut.TakeBodyAsync(dto);
Assert.IsNotNull(result);
}
}
public async Task ThrowExeptionWhenCheckEmailBodyIsNull_Test()
{
string body = null;
var firstEmail = EmailGeneratorUtil.GenerateEmailFirst();
firstEmail.Body = body;
var encodeDecodeServiceMock = new Mock <IEncodeDecodeService>().Object;
var loggerMock = new Mock <ILogger <EmailService> >().Object;
var options = TestUtilities.GetOptions(nameof(ThrowExeptionWhenCheckEmailBodyIsNull_Test));
using (var actContext = new E_MailApplicationsManagerContext(options))
{
var email = await actContext.Emails.AddAsync(firstEmail);
await actContext.SaveChangesAsync();
var dto = new EmailContentDto
{
GmailId = firstEmail.GmailId,
};
var sut = new EmailService(actContext, loggerMock, encodeDecodeServiceMock);
await sut.CheckEmailBodyAsync(dto);
}
}
public async Task ThrowExeptionWhenGmailIdIsNull_ChangeStatus_Test()
{
var status = "2";
string gmailId = null;
var firstEmail = EmailGeneratorUtil.GenerateEmailFirst();
var encodeDecodeServiceMock = new Mock <IEncodeDecodeService>().Object;
var loggerMock = new Mock <ILogger <EmailService> >().Object;
var options = TestUtilities.GetOptions(nameof(ThrowExeptionWhenGmailIdIsNull_ChangeStatus_Test));
using (var actContext = new E_MailApplicationsManagerContext(options))
{
var email = await actContext.Emails.AddAsync(firstEmail);
await actContext.SaveChangesAsync();
var dto = new EmailStatusIdDto
{
StatusId = status,
GmailId = gmailId
};
var sut = new EmailService(actContext, loggerMock, encodeDecodeServiceMock);
await sut.ChangeStatusAsync(dto);
}
}
public async Task ThrowExeptionWhenEmailBodyIsToLong_AddBodyToCurrentEmailAsync_Test()
{
var firstEmail = EmailGeneratorUtil.GenerateEmailFirst();
var body = new String('T', 1001);
var encodeDecodeServiceMock = new Mock <IEncodeDecodeService>().Object;
var loggerMock = new Mock <ILogger <EmailService> >().Object;
var options = TestUtilities.GetOptions(nameof(ThrowExeptionWhenEmailBodyIsToLong_AddBodyToCurrentEmailAsync_Test));
using (var actContext = new E_MailApplicationsManagerContext(options))
{
var email = await actContext.Emails.AddAsync(firstEmail);
await actContext.SaveChangesAsync();
var emailDto = new EmailContentDto
{
Body = body,
GmailId = firstEmail.GmailId
};
var sut = new EmailService(actContext, loggerMock, encodeDecodeServiceMock);
await sut.AddBodyToCurrentEmailAsync(emailDto);
}
}
public async Task SetEmailStatusInvalidApplication_Test()
{
var user = UserGeneratorUtil.GenerateUser();
var firstEmail = EmailGeneratorUtil.GenerateEmailFirst();
var encodeDecodeServiceMock = new Mock <IEncodeDecodeService>().Object;
var loggerMock = new Mock <ILogger <EmailService> >().Object;
var options = TestUtilities.GetOptions(nameof(SetEmailStatusInvalidApplication_Test));
using (var actContext = new E_MailApplicationsManagerContext(options))
{
var email = await actContext.Emails.AddAsync(firstEmail);
var currentUser = await actContext.AddAsync(user);
await actContext.SaveChangesAsync();
var dto = new StatusInvalidApplicationDto
{
GmailId = firstEmail.GmailId,
UserId = currentUser.Entity.Id
};
var sut = new EmailService(actContext, loggerMock, encodeDecodeServiceMock);
var result = await sut.SetEmailStatusInvalidApplicationAsync(dto);
Assert.IsTrue(result);
}
}
public async Task AddEmail_Test()
{
var firstEmail = EmailGeneratorUtil.GenerateEmailFirst();
var encodeDecodeServiceMock = new Mock <IEncodeDecodeService>().Object;
var loggerMock = new Mock <ILogger <EmailService> >().Object;
var options = TestUtilities.GetOptions(nameof(AddEmail_Test));
using (var actContext = new E_MailApplicationsManagerContext(options))
{
var email = await actContext.Emails.AddAsync(firstEmail);
await actContext.SaveChangesAsync();
var emailDto = new EmailDto
{
Subject = firstEmail.Subject,
Sender = firstEmail.Sender,
DateReceived = firstEmail.DateReceived,
GmailId = firstEmail.GmailId
};
var sut = new EmailService(actContext, loggerMock, encodeDecodeServiceMock);
var result = sut.AddMailAsync(emailDto);
Assert.IsNotNull(result);
}
using (var assertContext = new E_MailApplicationsManagerContext(options))
{
Assert.AreEqual(1, assertContext.Emails.Count());
}
}
public async Task ThrowException_IfUsernameIsLessThanThreeSymbols()
{
var username = "******";
var password = "******";
var email = "TestEmail";
var role = "TestRole";
var loggerMock = new Mock <ILogger <UserService> >().Object;
var options = TestUtilities.GetOptions(nameof(ThrowException_IfUsernameIsLessThanThreeSymbols));
using (var actContext = new E_MailApplicationsManagerContext(options))
{
var accountDto = new RegisterAccountDto
{
UserName = username,
Password = password,
Role = role,
Email = email
};
var accountService = new UserService(actContext, null, loggerMock);
await accountService.RegisterAccountAsync(accountDto);
}
}
public async Task ThrowExeptionWhenUserEmailIsMoreThanMaxLength_Test()
{
var username = "******";
var password = "******";
var email = new String('T', 51);
var role = "Manager";
var loggerMock = new Mock <ILogger <UserService> >().Object;
var options = TestUtilities.GetOptions(nameof(ThrowExeptionWhenUserEmailIsMoreThanMaxLength_Test));
using (var actContext = new E_MailApplicationsManagerContext(options))
{
var accountDto = new RegisterAccountDto
{
UserName = username,
Password = password,
Role = role,
Email = email
};
var accountService = new UserService(actContext, null, loggerMock);
await accountService.RegisterAccountAsync(accountDto);
}
}
public async Task ThrowExeptionWhenGmailIdIsWithMaxLanght_Test()
{
var subject = "TestSubject";
var dateReceived = "TestDate";
var sender = "TestSender";
var gmailId = new String('T', 101);
var encodeDecodeServiceMock = new Mock <IEncodeDecodeService>().Object;
var loggerMock = new Mock <ILogger <EmailService> >().Object;
var options = TestUtilities.GetOptions(nameof(ThrowExeptionWhenGmailIdIsWithMaxLanght_Test));
using (var actContext = new E_MailApplicationsManagerContext(options))
{
var sut = new EmailService(actContext, loggerMock, encodeDecodeServiceMock);
var emailDto = new EmailDto
{
GmailId = gmailId,
Subject = subject,
Sender = sender,
DateReceived = dateReceived
};
await sut.AddMailAsync(emailDto);
}
}
public async Task ListEmailsWithStatusOpenAsync_Test()
{
var firstEmail = EmailGeneratorUtil.GenerateEmailFirst();
firstEmail.EmailStatusId = (int)EmailStatusesType.Open;
var userId = firstEmail.UserId;
var loanApplicantDto = new LoanApplicantDto
{
UserId = userId,
};
var options = TestUtilities.GetOptions(nameof(ListEmailsWithStatusOpenAsync_Test));
using (var actContext = new E_MailApplicationsManagerContext(options))
{
await actContext.Emails.AddAsync(firstEmail);
await actContext.SaveChangesAsync();
var sut = new SearchService(actContext);
var result = await sut.ListEmailsWithStatusOpenAsync(loanApplicantDto);
Assert.IsNotNull(result);
}
}
public async Task ThrowExeptionWhenPhoneNumberIsNullInFormForLoan_Test()
{
var loanUtil = LoanGeneratorUtil.GenerateLoan();
loanUtil.PhoneNumber = null;
var mockEncodeDecodeService = new Mock <IEncodeDecodeService>().Object;
var options = TestUtilities.GetOptions(nameof(ThrowExeptionWhenPhoneNumberIsNullInFormForLoan_Test));
using (var actContext = new E_MailApplicationsManagerContext(options))
{
var loanDto = new LoanApplicantDto
{
Name = loanUtil.Name,
EGN = loanUtil.EGN,
PhoneNumber = loanUtil.PhoneNumber,
GmailId = loanUtil.GmailId
};
var sut = new LoanService(actContext, mockEncodeDecodeService);
await sut.FillInFormForLoanAsync(loanDto);
}
}
public async Task MappGmailBodyIntoEmailBody_Test()
{
var firstEmail = EmailGeneratorUtil.GenerateEmailFirst();
string body = "TestBody";
var emailServiceMock = new Mock <IEmailService>().Object;
var options = TestUtilities.GetOptions(nameof(MappGmailBodyIntoEmailBody_Test));
using (var actContext = new E_MailApplicationsManagerContext(options))
{
await actContext.Emails.AddAsync(firstEmail);
await actContext.SaveChangesAsync();
var sut = new MapperService(emailServiceMock);
await sut.MappGmailBodyIntoEmailBody(firstEmail.GmailId, body, firstEmail.UserId);
var emailBody = actContext.Emails
.Where(b => b.Body == body)
.FirstOrDefaultAsync();
Assert.IsNotNull(emailBody);
}
}
public async Task GetAllEmailAsyncByStatus_Test()
{
var status = "2";
var firstEmail = EmailGeneratorUtil.GenerateEmailFirst();
firstEmail.EmailStatusId = (int)EmailStatusesType.InvalidApplication;
var options = TestUtilities.GetOptions(nameof(GetAllEmailAsyncByStatus_Test));
using (var actContext = new E_MailApplicationsManagerContext(options))
{
await actContext.Emails.AddAsync(firstEmail);
await actContext.SaveChangesAsync();
var statusDto = new EmailStatusIdDto
{
StatusId = status
};
var sut = new SearchService(actContext);
var result = await sut.SearchEamilByStatusIdAsync(statusDto);
Assert.IsNotNull(result);
}
}
public async Task GetAllNotReviewedEmails_Test()
{
var firstEmail = EmailGeneratorUtil.GenerateEmailFirst();
firstEmail.EmailStatusId = (int)EmailStatusesType.NotReviewed;
var secondEmail = EmailGeneratorUtil.GenerateEmailSecond();
firstEmail.EmailStatusId = (int)EmailStatusesType.NotReviewed;
var options = TestUtilities.GetOptions(nameof(GetEmailsForChart_Test));
using (var actContext = new E_MailApplicationsManagerContext(options))
{
await actContext.Emails.AddAsync(firstEmail);
await actContext.Emails.AddAsync(secondEmail);
await actContext.SaveChangesAsync();
var sut = new SearchService(actContext);
var result = await sut.GetAllNotReviewedEmails();
Assert.AreEqual(2, result);
}
}
public async Task GetAllUserWorkingOnEmail_Test()
{
var firstEmail = EmailGeneratorUtil.GenerateEmailFirst();
var secondEmail = EmailGeneratorUtil.GenerateEmailSecond();
var userId = secondEmail.UserId;
var emailContentDto = new EmailContentDto
{
UserId = userId
};
var options = TestUtilities.GetOptions(nameof(GetAllUserWorkingOnEmail_Test));
using (var actContext = new E_MailApplicationsManagerContext(options))
{
await actContext.Emails.AddAsync(firstEmail);
await actContext.Emails.AddAsync(secondEmail);
await actContext.SaveChangesAsync();
var sut = new SearchService(actContext);
var result = await sut.GetAllUserWorkingOnEmailAsync(emailContentDto);
Assert.IsNotNull(result);
}
}
public async Task FillInFormForLoan_Test()
{
var loanUtil = LoanGeneratorUtil.GenerateLoan();
var firstEmail = EmailGeneratorUtil.GenerateEmailFirst();
var mockEncodeDecodeService = new Mock <IEncodeDecodeService>().Object;
var options = TestUtilities.GetOptions(nameof(FillInFormForLoan_Test));
using (var actContext = new E_MailApplicationsManagerContext(options))
{
var email = await actContext.Emails.AddAsync(firstEmail);
await actContext.SaveChangesAsync();
var loanDto = new LoanApplicantDto
{
Name = loanUtil.Name,
EGN = loanUtil.EGN,
PhoneNumber = loanUtil.PhoneNumber,
GmailId = loanUtil.GmailId,
UserId = loanUtil.GmailId
};
var sut = new LoanService(actContext, mockEncodeDecodeService);
var result = await sut.FillInFormForLoanAsync(loanDto);
Assert.IsNotNull(result);
}
}
public async Task ThrowExeptionWhenNewPassworDtoIsNull_ChangePassword_Test()
{
string newPassword = null;
var user = UserGeneratorUtil.GenerateUser();
var loggerMock = new Mock <ILogger <UserService> >().Object;
var options = TestUtilities.GetOptions(nameof(ThrowExeptionWhenNewPassworDtoIsNull_ChangePassword_Test));
using (var actContext = new E_MailApplicationsManagerContext(options))
{
await actContext.Users.AddAsync(user);
await actContext.SaveChangesAsync();
}
using (var assertContext = new E_MailApplicationsManagerContext(options))
{
var dto = new ChangePasswordDto
{
NewPassword = newPassword,
OldPassword = user.PasswordHash,
UserId = user.Id
};
var sut = new UserService(assertContext, null, loggerMock);
await sut.ChangePasswordAsync(dto);
}
}
public async Task MappGmailAttachmentIntoEmailAttachment_Test()
{
var firstEmail = EmailGeneratorUtil.GenerateEmailFirst();
var gmailId = firstEmail.GmailId;
var FileName = "TestFileName";
double fileSize = 876.77;
var emailServiceMock = new Mock <IEmailService>().Object;
var options = TestUtilities.GetOptions(nameof(MappGmailAttachmentIntoEmailAttachment_Test));
using (var actContext = new E_MailApplicationsManagerContext(options))
{
var sut = new MapperService(emailServiceMock);
await sut.MappGmailAttachmentIntoEmailAttachment(gmailId, FileName, fileSize);
await actContext.SaveChangesAsync();
var attachment = actContext.LoanApplicants.Where(b => b.GmailId == firstEmail.GmailId).FirstOrDefaultAsync();
Assert.IsNotNull(attachment);
}
}
public EmailService(E_MailApplicationsManagerContext context, ILogger <EmailService> logger,
IEncodeDecodeService encodeDecodeService)
{
this.context = context;
this.logger = logger;
this.encodeDecodeService = encodeDecodeService;
}
public async Task SaveLastLoginUserReturFalseWhenUserIsNull_Test()
{
var user = UserGeneratorUtil.GenerateUser();
user = null;
var options = TestUtilities.GetOptions(nameof(SaveLastLoginUserReturFalseWhenUserIsNull_Test));
using (var actContext = new E_MailApplicationsManagerContext(options))
{
var sut = new LogService(actContext);
var result = await sut.SaveLastLoginUser(user);
Assert.IsFalse(result);
}
}
public void CheckEmailForDigitReturnFalse_Test()
{
var egn = "7802120e67";
var mockEncodeDecodeService = new Mock <IEncodeDecodeService>().Object;
var options = TestUtilities.GetOptions(nameof(CheckEmailForDigitReturnFalse_Test));
using (var actContext = new E_MailApplicationsManagerContext(options))
{
var sut = new LoanService(actContext, mockEncodeDecodeService);
var result = sut.CheckEGNForDigit(egn);
Assert.IsFalse(result);
}
}
public async Task SaveLastLoginUser_Test()
{
var user = UserGeneratorUtil.GenerateUser();
var options = TestUtilities.GetOptions(nameof(SaveLastLoginUser_Test));
using (var actContext = new E_MailApplicationsManagerContext(options))
{
await actContext.Users.AddAsync(user);
await actContext.SaveChangesAsync();
var sut = new LogService(actContext);
var result = await sut.SaveLastLoginUser(user);
Assert.IsTrue(result);
}
}
public async Task ApproveLoan_Test()
{
var expectedResult = "1";
var loanUtil = LoanGeneratorUtil.GenerateLoan();
var firstEmail = EmailGeneratorUtil.GenerateEmailFirst();
var mockEncodeDecodeService = new Mock <IEncodeDecodeService>().Object;
var options = TestUtilities.GetOptions(nameof(ApproveLoan_Test));
using (var actContext = new E_MailApplicationsManagerContext(options))
{
var loan = await actContext.LoanApplicants.AddAsync(
new LoanApplicant
{
GmailId = loanUtil.GmailId,
EGN = loanUtil.GmailId,
Name = loanUtil.Name,
PhoneNumber = loanUtil.PhoneNumber,
UserId = loanUtil.UserId
});
await actContext.Emails.AddAsync(firstEmail);
await actContext.SaveChangesAsync();
var loanDto = new ApproveLoanDto
{
GmailId = loanUtil.GmailId,
IsApprove = expectedResult
};
var sut = new LoanService(actContext, mockEncodeDecodeService);
var result = await sut.ApproveLoanAsync(loanDto);
Assert.IsTrue(result);
}
}
public async Task FindLoansByIdAsync_Test()
{
var id = 2;
var options = TestUtilities.GetOptions(nameof(FindLoansByIdAsync_Test));
using (var actContext = new E_MailApplicationsManagerContext(options))
{
await actContext.LoanApplicants.AddAsync(new LoanApplicant { Id = id });
await actContext.SaveChangesAsync();
}
using (var assertContext = new E_MailApplicationsManagerContext(options))
{
var sut = new SearchService(assertContext);
var findEmail = await sut.FindLoansByIdAsync(id);
Assert.IsNotNull(findEmail);
}
}
public async Task GetAllFinishLoanApplicantAsync_Test()
{
var firstEmail = EmailGeneratorUtil.GenerateEmailFirst();
firstEmail.EmailStatusId = (int)EmailStatusesType.Closed;
var options = TestUtilities.GetOptions(nameof(GetAllFinishLoanApplicantAsync_Test));
using (var actContext = new E_MailApplicationsManagerContext(options))
{
await actContext.Emails.AddAsync(firstEmail);
await actContext.SaveChangesAsync();
var sut = new SearchService(actContext);
var result = await sut.GetAllFinishLoanApplicantAsync();
Assert.IsNotNull(result);
}
}
public async Task MappGmailDataIntoEmailData_Test()
{
var firstEmail = EmailGeneratorUtil.GenerateEmailFirst();
var emailServiceMock = new Mock <IEmailService>().Object;
var options = TestUtilities.GetOptions(nameof(MappGmailDataIntoEmailData_Test));
using (var actContext = new E_MailApplicationsManagerContext(options))
{
var sut = new MapperService(emailServiceMock);
await sut.MappGmailDataIntoEmailData(firstEmail.GmailId, firstEmail.DateReceived, firstEmail.Sender, firstEmail.Subject);
await actContext.SaveChangesAsync();
var email = actContext.Emails.Where(b => b.GmailId == firstEmail.GmailId).FirstOrDefaultAsync();
Assert.IsNotNull(email);
}
}
public async Task AddAttachment_Test()
{
var gmailId = "TestGmailId";
var FileName = "TestFileName";
double fileSize = 876.77;
var encodeDecodeServiceMock = new Mock <IEncodeDecodeService>().Object;
var loggerMock = new Mock <ILogger <EmailService> >().Object;
var options = TestUtilities.GetOptions(nameof(AddAttachment_Test));
using (var actContext = new E_MailApplicationsManagerContext(options))
{
await actContext.EmailAttachments.AddAsync(
new EmailAttachment
{
GmailId = gmailId,
FileName = FileName,
SizeInKB = fileSize
});
await actContext.SaveChangesAsync();
var ettachmentDto = new EmailAttachmentDTO
{
FileName = FileName,
GmailId = gmailId,
SizeInKB = fileSize
};
var sut = new EmailService(actContext, loggerMock, encodeDecodeServiceMock);
var result = sut.AddAttachmentAsync(ettachmentDto);
Assert.IsNotNull(result);
}
using (var assertContext = new E_MailApplicationsManagerContext(options))
{
Assert.AreEqual(2, assertContext.EmailAttachments.Count());
}
}
public async Task ThrowExeptionWhenExpectedResultIsNullIn_ApproveLoan_Test()
{
string expectedResult = null;
var gmailId = "TestGmailId";
var mockEncodeDecodeService = new Mock <IEncodeDecodeService>().Object;
var options = TestUtilities.GetOptions(nameof(ThrowExeptionWhenExpectedResultIsNullIn_ApproveLoan_Test));
using (var actContext = new E_MailApplicationsManagerContext(options))
{
var loanDto = new ApproveLoanDto
{
GmailId = gmailId,
IsApprove = expectedResult
};
var sut = new LoanService(actContext, mockEncodeDecodeService);
await sut.ApproveLoanAsync(loanDto);
}
}
