public async void GoalEditPostForOrgAdminWithIncorrectIdInModelStateReturnsBadRequest()
{
const int campaignId = 123;
const int goalId = 456;
// Arrange
var mockMediator = new Mock <IMediator>();
mockMediator.Setup(mock => mock.SendAsync(It.IsAny <GoalEditQuery>()))
.ReturnsAsync(new GoalEditViewModel
{
Id = goalId,
CampaignId = campaignId,
OrganizationId = OrgAdminOrgId
})
.Verifiable();
var goalController = new GoalController(mockMediator.Object);
var mockContext = MockControllerContextWithUser(OrgAdmin(OrgAdminOrgId));
goalController.ControllerContext = mockContext.Object;
var vm = new GoalEditViewModel {
Id = goalId, GoalType = GoalType.Text, TextualGoal = "Aim to please"
};
// Act
var result = await goalController.Edit(987, vm);
// Assert
Assert.IsType <BadRequestResult>(result);
}
public async void TestGoalCreateForSiteAdmin()
{
const int campaignId = 123;
// Arrange
var mockMediator = new Mock <IMediator>();
mockMediator.Setup(mock => mock.SendAsync(It.IsAny <CampaignSummaryQuery>()))
.ReturnsAsync(new CampaignSummaryViewModel {
Id = campaignId, OrganizationId = OrgAdminOrgId
})
.Verifiable();
var goalController = new GoalController(mockMediator.Object);
var mockContext = MockControllerContextWithUser(SiteAdmin());
goalController.ControllerContext = mockContext.Object;
// Act
var result = await goalController.Create(campaignId) as ViewResult;
// Assert
Assert.NotNull(result);
Assert.Equal("Edit", result.ViewName);
var vm = result.ViewData.Model as GoalEditViewModel;
Assert.NotNull(vm);
Assert.Equal(campaignId, vm.CampaignId);
Assert.Equal(OrgAdminOrgId, vm.OrganizationId);
}
public void OnTriggerEnter(Collider other)
{
if (other.tag == "Goal")
{
GoalController goal = other.GetComponent <GoalController>();
if (!goal.IsSunk)
{
goal.Trigger();
// If we're still holding onto the ball, we get the sink, but we don't want to kill it.
if (isThrown)
{
Destroy(rigidBody);
Destroy(GetComponent <Collider>());
transform.position = goal.transform.position;
fallSpeed = 0;
isSunk = true;
BallSunkEvent(distanceTravelled);
}
else
{
BallSunkEvent(distanceTravelled, false);
}
}
}
if (other.tag == "BlackHole")
{
GameObject.Destroy(gameObject);
}
}
public void Setup()
{
var config = new HttpConfiguration();
config.Routes.MapHttpRoute(
name: "Default",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional });
_request = new HttpRequestMessage(HttpMethod.Get, "http://localhost");
_request.Properties[HttpPropertyKeys.HttpConfigurationKey] = config;
_request.Properties[HttpPropertyKeys.HttpRouteDataKey] = new HttpRouteData(new HttpRoute());
_mockContainer = new Data.Mocks.MockContainer();
_teamRepo = new Data.TeamRepo(_mockContainer);
_goalRepo = new Data.GoalRepo(_mockContainer);
_dimensionRepo = new Data.DimensionRepo(_mockContainer);
var identity = new System.Security.Principal.GenericIdentity("*****@*****.**");
var princpal = new System.Security.Principal.GenericPrincipal(identity, new string[] { });
_controller = new GoalController(_goalRepo, _teamRepo, _dimensionRepo);
_controller.User = princpal;
_controller.Request = _request;
}
public async void TestGoalDeleteConfirmedSiteAdminRedirectToAction()
{
const int campaignId = 123;
const int goalId = 567;
// Arrange
var mockMediator = new Mock <IMediator>();
mockMediator.Setup(mock => mock.SendAsync(It.IsAny <GoalDeleteQuery>()))
.ReturnsAsync(new GoalDeleteViewModel
{
Id = goalId,
OwningOrganizationId = OrgAdminOrgId,
CampaignId = campaignId
})
.Verifiable();
var goalController = new GoalController(mockMediator.Object);
var mockContext = MockControllerContextWithUser(SiteAdmin());
goalController.ControllerContext = mockContext.Object;
// Act
var result = await goalController.DeleteConfirmed(goalId) as RedirectToActionResult;
// Assert
Assert.NotNull(result);
Assert.Equal("Details", result.ActionName);
Assert.Equal("Campaign", result.ControllerName);
Assert.Equal(AreaNames.Admin, result.RouteValues["area"]);
Assert.Equal(campaignId, result.RouteValues["id"]);
mockMediator.Verify(mock => mock.SendAsync(It.IsAny <GoalDeleteCommand>()), Times.Once);
}
void Awake()
{
centerBlock = null;
scoreLabel = GameObject.FindGameObjectWithTag (Tags.score).GetComponent<TextMesh> ();
timeLabel = GameObject.FindGameObjectWithTag (Tags.time).GetComponent<TextMesh> ();
goalController = GameObject.FindGameObjectWithTag (Tags.gameController).GetComponent<GoalController> ();
}
public async Task Test_UpsertGoalsController_Success()
{
_goalServices.Setup(g => g.UpsertGoalsService(It.IsAny <List <GoalModel> >()))
.Returns(Task.CompletedTask);
var controller = new GoalController(_goalServices.Object);
var response = await controller.UpsertGoals(new UpsertGoalsRequest()
{
UpsertGoals = new List <UpsertGoal>()
{
new UpsertGoal()
{
Id = 5,
UserId = 5,
GoalAmount = 50,
TargetAmount = 500,
GoalName = "Goal Name",
GoalSummary = "Goal Summary",
StartDate = DateTime.Now,
EndDate = DateTime.Now
}
}
});
Assert.NotNull(response);
Assert.AreEqual(200, ((OkResult)response).StatusCode);
}
public async void TestGoalDeleteSiteAdminDisplaysConfirmationPage()
{
const int goalId = 567;
// Arrange
var mockMediator = new Mock <IMediator>();
mockMediator.Setup(mock => mock.SendAsync(It.IsAny <GoalDeleteQuery>()))
.ReturnsAsync(new GoalDeleteViewModel
{
Id = goalId,
OwningOrganizationId = OrgAdminOrgId,
TextualGoal = "This goal should be deleted",
GoalType = GoalType.Numeric,
NumericGoal = 100
})
.Verifiable();
var goalController = new GoalController(mockMediator.Object);
var mockContext = MockControllerContextWithUser(SiteAdmin());
goalController.ControllerContext = mockContext.Object;
// Act
var result = await goalController.Delete(goalId) as ViewResult;
// Assert
Assert.NotNull(result);
Assert.Equal("Delete", result.ViewName);
var goalDeleteViewModel = (GoalDeleteViewModel)result.ViewData.Model;
Assert.Equal("This goal should be deleted", goalDeleteViewModel.TextualGoal);
Assert.Equal(GoalType.Numeric, goalDeleteViewModel.GoalType);
Assert.Equal(100, goalDeleteViewModel.NumericGoal);
}
public async void GoalCreatePostForOrgAdminWithValidModelStateReturnsRedirectToAction()
{
const int campaignId = 123;
// Arrange
var mockMediator = new Mock <IMediator>();
mockMediator.Setup(mock => mock.SendAsync(It.IsAny <CampaignSummaryQuery>()))
.ReturnsAsync(new CampaignSummaryViewModel {
Id = campaignId, OrganizationId = OrgAdminOrgId
})
.Verifiable();
var goalController = new GoalController(mockMediator.Object);
var mockContext = MockControllerContextWithUser(OrgAdmin(OrgAdminOrgId));
goalController.ControllerContext = mockContext.Object;
var vm = new GoalEditViewModel {
GoalType = GoalType.Text, TextualGoal = "Aim to please"
};
// Act
var result = await goalController.Create(campaignId, vm) as RedirectToActionResult;
// Assert
Assert.NotNull(result);
Assert.Equal("Details", result.ActionName);
Assert.Equal("Campaign", result.ControllerName);
Assert.Equal(AreaNames.Admin, result.RouteValues["area"]);
Assert.Equal(campaignId, result.RouteValues["id"]);
mockMediator.Verify(mock => mock.SendAsync(It.IsAny <GoalEditCommand>()), Times.Once);
}
void SpawnGoals()
{
Vector3 leftGoalWorldPos = GetTileBottomLeftPos(goalSpawnLocations[0].x, goalSpawnLocations[0].y);
Vector3 rightGoalWorldPos = GetTileBottomLeftPos(goalSpawnLocations[1].x, goalSpawnLocations[1].y);
Transform leftGoal = Instantiate(goalPrefab, leftGoalWorldPos, Quaternion.identity, parentGameObject.transform);
Transform rightGoal = Instantiate(goalPrefab, rightGoalWorldPos, Quaternion.identity, parentGameObject.transform);
// Flip the right goal to it's facing the right way then shift it two along to put it back in the correct position
// (its position is normally its bottom left, but flipping it in the x axis makes its position its bottom right)
rightGoal.transform.localScale = new Vector3(rightGoal.transform.localScale.x * -1, 1, 1);
rightGoal.transform.position = new Vector3(rightGoal.transform.position.x + 2, rightGoal.transform.position.y, rightGoal.transform.position.z);
// Listen for goal events
GoalController leftGoalController = leftGoal.GetComponent <GoalController>();
if (leftGoalController == null)
{
Debug.LogError("Unable to find goal controller on left goal game object");
}
leftGoalController.OnGoalEvent += HandleGoalEvent;
GoalController rightGoalController = rightGoal.GetComponent <GoalController>();
if (rightGoalController == null)
{
Debug.LogError("Unable to find goal controller on right goal game object");
}
rightGoalController.OnGoalEvent += HandleGoalEvent;
goals[0] = leftGoal;
goals[1] = rightGoal;
}
private void spawnGoal()
{
// TODO: We want to grab the component every time? Is that slow?
var sphereCollider = goalPrefab.GetComponent <SphereCollider>();
float radius = sphereCollider.radius * sphereCollider.transform.lossyScale.x;
bool goalCreated = false;
int maxAttempts = 50;
int attemptsMade = 0;
while (!goalCreated && attemptsMade < maxAttempts)
{
float distance = UnityEngine.Random.Range(blackHoleRadius + MinGoalDistance, blackHoleRadius + MaxGoalDistance);
Vector3 goalPosition = UnityEngine.Random.onUnitSphere * distance;
if (!Physics.CheckSphere(goalPosition, radius))
{
GoalController goal = GameObject.Instantiate(goalPrefab).GetComponent <GoalController>();
goal.transform.position = goalPosition;
goal.gameObject.SetActive(true);
goalCreated = true;
numGoals++;
GoalCreatedEvent(goal);
return;
}
attemptsMade++;
}
throw new Exception("Failed all attempts to spawn a goal.");
}
protected void SetUpPage()
{
SetContentView(Resource.Layout.CommonLayout);
#region Controller instantiations
/*
* The UserController shouldn't have to be instantiated here, since that would mean that we would lose
* the currently logged in user. Thus, it should always be in the intent coming into this activity.
*/
userController = JsonConvert.DeserializeObject <UserController>(Intent.GetStringExtra("UserController"), SerializationBinderHelper.Settings);
try {
goalController = JsonConvert.DeserializeObject <GoalController>(Intent.GetStringExtra("GoalController"), SerializationBinderHelper.Settings);
} catch (ArgumentNullException) {
goalController = new GoalController();
}
try {
noteController = JsonConvert.DeserializeObject <NoteController>(Intent.GetStringExtra("NoteController"));
} catch (ArgumentNullException) { noteController = new NoteController(); }
try {
fileController = JsonConvert.DeserializeObject <FileController>(Intent.GetStringExtra("FileController"));
} catch (ArgumentNullException) {
fileController = new FileController();
}
try {
calendarController = JsonConvert.DeserializeObject <CalendarController>(Intent.GetStringExtra("CalendarController"));
} catch (ArgumentNullException) {
calendarController = new CalendarController();
}
#endregion
}
public async void TestGoalEditPostForWrongOrgAdminReturns401()
{
// Arrange
var mockMediator = new Mock <IMediator>();
mockMediator.Setup(mock => mock.SendAsync(It.IsAny <GoalEditQuery>()))
.ReturnsAsync(new GoalEditViewModel())
.Verifiable();
mockMediator.Setup(x => x.SendAsync(It.IsAny <AuthorizableCampaignQuery>())).ReturnsAsync(new FakeAuthorizableCampaign(false, false, false, false));
var goalController = new GoalController(mockMediator.Object);
var mockContext = MockControllerContextWithUser(OrgAdmin(654));
goalController.ControllerContext = mockContext.Object;
// Act
var result = await goalController.Edit(456, new GoalEditViewModel()
{
Id = 456
});
// Assert
Assert.IsType <UnauthorizedResult>(result);
}
public void ShouldRenderIndexViewCorrectly()
{
Mock <IGenericService <Goal> > goalServiceMock = new Mock <IGenericService <Goal> >();
Goal goal = new Goal()
{
Id = 100,
Bloom = "Understand",
Description = @"Je begrijpt de basismechanismen voor access control, zodanig dat je in eigen woorden kunt uitleggen wat de betekenis is in de context van software security. "
};
goalServiceMock.Setup(m => m.FindAll(It.IsAny <string[]>(), It.IsAny <int>(), It.IsAny <int>())).Returns(new List <Goal>()
{
goal,
new Goal()
{
Id = 101
},
new Goal()
{
Id = 102
},
});
GoalController controller = new GoalController(goalServiceMock.Object);
List <Goal> model = (controller.Index() as ViewResult)?.ViewData.Model as List <Goal>;
Assert.Equal(3, model.Count);
Assert.Equal(100, model[0].Id);
Assert.Equal(101, model[1].Id);
Assert.Equal("Understand", model[0].Bloom);
}
protected override void OnTrialStart()
{
TrialStartTime = Time.realtimeSinceStartup;
_currentGoal = GoalManager.Instance.GetGoal(TrialNumber);
_currentGoal.Show();
_currentGoal.OnEnter += GoalEntered;
_currentGoal.SetColor(Color.green);
}
void Start()
{
this.goal = GameObject.Find("Goal");
this.goalController = this.goal.GetComponent <GoalController>();
this.player = GameObject.Find("Player");
this.carHealth = player.GetComponent <CarHealth>();
this.carDistance = this.player.GetComponent <Distance>();
}
protected override void OnTrialStart()
{
TrialStartTime = Time.realtimeSinceStartup;
_currentGoal = GoalManager.Instance.GetGoal(TrialNumber);
_currentGoal.Show();
_currentGoal.OnEnter += GoalEntered;
_currentGoal.SetColor(Color.green);
_synchronizationLog.LogPupilTimestamp("TrialStart");
}
public TripsModel(IStorage storage)
{
_trips = new TripController(storage);
_photos = new PhotoController(storage);
_places = new PlaceController(storage);
_goals = new GoalController(storage);
_goods = new GoodController(storage);
_purchases = new PurchaseController(storage);
}
public void SetUp()
{
context = new MockDreamLeagueContext();
gameWeekSummaryService = new Mock <IGameWeekSummaryService>();
cupWeekSummaryService = new Mock <IGameWeekSummaryService>();
gameWeekService = new Mock <IGameWeekService>();
auditService = new Mock <IAuditService>();
controller = new GoalController(context.MockContext.Object, gameWeekSummaryService.Object, cupWeekSummaryService.Object, gameWeekService.Object, auditService.Object);
}
public async Task Test_GetGoalsController_Exception()
{
_goalServices.Setup(g => g.GetGoalsService(It.IsAny <long>()))
.ThrowsAsync(new Exception("Goals not found"));
var controller = new GoalController(_goalServices.Object);
var response = await controller.GetGoals(1);
Assert.NotNull(response);
Assert.AreEqual(500, ((ObjectResult)response).StatusCode);
}
public async Task Test_UpsertGoalsController_BadArgument()
{
_goalServices.Setup(g => g.UpsertGoalsService(It.IsAny <List <GoalModel> >()))
.Returns(Task.CompletedTask);
var controller = new GoalController(_goalServices.Object);
var response = await controller.UpsertGoals(null);
Assert.NotNull(response);
Assert.AreEqual(400, ((ObjectResult)response).StatusCode);
}
public async Task Test_GetGoalsController_BadArgument()
{
_goalServices.Setup(g => g.GetGoalsService(It.IsAny <long>()))
.ReturnsAsync(new List <GoalModel>());
var controller = new GoalController(_goalServices.Object);
var response = await controller.GetGoals(0);
Assert.NotNull(response);
Assert.AreEqual(400, ((ObjectResult)response).StatusCode);
}
private void SpawnEntities()
{
// TODO(Rok Kos): Test how many starts and how many ends are there
Level level = Levels.levels[levelIndex];
Square[] grid = level.board;
for (int y = 0; y < level.rows; ++y)
{
for (int x = 0; x < level.columns; ++x)
{
int index = GetGridIndex(level.columns, y, x);
switch (level.board[index])
{
case Square.kStart:
{
if (isMLTraining)
{
break;
}
_playerController = Instantiate(playerControllerPrefab,
new Vector3(x - 0.5f, -y + 0.5f, 0), Quaternion.identity, WorldParent.transform);
_playerController.onBurst += Burst;
_playerController.onPlayerDead += GameOver;
_playerController.onLevelClear += NextLevel;
break;
}
case Square.kEnd:
{
_goalController = Instantiate(goalControllerPrefab,
new Vector3(x - 0.5f, -y + 0.5f, 0), Quaternion.identity, WorldParent.transform);
_goalController.onBurst += Burst;
break;
}
case Square.kEnemy:
{
EnemyController enemyController = Instantiate(enemyControllerPrefab,
new Vector3(x - 0.5f, -y + 0.5f, 0), Quaternion.identity, WorldParent.transform);
enemyController.Init(_playerController);
enemyController.onBurst += Burst;
_enemyControllers.Add(enemyController);
break;
}
case Square.kEmtpy:
default:
continue;
}
}
}
}
// Use this for initialization
void Awake()
{
deathTrigger = GameObject.FindWithTag("DeathTrigger");
GameObject goalController = GameObject.FindWithTag("GoalController"); //create reference for Player gameobject, and assign the variable via FindWithTag at start
if (goalController != null) // if the playerObject gameObject-reference is not null - assigning the reference via FindWithTag at first frame -
{
goalControllerScript = goalController.GetComponent<GoalController>();// - set the PlayerController-reference (called playerControllerScript) to the <script component> of the Player gameobject (via the gameObject-reference) to have access the instance of the PlayerController script
}
if (goalController == null) //for exception handling - to have the console debug the absense of a player controller script in order for this entire code, the code in the GameController to work
{
Debug.Log("Cannot find Goal Controller script for Health End State in GameController");
}
}
private void Awake()
{
//Initiate singleton
if (Instance == null)
{
Instance = this;
DontDestroyOnLoad(gameObject);
}
else
{
Destroy(gameObject);
}
}
public void RpcInitialize(BarController myBar, GoalController myGoal, int playerId, PhotonTargets photonTargets = PhotonTargets.All)
{
int ballViewID = myBar.photonView.viewID;
int goalViewID = myGoal.photonView.viewID;
List <int> sendDatas = new List <int>();
sendDatas.Add(ballViewID);
sendDatas.Add(goalViewID);
sendDatas.Add(playerId);
photonView.RPC("LocalInitialize", photonTargets, sendDatas.ToArray());
}
private void CreateGoal()
{
Debug.Log("creating goal");
if (isFinalLevel)
{
GoalController finalGoal = Instantiate <GoalController>(finalGoalPrefab, goalLocation);
finalGoal.transform.localPosition = Vector3.up * 1.05f;
}
else
{
GoalController goal = Instantiate <GoalController>(goalPrefab, goalLocation);
goal.transform.localPosition = Vector3.up * .44f;
}
}
public async Task Delete_ShouldReturnNoContent(
Guid goalId,
GoalController sut)
{
// Arrange
sut.GoalService.DeleteAsync(Arg.Is(goalId)).Returns(true);
// Act
var result = await sut.Delete(goalId);
// Asserts
result.Should().NotBeNull();
result.Should().BeOfType <NoContentResult>();
await sut.GoalService.Received(1).DeleteAsync(Arg.Is(goalId));
}
public async Task Delete_WhenDeleteFails_ShouldReturnNotModified(
Guid goalId,
GoalController sut)
{
// Arrange
sut.GoalService.DeleteAsync(Arg.Is(goalId)).Returns(false);
// Act
var result = await sut.Delete(goalId);
// Asserts
result.Should().NotBeNull();
result.Should().BeOfType <StatusCodeResult>();
((StatusCodeResult)result).StatusCode.Should().Be(304);
await sut.GoalService.Received(1).DeleteAsync(Arg.Is(goalId));
}
public async Task GetById_WhenGoalNull_ShouldReturnNotFound(
Guid goalId,
GoalController sut)
{
// Arranges
sut.GoalService.GetAsync(Arg.Is(goalId)).ReturnsNull();
// Act
var result = await sut.GetById(goalId);
// Asserts
result.Should().NotBeNull();
result.Should().BeOfType <NotFoundResult>();
await sut.GoalService.Received(1).GetAsync(Arg.Is(goalId));
sut.GoalMapper.DidNotReceive().Map(Arg.Any <Goal>());
}
// Use this for initialization
void Start()
{
player = GameObject.FindGameObjectWithTag("Player").GetComponent <ShipController>();
goal = GameObject.Find("MainGoal").GetComponent <GoalController>();
popupWin = GameObject.Find("popupWin");
popupLose = GameObject.Find("popupLose");
popupWin.gameObject.SetActive(false);
popupLose.gameObject.SetActive(false);
thisSceneName = SceneManager.GetActiveScene().name;
thisLevel = Int32.Parse(thisSceneName.Substring(6));
audioSource = GetComponent <AudioSource>();
audioSource.clip = bgm;
audioSource.volume = 0.3f;
audioSource.Play();
}
public async Task Put_WhenInvalidModelState_ShouldReturnBadRequest(
GoalModel goalModel,
GoalController sut)
{
// Arranges
sut.ModelState.AddModelError("Error key", "Error message");
// Act
var result = await sut.Put(goalModel);
// Asserts
result.Should().BeOfType <BadRequestObjectResult>();
((BadRequestObjectResult)result).Value.Should()
.BeOfType <SerializableError>();
sut.GoalMapper.DidNotReceive().Map(Arg.Any <GoalModel>());
await sut.GoalService.DidNotReceive().UpdateAsync(Arg.Any <Goal>());
}
void Start()
{
instance = this;
currentTarget = targetLeft;
}
// Use this for initialization
void Start()
{
counted = false;
goal = (GoalController) FindObjectOfType(typeof(GoalController));
}
