public async Task CreateChallengeAsync_ShouldBeOfTypeValidationResultWithErrors()
{
// Arrange
TestMock.ChallengePayoutStrategy.Setup(payout => payout.GetChallengePayout(It.IsAny <ChallengePayoutEntries>(), It.IsAny <EntryFee>())).Verifiable();
TestMock.ChallengePayoutFactory.Setup(payout => payout.CreateInstance()).Returns(TestMock.ChallengePayoutStrategy.Object).Verifiable();
var service = new ChallengeService(TestMock.ChallengePayoutFactory.Object, TestMock.ChallengeRepository.Object);
var bucket = new ChallengePayoutBucket(ChallengePayoutBucketPrize.Consolation, ChallengePayoutBucketSize.Individual);
var buckets = new ChallengePayoutBuckets(
new List <ChallengePayoutBucket>
{
bucket
});
var payoutEntries = new ChallengePayoutEntries(buckets);
// Act
var result = await service.CreateChallengeAsync(new ChallengeId(), payoutEntries, new EntryFee(5000, CurrencyType.Token));
// Assert
result.Should().BeOfType <DomainValidationResult <IChallenge> >();
result.Errors.Should().NotBeEmpty();
TestMock.ChallengePayoutStrategy.Verify(payout => payout.GetChallengePayout(It.IsAny <ChallengePayoutEntries>(), It.IsAny <EntryFee>()), Times.Once);
TestMock.ChallengePayoutFactory.Verify(payout => payout.CreateInstance(), Times.Once);
}
public void Should_Be_Right_Challenges_When_Find_By_Accelartion_And_User(int accelerationId, int userId)
{
var fakeContext = new FakeContext("ChallengeByAccelerationAndUser");
fakeContext.FillWithAll();
using (var context = new CodenationContext(fakeContext.FakeOptions))
{
var expected = fakeContext.GetFakeData <User>().
Where(user => user.Id == userId).
Join(fakeContext.GetFakeData <Candidate>(),
user => user.Id,
candidate => candidate.UserId,
(user, candidate) => candidate).
Join(fakeContext.GetFakeData <Acceleration>(),
candidate => candidate.AccelerationId,
acceleration => acceleration.Id,
(candidate, acceleration) => acceleration).
Where(acceleration => acceleration.Id == accelerationId).
Join(fakeContext.GetFakeData <Models.Challenge>(),
acceleration => acceleration.ChallengeId,
challenge => challenge.Id,
(acceleration, challenge) => challenge).
Distinct().
ToList();
var service = new ChallengeService(context);
var actual = service.FindByAccelerationIdAndUserId(userId, accelerationId);
Assert.Equal(expected, actual, new ChallengeIdComparer());
}
}
private BoardCell[][] getBoardCellArrayFromServiceStates(ChallengeService.state?[][] stateBoard)
{
BoardCell[][] newBoard = new BoardCell[stateBoard.Length][];
for (int x = 0; x < stateBoard.Length; ++x)
{
newBoard[x] = new BoardCell[stateBoard[x].Length];
for (int y = 0; y < stateBoard[x].Length; ++y)
{
switch (stateBoard[x][y])
{
case null:
case ChallengeService.state.NONE:
case ChallengeService.state.EMPTY:
newBoard[x][y] = BoardCell.EMPTY;
break;
case ChallengeService.state.FULL:
newBoard[x][y] = BoardCell.WALL;
break;
case ChallengeService.state.OUT_OF_BOUNDS:
newBoard[x][y] = BoardCell.OUT_OF_BOUNDS;
break;
default:
newBoard[x][y] = BoardCell.OUT_OF_BOUNDS;
break;
}
}
}
return newBoard;
}
public async Task <Challenge> Create([FromBody] NewChallenge model)
{
AuthorizeAny(
() => Actor.IsDirector,
() => IsSelf(model.PlayerId).Result
);
await Validate(model);
if (Actor.IsTester.Equals(false))
{
model.Variant = 0;
}
string graderUrl = string.Format(
"{0}://{1}{2}",
Request.Scheme,
Request.Host,
Url.Action("Grade")
);
var result = await ChallengeService.GetOrAdd(model, Actor.Id, graderUrl);
await Hub.Clients.Group(result.TeamId).ChallengeEvent(
new HubEvent <Challenge>(result, EventAction.Updated)
);
return(result);
}
public async Task <ArchivedChallenge[]> ListArchived([FromQuery] SearchFilter model)
{
AuthorizeAny(
() => Actor.IsDirector
);
return(await ChallengeService.ListArchived(model));
}
public async Task <List <ObserveChallenge> > FindConsoles([FromQuery] string gid)
{
AuthorizeAny(
() => Actor.IsDirector,
() => Actor.IsObserver
);
return(await ChallengeService.GetChallengeConsoles(gid));
}
public ConsoleActor GetConsoleActor([FromQuery] string uid)
{
AuthorizeAny(
() => Actor.IsDirector,
() => Actor.IsObserver
);
return(ChallengeService.GetConsoleActor(uid));
}
public ChallengeServiceTest()
{
_contextoFake = new FakeContext("ChallengeService");
_contextoFake.FillWithAll();
_contexto = new CodenationContext(_contextoFake.FakeOptions);
_challengeService = new ChallengeService(_contexto);
}
public LookupController(ILogger <LookupController> logger,
ServiceFacade.Controller context,
ChallengeService challengeService,
TriggerService triggerService) : base(context)
{
_logger = Require.IsNotNull(logger, nameof(logger));
_challengeService = Require.IsNotNull(challengeService, nameof(challengeService));
_triggerService = Require.IsNotNull(triggerService, nameof(triggerService));
}
public async Task <SectionSubmission[]> Audit([FromRoute] string id)
{
AuthorizeAny(
() => Actor.IsDirector
);
await Validate(new Entity { Id = id });
return(await ChallengeService.Audit(id));
}
public async Task <Challenge> Preview([FromBody] NewChallenge model)
{
AuthorizeAny(
() => IsSelf(model.PlayerId).Result
);
await Validate(model);
return(await ChallengeService.Preview(model));
}
public LookupController(ILogger <LookupController> logger,
ServiceFacade.Controller context,
ChallengeService challengeService,
TriggerService triggerService) : base(context)
{
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_challengeService = challengeService
?? throw new ArgumentNullException(nameof(challengeService));
_triggerService = triggerService
?? throw new ArgumentNullException(nameof(triggerService));
}
public ChallengesController(ILogger <ChallengesController> logger,
ServiceFacade.Controller context,
ActivityService activityService,
ChallengeService challengeService) : base(context)
{
_logger = Require.IsNotNull(logger, nameof(logger));
_mapper = context.Mapper;
_activityService = Require.IsNotNull(activityService, nameof(activityService));
_challengeService = Require.IsNotNull(challengeService, nameof(challengeService));
PageTitle = "Challenges";
}
public async Task <Challenge> Retrieve([FromRoute] string id)
{
AuthorizeAny(
() => Actor.IsDirector,
() => ChallengeService.UserIsTeamPlayer(id, Actor.Id).Result
);
await Validate(new Entity { Id = id });
return(await ChallengeService.Retrieve(id));
}
public GameInProgress(ChallengeService.ChallengeClient service, ChallengeService.state?[][] board)
{
_service = service;
_board = getBoardCellArrayFromServiceStates(board);
updateGameStatus(true);
_board[[email protected]][[email protected]] = BoardCell.BASE;
_board[[email protected]][[email protected]] = BoardCell.BASE;
_tank1Ai = new AiAgent(_me.units[0].id, false);
_tank2Ai = new AiAgent(_me.units[1].id, true);
}
public async Task SetConsoleActor([FromBody] ConsoleRequest model)
{
await Validate(new Entity { Id = model.SessionId });
var isTeamMember = await ChallengeService.UserIsTeamPlayer(model.SessionId, Actor.Id);
if (isTeamMember)
{
ActorMap.Update(
await ChallengeService.SetConsoleActor(model, Actor.Id, Actor.ApprovedName)
);
}
}
public async Task Delete([FromRoute] string id)
{
AuthorizeAny(
() => Actor.IsDirector
// () => Actor.IsTester && ChallengeService.UserIsTeamPlayer(id, Actor.Id).Result
);
await Validate(new Entity { Id = id });
await ChallengeService.Delete(id);
return;
}
public ChallengesController(ILogger <ChallengesController> logger,
ServiceFacade.Controller context,
BadgeService badgeService,
ChallengeService challengeService,
SiteService siteService)
: base(context)
{
_logger = Require.IsNotNull(logger, nameof(logger));
_badgeService = Require.IsNotNull(badgeService, nameof(badgeService));
_challengeService = Require.IsNotNull(challengeService, nameof(challengeService));
_siteService = Require.IsNotNull(siteService, nameof(SiteService));
PageTitle = "Challenges";
}
public async Task <IActionResult> TotalJ()
{
try
{
var result = await ChallengeService.CalcAsync();
return(Ok(result));
}
catch (Exception exception)
{
return(BadRequest($"{exception.Message} - {exception.InnerException?.Message}"));
}
}
public FeedbackController(
ILogger <ChallengeController> logger,
IDistributedCache cache,
FeedbackValidator validator,
ChallengeService challengeService,
FeedbackService feedbackService,
PlayerService playerService
) : base(logger, cache, validator)
{
ChallengeService = challengeService;
FeedbackService = feedbackService;
PlayerService = playerService;
}
public async Task <ContentResult> Total()
{
try
{
var result = await ChallengeService.CalcAsync();
return(Content(result.ToString()));
}
catch (Exception exception)
{
return(Content($"{exception.Message} - {exception.InnerException?.Message}"));
}
}
public void Should_Add_New_Challenge_When_Save()
{
var fakeContext = new FakeContext("SaveNewChallenge");
var fakeChallenge = fakeContext.GetFakeData <Models.Challenge>().First();
fakeChallenge.Id = 0;
using (var context = new CodenationContext(fakeContext.FakeOptions))
{
var service = new ChallengeService(context);
var actual = service.Save(fakeChallenge);
Assert.NotEqual(0, actual.Id);
}
}
public Activity(ILogger <Activity> logger,
ConfigureUserSite configureUserSite,
TriggerService triggerService,
ChallengeService challengeService,
UserService userService)
{
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_configureUserSite = configureUserSite
?? throw new ArgumentNullException(nameof(configureUserSite));
_triggerService = triggerService
?? throw new ArgumentNullException(nameof(triggerService));
_userService = userService ?? throw new ArgumentNullException(nameof(userService));
_challengeService = challengeService
?? throw new ArgumentNullException(nameof(challengeService));
}
public ChallengeController(
ILogger <ChallengeController> logger,
IDistributedCache cache,
ChallengeValidator validator,
ChallengeService challengeService,
PlayerService playerService,
IHubContext <AppHub, IAppHubEvent> hub,
ConsoleActorMap actormap
) : base(logger, cache, validator)
{
ChallengeService = challengeService;
PlayerService = playerService;
Hub = hub;
ActorMap = actormap;
}
public async Task <Challenge> Regrade([FromBody] Entity model)
{
AuthorizeAny(
() => Actor.IsDirector
);
await Validate(model);
var result = await ChallengeService.Regrade(model.Id);
await Hub.Clients.Group(result.TeamId).ChallengeEvent(
new HubEvent <Challenge>(result, EventAction.Updated)
);
return(result);
}
public async Task <Challenge> StopGamespace([FromBody] ChangedChallenge model)
{
AuthorizeAny(
() => Actor.IsDirector,
() => ChallengeService.UserIsTeamPlayer(model.Id, Actor.Id).Result
);
await Validate(new Entity { Id = model.Id });
var result = await ChallengeService.StopGamespace(model.Id, Actor.Id);
await Hub.Clients.Group(result.TeamId).ChallengeEvent(
new HubEvent <Challenge>(result, EventAction.Updated)
);
return(result);
}
public async Task FindChallengeAsync_ShouldBeOfTypeChallenge()
{
// Arrange
var challenge = TestData.FakerFactory.CreateChallengeFaker(1000).FakeChallenge();
TestMock.ChallengeRepository.Setup(repository => repository.FindChallengeOrNullAsync(It.IsAny <ChallengeId>())).ReturnsAsync(challenge).Verifiable();
var service = new ChallengeService(TestMock.ChallengePayoutFactory.Object, TestMock.ChallengeRepository.Object);
// Act
var result = await service.FindChallengeOrNullAsync(new ChallengeId());
// Assert
result.Should().BeOfType <Challenge>();
TestMock.ChallengeRepository.Verify(repository => repository.FindChallengeOrNullAsync(It.IsAny <ChallengeId>()), Times.Once);
}
public ChallengesController(ILogger <ChallengesController> logger,
ServiceFacade.Controller context,
ActivityService activityService,
CategoryService categoryService,
ChallengeService challengeService,
SiteService siteService) : base(context)
{
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_mapper = context.Mapper;
_activityService = activityService
?? throw new ArgumentNullException(nameof(activityService));
_categoryService = categoryService
?? throw new ArgumentNullException(nameof(categoryService));
_challengeService = challengeService
?? throw new ArgumentNullException(nameof(challengeService));
_siteService = siteService ?? throw new ArgumentNullException(nameof(siteService));
PageTitle = _sharedLocalizer[Annotations.Title.Challenges];
}
public async Task <Challenge> Grade([FromBody] SectionSubmission model)
{
AuthorizeAny(
() => Actor.IsDirector,
() => Actor.Id == model.Id, // auto-grader
() => ChallengeService.UserIsTeamPlayer(model.Id, Actor.Id).Result
);
await Validate(new Entity { Id = model.Id });
var result = await ChallengeService.Grade(model, Actor.Id);
await Hub.Clients.Group(result.TeamId).ChallengeEvent(
new HubEvent <Challenge>(result, EventAction.Updated)
);
return(result);
}
protected override async Task OnInitializedAsync()
{
try
{
_challengesResult = await ChallengeService.GetAllChallengesAsync(EventId);
if (_challengesResult != null)
{
await JSRuntime.InvokeVoidAsync("ClockFunctions.startTime", "timerDiv", _challengesResult.Event.EndDateTime);
}
_currentChallenge = _challengesResult.Challenges.FirstOrDefault();
}
catch (AccessTokenNotAvailableException exception)
{
exception.Redirect();
}
}
public void Should_Add_New_Challenge_When_Save()
{
var fakeContext = new FakeContext("SaveNewChallenge");
var fakeChallenge = new Models.Challenge
{
Name = "full name",
Slug = "pass",
CreatedAt = DateTime.Today
};
using (var context = new CodenationContext(fakeContext.FakeOptions))
{
var service = new ChallengeService(context);
var actual = service.Save(fakeChallenge);
Assert.NotEqual(0, actual.Id);
}
}
public void Should_Add_New_Challenge_When_Save()
{
var fakeContext = new FakeContext("SaveNewChallenge");
var fakeChallenge = new Models.Challenge();
fakeChallenge.Name = "name";
fakeChallenge.Slug = "slug";
fakeChallenge.CreatedAt = DateTime.Today;
using (var context = new CodenationContext(fakeContext.FakeOptions))
{
var service = new ChallengeService(context);
var actual = service.Save(fakeChallenge);
Assert.NotEqual(0, actual.Id);
Assert.Equal(fakeChallenge.Name, actual.Name);
Assert.Equal(fakeChallenge.Slug, actual.Slug);
Assert.Equal(fakeChallenge.CreatedAt, actual.CreatedAt);
}
}
private bool checkIsBulletInAir(BoardCell[][] board, ChallengeService.player me, ChallengeService.unit tank)
{
var bulletInAir = false;
if (me.bullets != null)
{
foreach (var bullet in me.bullets)
{
if (Math.Abs(bullet.x - tank.x) < board.Length / 6)
{
bulletInAir = true;
}
}
}
return bulletInAir;
}
private bool testPathToMiddleIsOpen(BoardCell[][] board, ChallengeService.unit tank, ChallengeService.@base enemyBase)
{
var minY = tank.y - 2;
var maxY = tank.y + 2;
var minX = Math.Min(tank.x, enemyBase.x)-2;
var maxX = Math.Max(tank.x, enemyBase.x)+2;
bool insideRange = board.Length > maxX && board[maxX].Length > maxY && 0 <= minX && 0 <= minY;
if (!insideRange)
{
return false;
}
for (int x = minX; x <= maxX; ++x)
{
for (int y = minY; y <= maxY; ++y)
{
if (board[x][y] != BoardCell.EMPTY)
{
return false;
}
}
}
return true;
}
public Move GetBestMove(ChallengeService.game game, BoardCell[][] board, ChallengeService.player me, ChallengeService.player enemy)
{
Move move = null;
ChallengeService.unit tank = findTankInPlayer(_tankId, me);
if (tank == null)
{
return null;
}
if (tank.x != _lastX || tank.y != _lastY)
{
_hasShotFromLastPosition = false;
}
var bulletInAir = checkIsBulletInAir(board, me, tank);
var stuckLastTurn = checkStuckLastTurn(tank);
var enemyBase = enemy.@base;
var pastMidpoint = (Math.Abs(enemyBase.y-tank.y) < (board[0].Length / 2));
if (stuckLastTurn && (tank.direction == ChallengeService.direction.UP || tank.direction == ChallengeService.direction.DOWN) && enemyBase.x != tank.x)
{
_targetX = tank.x + (pastMidpoint!=(tank.x > enemyBase.x) ? +1 : -1);
}
if (_checkForOpenPathToMiddle && !_headingToMiddle && tank.x != enemyBase.x)
{
_headingToMiddle = testPathToMiddleIsOpen(board, tank, enemyBase);
}
else if (_checkForOpenPathToMiddle && _headingToMiddle && tank.x == enemyBase.x)
{
_headingToMiddle = false;
}
ChallengeService.direction chosenDirection =
_headingToMiddle ?
(
tank.x > enemyBase.x ?
ChallengeService.direction.LEFT :
ChallengeService.direction.RIGHT
) :
(
tank.y != enemyBase.y ?
(
_targetX.HasValue && _targetX != tank.x ?
(
tank.x > _targetX ?
ChallengeService.direction.LEFT :
ChallengeService.direction.RIGHT
) :
(
tank.y > enemyBase.y ?
ChallengeService.direction.UP :
ChallengeService.direction.DOWN
)
) :
(
tank.x > enemyBase.x ?
ChallengeService.direction.LEFT :
ChallengeService.direction.RIGHT
)
);
if (chosenDirection != tank.direction || bulletInAir || _headingToMiddle)
{
move = MoveInDirection(tank.id, chosenDirection);
}
else
{
move = new Move(tank.id, ChallengeService.action.FIRE);
_hasShotFromLastPosition = true;
}
_lastX = tank.x;
_lastY = tank.y;
_lastAction = move.Action;
return move;
}
public Move MoveInDirection(int tankId, ChallengeService.direction direction)
{
switch (direction)
{
case ChallengeService.direction.UP:
return new Move(tankId, ChallengeService.action.UP);
case ChallengeService.direction.DOWN:
return new Move(tankId, ChallengeService.action.DOWN);
case ChallengeService.direction.LEFT:
return new Move(tankId, ChallengeService.action.LEFT);
case ChallengeService.direction.RIGHT:
return new Move(tankId, ChallengeService.action.RIGHT);
default:
return new Move(tankId, ChallengeService.action.NONE);
}
}
private ChallengeService.unit findTankInPlayer(int tankId, ChallengeService.player me)
{
if (me != null && me.units != null)
{
foreach (var unit in me.units)
{
if (unit.id == _tankId)
{
return unit;
}
}
}
return null;
}
public Move(int tank, ChallengeService.action action)
{
Tank = tank;
Action = action;
}
private bool checkStuckLastTurn(ChallengeService.unit tank)
{
return !(_lastAction == ChallengeService.action.FIRE || _lastAction == ChallengeService.action.NONE)
&& tank.x == _lastX && tank.y == _lastY
&& _hasShotFromLastPosition;
}
