public void GameOver()
{
State = GameState.Dead;
//SavedLives--;
MenuManager.Instance.GameOver();
SoundManager.PlaySfx(soundManager.soundGameover, 0.5f);
if (SavedLives <= 0)
{
//reset all levels and worlds
/*
* isNoLives = true;
*
* if (zeroLiveAction == ZeroLivesAction.ResetAllWorlds) {
* PlayerPrefs.DeleteAll ();
*
* } else {
* var highestWorld = PlayerPrefs.GetInt (GlobalValue.WorldReached, 1);
* //Reset the highest world
* PlayerPrefs.SetInt (highestWorld.ToString (), 1);
* SavedBullets = defaultBullet;
* SavedLives = defaultLive;
* SavedPoints = 0;
* } */
}
AdsController.ShowAds();
}
// Use this for initialization
void Start()
{
ads = AdsController.Instance;
GameObject music = GameObject.FindGameObjectWithTag("MUSIC");
if (music != null)
{
Destroy(music);
}
audio.clip = nhacNen;
audio.loop = true;
audio.Play();
Time.timeScale = 1;
pause_0 = pausePanel.position;
menu_0 = menuPanel.position;
submit_0 = SubmitPanel.position;
GameObject g = GameObject.FindGameObjectWithTag("COIN_UI");
if (g == null)
{
print("null");
}
CoinUiPosition = Camera.main.ScreenToWorldPoint(g.transform.position);
ads.Show_Banner(false);
}
public void GetAllAds_ShouldReturn_AllAds_SortedByIndex()
{
// Arrange
var fakeAds = this.mockContainer.AdRepositoryMock.Object.All();
var fakeUser = this.mockContainer.ApplicationUserRepositoryMock.Object.All().FirstOrDefault();
var mockContext = new Mock <IOnlineShopData>();
mockContext.Setup(r => r.Ads.All()).Returns(fakeAds.AsQueryable());
var mockIdProvider = new Mock <IUserIdProvider>();
if (fakeUser == null)
{
Assert.Fail("Cannot perform test no users available.");
}
mockIdProvider.Setup(r => r.GetUserId()).Returns(fakeUser.Id);
// Act
var adsController = new AdsController(mockContext.Object, mockIdProvider.Object);
this.SetupController(adsController);
var httpResponse = adsController.GetAllAds().ExecuteAsync(CancellationToken.None).Result;
var result = httpResponse.Content.ReadAsAsync <IEnumerable <AllAdsViewModel> >().Result.Select(a => a.Id);
var orderedFakeAds = fakeAds.OrderBy(a => a.TypeId).Select(a => a.Id).ToList();
// Assert
Assert.AreEqual(HttpStatusCode.OK, httpResponse.StatusCode);
CollectionAssert.AreEqual(orderedFakeAds, result.ToList());
}
void Start()
{
adsController = adsControllerGO.GetComponent <AdsController>();
Button btnLevel1 = level1Button.GetComponent <Button>();
btnLevel1.onClick.AddListener(LevelChangeLevel1);
}
public void CloseAd_AsNotAdOwner_ShouldReturn400BadRequest()
{
// Arrange
var fakeAds = this.mockContainer.AdRepositoryMock.Object.All();
// Act
var openAd = fakeAds.FirstOrDefault(a => a.Status == AdStatus.Open);
if (openAd == null)
{
Assert.Fail("Cannot perform test, because there are no open ads.");
}
var mockContext = new Mock <IOnlineShopData>();
mockContext.Setup(c => c.Ads).Returns(this.mockContainer.AdRepositoryMock.Object);
var mockProvider = new Mock <IUserIdProvider>();
var fakeUsers = this.mockContainer.ApplicationUserRepositoryMock.Object.All();
var nonExistingUser = fakeUsers.FirstOrDefault();
mockProvider.Setup(ip => ip.GetUserId()).Returns(nonExistingUser.Id);
var adsController = new AdsController(mockContext.Object, mockProvider.Object);
this.SetupController(adsController);
var httpResponse = adsController.CloseAd(openAd.Id).ExecuteAsync(CancellationToken.None).Result;
// Assert
Assert.AreEqual(HttpStatusCode.BadRequest, httpResponse.StatusCode);
Assert.AreEqual(AdStatus.Open, openAd.Status);
Assert.IsNull(openAd.ClosedOn);
}
public void ClosingAdd_AsOwner_ShouldReturn200Ok()
{
// Arrange
var fakeAds = this.mockContainer.AdRepositoryMock.Object.All();
// Act
var openAd = fakeAds.FirstOrDefault(a => a.Status == AdStatus.Open);
if (openAd == null)
{
Assert.Fail("Cannot perform test there is no open ads.");
}
var adId = openAd.Id;
var mockContext = new Mock <IOnlineShopData>();
mockContext.Setup(c => c.Ads).Returns(this.mockContainer.AdRepositoryMock.Object);
var mockProvider = new Mock <IUserIdProvider>();
mockProvider.Setup(ip => ip.GetUserId()).Returns(openAd.OwnerId);
var adsController = new AdsController(mockContext.Object, mockProvider.Object);
this.SetupController(adsController);
var httpResponse = adsController.CloseAd(adId).ExecuteAsync(CancellationToken.None).Result;
// Assert
mockContext.Verify(c => c.SaveChanges(), Times.Once);
Assert.AreEqual(AdStatus.Closed, openAd.Status);
Assert.IsNotNull(openAd.ClosedOn);
}
public void GetallAds_Should_Return_Total_Ads_Sorted_By_TypeIndex()
{
var fakeAds = this.mocks.AdRepositoryMock.Object.All();
var mockContext = new Mock<IOnlineShopData>();
mockContext.Setup(ctx => ctx.Ads.All()).Returns(fakeAds.AsQueryable());
var adsController = new AdsController(mockContext.Object);
this.ConfigureController(adsController);
var response = adsController.All().ExecuteAsync(CancellationToken.None).Result;
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
var adsResponse = response.Content.ReadAsAsync<IEnumerable<AdViewModel>>().Result
.Select(a => new
{
a.Id
}).ToList();
var orderedFakeAds = fakeAds
.OrderByDescending(a => a.Type.Index)
.ThenByDescending(a => a.PostedOn)
.Select(a => new { a.Id })
.ToList();
CollectionAssert.AreEqual(adsResponse, orderedFakeAds);
}
public void ShowlastChanceMenu()
{
if (lastChanceMenu.activeSelf)
{
lastChanceMenu.SetActive(false);
return;
}
if ((AdsController.CheckAddVideo(AdsController.rewVideo) &&
AdsController.CheckAddVideo(AdsController.video)) ||
adsController.RemoveAds)
{
if (adsController.RemoveAds)
{
_lastChanceTextTip.text = _noAdsText;
lastChanceMenu.SetActive(true);
}
else
{
_lastChanceTextTip.text = _adsText;
lastChanceMenu.SetActive(true);
}
}
else
{
snake.ChangeGameState(false);
}
}
public void GetAllAds_Should_Return_Total_Ads_Sorted_By_TypeIndex()
{
// Arrange
var fakeAds = this.mocks.AdRepositoryMock.Object.All();
var mockContext = new Mock <IOnlineShopData>();
var mockUserIdProvider = new Mock <IUserIdProvider>();
mockContext.Setup(c => c.Ads.All())
.Returns(fakeAds);
var adsController = new AdsController(mockContext.Object, mockUserIdProvider.Object);
this.SetupController(adsController);
// Act
var response = adsController.GetAds()
.ExecuteAsync(CancellationToken.None).Result;
// Assert
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
var adsResponse = response.Content
.ReadAsAsync <IEnumerable <AdViewModel> >()
.Result.Select(a => a.Id)
.ToList();
var orderedFakeAds = fakeAds
.OrderByDescending(a => a.Type.Index)
.ThenBy(a => a.PostedOn)
.Select(a => a.Id)
.ToList();
CollectionAssert.AreEqual(orderedFakeAds, adsResponse);
}
void Start()
{
// Set level text
levelText.text = "Level " + GamePersistence.gameData.level;
// Did we win the level ?
if (GameController.hasWon)
{
// Change texts
resultText.text = "PASS!";
hintText.text = "NEXT LEVEL ...";
// Change text colors
resultText.color = hintText.color = GameController.WIN_COLOR;
// Hide skip level button
skipLevelButton.gameObject.SetActive(false);
}
else
{
// Check if we need to show the skip level button
bool visible = GameController.levelAttempts >= SKIP_LEVEL_ATTEMPS && GamePersistence.gameData.level == GamePersistence.gameData.highestLevel &&
AdsController.IsRewardedVideoAdLoaded();
skipLevelButton.gameObject.SetActive(visible);
}
// Increase the games played count
gamesPlayedSinceStart++;
// Show ads
if (gamesPlayedSinceStart % GAMES_TO_SHOW_INTERSTITIAL_AD == 0)
{
AdsController.ShowInterstitialAd();
}
// Show banner ad
AdsController.ShowBannerAd();
}
public void GameFinish()
{
State = GameState.Finish;
Player.GameFinish();
MenuManager.Instance.Gamefinish();
SoundManager.PlaySfx(soundManager.soundGamefinish, 0.5f);
//save coins and points
SavedCoins = Coin;
SavedPoints = Point;
SavedBullets = Bullet;
//unlock new world if this level is the last one
if (LevelManager.Instance.isLastLevelOfWorld)
{
PlayerPrefs.SetInt(GlobalValue.WorldReached, GlobalValue.worldPlaying + 1);
Debug.Log("Completed the last level, if this is not the final level, please uncheck isLastLevelOfWorld in LevelManager script");
return;
}
//check to unlock new level
var levelreached = PlayerPrefs.GetInt(GlobalValue.worldPlaying.ToString(), 1);
if (GlobalValue.levelPlaying == levelreached)
{
PlayerPrefs.SetInt(GlobalValue.worldPlaying.ToString(), levelreached + 1);
Debug.Log("Unlock new level");
}
AdsController.ShowAds();
}
void Start()
{
//height = width;
instance = this;
//myCamera = gameObject.GetComponent<Camera>();
shutterSound = GetComponent <AudioSource>();
AudioManager = GameObject.Find("---AudioManager").GetComponent <AudioManager>();
ScreenCapDirectory = Application.persistentDataPath;
FinalCameraController = GetComponent <FinalCameraController>();
//CalculateInventory = GameObject.Find("---InventoryController").GetComponent<CalculateInventory>();
RatingSys = GameObject.Find("FloatingUI").GetComponent <RatingSystem>();
if (FinalCameraController != null)
{
AdsController = GameObject.Find("---AdsController").GetComponent <AdsController>();
}
// postImage = GetComponent<Image>();
// //print(postImage.name);
if (!FinalCameraController.isTutorial)
{
//KararaTop = KararaTopImage.sprite.name;
//KararaBottom = KararaBottomImage.sprite.name;
//KararaShoe = KararaShoeImage.sprite.name;
}
}
public void Closing_Ads_As_Non_Owner_Should_Return_400BadRequest()
{
var fakeAd = this._mocks.AdRepoMock.Object.All()
.FirstOrDefault(ad => ad.Status == AdStatus.Open);
if (fakeAd == null)
{
Assert.Fail("No ads available to perform the test.");
}
var adId = fakeAd.Id;
var mockContext = new Mock <IOnlineShopData>();
mockContext.Setup(c => c.Ads)
.Returns(this._mocks.AdRepoMock.Object);
var mockIdProvider = new Mock <IUserIdProvider>();
mockIdProvider.Setup(ip => ip.GetUserId())
.Returns("Ivan4o");
var adsController = new AdsController(mockContext.Object, mockIdProvider.Object);
this.SetupController(adsController);
var response = adsController.CloseAd(adId)
.ExecuteAsync(CancellationToken.None).Result;
Assert.AreEqual(response.StatusCode, HttpStatusCode.Unauthorized);
mockContext.Verify(c => c.SaveChanges(), Times.Never);
Assert.AreEqual(_mocks.AdRepoMock.Object.All().FirstOrDefault(ad => ad.Id == adId).Status, AdStatus.Open);
}
public void StartGame()
{
State = GameState.Playing;
LevelManager.Instance.StartGame();
AdsController.HideAds();
}
public void GetAllAds_ShouldReturnAllAdsSortedByTypeIndex()
{
var fakeAds = this.mocks.AdRepositoryMock.Object.All();
var mockContext = new Mock<IOnlineShopData>();
var mockUserIdProvider = new Mock<IUserIdProvider>();
mockContext
.Setup(r => r.Ads.All())
.Returns(fakeAds);
var adsController = new AdsController(mockContext.Object, mockUserIdProvider.Object);
this.SetupController(adsController);
var response = adsController.Get()
.ExecuteAsync(CancellationToken.None).Result;
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
var adsResponse = response.Content
.ReadAsAsync<IEnumerable<AdViewModel>>()
.Result.Select(a => a.Id)
.ToList();
var orderedFakeAds = fakeAds
.OrderByDescending(a => a.Type.Index)
.ThenByDescending(a => a.PostedOn)
.Select(a => a.Id)
.ToList();
CollectionAssert.AreEqual(orderedFakeAds, adsResponse);
}
void Start()
{
InventoryController = GameObject.Find("---InventoryController");
TouchController = GameObject.Find("---TouchController").GetComponent <TouchController>();
AllMachines = GameObject.Find("---ClothInMachineController").GetComponent <AllMachines>();
FinalCameraController = GameObject.Find("Main Camera").GetComponent <FinalCameraController>();
SubwayMovement = GameObject.Find("---StationController").GetComponent <SubwayMovement>();
LostAndFound = GameObject.Find("Lost&Found_basket").GetComponent <LostAndFound>();
SpriteLoader = GameObject.Find("---SpriteLoader").GetComponent <SpriteLoader>();
AdsController = GameObject.Find("---AdsController").GetComponent <AdsController>();
InventorySlotMgt = GameObject.Find("---InventoryController").GetComponent <InventorySlotMgt>();
//AudioManager = GameObject.Find("---AudioManager").GetComponent<AudioManager>();
LevelManager = FinalCameraController.LevelManager;
startPos = transform.position;
// selfButton.onClick.AddListener(AddClothToInventory);
//currentSprite = GetComponent<SpriteRenderer>().sprite;
myImage = GetComponent <Image>();
startSprite = GetComponent <Image>().sprite;
if (!FinalCameraController.isTutorial)
{
returnConfirmButton.gameObject.SetActive(false);
}
}
public void TestGetAdsShouldReturnAllAdsSortedByType()
{
var mockedContext = new Mock <IOnlineShopData>();
mockedContext.Setup(c => c.Ads).Returns(this.mock.AdRepositoryMock.Object);
var adsController = new AdsController(mockedContext.Object);
adsController.Request = new HttpRequestMessage();
adsController.Configuration = new HttpConfiguration();
var response = adsController.GetAds().ExecuteAsync(CancellationToken.None).Result;
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
var responseAds = response.Content
.ReadAsAsync <IEnumerable <AdViewModel> >()
.Result
.Select(a => a.Id)
.ToList();
var fakeAds = this.mock.AdRepositoryMock.Object.All()
.Select(AdViewModel.Create)
.OrderBy(a => a.Type)
.ThenBy(a => a.PostDateTime)
.Select(a => a.Id)
.ToList();
CollectionAssert.AreEqual(fakeAds, responseAds);
}
// Use this for initialization
void Start()
{
DontDestroyOnLoad(gameObject);
instance = this;
RequestBanner();
RequestInterstitial();
}
public void Closing_Ad_As_Owner_Should_Return_200OK()
{
var fakeAds = this.mocks.AdRepositoryMock.Object.All();
var openAd = fakeAds.FirstOrDefault(ad => ad.Status == AdStatus.Open);
if (openAd == null)
{
Assert.Fail("Cannot perform test - no open ads available.");
}
var mockContext = new Mock <IOnlineShopData>();
mockContext.Setup(c => c.Ads)
.Returns(this.mocks.AdRepositoryMock.Object);
var mockUserIdProvider = new Mock <IUserIdProvider>();
mockUserIdProvider.Setup(uip => uip.GetUserId())
.Returns(openAd.OwnerId);
var adsController = new AdsController(mockContext.Object, mockUserIdProvider.Object);
this.SetupController(adsController);
var response = adsController.CloseAd(openAd.Id)
.ExecuteAsync(CancellationToken.None).Result;
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
mockContext.Verify(c => c.SaveChanges(), Times.Once);
Assert.IsNotNull(openAd.ClosedOn);
Assert.AreEqual(AdStatus.Closed, openAd.Status);
}
public UnityAdsController(AdsController controller, string gameId, bool testMode, string videoId)
{
m_Controller = controller;
m_GameId = gameId;
m_TestMode = testMode;
m_VideoPlacement = videoId;
}
private IEnumerator WaitThenHideCompleteScreen()
{
yield return(new WaitForSeconds(1f));
bool adShown = false;
if (AdsController.Exists())
{
if (LevelsToCompleteBeforeAd <= 0)
{
LevelsToCompleteBeforeAd = adLevelCompleteAmount;
// Show an interstital ad and only pause the timer if an ad actually shows, when the interstitial is closed un-pause the timer
adShown = AdsController.Instance.ShowInterstitialAd(() =>
{
// Once the ad is closed hide the completed screen
UIScreenController.Instance.HideOverlay(UIScreenController.CompleteScreenId, true, Tween.TweenStyle.EaseIn);
});
}
}
// If no ad was shown then hide the completed overlay right away
if (!adShown)
{
UIScreenController.Instance.HideOverlay(UIScreenController.CompleteScreenId, true, Tween.TweenStyle.EaseIn);
}
}
// Use this for initialization
void Start()
{
score = 0;
scr = GameObject.FindGameObjectWithTag("Score").GetComponentInChildren <Text>();
pauseMenu = GameObject.FindGameObjectWithTag("ShowOnPause");
pauseMenu.SetActive(false);
blur = GameObject.FindGameObjectWithTag("Blur");
blur.SetActive(false);
levelFailMenu = GameObject.FindGameObjectWithTag("ShowOnLevelFail");
levelFailMenu.SetActive(false);
player = FindObjectOfType <PlayerController>();
currentCheckPoint = player.transform.position;
currentSprite = player.GetComponent <SpriteRenderer>().sprite;
currentRadius = player.GetComponent <CircleCollider2D>().radius;
nextLevel = nextLevelSprite.GetComponent <Animator>();
sound = true;
ads = FindObjectOfType <AdsController>();
if (sound)
{
btnSound.image.sprite = soundOff;
}
else
{
btnSound.image.sprite = soundOn;
}
}
public async Task PostDeleteShouldReturnRedirectWithValidId()
{
// Arrange
const int idValue = 1;
int modelId = 0;
var adService = new Mock <IAdminAdService>();
adService
.Setup(u => u.Delete(It.IsAny <int>()))
.Callback((int id) =>
{
modelId = id;
}).Returns(Task.FromResult(true));
var controller = new AdsController(adService.Object);
// Act
var result = await controller.Delete(idValue);
// Assert
modelId.Should().Be(idValue);
result.Should().BeOfType <string>();
result.Should().Be($"The ad has been succesffuly deleted.");
}
// Use this for initialization
void Start()
{
level = FindObjectOfType <LevelController>();
ads = FindObjectOfType <AdsController>();
blur = GameObject.FindGameObjectWithTag("Blur");
levelFailMenu = GameObject.FindGameObjectWithTag("ShowOnLevelFail");
}
public void OnSkipLevelButton()
{
// Reset level attempts flag
GameController.levelAttempts = 0;
// Play a rewarded ad video
AdsController.ShowRewardedVideoAd();
}
void Awake()
{
if (_instance != null)
{
Destroy(this.gameObject);
}
_instance = this;
}
// that method for button
public void ShowVideo()
{
AdsController.ShowRewardedVideo(actionsAfterAd.Invoke);
_openAndCloseCore.Close(adBonus.transform);
_isAdBonusActive = false;
_currentTime = 0;
}
void MakeSingleton()
{
if (instance == null)
{
instance = this;
DontDestroyOnLoad(gameObject);
}
}
void OnApplicationFocus(bool hasFocus)
{
if (hasFocus)
{
// Notify application focus on ads
AdsController.OnResume();
}
}
public void CreateAd_Should_Succsessfully_Add_To_Repository()
{
// Arrange
var ads = new List <Ad>();
var fakeUser = this.mocks.UserRepositoryMock.Object.All()
.FirstOrDefault();
if (fakeUser == null)
{
Assert.Fail("Cannot perform test - no users available.");
}
this.mocks.AdRepositoryMock
.Setup(r => r.Add(It.IsAny <Ad>()))
.Callback((Ad ad) =>
{
ad.Owner = fakeUser;
ads.Add(ad);
});
var mockContext = new Mock <IOnlineShopData>();
mockContext.Setup(c => c.Ads)
.Returns(this.mocks.AdRepositoryMock.Object);
mockContext.Setup(c => c.Categories)
.Returns(this.mocks.CategoryRepositoryMock.Object);
mockContext.Setup(c => c.Users)
.Returns(this.mocks.UserRepositoryMock.Object);
mockContext.Setup(c => c.AdTypes)
.Returns(this.mocks.AdTypeRepositoryMock.Object);
var mockUserIdProvider = new Mock <IUserIdProvider>();
mockUserIdProvider.Setup(uip => uip.GetUserId())
.Returns(fakeUser.Id);
var adsController = new AdsController(mockContext.Object, mockUserIdProvider.Object);
this.SetupController(adsController);
var randomName = Guid.NewGuid().ToString();
var newAd = new CreateAdBindingModel
{
Name = randomName,
Price = 555,
TypeId = 1,
Description = "Some description.",
Categories = new[] { 3, 1, 99 }
};
var response = adsController.CreateAd(newAd)
.ExecuteAsync(CancellationToken.None).Result;
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
mockContext.Verify(c => c.SaveChanges(), Times.Once);
Assert.AreEqual(1, ads.Count);
Assert.AreEqual(newAd.Name, ads[0].Name);
}
protected override void Awake()
{
base.Awake();
GameInfo.Init();
Localization.Init();
Notification.Init();
AdsController.Init();
}
protected override void OnDestroy()
{
CurrencyController?.Dispose();
ShopController?.Dispose();
AdsController?.Dispose();
DailyBonusController?.Dispose();
StorageController?.Dispose();
base.OnDestroy();
}
// Use this for initialization
void Awake()
{
if (instance == null){
instance = this;
}
else if (instance != this){
Destroy(gameObject);
}
DontDestroyOnLoad(gameObject);
}
public void CanCallGet()
{
var ad = new Ad()
{
Id = 10,
Name = "10",
Description = "10"
};
var mock = new Mock<IAdRepository>();
mock.Setup(c => c.Get(It.IsAny<int>())).Returns(ad);
var controller = new AdsController(mock.Object);
var result = controller.Get(10);
Assert.IsTrue(result.Name == "10");
}
public void CanCallDelete()
{
var ad = new Ad()
{
Id = 40,
Name = "40",
Description = "40"
};
var mock = new Mock<IAdRepository>();
mock.Setup(c => c.Delete(It.IsAny<int>())).Returns<Ad>(null);
mock.Setup(c => c.Get(It.IsAny<int>())).Returns(ad);
var controller = new AdsController(mock.Object);
controller.Delete(ad.Id);
mock.Verify(repo => repo.Delete(It.IsAny<int>()), Times.AtLeastOnce());
}
public void CanCallGetAll()
{
var ads = new List<Ad>() {
new Ad() { Id = 1, Name = "1", Description = "1"},
new Ad() { Id = 2, Name = "2", Description = "2"}
}.AsQueryable();
var mock = new Mock<IAdRepository>();
mock.Setup(c => c.GetAll()).Returns(ads);
//mock.Setup(x => x.GetCustomerTotal(It.IsAny<int>())).Returns(25.5);
var controller = new AdsController(mock.Object);
var results = controller.GetAll();
Assert.IsTrue(results.Count() > 1);
Assert.IsTrue(results.First().Id == 1);
Assert.IsTrue(results.Last().Description == "2");
}
public void Close_Ad_As_NonOwner_Should_Return_400BadRequest()
{
var fakeAds = this.mocks.AdRepositoryMock.Object.All();
var fakeUsers = this.mocks.UserRepositoryMock.Object.All();
var openAd = fakeAds.FirstOrDefault(a => a.Status == AdStatus.Open);
if (openAd == null)
{
Assert.Fail("Cannot perform test - no open ads exist.");
}
var openAdOwnerId = openAd.OwnerId;
var fakeForeignUser = fakeUsers.FirstOrDefault(u => u.Id != openAdOwnerId);
if (fakeForeignUser == null)
{
Assert.Fail("Cannot perform test - no foreign user available.");
}
var fakeForeignUserId = fakeForeignUser.Id;
var openAdId = openAd.Id;
var mockIdProvider = new Mock<IUserIdProvider>();
mockIdProvider.Setup(ip => ip.GetUserId())
.Returns(fakeForeignUserId);
var mockContext = new Mock<IOnlineShopData>();
mockContext.Setup(c => c.Ads).Returns(this.mocks.AdRepositoryMock.Object);
var adsController = new AdsController(mockContext.Object, mockIdProvider.Object);
this.ConfigureController(adsController);
var response = adsController.Close(openAdId).ExecuteAsync(CancellationToken.None).Result;
Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode);
mockContext.Verify(c => c.SaveChanges(), Times.Never);
Assert.AreEqual(AdStatus.Open, openAd.Status);
}
public void CreateAd_ShouldSuccessfullyAddToRepository()
{
var ads = new List<Ad>();
var fakeUser = this.mocks.ApplicationUserRepositoryMock.Object.All()
.FirstOrDefault();
if (fakeUser == null)
{
Assert.Fail("Cannot perform test - no users available.");
}
this.mocks.AdRepositoryMock
.Setup(r => r.Add(It.IsAny<Ad>()))
.Callback((Ad ad) =>
{
ad.Owner = fakeUser;
ads.Add(ad);
});
var mockContext = new Mock<IOnlineShopData>();
mockContext
.Setup(c => c.Ads)
.Returns(this.mocks.AdRepositoryMock.Object);
mockContext
.Setup(c => c.AdTypes)
.Returns(this.mocks.AdTypeRepositoryMock.Object);
mockContext
.Setup(c => c.ApplicationUsers)
.Returns(this.mocks.ApplicationUserRepositoryMock.Object);
mockContext
.Setup(c => c.Categories)
.Returns(this.mocks.CategoryRepositoryMock.Object);
var mockIdProvider = new Mock<IUserIdProvider>();
mockIdProvider
.Setup(ip => ip.GetUserId())
.Returns(fakeUser.Id);
var adsController = new AdsController(mockContext.Object, mockIdProvider.Object);
this.SetupController(adsController);
var randomName = Guid.NewGuid().ToString();
var newAd = new CreateAdBindingModel()
{
Name = randomName,
Price = 555,
TypeId = 1,
Description = "Nothing much to say",
Categories = new[] { 1, 2, 3 }
};
var response = adsController.Post(newAd)
.ExecuteAsync(CancellationToken.None).Result;
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
mockContext.Verify(c => c.SaveChanges(), Times.Once);
Assert.AreEqual(1, ads.Count);
Assert.AreEqual(newAd.Name, ads[0].Name);
}
void Awake()
{
g_instance = this;
}
private void SetupController(AdsController adsController)
{
adsController.Request = new HttpRequestMessage();
adsController.Configuration = new HttpConfiguration();
}
public void CloseAdAsNonOwnerShouldReturn401Unauthorized()
{
var fakeAds = this.mocks.AdRepositoryMock.Object.All();
var openAd = fakeAds.FirstOrDefault(a => a.Status == AdStatus.Open);
if (openAd == null)
{
Assert.Fail("Cannot perform test - no open ads available.");
}
var adId = openAd.Id;
var fakeUsers = this.mocks.ApplicationUserRepositoryMock.Object.All();
var foreignUser = fakeUsers.FirstOrDefault(u => u.Id != openAd.OwnerId);
var mockContext = new Mock<IOnlineShopData>();
mockContext
.Setup(c => c.Ads)
.Returns(this.mocks.AdRepositoryMock.Object);
var mockIdProvider = new Mock<IUserIdProvider>();
mockIdProvider
.Setup(ip => ip.GetUserId())
.Returns(foreignUser.Id);
var adsController = new AdsController(mockContext.Object, mockIdProvider.Object);
this.SetupController(adsController);
var response = adsController.CloseAd(adId)
.ExecuteAsync(CancellationToken.None).Result;
Assert.AreEqual(HttpStatusCode.Unauthorized, response.StatusCode);
mockContext.Verify(c => c.SaveChanges(), Times.Never);
Assert.AreEqual(openAd.Status, AdStatus.Open);
}
public void Closing_Ad_As_Owner_Should_Return_200OK()
{
var fakeAds = this.mocks.AdRepositoryMock.Object.All();
var openAd = fakeAds.FirstOrDefault(ad => ad.Status == AdStatus.Open);
if (openAd == null)
{
Assert.Fail("Cannot perform test - no open ads available.");
}
var openAdId = openAd.Id;
var mockContext = new Mock<IOnlineShopData>();
mockContext.Setup(c => c.Ads)
.Returns(this.mocks.AdRepositoryMock.Object);
var mockIdProvider = new Mock<IUserIdProvider>();
mockIdProvider.Setup(p => p.GetUserId())
.Returns(openAd.OwnerId);
var adsController = new AdsController(mockContext.Object, mockIdProvider.Object);
this.ConfigureController(adsController);
var response = adsController.Close(openAdId).ExecuteAsync(CancellationToken.None).Result;
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
mockContext.Verify(c => c.SaveChanges(), Times.Once);
Assert.AreNotEqual(openAd.ClosedOn, null);
Assert.AreEqual(openAd.Status, AdStatus.Closed);
}
public void CanCallInsert()
{
var ad = new Ad()
{
Name = "20",
Description = "20"
};
var newAd = new Ad()
{
Id = 20,
Name = "20",
Description = "20"
};
var mock = new Mock<IAdRepository>();
mock.Setup(c => c.Insert(It.IsAny<Ad>())).Returns(newAd);
var controller = new AdsController(mock.Object);
controller.Request = new HttpRequestMessage
{
RequestUri = new Uri("http://localhost/api/ads")
};
controller.Configuration = new HttpConfiguration();
controller.Configuration.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional });
controller.RequestContext.RouteData = new HttpRouteData(
route: new HttpRoute(),
values: new HttpRouteValueDictionary { { "controller", "ads" } });
var response = controller.Post(ad);
var expectedUrl = "http://localhost/api/ads/" + newAd.Id;
Assert.IsNotNull(response);
Assert.AreEqual(expectedUrl, response.Headers.Location.AbsoluteUri);
}
public void ShouldThrowDuringUpdateIfEntityDoesNotExist()
{
var mock = new Mock<IAdRepository>();
mock.Setup(c => c.Update(It.IsAny<Ad>(), It.IsAny<int>())).Returns((Ad)null);
mock.Setup(c => c.Get(It.IsAny<int>())).Returns((Ad)null);
var controller = new AdsController(mock.Object);
controller.Put(1, new Ad());
}
private void ConfigureController(AdsController controller)
{
controller.Request = new HttpRequestMessage();
controller.Configuration = new HttpConfiguration();
}
