public void Add_ShouldThrowArgumentNullExceptionWhenNullTagProvided()
{
var data = new FakeGalleryData();
var tagsService = new TagsService(data);
tagsService.Add(null);
}
public TagImageDialogVM(
TagsService tagsService,
ProjectService projectService)
{
TagsService = tagsService;
ProjectService = projectService;
TagsExist = TagsService.Tags.Count > 0;
}
/// <summary>
///
/// </summary>
/// <param name="logger"></param>
/// <param name="tagsService"></param>
public FindTagHandler(
ILogger <FindTagHandler> logger,
TagsService tagsService
)
{
_logger = logger;
_tagsService = tagsService;
}
public void GetById_ShouldReturnZeroWhenSuchTagIdIsNotFound()
{
var data = new FakeGalleryData();
var tagsService = new TagsService(data);
var foundTags = tagsService.GetById(GlobalConstants.DefaultTagIdForTesting);
Assert.AreEqual(0, foundTags.Count());
}
public NotesController(NotesService notesService, TagsService tagsService,
IAuthorizationService authorizationService, IMapper mapper, ILogger <NotesController> logger)
{
_notesService = notesService;
_tagsService = tagsService;
_authorizationService = authorizationService;
_mapper = mapper;
_logger = logger;
}
private static void AddTagsToProperty(RealEstatesDbContext context)
{
Console.WriteLine("Adding tags to properties started!");
IPropertiesService propertiesService = new PropertiesService(context);
ITagsService tagsService = new TagsService(context, propertiesService);
tagsService.BulkAddTagsToProperty();
Console.WriteLine("Adding tags to properties finished!");
}
public void Delete_ShouldReturnProperValueWhenTagIdDoesNotExist()
{
var data = new FakeGalleryData();
var tagsService = new TagsService(data);
var deletedTagId = tagsService.DeleteTagById(GlobalConstants.DefaultTagIdForTesting);
Assert.AreEqual(-1, deletedTagId);
}
private static void BulkTagsToProperties(RealEstatesDbContext context)
{
Console.WriteLine("Bulk operation started...");
var propertyService = new PropertiesService(context);
var service = new TagsService(context, propertyService);
service.BulkTagToProperties();
Console.WriteLine("Bulk operation finished successfully!");
}
public TagsServiceTests()
{
this.tagsList = new List <Tag>();
this.tagsRepo = new Mock <IRepository <Tag> >();
this.tagsRepo.Setup(x => x.All()).Returns(this.tagsList.AsQueryable());
this.tagsRepo.Setup(x => x.AddAsync(It.IsAny <Tag>())).Callback((Tag tag) => this.tagsList.Add(tag));
this.tagsService = new TagsService(this.tagsRepo.Object);
}
public void Delete_ShouldReturnProperValueWhenTagIdDoesNotExist()
{
var data = new FakeGalleryData();
var tagsService = new TagsService(data);
var deletedTagId = tagsService.DeleteTagById(GlobalConstants.DefaultTagIdForTesting);
Assert.AreEqual(-1, deletedTagId);
}
public HomeController(NotesService notesService, FilesService filesService, TagsService tagsService,
IAuthorizationService authorizationService, ILogger <HomeController> logger)
{
_notesService = notesService;
_filesService = filesService;
_tagsService = tagsService;
_authorizationService = authorizationService;
_logger = logger;
}
public FindTagCommand(
ILogger <FindTagCommand> logger,
TelegramService telegramService,
TagsService tagsService
)
{
_logger = logger;
_tagsService = tagsService;
_telegramService = telegramService;
}
public HomeController(ILogger <HomeController> logger,
UserManager <Usuarios> userManager,
MovimentacaoService movimentacaoService,
TagsService tagsService)
{
_userManager = userManager;
_movimentacaoService = movimentacaoService;
_tagsService = tagsService;
_logger = logger;
}
public void AddTags_NoTagInDb_AddTag()
{
var init = new InitializeMockContext();
var mock = init.mock;
var controller = new TagsService(mock.Object);
controller.GetOrAddTag("Yellow", mock.Object);
init.mockSetTags.Verify(m => m.Add(It.IsAny <Tags>()), Times.Once());
mock.Verify(m => m.SaveChanges(), Times.Once());
}
private static void BulkTagToProperties(ApplicationDbContext db)
{
Console.WriteLine("Bulk operation started!");
IPropertiesService propertiesService = new PropertiesService(db);
ITagsService tagsService = new TagsService(db, propertiesService);
tagsService.BulkTagToProperties();
Console.WriteLine("Bulk operation finished!");
}
public async Task GetAllTagsAsync_WithoutTags_ReturnsEmptyCollection()
{
// Arrange
var context = this.NewInMemoryDatabase();
var tagsService = new TagsService(context);
// Act
var actualResult = await tagsService.GetAllTagsAsync();
// Assert
Assert.Empty(actualResult);
}
public async Task GetTagsCountMethodShouldReturnZeroIfThereArentAnyTags()
{
var options = new DbContextOptionsBuilder <AlexandriaDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
var db = new AlexandriaDbContext(options);
var tagsService = new TagsService(db);
Assert.Equal(0, await tagsService.GetTagsCountAsync());
}
public void GetPostTags_ValidPostId_Test()
{
var init = new InitializeMockContext();
var mock = init.mock;
var postId = 1;
var tagsService = new TagsService(mock.Object);
var result = tagsService.GetTags(postId).Count;
var expected = 2;
Assert.AreEqual(expected, result);
}
public TagsServiceTest()
{
this.tagsRepo = new Mock <IDeletableEntityRepository <Tag> >();
this.gameTagsRepo = new Mock <IRepository <GameTag> >();
this.tagsList = new List <Tag>();
this.service = new TagsService(this.tagsRepo.Object, this.gameTagsRepo.Object);
this.tagsRepo.Setup(x => x.AllAsNoTracking()).Returns(this.tagsList.AsQueryable());
this.tagsRepo.Setup(x => x.AddAsync(It.IsAny <Tag>())).Callback(
(Tag item) => this.tagsList.Add(item));
}
private void InitTestServices()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString());
ApplicationDbContext dbContext = new ApplicationDbContext(options.Options);
this.tagRepository = new EfDeletableEntityRepository <Tag>(dbContext);
this.tagService = new TagsService(
this.tagRepository);
}
public async Task CreateMethodShoudAddTagInDatabase()
{
var options = new DbContextOptionsBuilder <AlexandriaDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString());
var db = new AlexandriaDbContext(options.Options);
var tagsService = new TagsService(db);
await tagsService.CreateTagAsync("test");
Assert.Equal(1, await db.Tags.CountAsync());
}
public void GetById_ShouldReturnProperAmountOfTags()
{
var data = new FakeGalleryData();
var tagsService = new TagsService(data);
var newTag = new Tag();
var tagId = newTag.Id;
tagsService.Add(newTag);
var foundTags = tagsService.GetById(tagId);
Assert.AreEqual(1, foundTags.Count());
}
private static void AddTag(RealEstatesDbContext context)
{
Console.WriteLine("Tag name:");
string tagName = Console.ReadLine();
Console.WriteLine("Importance (optional):");
int importance = int.Parse(Console.ReadLine());
IPropertiesService propertiesService = new PropertiesService(context);
ITagsService tagsService = new TagsService(context, propertiesService);
tagsService.Add(tagName, importance);
}
public void GetById_ShouldReturnProperAmountOfTags()
{
var data = new FakeGalleryData();
var tagsService = new TagsService(data);
var newTag = new Tag();
var tagId = newTag.Id;
tagsService.Add(newTag);
var foundTags = tagsService.GetById(tagId);
Assert.AreEqual(1, foundTags.Count());
}
private static void AddTag(ApplicationDbContext db)
{
Console.WriteLine("Tag name:");
string tagName = Console.ReadLine();
Console.WriteLine("Importance:");
int tagImportance = int.Parse(Console.ReadLine());
IPropertiesService propertiesService = new PropertiesService(db);
ITagsService tagsService = new TagsService(db, propertiesService);
tagsService.Add(tagName, tagImportance);
}
public async Task GetAllMethodShouldWorkCorrectWithSearch()
{
var options = new DbContextOptionsBuilder <ForumDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
var db = new ForumDbContext(options);
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap <Tag, Tag>();
});
var mapper = config.CreateMapper();
var dateTimeProvider = new Mock <IDateTimeProvider>();
dateTimeProvider.Setup(dtp => dtp.Now()).Returns(new DateTime(2020, 3, 27));
var tags = new List <Tag>
{
new Tag {
Name = "Tag", CreatedOn = dateTimeProvider.Object.Now()
},
new Tag {
Name = "Test 1", CreatedOn = dateTimeProvider.Object.Now()
},
new Tag {
Name = "Test 2", CreatedOn = dateTimeProvider.Object.Now()
}
};
await db.Tags.AddRangeAsync(tags);
await db.SaveChangesAsync();
var expected = new List <Tag>
{
new Tag {
Id = 2, Name = "Test 1", CreatedOn = dateTimeProvider.Object.Now()
},
new Tag {
Id = 3, Name = "Test 2", CreatedOn = dateTimeProvider.Object.Now()
}
};
var tagsService = new TagsService(db, mapper, dateTimeProvider.Object);
var actual = await tagsService.GetAllAsync <Tag>("Test");
actual.Should().BeEquivalentTo(expected);
}
private void InitTestServices()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString());
ApplicationDbContext dbContext = new ApplicationDbContext(options.Options);
this.imageRepository = new EfDeletableEntityRepository <Image>(dbContext);
var tagRepository = new EfDeletableEntityRepository <Tag>(dbContext);
this.tagService = new TagsService(tagRepository);
this.imageCategoryRepository = new EfDeletableEntityRepository <ImageCategory>(dbContext);
var tempCloudImageRepository = new EfRepository <TempCloudImage>(dbContext);
this.tempCloudImageService = new TempCloudImagesService(tempCloudImageRepository);
this.voteRepository = new EfRepository <Vote>(dbContext);
var userSubscribeRepository = new EfDeletableEntityRepository <UserSubscribe>(dbContext);
this.imageTagRepository = new EfDeletableEntityRepository <ImageTag>(dbContext);
this.userRepository = new EfDeletableEntityRepository <ApplicationUser>(dbContext);
var categoryRepository = new EfDeletableEntityRepository <Category>(dbContext);
var loggerCategory = Mock.Of <ILogger <CategoriesService> >();
this.categoriesService = new CategoriesService(
loggerCategory,
categoryRepository,
this.voteRepository,
this.imageRepository,
this.imageCategoryRepository);
var logger = Mock.Of <ILogger <ImagesService> >();
this.imagesService = new ImagesService(
logger,
this.imageRepository,
this.voteRepository,
userSubscribeRepository,
this.imageTagRepository,
tagRepository,
this.imageCategoryRepository,
this.userRepository,
this.categoriesService,
this.tagService,
this.tempCloudImageService);
}
public void AddTags_TagInDb_AddTag()
{
var init = new InitializeMockContext();
var mock = init.mock;
var controller = new TagsService(mock.Object);
var tagBanan = controller.GetOrAddTag("banan", mock.Object);
mock.Verify(m => m.SaveChanges(), Times.Never());
init.mockSetTags.Verify(m => m.Add(It.IsAny <Tags>()), Times.Never());
var expected = 1;
Assert.AreEqual(1, tagBanan.Count);
}
public void GetAllTagsAsKeyValuePairShouldReturnZeroWhenEmpty()
{
var list = new List <Tag>();
var repository = new Mock <IDeletableEntityRepository <Tag> >();
repository.Setup(r => r.AllAsNoTracking()).Returns(() => list.AsQueryable());
var service = new TagsService(repository.Object);
var tags = service.GetAllTagsAsKeyValuePair();
Assert.Empty(tags);
repository.Verify(x => x.AllAsNoTracking(), Times.Once);
}
public void Delete_ShouldReturnProperDeletedTagId()
{
var data = new FakeGalleryData();
var tagsService = new TagsService(data);
var newTag = new Tag();
var tagId = newTag.Id;
tagsService.Add(newTag);
tagsService.DeleteTagById(tagId);
var foundTags = tagsService.GetById(tagId);
Assert.AreEqual(0, foundTags.Count());
}
public void Delete_ShouldReturnProperDeletedTagId()
{
var data = new FakeGalleryData();
var tagsService = new TagsService(data);
var newTag = new Tag();
var tagId = newTag.Id;
tagsService.Add(newTag);
tagsService.DeleteTagById(tagId);
var foundTags = tagsService.GetById(tagId);
Assert.AreEqual(0, foundTags.Count());
}
public async Task CreateMethodShouldAddTheCorrectTagInDatabase()
{
var options = new DbContextOptionsBuilder <AlexandriaDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
var db = new AlexandriaDbContext(options);
var tagsService = new TagsService(db);
await tagsService.CreateTagAsync("test");
var result = await db.Tags.FirstOrDefaultAsync();
Assert.Equal("test", result.Name);
}
private static void AddTag(RealEstatesDbContext context)
{
Console.Write("Tag name:");
var name = Console.ReadLine();
Console.Write("Importance (optional):");
var parsed = int.TryParse(Console.ReadLine(), out var importance);
var propertyService = new PropertiesService(context);
var service = new TagsService(context, propertyService);
var tagImportance = parsed ? importance : (int?)null;
service.Add(name, tagImportance);
}
public IssueTagsServiceTests()
{
this.issueTagsList = new List <IssueTag>();
this.issueTagsRepo = new Mock <IRepository <IssueTag> >();
this.issueTagsRepo.Setup(x => x.All()).Returns(this.issueTagsList.AsQueryable());
this.issueTagsRepo.Setup(x => x.AddAsync(It.IsAny <IssueTag>())).Callback((IssueTag issueTag) => this.issueTagsList.Add(issueTag));
this.tagsList = new List <Tag>();
this.tagsRepo = new Mock <IRepository <Tag> >();
this.tagsRepo.Setup(x => x.All()).Returns(this.tagsList.AsQueryable());
this.tagsRepo.Setup(x => x.AddAsync(It.IsAny <Tag>())).Callback((Tag tag) => this.tagsList.Add(tag));
this.tagsService = new TagsService(this.tagsRepo.Object);
this.issueTagsService = new IssueTagsService(this.issueTagsRepo.Object, new StringOperationsServices(), this.tagsService);
}
public void GetById_ShouldReturnZeroWhenSuchTagIdIsNotFound()
{
var data = new FakeGalleryData();
var tagsService = new TagsService(data);
var foundTags = tagsService.GetById(GlobalConstants.DefaultTagIdForTesting);
Assert.AreEqual(0, foundTags.Count());
}
