public override async Task InitializeAsync()
{
await base.InitializeAsync();
HttpClient = TestServer.CreateClient();
_userLogin = TestServer.Host.Services.GetRequiredService <IOptions <UserLoginOption> >()?.Value;
HttpServiceTest = TestServer.Host.Services.GetRequiredService <IHttpServiceTest>();
_adminToken = await HttpServiceTest.GetAuthorizationToken(_userLogin);
AccountAdmin = await HttpServiceTest.CreateNewTestUser(FormCreateUserModel(ConstTest.Role.AccountAdmin), _adminToken);
OperationAdmin = await HttpServiceTest.CreateNewTestUser(FormCreateUserModel(ConstTest.Role.OperationAdmin), _adminToken);
SystemAdmin = await HttpServiceTest.CreateNewTestUser(FormCreateUserModel(ConstTest.Role.SystemAdmin), _adminToken);
Manager = await HttpServiceTest.CreateNewTestUser(FormCreateUserModel(ConstTest.Role.Manager), _adminToken);
Company = await HttpServiceTest.GetTestCompany(ConstTest.DefaultCompanyName, _adminToken);
CompanyWithoutAnyBranch = await HttpServiceTest.GetTestCompany(ConstTest.DefaultCompanyNameNotBindAnyBranch, _adminToken);
Branch = await HttpServiceTest.GetTestBranch(ConstTest.DefaultBranchName, _adminToken);
Supervisor = await HttpServiceTest.CreateNewTestUser(FormCreateUserModel(ConstTest.Role.Supervisor, Company.Id, Branch.Id), _adminToken);
SupervisorWithCompanyWithoutBranch = await HttpServiceTest.CreateNewTestUser(FormCreateUserModel(ConstTest.Role.Supervisor, CompanyWithoutAnyBranch.Id), _adminToken);
Users = FillingUser();
}
public async Task ShouldReturSuccessWhenPostComments(string roleName)
{
// Arrange
var device = _baseTest.Fixture.Build <Device>().Without(x => x.DeviceHistory).Create();
_baseTest.DbContext.Devices.Add(device);
_baseTest.DbContext.SaveChanges();
string uriPostComments = $"devices/{device.Id}/comments";
var user = _baseTest.Users[roleName];
var userLoginOptiomTest = new UserLoginOption {
UserName = user.Email, Password = ConstTest.Password, Scope = Const.Permissions.Comment.Create
};
var userToken = await _baseTest.HttpServiceTest.GetAuthorizationToken(userLoginOptiomTest);
var commentRequestModel = _baseTest.Fixture.Create <CommentRequestModel>();
var content = new StringContent(JsonConvert.SerializeObject(commentRequestModel), Encoding.UTF8, "application/json");
// Act
_baseTest.HttpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(userToken.TokenType, userToken.AccessToken);
var response = await _baseTest.HttpClient.PostAsync(uriPostComments, content);
response.EnsureSuccessStatusCode();
//Assert
response.StatusCode.Should().Be(StatusCodes.Status201Created);
_baseTest.DbContext.Comments.Count().Should().Be(1);
_baseTest.DbContext.Comments.First().Message.Should().Be(commentRequestModel.Comment);
_baseTest.DbContext.Comments.First().UserId.Should().Be(user.Id);
_baseTest.DbContext.Comments.First().DeviceId.Should().Be(device.Id);
_baseTest.DbContext.Comments.First().UserName.Should().Be($"{user.GivenName} {user.Surname}");
}
public async Task ShouldReturForbidIfSupervisorHasAnotherCompanyWhenGetHistory()
{
// Arrange
var userLoginOptiomTest = new UserLoginOption {
UserName = _baseTest.Supervisor.Email, Password = ConstTest.Password, Scope = Const.Permissions.Comment.Read
};
var userToken = await _baseTest.HttpServiceTest.GetAuthorizationToken(userLoginOptiomTest);
int historyCount = 5;
int anotherCompanyId = _baseTest.Supervisor.CompanyId.Value + 1;
var device = _baseTest.Fixture.Build <Device>()
.With(x => x.CompanyId, anotherCompanyId)
.Without(x => x.DeviceHistory).Create();
var historyMockList = _baseTest.Fixture.Build <DeviceHistory>()
.With(x => x.DeviceId, device.Id)
.With(x => x.LoggedInUserId, _baseTest.OperationAdmin.Id)
.With(x => x.CompanyId, _baseTest.Supervisor.CompanyId)
.Without(x => x.Device)
.CreateMany(historyCount);
_baseTest.DbContext.Devices.Add(device);
_baseTest.DbContext.DeviceHistory.AddRange(historyMockList);
_baseTest.DbContext.SaveChanges();
string uriGetComments = $"devices/{device.Id}/history";
// Act
_baseTest.HttpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(userToken.TokenType, userToken.AccessToken);
var response = await _baseTest.HttpClient.GetAsync(uriGetComments);
//Assert
response.StatusCode.Should().Be(StatusCodes.Status403Forbidden);
}
public async Task <TokenModel> GetAuthorizationToken(UserLoginOption userLogin)
{
var uri = new Uri($"{_identityServiceUsrl}/authorize/token");
var responseString = await SendRequestAsync(uri, HttpMethod.Post, JsonConvert.SerializeObject(userLogin));
return(DeserializeResultFromResponseString <TokenModel>(responseString));
}
public async Task ShouldReturHistoryForSupervisorWhenGetHistory()
{
// Arrange
var userLoginOptiomTest = new UserLoginOption {
UserName = _baseTest.Supervisor.Email, Password = ConstTest.Password, Scope = Const.Permissions.Comment.Read
};
var userToken = await _baseTest.HttpServiceTest.GetAuthorizationToken(userLoginOptiomTest);
int historyCountWithUserCompanyId = 8;
int historyCountWithOtherCompanyId = 5;
var device = _baseTest.Fixture.Build <Device>()
.With(x => x.Id, Guid.NewGuid())
.With(x => x.CompanyId, _baseTest.Supervisor.CompanyId)
.Without(x => x.DeviceHistory).Create();
var historyMockList = _baseTest.Fixture.Build <DeviceHistory>()
.With(x => x.DeviceId, device.Id)
.With(x => x.LoggedInUserId, _baseTest.OperationAdmin.Id)
.With(x => x.CompanyId, _baseTest.Supervisor.CompanyId)
.Without(x => x.Device)
.CreateMany(historyCountWithUserCompanyId).ToList();
historyMockList.AddRange(_baseTest.Fixture.Build <DeviceHistory>()
.With(x => x.DeviceId, device.Id)
.With(x => x.LoggedInUserId, _baseTest.OperationAdmin.Id)
.With(x => x.CompanyId, _baseTest.Supervisor.CompanyId + 1)
.Without(x => x.Device)
.CreateMany(historyCountWithOtherCompanyId));
_baseTest.DbContext.Devices.Add(device);
_baseTest.DbContext.DeviceHistory.AddRange(historyMockList);
_baseTest.DbContext.SaveChanges();
string uriGetComments = $"devices/{device.Id}/history";
// Act
_baseTest.HttpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(userToken.TokenType, userToken.AccessToken);
var response = await _baseTest.HttpClient.GetAsync(uriGetComments);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();
var comments = JsonConvert.DeserializeObject <LazyLoadedResult <DeviceHistoryModel> >(responseString);
//Assert
comments.Total.Should().Be(historyCountWithUserCompanyId);
comments.Result.Count().Should().Be(historyCountWithUserCompanyId);
comments.Result.Should().BeInDescendingOrder(x => x.CreatedOn);
}
public async Task ShouldReturForbidResultIFUserHasNotAccessWhenGetComments()
{
// Arrange
var deviceId = Guid.NewGuid();
string uriGetComments = $"devices/{deviceId}/comments";
var userLoginOptiomTest = new UserLoginOption {
UserName = _baseTest.Manager.Email, Password = ConstTest.Password, Scope = ConstTest.DefaultScopeHasNotAccess
};
var userToken = await _baseTest.HttpServiceTest.GetAuthorizationToken(userLoginOptiomTest);
// Act
_baseTest.HttpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(userToken.TokenType, userToken.AccessToken);
var response = await _baseTest.HttpClient.GetAsync(uriGetComments);
//Assert
response.StatusCode.Should().Be(StatusCodes.Status403Forbidden);
}
public async Task ShouldReturForbidResultIFDeviceNotExistWhenGetHistory()
{
// Arrange
var deviceId = Guid.NewGuid();
string uriGetComments = $"devices/{deviceId}/history";
var userLoginOptiomTest = new UserLoginOption {
UserName = _baseTest.OperationAdmin.Email, Password = ConstTest.Password, Scope = Const.Permissions.History.Read
};
var userToken = await _baseTest.HttpServiceTest.GetAuthorizationToken(userLoginOptiomTest);
// Act
_baseTest.HttpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(userToken.TokenType, userToken.AccessToken);
var response = await _baseTest.HttpClient.GetAsync(uriGetComments);
response.StatusCode.Should().Be(StatusCodes.Status404NotFound);
}
public async Task ShouldReturBadRequestIFDeviceNotExistWhenPostComments()
{
// Arrange
var deviceId = Guid.NewGuid();
string uriPostComments = $"devices/{deviceId}/comments";
var userLoginOptiomTest = new UserLoginOption {
UserName = _baseTest.OperationAdmin.Email, Password = ConstTest.Password, Scope = Const.Permissions.Comment.Create
};
var userToken = await _baseTest.HttpServiceTest.GetAuthorizationToken(userLoginOptiomTest);
var content = new StringContent(JsonConvert.SerializeObject(_baseTest.Fixture.Create <CommentRequestModel>()), Encoding.UTF8, "application/json");
// Act
_baseTest.HttpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(userToken.TokenType, userToken.AccessToken);
var response = await _baseTest.HttpClient.PostAsync(uriPostComments, content);
//Assert
response.StatusCode.Should().Be(StatusCodes.Status400BadRequest);
}
public async Task ShouldReturEmptyResultIFDeviceNotExistWhenGetComments()
{
// Arrange
var deviceId = Guid.NewGuid();
string uriGetComments = $"devices/{deviceId}/comments";
var userLoginOptiomTest = new UserLoginOption {
UserName = _baseTest.OperationAdmin.Email, Password = ConstTest.Password, Scope = Const.Permissions.Comment.Read
};
var userToken = await _baseTest.HttpServiceTest.GetAuthorizationToken(userLoginOptiomTest);
// Act
_baseTest.HttpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(userToken.TokenType, userToken.AccessToken);
var response = await _baseTest.HttpClient.GetAsync(uriGetComments);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();
var comments = JsonConvert.DeserializeObject <LazyLoadedResult <CommentModel> >(responseString);
//Assert
comments.Total.Should().Be(0);
comments.Result.Should().BeEmpty();
}
public async Task ShouldReturCommentsWithLazyLoadingWhenGetComments(int skip, int take)
{
// Arrange
var userLoginOptiomTest = new UserLoginOption {
UserName = _baseTest.OperationAdmin.Email, Password = ConstTest.Password, Scope = Const.Permissions.Comment.Read
};
var userToken = await _baseTest.HttpServiceTest.GetAuthorizationToken(userLoginOptiomTest);
int commentCount = 10;
var device = _baseTest.Fixture.Build <Device>().With(x => x.Id, Guid.NewGuid()).Without(x => x.DeviceHistory).Create();
var commentsMockList = _baseTest.Fixture.Build <Comment>()
.With(x => x.DeviceId, device.Id)
.With(x => x.UserId, _baseTest.OperationAdmin.Id)
.Without(x => x.Device)
.CreateMany(commentCount);
_baseTest.DbContext.Devices.Add(device);
_baseTest.DbContext.Comments.AddRange(commentsMockList);
_baseTest.DbContext.SaveChanges();
string uriGetComments = $"devices/{device.Id}/comments?{nameof(LazyLoadParameters.Offset)}={skip}&{nameof(LazyLoadParameters.Limit)}={take}";
// Act
_baseTest.HttpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(userToken.TokenType, userToken.AccessToken);
var response = await _baseTest.HttpClient.GetAsync(uriGetComments);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();
var comments = JsonConvert.DeserializeObject <LazyLoadedResult <CommentModel> >(responseString);
//Assert
comments.Offset.Should().Be(skip);
comments.Limit.Should().Be(take);
comments.Total.Should().Be(commentCount);
comments.Result.Count().Should().Be(_baseTest.DbContext.Comments.Skip(skip).Take(take).Count());
}
public override void Visit(UserLoginOption node) { this.action(node); }
public override void ExplicitVisit(UserLoginOption fragment)
{
_fragments.Add(fragment);
}
public async Task InitializeAsync()
{
lock (_lock)
{
var builder = new ConfigurationBuilder()
.AddJsonFile("appsettings.json", optional: true);
var configuration = builder.Build();
IWebHostBuilder webHostBuild =
WebHost.CreateDefaultBuilder()
.UseStartup <TestStartUp>()
.UseWebRoot(Directory.GetCurrentDirectory())
.UseContentRoot(Directory.GetCurrentDirectory());
var cableDbConnectionString = configuration.GetConnectionString("cpdb");
var dbConnectionString = configuration.GetConnectionString("db");
if (string.IsNullOrWhiteSpace(cableDbConnectionString) || string.IsNullOrWhiteSpace(dbConnectionString))
{
throw new ApplicationException("Missing the connection string to database");
}
;
webHostBuild.ConfigureServices(service =>
{
service.AddDbContextPool <CablePortalAppDataContext>(ctxOptions =>
{
ctxOptions.UseInMemoryDatabase(cableDbConnectionString).EnableSensitiveDataLogging();
ctxOptions.ConfigureWarnings(x => x.Ignore(InMemoryEventId.TransactionIgnoredWarning));
});
service.AddDbContextPool <AppDataContext>(ctxOptions =>
{
ctxOptions.UseInMemoryDatabase(dbConnectionString).EnableSensitiveDataLogging();
ctxOptions.ConfigureWarnings(x => x.Ignore(InMemoryEventId.TransactionIgnoredWarning));
});
service.Configure <UserLoginOption>(options => configuration.Bind("TestUserCredential", options));
service.AddScoped <IHttpServiceTest, HttpServiceTest>();
string azureStorageConnectionString = configuration["connectionStrings:storageAccount"];
if (!CloudStorageAccount.TryParse(azureStorageConnectionString, out CloudStorageAccount storageAccount))
{
throw new ApplicationException("Missing Azure Blob Storage settings");
}
var blobStorageClient = storageAccount.CreateCloudBlobClient();
_cloudBlobContainer = blobStorageClient.GetContainerReference(DefaultCompanyId.ToString());
if (_cloudBlobContainer == null)
{
throw new ApplicationException("Blob container not exist");
}
});
TestServer = new TestServer(webHostBuild);
CableDbContext = TestServer.Host.Services.GetRequiredService <CablePortalAppDataContext>();
DbContext = TestServer.Host.Services.GetRequiredService <AppDataContext>();
TestSeed = TestServer.Host.Services.GetRequiredService <TestSeed>();
HttpClient = TestServer.CreateClient();
Fixture = new Fixture();
Fixture.Customizations.Add(new IgnoreVirtualMembers());
_userLogin = TestServer.Host.Services.GetRequiredService <IOptions <UserLoginOption> >()?.Value;
HttpServiceTest = TestServer.Host.Services.GetRequiredService <IHttpServiceTest>();
}
AdminToken = await HttpServiceTest.GetAuthorizationToken(_userLogin);
AdminProfile = await HttpServiceTest.GetUserProfile(AdminToken);
}
