public async Task SetProficiencyAsync_SetFalse_ReturnSuccess()
{
// Arrange
var charProvider = new MockCharacterProvider();
var statProvider = new MockStatisticProvider();
var statOptions = new StatisticOptions
{
InitialAttributeMin = 1,
InitialAttributeMax = 10,
InitialAttributePoints = 40,
InitialAttributesAtMax = 7,
InitialAttributesProficient = 0
};
var controller = new StatisticController(charProvider, statProvider, new GenericProgressionStrategy(statProvider, statOptions));
var character = await charProvider.GetActiveCharacterAsync(1);
await controller.SetStatisticAsync(1, "strength", 10);
// Act
var result = await controller.SetProficiencyAsync(1, "strength", false);
// Assert
Assert.Equal(StatisticResult.StatisticSetSucessfully(), result);
}
/// <inheritdoc />
public async Task <VmGoalCompletionStatistic> GetGoalCompletion(
ApplicationUser currentUser,
StatisticOptions options)
{
IQueryable <Goal> query;
try
{
query = _goalsRepository.GetPerformerGoals(_dataContext.Goals, options.UserIds);
query = _goalsRepository.GetGoalsForProjects(query, options.ProjectIds);
query = _goalsRepository.GetGoalsForPeriod(query, options.DateBegin, options.DateEnd);
}
catch (ArgumentException)
{
throw new HttpResponseException(BadRequest, "Wrong options");
}
var goalsArray = await query
.Select(g => new Goal
{
PerformerId = g.PerformerId,
State = g.State,
StateChangedDate = g.StateChangedDate,
ExpectedCompletedDate = g.ExpectedCompletedDate
})
.ToArrayAsync();
var usersGoals = goalsArray
.GroupBy(g => g.PerformerId)
.ToDictionary(g => g.Key, g => g.ToArray());
return(GetGoalCompletion(usersGoals));
}
public async Task SetProficiencyAsync_ValidInput_ReturnSuccess()
{
// Arrange
var charProvider = new MockCharacterProvider();
var statProvider = new MockStatisticProvider();
var statOptions = new StatisticOptions
{
InitialAttributeMin = 1,
InitialAttributeMax = 10,
InitialAttributePoints = 40,
InitialAttributesAtMax = 7,
InitialAttributesProficient = 1
};
var controller = new StatisticController(charProvider, statProvider, new GenericProgressionStrategy(statProvider, statOptions));
var character = await charProvider.GetActiveCharacterAsync(1);
Statistic str = await statProvider.GetStatisticAsync("strength");
await controller.SetStatisticAsync(1, "strength", 10);
// Act
await controller.SetProficiencyAsync(1, "strength", true);
// Assert
Assert.True(character.GetStatistic(str).IsProficient);
}
public async Task <ActionResult <VmProjectStatistic> > GetProjectStatistic(string userId, int projectId,
[FromBody] StatisticOptions options)
{
var statistic = await _statisticService.GetStatisticForUserAndProject(userId, projectId, options);
return(Ok(statistic));
}
public async Task SetStatisticAsync_LevelTooHighButAttributesUnset_ReturnSuccess()
{
// Arrange
var charProvider = new MockCharacterProvider();
var character = await charProvider.CreateCharacterAsync(100, "TooHigh");
// the important bit
character.Experience = 50000;
var statProvider = new MockStatisticProvider();
var statOptions = new StatisticOptions
{
InitialAttributeMin = 1,
InitialAttributeMax = 10,
InitialAttributePoints = 10,
InitialSetupMaxLevel = 1
};
var controller = new StatisticController(charProvider, statProvider, new GenericProgressionStrategy(statProvider, statOptions));
// Act
var result = await controller.SetStatisticAsync(100, "strength", 3);
// Assert
Assert.Equal(StatisticResult.StatisticSetSucessfully(), result);
}
public async Task <VmProjectStatistic> GetStatisticForProject(int projectId, StatisticOptions options)
{
var query = _dataContext.Goals
.Where(g => g.ProjectId == projectId &&
!g.IsRemoved);
return(await GetStatistic(query, options));
}
public async Task <VmProjectStatistic> GetStatisticForUser(string userId, StatisticOptions options)
{
var query = _dataContext.Goals
.Include(g => g.Project)
.Where(g => g.PerformerId == userId &&
!g.IsRemoved);
return(await GetStatistic(query, options));
}
public async Task SetStatisticAsync_ValidInput_ReturnSuccess()
{
// Arrange
var charProvider = new MockCharacterProvider();
var statProvider = new MockStatisticProvider();
var statOptions = new StatisticOptions
{
InitialAttributeMin = 1,
InitialAttributeMax = 10,
InitialAttributePoints = 40,
InitialAttributesAtMax = 7
};
var controller = new StatisticController(charProvider, statProvider, new GenericProgressionStrategy(statProvider, statOptions));
var character = await charProvider.GetActiveCharacterAsync(1);
// Act
await controller.SetStatisticAsync(1, "strength", 10);
await controller.SetStatisticAsync(1, "perception", 2);
await controller.SetStatisticAsync(1, "endurance", 6);
await controller.SetStatisticAsync(1, "charisma", 6);
await controller.SetStatisticAsync(1, "intelligence", 6);
await controller.SetStatisticAsync(1, "agility", 5);
await controller.SetStatisticAsync(1, "luck", 5);
// Assert
Statistic str = await statProvider.GetStatisticAsync("strength"),
per = await statProvider.GetStatisticAsync("perception"),
end = await statProvider.GetStatisticAsync("endurance"),
cha = await statProvider.GetStatisticAsync("charisma"),
inte = await statProvider.GetStatisticAsync("intelligence"),
agi = await statProvider.GetStatisticAsync("agility"),
lck = await statProvider.GetStatisticAsync("luck");
Assert.True(character.GetStatistic(str).Value.Equals(10) &&
character.GetStatistic(per).Value.Equals(2) &&
character.GetStatistic(end).Value.Equals(6) &&
character.GetStatistic(cha).Value.Equals(6) &&
character.GetStatistic(inte).Value.Equals(6) &&
character.GetStatistic(agi).Value.Equals(5) &&
character.GetStatistic(lck).Value.Equals(5));
}
public async Task SetStatisticAsync_InvalidCharacterId_ReturnCharacterNotFound()
{
// Arrange
var charProvider = new MockCharacterProvider();
var statProvider = new MockStatisticProvider();
StatisticOptions statOptions = new StatisticOptions();
var controller = new StatisticController(charProvider, statProvider, new GenericProgressionStrategy(statProvider, statOptions));
// Act
var result = await controller.SetStatisticAsync(ulong.MaxValue, "strength", 5);
// Assert
Assert.Equal(CharacterResult.CharacterNotFound(), result);
}
public async Task SetStatisticAsync_InvalidStatisticName_ReturnStatisticNotFound()
{
// Arrange
var charProvider = new MockCharacterProvider();
var statProvider = new MockStatisticProvider();
StatisticOptions statOptions = new StatisticOptions();
var controller = new StatisticController(charProvider, statProvider, new GenericProgressionStrategy(statProvider, statOptions));
// Act
var result = await controller.SetStatisticAsync(1, "invalid", 5);
// Assert
Assert.Equal(StatisticResult.StatisticNotFound(), result);
}
public async Task SetStatisticAsync_LevelTooHigh_ReturnLevelTooHigh()
{
// Arrange
var charProvider = new MockCharacterProvider();
var character = await charProvider.CreateCharacterAsync(100, "TooHigh");
var statProvider = new MockStatisticProvider();
var statOptions = new StatisticOptions
{
InitialAttributeMin = 1,
InitialAttributeMax = 10,
InitialAttributePoints = 40,
InitialSkillPoints = 1,
InitialSetupMaxLevel = 1,
AttributePointsOnLevelUp = 0
};
var controller = new StatisticController(charProvider, statProvider, new GenericProgressionStrategy(statProvider, statOptions));
// Act
// Set initial special
await controller.SetStatisticAsync(100, "strength", 10);
await controller.SetStatisticAsync(100, "perception", 2);
await controller.SetStatisticAsync(100, "endurance", 6);
await controller.SetStatisticAsync(100, "charisma", 6);
await controller.SetStatisticAsync(100, "intelligence", 6);
await controller.SetStatisticAsync(100, "agility", 5);
await controller.SetStatisticAsync(100, "luck", 5);
character.Experience = 50000;
await charProvider.UpdateCharacterAsync(character);
// Attempt to set initial special again after going past InitialSetupMaxLevel
var result = await controller.SetStatisticAsync(100, "strength", 4);
// Assert
Assert.Equal(CharacterResult.LevelTooHigh(), result);
}
public async Task GiveExperienceAsync_NotInEnabledChannel_ExperienceEqualsZero()
{
var provider = new MockCharacterProvider();
var statProvider = new MockStatisticProvider();
var statOptions = new StatisticOptions
{
ExpEnabledChannels = new ulong[] { 1 },
ExpMessageLengthDivisor = 1
};
var strategy = new GenericProgressionStrategy(statProvider, statOptions);
var controller = new CharacterController(provider, strategy, new GeneralOptions());
await controller.GiveExperienceAsync(1, 2, "12345");
var character = await provider.GetActiveCharacterAsync(1);
Assert.True(character.Experience == 0);
}
public async Task SetStatisticAsync_AboveMaximum_ReturnTooHigh()
{
// Arrange
var charProvider = new MockCharacterProvider();
var statProvider = new MockStatisticProvider();
var statOptions = new StatisticOptions
{
InitialAttributeMax = 10,
InitialAttributePoints = 12,
};
var controller = new StatisticController(charProvider, statProvider, new GenericProgressionStrategy(statProvider, statOptions));
// Act
var result = await controller.SetStatisticAsync(1, "strength", 11);
// Assert
Assert.Equal(GenericResult.ValueTooHigh(), result);
}
public async Task SetStatisticAsync_NewValueLowerThanCurrent_ReturnInvalidInput()
{
// Arrange
var charProvider = new MockCharacterProvider();
var character = await charProvider.CreateCharacterAsync(100, "TooHigh");
var statProvider = new MockStatisticProvider();
var statOptions = new StatisticOptions
{
InitialAttributeMin = 1,
InitialAttributeMax = 10,
InitialAttributePoints = 40,
InitialSetupMaxLevel = 1,
AttributePointsOnLevelUp = 0
};
var controller = new StatisticController(charProvider, statProvider, new GenericProgressionStrategy(statProvider, statOptions));
// Act
// Set initial special
await controller.SetStatisticAsync(100, "strength", 10);
await controller.SetStatisticAsync(100, "perception", 2);
await controller.SetStatisticAsync(100, "endurance", 6);
await controller.SetStatisticAsync(100, "charisma", 6);
await controller.SetStatisticAsync(100, "intelligence", 6);
await controller.SetStatisticAsync(100, "agility", 5);
await controller.SetStatisticAsync(100, "luck", 5);
character.Experience = 50000;
await charProvider.UpdateCharacterAsync(character);
// Attempt to set special lower than current value
var result = await controller.SetStatisticAsync(100, "strength", 4);
// Assert
Assert.Equal(Messages.INVALID_INPUT, result.Message);
}
public async Task <VmTotalStatistic> GetTotal(
ApplicationUser currentUser,
StatisticOptions options)
{
IQueryable <Goal> query = _dataContext.Goals;
try
{
query = _goalsRepository.GetPerformerGoals(query, options.UserIds);
query = _goalsRepository.GetGoalsForProjects(query, options.ProjectIds);
query = _goalsRepository.GetGoalsForPeriod(query, options.DateBegin, options.DateEnd);
}
catch (ArgumentException)
{
throw new HttpResponseException(BadRequest, "Wrong options");
}
var goalsArray = await query
.Select(g => new Goal
{
PerformerId = g.PerformerId,
ProjectId = g.ProjectId,
Project = g.Project,
State = g.State,
StateChangedDate = g.StateChangedDate,
ExpectedCompletedDate = g.ExpectedCompletedDate,
EstimatedPerformingHours = g.EstimatedPerformingHours,
ActualPerformingHours = g.ActualPerformingHours
})
.ToArrayAsync();
var usersGoals = goalsArray
.GroupBy(g => g.PerformerId)
.ToDictionary(g => g.Key, g => g.ToArray());
var result = new VmTotalStatistic
{
GoalCompletion = _goalCompletionStatisticService.GetGoalCompletion(usersGoals),
WorkloadByProjects = _workloadForProjectStatisticService.GetWorkloadByProject(usersGoals)
};
return(result);
}
public async Task GetStatisticForProject()
{
//Arrange
var options = new StatisticOptions
{
DateBegin = DateTime.Now - TimeSpan.FromDays(1),
DateEnd = DateTime.Now,
UserIds = new List <string> {
_testData.Users.First().Id
},
ProjectIds = new List <int> {
_testData.Projects.First().Id
}
};
//Act
var result = await _service.GetGoalCompletion(_currentUser, options);
//Assert
Assert.NotNull(result);
}
public async Task SetStatisticAsync_NotEnoughPoints_ReturnNotEnoughPoints()
{
// Arrange
int points = 1;
int luckScore = 2;
var charProvider = new MockCharacterProvider();
var statProvider = new MockStatisticProvider();
var statOptions = new StatisticOptions
{
InitialAttributeMax = 10,
InitialAttributePoints = points
};
var controller = new StatisticController(charProvider, statProvider, new GenericProgressionStrategy(statProvider, statOptions));
// Act
var result = await controller.SetStatisticAsync(1, "luck", 2);
// Assert
// TODO: update unit tests to match new result
Assert.Equal(GenericResult.Failure(
string.Format(Messages.STAT_NOT_ENOUGH_POINTS, luckScore, points)), result);
}
public async Task <VmWorkloadByProjectsStatistic> GetWorkloadByProject(
ApplicationUser currentUser,
StatisticOptions options)
{
IQueryable <Goal> query = _dataContext.Goals
.Include(g => g.Project);
try
{
query = _goalsRepository.GetPerformerGoals(query, options.UserIds);
query = _goalsRepository.GetGoalsForProjects(query, options.ProjectIds);
query = _goalsRepository.GetGoalsForPeriod(query, options.DateBegin, options.DateEnd);
}
catch (ArgumentException)
{
throw new HttpResponseException(BadRequest, "Wrong options");
}
var goalsArray = await query
.Select(g => new Goal
{
Project = new Project {
Name = g.Project.Name
},
PerformerId = g.PerformerId,
ProjectId = g.ProjectId,
EstimatedPerformingHours = g.EstimatedPerformingHours,
})
.ToArrayAsync();
var usersGoals = goalsArray
.GroupBy(g => g.PerformerId)
.ToDictionary(g => g.Key, g => g.ToArray());
return(GetWorkloadByProject(usersGoals));
}
public async Task SetStatisticAsync_TooManyAtMax_ReturnTooManyAtMax()
{
// Arrange
var charProvider = new MockCharacterProvider();
var statProvider = new MockStatisticProvider();
var statOptions = new StatisticOptions
{
InitialAttributeMax = 2,
InitialAttributePoints = 6,
InitialAttributesAtMax = 2
};
var controller = new StatisticController(charProvider, statProvider, new GenericProgressionStrategy(statProvider, statOptions));
// Act
await controller.SetStatisticAsync(1, "strength", 2);
await controller.SetStatisticAsync(1, "perception", 2);
var result = await controller.SetStatisticAsync(1, "endurance", 2);
// Assert
Assert.Equal(StatisticResult.TooManyAtMax(2), result);
}
public async Task <IDictionary <string, VmWorkloadByDaysStatistic> > GetWorkloadByDays(
ApplicationUser currentUser,
StatisticOptions options)
{
throw new System.NotImplementedException();
}
private async Task <VmProjectStatistic> GetStatistic(IQueryable <Goal> query, StatisticOptions options)
{
if (options != null)
{
query = query.Where(g => g.CreationDate >= options.DateBegin &&
g.CreationDate <= options.DateEnd);
}
var queryData = await query.ToArrayAsync();
var commonStatistic = queryData.GroupBy(g => g.State)
.Select(x => new
{
State = x.Key,
Count = x.Count()
})
.ToArray();
var byDayStatistic = queryData
.GroupBy(x => (x.StateChangedDate ?? x.CreationDate).Date)
.OrderBy(x => x.Key)
.Select(x => new
{
Date = x.Key,
Statistic = x.GroupBy(y => y.State).Select(y => new
{
State = y.Key,
Count = y.Count()
})
})
.ToArray();
var vm = new VmProjectStatistic
{
GoalsCountForState = new[]
{
commonStatistic.FirstOrDefault(s => s.State == GoalState.New)?.Count ?? 0,
commonStatistic.FirstOrDefault(s => s.State == GoalState.Perform)?.Count ?? 0,
commonStatistic.FirstOrDefault(s => s.State == GoalState.Delay)?.Count ?? 0,
commonStatistic.FirstOrDefault(s => s.State == GoalState.Testing)?.Count ?? 0,
commonStatistic.FirstOrDefault(s => s.State == GoalState.Succeed)?.Count ?? 0,
commonStatistic.FirstOrDefault(s => s.State == GoalState.Rejected)?.Count ?? 0
},
ByDateStatistics = byDayStatistic
.Select(x => new ByDateGoalStatistic(x.Date, new[]
{
x.Statistic.FirstOrDefault(s => s.State == GoalState.New)?.Count ?? 0,
x.Statistic.FirstOrDefault(s => s.State == GoalState.Perform)?.Count ?? 0,
x.Statistic.FirstOrDefault(s => s.State == GoalState.Delay)?.Count ?? 0,
x.Statistic.FirstOrDefault(s => s.State == GoalState.Testing)?.Count ?? 0,
x.Statistic.FirstOrDefault(s => s.State == GoalState.Succeed)?.Count ?? 0,
x.Statistic.FirstOrDefault(s => s.State == GoalState.Rejected)?.Count ?? 0
}))
.ToArray()
};
return(vm);
}
public NewVegasProgressionStrategy(IStatisticProvider statProvider, StatisticOptions statOptions) : base(statProvider, statOptions)
{
_statOptions = statOptions;
_statProvider = statProvider;
}
public async Task <VmGoalCompletionStatistic> GetGoalCompletion([FromBody] StatisticOptions options)
{
var currentUser = await _currentUserService.GetCurrentUser(User);
return(await _goalCompletionStatisticService.GetGoalCompletion(currentUser, options));
}
public async Task <VmWorkloadByProjectsStatistic> GetWorkloadByProject([FromBody] StatisticOptions options)
{
var currentUser = await _currentUserService.GetCurrentUser(User);
return(await _projectWorkloadStatisticService.GetWorkloadByProject(currentUser, options));
}
public async Task <IDictionary <string, VmWorkloadByDaysStatistic> > GetWorkloadByDays([FromBody] StatisticOptions options)
{
var currentUser = await _currentUserService.GetCurrentUser(User);
return(await _daysWorkloadStatisticService.GetWorkloadByDays(currentUser, options));
}
public async Task <VmTotalStatistic> GetTotal([FromBody] StatisticOptions options)
{
var currentUser = await _currentUserService.GetCurrentUser(User);
return(await _totalStatisticService.GetTotal(currentUser, options));
}
public GenericProgressionStrategy(IStatisticProvider statProvider, StatisticOptions statOptions)
{
_statProvider = statProvider;
_statOptions = statOptions;
}
