public async void EnsureAsyncGetTopProductsReturnsItems()
 {
     // Only test happy path, as the MusicClient tests cover the unhappy path
     IMusicClient client = new MusicClient("test", "gb", new MockApiRequestHandler(Resources.product_parse_tests));
     ListResponse<Product> result = await client.GetTopProductsAsync(Category.Album);
     Assert.Greater(result.Result.Count, 0, "Expected more than 0 results");
 }

        public void EnsureGetArtistsAroundLocationReturnsArtistsForValidSearch()
        {
            IMusicClient client = new MusicClient("test", "test", "gb", new MockApiRequestHandler(Resources.search_artists));
            client.GetArtistsAroundLocation(
                (ListResponse<Artist> result) =>
                {
                    Assert.IsNotNull(result, "Expected a result");
                    Assert.IsNotNull(result.StatusCode, "Expected a status code");
                    Assert.IsTrue(result.StatusCode.HasValue, "Expected a status code");
                    Assert.AreEqual(HttpStatusCode.OK, result.StatusCode.Value, "Expected a 200 response");
                    Assert.IsNotNull(result.Result, "Expected a list of results");
                    Assert.IsNull(result.Error, "Expected no error");
                    Assert.Greater(result.Result.Count, 0, "Expected more than 0 results");

                    foreach (Artist artist in result.Result)
                    {
                        Assert.IsFalse(string.IsNullOrEmpty(artist.Id), "Expected Id to be populated");
                        Assert.IsFalse(string.IsNullOrEmpty(artist.Name), "Expected Name to be populated");
                        Assert.IsNotNull(artist.Genres, "Expected a genre list");
                        Assert.Greater(artist.Genres.Length, 0, "Expected more than 0 genres");
                    }
                },
                51.45534,
                -2.59239);
        }

 public void EnsureExceptionIsThrownIfNullProductAsync()
 {
     IMusicClient client = new MusicClient("test", "gb", new MockApiRequestHandler(Resources.product_parse_tests));
     Product nullProduct = null;
     var t = client.GetSimilarProductsAsync(nullProduct);
     t.Wait();
 }

 public void EnsureAuthTokenSetCorrectly()
 {
     var client = new MusicClient("test", "gb", new MockApiRequestHandler(FakeResponse.NotFound()));
     client.SetAuthenticationToken(AuthTokenTests.GetTestAuthToken());
     Assert.AreEqual(true, client.IsUserAuthenticated, "Expected an authenticated user");
     Assert.AreEqual(true, client.IsUserTokenActive, "Expected an authenticated user");
 }

		public ActivityViewModel (MusicClient client, AuthHelper authHelper)
		{
			this._mixRadioClient = client;
			this._authHelper = authHelper;
			this.Artists = new ObservableCollection<Artist> ();
			this.Tracks = new ObservableCollection<UserEvent> ();
		}

 public void EnsureAsyncGetProductsReturnsItems()
 {
     // Only test happy path, as the MusicClient tests cover the unhappy path
     IMusicClient client = new MusicClient("test", "gb", new MockApiRequestHandler(Resources.single_product));
     var task = client.GetProductAsync("test");
     task.Wait();
     this.ValidateProductResponse(task.Result);
 }

        public async void EnsureAsyncGetGenresReturnsItems()
        {
            // Only test happy path, as the MusicClient tests cover the unhappy path
            IMusicClient client = new MusicClient("test", "gb", new MockApiRequestHandler(Resources.genres));

            ListResponse<Genre> result = await client.GetGenresAsync();
            Assert.Greater(result.Result.Count, 0, "Expected more than 0 results");
        }

 public async Task EnsureRefreshAuthenticationTokenAsyncReturnsExistingTokenIfValid()
 {
     var client = new MusicClient("test", "gb", new MockApiRequestHandler(FakeResponse.NotFound()));
     var token = AuthTokenTests.GetTestAuthToken();
     client.SetAuthenticationToken(token);
     var result = await client.RefreshAuthenticationTokenAsync("secret");
     Assert.AreEqual(token.AccessToken, result.AccessToken, "Expected the same token");
 }

 public async Task EnsureGetArtistProductsReturnsItems()
 {
     IMusicClient client = new MusicClient("test", "gb", new MockApiRequestHandler(Resources.search_artists));
     var t = await client.GetArtistProductsAsync("test", Category.Album);
     this.ValidateProductListResponse(t);
     t = await client.GetArtistProductsAsync("test");
     this.ValidateProductListResponse(t);
 }

        public async Task EnsureRequestIdComesBackInResponse()
        {
            IMusicClient client = new MusicClient("test", "gb", new MockApiRequestHandler(Resources.search_suggestions));
            var requestId = Guid.NewGuid();
            ListResponse<string> result = await client.GetSearchSuggestionsAsync("green", requestId: requestId);

            Assert.IsNotNull(result, "Expected a result");
            Assert.AreEqual(requestId, result.RequestId);
        }

 public async Task FindTest3()
 {
     var client = new MusicClient("XboxMusicClientTests", "ThisWillBeChangedOften");
     var result = await client.Find("caparezza non me lo posso promettere");
     Assert.IsNotNull(result);
     Assert.IsNotNull(result.Error);
     Assert.IsNotNull(result.Error.Response);
     Assert.AreEqual("NotFound", result.Error.ErrorCode);
 }

		public App(IAuthPlatformSpecific platformSpecificAuth, string appVersion, IUriLauncher uriLauncher)
        {
			this.MixRadioClient = new MusicClient (ApiKeys.ClientId);
			this.AuthHelper = new AuthHelper (platformSpecificAuth, this.MixRadioClient);
			this.ActivityViewModel = new ActivityViewModel (this.MixRadioClient, this.AuthHelper);
			this.AppVersion = appVersion;
			this.UriLauncher = uriLauncher;
			this.MainPage = new RootPage ();
        }

 public void EnsureGetArtistProductsReturnsItems()
 {
     IMusicClient client = new MusicClient("test", "gb", new MockApiRequestHandler(Resources.search_artists));
     var task = client.GetArtistProductsAsync(new Artist() { Id = "test" }, Category.Album);
     task.Wait();
     this.ValidateProductListResponse(task.Result);
     task = client.GetArtistProductsAsync("test");
     task.Wait();
     this.ValidateProductListResponse(task.Result);
 }

 public async Task GetTest1()
 {
     var client = new MusicClient("XboxMusicClientTests", "ThisWillBeChangedOften");
     var result = await client.Get("music.C61C0000-0200-11DB-89CA-0019B92A3933");
     Assert.IsNotNull(result);
     Assert.IsNull(result.Error);
     Assert.IsNotNull(result.Artists);
     //Assert.IsNotNull(result.Tracks);
     //Assert.IsNotNull(result.Albums);
 }

 public async Task FindTest2()
 {
     var client = new MusicClient("XboxMusicClientTests", "ThisWillBeChangedOften");
     var result = await client.Find("Daft Punk", getAlbums: false);
     Assert.IsNotNull(result);
     Assert.IsNull(result.Error);
     Assert.IsNotNull(result.Artists);
     Assert.IsNotNull(result.Tracks);
     Assert.IsNull(result.Albums);
 }

 public async Task FindTest1Continued()
 {
     var client = new MusicClient("XboxMusicClientTests", "ThisWillBeChangedOften");
     var result = await client.Find("Daft Punk", _find1ContinuationToken);
     Assert.IsNotNull(result);
     Assert.IsNull(result.Error);
     Assert.IsNotNull(result.Albums);
     Assert.IsNull(result.Artists);
     Assert.IsNull(result.Tracks);
 }

 public void EnsureAsyncGetArtistProductsReturnsItems()
 {
     // Only test happy path, as the MusicClient tests cover the unhappy path
     IMusicClient client = new MusicClient("test", "gb", new MockApiRequestHandler(Resources.artist_products));
     var artistProductByIdTask = client.GetArtistProductsAsync("test");
     var artistProductByArtistTask = client.GetArtistProductsAsync(new Artist() { Id = "test" });
     artistProductByIdTask.Wait();
     artistProductByArtistTask.Wait();
     this.ValidateProductListResponse(artistProductByIdTask.Result);
     this.ValidateProductListResponse(artistProductByArtistTask.Result);
 }

 public async Task EnsureGetNewReleasesReturnsErrorForFailedCall()
 {
     IMusicClient client = new MusicClient("test", "gb", new MockApiRequestHandler(FakeResponse.NotFound()));
     ListResponse<Product> result = await client.GetNewReleasesAsync(Category.Album);
     Assert.IsNotNull(result, "Expected a result");
     Assert.IsNotNull(result.StatusCode, "Expected a status code");
     Assert.IsTrue(result.StatusCode.HasValue, "Expected a status code");
     Assert.AreNotEqual(HttpStatusCode.OK, result.StatusCode.Value, "Expected a non-OK response");
     Assert.IsNotNull(result.Error, "Expected an error");
     Assert.AreEqual(typeof(ApiCallFailedException), result.Error.GetType(), "Expected an ApiCallFailedException");
 }

 public async Task EnsureGetProductReturnsUnknownErrorForFailedCall()
 {
     IMusicClient client = new MusicClient("test", "gb", new MockApiRequestHandler(FakeResponse.ConflictServerError("{ \"error\":\"true\"}")));
     Response<Product> result = await client.GetProductAsync("test");
     Assert.IsNotNull(result, "Expected a result");
     Assert.IsNotNull(result.StatusCode, "Expected a status code");
     Assert.IsTrue(result.StatusCode.HasValue, "Expected a status code");
     Assert.AreNotEqual(HttpStatusCode.OK, result.StatusCode.Value, "Expected a non-OK response");
     Assert.IsNotNull(result.Error, "Expected an error");
     Assert.AreEqual(typeof(ApiCallFailedException), result.Error.GetType(), "Expected an ApiCallFailedException");
 }

 public async Task EnsureGetGenresReturnsErrorForFailedCall()
 {
     IMusicClient client = new MusicClient("test", "gb", new MockApiRequestHandler(FakeResponse.InternalServerError()));
     var result = await client.GetGenresAsync();
     Assert.IsNotNull(result, "Expected a result");
     Assert.IsNotNull(result.StatusCode, "Expected a status code");
     Assert.IsTrue(result.StatusCode.HasValue, "Expected a status code");
     Assert.AreNotEqual(HttpStatusCode.OK, result.StatusCode.Value, "Expected a non-OK response");
     Assert.IsNotNull(result.Error, "Expected an error");
     Assert.AreEqual(typeof(ApiCallFailedException), result.Error.GetType(), "Expected an ApiCallFailedException");
 }