public async Task Should_Get_NotProvided_Calories_From_Service_For_Valid_MealName()
{
// Arrange
_fixture.StartScope();
var request = new Create.Request
{
Date = DateTime.UtcNow,
Time = "11:11",
Text = Guid.NewGuid().ToString()
};
const decimal calories = 55.55M;
var service = (TestCaloriesService)_fixture.GetService <ICaloriesService>();
service.Calories.Add(request.Text, calories);
var testAccount = (TestAccountProvider)_fixture.GetService <ICurrentAccountProvider>();
testAccount.Id = Guid.NewGuid();
// Act
var response = await _fixture.SendAsync(request);
var meal = await _fixture.FindAsync <Meal>(response.Id);
// Assert
Assert.NotNull(response);
Assert.Equal(request.Date.ToShortDateString(), meal.Date.ToShortDateString());
Assert.Equal(request.Time, meal.Time.ToShortTimeString());
Assert.Equal(request.Text, meal.Text);
Assert.Equal(calories, meal.Calories);
Assert.Equal(testAccount.Id, meal.AccountId);
}
public async Task Should_Update_Meal()
{
_fixture.StartScope();
// Arrange-TestAccount
var testAccount = (TestAccountProvider)_fixture.GetService <ICurrentAccountProvider>();
{ // Arrange-Account
var request = new Api.Features.Account.Create.Request
{
Email = _fixture.GetEmail(),
Password = Guid.NewGuid().ToString()
};
await _fixture.SendAsync(request);
testAccount.Id =
(await _fixture.ExecuteDbContextAsync(db => db.Accounts.SingleOrDefaultAsync(x => x.Email == request.Email))).Id;
}
Guid id;
{
// Arrange-Meal-To-Update
var request = new Create.Request
{
Date = DateTime.UtcNow.Date,
Time = "11:11",
Text = "string",
Calories = 3
};
var response = await _fixture.SendAsync(request);
id = response.Id;
}
{
// Arrange
var request = new Update.Request
{
Id = id,
Date = DateTime.UtcNow.Date.AddDays(1),
Time = "11:15",
Text = "Another String",
Calories = 22
};
// Act
await _fixture.SendAsync(request);
var meal =
await _fixture.ExecuteDbContextAsync(db => db.Meals.SingleOrDefaultAsync(x => x.Id == id));
// Assert
Assert.Equal(request.Date.ToShortDateString(), meal.Date.ToShortDateString());
Assert.Equal(request.Time, meal.Time.ToShortTimeString());
Assert.Equal(request.Text, meal.Text);
Assert.Equal(request.Calories, meal.Calories);
Assert.False(meal.CalorieStatus);
Assert.Equal(testAccount.Id, meal.AccountId);
}
}
public async Task <IActionResult> Create([FromBody] Create.Request req)
{
var requester = new AuthenticationServer.ProtocolModels.Auth.CreateAccount();
requester.request.account = req.account;
requester.request.password = req.password;
requester.request.nickname = req.nickname;
var response = await requester.PostAsync(AuthenticationServerInfo.Uri);
if (response == null)
{
return(BuildErrorResponse("SeverInternalError"));
}
if (response.resultCode == AuthenticationServer.ProtocolModels.Auth.CreateAccount.Response.ResultCode.AlreadyExists)
{
return(BuildErrorResponse($"<{req.account}> is already exists."));
}
return(Ok(new Create.Response
{
account = response.account,
nickname = response.nickname,
permission = response.permission,
}));
}
public async Task Throws_Create_Exception_For_Existing_Email()
{
// Arrange
_fixture.StartScope();
var request = new Create.Request
{
Email = "*****@*****.**",
Password = Guid.NewGuid().ToString()
};
{ // Create Account
var response = await _fixture.SendAsync(request);
// Inner-Assert
Assert.NotNull(response);
Assert.NotEmpty(response.Token);
}
{
// Act & Assert
var exception = await Assert.ThrowsAsync <RestException>(() => _fixture.SendAsync(request));
Assert.Equal(HttpStatusCode.Conflict, exception.HttpStatus);
}
}
public async Task Should_Get_Token()
{
// Arrange
_fixture.StartScope();
var createRequest = new Create.Request
{
Email = "*****@*****.**",
Password = Guid.NewGuid().ToString()
};
var request = new Token.Request
{
Email = createRequest.Email,
Password = createRequest.Password
};
// Act
await _fixture.SendAsync(createRequest);
var response = await _fixture.SendAsync(request);
// Assert
Assert.NotNull(response);
Assert.NotEmpty(response.Token);
}
public async Task Should_Set_Null_For_Invalid_MealName()
{
// Arrange
_fixture.StartScope();
var request = new Create.Request
{
Date = DateTime.UtcNow,
Time = "11:11",
Text = Guid.NewGuid().ToString()
};
var testAccount = (TestAccountProvider)_fixture.GetService <ICurrentAccountProvider>();
testAccount.Id = Guid.NewGuid();
// Act
var response = await _fixture.SendAsync(request);
var meal = await _fixture.FindAsync <Meal>(response.Id);
// Assert
Assert.NotNull(response);
Assert.Equal(request.Date.ToShortDateString(), meal.Date.ToShortDateString());
Assert.Equal(request.Time, meal.Time.ToShortTimeString());
Assert.Equal(request.Text, meal.Text);
Assert.Null(meal.Calories);
Assert.Equal(testAccount.Id, meal.AccountId);
}
public async Task <Create.Response> Create(Create.Request request, CancellationToken cancellationToken)
{
var userId = await _identityService.GetCurrentUserId(cancellationToken);
if (string.IsNullOrEmpty(userId))
{
throw new NoUserForAdCreationException($"Попытка создания объявления [{request.Title}] без пользователя.");
}
var ad = new Domain.Advertisement
{
Title = request.Title,
Description = request.Description,
Price = request.Price,
Cover = request.Cover,
OwnerId = userId,
Status = Domain.Advertisement.Statuses.Created,
Location = request.Location,
GeoLat = request.GeoLat,
GeoLon = request.GeoLon,
CreatedDate = DateTime.UtcNow,
CategoryId = request.CategoryId
};
await _repository.Save(ad, cancellationToken);
return(new Create.Response
{
Id = ad.Id
});
}
public async Task <IActionResult> Post(Create.Request request)
{
var result =
await this.mediator.Send(request);
return(Ok(result));
}
public async Task Should_Get_Account_Index_With_Filter()
{
_fixture.StartScope();
{ // Arrange-TestAccountList
var request = new Create.Request
{
Email = "*****@*****.**",
Password = Guid.NewGuid().ToString()
};
await _fixture.SendAsync(request);
request.Email = "*****@*****.**";
await _fixture.SendAsync(request);
request.Email = "*****@*****.**";
await _fixture.SendAsync(request);
// Act
var count =
await _fixture.CountAsync <Account>();
// Assert
// There is also an AdminAccount
Assert.Equal(3 + 1, count);
}
{ // Single Result Test
// Arrange
var request = new Index.Request
{
Filter = "Email eq '*****@*****.**'"
};
// Act
var response = await _fixture.SendAsync(request);
// Assert
Assert.NotNull(response);
Assert.Single(response.Items);
Assert.Equal("*****@*****.**", response.Items.First().Email);
}
{ // Multiple Result Test
// Arrange
var request = new Index.Request
{
Filter = "Role eq 'RegularUser'"
};
// Act
var response = await _fixture.SendAsync(request);
// Assert
Assert.NotNull(response);
Assert.Equal(3, response.Items.Count);
Assert.Equal("*****@*****.**", response.Items.First().Email);
}
}
public async Task ShouldReturnCreatedUsername()
{
var request = new Create.Request("isanjay", "Sanjay_11!", "Sanjay", "Idpuganti", "*****@*****.**");
var handledResult = await _handler.Handle(request,
CancellationToken.None);
Assert.Equal(handledResult.Username, request.Username);
}
public async Task Throws_Update_Exception_If_Sender_Is_Not_Meal_Owner()
{
_fixture.StartScope();
// Arrange-TestAccount(RegularUser)
var testAccount = (TestAccountProvider)_fixture.GetService <ICurrentAccountProvider>();
testAccount.Role = Role.RegularUser;
{ // Arrange-Account
var request = new Api.Features.Account.Create.Request
{
Email = _fixture.GetEmail(),
Password = Guid.NewGuid().ToString()
};
await _fixture.SendAsync(request);
testAccount.Id =
(await _fixture.ExecuteDbContextAsync(db => db.Accounts.SingleOrDefaultAsync(x => x.Email == request.Email))).Id;
}
// This is created by another Account
var createRequest = new Create.Request
{
Date = DateTime.UtcNow.Date,
Time = "11:11",
Text = "string",
Calories = 3
};
var createResponse = await _fixture.SendAsync(createRequest);
{ // Arrange-Account(Change the Account)
var request = new Api.Features.Account.Create.Request
{
Email = _fixture.GetEmail(),
Password = Guid.NewGuid().ToString()
};
await _fixture.SendAsync(request);
testAccount.Id =
(await _fixture.ExecuteDbContextAsync(db => db.Accounts.SingleOrDefaultAsync(x => x.Email == request.Email))).Id;
}
{
// Arrange
var request = new Update.Request
{
Id = createResponse.Id,
Date = DateTime.UtcNow.Date.AddDays(1),
Time = "11:15",
Text = "Another String",
Calories = 22
};
// Act & Assert
await Assert.ThrowsAsync <RestException>(() => _fixture.SendAsync(request));
}
}
public void GivenIHaveCreatePlayerRequest(Table table)
{
_request = GetPlayer(table);
var playerId = new PlayerId("player1");
_testFixture.MockNextRandomId(playerId.ToString());
_expectedPlayer = new Player(_testFixture.CurrentTenant, new Version("<some-version>"), playerId, _request.FirstName, _request.LastName);
}
public async Task Should_Set_True_To_CalorieStatus_If_CurrentCalories_IsLessThan_TargetCalories_With_Multiple_Meals()
{
_fixture.StartScope();
// Arrange-TestAccount
var testAccount = (TestAccountProvider)_fixture.GetService <ICurrentAccountProvider>();
{ // Arrange-Account
var request = new Api.Features.Account.Create.Request
{
Email = _fixture.GetEmail(),
Password = Guid.NewGuid().ToString()
};
await _fixture.SendAsync(request);
testAccount.Id =
(await _fixture.ExecuteDbContextAsync(db => db.Accounts.SingleOrDefaultAsync(x => x.Email == request.Email))).Id;
}
{ // Arrange-AccountSetting
var request = new Api.Features.Account.UpdateSetting.Request
{
TargetCalories = 3
};
await _fixture.SendAsync(request);
}
{ // Arrange
var request = new Create.Request
{
Date = DateTime.UtcNow.Date,
Time = "11:11",
Text = Guid.NewGuid().ToString(),
Calories = 1
};
// Act
await _fixture.SendAsync(request);
var response = await _fixture.SendAsync(request);
var meal = await _fixture.FindAsync <Meal>(response.Id);
// Assert
Assert.NotNull(response);
Assert.Equal(request.Date.ToShortDateString(), meal.Date.ToShortDateString());
Assert.Equal(request.Time, meal.Time.ToShortTimeString());
Assert.Equal(request.Text, meal.Text);
Assert.Equal(request.Calories, meal.Calories);
Assert.True(meal.CalorieStatus);
Assert.Equal(testAccount.Id, meal.AccountId);
}
}
public async Task Create_Response_Success(
Create.Request request, CancellationToken cancellationToken,
int userId)
{
ConfigureMoqEnvironment(userId.ToString(), 1);
// Act
var response = await advertisementService.Create(request, cancellationToken);
// Assert
_identityServiceMock.Verify();
Assert.NotNull(response);
Assert.NotEqual(default, response.Id);
public async Task Should_Delete_Meal()
{
_fixture.StartScope();
// Arrange-TestAccount
var testAccount = (TestAccountProvider)_fixture.GetService <ICurrentAccountProvider>();
{ // Arrange-Account
var request = new Api.Features.Account.Create.Request
{
Email = _fixture.GetEmail(),
Password = Guid.NewGuid().ToString()
};
await _fixture.SendAsync(request);
testAccount.Id =
(await _fixture.ExecuteDbContextAsync(db => db.Accounts.SingleOrDefaultAsync(x => x.Email == request.Email))).Id;
}
Guid id;
{
// Arrange-Meal-To-Delete
var request = new Create.Request
{
Date = DateTime.UtcNow.Date,
Time = "11:11",
Text = "string",
Calories = 3
};
var response = await _fixture.SendAsync(request);
id = response.Id;
}
{
// Arrange
var request = new Delete.Request
{
Id = id
};
// Act
await _fixture.SendAsync(request);
var count = await _fixture.CountAsync <Meal>();
// Assert
Assert.Equal(0, count);
}
}
public async Task Throws_Update_Exception_For_Invalid_Identifier()
{
_fixture.StartScope();
// Arrange-TestAccount
var testAccount = (TestAccountProvider)_fixture.GetService <ICurrentAccountProvider>();
{ // Arrange-Account
var request = new Api.Features.Account.Create.Request
{
Email = _fixture.GetEmail(),
Password = Guid.NewGuid().ToString()
};
await _fixture.SendAsync(request);
testAccount.Id =
(await _fixture.ExecuteDbContextAsync(db => db.Accounts.SingleOrDefaultAsync(x => x.Email == request.Email))).Id;
}
{
// Arrange-Meal-To-Update
var request = new Create.Request
{
Date = DateTime.UtcNow.Date,
Time = "11:11",
Text = "string",
Calories = 3
};
await _fixture.SendAsync(request);
}
{
// Arrange
var request = new Update.Request
{
Id = Guid.NewGuid(),
Date = DateTime.UtcNow.Date.AddDays(1),
Time = "11:15",
Text = "Another String",
Calories = 22
};
// Act & Assert
await Assert.ThrowsAsync <RestException>(() => _fixture.SendAsync(request));
}
}
public async Task <IActionResult> Post(Create.Request request)
{
if (request.Model == null)
{
return(BadRequest("Invalid body."));
}
var @event = new AccountCreated(
request.CorrelationId,
request.Model.Type,
request.Model.Balance);
session.Events.StartStream <Account>(request.Model.Id, @event);
await session.SaveChangesAsync(new CancellationToken()).ConfigureAwait(false);
return(StatusCode(201)); //return the route you dingus.
}
public async Task <Create.Response> Create(Create.Request request, CancellationToken cancellationToken)
{
var userId = await _identityService.GetCurrentUserId(cancellationToken);
var ad = new Domain.Ad
{
Price = request.Price,
Status = Domain.Ad.Statuses.Created,
OwnerId = userId,
CreatedAt = DateTime.UtcNow
};
await _repository.Save(ad, cancellationToken);
return(new Create.Response
{
Id = ad.Id
});
}
public async Task Should_Get_Account_Index_Without_Filter()
{
_fixture.StartScope();
{ // Arrange-TestAccountList
var request = new Create.Request
{
Email = "*****@*****.**",
Password = Guid.NewGuid().ToString()
};
await _fixture.SendAsync(request);
request.Email = "*****@*****.**";
await _fixture.SendAsync(request);
request.Email = "*****@*****.**";
await _fixture.SendAsync(request);
// Act
var count =
await _fixture.CountAsync <Account>();
// Assert
// There is also an AdminAccount
Assert.Equal(3 + 1, count);
}
{
// Arrange
var request = new Index.Request
{
PageSize = 100
};
// Act
var response = await _fixture.SendAsync(request);
// Assert
Assert.NotNull(response);
Assert.Equal(4, response.Items.Count);
}
}
public async Task Throws_Get_Token_Exception_For_Invalid_Credentials()
{
// Arrange
_fixture.StartScope();
var createRequest = new Create.Request
{
Email = "*****@*****.**",
Password = Guid.NewGuid().ToString()
};
var request = new Token.Request
{
Email = _fixture.GetEmail(),
Password = createRequest.Password
};
// Act
await Assert.ThrowsAsync <RestException>(() => _fixture.SendAsync(request));
}
public async Task Should_Update_Account()
{
_fixture.StartScope();
// Arrange-TestAccount
var testAccount = (TestAccountProvider)_fixture.GetService <ICurrentAccountProvider>();
{ // Arrange-Account
var request = new Create.Request
{
Email = _fixture.GetEmail(),
Password = Guid.NewGuid().ToString()
};
await _fixture.SendAsync(request);
testAccount.Id =
(await _fixture.ExecuteDbContextAsync(db => db.Accounts.SingleOrDefaultAsync(x => x.Email == request.Email))).Id;
}
{
// Arrange
var request = new Update.Request
{
Password = Guid.NewGuid().ToString()
};
var passwordHasher = _fixture.GetService <IPasswordHasher>();
// Act
await _fixture.SendAsync(request);
var account =
await _fixture.ExecuteDbContextAsync(db => db.Accounts.SingleOrDefaultAsync(x => x.Id == testAccount.Id));
// Assert
Assert.NotNull(account);
Assert.True(passwordHasher.VerifyHashedPassword(request.Password, account.PasswordHash));
}
}
public async Task Should_Delete_Account_With_Valid_Email()
{
_fixture.StartScope();
string email;
{ // Arrange-Account-To-Delete
var request = new Create.Request
{
Email = _fixture.GetEmail(),
Password = Guid.NewGuid().ToString()
};
await _fixture.SendAsync(request);
email = request.Email;
}
{
// Arrange
var request = new Delete.Request
{
Email = email
};
// Act
await _fixture.SendAsync(request);
var account = await _fixture.ExecuteDbContextAsync(db => db.Accounts.SingleOrDefaultAsync(x => x.Email == email));
var count = await _fixture.ExecuteDbContextAsync(db => db.Accounts.CountAsync());
// Assert
Assert.Null(account);
// There should be only Admin account
Assert.Equal(1, count);
}
}
public async Task Should_Create_Account()
{
// Arrange
_fixture.StartScope();
var request = new Create.Request
{
Email = "*****@*****.**",
Password = Guid.NewGuid().ToString()
};
var passwordHasher = _fixture.GetService <IPasswordHasher>();
// Act
var response = await _fixture.SendAsync(request);
var account =
await _fixture.ExecuteDbContextAsync(db => db.Accounts.SingleOrDefaultAsync(x => x.Email == request.Email));
// Assert
Assert.NotNull(response);
Assert.NotEmpty(response.Token);
Assert.NotNull(account);
Assert.Equal(request.Email, account.Email);
Assert.True(passwordHasher.VerifyHashedPassword(request.Password, account.PasswordHash));
}
public async Task Throws_Delete_Exception_For_Invalid_Email()
{
_fixture.StartScope();
{ // Arrange-Account-To-Delete
var request = new Create.Request
{
Email = _fixture.GetEmail(),
Password = Guid.NewGuid().ToString()
};
await _fixture.SendAsync(request);
}
{
// Arrange
var request = new Delete.Request
{
Email = _fixture.GetEmail()
};
// Act & Assert
await Assert.ThrowsAsync <RestException>(() => _fixture.SendAsync(request));
}
}
public Task <IActionResult> Create(Create.Request request)
{
return(_createHandler.ExecuteHandler(request, _mapper.Map <ApiPlayer>));
}
public async Task Should_Get_Meal_Index_With_Filter()
{
_fixture.StartScope();
// Arrange-TestAccount
var testAccount = (TestAccountProvider)_fixture.GetService <ICurrentAccountProvider>();
{ // Arrange-Account
var request = new Api.Features.Account.Create.Request
{
Email = _fixture.GetEmail(),
Password = Guid.NewGuid().ToString()
};
await _fixture.SendAsync(request);
testAccount.Id =
(await _fixture.ExecuteDbContextAsync(db => db.Accounts.SingleOrDefaultAsync(x => x.Email == request.Email))).Id;
}
{ // Arrange-AccountSetting
var request = new Api.Features.Account.UpdateSetting.Request
{
TargetCalories = 10
};
await _fixture.SendAsync(request);
}
{ // Arrange-MealList
var request = new Create.Request
{
Date = DateTime.UtcNow.Date,
Time = "11:11",
Text = "string",
Calories = 3
};
await _fixture.SendAsync(request);
request.Text = "string";
await _fixture.SendAsync(request);
request.Text = "string1";
await _fixture.SendAsync(request);
request.Text = "OverCalories"; // Now => 3+3+3+3 > 10
await _fixture.SendAsync(request);
request.Date = request.Date.AddDays(1); // This will be used to create complex query
request.Text = "New Day";
await _fixture.SendAsync(request);
// Act
var count =
await _fixture.CountAsync <Meal>();
// Assert
Assert.Equal(5, count);
}
{ // Single Result Test
// Arrange
var request = new Index.Request
{
Filter = "CalorieStatus = 'false'"
};
// Act
var response = await _fixture.SendAsync(request);
// Assert
Assert.NotNull(response);
Assert.Single(response.Items);
Assert.Equal("11:11", response.Items.First().Time);
Assert.Equal("OverCalories", response.Items.First().Text);
}
{ // Multiple Result Test With Single Filter
// Arrange
var request = new Index.Request
{
Filter = "CalorieStatus = 'true'"
};
// Act
var response = await _fixture.SendAsync(request);
// Assert
Assert.NotNull(response);
Assert.Equal(4, response.Items.Count);
}
{ // Multiple Result Test With Multiple Filter
// Arrange
var request = new Index.Request
{
Filter = "(CalorieStatus = 'false') or (Text eq 'string')"
};
// Act
var response = await _fixture.SendAsync(request);
// Assert
Assert.NotNull(response);
// 2 item by Text = 'string' + 1 item by CalorieStatus = 'false'
Assert.Equal(3, response.Items.Count);
Assert.Contains(response.Items, x => x.Text.Equals("string"));
Assert.Contains(response.Items, x => x.Text.Equals("OverCalories"));
}
{ // Single Result Test With Complex Multiple Filter
// Arrange
var request = new Index.Request
{
Filter = $"(CalorieStatus = 'true' or Text = 'New Day') AnD Date = '{DateTime.UtcNow.Date}'"
};
// Act
var response = await _fixture.SendAsync(request);
// Assert
Assert.NotNull(response);
Assert.Equal(3, response.Items.Count);
// Because of date expression
Assert.DoesNotContain(response.Items, x => x.Text.Equals("New Day"));
// Because of CalorieStatus expression
// Even if first part of the expression matches this item, second part eliminated it
Assert.DoesNotContain(response.Items, x => x.Text.Equals("OverCalories"));
Assert.DoesNotContain(response.Items, x => x.CalorieStatus.Equals(false));
}
}
public async Task Should_Get_Meal_Index_Without_Filter()
{
_fixture.StartScope();
// Arrange-TestAccount
var testAccount = (TestAccountProvider)_fixture.GetService <ICurrentAccountProvider>();
{ // Arrange-Account
var request = new Api.Features.Account.Create.Request
{
Email = _fixture.GetEmail(),
Password = Guid.NewGuid().ToString()
};
await _fixture.SendAsync(request);
testAccount.Id =
(await _fixture.ExecuteDbContextAsync(db => db.Accounts.SingleOrDefaultAsync(x => x.Email == request.Email))).Id;
}
{ // Arrange-AccountSetting
var request = new Api.Features.Account.UpdateSetting.Request
{
TargetCalories = 10
};
await _fixture.SendAsync(request);
}
{ // Arrange-MealList
var request = new Create.Request
{
Date = DateTime.UtcNow.Date,
Time = "11:11",
Text = "string",
Calories = 3
};
await _fixture.SendAsync(request);
request.Date = request.Date.AddDays(1);
request.Text = "string";
await _fixture.SendAsync(request);
request.Date = request.Date.AddDays(1);
request.Text = "string1";
await _fixture.SendAsync(request);
request.Date = request.Date.AddDays(1);
request.Text = "string1";
await _fixture.SendAsync(request);
// Act
var count =
await _fixture.CountAsync <Meal>();
// Assert
Assert.Equal(4, count);
}
{
// Arrange
var request = new Index.Request
{
PageSize = 100
};
// Act
var response = await _fixture.SendAsync(request);
// Assert
Assert.NotNull(response);
Assert.Equal(4, response.Items.Count);
}
}
public async Task <int> CreateGroup(Create.Request request)
{
return(await _mediator.Send(request));
}
