public void Update_Building_LinkedToProject_NotAllowed()
{
// Arrange
var helper = new TestHelper();
var user = PrincipalHelper.CreateForPermission(Permissions.PropertyView, Permissions.PropertyEdit).AddAgency(1);
var init = helper.InitializeDatabase(user);
var project = init.CreateProject(1);
project.ReportedFiscalYear = 2020;
var building = init.CreateBuilding(null, 2, agency: project.Agency);
var fiscal = init.CreateFiscal(building, 2020, Entity.FiscalKeys.NetBook, 10);
project.AddProperty(building);
init.SaveChanges();
var options = ControllerHelper.CreateDefaultPimsOptions();
var service = helper.CreateService <BuildingService>(user, options);
// Act
building.Name = "change";
// Assert, updating a building in a project should not throw an exception.
Assert.Throws <NotAuthorizedException>(() =>
service.Update(building));
}
public void Update_BuildingFinancials()
{
// Arrange
var helper = new TestHelper();
var user = PrincipalHelper.CreateForPermission(Permissions.PropertyView, Permissions.PropertyEdit).AddAgency(1);
var init = helper.InitializeDatabase(user);
var parcel = init.CreateParcel(3);
var building = init.CreateBuilding(parcel, 4);
init.SaveChanges();
var options = ControllerHelper.CreateDefaultPimsOptions();
var service = helper.CreateService <BuildingService>(user, options);
// Act
building.Evaluations.Add(new Entity.BuildingEvaluation(building, DateTime.Now, Entity.EvaluationKeys.Assessed, 1000));
building.Fiscals.Add(new Entity.BuildingFiscal(building, 2021, Entity.FiscalKeys.Market, 1000));
building.Fiscals.Add(new Entity.BuildingFiscal(building, 2021, Entity.FiscalKeys.NetBook, 2000));
var result = service.UpdateFinancials(building);
// Assert
Assert.NotNull(result);
Assert.Contains(result.Evaluations, e => e.Key == Entity.EvaluationKeys.Assessed && e.Value == 1000);
Assert.Contains(result.Fiscals, e => e.Key == Entity.FiscalKeys.Market && e.Value == 1000);
Assert.Contains(result.Fiscals, e => e.Key == Entity.FiscalKeys.NetBook && e.Value == 2000);
}
public async void GetRoleAsync_ById_Failed()
{
// Arrange
var helper = new TestHelper();
var user = PrincipalHelper.CreateForPermission();
var options = helper.CreateDefaultKeycloakOptions();
var openIdConnect = new Mock <IOpenIdConnectRequestClient>();
openIdConnect.Setup(m => m.AuthClientOptions).Returns(new Pims.Core.Http.Configuration.AuthClientOptions());
openIdConnect.Setup(m => m.GetAsync(It.IsAny <string>())).ReturnsAsync(new HttpResponseMessage(HttpStatusCode.BadRequest)
{
RequestMessage = new HttpRequestMessage(HttpMethod.Get, "http://keycloak")
});
helper.AddSingleton(openIdConnect.Object);
var service = helper.Create <KeycloakService>();
var id = Guid.NewGuid();
// Act
await Assert.ThrowsAsync <HttpClientRequestException>(async() => await service.GetRoleAsync(id));
// Assert
openIdConnect.Verify(m => m.GetAsync($"{options.Value.Admin.Authority}/roles-by-id/{id}"), Times.Once());
}
public void Get_AsAdmin()
{
// Arrange
var helper = new TestHelper();
var user = PrincipalHelper.CreateForPermission(Permissions.PropertyView, Permissions.AdminProperties);
using var init = helper.InitializeDatabase(user);
var parcel = init.CreateParcel(1);
var building = init.CreateBuilding(parcel, 2);
init.SaveChanges();
var service = helper.CreateService <BuildingService>(user);
var context = helper.GetService <PimsContext>();
// Act
var result = service.Get(2);
// Assert
Assert.NotNull(result);
Assert.Equal(EntityState.Detached, context.Entry(result).State);
Assert.Equal(building, result, new ShallowPropertyCompare());
Assert.NotNull(building.Address);
Assert.NotNull(building.Address.AdministrativeArea);
Assert.NotNull(building.Address.Province);
Assert.NotNull(building.Classification);
Assert.NotNull(building.Agency);
Assert.NotNull(building.Address);
Assert.NotNull(building.Address);
// TODO: Add asserts for Evaluations
// TODO: Add asserts for Fiscals
}
public void Update_Parcel_UpdateProjectFinancials()
{
// Arrange
var helper = new TestHelper();
var user = PrincipalHelper.CreateForPermission(Permissions.PropertyView, Permissions.PropertyEdit, Permissions.AdminProjects).AddAgency(1);
var init = helper.InitializeDatabase(user);
var project = init.CreateProject(1);
project.ReportedFiscalYear = 2020;
var parcel = init.CreateParcel(1);
var fiscal = init.CreateFiscal(parcel, 2020, Entity.FiscalKeys.NetBook, 10);
project.AddProperty(parcel);
init.SaveChanges();
var options = ControllerHelper.CreateDefaultPimsOptions();
var service = helper.CreateService <ParcelService>(user, options);
// Act
fiscal.Value = 15;
var result = service.Update(parcel);
// Assert
Assert.NotNull(result);
project.NetBook.Should().Be(15);
}
public void Get_Organizations(OrganizationFilter filter, int expectedCount)
{
// Arrange
var helper = new TestHelper();
var user = PrincipalHelper.CreateForPermission(Permissions.SystemAdmin);
using var init = helper.InitializeDatabase(user);
var organization1 = init.CreateOrganization(100, "TST");
organization1.PrntOrganizationId = 0;
organization1.IsDisabled = false;
var organization2 = init.CreateOrganization(101, "TST2");
organization2.PrntOrganizationId = 0;
var organization3 = init.CreateOrganization(102, "TST3");
organization3.IsDisabled = true;
var organization4 = init.CreateOrganization(200, "TST4");
init.AddAndSaveChanges(organization1, organization2, organization3, organization4);
var service = helper.CreateRepository <UserOrganizationService>(user);
var context = helper.GetService <PimsContext>();
// Act
var result = service.Get(filter);
// Assert
Assert.NotNull(result);
Assert.IsAssignableFrom <Paged <Entity.PimsOrganization> >(result);
Assert.Equal(expectedCount, result.Items.Count);
}
public async void DeleteAttackDetectionAsync_Failed()
{
// Arrange
var helper = new TestHelper();
var user = PrincipalHelper.CreateForPermission();
var options = helper.CreateDefaultKeycloakOptions();
var openIdConnect = new Mock <IOpenIdConnectRequestClient>();
openIdConnect.Setup(m => m.AuthClientOptions).Returns(new Pims.Core.Http.Configuration.AuthClientOptions());
openIdConnect.Setup(m => m.DeleteAsync(It.IsAny <string>(), It.IsAny <HttpContent>())).ReturnsAsync(new HttpResponseMessage(HttpStatusCode.BadRequest)
{
RequestMessage = new HttpRequestMessage(HttpMethod.Delete, "http://keycloak")
});
helper.AddSingleton(openIdConnect.Object);
var service = helper.Create <KeycloakService>();
// Act
var result = await Assert.ThrowsAsync <HttpClientRequestException>(async() => await service.DeleteAttackDetectionAsync());
// Assert
openIdConnect.Verify(m => m.DeleteAsync($"{options.Value.Admin.Authority}/attack-detection/brute-force/users", null), Times.Once());
result.StatusCode.Should().Be(HttpStatusCode.BadRequest);
}
public void Get_RemoveSensitiveBuildings()
{
// Arrange
var helper = new TestHelper();
var user = PrincipalHelper.CreateForPermission(Permissions.PropertyView).AddAgency(1);
using var init = helper.InitializeDatabase(user);
var parcel = init.CreateParcel(1, 1, 1);
init.CreateBuilding(parcel, 2);
var sensitive = init.CreateBuilding(parcel, 3);
sensitive.IsSensitive = true;
init.SaveChanges();
var service = helper.CreateService <ParcelService>(user);
var context = helper.GetService <PimsContext>();
// Act
var result = service.Get(1);
// Assert
Assert.NotNull(result);
Assert.Equal(EntityState.Detached, context.Entry(result).State);
Assert.Equal(parcel, result, new ShallowPropertyCompare());
Assert.Single(result.Buildings);
Assert.False(result.IsSensitive);
Assert.False(result.Buildings.First().IsSensitive);
}
public void AddPayment()
{
// Arrange
var user = PrincipalHelper.CreateForPermission(Permissions.LeaseEdit, Permissions.LeaseView);
var lease = EntityHelper.CreateLease(1);
helper.CreatePimsContext(user, true).AddAndSaveChanges(lease);
var term = new PimsLeaseTerm()
{
TermStartDate = DateTime.Now, TermExpiryDate = DateTime.Now.AddDays(10)
};
MockCommonServices();
leaseService.Setup(x => x.IsRowVersionEqual(It.IsAny <long>(), It.IsAny <long>())).Returns(true);
leaseService.Setup(x => x.GetById(It.IsAny <long>())).Returns(lease);
leaseTermRepository.Setup(x => x.GetById(It.IsAny <long>(), true)).Returns(term);
// Act
var payment = new PimsLeasePayment()
{
PaymentReceivedDate = DateTime.Now
};
var updatedLease = paymentService.AddPayment(lease.Id, 1, payment);
// Assert
leasePaymentRepository.Verify(x => x.Add(payment), Times.Once);
leaseService.Verify(x => x.GetById(lease.Id), Times.Once);
}
public void Get_Page_AsAdmin(ParcelFilter filter, int[] agencyIds, int expectedTotal)
{
// Arrange
var helper = new TestHelper();
var user = PrincipalHelper.CreateForPermission(Permissions.PropertyView, Permissions.AdminProperties);
using var init = helper.InitializeDatabase(user);
var parcels = init.CreateParcels(1, 20);
parcels.Next(0).Location.X = -123.720810;
parcels.Next(0).Location.Y = 48.529338;
parcels.Next(1).Agency = init.Agencies.Find(3);
parcels.Next(1).AgencyId = 3;
parcels.Next(2).ClassificationId = 2;
parcels.Next(3).Description = "-DescriptionTest-";
parcels.Next(4).Address.AdministrativeArea = "-AdministrativeArea-";
parcels.Next(5).Zoning = "-Zoning-";
parcels.Next(6).ZoningPotential = "-ZoningPotential-";
init.SaveChanges();
var service = helper.CreateService <ParcelService>(user);
// Act
var result = service.GetPage(filter);
// Assert
Assert.NotNull(result);
Assert.IsAssignableFrom <IEnumerable <Entity.Parcel> >(result);
Assert.Equal(expectedTotal, result.Total);
}
public void UpdatePayment_ReceivedDateOutOfRange()
{
// Arrange
var user = PrincipalHelper.CreateForPermission(Permissions.LeaseEdit);
var lease = EntityHelper.CreateLease(1);
var originalPayment = new PimsLeasePayment()
{
PaymentReceivedDate = DateTime.Now
};
var term = new PimsLeaseTerm()
{
TermStartDate = DateTime.Now, TermExpiryDate = DateTime.Now.AddDays(10)
};
helper.CreatePimsContext(user, true).AddAndSaveChanges(lease);
MockCommonServices();
leaseService.Setup(x => x.IsRowVersionEqual(It.IsAny <long>(), It.IsAny <long>())).Returns(true);
leaseTermRepository.Setup(x => x.GetById(It.IsAny <long>(), It.IsAny <bool>())).Returns(term);
// Act
var payment = new PimsLeasePayment()
{
LeasePaymentId = originalPayment.LeasePaymentId, PaymentReceivedDate = DateTime.Now.AddDays(30)
};
var ex = Assert.Throws <InvalidOperationException>(() => paymentService.UpdatePayment(lease.Id, 1, 1, payment));
ex.Message.Should().Be("Payment received date must be within the start and expiry date of the term.");
}
public void UpdateParcelFinancialsWithEvaluations_Success()
{
// Arrange
var helper = new TestHelper();
var user = PrincipalHelper.CreateForPermission(Permissions.SystemAdmin);
var parcel = EntityHelper.CreateParcel(1, 1, 1, 1);
var originalName = "original";
parcel.Name = originalName;
EntityHelper.CreateEvaluations(parcel, new DateTime(2017, 1, 1), 2, Entity.EvaluationKeys.Assessed, 2000);
helper.CreatePimsContext(user, true).AddAndSaveChanges(parcel);
var service = helper.CreateService <ParcelService>();
var updateParcel = EntityHelper.CreateParcel(1, 1, 1, 1);
var newName = "testing name is updated";
EntityHelper.CreateEvaluations(updateParcel, new DateTime(2018, 1, 1), 2, Entity.EvaluationKeys.Assessed, 5000);
updateParcel.Name = newName;
// Act
service.UpdateFinancials(updateParcel);
// Assert
parcel.Name.Should().Be(originalName);
parcel.Evaluations.Should().HaveCount(3);
parcel.Evaluations.Sum(f => f.Value).Should().Be(9000);
}
public void UpdateParcelFinancialsWithNewFiscals_Success()
{
// Arrange
var helper = new TestHelper();
var user = PrincipalHelper.CreateForPermission(Permissions.SystemAdmin);
var parcel = EntityHelper.CreateParcel(1, 1, 1, 1);
var originalName = "original";
parcel.Name = originalName;
helper.CreatePimsContext(user, true).AddAndSaveChanges(parcel);
var service = helper.CreateService <ParcelService>();
var updateParcel = EntityHelper.CreateParcel(1, 1, 1, 1);
var newName = "testing name is updated";
EntityHelper.CreateFiscals(updateParcel, new[] { 2018, 2019 }, Entity.FiscalKeys.NetBook, 5000);
updateParcel.Name = newName;
// Act
service.UpdateFinancials(updateParcel);
// Assert
parcel.Name.Should().Be(originalName);
parcel.Fiscals.Should().HaveCount(2);
parcel.Fiscals.Sum(f => f.Value).Should().Be(10000);
}
public void Get_Parcels(ParcelFilter filter, int expectedCount)
{
// Arrange
var helper = new TestHelper();
var user = PrincipalHelper.CreateForPermission(Permissions.SystemAdmin);
using var init = helper.InitializeDatabase(user);
var parcels = init.CreateParcels(1, 20);
parcels.Next(0).Location.X = -123.720810;
parcels.Next(0).Location.Y = 48.529338;
parcels.Next(1).Agency = init.Agencies.Find(3);
parcels.Next(1).AgencyId = 3;
parcels.Next(2).ClassificationId = 2;
parcels.Next(3).Description = "-DescriptionTest-";
parcels.Next(4).Address.AdministrativeArea = "-AdministrativeArea-";
parcels.Next(5).ProjectNumber = "ProjectNumber";
parcels.Next(6).Zoning = "-Zoning-";
parcels.Next(7).ZoningPotential = "-ZoningPotential-";
init.SaveChanges();
var service = helper.CreateService <ParcelService>(user);
var context = helper.GetService <PimsContext>();
// Act
var result = service.Get(filter);
// Assert
Assert.NotNull(result);
Assert.IsAssignableFrom <Paged <Entity.Parcel> >(result);
Assert.Equal(expectedCount, result.Items.Count());
}
public void CreateKeycloakService_NoAdminAuthority()
{
// Arrange
var helper = new TestHelper();
var user = PrincipalHelper.CreateForPermission();
var options = Options.Create(new KeycloakOptions()
{
Authority = "https://keycloak",
Audience = "pims",
Client = "pims",
Admin = new KeycloakAdminOptions()
});
var openIdConnect = new Mock <IOpenIdConnectRequestClient>();
openIdConnect.Setup(m => m.AuthClientOptions).Returns(new Pims.Core.Http.Configuration.AuthClientOptions());
openIdConnect.Setup(m => m.DeleteAsync(It.IsAny <string>(), It.IsAny <HttpContent>())).ReturnsAsync(new HttpResponseMessage(HttpStatusCode.OK));
helper.AddSingleton(openIdConnect.Object);
// Act
// Assert
var result = Assert.Throws <ConfigurationException>(() => helper.Create <KeycloakService>(options, user));
result.Message.Should().Be("The configuration for Keycloak:Admin:Authority is invalid or missing.");
}
public void Get_AsAdmin()
{
// Arrange
var helper = new TestHelper();
var user = PrincipalHelper.CreateForPermission(Permissions.PropertyView, Permissions.AdminProperties);
var parcel = EntityHelper.CreateParcel(1, 1, 1, 1);
helper.CreatePimsContext(user, true).AddAndSaveChanges(parcel);
var service = helper.CreateService <ParcelService>(user);
var context = helper.GetService <PimsContext>();
// Act
var result = service.Get(1);
// Assert
Assert.NotNull(result);
Assert.Equal(EntityState.Detached, context.Entry(result).State);
Assert.Equal(parcel, result, new ShallowPropertyCompare());
Assert.NotNull(parcel.Address);
Assert.NotNull(parcel.Address.City);
Assert.NotNull(parcel.Address.Province);
Assert.NotNull(parcel.Classification);
Assert.NotNull(parcel.Agency);
Assert.NotNull(parcel.Address);
Assert.NotNull(parcel.Address);
Assert.NotNull(parcel.Evaluations);
Assert.NotNull(parcel.Fiscals);
Assert.NotNull(parcel.Buildings);
}
public void SetProjectPropertiesVisiblity()
{
// Arrange
var helper = new TestHelper();
var user = PrincipalHelper.CreateForPermission(Permissions.ProjectView, Permissions.ProjectEdit).AddAgency(1);
var context = helper.InitializeDatabase(user);
var project = context.CreateProject(1);
var parcel = context.CreateParcel(1);
project.AddProperty(parcel);
// Act
context.SetProjectPropertiesVisiblity(project, false);
// Assert
var properties = project.Properties.ToArray();
foreach (var property in properties)
{
if (property.BuildingId.HasValue)
{
property.Building.IsVisibleToOtherAgencies.Should().BeFalse();
}
else if (property.ParcelId.HasValue)
{
property.Parcel.IsVisibleToOtherAgencies.Should().BeFalse();
}
}
}
public void Get_WithAgency_RemoveSensitiveBuildings()
{
// Arrange
var helper = new TestHelper();
var user = PrincipalHelper.CreateForPermission(Permissions.PropertyView, Permissions.SensitiveView).AddAgency(1);
using var init = helper.InitializeDatabase(user);
var agency = init.Agencies.Find(1);
var parcel = init.CreateParcel(1, agency);
parcel.IsSensitive = true;
init.CreateBuilding(parcel, 2);
var building1 = init.CreateBuilding(parcel, 3);
building1.IsSensitive = true;
var building2 = init.CreateBuilding(parcel, 4, "13", "l4", 1, 1, init.Agencies.Find(2));
building2.IsSensitive = true;
init.SaveChanges();
var service = helper.CreateService <ParcelService>(user);
var context = helper.GetService <PimsContext>();
// Act
var result = service.Get(1);
// Assert
Assert.NotNull(result);
Assert.Equal(EntityState.Detached, context.Entry(result).State);
Assert.Equal(parcel, result, new ShallowPropertyCompare());
Assert.Equal(2, result.Buildings.Count());
Assert.True(result.IsSensitive);
Assert.Equal(1, result.Buildings.Count(b => b.IsSensitive));
}
public async void GetGroupsAsync_Failed()
{
// Arrange
var helper = new TestHelper();
var user = PrincipalHelper.CreateForPermission();
var options = helper.CreateDefaultKeycloakOptions();
var openIdConnect = new Mock <IOpenIdConnectRequestClient>();
openIdConnect.Setup(m => m.AuthClientOptions).Returns(new Pims.Core.Http.Configuration.AuthClientOptions());
openIdConnect.Setup(m => m.GetAsync(It.IsAny <string>())).ReturnsAsync(new HttpResponseMessage(HttpStatusCode.BadRequest)
{
RequestMessage = new HttpRequestMessage(HttpMethod.Get, "http://keycloak")
});
helper.AddSingleton(openIdConnect.Object);
var service = helper.Create <KeycloakService>();
var first = 1;
var max = 10;
var search = "search";
// Act
await Assert.ThrowsAsync <HttpClientRequestException>(async() => await service.GetGroupsAsync(first, max, search));
// Assert
openIdConnect.Verify(m => m.GetAsync($"{options.Value.Admin.Authority}/groups?first={first}&max={max}&search={search}"), Times.Once());
}
public void LtsaExceptionClientModel_Success()
{
// Arrange
var message = "test2";
var status = HttpStatusCode.OK;
var helper = new TestHelper();
var user = PrincipalHelper.CreateForPermission();
var options = Options.Create(new LtsaOptions());
helper.Create <LtsaService>(options, user);
var exception = new HttpClientRequestException(message, status);
var client = helper.GetService <Mock <IHttpRequestClient> >().Object;
var error = new Error()
{
ErrorMessages = new List <string>()
{
"errorMessages"
}
};
// Act
var ltsaException = new LtsaException(exception, client, error);
// Assert
Assert.NotNull(ltsaException.Message);
ltsaException.Message.Should().Be(message + System.Environment.NewLine);
ltsaException.Client.Should().Be(client);
ltsaException.StatusCode.Should().Be(status);
ltsaException.Detail.Should().Be(null);
}
public async void GetGroupCountAsync_Success()
{
// Arrange
var helper = new TestHelper();
var user = PrincipalHelper.CreateForPermission();
var options = helper.CreateDefaultKeycloakOptions();
var openIdConnect = new Mock <IOpenIdConnectRequestClient>();
openIdConnect.Setup(m => m.AuthClientOptions).Returns(new Pims.Core.Http.Configuration.AuthClientOptions());
openIdConnect.Setup(m => m.GetAsync(It.IsAny <string>())).ReturnsAsync(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent("{\"Count\":1}")
});
helper.AddSingleton(openIdConnect.Object);
var service = helper.Create <KeycloakService>();
// Act
var result = await service.GetGroupCountAsync();
// Assert
openIdConnect.Verify(m => m.GetAsync($"{options.Value.Admin.Authority}/groups/count"), Times.Once());
result.Should().Be(1);
}
public async void GetRolesAsync_Success()
{
// Arrange
var helper = new TestHelper();
var user = PrincipalHelper.CreateForPermission();
var roles = new[]
{
new RoleModel()
{
Id = Guid.NewGuid()
}
};
var options = helper.CreateDefaultKeycloakOptions();
var openIdConnect = new Mock <IOpenIdConnectRequestClient>();
openIdConnect.Setup(m => m.AuthClientOptions).Returns(new Pims.Core.Http.Configuration.AuthClientOptions());
openIdConnect.Setup(m => m.GetAsync(It.IsAny <string>())).ReturnsAsync(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(System.Text.Json.JsonSerializer.Serialize(roles))
});
helper.AddSingleton(openIdConnect.Object);
var service = helper.Create <KeycloakService>();
// Act
var result = await service.GetRolesAsync();
// Assert
openIdConnect.Verify(m => m.GetAsync($"{options.Value.Admin.Authority}/roles"), Times.Once());
}
public void Get_Page_AsAdmin_AllAgencies()
{
// Arrange
var helper = new TestHelper();
var user = PrincipalHelper.CreateForPermission(Permissions.PropertyView, Permissions.AdminProperties);
using var init = helper.InitializeDatabase(user);
var parcels = init.CreateParcels(1, 20);
parcels.Next(0).Latitude = 50;
parcels.Next(0).Longitude = 25;
parcels.Next(1).Agency = init.Agencies.Find(3);
parcels.Next(1).AgencyId = 3;
parcels.Next(2).ClassificationId = 2;
parcels.Next(3).Description = "-DescriptionTest-";
parcels.Next(4).Municipality = "-Municipality-";
parcels.Next(5).Zoning = "-Zoning-";
parcels.Next(6).ZoningPotential = "-ZoningPotential-";
init.SaveChanges();
var service = helper.CreateService <ParcelService>(user);
// Act
var result = service.GetPage(new ParcelFilter());
// Assert
Assert.NotNull(result);
Assert.IsAssignableFrom <IEnumerable <Entity.Parcel> >(result);
Assert.Equal(20, result.Total);
}
public void Get_WithCode(string statusCode, int expectedCount)
{
// Arrange
var helper = new TestHelper();
var user = PrincipalHelper.CreateForPermission(Permissions.PropertyView);
var init = helper.CreatePimsContext(user, true);
var status1 = EntityHelper.CreateProjectStatus(1, "DRAFT", "DRAFT");
var status2 = EntityHelper.CreateProjectStatus(2, "SUBMIT", "SUBMIT");
init.AddAndSaveChanges(status1, status2);
var tasks = EntityHelper.CreateDefaultTasks();
init.AddAndSaveRange(tasks);
tasks.ForEach(t => status2.Tasks.Add(t));
init.UpdateAndSaveChanges(status2);
var service = helper.CreateService <TaskService>(user);
// Act
var result = service.GetForStatus(statusCode);
// Assert
Assert.NotNull(result);
Assert.IsAssignableFrom <IEnumerable <Entity.Task> >(result);
result.Should().HaveCount(expectedCount);
}
public void LtsaServiceCollection_Success()
{
// Arrange
var helper = new TestHelper();
var user = PrincipalHelper.CreateForPermission();
helper.AddSingleton(user);
var builder = new ConfigurationBuilder();
var options = new LtsaOptions()
{
IntegratorUsername = "******",
IntegratorPassword = "******",
MyLtsaUsername = "******",
MyLtsaUserPassword = "******",
};
var ltsaJson = JsonSerializer.Serialize(new { Ltsa = options });
IConfigurationRoot ltsaConfig;
using (var io = new MemoryStream(Encoding.UTF8.GetBytes(ltsaJson)))
{
builder.AddJsonStream(io);
ltsaConfig = builder.Build();
}
var mockClientFactory = new Mock <IHttpClientFactory>();
var mockIOptionsMonitor = new Mock <IOptionsMonitor <JsonSerializerOptions> >();
var mockIlogger = new Mock <ILogger <HttpRequestClient> >();
var mockILtsaService = new Mock <ILogger <ILtsaService> >();
helper.AddSingleton(mockClientFactory.Object);
helper.AddSingleton(mockIOptionsMonitor.Object);
helper.AddSingleton(mockIlogger.Object);
helper.AddSingleton(mockILtsaService.Object);
// Act
_ = helper.Services.AddLtsaService(section: ltsaConfig.GetSection("Ltsa"));
var ltsaOptions = helper.GetService <IOptions <LtsaOptions> >();
var ltsaService = helper.GetService <ILtsaService>();
var httpRequestClient = helper.GetService <IHttpRequestClient>();
var jwtSecurityTokenHandler = helper.GetService <JwtSecurityTokenHandler>();
// Assert
Assert.NotNull(ltsaService);
Assert.NotNull(httpRequestClient);
Assert.NotNull(jwtSecurityTokenHandler);
Assert.NotNull(ltsaOptions);
ltsaOptions.Value.AuthUrl.Should().Be(options.AuthUrl);
ltsaOptions.Value.HostUri.Should().Be(options.HostUri);
ltsaOptions.Value.IntegratorPassword.Should().Be(options.IntegratorPassword);
ltsaOptions.Value.IntegratorUsername.Should().Be(options.IntegratorUsername);
ltsaOptions.Value.MyLtsaUsername.Should().Be(options.MyLtsaUsername);
ltsaOptions.Value.OrdersEndpoint.Should().Be(options.OrdersEndpoint);
ltsaOptions.Value.RefreshEndpoint.Should().Be(options.RefreshEndpoint);
}
public async void GetGroupMembersAsync_Success()
{
// Arrange
var helper = new TestHelper();
var user = PrincipalHelper.CreateForPermission();
var users = new[] {
new UserModel()
{
Id = Guid.NewGuid(),
Email = "email",
EmailVerified = false,
Enabled = true,
FirstName = "first",
LastName = "last",
Username = "******",
Attributes = new System.Collections.Generic.Dictionary <string, string[]>()
{
{ "attr1", new [] { "attribute" } }
},
RealmRoles = new[] { "role" },
Groups = new[] { "group" },
}
};
var options = helper.CreateDefaultKeycloakOptions();
var openIdConnect = new Mock <IOpenIdConnectRequestClient>();
openIdConnect.Setup(m => m.AuthClientOptions).Returns(new Pims.Core.Http.Configuration.AuthClientOptions());
openIdConnect.Setup(m => m.GetAsync(It.IsAny <string>())).ReturnsAsync(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(System.Text.Json.JsonSerializer.Serialize(users))
});
helper.AddSingleton(openIdConnect.Object);
var service = helper.Create <KeycloakService>();
var id = Guid.NewGuid();
var first = 1;
var max = 10;
// Act
var result = await service.GetGroupMembersAsync(id, first, max);
// Assert
openIdConnect.Verify(m => m.GetAsync($"{options.Value.Admin.Authority}/groups/{id}/members?first={first}&max={max}"), Times.Once());
result.Should().HaveCount(1);
result.First().Id.Should().Be(users.First().Id);
result.First().Email.Should().Be(users.First().Email);
result.First().EmailVerified.Should().Be(users.First().EmailVerified);
result.First().Enabled.Should().Be(users.First().Enabled);
result.First().FirstName.Should().Be(users.First().FirstName);
result.First().LastName.Should().Be(users.First().LastName);
result.First().Username.Should().Be(users.First().Username);
}
public async void GetTitleSummariesAsync_RefreshToken_LtsaError()
{
// Arrange
var helper = new TestHelper();
var user = PrincipalHelper.CreateForPermission();
var options = Options.Create(new LtsaOptions());
var service = helper.Create <LtsaService>(options, user);
var tokenRequestResponse = new HttpResponseMessage(HttpStatusCode.Unauthorized)
{
RequestMessage = new HttpRequestMessage(HttpMethod.Post, "https://test"),
Content = new StringContent("{\"ErrorMessages\":[]}"),
};
var refreshTokenRequestResponse = new HttpResponseMessage(HttpStatusCode.InternalServerError)
{
RequestMessage = new HttpRequestMessage(HttpMethod.Post, "https://test"),
Content = new StringContent("{\"ErrorMessages\":[]}"),
};
var titleSummariesResponse = new TitleSummariesResponse()
{
TitleSummaries = new List <TitleSummary>()
{
new TitleSummary()
{
TitleNumber = "titleNumber",
LandTitleDistrictCode = LandTitleDistrictCode.VA,
}
}
};
var client = helper.GetService <Mock <IHttpRequestClient> >();
client.Setup(m => m.PostJsonAsync(It.IsAny <string>(), It.IsAny <IntegratorCredentials>()))
.ReturnsAsync(new HttpResponseMessage()
{
Content = new StringContent(accessTokenResponse)
});
client.Setup(m => m.PostJsonAsync(It.Is <string>((url) => url == options.Value.AuthUrl + "/token"), It.IsAny <Object>()))
.ThrowsAsync(new HttpClientRequestException(refreshTokenRequestResponse));
client.SetupSequence(m => m.SendAsync <TitleSummariesResponse>(It.IsAny <string>(), It.IsAny <HttpMethod>(), It.IsAny <HttpContent>(), It.IsAny <Func <HttpResponseMessage, bool> >()))
.ThrowsAsync(new HttpClientRequestException(tokenRequestResponse)).ReturnsAsync(titleSummariesResponse).ThrowsAsync(new HttpClientRequestException(tokenRequestResponse)).ReturnsAsync(titleSummariesResponse);
// Act
// Assert
var response = await service.GetTitleSummariesAsync(123456789); //the first call will use the regular token
await Assert.ThrowsAsync <LtsaException>(async() => await service.GetTitleSummariesAsync(123456789)); //the second call will use the refresh token
client.Verify(m => m.PostJsonAsync(options.Value.AuthUrl + "/login/integrator",
It.IsAny <IntegratorCredentials>()), Times.Once);
client.Verify(m => m.PostJsonAsync(options.Value.AuthUrl + "/token",
It.IsAny <Object>()), Times.Once);
}
public void Get_KeyNotFound()
{
// Arrange
var helper = new TestHelper();
var user = PrincipalHelper.CreateForPermission(Permissions.ProjectView);
var service = helper.CreateService <ProjectNotificationService>(user);
// Act
// Assert
Assert.Throws <KeyNotFoundException>(() => service.Get(1));
}
public void GetQueues_ArgumentNull()
{
// Arrange
var helper = new TestHelper();
var user = PrincipalHelper.CreateForPermission(Permissions.SystemAdmin);
var service = helper.CreateService <NotificationQueueService>(user);
// Act
// Assert
Assert.Throws <ArgumentNullException>(() => service.GetPage(null));
}
public void GetQueues_NotAuthorized()
{
// Arrange
var helper = new TestHelper();
var user = PrincipalHelper.CreateForPermission();
var service = helper.CreateService <NotificationQueueService>(user);
// Act
// Assert
Assert.Throws <NotAuthorizedException>(() => service.GetPage(null));
}
