public async Task AddCreationModelWhenNoMatchingSuggestion()
{
var workspace = createWorkspace(13, "Some workspace");
var tagSuggestions = getTagSuggestions(10, workspace);
InteractorFactory.GetTagsAutocompleteSuggestions(Arg.Any <IList <string> >())
.Execute()
.Returns(Observable.Return(tagSuggestions));
InteractorFactory.GetWorkspaceById(workspace.Id).Execute()
.Returns(Observable.Return(workspace));
var tagIds = tagSuggestions.Select(tag => tag.TagId).ToArray();
var nonExistingTag = "Non existing tag";
ViewModel.Prepare((tagIds, workspace.Id));
await ViewModel.Initialize();
var observer = TestScheduler.CreateObserver <IEnumerable <SelectableTagBaseViewModel> >();
ViewModel.Tags.Subscribe(observer);
ViewModel.FilterText.OnNext(nonExistingTag);
TestScheduler.Start();
observer.LastEmittedValue().First().Name.Should().Be(nonExistingTag);
observer.LastEmittedValue().First().WorkspaceId.Should().Be(workspace.Id);
observer.LastEmittedValue().First().Selected.Should().BeFalse();
observer.LastEmittedValue().First().Should().BeOfType <SelectableTagCreationViewModel>();
}
public async Task OnlyContainsTagsFromTheSameWorkspaceAsTimeEntry()
{
var tags = new List <TagSuggestion>();
var workspaces = Enumerable.Range(0, 5)
.Select(i => createWorkspace(i, $"Workspace{i}")).ToArray();
workspaces.ForEach(workspace
=> tags.AddRange(getTagSuggestions(5, workspace)));
InteractorFactory.GetTagsAutocompleteSuggestions(Arg.Any <IList <string> >())
.Execute()
.Returns(Observable.Return(tags));
var targetWorkspace = workspaces[1];
InteractorFactory.GetWorkspaceById(targetWorkspace.Id).Execute()
.Returns(Observable.Return(targetWorkspace));
var tagIds = tags.Select(tag => tag.TagId).ToArray();
ViewModel.Prepare((tagIds, targetWorkspace.Id));
await ViewModel.Initialize();
var observer = TestScheduler.CreateObserver <IEnumerable <SelectableTagBaseViewModel> >();
ViewModel.Tags.Subscribe(observer);
TestScheduler.Start();
observer.LastEmittedValue().Should().HaveCount(5);
observer.LastEmittedValue().Should()
.OnlyContain(tag => tag.WorkspaceId == targetWorkspace.Id);
}
public async Task IsUpdatedWhenTextIsChanged()
{
var workspace = createWorkspace(13, "Some workspace");
var oldSuggestions = getTagSuggestions(3, workspace);
var newSuggestions = getTagSuggestions(1, workspace);
var oldTagIds = oldSuggestions.Select(tag => tag.TagId).ToArray();
var queryText = "Query text";
InteractorFactory.GetTagsAutocompleteSuggestions(
Arg.Is <IList <string> >(words => words.SequenceEqual(queryText.SplitToQueryWords())))
.Execute()
.Returns(Observable.Return(newSuggestions));
InteractorFactory.GetWorkspaceById(workspace.Id).Execute()
.Returns(Observable.Return(workspace));
ViewModel.Prepare((oldTagIds, workspace.Id));
await ViewModel.Initialize();
var observer = TestScheduler.CreateObserver <IEnumerable <SelectableTagBaseViewModel> >();
ViewModel.Tags.Subscribe(observer);
ViewModel.FilterText.OnNext(queryText);
TestScheduler.Start();
var received = observer.LastEmittedValue();
received.Should().HaveCount(2);
}
public void PrependsTheNewTagToTheTagList()
{
var tagName = "Some Tag";
long workspaceId = 123;
var initialTags = CreateTags(count: 10);
InteractorFactory
.GetTagsAutocompleteSuggestions(Arg.Any <IList <string> >())
.Execute()
.Returns(Observable.Return(initialTags));
var createdTag = CreateTagSubstitute(0, tagName);
createdTag.WorkspaceId.Returns(workspaceId);
DataSource.Tags.Create(Arg.Is(tagName), Arg.Any <long>())
.Returns(Observable.Return(createdTag));
ViewModel.Prepare((new long[0], workspaceId));
ViewModel.Initialize().Wait();
//Reconfigure AutocopleteProvider, so it returns the created tag as well
var createdTagSuggestion = new TagSuggestion(createdTag);
var newTagSuggestions = initialTags
.Concat(new AutocompleteSuggestion[] { createdTagSuggestion });
var observable = Observable
.Return(newTagSuggestions);
InteractorFactory
.GetTagsAutocompleteSuggestions(Arg.Any <IList <string> >())
.Execute()
.Returns(observable);
ViewModel.Text = tagName;
ViewModel.CreateTagCommand.ExecuteAsync(tagName).Wait();
ViewModel.Tags.First().Name.Should().Be(tagName);
}
public async Task ReturnsFalseIfTagIsCreated()
{
InteractorFactory
.GetTagsAutocompleteSuggestions(Arg.Any <IList <string> >())
.Execute()
.Returns(Observable.Return(new List <AutocompleteSuggestion>()));
var newTag = Substitute.For <IThreadSafeTag>();
newTag.Id.Returns(12345);
newTag.WorkspaceId.Returns(workspaceId);
newTag.Name.Returns("new tag");
ViewModel.Prepare((new long[] { }, workspaceId));
var observer = TestScheduler.CreateObserver <bool>();
await ViewModel.Initialize();
ViewModel.IsEmpty.Subscribe(observer);
InteractorFactory
.GetTagsAutocompleteSuggestions(Arg.Any <IList <string> >())
.Execute()
.Returns(Observable.Return(TagSuggestion.FromTags(new List <IThreadSafeTag> {
newTag
})));
ViewModel.FilterText.OnNext(string.Empty);
TestScheduler.Start();
observer.LastEmittedValue().Should().BeFalse();
}
public async Task IsSortedBySelectedStatusThenByName()
{
var workspace = createWorkspace(13, "Some workspace");
var tagSuggestions = getTagSuggestions(4, workspace).ToArray();
var shuffledTags = new[] { tagSuggestions[3], tagSuggestions[1], tagSuggestions[2], tagSuggestions[0] };
var selectedTagIds = new[] { tagSuggestions[0].TagId, tagSuggestions[2].TagId };
InteractorFactory.GetTagsAutocompleteSuggestions(Arg.Any <IList <string> >())
.Execute()
.Returns(Observable.Return(shuffledTags));
InteractorFactory.GetWorkspaceById(workspace.Id).Execute()
.Returns(Observable.Return(workspace));
ViewModel.Prepare((selectedTagIds, workspace.Id));
await ViewModel.Initialize();
ViewModel.Tags.Should().HaveCount(4);
ViewModel.Tags[0].Name.Should().Be("Tag0");
ViewModel.Tags[1].Name.Should().Be("Tag2");
ViewModel.Tags[2].Name.Should().Be("Tag1");
ViewModel.Tags[3].Name.Should().Be("Tag3");
ViewModel.Tags[0].Selected.Should().BeTrue();
ViewModel.Tags[1].Selected.Should().BeTrue();
ViewModel.Tags[2].Selected.Should().BeFalse();
ViewModel.Tags[3].Selected.Should().BeFalse();
}
public async Task IsFalseWhenSuchTagAlreadyExists(string text)
{
var tags = CreateTags(10);
InteractorFactory
.GetTagsAutocompleteSuggestions(Arg.Any <IList <string> >())
.Execute()
.Returns(Observable.Return(tags));
ViewModel.Prepare((new long[0], 0));
await ViewModel.Initialize();
ViewModel.Text = text;
ViewModel.SuggestCreation.Should().BeFalse();
}
public async Task IsPopulatedAfterInitialization()
{
var workspace = createWorkspace(13, "Some workspace");
var tagSuggestions = getTagSuggestions(10, workspace);
var tagIds = tagSuggestions.Select(tag => tag.TagId).ToArray();
InteractorFactory.GetTagsAutocompleteSuggestions(Arg.Any <IList <string> >())
.Execute()
.Returns(Observable.Return(tagSuggestions));
InteractorFactory.GetWorkspaceById(workspace.Id).Execute()
.Returns(Observable.Return(workspace));
ViewModel.Prepare((tagIds, workspace.Id));
await ViewModel.Initialize();
ViewModel.Tags.Should().HaveCount(tagSuggestions.Count());
}
private void setup(Func <long, long> workspaceIdSelector)
{
var tags = Enumerable.Range(0, 10)
.Select(i =>
{
var tag = Substitute.For <IThreadSafeTag>();
tag.Name.Returns(Guid.NewGuid().ToString());
tag.Id.Returns(i);
tag.WorkspaceId.Returns(workspaceIdSelector(i));
return(tag);
})
.ToList();
InteractorFactory
.GetTagsAutocompleteSuggestions(Arg.Any <IList <string> >())
.Execute()
.Returns(Observable.Return(TagSuggestion.FromTags(tags)));
}
public async Task IsClearedWhenTextIsChanged()
{
var workspace = createWorkspace(13, "Some workspace");
var oldSuggestions = getTagSuggestions(3, workspace);
var newSuggestions = getTagSuggestions(1, workspace);
var oldTagIds = oldSuggestions.Select(tag => tag.TagId).ToArray();
var queryText = "Query text";
InteractorFactory.GetTagsAutocompleteSuggestions(
Arg.Is <IList <string> >(words => words.SequenceEqual(queryText.SplitToQueryWords())))
.Execute()
.Returns(Observable.Return(newSuggestions));
InteractorFactory.GetWorkspaceById(workspace.Id).Execute()
.Returns(Observable.Return(workspace));
ViewModel.Prepare((oldTagIds, workspace.Id));
await ViewModel.Initialize();
ViewModel.Text = queryText;
ViewModel.Tags.Should().HaveCount(1);
}
public async Task IsPopulatedAfterInitialization()
{
var workspace = createWorkspace(13, "Some workspace");
var tagSuggestions = getTagSuggestions(10, workspace);
var tagIds = tagSuggestions.Select(tag => tag.TagId).ToArray();
InteractorFactory.GetTagsAutocompleteSuggestions(Arg.Any <IList <string> >())
.Execute()
.Returns(Observable.Return(tagSuggestions));
InteractorFactory.GetWorkspaceById(workspace.Id).Execute()
.Returns(Observable.Return(workspace));
await ViewModel.Initialize(new SelectTagsParameter(tagIds, workspace.Id));
var observer = TestScheduler.CreateObserver <IEnumerable <SelectableTagBaseViewModel> >();
ViewModel.Tags.Subscribe(observer);
TestScheduler.Start();
observer.LastEmittedValue().Should().HaveCount(tagSuggestions.Count());
}
private async Task prepare(long tagId, long workspaceId)
{
ViewModel.Prepare((new long[0], workspaceId));
await ViewModel.Initialize();
var createdTag = Substitute.For <IThreadSafeTag>();
createdTag.Id.Returns(tagId);
createdTag.WorkspaceId.Returns(workspaceId);
DataSource
.Tags
.Create(Arg.Any <string>(), Arg.Any <long>())
.Returns(Observable.Return(createdTag));
var observable = Observable
.Return(new AutocompleteSuggestion[] { new TagSuggestion(createdTag) });
InteractorFactory
.GetTagsAutocompleteSuggestions(Arg.Any <IList <string> >())
.Execute()
.Returns(observable);
}
public async Task IsFalseWhenSuchTagAlreadyExists(string text)
{
var textTags = new List <(long, string)> {
(1, "t"), (2, "p"), (3, "Text"), (4, "te")
};
var tags = textTags
.AsEnumerable()
.Select(tuple => CreateTagSubstitute(tuple.Item1, tuple.Item2))
.Select(tag => new TagSuggestion(tag));
InteractorFactory
.GetTagsAutocompleteSuggestions(Arg.Any <IList <string> >())
.Execute()
.Returns(Observable.Return(tags));
ViewModel.Prepare((new long[0], 0));
await ViewModel.Initialize();
ViewModel.Text = text;
ViewModel.SuggestCreation.Should().BeFalse();
}
public async Task IsSortedBySelectedStatusThenByName()
{
var workspace = createWorkspace(13, "Some workspace");
var tagSuggestions = getTagSuggestions(4, workspace).ToArray();
var shuffledTags = new[] { tagSuggestions[3], tagSuggestions[1], tagSuggestions[2], tagSuggestions[0] };
var selectedTagIds = new[] { tagSuggestions[0].TagId, tagSuggestions[2].TagId };
InteractorFactory.GetTagsAutocompleteSuggestions(Arg.Any <IList <string> >())
.Execute()
.Returns(Observable.Return(shuffledTags));
InteractorFactory.GetWorkspaceById(workspace.Id).Execute()
.Returns(Observable.Return(workspace));
await ViewModel.Initialize(new SelectTagsParameter(selectedTagIds, workspace.Id));
var observer = TestScheduler.CreateObserver <IEnumerable <SelectableTagBaseViewModel> >();
ViewModel.Tags.Subscribe(observer);
TestScheduler.Start();
var tags = observer.LastEmittedValue().ToArray();
tags.Should().HaveCount(4);
tags[0].Name.Should().Be("Tag0");
tags[1].Name.Should().Be("Tag2");
tags[2].Name.Should().Be("Tag1");
tags[3].Name.Should().Be("Tag3");
tags[0].Selected.Should().BeTrue();
tags[1].Selected.Should().BeTrue();
tags[2].Selected.Should().BeFalse();
tags[3].Selected.Should().BeFalse();
}
