public When_Qualification_MissingQualification_Is_Loaded()
{
var routes = new List <RouteSummaryViewModel>
{
new RouteSummaryViewModel {
Id = 1, Name = "Route 1", Summary = "Route Summary 1"
},
new RouteSummaryViewModel {
Id = 2, Name = "Route 2", Summary = "Route Summary 2"
}
};
_qualificationService = Substitute.For <IQualificationService>();
_qualificationService.GetLarTitleAsync("12345678").Returns("LAR title from lookup");
var providerVenueService = Substitute.For <IProviderVenueService>();
providerVenueService.GetVenuePostcodeAsync(1).Returns("CV1 2WT");
_routePathService = Substitute.For <IRoutePathService>();
_routePathService.GetRouteSummaryAsync().Returns(routes);
var providerQualificationService = Substitute.For <IProviderQualificationService>();
var qualificationController = new QualificationController(providerVenueService, _qualificationService, providerQualificationService, _routePathService);
_result = qualificationController.MissingQualificationAsync(1, "12345678").GetAwaiter().GetResult();
}
public async Task GetLargeQualificationSupplierDetailsTest()
{
_claims = new Claim[1] {
new Claim(IdentityConfigs.Claims.SelectedCR, "2050038794")
};
_qualificationController = _qualificationController.WithIdentity(_claims);
int qualificationId = 457;
decimal cashMax = 5;
decimal cashMin = 2;
decimal financialCapacity = 50;
decimal technicalAdministrativeCapacity = 50;
decimal tenderPointsToPass = 5;
decimal totalEmployeeCountMax = 5;
decimal totalEmployeeCountMin = 2;
decimal totalEmployeeCountWeight = 50;
decimal totalEmployeePercentageMax = 5;
var result = await _qualificationController.GetLargeQualificationSupplierDetails(qualificationId);
Assert.NotNull(result);
Assert.Equal(result.CashRateMax, cashMax);
Assert.Equal(result.CashRateMin, cashMin);
Assert.Equal(result.FinancialCapacity, financialCapacity);
Assert.Equal(result.TechnicalAdministrativeCapacity, technicalAdministrativeCapacity);
Assert.Equal(result.TenderPointsToPass, tenderPointsToPass);
Assert.Equal(result.TotalEmployeeCountMax, totalEmployeeCountMax);
Assert.Equal(result.TotalEmployeeCountMin, totalEmployeeCountMin);
Assert.Equal(result.TotalEmployeeCountWeight, totalEmployeeCountWeight);
Assert.Equal(result.TotalEmployeePercentageMax, totalEmployeePercentageMax);
}
public void TestPostQualificationController_RedirectingCorrectly()
{
Mock <IStudentEducationBusinessAccess> mock = new Mock <IStudentEducationBusinessAccess>();
mock.Setup(x => x.InsertStudentEducationInfoIntoDatabase(student));
Mock <HttpSessionStateBase> session = new Mock <HttpSessionStateBase>();
session.Setup(s => s["marks"]).Returns(90);
Mock <HttpContextBase> httpContext = new Mock <HttpContextBase>();
httpContext.SetupGet(c => c.Session).Returns(session.Object);
ControllerContext ctx = new ControllerContext();
ctx.HttpContext = httpContext.Object;
QualificationController controller = new QualificationController(mock.Object);
controller.ControllerContext = ctx;
RedirectToRouteResult result = controller.QualificationInfo(student) as RedirectToRouteResult;
Assert.That(result.RouteValues["action"], Is.EqualTo("DecisionInfo"));
}
public void TestQualificationController_ReturningCorrectView()
{
QualificationController qualificationController = new QualificationController();
ViewResult result = qualificationController.QualificationInfo() as ViewResult;
Assert.That(result.ViewName, Is.EqualTo("QualificationInfo"));
}
public void TestPostQualificationController_WhenExceptionOccurs()
{
Mock <IStudentEducationBusinessAccess> mock = new Mock <IStudentEducationBusinessAccess>();
Exception exception = new Exception();
mock.Setup(x => x.InsertStudentEducationInfoIntoDatabase(student)).Throws(exception);
Mock <HttpSessionStateBase> session = new Mock <HttpSessionStateBase>();
session.Setup(s => s["marks"]).Returns(90);
Mock <HttpContextBase> httpContext = new Mock <HttpContextBase>();
httpContext.SetupGet(c => c.Session).Returns(session.Object);
ControllerContext ctx = new ControllerContext();
ctx.HttpContext = httpContext.Object;
QualificationController controller = new QualificationController(mock.Object);
controller.ControllerContext = ctx;
ViewResult result = controller.QualificationInfo(student) as ViewResult;
Assert.That(result.ViewName, Is.EqualTo("Error"));
}
public When_Qualification_SaveQualification_Has_No_Selected_Routes()
{
var qualificationService = Substitute.For <IQualificationService>();
var providerVenueService = Substitute.For <IProviderVenueService>();
var providerQualificationService = Substitute.For <IProviderQualificationService>();
var routePathService = Substitute.For <IRoutePathService>();
var qualificationController = new QualificationController(providerVenueService, qualificationService,
providerQualificationService, routePathService);
var controllerWithClaims = new ClaimsBuilder <QualificationController>(qualificationController)
.AddUserName("username")
.AddEmail("*****@*****.**")
.Build();
var viewModel = new SaveQualificationViewModel
{
QualificationId = 1,
Title = "Qualification title",
ShortTitle = new string("Short Title"),
Source = "Test",
Routes = new List <RouteSummaryViewModel>
{
new RouteSummaryViewModel
{
Id = 1,
Name = "Route 1",
IsSelected = false
}
}
};
_result = controllerWithClaims.SaveQualificationAsync(viewModel).GetAwaiter().GetResult();
}
public When_Qualification_Save_MissingQualification_Short_Title_Is_Too_Long()
{
var qualificationService = Substitute.For <IQualificationService>();
var providerVenueService = Substitute.For <IProviderVenueService>();
var providerQualificationService = Substitute.For <IProviderQualificationService>();
var routePathService = Substitute.For <IRoutePathService>();
var qualificationController = new QualificationController(providerVenueService, qualificationService,
providerQualificationService, routePathService);
var controllerWithClaims = new ClaimsBuilder <QualificationController>(qualificationController)
.AddUserName("username")
.AddEmail("*****@*****.**")
.Build();
var viewModel = new MissingQualificationViewModel
{
ProviderVenueId = 1,
LarId = "12345678",
QualificationId = 1,
Title = "Qualification title",
ShortTitle = new string('X', 101),
Routes = new List <RouteSummaryViewModel>
{
new RouteSummaryViewModel
{
Id = 1,
Name = "Route 1",
IsSelected = true
}
}
};
_result = controllerWithClaims.SaveMissingQualificationAsync(viewModel).GetAwaiter().GetResult();
}
public QualificationApiControllertest()
{
var serviceProvider = services.BuildServiceProvider();
tenderService = serviceProvider.GetService <ITenderAppService>();
qualificationAppService = serviceProvider.GetService <IQualificationAppService>();
iDMAppService = serviceProvider.GetService <IIDMAppService>();
lookupAppService = serviceProvider.GetService <ILookUpService>();
supplierqualificationService = serviceProvider.GetService <ISupplierQualificationDocumentAppService>();
verificationService = serviceProvider.GetService <IVerificationService>();
//Configure mapping just for this test
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap <PreQualificationBasicDetailsModel, PreQualificationBasicDetailsModel>();
cfg.CreateMap <MOF.Etimad.Monafasat.Core.Entities.Tender, PreQualificationSavingModel>();
cfg.ValidateInlineMaps = false;
});
mapper = config.CreateMapper();
_mockRootConfiguration = MockHelper.CreateIOptionSnapshotMock(new MOF.Etimad.Monafasat.SharedKernal.RootConfigurations());
//verificationService = new Mock<IVerificationService>().Object;
authorizationService = new Mock <IAuthorizationService>().Object;
supplierService = new Mock <ISupplierService>().Object;
offerAppService = new Mock <IOfferAppService>().Object;
supplierQualificationDocumentDomainService = new Mock <ISupplierQualificationDocumentDomainService>().Object;
memoryCache = new Mock <IMemoryCache>().Object;
branchAppService = new Mock <IBranchAppService>().Object;
_qualificationController = new QualificationController(supplierqualificationService, qualificationAppService, mapper, verificationService,
iDMAppService, authorizationService, supplierService, offerAppService, lookupAppService, tenderService, supplierQualificationDocumentDomainService, _mockRootConfiguration);
_lookupController = new LookupController(lookupAppService, mapper, iDMAppService, branchAppService, memoryCache, _mockRootConfiguration);
}
public When_Qualification_Add_Qualification_Does_Not_Exist()
{
var providerVenueService = Substitute.For <IProviderVenueService>();
_qualificationService = Substitute.For <IQualificationService>();
_qualificationService.IsValidLarIdAsync("12345678").Returns(true);
_qualificationService.GetQualificationAsync("12345678").ReturnsNull();
_qualificationService.IsValidOfqualLarIdAsync("12345678").Returns(true);
_providerQualificationService = Substitute.For <IProviderQualificationService>();
var routePathService = Substitute.For <IRoutePathService>();
var qualificationController = new QualificationController(providerVenueService, _qualificationService, _providerQualificationService, routePathService);
var controllerWithClaims = new ClaimsBuilder <QualificationController>(qualificationController)
.AddUserName("username")
.AddEmail("*****@*****.**")
.Build();
var viewModel = new AddQualificationViewModel
{
ProviderVenueId = 1,
LarId = "12345678",
Postcode = "CV1 2WT"
};
_result = controllerWithClaims.CreateQualificationAsync(viewModel).GetAwaiter().GetResult();
}
public async Task GetStatusFblagTest()
{
_claims = new Claim[1] {
new Claim(IdentityConfigs.Claims.Role, RoleNames.ApprovePlaintDataPolicy)
};
_qualificationController = _qualificationController.WithIdentity(_claims);
var response = await _qualificationController.GetStatusFlag();
Assert.True(response);
}
public async Task ApprvePreQualificationTest()
{
_claims = new Claim[2] {
new Claim(IdentityConfigs.Claims.SelectedGovAgency, "022001000000,022001000000"),
new Claim(IdentityConfigs.Claims.BranchId, "1")
};
_qualificationController = _qualificationController.WithIdentity(_claims);
await _qualificationController.ApprvePreQualification(702, "0");
}
public async Task ReopenPreQualificationFromCommitteeSecrtaryTest()
{
_claims = new Claim[2] {
new Claim(IdentityConfigs.Claims.SelectedGovAgency, "022001000000,022001000000"),
new Claim(IdentityConfigs.Claims.BranchId, "1")
};
_qualificationController = _qualificationController.WithIdentity(_claims);
await _qualificationController.ReopenPreQualificationFromCommitteeSecrtary(706);
}
public void TestPostQualificationController_WhenModelStateIsInvalid()
{
QualificationController controller = new QualificationController();
controller.ModelState.AddModelError("xyz", "An error has occured");
ViewResult result = controller.QualificationInfo(student2) as ViewResult;
Assert.That(result.ViewName, Is.EqualTo("QualificationInfo"));
}
public async Task SendQualificationToCommitteeApproveTest()
{
_claims = new Claim[2] {
new Claim(IdentityConfigs.Claims.SelectedGovAgency, "022001000000,022001000000"),
new Claim(IdentityConfigs.Claims.BranchId, "1")
};
_qualificationController = _qualificationController.WithIdentity(_claims);
await _qualificationController.SendQualificationToCommitteeApprove(700);
}
public async Task GetPreQualificationDetailsForCheckingTest()
{
int tenderid = 220;
_claims = new Claim[1] {
new Claim(IdentityConfigs.Claims.CommitteeId, CommitteeType.TechincalCommittee.ToString())
};
_qualificationController = _qualificationController.WithIdentity(_claims);
await Assert.ThrowsAsync <AuthorizationException>(() => _qualificationController.GetPreQualificationDetailsForChecking(tenderid));
}
public async Task SendPreQualificationToApproveTest()
{
_claims = new Claim[2] {
new Claim(IdentityConfigs.Claims.SelectedGovAgency, "022001000000,022001000000"),
new Claim(IdentityConfigs.Claims.BranchId, "1")
};
_qualificationController = _qualificationController.WithIdentity(_claims);
int id = Util.Decrypt("S5w4nQxXBKMJK*@@**UCTg3n0A==");
await _qualificationController.SendPreQualificationToApprove(id);
}
public async Task AddQualificationToSupplierFavouriteListAsyncTest()
{
_claims = new Claim[1] {
new Claim(IdentityConfigs.Claims.Role, RoleNames.MonafasatAccountManager)
};
_qualificationController = _qualificationController.WithIdentity(_claims);
int tenderid = 653;
var result = await _qualificationController.AddQualificationToSupplierFavouriteList(tenderid);
Assert.True(result);
}
public async Task GetPrequalificationStatusTest()
{
_claims = new Claim[1] {
new Claim(IdentityConfigs.Claims.SelectedCR, "2050038794")
};
_qualificationController = _qualificationController.WithIdentity(_claims);
int qualificationId = 208;
var result = await _qualificationController.GetPrequalificationStatus(qualificationId);
Assert.Equal(result, (int)Enums.TenderStatus.DocumentChecking);
}
public async Task PreQualificationApprovalTest()
{
_claims = new Claim[1] {
new Claim(IdentityConfigs.Claims.SelectedGovAgency, "022001000000,022001000000")
};
_qualificationController = _qualificationController.WithIdentity(_claims);
int tenderid = 653;
var result = await _qualificationController.GetPreQualificationForApproval(tenderid);
Assert.NotNull(result);
Assert.Equal(result.PreQualificationId, tenderid);
}
public async Task GetPreQualificationDetailsForSupplierTest()
{
_claims = new Claim[1] {
new Claim(IdentityConfigs.Claims.Role, RoleNames.MonafasatAccountManager)
};
_qualificationController = _qualificationController.WithIdentity(_claims);
int qualificationId = 295;
var result = await _qualificationController.GetPreQualificationDetailsForSupplier(qualificationId);
Assert.NotNull(result);
Assert.Equal(result.Id, qualificationId);
}
public async Task GetPreQualificationForUnderOperationsStageIndexTest()
{
_claims = new Claim[1] {
new Claim(IdentityConfigs.Claims.BranchId, "1")
};
_qualificationController = _qualificationController.WithIdentity(_claims);
var requestModel = new PreQualificationSearchCriteriaModel()
{
};
var result = await _qualificationController.GetPreQualificationForUnderOperationsStageIndex(requestModel);
Assert.NotNull(result);
}
public async Task RejectApprvePreQualificationTest()
{
_claims = new Claim[2] {
new Claim(IdentityConfigs.Claims.SelectedGovAgency, "022001000000,022001000000"),
new Claim(IdentityConfigs.Claims.BranchId, "1")
};
_qualificationController = _qualificationController.WithIdentity(_claims);
RejectionModel model = new RejectionModel()
{
TenderId = 703, RejectionReason = "reason"
};
await _qualificationController.RejectApprvePreQualification(model);
}
public async Task ChooseQualificationResultTest()
{
_claims = new Claim[2] {
new Claim(IdentityConfigs.Claims.SelectedGovAgency, "022001000000,022001000000"),
new Claim(IdentityConfigs.Claims.BranchId, "1")
};
_qualificationController = _qualificationController.WithIdentity(_claims);
ChooseQualificationResultModel model = new ChooseQualificationResultModel()
{
QualificationId = 629, FailingReason = "reason", FinalResultStatusId = (int)Enums.QualificationResultLookup.Failed, SupplierId = "1010000154"
};
await _qualificationController.ChooseQualificationResult(model);
}
public async Task GetPreQualificationDetailsTest()
{
_claims = new Claim[1] {
new Claim(IdentityConfigs.Claims.Role, RoleNames.MonafasatAccountManager)
};
_qualificationController = _qualificationController.WithIdentity(_claims);
int qualificationId = 295;
string referenceNumber = "191139000437";
var result = await _qualificationController.GetPreQualificationDetails(qualificationId);
Assert.NotNull(result);
Assert.Equal(result.ReferenceNumber, referenceNumber);
}
public async Task GetQualificationsListForVisitorTest()
{
_claims = new Claim[1] {
new Claim(IdentityConfigs.Claims.Role, RoleNames.supplier)
};
_qualificationController = _qualificationController.WithIdentity(_claims);
var requestModel = new PreQualificationSearchCriteriaModel()
{
};
var result = await _qualificationController.GetQualificationsListForVisitor(requestModel);
Assert.NotNull(result);
Assert.NotEmpty(result.Items);
}
public async Task GetSupplierDataReviewModelTest()
{
_claims = new Claim[1] {
new Claim(IdentityConfigs.Claims.Role, RoleNames.MonafasatAccountManager)
};
_qualificationController = _qualificationController.WithIdentity(_claims);
int qualificationId = 208;
string SupplierId = "142154293000206";
var result = await _qualificationController.GetSupplierDataReviewModel(qualificationId, SupplierId);
Assert.NotNull(result);
Assert.Equal(result.QualificationTypeId, (int)Enums.PreQualificationType.Small);
Assert.Equal(result.SupplierCR, SupplierId);
}
public async Task ReopenPostQualificationCheckingTest()
{
_claims = new Claim[2] {
new Claim(IdentityConfigs.Claims.SelectedGovAgency, "022001000000,022001000000"),
new Claim(IdentityConfigs.Claims.BranchId, "1")
};
_qualificationController = _qualificationController.WithIdentity(_claims);
var result = await _qualificationController.ReopenPostQualificationChecking(687);
Assert.NotNull(result);
Assert.Equal("022001000000", result.AgencyCode);
Assert.Equal(1, result.BranchId);
Assert.Equal(3, result.TechnicalOrganizationId);
}
public async Task ReopenPostQualificationCheckingAsync()
{
_claims = new Claim[1] {
new Claim(IdentityConfigs.Claims.SelectedCR, "2050038794")
};
_qualificationController = _qualificationController.WithIdentity(_claims);
var result = await _qualificationController.ReopenPostQualificationChecking(203);
Assert.NotNull(result);
Assert.Equal("022001000000", result.AgencyCode);
Assert.Equal("555", result.TenderNumber);
Assert.Equal(5, result.TechnicalOrganizationId);
Assert.Equal(1, result.BranchId);
Assert.True(result.InsideKSA);
}
public async Task IndexPagingAsyncTest()
{
_claims = new Claim[1] {
new Claim(IdentityConfigs.Claims.Role, RoleNames.MonafasatAccountManager)
};
_qualificationController = _qualificationController.WithIdentity(_claims);
var requestModel = new PreQualificationSearchCriteriaModel()
{
};
var response = await _qualificationController.GetPreQualificationsBySearchCriteria(requestModel);
Assert.NotNull(response);
Assert.NotEmpty(response.Items);
}
public async Task GetSupplierDocumentsTest()
{
_claims = new Claim[1] {
new Claim(IdentityConfigs.Claims.SelectedCR, "2050038794")
};
_qualificationController = _qualificationController.WithIdentity(_claims);
int preQualificationId = 220;
var result = await _qualificationController.GetSupplierDocuments(preQualificationId);
Assert.NotNull(result);
Assert.Equal(preQualificationId, result.PreQualificationId);
Assert.Equal("2050038794", result.SupplierId);
Assert.Equal(88, result.SupplierPreQualificationDocumentId);
}
