public async Task AddTheGuideToTheUser()
{
var dotaHelperData = new Mock <IDotaHelperData>();
var users = new Mock <IDotaHelperRepository <DotaHelperUser> >();
var postedGuides = new Mock <ICollection <Guide> >();
var user = new DotaHelperUser {
PostedGuides = postedGuides.Object
};
users.Setup(x => x.FindAsync(It.IsAny <string>())).Returns(Task.FromResult(user));
var userGuides = new Mock <IDotaHelperRepository <DotaHelperUserGuide> >();
var guides = new Mock <IGuideData>();
dotaHelperData.Setup(x => x.Users).Returns(users.Object);
dotaHelperData.Setup(x => x.Guides).Returns(guides.Object);
dotaHelperData.Setup(x => x.UserGuides).Returns(userGuides.Object);
var heroesProvider = new Mock <IHeroesProvider>();
var itemsProvider = new Mock <IItemsProvider>();
var mapper = new Mock <IMapper>();
var guideService = new GuidesService(dotaHelperData.Object, heroesProvider.Object, itemsProvider.Object, mapper.Object);
await guideService.AddGuide("1", new GuidePostDataModel());
postedGuides.Verify(x => x.Add(It.IsAny <Guide>()), Times.Once);
}
public async Task CallSaveChanges()
{
var dotaHelperData = new Mock <IDotaHelperData>();
var users = new Mock <IDotaHelperRepository <DotaHelperUser> >();
var postedGuides = new Mock <List <Guide> >();
var user = new DotaHelperUser {
PostedGuides = postedGuides.Object, Id = "3"
};
users.Setup(x => x.FindAsync(It.IsAny <string>())).Returns(Task.FromResult(user));
var userGuides = new Mock <IDotaHelperRepository <DotaHelperUserGuide> >();
var guide = new Guide {
Id = "5"
};
var guides = new Mock <IGuideData>();
guides.Setup(x => x.FindAsync(It.IsAny <string>())).Returns(Task.FromResult(guide));
dotaHelperData.Setup(x => x.Users).Returns(users.Object);
dotaHelperData.Setup(x => x.Guides).Returns(guides.Object);
dotaHelperData.Setup(x => x.UserGuides).Returns(userGuides.Object);
var heroesProvider = new Mock <IHeroesProvider>();
var itemsProvider = new Mock <IItemsProvider>();
var mapper = new Mock <IMapper>();
var guideService = new GuidesService(dotaHelperData.Object, heroesProvider.Object, itemsProvider.Object, mapper.Object);
await guideService.FavoriteGuide("3", "5");
dotaHelperData.Verify(x => x.SaveChangesAsync(), Times.Once);
}
public void All_WithData_ReturnsSameData()
{
var options = new DbContextOptionsBuilder <GameInfoContext>()
.UseInMemoryDatabase(databaseName: "Db_WithGuides")
.Options;
using (var context = new GameInfoContext(options))
{
var service = new GuidesService(context);
var guides = new List <Guide>
{
new Guide()
{
Title = "1", Content = "1"
},
new Guide()
{
Title = "2", Content = "2"
},
new Guide()
{
Title = "3", Content = "3"
}
};
context.Guides.AddRange(guides);
context.SaveChanges();
Assert.Equal(3, service.All().Count);
}
}
public async Task GetReportsShouldGetOne()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString());
var context = new ApplicationDbContext(options.Options);
var guideRepository = new EfDeletableEntityRepository <Guide>(context);
var guideService = new GuidesService(guideRepository);
var guideModel = new CreateGuideInputModel()
{
Category = "Action",
Description = "someDesc",
GameId = "1",
ImageUrl = "google",
Title = "test",
};
var guideId = await guideService.CreateAsync(guideModel, "1");
var repository = new EfRepository <Report>(context);
var service = new ReportsService(repository);
var model = new AddReportToGuideInputModel()
{
UserId = "1",
GuideId = guideId,
Reason = "tupooooo",
};
await service.AddReportToGuideAsync(model);
var actual = await service.GetByGuideAsync <ReportForGuideViewModel>(model.GuideId);
Assert.Single(actual);
}
public void Add_SavesToDatabase()
{
var options = new DbContextOptionsBuilder <GameInfoContext>()
.UseInMemoryDatabase(databaseName: "AddGuide_ToDb")
.Options;
using (var context = new GameInfoContext(options))
{
var guideToAdd = new AddGuideInputModel()
{
GuideTitle = "Guide", GuideContent = "Content"
};
var user = new GameInfoUser()
{
UserName = "******"
};
var service = new GuidesService(context);
service.Add(guideToAdd, user);
var expectedGuide = new Guide()
{
Title = guideToAdd.GuideTitle, Content = guideToAdd.GuideContent
};
Assert.NotEmpty(context.Guides);
Assert.Equal(expectedGuide.Title, context.Guides.First().Title);
Assert.Equal(expectedGuide.Content, context.Guides.First().Content);
}
}
public async Task SearchGuideShouldFindOneByTitle()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString());
var context = new ApplicationDbContext(options.Options);
await context.Users.AddAsync(new ApplicationUser()
{
Id = "2"
});
await context.Games.AddAsync(new Game()
{
Id = "1"
});
var postRepository = new EfDeletableEntityRepository <Post>(context);
var guideRepository = new EfDeletableEntityRepository <Guide>(context);
var searchBarService = new SearchBarService(postRepository, guideRepository);
var guideService = new GuidesService(guideRepository);
var guideModel = new CreateGuideInputModel()
{
Title = "testtesttest",
Category = "Action",
Description = "sssss",
GameId = "1",
ImageUrl = "test",
};
await guideService.CreateAsync(guideModel, "2");
var actual = await searchBarService.SearchGuide <GuideViewModel>("test", 5, 0);
Assert.Single(actual);
}
public void ById_WithGuide_ReturnsGuide()
{
var options = new DbContextOptionsBuilder <GameInfoContext>()
.UseInMemoryDatabase(databaseName: "Db_ForById_WithGuide")
.Options;
using (var context = new GameInfoContext(options))
{
var service = new GuidesService(context);
var guideToAdd = new Guide()
{
Title = "GuideTitle",
Content = "GuideContent"
};
context.Guides.Add(guideToAdd);
context.SaveChanges();
var guideFromDb = service.ById(1);
Assert.Equal(guideToAdd.Title, guideFromDb.Title);
Assert.Equal(guideToAdd.Content, guideFromDb.Content);
}
}
public async Task SetIsFavoritedToTrueIfUserHasFavoritedTheGuide()
{
var dotaHelperData = new Mock <IDotaHelperData>();
var guides = new Mock <IGuideData>();
guides.Setup(x => x.FindAsync("1")).Returns(Task.FromResult(new Guide {
Id = "1"
}));
var users = new Mock <IDotaHelperRepository <DotaHelperUser> >();
users.Setup(x => x.FindAsync("5")).Returns(Task.FromResult(new DotaHelperUser {
FavoritedGuides = new List <DotaHelperUserGuide> {
new DotaHelperUserGuide {
GuideId = "1"
}
}
}));
dotaHelperData.Setup(x => x.Guides).Returns(guides.Object);
dotaHelperData.Setup(x => x.Users).Returns(users.Object);
var heroesProvider = new Mock <IHeroesProvider>();
var itemsProvider = new Mock <IItemsProvider>();
var mapper = new Mock <IMapper>();
mapper.Setup(x => x.Map <GuideDetailsDto>(It.IsAny <object>())).Returns(new GuideDetailsDto {
ItemIds = new List <string>()
});
var guideService = new GuidesService(dotaHelperData.Object, heroesProvider.Object, itemsProvider.Object, mapper.Object);
var result = await guideService.GetGuideDetailsAsync("1", "5");
Assert.IsTrue(result.IsFavorited);
}
public async Task GetLatestShouldReturnModel()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString());
var context = new ApplicationDbContext(options.Options);
await context.Users.AddAsync(new ApplicationUser()
{
Id = "1"
});
await context.Games.AddAsync(new Game()
{
Id = "1"
});
var repository = new EfDeletableEntityRepository <Guide>(context);
var service = new GuidesService(repository);
var model = new CreateGuideInputModel()
{
Title = "new",
GameId = "1",
Category = "Action",
Description = "test",
ImageUrl = "google",
};
await service.CreateAsync(model, "1");
var actual = await service.TakeLatestGuideAsync <LatestGuideViewModel>();
Assert.IsType <LatestGuideViewModel>(actual);
}
public async Task CallGetHeroForEveryGuideFound()
{
var dotaHelperData = new Mock <IDotaHelperData>();
var guides = new Mock <IGuideData>();
guides.Setup(x => x.CountAsync()).Returns(Task.FromResult(50));
dotaHelperData.Setup(x => x.Guides).Returns(guides.Object);
var heroesProvider = new Mock <IHeroesProvider>();
heroesProvider.Setup(x => x.GetHeroAsync(It.IsAny <string>())).Returns(Task.FromResult(new HeroDto {
ImageUrl = ""
}));
var itemsProvider = new Mock <IItemsProvider>();
var mapper = new Mock <IMapper>();
var guidesList = new List <GuideListDto> {
new GuideListDto {
HeroId = "1", ItemIds = new List <string>()
}, new GuideListDto {
HeroId = "2", ItemIds = new List <string>()
}, new GuideListDto {
HeroId = "3", ItemIds = new List <string>()
}
};
mapper.Setup(x => x.Map <IEnumerable <GuideListDto> >(It.IsAny <object>())).Returns(guidesList);
var guideService = new GuidesService(dotaHelperData.Object, heroesProvider.Object, itemsProvider.Object, mapper.Object);
await guideService.GetGuidesAsync();
heroesProvider.Verify(x => x.GetHeroAsync("1"), Times.Once);
heroesProvider.Verify(x => x.GetHeroAsync("2"), Times.Once);
heroesProvider.Verify(x => x.GetHeroAsync("3"), Times.Once);
}
public async Task RemoveGuideFromUserFavoritesIfAlreadyFavorited()
{
var dotaHelperData = new Mock <IDotaHelperData>();
var users = new Mock <IDotaHelperRepository <DotaHelperUser> >();
var postedGuides = new Mock <List <Guide> >();
var user = new DotaHelperUser {
PostedGuides = postedGuides.Object, Id = "3", FavoritedGuides = new List <DotaHelperUserGuide> {
new DotaHelperUserGuide {
GuideId = "5"
}
}
};
users.Setup(x => x.FindAsync(It.IsAny <string>())).Returns(Task.FromResult(user));
var userGuides = new Mock <IDotaHelperRepository <DotaHelperUserGuide> >();
var guide = new Guide {
Id = "5"
};
var guides = new Mock <IGuideData>();
guides.Setup(x => x.FindAsync(It.IsAny <string>())).Returns(Task.FromResult(guide));
dotaHelperData.Setup(x => x.Users).Returns(users.Object);
dotaHelperData.Setup(x => x.Guides).Returns(guides.Object);
dotaHelperData.Setup(x => x.UserGuides).Returns(userGuides.Object);
var heroesProvider = new Mock <IHeroesProvider>();
var itemsProvider = new Mock <IItemsProvider>();
var mapper = new Mock <IMapper>();
var guideService = new GuidesService(dotaHelperData.Object, heroesProvider.Object, itemsProvider.Object, mapper.Object);
await guideService.FavoriteGuide("3", "5");
userGuides.Verify(x => x.Add(It.IsAny <DotaHelperUserGuide>()), Times.Never);
userGuides.Verify(x => x.Remove(It.IsAny <DotaHelperUserGuide>()), Times.Once);
}
public void All_WithNoData_ReturnsNoData()
{
var options = new DbContextOptionsBuilder <GameInfoContext>()
.UseInMemoryDatabase(databaseName: "NoGuides_Db")
.Options;
using (var context = new GameInfoContext(options))
{
var service = new GuidesService(context);
Assert.Equal(0, service.All().Count);
}
}
public void Delete_NoData_ReturnsNull()
{
var options = new DbContextOptionsBuilder <GameInfoContext>()
.UseInMemoryDatabase(databaseName: "NoGuides_Db_ForDelete")
.Options;
using (var context = new GameInfoContext(options))
{
var service = new GuidesService(context);
Assert.False(service.Delete(2));
}
}
public void ById_WithNoGuides_ReturnsNull()
{
var options = new DbContextOptionsBuilder <GameInfoContext>()
.UseInMemoryDatabase(databaseName: "NoGuides_Db_ForById")
.Options;
using (var context = new GameInfoContext(options))
{
var service = new GuidesService(context);
Assert.Null(service.ById(1));
}
}
public async Task GetAllItems()
{
var dotaHelperData = new Mock <IDotaHelperData>();
var heroesProvider = new Mock <IHeroesProvider>();
var itemsProvider = new Mock <IItemsProvider>();
var mapper = new Mock <IMapper>();
var guideService = new GuidesService(dotaHelperData.Object, heroesProvider.Object, itemsProvider.Object, mapper.Object);
await guideService.GetCreateModel();
itemsProvider.Verify(x => x.GetAllItemsAsync());
}
public async Task CorrectlySkipAndTakeWhenPageIsNegativeOr0(int page)
{
var dotaHelperData = new Mock <IDotaHelperData>();
var guides = new Mock <IGuideData>();
guides.Setup(x => x.CountAsync()).Returns(Task.FromResult(50));
dotaHelperData.Setup(x => x.Guides).Returns(guides.Object);
var heroesProvider = new Mock <IHeroesProvider>();
var itemsProvider = new Mock <IItemsProvider>();
var mapper = new Mock <IMapper>();
var guideService = new GuidesService(dotaHelperData.Object, heroesProvider.Object, itemsProvider.Object, mapper.Object);
await guideService.GetGuidesAsync(page);
var skip = 0;
var take = 5;
guides.Verify(x => x.GetPagedGuidesAsync(skip, take));
}
public async Task GetGameItems()
{
var dotaHelperData = new Mock <IDotaHelperData>();
var guides = new Mock <IGuideData>();
dotaHelperData.Setup(x => x.Guides).Returns(guides.Object);
var heroesProvider = new Mock <IHeroesProvider>();
var itemsProvider = new Mock <IItemsProvider>();
var mapper = new Mock <IMapper>();
mapper.Setup(x => x.Map <GuideDetailsDto>(It.IsAny <object>())).Returns(new GuideDetailsDto {
ItemIds = new List <string>()
});
var guideService = new GuidesService(dotaHelperData.Object, heroesProvider.Object, itemsProvider.Object, mapper.Object);
await guideService.GetGuideDetailsAsync("1", null);
itemsProvider.Verify(x => x.GetAllItemsAsync(), Times.Once);
}
public async Task MapTheGuideToTheCorrectType()
{
var dotaHelperData = new Mock <IDotaHelperData>();
var guides = new Mock <IGuideData>();
var guide = new Guide();
guides.Setup(x => x.FindAsync("1")).Returns(Task.FromResult(guide));
dotaHelperData.Setup(x => x.Guides).Returns(guides.Object);
var heroesProvider = new Mock <IHeroesProvider>();
var itemsProvider = new Mock <IItemsProvider>();
var mapper = new Mock <IMapper>();
mapper.Setup(x => x.Map <GuideDetailsDto>(It.IsAny <object>())).Returns(new GuideDetailsDto {
ItemIds = new List <string>()
});
var guideService = new GuidesService(dotaHelperData.Object, heroesProvider.Object, itemsProvider.Object, mapper.Object);
await guideService.GetGuideDetailsAsync("1", null);
mapper.Verify(x => x.Map <GuideDetailsDto>(guide), Times.Once);
}
public async Task EditGuideShouldEditContent()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString());
var context = new ApplicationDbContext(options.Options);
await context.Users.AddAsync(new ApplicationUser()
{
Id = "1"
});
await context.Games.AddAsync(new Game()
{
Id = "1"
});
var repository = new EfDeletableEntityRepository <Guide>(context);
var service = new GuidesService(repository);
var model = new CreateGuideInputModel()
{
Title = "new",
GameId = "1",
Category = "Action",
Description = "test",
ImageUrl = "google",
};
var guideId = await service.CreateAsync(model, "1");
var oldGuide = await service.GetByIdAsync <EditGuideViewModel>(guideId);
var contentOldValue = oldGuide.Content;
await service.EditGuideAsync(oldGuide.Id, oldGuide.Title, "newwwwwwwwwwwwwwwwwwwwwwwwwwwww");
var newGuide = await service.GetByIdAsync <EditGuideViewModel>(guideId);
Assert.NotEqual(contentOldValue, newGuide.Title);
}
public async Task AddOnGuideShouldAdd()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString());
var context = new ApplicationDbContext(options.Options);
var repository = new EfDeletableEntityRepository <Guide>(context);
var service = new GuidesService(repository);
var model = new CreateGuideInputModel()
{
Title = "test",
Category = "Action",
Description = "test",
GameId = "1",
ImageUrl = "test",
};
await service.CreateAsync(model, "1");
var actual = await service.GetAllCountAsync();
Assert.Equal(1, actual);
}
public void Delete_WithData_DeletesGuide()
{
var options = new DbContextOptionsBuilder <GameInfoContext>()
.UseInMemoryDatabase(databaseName: "Db_WithGuides_ForDelete")
.Options;
using (var context = new GameInfoContext(options))
{
context.Guides.Add(new Guide()
{
Title = "ToDelete", Content = "None"
});
context.SaveChanges();
}
using (var context = new GameInfoContext(options))
{
var service = new GuidesService(context);
var result = service.Delete(1);
Assert.True(result);
Assert.Equal(0, context.Guides.Count());
}
}
public async Task GetAllForAdminShouldGetFive()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString());
var context = new ApplicationDbContext(options.Options);
await context.Users.AddAsync(new ApplicationUser()
{
Id = "1"
});
await context.Games.AddAsync(new Game()
{
Id = "1"
});
var repository = new EfDeletableEntityRepository <Guide>(context);
var service = new GuidesService(repository);
var models = new List <CreateGuideInputModel>()
{
new CreateGuideInputModel()
{
Title = "new",
GameId = "1",
Category = "Action",
Description = "test",
ImageUrl = "google",
},
new CreateGuideInputModel()
{
Title = "new2",
GameId = "1",
Category = "Action",
Description = "test2",
ImageUrl = "google2",
},
new CreateGuideInputModel()
{
Title = "new3",
GameId = "1",
Category = "Action",
Description = "test3",
ImageUrl = "google3",
},
new CreateGuideInputModel()
{
Title = "new4",
GameId = "1",
Category = "Action",
Description = "test4",
ImageUrl = "google4",
},
new CreateGuideInputModel()
{
Title = "new5",
GameId = "1",
Category = "Action",
Description = "test5",
ImageUrl = "google5",
},
new CreateGuideInputModel()
{
Title = "new6",
GameId = "1",
Category = "Action",
Description = "test6",
ImageUrl = "google6",
},
};
foreach (var model in models)
{
await service.CreateAsync(model, "1");
}
var actual = await service.GetAllForAdminAsync <GuideViewModel>(5, 0);
Assert.Equal(5, actual.Count());
}
public async Task SearchGuideShouldTakeFive()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString());
var context = new ApplicationDbContext(options.Options);
await context.Users.AddAsync(new ApplicationUser()
{
Id = "1"
});
await context.Games.AddAsync(new Game()
{
Id = "1"
});
var postRepository = new EfDeletableEntityRepository <Post>(context);
var guideRepository = new EfDeletableEntityRepository <Guide>(context);
var searchBarService = new SearchBarService(postRepository, guideRepository);
var guideService = new GuidesService(guideRepository);
var guideModels = new List <CreateGuideInputModel>()
{
new CreateGuideInputModel()
{
Title = "new",
Category = "Action",
Description = "test",
GameId = "1",
ImageUrl = "google",
},
new CreateGuideInputModel()
{
Title = "new",
Category = "Action",
Description = "test1",
ImageUrl = "google",
GameId = "1",
},
new CreateGuideInputModel()
{
Title = "testttt",
Category = "Action",
Description = "new",
ImageUrl = "google",
GameId = "1",
},
new CreateGuideInputModel()
{
Title = "new",
Category = "Action",
Description = "test5",
ImageUrl = "google",
GameId = "1",
},
new CreateGuideInputModel()
{
Title = "new",
Category = "Action",
Description = "test7",
ImageUrl = "google",
GameId = "1",
},
new CreateGuideInputModel()
{
Title = "newtest3",
Category = "Action",
Description = "eee",
ImageUrl = "google",
GameId = "1",
},
};
foreach (var guideModel in guideModels)
{
await guideService.CreateAsync(guideModel, "1");
}
var actual = await searchBarService.SearchGuide <GuideViewModel>("test", 5, 0);
Assert.Equal(5, actual.Count());
}
public async Task GetCountBySearchShouldGetFour()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString());
var context = new ApplicationDbContext(options.Options);
await context.Users.AddAsync(new ApplicationUser()
{
Id = "1"
});
await context.Games.AddAsync(new Game()
{
Id = "1"
});
var repository = new EfDeletableEntityRepository <Guide>(context);
var service = new GuidesService(repository);
var models = new List <CreateGuideInputModel>()
{
new CreateGuideInputModel()
{
Title = "new",
GameId = "1",
Category = "Action",
Description = "test",
ImageUrl = "google",
},
new CreateGuideInputModel()
{
Title = "new2",
GameId = "1",
Category = "Action",
Description = "test2",
ImageUrl = "google2",
},
new CreateGuideInputModel()
{
Title = "new3",
GameId = "1",
Category = "Mmo",
Description = "test3",
ImageUrl = "google3",
},
};
foreach (var model in models)
{
await service.CreateAsync(model, "1");
}
var lastModel = new CreateGuideInputModel()
{
Title = "teeest",
GameId = "1",
Category = "Mmo",
Description = "newwwwwwww",
ImageUrl = "google4",
};
await service.CreateAsync(lastModel, "2");
var actual = await service.GetCountBySearchAsync("new");
Assert.Equal(4, actual);
}
