public void ExportProjects_ExcelX_Query_Success(Uri uri)
{
// Arrange
var helper = new TestHelper();
var controller = helper.CreateController <ProjectController>(Permissions.PropertyView, uri);
var headers = helper.GetService <Mock <Microsoft.AspNetCore.Http.IHeaderDictionary> >();
headers.Setup(m => m["Accept"]).Returns(ContentTypes.CONTENT_TYPE_EXCELX);
var agency = EntityHelper.CreateAgency(1);
var project = new Entity.Project()
{
Agency = agency
};
var projects = new[] { project };
var service = helper.GetService <Mock <IPimsService> >();
var mapper = helper.GetService <IMapper>();
var page = new Paged <Entity.Project>(projects);
service.Setup(m => m.Project.GetPage(It.IsAny <Entity.Models.ProjectFilter>())).Returns(page);
// Act
var result = controller.ExportProjects();
// Assert
var actionResult = Assert.IsType <FileStreamResult>(result);
Assert.Equal(ContentTypes.CONTENT_TYPE_EXCELX, actionResult.ContentType);
Assert.NotNull(actionResult.FileDownloadName);
Assert.True(actionResult.FileStream.Length > 0);
service.Verify(m => m.Project.GetPage(It.IsAny <Entity.Models.ProjectFilter>()), Times.Once());
}
public void GetAgencies_Filtered_Success()
{
// Arrange
var helper = new TestHelper();
var controller = helper.CreateController <AgencyController>(Permissions.AdminAgencies);
var mapper = helper.GetService <IMapper>();
var service = helper.GetService <Mock <IPimsAdminService> >();
var agencies = new Entity.Agency[] { EntityHelper.CreateAgency(1, "agency1"), EntityHelper.CreateAgency(2, "agency2") };
var paged = new Entity.Models.Paged <Entity.Agency>(agencies);
service.Setup(m => m.Agency.Get(It.IsAny <Entity.Models.AgencyFilter>())).Returns(paged);
var filter = new Entity.Models.AgencyFilter(1, 10);
// Act
var result = controller.GetAgencies(filter);
// Assert
var actionResult = Assert.IsType <JsonResult>(result);
Assert.Null(actionResult.StatusCode);
var actualResult = Assert.IsType <Pims.Api.Models.PageModel <Model.AgencyModel> >(actionResult.Value);
Assert.Equal(mapper.Map <Model.AgencyModel[]>(agencies), actualResult.Items, new DeepPropertyCompare());
service.Verify(m => m.Agency.Get(filter), Times.Once());
}
public void ExportProjects_Csv_Query_Success()
{
// Arrange
var helper = new TestHelper();
var controller = helper.CreateController <ProjectController>(Permissions.PropertyView);
var headers = helper.GetService <Mock <Microsoft.AspNetCore.Http.IHeaderDictionary> >();
headers.Setup(m => m["Accept"]).Returns(ContentTypes.CONTENT_TYPE_CSV);
var agency = EntityHelper.CreateAgency(1);
var project = new Entity.Project()
{
Agency = agency
};
var projects = new[] { project };
var service = helper.GetService <Mock <IPimsService> >();
var mapper = helper.GetService <IMapper>();
var page = new Paged <Entity.Project>(projects);
service.Setup(m => m.Project.GetPage(It.IsAny <Entity.Models.ProjectFilter>())).Returns(page);
// Act
var result = controller.ExportProjects();
// Assert
var actionResult = Assert.IsType <ContentResult>(result);
var actualResult = Assert.IsType <string>(actionResult.Content);
Assert.Equal(ContentTypes.CONTENT_TYPE_CSV, actionResult.ContentType);
service.Verify(m => m.Project.GetPage(It.IsAny <Entity.Models.ProjectFilter>()), Times.Once());
}
public async Task DeleteAgencyAsync()
{
// Arrange
var helper = new TestHelper();
var controller = helper.CreateController <AgencyController>(Permissions.AdminAgencies);
var mapper = helper.GetService <IMapper>();
var service = helper.GetService <Mock <IPimsAdminService> >();
var agency = EntityHelper.CreateAgency(1, "agency1");
service.Setup(m => m.Agency.Remove(It.IsAny <Entity.Agency>()));
var model = mapper.Map <Model.AgencyModel>(agency);
// Act
var result = await controller.DeleteAgencyAsync(model);
// Assert
var actionResult = Assert.IsType <JsonResult>(result);
Assert.Null(actionResult.StatusCode);
var actualResult = Assert.IsType <Model.AgencyModel>(actionResult.Value);
Assert.Equal(mapper.Map <Model.AgencyModel>(agency), actualResult, new DeepPropertyCompare());
service.Verify(m => m.Agency.Remove(It.IsAny <Entity.Agency>()), Times.Once());
}
public void AccessRequestAgency_AccessRequest_Constructor_ArgumentNullException()
{
// Arrange
var agency = EntityHelper.CreateAgency(5);
// Act
// Assert
Assert.Throws <ArgumentNullException>(() => new AccessRequestAgency(null, agency));
}
public void NotificationQueue_Constructor_02_ArgumentException(string subject, string body, NotificationTemplate template, Type throws)
{
// Arrange
var agency = EntityHelper.CreateAgency(2);
agency.Email = "*****@*****.**";
var project = EntityHelper.CreateProject(1, agency);
// Act
// Assert
Assert.Throws(throws, () => new NotificationQueue(template, project, agency, subject, body));
}
public void AccessRequestAgency_Id_Constructor()
{
// Arrange
var accessRequest = EntityHelper.CreateAccessRequest(5);
var agency = EntityHelper.CreateAgency(2);
// Act
var accessRequestAgency = new AccessRequestAgency(accessRequest.Id, agency.Id);
// Assert
accessRequestAgency.AccessRequestId.Should().Be(accessRequest.Id);
accessRequestAgency.AgencyId.Should().Be(agency.Id);
}
public void Remove_BuildingConstructionType_KeyNotFound()
{
// Arrange
var helper = new TestHelper();
var user = PrincipalHelper.CreateForPermission();
var agency = EntityHelper.CreateAgency(1);
var constructionType = EntityHelper.CreateBuildingConstructionType(100, "Test");
helper.CreatePimsContext(user, true);
var service = helper.CreateService <BuildingConstructionTypeService>(user);
var context = helper.GetService <PimsContext>();
// Act
// Assert
Assert.Throws <KeyNotFoundException>(() =>
service.Remove(constructionType));
}
public void NotificationQueue_Constructor_02()
{
// Arrange
var date = DateTime.UtcNow;
var template = new NotificationTemplate("template", "subject", "body")
{
BodyType = NotificationBodyTypes.Text,
Priority = NotificationPriorities.Low,
Encoding = NotificationEncodings.Base64,
Tag = "tag"
};
var agency = EntityHelper.CreateAgency(2);
agency.Email = "*****@*****.**";
var project = EntityHelper.CreateProject(1, agency);
// Act
var queue = new NotificationQueue(template, project, agency, "subject", "body");
// Assert
queue.Id.Should().Be(0);
queue.Key.Should().NotBeEmpty();
queue.TemplateId.Should().Be(template.Id);
queue.Template.Should().Be(template);
queue.Subject.Should().Be("subject");
queue.Body.Should().Be("body");
queue.BodyType.Should().Be(template.BodyType);
queue.Priority.Should().Be(template.Priority);
queue.Encoding.Should().Be(template.Encoding);
queue.Tag.Should().Be(template.Tag);
queue.ProjectId.Should().Be(project.Id);
queue.Project.Should().Be(project);
queue.ToAgencyId.Should().Be(agency.Id);
queue.ToAgency.Should().Be(agency);
queue.To.Should().Be(agency.Email);
queue.SendOn.Should().BeOnOrAfter(date);
}
public void GetAgency()
{
// Arrange
var helper = new TestHelper();
var controller = helper.CreateController <AgencyController>(Permissions.AdminAgencies);
var mapper = helper.GetService <IMapper>();
var service = helper.GetService <Mock <IPimsAdminService> >();
var agency = EntityHelper.CreateAgency(1, "agency1");
service.Setup(m => m.Agency.Get(It.IsAny <int>())).Returns(agency);
// Act
var result = controller.GetAgency(agency.Id);
// Assert
var actionResult = Assert.IsType <JsonResult>(result);
Assert.Null(actionResult.StatusCode);
var actualResult = Assert.IsType <Model.AgencyModel>(actionResult.Value);
Assert.Equal(mapper.Map <Model.AgencyModel>(agency), actualResult, new DeepPropertyCompare());
service.Verify(m => m.Agency.Get(agency.Id), Times.Once());
}
public void GetAll()
{
// Arrange
var helper = new TestHelper();
var controller = helper.CreateController <LookupController>(Permissions.PropertyView);
var mapper = helper.GetService <IMapper>();
var service = helper.GetService <Mock <IPimsService> >();
var role = EntityHelper.CreateRole("admin");
service.Setup(m => m.Lookup.GetRoles()).Returns(new[] { role });
var agency = EntityHelper.CreateAgency();
service.Setup(m => m.Lookup.GetAgencies()).Returns(new[] { agency });
var propertyClassification = EntityHelper.CreatePropertyClassification("class", true);
service.Setup(m => m.Lookup.GetPropertyClassifications()).Returns(new[] { propertyClassification });
var province = EntityHelper.CreateProvince("BC", "British Columbia");
service.Setup(m => m.Lookup.GetProvinces()).Returns(new[] { province });
var city = EntityHelper.CreateCity("VIC", "Victoria");
service.Setup(m => m.Lookup.GetCities()).Returns(new[] { city });
var buildingConstructionType = EntityHelper.CreateBuildingConstructionType("type");
service.Setup(m => m.Lookup.GetBuildingConstructionTypes()).Returns(new[] { buildingConstructionType });
var buildingPredominateUse = EntityHelper.CreateBuildingPredominateUse("use");
service.Setup(m => m.Lookup.GetBuildingPredominateUses()).Returns(new[] { buildingPredominateUse });
var buildingOccupantType = EntityHelper.CreateBuildingOccupantType("occupant");
service.Setup(m => m.Lookup.GetBuildingOccupantTypes()).Returns(new[] { buildingOccupantType });
var tierLevel = EntityHelper.CreateTierLevel("tierlevel");
service.Setup(m => m.Lookup.GetTierLevels()).Returns(new[] { tierLevel });
// Act
var result = controller.GetAll();
// Assert
var actionResult = Assert.IsType <JsonResult>(result);
var actualResult = Assert.IsAssignableFrom <IEnumerable <object> >(actionResult.Value);
Assert.Equal(mapper.Map <Model.RoleModel>(role), actualResult.First(), new ShallowPropertyCompare());
Assert.Equal(mapper.Map <Models.CodeModel <int> >(agency), actualResult.Next(1), new ShallowPropertyCompare());
Assert.Equal(mapper.Map <Models.LookupModel <int> >(propertyClassification), actualResult.Next(2), new ShallowPropertyCompare());
Assert.Equal(mapper.Map <Models.LookupModel <string> >(province), actualResult.Next(3), new ShallowPropertyCompare());
Assert.Equal(mapper.Map <Models.CodeModel <int> >(city), actualResult.Next(4), new ShallowPropertyCompare());
Assert.Equal(mapper.Map <Models.LookupModel <int> >(buildingConstructionType), actualResult.Next(5), new ShallowPropertyCompare());
Assert.Equal(mapper.Map <Models.LookupModel <int> >(buildingPredominateUse), actualResult.Next(6), new ShallowPropertyCompare());
Assert.Equal(mapper.Map <Models.LookupModel <int> >(buildingOccupantType), actualResult.Next(7), new ShallowPropertyCompare());
Assert.Equal(mapper.Map <Models.LookupModel <int> >(tierLevel), actualResult.Next(8), new ShallowPropertyCompare());
}
