public async Task PostResults_ReturnsViewResultAgain_WhenModelStateIsInvalid()
{
// Arrange
var mockUserManager = new FakeUserManager();
var mockLoggerFactory = new Mock <ILoggerFactory>();
var mockLogger = new Mock <ILogger>();
mockLoggerFactory.Setup(f => f.CreateLogger(It.IsAny <string>()))
.Returns(mockLogger.Object);
var mockMapper = new Mock <IMapper>();
var mockChallengeService = new Mock <IChallengeService>();
var challengeResultViewModel = new ChallengeResultViewModel();
var challengeController = new ChallengeController(
mockUserManager,
mockLoggerFactory.Object,
mockMapper.Object,
mockChallengeService.Object
);
challengeController.ModelState.AddModelError("", "");
// Act
var result = await challengeController.PostResults(challengeResultViewModel) as ViewResult;
// Assert
Assert.IsType <ViewResult>(result);
var model = Assert.IsType <ChallengeResultViewModel>(result.Model);
Assert.Equal(false, result.ViewData.ModelState.IsValid);
}
// Use this for initialization
void Start()
{
myRigidbody = transform.GetComponent <Rigidbody2D>();
posX = transform.position.x;
myChallengeController = GameObject.FindObjectOfType <ChallengeController>();
myGameController = GameObject.FindObjectOfType <GameControl>();
}
public async Task ShareResult_ReturnsStatusCode500_IfChallengeNotExists()
{
// Arrange
var mockUserManager = new FakeUserManager();
var mockLoggerFactory = new Mock <ILoggerFactory>();
var mockLogger = new Mock <ILogger>();
mockLoggerFactory.Setup(f => f.CreateLogger(It.IsAny <string>()))
.Returns(mockLogger.Object);
var mockMapper = new Mock <IMapper>();
var mockChallengeService = new Mock <IChallengeService>();
mockChallengeService.Setup(c => c.GetChallengeAsync(It.IsAny <int>()))
.ReturnsAsync((ChallengeDto)null) // Challenge does not exist
.Verifiable();
var challengeController = new ChallengeController(
mockUserManager,
mockLoggerFactory.Object,
mockMapper.Object,
mockChallengeService.Object
);
// Act
var result = await challengeController.ShareResult(It.IsAny <int>()) as StatusCodeResult;
// Assert
Assert.IsType <StatusCodeResult>(result);
Assert.Equal(500, result.StatusCode);
}
public async Task Challenges_ReturnsStatusCode500_WhenEmpty()
{
// Arrange
var mockUserManager = new FakeUserManager();
var mockLoggerFactory = new Mock <ILoggerFactory>();
var mockLogger = new Mock <ILogger>();
mockLoggerFactory.Setup(f => f.CreateLogger(It.IsAny <string>()))
.Returns(mockLogger.Object);
var mockMapper = new Mock <IMapper>();
var mockChallengeService = new Mock <IChallengeService>();
var challengeController = new ChallengeController(
mockUserManager,
mockLoggerFactory.Object,
mockMapper.Object,
mockChallengeService.Object
);
// Act
var result = await challengeController.Challenges() as StatusCodeResult;
// Assert
Assert.IsType <StatusCodeResult>(result);
Assert.Equal(500, result.StatusCode);
}
public async Task DeleteChallenge_ReturnsStatusCode500_IfChallengeNotDeleted()
{
// Arrange
var mockUserManager = new FakeUserManager();
var mockLoggerFactory = new Mock <ILoggerFactory>();
var mockLogger = new Mock <ILogger>();
mockLoggerFactory.Setup(f => f.CreateLogger(It.IsAny <string>()))
.Returns(mockLogger.Object);
var mockMapper = new Mock <IMapper>();
var mockChallengeService = new Mock <IChallengeService>();
mockChallengeService.Setup(c => c.DeleteChallengeAsync(It.IsAny <int>(), It.IsAny <int>()))
.ReturnsAsync(false) // Delete challenge error
.Verifiable();
var challengeController = new ChallengeController(
mockUserManager,
mockLoggerFactory.Object,
mockMapper.Object,
mockChallengeService.Object
);
// Act
var result = await challengeController.DeleteChallenge(It.IsAny <int>()) as StatusCodeResult;
// Assert
Assert.IsType <StatusCodeResult>(result);
Assert.Equal(500, result.StatusCode);
}
public async Task ShareResult_ReturnsViewResultWithModel_IfChallengeExists()
{
// Arrange
var mockUserManager = new FakeUserManager();
var mockLoggerFactory = new Mock <ILoggerFactory>();
var mockLogger = new Mock <ILogger>();
mockLoggerFactory.Setup(f => f.CreateLogger(It.IsAny <string>()))
.Returns(mockLogger.Object);
var mockMapper = new Mock <IMapper>();
mockMapper.Setup(m => m.Map <ShareChallengeViewModel>(It.IsAny <ChallengeDto>()))
.Returns(new ShareChallengeViewModel())
.Verifiable();
var mockChallengeService = new Mock <IChallengeService>();
mockChallengeService.Setup(c => c.GetChallengeAsync(It.IsAny <int>()))
.ReturnsAsync(new ChallengeDto()) // Challenge exists
.Verifiable();
var challengeController = new ChallengeController(
mockUserManager,
mockLoggerFactory.Object,
mockMapper.Object,
mockChallengeService.Object
);
// Act
var result = await challengeController.ShareResult(It.IsAny <int>()) as ViewResult;
// Assert
Assert.IsType <ViewResult>(result);
var model = Assert.IsType <ShareChallengeViewModel>(result.Model);
// Assert.Equal(0, model.Reps); // TODO assert on all properties
}
public async Task PostResults_ReturnsStatusCode500_WhenServiceError()
{
// Arrange
var mockUserManager = new FakeUserManager();
var mockLoggerFactory = new Mock <ILoggerFactory>();
var mockLogger = new Mock <ILogger>();
mockLoggerFactory.Setup(f => f.CreateLogger(It.IsAny <string>()))
.Returns(mockLogger.Object);
var mockMapper = new Mock <IMapper>();
var mockChallengeService = new Mock <IChallengeService>();
mockChallengeService.Setup(c => c.SetResultAsync(It.IsAny <ChallengeResultDto>()))
.ReturnsAsync(false)
.Verifiable();
var challengeResultViewModel = new ChallengeResultViewModel();
var challengeController = new ChallengeController(
mockUserManager,
mockLoggerFactory.Object,
mockMapper.Object,
mockChallengeService.Object
);
// Act
var result = await challengeController.PostResults(challengeResultViewModel) as StatusCodeResult;
// Assert
Assert.IsType <StatusCodeResult>(result);
Assert.Equal(500, result.StatusCode);
}
public async Task DeleteChallenge_ReturnsRedirectAction_IfChallengeDeleted()
{
// Arrange
var mockUserManager = new FakeUserManager();
var mockLoggerFactory = new Mock <ILoggerFactory>();
var mockLogger = new Mock <ILogger>();
mockLoggerFactory.Setup(f => f.CreateLogger(It.IsAny <string>()))
.Returns(mockLogger.Object);
var mockMapper = new Mock <IMapper>();
var mockChallengeService = new Mock <IChallengeService>();
mockChallengeService.Setup(c => c.DeleteChallengeAsync(It.IsAny <int>(), It.IsAny <int>()))
.ReturnsAsync(true) // Delete challenge success
.Verifiable();
var challengeController = new ChallengeController(
mockUserManager,
mockLoggerFactory.Object,
mockMapper.Object,
mockChallengeService.Object
);
// Act
var result = await challengeController.DeleteChallenge(It.IsAny <int>()) as RedirectToActionResult;
// Assert
Assert.IsType <RedirectToActionResult>(result);
Assert.Equal("Challenges", result.ActionName);
}
public async Task PostResults_RedirectToAction_WhenDatabaseSuccess()
{
// Arrange
var mockUserManager = new FakeUserManager();
var mockLoggerFactory = new Mock <ILoggerFactory>();
var mockLogger = new Mock <ILogger>();
mockLoggerFactory.Setup(f => f.CreateLogger(It.IsAny <string>()))
.Returns(mockLogger.Object);
var mockMapper = new Mock <IMapper>();
mockMapper.Setup(m => m.Map <ChallengeResultDto>(It.IsAny <ChallengeResultViewModel>()))
.Returns(new ChallengeResultDto())
.Verifiable();
var mockChallengeService = new Mock <IChallengeService>();
mockChallengeService.Setup(c => c.SetResultAsync(It.IsAny <ChallengeResultDto>()))
.ReturnsAsync(true)
.Verifiable();
var challengeResultViewModel = new ChallengeResultViewModel();
var challengeController = new ChallengeController(
mockUserManager,
mockLoggerFactory.Object,
mockMapper.Object,
mockChallengeService.Object
);
// Act
var result = await challengeController.PostResults(challengeResultViewModel) as RedirectToActionResult;
// Assert
Assert.IsType <RedirectToActionResult>(result);
Assert.Equal("Challenges", result.ActionName);
}
public async Task GetAllChallenge()
{
try
{
// Arrange
ChallengeController controller = new ChallengeController();
controller.Request = new HttpRequestMessage();
controller.Request.Properties.Add(HttpPropertyKeys.HttpConfigurationKey, new HttpConfiguration());
// Act
ChallengeProvider _ChallengeProvider = new ChallengeProvider();
var testProducts = await _ChallengeProvider.GetAll() as List <Challenge>;
int testproduct = testProducts.Count;
// Act
var response = await controller.GetChallenges() as HttpResponseMessage;
ObjectContent objContent = response.Content as ObjectContent;
List <Challenge> picklistItem = objContent.Value as List <Challenge>;
int icount = picklistItem.Count;
var response1 = await controller.GetChallengesByCategoryClub(1, 5) as HttpResponseMessage;
ObjectContent objContent1 = response1.Content as ObjectContent;
List <Challenge> picklistItem1 = objContent1.Value as List <Challenge>;
// Assert
Assert.IsNotNull(response);
Assert.AreEqual(testproduct, icount);
}
catch (Exception ex)
{
throw ex;
}
}
public void PostChallenge()
{
try
{
// Arrange
ChallengeController controller = new ChallengeController();
controller.Request = new HttpRequestMessage();
controller.Request.Properties.Add(HttpPropertyKeys.HttpConfigurationKey, new HttpConfiguration());
Challenge objChallange = new Challenge()
{
Name = "TEST",
StartDate = DateTime.Today,
EndDate = DateTime.Now.AddDays(10),
Duration = 10,
ChallengeTypeId = 1,
ChallengeClubLevelId = 2,
IsOganizationLevel = true
};
// Act
var response = controller.PostChallenge(objChallange) as HttpResponseMessage;
// Assert
Assert.IsNotNull(response);
Assert.AreEqual(HttpStatusCode.Created, response.StatusCode);
Assert.IsNotNull(response.Content);
}
catch (Exception ex)
{
throw ex;
}
}
void Awake()
{
audioCont = FindObjectOfType <AudioController>();
abilityCont = FindObjectOfType <AbilityController>();
challengeCont = FindObjectOfType <ChallengeController>();
spawnCont = FindObjectOfType <SpawnController>();
UICont = FindObjectOfType <UIController>();
isFollowing = true;
fireParticles = GetComponentsInChildren <ParticleSystem>();
healthBarCont = FindObjectOfType <HealthBarController>();
float[] zeroDataFloat = new float[11];
for (int i = 0; i < zeroDataFloat.Length; i++)
{
zeroDataFloat[i] = 0;
}
damageTaken = zeroDataFloat;
gameCont = FindObjectOfType <GameController>();
life = defaultLife;
camera = FindObjectOfType <CameraController>();
transform.position = new Vector3(Camera.main.ScreenToWorldPoint(Input.mousePosition).x, Camera.main.ScreenToWorldPoint(Input.mousePosition).y, 0);
rig = GetComponent <Rigidbody2D>();
position = transform.position;
isMobileBuild = (Application.platform == RuntimePlatform.Android || Application.platform == RuntimePlatform.IPhonePlayer) ? true : false;
StartCoroutine(RestartPosition());
effect = Instantiate(abilityEffects[abilityCont.GetActiveAbility()], transform);
effect.transform.localPosition = Vector3.zero;
//audioSource = effect.GetComponentInChildren<AudioSource>();
comboCount = 0;
comboSum = 0;
}
public static ChallengeController getInstance()
{
if (!_Instance)
{
_Instance = new ChallengeController();
}
return(_Instance);
}
public void StartCloneControl(ChallengeController challenge)
{
UnityEngine.Assertions.Assert.IsNull(_currentChallenge);
UnityEngine.Assertions.Assert.IsFalse(_playerState.HasValue);
UnityEngine.Assertions.Assert.IsFalse(_oldGravity.HasValue);
_currentChallenge = challenge;
_playerState = new PlayerState(transform, _animator);
_interactableWatcher.enabled = false;
_oldGravity = Physics2D.gravity;
}
// Use this for initialization
void Start()
{
myRigidbody = transform.GetComponent <Rigidbody2D> ();
posX = transform.position.x;
myChallengeController = GameObject.FindObjectOfType <ChallengeController> ();
myGameController = GameObject.FindObjectOfType <GameController> ();
ls = GameObject.FindObjectOfType <LightSpawner> ();
myAudioSource = GameObject.FindObjectOfType <AudioSource> ();
anim = GetComponent <Animator> ();
}
private void Start()
{
myRigidbody = transform.GetComponent <Rigidbody2D>();
posX = transform.position.x;
isGameOver = false;
myChallengeController = GameObject.FindObjectOfType <ChallengeController>();
myGameController = GameObject.FindObjectOfType <GameController>();
myAudioPlayer = GameObject.FindObjectOfType <AudioSource>();
}
//public Animator anim;
void Start()
{
myRigidBody = transform.GetComponent <Rigidbody2D> ();
//posX = transform.position.x;
myChallengeController = GameObject.FindObjectOfType <ChallengeController> ();
myGameController = GameObject.FindObjectOfType <GameController>();
myAudioPlayer = GameObject.FindObjectOfType <AudioSource>();
//anim = GetComponent<Animator>();
//anim.SetBool ("grounded", isGrounded);
}
public ChallengeObj GetChallengeObj(ChallengeController chaController)
{
ChallengeObj obj = new ChallengeObj();
chaController.UpdateChallenge();
obj.NumberA = chaController.Number1;
obj.NumberB = chaController.Number2;
obj.Signal = "x";
obj.Result = Calculate(chaController.Number1, chaController.Number2);
return(obj);
}
public ChallengeObj GetChallengeObj(ChallengeController chaController)
{
ChallengeObj obj = new ChallengeObj();
chaController.UpdateChallenge();
obj.Signal = "-";
obj.Result = VerifyIfSubtractIsValid(chaController);
obj.NumberA = chaController.Number1;
obj.NumberB = chaController.Number2;
return(obj);
}
private int VerifyIfSubtractIsValid(ChallengeController chaController)
{
int res = chaController.Number1 - chaController.Number2;
while (VerifyIfResultsIsNegative(res))
{
chaController.UpdateChallenge();
res = chaController.Number1 - chaController.Number2;
}
return(Calculate(chaController.Number1, chaController.Number2));
}
public async Task TestAllPayloadAndReturnItemPost()
{
var controller = new ChallengeController();
// Arrange
string json = File.ReadAllText("InputJson/sample_request.json");
Payload input = JsonConvert.DeserializeObject <Payload>(json);
// Act
ActionResult <Response> actionResult = await controller.Post(input);
// Assert
Assert.IsType <ActionResult <Response> >(actionResult);
}
private ChallengeController m_challengeController; //闯关控制器
private void Start()
{
unMute.TransitionTo(0f);
m_challengeController = ChallengeController.Instance;
if (m_challengeController != null)
{
//订阅闯关控制器事件
m_challengeController.OnChallengeSucceed += FinishSnapShot;
m_challengeController.OnChallengeFailed += FinishSnapShot;
m_challengeController.OnChallengePaused += Mute;
m_challengeController.OnChallengeStart += UnMute;
}
}
public void StopCloneControl()
{
UnityEngine.Assertions.Assert.IsNotNull(_currentChallenge);
UnityEngine.Assertions.Assert.IsTrue(_playerState.HasValue);
UnityEngine.Assertions.Assert.IsTrue(_oldGravity.HasValue);
if (!_currentChallenge.Completed)
{
_playerState.Value.Apply(gameObject, _animator);
Physics2D.gravity = _oldGravity.Value;
}
_interactableWatcher.enabled = true;
_currentChallenge = null;
_playerState = null;
_oldGravity = null;
}
public void Should_Be_Ok_When_Find_By_Accelartion_And_User(int accelerationId, int userId)
{
var fakes = new Fakes();
var fakeService = fakes.FakeChallengeService().Object;
var expected = fakeService.FindByAccelerationIdAndUserId(accelerationId, userId).
Select(x => fakes.Mapper.Map <ChallengeDTO>(x)).
ToList();
var controller = new ChallengeController(fakeService, fakes.Mapper);
var result = controller.GetAll(accelerationId: accelerationId, userId: userId);
Assert.IsType <OkObjectResult>(result.Result);
var actual = (result.Result as OkObjectResult).Value as List <ChallengeDTO>;
Assert.NotNull(actual);
Assert.Equal(expected, actual, new ChallengeDTOIdComparer());
}
public void Return_CorrectView()
{
var tracksServiceFake = new Mock <ITracksService>();
var challengesServiceFake = new Mock <IChallengesService>();
var mapperFake = new Mock <IMappingProvider>();
var fileSystemFake = new Mock <IFileSystemService>();
var fileUtilsFake = new Mock <IFileUnits>();
var controller = new ChallengeController(
tracksServiceFake.Object,
challengesServiceFake.Object,
fileSystemFake.Object,
mapperFake.Object,
fileUtilsFake.Object);
// Act & Assert
controller.WithCallTo(x => x.Create()).ShouldRenderDefaultView();
}
public void Should_Be_Ok_When_Post()
{
var fakes = new Fakes();
var fakeService = fakes.FakeChallengeService().Object;
var expected = fakes.Get <ChallengeDTO>().First();
expected.Id = 0;
var controller = new ChallengeController(fakeService, fakes.Mapper);
var result = controller.Post(expected);
Assert.IsType <OkObjectResult>(result.Result);
var actual = (result.Result as OkObjectResult).Value as ChallengeDTO;
Assert.NotNull(actual);
Assert.Equal(999, actual.Id);
Assert.Equal(expected.Name, actual.Name);
Assert.Equal(expected.Slug, actual.Slug);
}
void Start()
{
// default components
gameStatus = new SaveGameStatus();
displayText = GetComponent <InGameDisplayText>();
findPlayerController = GetComponent <FindControllers>();
phase = GetComponent <PhaseController>();
player = findPlayerController.FindPlayerController();
challenge = GetComponent <ChallengeController>();
cheat = new PhaseCheater();
// setting scores and others
// gameStatus.SetGameDifficultToPlayerPrefs(3); - to tests
gameStatus.GetGameDifficultToPlayerPrefs();
phase.MultiplierNextPhase();
GameOverFlag = false;
RestartFlag = false;
score = 0;
difficultCounter = 0;
// setting start texts
VerifyIfFirstGame();
SetDisplayTexts();
player.PlayerWait();
// start the phase
spawnWaves = new SpawnWaves();
spawnWaves.GetGameControllerReference(this);
startTheGame = new StartPhase();
startTheGame.GetDisplayTextFromGameController(displayText);
startTheGame.GetThePhaseFromGameController(phase);
startTheGame.GetThePlayerFromGameController(player);
StartCoroutine(startTheGame.StartTheGame(this));
ContinueSpawnWaves = true;
CanSpawnWaves();
restart = new Restart(this, challenge);
restart.GetDisplayTextFromGameController(displayText);
}
public void Setup()
{
MockChallengeHandler = new Mock <IChallengeHandler>();
Unit = new ChallengeController(MockChallengeHandler.Object);
RouteData = new RouteData();
MockContextBase = new Mock <HttpContextBase>();
MockRequestBase = new Mock <HttpRequestBase>();
MockResponseBase = new Mock <HttpResponseBase>();
MockUser = new Mock <IPrincipal>();
MockContextBase.Setup(x => x.Request).Returns(MockRequestBase.Object);
MockContextBase.Setup(x => x.Response).Returns(MockResponseBase.Object);
MockContextBase.Setup(x => x.User).Returns(MockUser.Object);
UnitControllerContext = new ControllerContext(MockContextBase.Object, RouteData, Unit);
Unit.ControllerContext = UnitControllerContext;
}
public async Task ReloadPage()
{
var tracksServiceFake = new Mock <ITracksService>();
var challengesServiceFake = new Mock <IChallengesService>();
var mapperFake = new Mock <IMappingProvider>();
var fileSystemFake = new Mock <IFileSystemService>();
var fileUtilsFake = new Mock <IFileUnits>();
var controller = new ChallengeController(
tracksServiceFake.Object,
challengesServiceFake.Object,
fileSystemFake.Object,
mapperFake.Object,
fileUtilsFake.Object);
var vModelFake = new Mock <ChallengeAdministrationViewModel>();
// Act & Assert
controller.WithCallTo(x => x.Create(vModelFake.Object)).ShouldRedirectTo(x => x.Create());
}
public async Task Call_ChallengesServiceCreateWhenNoFileIsAttached()
{
var tracksServiceFake = new Mock <ITracksService>();
var challengesServiceFake = new Mock <IChallengesService>();
var mapperFake = new Mock <IMappingProvider>();
var fileSystemFake = new Mock <IFileSystemService>();
var fileUtilsFake = new Mock <IFileUnits>();
var controller = new ChallengeController(
tracksServiceFake.Object,
challengesServiceFake.Object,
fileSystemFake.Object,
mapperFake.Object,
fileUtilsFake.Object);
var vModelFake = new Mock <ChallengeAdministrationViewModel>();
challengesServiceFake.Setup(
x => x.Create(
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <Language>(),
It.IsAny <double>(),
It.IsAny <int>(),
It.IsAny <IEnumerable <Test> >())).Verifiable();
// Act
await controller.Create(vModelFake.Object);
// Assert
challengesServiceFake.Verify(
x => x.Create(
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <Language>(),
It.IsAny <double>(),
It.IsAny <int>(),
It.IsAny <IEnumerable <Test> >()), Times.Once);
}
