public void WhenModelIsUpdatedTheViewModelIsUpdatedToo()
{
var item = new Item();
var offlineTaskService = A.Fake <IOfflineTaskService>();
var navigation = A.Fake <INavigationService>();
var logging = A.Fake <ILoggingService>();
var device = A.Fake <IPlatformSpecific>();
var database = TestsHelper.CreateFakeDatabase();
var viewModel = new ItemViewModel(item,
offlineTaskService,
navigation,
logging,
device,
database);
bool eventWasFired = false;
viewModel.PropertyChanged += (s, e) =>
{
eventWasFired = true;
Assert.True(e.PropertyName == nameof(ItemViewModel.Model));
};
viewModel.RaisePropertyChanged(nameof(viewModel.Model));
Assert.True(eventWasFired);
}
public async Task ArticleWithEmptyContentShouldFailWithoutAnInternetConnection()
{
var offlineTaskService = A.Fake <IOfflineTaskService>();
var loggingService = A.Fake <ILoggingService>();
var platform = A.Fake <IPlatformSpecific>();
var navigationService = A.Fake <INavigationService>();
var client = A.Fake <IWallabagClient>();
var database = TestsHelper.CreateFakeDatabase();
// Insert a sample item without content to the database
var item = new Item()
{
Id = 1,
Content = string.Empty
};
database.Insert(item);
// If the ViewModel asks for an internet connection, return false
A.CallTo(() => platform.InternetConnectionIsAvailable).Returns(false);
var viewModel = new ItemPageViewModel(offlineTaskService, loggingService, platform, navigationService, client, database);
await viewModel.ActivateAsync(item.Id, new Dictionary <string, object>(), Data.Common.NavigationMode.New);
A.CallTo(() => platform.InternetConnectionIsAvailable).MustHaveHappened();
A.CallTo(() => client.GetItemAsync(A <int> .That.IsEqualTo(1), A <CancellationToken> .Ignored)).MustNotHaveHappened();
A.CallTo(() => platform.GetArticleTemplateAsync()).MustNotHaveHappened();
Assert.True(viewModel.ErrorDuringInitialization);
Assert.True(string.IsNullOrEmpty(viewModel?.FormattedHtml));
}
public void AddingATagToMultipleItemsAddsThemUsingTheOfflineTaskService()
{
var offlineTaskService = A.Fake <IOfflineTaskService>();
var loggingService = A.Fake <ILoggingService>();
var database = TestsHelper.CreateFakeDatabase();
var navigationService = A.Fake <INavigationService>();
var viewModel = new EditTagsViewModel(offlineTaskService, loggingService, database, navigationService)
{
Items = new List <Item>()
{
new Item()
{
Id = 1, Title = "First test"
},
new Item()
{
Id = 2, Title = "Second test"
},
}
};
viewModel.Tags.Add(new Tag()
{
Id = 1, Label = "test"
});
viewModel.FinishCommand.Execute(null);
A.CallTo(() => offlineTaskService.AddAsync(A <int> .Ignored, OfflineTask.OfflineTaskAction.EditTags, A <List <Tag> > .Ignored, A <List <Tag> > .Ignored)).MustHaveHappened(Repeated.Exactly.Twice);
}
public async Task AddingOneItemWithTagsDoesAddThemToTheCurrentTagList()
{
var offlineTaskService = A.Fake <IOfflineTaskService>();
var loggingService = A.Fake <ILoggingService>();
var database = TestsHelper.CreateFakeDatabase();
var navigationService = A.Fake <INavigationService>();
var item = new Item()
{
Id = 1,
Tags = new System.Collections.ObjectModel.ObservableCollection <Tag>()
{
new Tag()
{
Id = 1, Label = "test"
},
new Tag()
{
Id = 2, Label = "test"
},
new Tag()
{
Id = 3, Label = "test"
},
}
};
database.Insert(item);
var viewModel = new EditTagsViewModel(offlineTaskService, loggingService, database, navigationService);
await viewModel.ActivateAsync(item.Id, new Dictionary <string, object>(), Data.Common.NavigationMode.New);
Assert.Equal(3, viewModel.Tags.Count);
Assert.False(viewModel.TagsCountIsZero);
}
public async Task ExecutingAnAddItemOfflineTaskReplacesTheItemIdOfTheTask()
{
var client = A.Fake <IWallabagClient>();
var platform = A.Fake <IPlatformSpecific>();
var loggingService = A.Fake <ILoggingService>();
var database = TestsHelper.CreateFakeDatabase();
var taskService = new OfflineTaskService(client, database, loggingService, platform);
A.CallTo(() => client.AddAsync(A <Uri> .Ignored, A <IEnumerable <string> > .Ignored, A <string> .Ignored, A <CancellationToken> .Ignored)).Returns(new WallabagItem()
{
Id = 123
});
A.CallTo(() => platform.InternetConnectionIsAvailable).Returns(true);
int itemId = 0;
taskService.TaskExecuted += (s, e) => itemId = e.Task.ItemId;
await taskService.ExecuteAsync(new OfflineTask()
{
Id = 0,
ItemId = 0,
Action = OfflineTask.OfflineTaskAction.AddItem,
Url = "https://test.de",
Tags = new List <string>()
});
Assert.Equal(123, itemId);
}
public void ExecutingTheChangeFavoriteStatusCommandChangesItemPropertiesCorrect()
{
var offlineTaskService = A.Fake <IOfflineTaskService>();
var loggingService = A.Fake <ILoggingService>();
var platform = A.Fake <IPlatformSpecific>();
var navigationService = A.Fake <INavigationService>();
var client = A.Fake <IWallabagClient>();
var database = TestsHelper.CreateFakeDatabase();
var item = new Item()
{
Id = 1,
Content = string.Empty,
IsStarred = false
};
var viewModel = new ItemPageViewModel(offlineTaskService, loggingService, platform, navigationService, client, database)
{
Item = new ItemViewModel(item, offlineTaskService, navigationService, loggingService, platform, database)
};
Assert.False(viewModel.Item.Model.IsStarred);
viewModel.ChangeFavoriteStatusCommand.Execute(null);
Assert.True(viewModel.Item.Model.IsStarred);
viewModel.ChangeFavoriteStatusCommand.Execute(null);
Assert.False(viewModel.Item.Model.IsStarred);
}
public void InvokingTheQueryUpdateUpdatesTheSuggestions()
{
var offlineTaskService = A.Fake <IOfflineTaskService>();
var loggingService = A.Fake <ILoggingService>();
var database = TestsHelper.CreateFakeDatabase();
var navigationService = A.Fake <INavigationService>();
//Fake some tags
var fakeTags = new List <Tag>();
for (int i = 0; i < 3; i++)
{
var tag = new Tag()
{
Label = $"{nameof(EditTagsViewModelTests)} fake tag {i}",
Id = i
};
fakeTags.Add(tag);
database.Insert(tag);
}
var viewModel = new EditTagsViewModel(offlineTaskService, loggingService, database, navigationService)
{
TagQuery = nameof(EditTagsViewModelTests)
};
viewModel.TagQueryChangedCommand.Execute(null);
Assert.Equal(3, viewModel.Suggestions.Count);
Assert.Contains(nameof(EditTagsViewModel), viewModel.Suggestions[0].Label);
}
public void EditingTheTagsNavigatesToProperPage()
{
var offlineTaskService = A.Fake <IOfflineTaskService>();
var loggingService = A.Fake <ILoggingService>();
var platform = A.Fake <IPlatformSpecific>();
var navigationService = A.Fake <INavigationService>();
var client = A.Fake <IWallabagClient>();
var database = TestsHelper.CreateFakeDatabase();
var item = new Item()
{
Id = 1,
Tags = new System.Collections.ObjectModel.ObservableCollection <Tag>()
{
new Tag()
{
Label = "test"
}
}
};
var viewModel = new ItemPageViewModel(offlineTaskService, loggingService, platform, navigationService, client, database)
{
Item = new ItemViewModel(item, offlineTaskService, navigationService, loggingService, platform, database)
};
viewModel.EditTagsCommand.Execute(null);
A.CallTo(() => navigationService.Navigate(A <Data.Common.Navigation.Pages> .That.IsEqualTo(Data.Common.Navigation.Pages.EditTagsPage), A <object> .Ignored)).MustHaveHappened();
}
public void AddingMultipleItemsWithTagsDoesntAddThemToTheCurrentTagList()
{
var offlineTaskService = A.Fake <IOfflineTaskService>();
var loggingService = A.Fake <ILoggingService>();
var database = TestsHelper.CreateFakeDatabase();
var navigationService = A.Fake <INavigationService>();
var viewModel = new EditTagsViewModel(offlineTaskService, loggingService, database, navigationService)
{
Items = new List <Item>()
{
new Item()
{
Id = 1, Title = "First test"
},
new Item()
{
Id = 2, Title = "Second test"
},
}
};
Assert.Equal(0, viewModel.Tags.Count);
Assert.True(viewModel.TagsCountIsZero);
}
public async Task ExecutingAQueueOfTasksActuallyExecutesEachOfThem()
{
var client = A.Fake <IWallabagClient>();
var platform = A.Fake <IPlatformSpecific>();
var loggingService = A.Fake <ILoggingService>();
var database = TestsHelper.CreateFakeDatabase();
A.CallTo(() => platform.InternetConnectionIsAvailable).Returns(false);
var taskService = new OfflineTaskService(client, database, loggingService, platform);
for (int i = 0; i < 10; i++)
{
await taskService.AddAsync($"https://test-{i}.de", Array.Empty <string>());
}
A.CallTo(() => platform.InternetConnectionIsAvailable).Returns(true);
A.CallTo(() => client.AddAsync(A <Uri> .Ignored, A <IEnumerable <string> > .Ignored, A <string> .Ignored, A <CancellationToken> .Ignored)).Returns(new WallabagItem()
{
Id = 1,
Title = "My fake item",
Url = "https://test.de",
Tags = new List <WallabagTag>()
});
await taskService.ExecuteAllAsync();
A.CallTo(() => client.AddAsync(A <Uri> .Ignored, A <IEnumerable <string> > .Ignored, A <string> .Ignored, A <CancellationToken> .Ignored)).MustHaveHappened(Repeated.Exactly.Times(10));
}
public void DeletingAnItemInvokesProperActions()
{
var item = new Item()
{
Id = 10
};
var offlineTaskService = A.Fake <IOfflineTaskService>();
var navigation = A.Fake <INavigationService>();
var logging = A.Fake <ILoggingService>();
var device = A.Fake <IPlatformSpecific>();
var database = TestsHelper.CreateFakeDatabase();
database.Insert(item);
var viewModel = new ItemViewModel(item,
offlineTaskService,
navigation,
logging,
device,
database);
viewModel.DeleteCommand.Execute(null);
A.CallTo(() => offlineTaskService.AddAsync(
10,
A <OfflineTask.OfflineTaskAction> .That.IsEqualTo(OfflineTask.OfflineTaskAction.Delete),
A <List <Tag> > .Ignored,
A <List <Tag> > .Ignored)).MustHaveHappened();
Assert.Null(database.Find <Item>(10));
}
public async Task ArticleWithEmptyContentIsReFetchedFromTheServerAndContinuesIfSuccessful()
{
var offlineTaskService = A.Fake <IOfflineTaskService>();
var loggingService = A.Fake <ILoggingService>();
var platform = A.Fake <IPlatformSpecific>();
var navigationService = A.Fake <INavigationService>();
var client = A.Fake <IWallabagClient>();
var database = TestsHelper.CreateFakeDatabase();
// Insert a sample item without content to the database
var item = new Item()
{
Id = 1,
Content = string.Empty
};
database.Insert(item);
// If the ViewModel asks for an internet connection, return true
A.CallTo(() => platform.InternetConnectionIsAvailable).Returns(true);
// This is our custom template to see if the formatting was fine
A.CallTo(() => platform.GetArticleTemplateAsync()).Returns("{{title}}");
// Return an item if asked for
A.CallTo(() => client.GetItemAsync(A <int> .That.IsEqualTo(1), A <CancellationToken> .Ignored)).Returns(new WallabagItem()
{
Id = 1,
Content = "This is my content.",
CreationDate = DateTime.Now,
DomainName = "test.de",
EstimatedReadingTime = 10,
IsRead = false,
IsStarred = false,
Language = "de-DE",
LastUpdated = DateTime.Now,
Mimetype = "text/html",
Title = "This is my title",
Url = "https://test.de"
});
var viewModel = new ItemPageViewModel(offlineTaskService, loggingService, platform, navigationService, client, database);
await viewModel.ActivateAsync(item.Id, new Dictionary <string, object>(), Data.Common.NavigationMode.New);
// Everything should be fine and our custom template should be applied
A.CallTo(() => platform.InternetConnectionIsAvailable).MustHaveHappened();
A.CallTo(() => client.GetItemAsync(A <int> .That.IsEqualTo(1), A <CancellationToken> .Ignored)).MustHaveHappened();
A.CallTo(() => platform.GetArticleTemplateAsync()).MustHaveHappened();
Assert.False(viewModel.ErrorDuringInitialization);
Assert.False(string.IsNullOrEmpty(viewModel.FormattedHtml));
Assert.Equal("This is my title", viewModel.FormattedHtml);
}
public void CancellingWillNavigateBack()
{
var offlineTaskService = A.Fake <IOfflineTaskService>();
var loggingService = A.Fake <ILoggingService>();
var database = TestsHelper.CreateFakeDatabase();
var navigationService = A.Fake <INavigationService>();
var viewModel = new AddItemViewModel(offlineTaskService, loggingService, database, navigationService);
viewModel.CancelCommand.Execute(null);
A.CallTo(() => navigationService.GoBack()).MustHaveHappened();
}
public async Task ExecutingAnOfflineTaskWithoutInternetConnectionDoesNotCallTheAPI()
{
var client = A.Fake <IWallabagClient>();
var platform = A.Fake <IPlatformSpecific>();
var loggingService = A.Fake <ILoggingService>();
var database = TestsHelper.CreateFakeDatabase();
A.CallTo(() => platform.InternetConnectionIsAvailable).Returns(false);
var taskService = new OfflineTaskService(client, database, loggingService, platform);
await taskService.AddAsync("http://test.de", new List <string>());
A.CallTo(() => client.AddAsync(A <Uri> .Ignored, A <IEnumerable <string> > .Ignored, A <string> .Ignored, A <CancellationToken> .Ignored)).MustNotHaveHappened();
}
public async Task AddingANewTaskForNewUrlFiresTheTaskAddedEvent()
{
var client = A.Fake <IWallabagClient>();
var platform = A.Fake <IPlatformSpecific>();
var loggingService = A.Fake <ILoggingService>();
var database = TestsHelper.CreateFakeDatabase();
var taskService = new OfflineTaskService(client, database, loggingService, platform);
await Assert.RaisesAsync <OfflineTaskAddedEventArgs>(
x => taskService.TaskAdded += x,
x => taskService.TaskAdded -= x,
() => taskService.AddAsync("https://test.de", Array.Empty <string>()));
}
public async Task AddingANewTaskForExistingArticleFiresTheTaskAddedEvent()
{
var client = A.Fake <IWallabagClient>();
var platform = A.Fake <IPlatformSpecific>();
var loggingService = A.Fake <ILoggingService>();
var database = TestsHelper.CreateFakeDatabase();
var taskService = new OfflineTaskService(client, database, loggingService, platform);
await Assert.RaisesAsync <OfflineTaskAddedEventArgs>(
x => taskService.TaskAdded += x,
x => taskService.TaskAdded -= x,
() => taskService.AddAsync(0, OfflineTask.OfflineTaskAction.MarkAsRead));
}
public async Task RemovingAnTagAndAddingAnotherExecutesTheProperActions()
{
var offlineTaskService = A.Fake <IOfflineTaskService>();
var loggingService = A.Fake <ILoggingService>();
var database = TestsHelper.CreateFakeDatabase();
var navigationService = A.Fake <INavigationService>();
var tagToRemove = new Tag()
{
Id = 2, Label = "test"
};
var tagToAdd = new Tag()
{
Id = 4, Label = "test"
};
var item = new Item()
{
Id = 1,
Tags = new System.Collections.ObjectModel.ObservableCollection <Tag>()
{
new Tag()
{
Id = 1, Label = "test"
},
tagToRemove,
new Tag()
{
Id = 3, Label = "test"
},
}
};
database.Insert(item);
var viewModel = new EditTagsViewModel(offlineTaskService, loggingService, database, navigationService);
await viewModel.ActivateAsync(item.Id, new Dictionary <string, object>(), Data.Common.NavigationMode.New);
Assert.Equal(3, viewModel.Tags.Count);
viewModel.Tags.Add(tagToAdd);
viewModel.Tags.Remove(tagToRemove);
Assert.Equal(3, viewModel.Tags.Count);
viewModel.FinishCommand.Execute(null);
A.CallTo(() => offlineTaskService.AddAsync(A <int> .Ignored, OfflineTask.OfflineTaskAction.EditTags, A <List <Tag> > .That.Contains(tagToAdd), A <List <Tag> > .That.Contains(tagToRemove))).MustHaveHappened(Repeated.Exactly.Once);
//A.CallTo(() => navigationService.GoBack()).MustHaveHappened();
}
public async Task GettingAPreviewImageForAVideoReturnsValidValue(string provider, string videoId)
{
var offlineTaskService = A.Fake <IOfflineTaskService>();
var loggingService = A.Fake <ILoggingService>();
var platform = A.Fake <IPlatformSpecific>();
var navigationService = A.Fake <INavigationService>();
var client = A.Fake <IWallabagClient>();
var database = TestsHelper.CreateFakeDatabase();
var viewModel = new ItemPageViewModel(offlineTaskService, loggingService, platform, navigationService, client, database);
string result = await viewModel.GetPreviewImageForVideoAsync(provider, videoId);
Assert.NotEqual(string.Empty, result);
Assert.True(result.StartsWith("http"));
}
public void ParsingTheTagQueryWontAddEmptyOrSpaceStrings()
{
var offlineTaskService = A.Fake <IOfflineTaskService>();
var loggingService = A.Fake <ILoggingService>();
var database = TestsHelper.CreateFakeDatabase();
var navigationService = A.Fake <INavigationService>();
var viewModel = new EditTagsViewModel(offlineTaskService, loggingService, database, navigationService)
{
TagQuery = ", ,"
};
viewModel.TagSubmittedCommand.Execute(null);
Assert.Equal(0, viewModel.Suggestions.Count);
}
public async Task NavigationWithAWrongParameterReportsError()
{
var offlineTaskService = A.Fake <IOfflineTaskService>();
var loggingService = A.Fake <ILoggingService>();
var platform = A.Fake <IPlatformSpecific>();
var navigationService = A.Fake <INavigationService>();
var client = A.Fake <IWallabagClient>();
var database = TestsHelper.CreateFakeDatabase();
var viewModel = new ItemPageViewModel(offlineTaskService, loggingService, platform, navigationService, client, database);
await viewModel.ActivateAsync(9999, new Dictionary <string, object>(), Data.Common.NavigationMode.New);
Assert.True(viewModel.ErrorDuringInitialization);
A.CallTo(() => platform.GetArticleTemplateAsync()).MustNotHaveHappened();
}
public void InvokingTheScanQRCodeCommandNavigatesToTheQRPage()
{
var logging = A.Fake <ILoggingService>();
var navigation = A.Fake <INavigationService>();
var device = A.Fake <IPlatformSpecific>();
var client = A.Fake <IWallabagClient>();
var apiService = A.Fake <IApiClientCreationService>();
var database = TestsHelper.CreateFakeDatabase();
var viewModel = new LoginPageViewModel(logging, navigation, device, client, apiService, database);
viewModel.ScanQRCodeCommand.Execute();
A.CallTo(() => navigation.Navigate(Data.Common.Navigation.Pages.QRScanPage)).MustHaveHappened();
}
public async Task ExecutingATaskWithFalseAPIResultDoesNotRemoveThemFromTheDatabase()
{
var client = A.Fake <IWallabagClient>();
var platform = A.Fake <IPlatformSpecific>();
var loggingService = A.Fake <ILoggingService>();
var database = TestsHelper.CreateFakeDatabase();
A.CallTo(() => client.ArchiveAsync(A <WallabagItem> .Ignored, A <CancellationToken> .Ignored)).Returns(false);
var taskService = new OfflineTaskService(client, database, loggingService, platform);
int count = taskService.Count;
await taskService.AddAsync(0, OfflineTask.OfflineTaskAction.MarkAsRead);
Assert.Equal(count + 1, taskService.Count);
}
public void TheUrlFieldIsVisibleIfTheSelectedProviderUrlIsNotNull()
{
var logging = A.Fake <ILoggingService>();
var navigation = A.Fake <INavigationService>();
var device = A.Fake <IPlatformSpecific>();
var client = A.Fake <IWallabagClient>();
var apiService = A.Fake <IApiClientCreationService>();
var database = TestsHelper.CreateFakeDatabase();
var viewModel = new LoginPageViewModel(logging, navigation, device, client, apiService, database)
{
SelectedProvider = WallabagProvider.GetOther(device)
};
viewModel.RaisePropertyChanged(nameof(viewModel.SelectedProvider));
Assert.Null(viewModel.SelectedProvider.Url);
Assert.True(viewModel.UrlFieldIsVisible);
}
public async Task NavigationWithParameterSetsProperties()
{
var logging = A.Fake <ILoggingService>();
var navigation = A.Fake <INavigationService>();
var device = A.Fake <IPlatformSpecific>();
var client = A.Fake <IWallabagClient>();
var apiService = A.Fake <IApiClientCreationService>();
var database = TestsHelper.CreateFakeDatabase();
var viewModel = new LoginPageViewModel(logging, navigation, device, client, apiService, database);
var param = new ProtocolSetupNavigationParameter("user", "http://test.de");
await viewModel.ActivateAsync(param, new Dictionary <string, object>(), Data.Common.NavigationMode.New);
Assert.True(WallabagProvider.GetOther(device).Equals(viewModel.SelectedProvider));
Assert.Equal("user", viewModel.Username);
Assert.Equal("http://test.de", viewModel.Url);
}
public void AddingAnMicrosoftEdgeUriAddsTheCorrectOne()
{
var offlineTaskService = A.Fake <IOfflineTaskService>();
var loggingService = A.Fake <ILoggingService>();
var database = TestsHelper.CreateFakeDatabase();
var navigationService = A.Fake <INavigationService>();
var viewModel = new AddItemViewModel(offlineTaskService, loggingService, database, navigationService)
{
UriString = "read:http://wallabag.org"
};
viewModel.AddCommand.Execute(null);
A.CallTo(() => navigationService.GoBack()).MustHaveHappened();
A.CallTo(() => offlineTaskService.AddAsync(A <string> .That.IsEqualTo("http://wallabag.org"), A <IEnumerable <string> > .Ignored)).MustHaveHappened();
// TODO: Add database check
}
public void AddingAnInvalidUriDoesNotExecuteTheOfflineTaskService()
{
var offlineTaskService = A.Fake <IOfflineTaskService>();
var loggingService = A.Fake <ILoggingService>();
var database = TestsHelper.CreateFakeDatabase();
var navigationService = A.Fake <INavigationService>();
var viewModel = new AddItemViewModel(offlineTaskService, loggingService, database, navigationService)
{
UriString = "fake"
};
viewModel.AddCommand.Execute(null);
A.CallTo(() => navigationService.GoBack()).MustNotHaveHappened();
A.CallTo(() => offlineTaskService.AddAsync(A <string> .Ignored, A <IEnumerable <string> > .Ignored)).MustNotHaveHappened();
// TODO: Add database check
}
public void SubmittingWillClearTheQueryAfterwards()
{
var offlineTaskService = A.Fake <IOfflineTaskService>();
var loggingService = A.Fake <ILoggingService>();
var database = TestsHelper.CreateFakeDatabase();
var navigationService = A.Fake <INavigationService>();
var viewModel = new EditTagsViewModel(offlineTaskService, loggingService, database, navigationService)
{
TagQuery = "test1"
};
viewModel.TagSubmittedCommand.Execute(null);
Assert.Equal(1, viewModel.Tags.Count);
Assert.False(viewModel.TagsCountIsZero);
Assert.True(string.IsNullOrEmpty(viewModel.TagQuery));
}
public async Task UsingYoutubeOrVimeoAsHostnameSetsTheHostnameEmpty()
{
var offlineTaskService = A.Fake <IOfflineTaskService>();
var loggingService = A.Fake <ILoggingService>();
var platform = A.Fake <IPlatformSpecific>();
var navigationService = A.Fake <INavigationService>();
var client = A.Fake <IWallabagClient>();
var database = TestsHelper.CreateFakeDatabase();
var fakeItems = new List <Item>
{
new Item()
{
Id = 1,
Hostname = "youtube.com",
Content = "test content",
PreviewImageUri = new Uri("https://test.de")
},
new Item()
{
Id = 2,
Hostname = "vimeo.com",
Content = "test content",
PreviewImageUri = new Uri("https://test.de")
}
};
A.CallTo(() => platform.GetArticleTemplateAsync()).Returns("{{imageHeader}}");
foreach (var item in fakeItems)
{
database.Insert(item);
var fakeItemViewModel = new ItemViewModel(item, offlineTaskService, navigationService, loggingService, platform, database);
var viewModel = new ItemPageViewModel(offlineTaskService, loggingService, platform, navigationService, client, database)
{
Item = fakeItemViewModel
};
await viewModel.ActivateAsync(item.Id, new Dictionary <string, object>(), Data.Common.NavigationMode.New);
Assert.False(viewModel.ErrorDuringInitialization);
Assert.Equal(string.Empty, viewModel.FormattedHtml);
}
}
public void SubmittingASuggestionAddsItToTheTagsList()
{
var offlineTaskService = A.Fake <IOfflineTaskService>();
var loggingService = A.Fake <ILoggingService>();
var database = TestsHelper.CreateFakeDatabase();
var navigationService = A.Fake <INavigationService>();
var viewModel = new EditTagsViewModel(offlineTaskService, loggingService, database, navigationService);
var tagToTest = new Tag()
{
Id = 1337,
Label = "My suggestion tag"
};
viewModel.TagSubmittedCommand.Execute(tagToTest);
Assert.Equal(1, viewModel.Tags.Count);
Assert.Equal(tagToTest, viewModel.Tags[0]);
}
public void RegisterCommandCanNotBeExecutedIfSelectedProviderIsNull()
{
var logging = A.Fake <ILoggingService>();
var navigation = A.Fake <INavigationService>();
var device = A.Fake <IPlatformSpecific>();
var client = A.Fake <IWallabagClient>();
var apiService = A.Fake <IApiClientCreationService>();
var database = TestsHelper.CreateFakeDatabase();
var uriToTest = new Uri("https://test.de");
var viewModel = new LoginPageViewModel(logging, navigation, device, client, apiService, database)
{
SelectedProvider = null
};
Assert.False(viewModel.RegisterCommand.CanExecute(null));
A.CallTo(() => device.LaunchUri(A <Uri> .That.IsEqualTo(uriToTest.Append("/register")), A <Uri> .Ignored)).MustNotHaveHappened();
}
