public override async Task <PageResponse <LastArtist> > HandleResponse(HttpResponseMessage response)
{
var json = await response.Content.ReadAsStringAsync();
var jtoken = JsonConvert.DeserializeObject <JToken>(json);
var resultsToken = jtoken.SelectToken("topartists");
LastResponseStatus status;
if (LastFm.IsResponseValid(json, out status) && response.IsSuccessStatusCode)
{
if (string.IsNullOrEmpty(resultsToken.SelectToken("@attr.tag").Value <string>()))
{
return(PageResponse <LastArtist> .CreateErrorResponse(LastResponseStatus.MissingParameters));
}
var itemsToken = resultsToken.SelectToken("artist");
return(PageResponse <LastArtist> .CreateSuccessResponse(itemsToken, resultsToken, LastArtist.ParseJToken, LastPageResultsType.Attr));
}
else
{
// The tag api always returns a "valid" response, so
return(PageResponse <LastArtist> .CreateErrorResponse(status));
}
}
public async override Task <PageResponse <LastStation> > HandleResponse(HttpResponseMessage response)
{
string json = await response.Content.ReadAsStringAsync();
LastResponseStatus status;
if (LastFm.IsResponseValid(json, out status) && response.IsSuccessStatusCode)
{
JToken jtoken = JsonConvert.DeserializeObject <JToken>(json).SelectToken("recentstations");
var stationsToken = jtoken.SelectToken("station");
var stations = stationsToken.Children().Select(LastStation.ParseJToken).ToList();
var pageresponse = PageResponse <LastStation> .CreateSuccessResponse(stations);
var attrToken = jtoken.SelectToken("@attr");
pageresponse.AddPageInfoFromJToken(attrToken);
return(pageresponse);
}
else
{
return(LastResponse.CreateErrorResponse <PageResponse <LastStation> >(status));
}
}
public async override Task <PageResponse <LastTrack> > HandleResponse(HttpResponseMessage response)
{
var json = await response.Content.ReadAsStringAsync();
LastFmApiError error;
if (LastFm.IsResponseValid(json, out error) && response.IsSuccessStatusCode)
{
JToken jtoken = JsonConvert.DeserializeObject <JToken>(json).SelectToken("recenttracks");
var tracksToken = jtoken.SelectToken("track");
var tracks = new List <LastTrack>();
foreach (var track in tracksToken.Children())
{
var t = LastTrack.ParseJToken(track);
tracks.Add(t);
}
var pageresponse = PageResponse <LastTrack> .CreateSuccessResponse(tracks);
var attrToken = jtoken.SelectToken("@attr");
pageresponse.AddPageInfoFromJToken(attrToken);
return(pageresponse);
}
else
{
return(LastResponse.CreateErrorResponse <PageResponse <LastTrack> >(error));
}
}
public async Task CreateTasteTextTest()
{
// given: user api mock
string username = "******";
LastStatsTimeSpan timeSpan = LastStatsTimeSpan.Overall;
// create test data
int amount = 3;
IEnumerable <LastArtist> responseArtists = TestHelper.CreateGenericArtists(amount);
Mock <IUserApi> userApiMock = new Mock <IUserApi>(MockBehavior.Strict);
userApiMock.Setup(u => u.GetTopArtists(username, timeSpan, It.IsAny <int>(), amount))
.Returns(Task.Run(() => PageResponse <LastArtist> .CreateSuccessResponse(responseArtists)));
PasteYourTasteViewModel vm = new PasteYourTasteViewModel(userApiMock.Object)
{
Username = username,
Amount = amount
};
// when: getting the taste text
await vm.GetTopArtists();
// then: taste text contains artists
foreach (var artist in responseArtists)
{
Assert.That(vm.TasteText.Contains(artist.Name), Is.True);
}
}
public Task <PageResponse <LastArtist> > GetRecommendedArtistsAsync(int page = 1, int limit = 30)
{
return(Task.FromResult(PageResponse <LastArtist> .CreateSuccessResponse(new List <LastArtist>
{
CreateArtist("Iggy Azalea",
"http://musicimage.xboxlive.com/content/music.1F154700-0200-11DB-89CA-0019B92A3933/image?locale=en-US")
})));
}
public void LoginTest()
{
// given: mocks
var lastAuthMock = new Mock <ILastAuth>(MockBehavior.Strict);
bool isSubscriber = true;
string username = "******";
string token = "TestToken";
lastAuthMock.Setup(l => l.UserSession).Returns(new LastUserSession()
{
IsSubscriber = isSubscriber, Token = token, Username = username
});
lastAuthMock.Setup(l => l.LoadSession(It.IsAny <LastUserSession>())).Returns(true);
lastAuthMock.Setup(l => l.Authenticated).Returns(true);
var userApiMock = new Mock <IUserApi>(MockBehavior.Strict);
userApiMock.Setup(u => u.GetRecentScrobbles(It.IsAny <string>(), It.IsAny <DateTimeOffset?>(), It.IsAny <DateTimeOffset?>(),
It.IsAny <bool>(), 1, It.IsAny <int>()))
.Returns(() => Task.Run(() => PageResponse <LastTrack> .CreateSuccessResponse()));
userApiMock.Setup(u => u.GetRecentScrobbles(It.IsAny <string>(), It.IsAny <DateTimeOffset?>(), It.IsAny <DateTimeOffset?>(),
It.IsAny <bool>(), 2, It.IsAny <int>()))
.Returns(() => Task.Run(() => PageResponse <LastTrack> .CreateSuccessResponse()));
userApiMock.Setup(u => u.GetRecentScrobbles(It.IsAny <string>(), It.IsAny <DateTimeOffset?>(), It.IsAny <DateTimeOffset?>(),
It.IsAny <bool>(), 3, It.IsAny <int>()))
.Returns(() => Task.Run(() => PageResponse <LastTrack> .CreateSuccessResponse()));
var messageBoxServiceMock = new Mock <IMessageBoxService>(MockBehavior.Strict);
messageBoxServiceMock.Setup(m => m.ShowDialog(It.IsAny <string>())).Returns(IMessageBoxServiceResult.OK);
var windowManagerMock = new Mock <IExtendedWindowManager>(MockBehavior.Strict);
windowManagerMock.Setup(w => w.ShowDialog(It.IsAny <LoginViewModel>(), It.IsAny <object>(), It.IsAny <IDictionary <string, object> >())).Returns(true);
windowManagerMock.SetupGet(w => w.MessageBoxService).Returns(messageBoxServiceMock.Object);
var fileOperatorMock = new Mock <IFileOperator>(MockBehavior.Strict);
var directoryOperatorMock = new Mock <IDirectoryOperator>(MockBehavior.Strict);
directoryOperatorMock.Setup(d => d.Exists(It.IsAny <string>())).Returns(true);
directoryOperatorMock.Setup(d => d.GetFiles(It.IsAny <string>())).Returns(Array.Empty <string>());
var userSerializerMock = new Mock <ISerializer>(MockBehavior.Strict);
userSerializerMock.Setup(u => u.Serialize(It.IsAny <User>(), It.IsAny <string>(), It.IsAny <IEnumerable <Type> >()));
UserViewModel vm = new UserViewModel(windowManagerMock.Object, lastAuthMock.Object, userApiMock.Object, fileOperatorMock.Object, directoryOperatorMock.Object, userSerializerMock.Object);
vm.AddUser();
vm.SelectedUser = vm.AvailableUsers.First();
// when: logging the user in
vm.LoginUser();
// then: active user changed
Assert.That(vm.ActiveUser, Is.SameAs(vm.SelectedUser));
}
public async override Task <PageResponse <LastTag> > HandleResponse(HttpResponseMessage response)
{
var json = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
LastResponseStatus status;
if (LastFm.IsResponseValid(json, out status) && response.IsSuccessStatusCode)
{
var jtoken = JsonConvert.DeserializeObject <JToken>(json);
var itemsToken = jtoken.SelectToken("toptags.tag");
return(PageResponse <LastTag> .CreateSuccessResponse(itemsToken, LastTag.ParseJToken));
}
return(PageResponse <LastTag> .CreateErrorResponse(status));
}
public override async Task <PageResponse <LastWeeklyChartList> > HandleResponse(HttpResponseMessage response)
{
var json = await response.Content.ReadAsStringAsync();
LastResponseStatus status;
if (LastFm.IsResponseValid(json, out status) && response.IsSuccessStatusCode)
{
var jtoken = JsonConvert.DeserializeObject <JToken>(json);
var chartListToken = jtoken.SelectToken("weeklychartlist");
var itemsToken = chartListToken.SelectToken("chart");
var pageInfoToken = chartListToken.SelectToken("@attr");
return(PageResponse <LastWeeklyChartList> .CreateSuccessResponse(itemsToken, pageInfoToken, LastWeeklyChartList.ParseJToken, LastPageResultsType.Attr));
}
return(LastResponse.CreateErrorResponse <PageResponse <LastWeeklyChartList> >(status));
}
public async override Task <PageResponse <LastTrack> > HandleResponse(HttpResponseMessage response)
{
var json = await response.Content.ReadAsStringAsync();
LastFmApiError error;
if (LastFm.IsResponseValid(json, out error) && response.IsSuccessStatusCode)
{
var jtoken = JsonConvert.DeserializeObject <JToken>(json);
var itemsToken = jtoken.SelectToken("similartracks").SelectToken("track");
return(PageResponse <LastTrack> .CreateSuccessResponse(itemsToken, null, LastTrack.ParseJToken));
}
else
{
return(LastResponse.CreateErrorResponse <PageResponse <LastTrack> >(error));
}
}
public async override Task <PageResponse <LastArtist> > HandleResponse(HttpResponseMessage response)
{
var json = await response.Content.ReadAsStringAsync();
LastResponseStatus status;
if (LastFm.IsResponseValid(json, out status) && response.IsSuccessStatusCode)
{
var jtoken = JsonConvert.DeserializeObject <JToken>(json);
var itemsToken = jtoken.SelectToken("similarartists").SelectToken("artist");
return(PageResponse <LastArtist> .CreateSuccessResponse(itemsToken, LastArtist.ParseJToken));
}
else
{
return(LastResponse.CreateErrorResponse <PageResponse <LastArtist> >(status));
}
}
public async override Task <PageResponse <LastTag> > HandleResponse(HttpResponseMessage response)
{
var json = await response.Content.ReadAsStringAsync();
LastResponseStatus status;
if (LastFm.IsResponseValid(json, out status) && response.IsSuccessStatusCode)
{
var jtoken = JsonConvert.DeserializeObject <JToken>(json).SelectToken("similartags");
var itemsToken = jtoken.SelectToken("tag");
var attrToken = jtoken.SelectToken("@attr");
var relatedTag = attrToken.SelectToken("tag").Value <string>();
return(PageResponse <LastTag> .CreateSuccessResponse(itemsToken, jt => LastTag.ParseJToken(jt, relatedTag)));
}
return(LastResponse.CreateErrorResponse <PageResponse <LastTag> >(status));
}
public async override Task <PageResponse <LastTrack> > HandleResponse(HttpResponseMessage response)
{
var json = await response.Content.ReadAsStringAsync();
LastResponseStatus status;
if (LastFm.IsResponseValid(json, out status) && response.IsSuccessStatusCode)
{
var jtoken = JsonConvert.DeserializeObject <JToken>(json).SelectToken("tracks");
var tracksToken = jtoken.SelectToken("track");
var pageInfoToken = jtoken.SelectToken("@attr");
return(PageResponse <LastTrack> .CreateSuccessResponse(tracksToken, pageInfoToken, LastTrack.ParseJToken, LastPageResultsType.Attr));
}
else
{
return(LastResponse.CreateErrorResponse <PageResponse <LastTrack> >(status));
}
}
public override async Task <PageResponse <LastAlbum> > HandleResponse(HttpResponseMessage response)
{
var json = await response.Content.ReadAsStringAsync();
LastResponseStatus status;
if (LastFm.IsResponseValid(json, out status) && response.IsSuccessStatusCode)
{
var jtoken = JToken.Parse(json);
var itemsToken = jtoken.SelectToken("topalbums").SelectToken("album");
var pageInfoToken = jtoken.SelectToken("@attr");
return(PageResponse <LastAlbum> .CreateSuccessResponse(itemsToken, pageInfoToken, LastAlbum.ParseJToken, LastPageResultsType.Attr));
}
else
{
return(LastResponse.CreateErrorResponse <PageResponse <LastAlbum> >(status));
}
}
public async override Task <PageResponse <LastTag> > HandleResponse(HttpResponseMessage response)
{
var json = await response.Content.ReadAsStringAsync();
LastFmApiError error;
if (LastFm.IsResponseValid(json, out error) && response.IsSuccessStatusCode)
{
var jtoken = JsonConvert.DeserializeObject <JToken>(json);
var resultsToken = jtoken.SelectToken("toptags");
var itemsToken = resultsToken.SelectToken("tag");
return(PageResponse <LastTag> .CreateSuccessResponse(itemsToken, resultsToken, LastTag.ParseJToken, LastPageResultsType.Attr));
}
else
{
return(LastResponse.CreateErrorResponse <PageResponse <LastTag> >(error));
}
}
public override async Task <PageResponse <LastTrack> > HandleResponse(HttpResponseMessage response)
{
var json = await response.Content.ReadAsStringAsync();
LastResponseStatus status;
if (LastFm.IsResponseValid(json, out status) && response.IsSuccessStatusCode)
{
var jtoken = JsonConvert.DeserializeObject <JToken>(json);
var resultsToken = jtoken.SelectToken("results");
var itemsToken = resultsToken.SelectToken("trackmatches").SelectToken("track");
return(PageResponse <LastTrack> .CreateSuccessResponse(itemsToken, resultsToken, LastTrack.ParseJToken, LastPageResultsType.OpenQuery));
}
else
{
return(LastResponse.CreateErrorResponse <PageResponse <LastTrack> >(status));
}
}
public override async Task <PageResponse <LastTag> > HandleResponse(HttpResponseMessage response)
{
var json = await response.Content.ReadAsStringAsync();
LastResponseStatus status;
if (LastFm.IsResponseValid(json, out status) && response.IsSuccessStatusCode)
{
var jo = JObject.Parse(json);
var tagsToken = jo.SelectToken("tags.tag");
var pageInfoToken = jo.SelectToken("@attr");
return(PageResponse <LastTag> .CreateSuccessResponse(tagsToken, pageInfoToken, LastTag.ParseJToken, LastPageResultsType.Attr));
}
else
{
return(PageResponse <LastTag> .CreateErrorResponse(status));
}
}
public override async Task <PageResponse <LastShout> > HandleResponse(HttpResponseMessage response)
{
var json = await response.Content.ReadAsStringAsync();
LastFmApiError error;
if (LastFm.IsResponseValid(json, out error) && response.IsSuccessStatusCode)
{
var jtoken = JsonConvert.DeserializeObject <JToken>(json);
var shoutsToken = jtoken.SelectToken("shouts");
var itemsToken = shoutsToken.SelectToken("shout");
var pageInfoToken = shoutsToken.SelectToken("@attr");
return(PageResponse <LastShout> .CreateSuccessResponse(itemsToken, pageInfoToken, LastShout.ParseJToken));
}
else
{
return(LastResponse.CreateErrorResponse <PageResponse <LastShout> >(error));
}
}
/// <summary>
/// Creates a user that has hit the daily scrobble limit.
/// </summary>
/// <returns>User with reached limit.</returns>
public static Login.User CreateCappedUser()
{
var tracks1 = CreateGenericScrobbles(1000).ToLastTracks();
var tracks2 = CreateGenericScrobbles(1000).ToLastTracks();
var tracks3 = CreateGenericScrobbles(1000).ToLastTracks();
var userApiMock = new Mock <IUserApi>(MockBehavior.Strict);
// setup so first page returs the scrobbles
userApiMock.Setup(u => u.GetRecentScrobbles(It.IsAny <string>(), It.IsAny <DateTimeOffset?>(), It.IsAny <DateTimeOffset?>(),
It.IsAny <bool>(), 1, It.IsAny <int>()))
.Returns(() => Task.Run(() => PageResponse <LastTrack> .CreateSuccessResponse(tracks1)));
userApiMock.Setup(u => u.GetRecentScrobbles(It.IsAny <string>(), It.IsAny <DateTimeOffset?>(), It.IsAny <DateTimeOffset?>(),
It.IsAny <bool>(), 2, It.IsAny <int>()))
.Returns(() => Task.Run(() => PageResponse <LastTrack> .CreateSuccessResponse(tracks2)));
userApiMock.Setup(u => u.GetRecentScrobbles(It.IsAny <string>(), It.IsAny <DateTimeOffset?>(), It.IsAny <DateTimeOffset?>(),
It.IsAny <bool>(), 3, It.IsAny <int>()))
.Returns(() => Task.Run(() => PageResponse <LastTrack> .CreateSuccessResponse(tracks3)));
return(new Login.User("TestUser", "TestToken", true, userApiMock.Object));
}
public static Login.User CreateUserWithRecentTracks(string username, string token, bool isSubscriber, IEnumerable <LastTrack> tracks)
{
if (tracks == null || tracks.Count() > 1000)
{
throw new ArgumentException(nameof(tracks), "tracks is null or has more than 1000 tracks");
}
var userApiMock = new Mock <IUserApi>(MockBehavior.Strict);
// setup so first page returs the scrobbles
userApiMock.Setup(u => u.GetRecentScrobbles(username, It.IsAny <DateTimeOffset?>(), It.IsAny <DateTimeOffset?>(),
It.IsAny <bool>(), 1, It.IsAny <int>()))
.Returns(() => Task.Run(() => PageResponse <LastTrack> .CreateSuccessResponse(tracks)));
userApiMock.Setup(u => u.GetRecentScrobbles(username, It.IsAny <DateTimeOffset?>(), It.IsAny <DateTimeOffset?>(),
It.IsAny <bool>(), 2, It.IsAny <int>()))
.Returns(() => Task.Run(() => PageResponse <LastTrack> .CreateSuccessResponse()));
userApiMock.Setup(u => u.GetRecentScrobbles(username, It.IsAny <DateTimeOffset?>(), It.IsAny <DateTimeOffset?>(),
It.IsAny <bool>(), 3, It.IsAny <int>()))
.Returns(() => Task.Run(() => PageResponse <LastTrack> .CreateSuccessResponse()));
return(new Login.User(username, token, isSubscriber, userApiMock.Object));
}
public void CreateTasteTextTest()
{
// given: user api mock
string username = "******";
int amount = 3;
LastStatsTimeSpan timeSpan = LastStatsTimeSpan.Overall;
// create test data
List <LastArtist> responseArtists = new List <LastArtist>();
for (int i = 0; i < amount; i++)
{
responseArtists.Add(new LastArtist()
{
Name = "TestArtist" + i
});
}
Mock <IUserApi> userApiMock = new Mock <IUserApi>(MockBehavior.Strict);
userApiMock.Setup(u => u.GetTopArtists(username, timeSpan, It.IsAny <int>(), amount))
.Returns(Task.Run(() => PageResponse <LastArtist> .CreateSuccessResponse(responseArtists)));
PasteYourTasteViewModel vm = new PasteYourTasteViewModel(userApiMock.Object)
{
Username = username,
Amount = amount
};
// when: getting the taste text
vm.GetTopArtists();
// then: taste text contains artists
foreach (var artist in responseArtists)
{
Assert.That(vm.TasteText.Contains(artist.Name), Is.True);
}
}
public async Task ScrobbleTest()
{
//given: FriendScrobbleViewModel with mocked userapi
List <Scrobble> expected = new List <Scrobble>
{
new Scrobble("TestArtist", "TestAlbum", "TestTrack", DateTime.Now)
{
Duration = TimeSpan.FromSeconds(30)
},
new Scrobble("TestArtist2", "TestAlbum2", "TestTrack2", DateTime.Now.AddSeconds(1))
{
Duration = TimeSpan.FromSeconds(30)
},
new Scrobble("TestArtist3", "TestAlbum3", "TestTrack3", DateTime.Now.AddSeconds(2))
{
Duration = TimeSpan.FromSeconds(30)
}
};
Mock <IAuthScrobbler> scrobblerMock = new Mock <IAuthScrobbler>();
IEnumerable <Scrobble> actual = null;
scrobblerMock.Setup(i => i.ScrobbleAsync(It.IsAny <IEnumerable <Scrobble> >())).Callback <IEnumerable <Scrobble> >(s => actual = s)
.Returns(Task.Run(() => new ScrobbleResponse()));
Mock <IUserApi> userApiMock = new Mock <IUserApi>();
userApiMock.Setup(i => i.GetRecentScrobbles(It.IsAny <string>(), It.IsAny <DateTimeOffset?>(), It.IsAny <int>(), It.IsAny <int>())).Returns(()
=> Task.Run(() => PageResponse <LastTrack> .CreateSuccessResponse(expected.ToLastTracks())));
FriendScrobbleViewModel vm = new FriendScrobbleViewModel(null, userApiMock.Object)
{
Scrobbler = scrobblerMock.Object,
Username = "******"
};
await vm.FetchScrobbles();
vm.SelectAll();
// when: scrobbling the fetched tracks.
await vm.Scrobble();
// we add 1 second to each TimePlayed of the expected because the vm does this too so you can scrobble from yourself...
for (int i = 0; i < expected.Count; i++)
{
expected[i] = expected[i].CloneWithAddedSecond();
}
// then: scrobbled tracks should be equal to the given tracks.
Assert.That(actual.IsEqualScrobble(expected), Is.True);
}
public Task <PageResponse <LastAlbum> > GetArtistTopAlbums(string name)
{
var pageResp = PageResponse <LastAlbum> .CreateSuccessResponse(CreateDesignAlbums());
return(Task.FromResult(pageResp));
}
public Task <PageResponse <LastArtist> > SearchArtistAsync(string query, int page = 1, int limit = 30)
{
var pageResp = PageResponse <LastArtist> .CreateSuccessResponse(CreateDesignArtists());
return(Task.FromResult(pageResp));
}
public Task <PageResponse <LastTrack> > GetTopTracksAsync(int page = 1, int limit = 30)
{
var pageResp = PageResponse <LastTrack> .CreateSuccessResponse(CreateDesignTracks());
return(Task.FromResult(pageResp));
}
public async Task ScrobbleTest()
{
// given: mocks
string artistSearchText = "TestArtist";
Mock <IExtendedWindowManager> windowManagerMock = new Mock <IExtendedWindowManager>(MockBehavior.Strict);
IEnumerable <LastArtist> artists = TestHelper.CreateGenericArtists(3);
IEnumerable <LastAlbum> albums = TestHelper.CreateGenericAlbums(3);
Mock <IArtistApi> artistAPIMock = new Mock <IArtistApi>(MockBehavior.Strict);
artistAPIMock.Setup(a => a.SearchAsync(artistSearchText, It.IsAny <int>(), It.IsAny <int>()))
.Returns(Task.Run(() => PageResponse <LastArtist> .CreateSuccessResponse(artists)));
artistAPIMock.Setup(a => a.GetTopAlbumsAsync(artists.First().Name, It.IsAny <bool>(), It.IsAny <int>(), It.IsAny <int>()))
.Returns(Task.Run(() => PageResponse <LastAlbum> .CreateSuccessResponse(albums)));
DateTime scrobbleTime = DateTime.Now;
List <Scrobble> expectedScrobbles = new List <Scrobble>();
for (int i = 0; i < 3; i++)
{
// -3 minutes because that is the default if the song has no duration
expectedScrobbles.Add(new Scrobble("TestArtist", "TestAlbum", "TestTrack", scrobbleTime.Subtract(TimeSpan.FromMinutes(i * 3))));
}
LastAlbum albumToScrobble = albums.First();
albumToScrobble.Tracks = expectedScrobbles.ToLastTracks();
Mock <IAlbumApi> albumAPIMock = new Mock <IAlbumApi>(MockBehavior.Strict);
albumAPIMock.Setup(a => a.GetInfoAsync(albums.First().ArtistName, albums.First().Name, It.IsAny <bool>(), It.IsAny <string>()))
.Returns(Task.Run(() => LastResponse <LastAlbum> .CreateSuccessResponse(albumToScrobble)));
IEnumerable <Scrobble> actual = null;
Mock <IUserScrobbler> scrobblerMock = new Mock <IUserScrobbler>(MockBehavior.Strict);
scrobblerMock.Setup(u => u.ScrobbleAsync(It.IsAny <IEnumerable <Scrobble> >(), false)).Callback <IEnumerable <Scrobble>, bool>((s, c) => actual = s)
.Returns(Task.Run(() => new ScrobbleResponse()));
scrobblerMock.Setup(u => u.IsAuthenticated).Returns(true);
var discocsClientMock = new Mock <IDiscogsDataBaseClient>(MockBehavior.Strict);
var vm = new DatabaseScrobbleViewModel(windowManagerMock.Object, artistAPIMock.Object, albumAPIMock.Object, discocsClientMock.Object)
{
DatabaseToSearch = Database.LastFm,
Scrobbler = scrobblerMock.Object,
SearchType = SearchType.Artist,
SearchText = artistSearchText,
};
vm.ScrobbleTimeVM.UseCurrentTime = false;
vm.ScrobbleTimeVM.Time = scrobbleTime;
// when searching and scrobbling
await vm.Search();
// now we should have artists
// we "click" the first one, this should trigger the album search
(vm.ActiveItem as ArtistResultViewModel).Items.First().Clicked();
// now we should have albums
// we "click" the first one, this should trigger the tracklist fetching
(vm.ActiveItem as ReleaseResultViewModel).Items.First().Clicked();
vm.CheckAll();
await vm.Scrobble();
// then: correct items where scrobbles
Assert.That(actual.IsEqualScrobble(expectedScrobbles), Is.True);
}
public async Task ScrobbleTest()
{
//given: FriendScrobbleViewModel with mocked userapi
var expected = TestHelper.CreateGenericScrobbles(3);
IEnumerable <Scrobble> actual = null;
Mock <IUserScrobbler> scrobblerMock = new Mock <IUserScrobbler>(MockBehavior.Strict);
scrobblerMock.Setup(u => u.ScrobbleAsync(It.IsAny <IEnumerable <Scrobble> >(), false)).Callback <IEnumerable <Scrobble>, bool>((s, c) => actual = s)
.Returns(Task.Run(() => new ScrobbleResponse()));
scrobblerMock.Setup(u => u.IsAuthenticated).Returns(true);
Mock <IUserApi> userApiMock = new Mock <IUserApi>();
userApiMock.Setup(i => i.GetRecentScrobbles(It.IsAny <string>(), It.IsAny <DateTimeOffset?>(), It.IsAny <int>(), It.IsAny <int>())).Returns(()
=> Task.Run(() => PageResponse <LastTrack> .CreateSuccessResponse(expected.ToLastTracks())));
Mock <IExtendedWindowManager> windowManagerMock = new Mock <IExtendedWindowManager>(MockBehavior.Strict);
FriendScrobbleViewModel vm = new FriendScrobbleViewModel(windowManagerMock.Object, userApiMock.Object)
{
Scrobbler = scrobblerMock.Object,
Username = "******"
};
await vm.FetchScrobbles();
vm.CheckAll();
// when: scrobbling the fetched tracks.
await vm.Scrobble();
// we add 1 second to each TimePlayed of the expected because the vm does this too so you can scrobble from yourself...
for (int i = 0; i < expected.Length; i++)
{
expected[i] = expected[i].CloneWithAddedTime(TimeSpan.FromSeconds(1));
}
// then: scrobbled tracks should be equal to the given tracks.
Assert.That(actual.IsEqualScrobble(expected), Is.True);
}
public Task <PageResponse <LastArtist> > GetTopArtistsAsync(int page = 1, int limit = 30)
{
var pageResp = PageResponse <LastArtist> .CreateSuccessResponse(CreateDesignArtists());
return(Task.FromResult(pageResp));
}
