public async Task GivenTankDoesNotExist_RespondsWithNotFound()
{
// Arrange
var userId = Guid.NewGuid();
var bearerToken = new TestBearerTokenBuilder()
.WithUserId(userId)
.WithRole(UserRole.Standard)
.Build();
HttpClient.SetBearerToken(bearerToken);
var user = new UserEntity
{
Id = userId
};
await _userCollection.InsertOneAsync(user);
// Act
var response = await HttpClient.GetAsync(_url);
// Assert
var responseData = await response.Content.ReadFromJsonAsync <ExceptionResponse>();
Assert.Multiple(() =>
{
Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NotFound));
Assert.That(responseData.ExceptionCode, Is.EqualTo((int)ExceptionCode.EntityNotFound));
Assert.That(responseData.TechnicalMessage, Is.Not.Null);
Assert.That(responseData.UserMessage, Is.EqualTo(ExceptionMessages.Tank.NoTanksWithUserId));
});
}
public async Task GivenLicenseDoesNotExist_RespondsWithNotFound()
{
// Arrange
var licenseId = Guid.NewGuid();
var url = GetUrl(licenseId);
var bearerToken = new TestBearerTokenBuilder()
.WithRole(UserRole.Standard)
.Build();
HttpClient.SetBearerToken(bearerToken);
// Act
var response = await HttpClient.GetAsync(url);
// Assert
var responseData = await response.Content.ReadFromJsonAsync <ExceptionResponse>();
Assert.Multiple(() =>
{
Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NotFound));
Assert.That(responseData.ExceptionCode, Is.EqualTo((int)ExceptionCode.EntityNotFound));
Assert.That(responseData.TechnicalMessage, Is.Not.Null);
Assert.That(responseData.UserMessage, Is.EqualTo(ExceptionMessages.License.NoLicenseWithId));
});
}
public async Task GivenInvalidUserId_RespondsWithNotFound()
{
// Arrange - Data
var userId = Guid.NewGuid();
var url = GetUrl(userId);
var bearerToken = new TestBearerTokenBuilder()
.WithRole(UserRole.Administrator)
.Build();
// Arrange - Client
HttpClient.SetBearerToken(bearerToken);
// Act
var response = await HttpClient.GetAsync(url);
// Assert
var responseData = await response.Content.ReadFromJsonAsync <ExceptionResponse>();
Assert.Multiple(() =>
{
Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NotFound));
Assert.That(responseData.ExceptionCode, Is.EqualTo((int)ExceptionCode.EntityNotFound));
Assert.That(responseData.TechnicalMessage, Is.Not.Null);
Assert.That(responseData.UserMessage, Is.EqualTo(ExceptionMessages.User.UserNotFound));
});
}
private void SetStandardBearerToken()
{
var bearerToken = new TestBearerTokenBuilder()
.WithRole(UserRole.Standard)
.Build();
HttpClient.SetBearerToken(bearerToken);
}
public async Task GivenInvalidRole_RespondsWithForbidden()
{
// Arrange
var bearerToken = new TestBearerTokenBuilder().Build();
var request = new CreateLicenseRequest();
HttpClient.SetBearerToken(bearerToken);
// Act
var response = await HttpClient.PostAsJsonAsync(_url, request);
// Assert
Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.Forbidden));
}
public async Task GivenInvalidRole_RespondsWithForbidden()
{
// Arrange
var licenseId = Guid.NewGuid();
var url = GetUrl(licenseId);
var bearerToken = new TestBearerTokenBuilder()
.Build();
HttpClient.SetBearerToken(bearerToken);
// Act
var response = await HttpClient.GetAsync(url);
// Assert
Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.Forbidden));
}
public async Task GivenLicenseExists_RespondsWithLicense()
{
// Arrange
var licenseId = Guid.NewGuid();
var url = GetUrl(licenseId);
var bearerToken = new TestBearerTokenBuilder()
.WithRole(UserRole.Standard)
.Build();
var license = new LicenseEntity
{
Id = licenseId,
Key = "This is a key",
Created = DateTime.UtcNow,
Products = new List <LicenseProductEntity>
{
new LicenseProductEntity
{
Name = "Product Name",
Created = DateTime.UtcNow,
Expiration = DateTime.UtcNow
}
}
};
await _licenseCollection.InsertOneAsync(license);
HttpClient.SetBearerToken(bearerToken);
// Act
var response = await HttpClient.GetAsync(url);
// Assert
var responseData = await response.Content.ReadFromJsonAsync <LicenseResponse>();
Assert.Multiple(() =>
{
Assert.That(responseData.Id, Is.EqualTo(licenseId));
Assert.That(responseData.Products[0].Name, Is.EqualTo(license.Products[0].Name));
DiagnoseaAssert.That(responseData.Products[0].Expiration, Is.EqualTo(license.Products[0].Expiration));
});
}
public async Task GivenTankDoesExist_RespondsWithTank()
{
// Arrange
var userId = Guid.NewGuid();
var tankId = Guid.NewGuid();
var bearerToken = new TestBearerTokenBuilder()
.WithUserId(userId)
.WithRole(UserRole.Standard)
.Build();
HttpClient.SetBearerToken(bearerToken);
var user = new UserEntity
{
Id = userId
};
var tank = new TankEntity
{
Id = tankId,
UserId = userId
};
await _userCollection.InsertOneAsync(user);
await _tankCollection.InsertOneAsync(tank);
// Act
var response = await HttpClient.GetAsync(_url);
// Assert
var responseData = await response.Content.ReadFromJsonAsync <IEnumerable <TankResponse> >();
Assert.Multiple(() =>
{
Assert.That(responseData.Count(), Is.EqualTo(1));
var resultingTankResponse = responseData.FirstOrDefault();
Assert.That(resultingTankResponse.Id, Is.EqualTo(tankId));
});
}
public async Task GivenValidUserId_RespondsWithUser()
{
// Arrange - Data
var userId = Guid.NewGuid();
var url = GetUrl(userId);
var bearerToken = new TestBearerTokenBuilder()
.WithRole(UserRole.Administrator)
.Build();
// Arrange - Client
HttpClient.SetBearerToken(bearerToken);
// Arrange - Entity
var user = new UserEntity
{
Id = userId,
UserName = "******",
FriendlyName = "This is a friendly name"
};
await _userCollection.InsertOneAsync(user);
// Act
var response = await HttpClient.GetAsync(url);
// Assert
var responseData = await response.Content.ReadFromJsonAsync <UserResponse>();
Assert.Multiple(() =>
{
Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
Assert.That(responseData.Id, Is.EqualTo(user.Id));
Assert.That(responseData.UserName, Is.EqualTo(user.UserName));
Assert.That(responseData.FriendlyName, Is.EqualTo(user.FriendlyName));
});
}
