public void Test_Groups_Delete_Add_Contribution() { var client = SoundCloudClient.CreateAuthorized(_settings.Token); var group = new Group(); group.id = GroupId; var track = new Track(); track.id = Track3Id; var result = client.Groups.Post(group, track); Assert.That(result.IsSuccess, Is.True); Assert.That(result.Data.id, Is.EqualTo(track.id)); var tracks = client.Groups.GetContributions(group); Assert.That(tracks.Any(x => x.id == track.id), Is.True); client.Groups.DeleteContribution(group, track); tracks = client.Groups.GetContributions(group); Assert.That(tracks.All(x => x.id != track.id), Is.True); }
public void Test_Me_WebProfile_Post_Delete() { var client = SoundCloudClient.CreateAuthorized(_settings.Token); var profile = new WebProfile(); profile.url = "http://facebook.com"; profile.title = "Facebook"; profile.service = WebService.Facebook; var postResult = client.Me.PostWebProfile(profile); Assert.That(postResult.IsSuccess, Is.True); Assert.That(postResult.Data.url, Is.EqualTo(profile.url)); Assert.That(postResult.Data.title, Is.EqualTo(profile.title)); var profiles = client.Me.GetWebProfiles(); Assert.That(profiles.Any(x => x.id == postResult.Data.id), Is.True); var deleteResult = client.Me.DeleteWebProfile(postResult.Data); Assert.That(deleteResult.IsSuccess, Is.True); profiles = client.Me.GetWebProfiles(); Assert.That(profiles.All(x => x.id != postResult.Data.id), Is.True); }
public async Task Me_Follow_Unfollow() { const int userId = 66852985; var client = SoundCloudClient.CreateAuthorized(Settings.Token); var user = new User { Id = userId }; var followResult = await client.Me.FollowAsync(user); Assert.That(followResult.Errors, Is.Empty); var followingsResult1 = await client.Me.GetFollowingsAsync(); Assert.That(followingsResult1, Has.One.Matches <User>(x => x.Id == user.Id)); var unfollowResult = await client.Me.UnfollowAsync(user); Assert.That(unfollowResult.Errors, Is.Empty); var followingsResult2 = await client.Me.GetFollowingsAsync(); Assert.That(followingsResult2, Has.None.Matches <User>(x => x.Id == user.Id)); }
public async Task Me_Like_Unlike() { const int trackId = 211433527; var client = SoundCloudClient.CreateAuthorized(Settings.Token); var track = new Track { Id = trackId }; var likeResult = await client.Me.LikeAsync(track); Assert.That(likeResult.Errors, Is.Empty); var favoritesResult1 = await client.Me.GetFavoritesAsync(); Assert.That(favoritesResult1, Has.One.Matches <Track>(x => x.Id == track.Id)); var unlikeResult = await client.Me.UnlikeAsync(track); Assert.That(unlikeResult.Errors, Is.Empty); var favoritesResult2 = await client.Me.GetFavoritesAsync(); Assert.That(favoritesResult2, Has.None.Matches <Track>(x => x.Id == track.Id)); }
public async Task Me_WebProfile_Post_Delete() { var client = SoundCloudClient.CreateAuthorized(Settings.Token); var profile = new WebProfile { Url = "http://facebook.com", Title = "Facebook", Service = WebService.Facebook }; var postResult = await client.Me.PostWebProfileAsync(profile); Assert.That(postResult.Url, Is.EqualTo(profile.Url)); Assert.That(postResult.Title, Is.EqualTo(profile.Title)); var profilesResult1 = await client.Me.GetWebProfilesAsync(); Assert.That(profilesResult1, Has.One.Matches <Track>(x => x.Id == postResult.Id)); var deleteResult = await client.Me.DeleteWebProfileAsync(postResult); Assert.That(deleteResult.Error, Is.Null.Or.Empty); Assert.That(deleteResult.Errors, Is.Empty); var profilesResult2 = await client.Me.GetWebProfilesAsync(); Assert.That(profilesResult2, Has.None.Matches <Track>(x => x.Id == postResult.Id)); }
public void Test_Playlists_GetSecretToken() { var client = SoundCloudClient.CreateAuthorized(_settings.Token); var playlist = new Playlist(); playlist.title = "TestPlaylist"; playlist.tracks = new List <Track>(); playlist.tracks.Add(new Track { id = TrackId }); playlist.tag_list = new List <string> { "Sampletag", "Sampletag2" }; playlist.genre = "Sample"; playlist.playlist_type = PlaylistType.Compilation; var postResult = client.Playlists.Post(playlist); Assert.IsTrue(postResult.IsSuccess); var token = client.Playlists.GetSecretToken(postResult.Data); client.Playlists.Delete(postResult.Data); Assert.That(string.IsNullOrWhiteSpace(token.token), Is.False); }
public async Task Playlists_GetSecretToken() { var client = SoundCloudClient.CreateAuthorized(Settings.Token); var playlist = new Playlist(); playlist.Title = "TestPlaylist"; playlist.Tracks = new List <Track> { new Track { Id = TrackId } }; playlist.TagList = new List <string> { "Sampletag", "Sampletag2" }; playlist.Genre = "Sample"; playlist.PlaylistType = PlaylistType.Compilation; var postResult = await client.Playlists.PostAsync(playlist); Assert.That(postResult.Title, Is.EqualTo(playlist.Title)); var token = await client.Playlists.GetSecretTokenAsync(postResult); Assert.That(token.Token, Is.Not.Empty); var deleteResult = await client.Playlists.DeleteAsync(postResult); Assert.That(deleteResult.Error, Is.Null.Or.Empty); Assert.That(deleteResult.Errors, Is.Empty); }
public void Test_Playlists_Get() { var client = SoundCloudClient.CreateAuthorized(_settings.Token); var playlist = new Playlist(); playlist.title = "TestPlaylist"; playlist.tracks = new List <Track>(); playlist.tracks.Add(new Track { id = TrackId }); playlist.tag_list = new List <string> { "Sampletag", "Sampletag2" }; playlist.genre = "Sample"; playlist.playlist_type = PlaylistType.Compilation; var postResult = client.Playlists.Post(playlist); Assert.IsTrue(postResult.IsSuccess); var requestPlaylist = client.Playlists.Get(postResult.Data.id); client.Playlists.Delete(postResult.Data); Assert.That(requestPlaylist, Is.Not.Null); Assert.That(requestPlaylist.tracks.Count, Is.GreaterThanOrEqualTo(1)); Assert.That(requestPlaylist.uri.Query, Does.Contain("oauth_token=" + _settings.Token)); Assert.That(requestPlaylist.created_with.uri.Query, Does.Contain("oauth_token=" + _settings.Token)); Assert.That(requestPlaylist.tracks[0].uri.Query, Does.Contain("oauth_token=" + _settings.Token)); Assert.That(requestPlaylist.user.uri.Query, Does.Contain("oauth_token=" + _settings.Token)); }
public void Test_Me_GetConnections() { var client = SoundCloudClient.CreateAuthorized(_settings.Token); var connections = client.Me.GetConnections().ToList(); Assert.That(connections.Any(), Is.True); }
public void Test_Me_GetActivity() { var client = SoundCloudClient.CreateAuthorized(_settings.Token); var activities = client.Me.GetActivities().Take(100).ToList(); Assert.That(activities.Any(), Is.True); }
public void Test_Me_GetFollowings() { var client = SoundCloudClient.CreateAuthorized(_settings.Token); var followings = client.Me.GetFollowings(); Assert.That(followings.Any(), Is.True); }
public void Test_Me_GetWebProfiles() { var client = SoundCloudClient.CreateAuthorized(_settings.Token); var groups = client.Me.GetWebProfiles().ToList(); Assert.That(groups.Any(), Is.True); }
public void Test_Me_GetTracks() { var client = SoundCloudClient.CreateAuthorized(_settings.Token); var tracks = client.Me.GetTracks(); Assert.That(tracks.Any(), Is.True); }
public void Test_Me_GetPlaylists() { var client = SoundCloudClient.CreateAuthorized(_settings.Token); var playlists = client.Me.GetPlaylists().ToList(); Assert.That(playlists.Any(), Is.True); }
public async Task Me_Get() { var client = SoundCloudClient.CreateAuthorized(Settings.Token); var user = await client.Me.GetAsync(); Assert.That(user, Is.Not.Null); Assert.That(user.Username, Is.EqualTo("sharpsound")); }
public async Task Test_Apps_Get() { var client = SoundCloudClient.CreateAuthorized(Settings.Token); var apps = await client.Apps.GetAllAsync(); var result = await client.Apps.GetAsync(apps.First().Id); Assert.That(result, Is.Not.Null); Assert.That(result.Id, Is.EqualTo(apps.First().Id)); }
public void Test_Tracks_Post_Delete() { var client = SoundCloudClient.CreateAuthorized(_settings.Token); var title = "SampleTitle at " + DateTime.Now.ToLocalTime(); var postResult = client.Tracks.UploadTrack(title, TestDataProvider.GetSound()); Assert.That(postResult.Data.title, Is.EqualTo(title)); var postedTrack = postResult.Data; postedTrack.commentable = false; postedTrack.description = "TestDescription"; postedTrack.download_url = new Uri("http://sampleurl.com"); postedTrack.downloadable = true; postedTrack.genre = "SampleGenre"; postedTrack.label_name = "MySampleLabel"; postedTrack.license = License.CcBy; postedTrack.purchase_url = new Uri("http://sampleurl.com"); postedTrack.release_day = 10; postedTrack.release_month = 10; postedTrack.release_year = 2010; postedTrack.sharing = Sharing.Public; postedTrack.tag_list = new List <string> { "Tag1", "Tag2" }; postedTrack.title = "NewTitle"; postedTrack.track_type = TrackType.Sample; var updateResult = client.Tracks.UploadArtwork(postedTrack, TestDataProvider.GetArtwork()); Assert.That(updateResult.Data.artwork_url, Is.Not.Null); updateResult = client.Tracks.Update(postedTrack); Assert.That(updateResult.Data.description, Is.EqualTo(postedTrack.description)); Assert.That(updateResult.Data.download_url.ToString(), Does.Contain("https://api.soundcloud.com/tracks/" + postedTrack.id + "/download")); Assert.That(updateResult.Data.downloadable, Is.EqualTo(postedTrack.downloadable)); Assert.That(updateResult.Data.genre, Is.EqualTo(postedTrack.genre)); Assert.That(updateResult.Data.label_name, Is.EqualTo(postedTrack.label_name)); Assert.That(updateResult.Data.license, Is.EqualTo(postedTrack.license)); Assert.That(updateResult.Data.purchase_url, Is.EqualTo(postedTrack.purchase_url)); Assert.That(updateResult.Data.release_day, Is.EqualTo(postedTrack.release_day)); Assert.That(updateResult.Data.release_month, Is.EqualTo(postedTrack.release_month)); Assert.That(updateResult.Data.release_year, Is.EqualTo(postedTrack.release_year)); Assert.That(updateResult.Data.sharing, Is.EqualTo(postedTrack.sharing)); Assert.That(updateResult.Data.tag_list.Contains("Tag1"), Is.True); Assert.That(updateResult.Data.tag_list.Contains("Tag2"), Is.True); Assert.That(updateResult.Data.title, Is.EqualTo(postedTrack.title)); Assert.That(updateResult.Data.track_type, Is.EqualTo(postedTrack.track_type)); client.Tracks.Delete(postedTrack); Assert.Pass(); }
public void Test_Apps_Get() { var client = SoundCloudClient.CreateAuthorized(_settings.Token); var appToGet = client.Apps.Get().First(); var app = client.Apps.Get(appToGet.id); Assert.That(app, Is.Not.Null); Assert.That(app.uri.Query, Does.Contain(_settings.Token)); }
public void Test_Me_Get() { var client = SoundCloudClient.CreateAuthorized(_settings.Token); var user = client.Me.Get(); Assert.That(user, Is.Not.Null); Assert.That(user.username, Is.EqualTo("sharpsound")); Assert.That(user.uri.Query, Does.Contain(_settings.Token)); }
public async Task Tracks_Post_Delete() { var client = SoundCloudClient.CreateAuthorized(Settings.Token); var title = "SampleTitle at " + DateTime.Now.ToLocalTime(); var postResult = await client.Tracks.UploadTrackAsync(title, TestDataProvider.GetSound()); Assert.That(postResult.Title, Is.EqualTo(title)); postResult.Commentable = false; postResult.Description = "TestDescription"; postResult.DownloadUrl = new Uri("http://sampleurl.com"); postResult.Downloadable = true; postResult.Genre = "SampleGenre"; postResult.LabelName = "MySampleLabel"; postResult.License = License.CcBy; postResult.PurchaseUrl = new Uri("http://sampleurl.com"); postResult.ReleaseDay = 10; postResult.ReleaseMonth = 10; postResult.ReleaseYear = 2010; postResult.Sharing = Sharing.Public; postResult.TagList = new List <string> { "Tag1", "Tag2" }; postResult.Title = "NewTitle"; postResult.TrackType = TrackType.Sample; var uploadArtworkResult = await client.Tracks.UploadArtworkAsync(postResult, TestDataProvider.GetArtwork()); Assert.That(uploadArtworkResult.ArtworkUrl, Is.Not.Null); var updateResult = await client.Tracks.UpdateAsync(postResult); Assert.That(updateResult.Description, Is.EqualTo(postResult.Description)); Assert.That(updateResult.DownloadUrl.ToString(), Does.Contain("https://api.soundcloud.com/tracks/" + postResult.Id + "/download")); Assert.That(updateResult.Downloadable, Is.EqualTo(postResult.Downloadable)); Assert.That(updateResult.Genre, Is.EqualTo(postResult.Genre)); Assert.That(updateResult.LabelName, Is.EqualTo(postResult.LabelName)); Assert.That(updateResult.License, Is.EqualTo(postResult.License)); Assert.That(updateResult.PurchaseUrl, Is.EqualTo(postResult.PurchaseUrl)); Assert.That(updateResult.ReleaseDay, Is.EqualTo(postResult.ReleaseDay)); Assert.That(updateResult.ReleaseMonth, Is.EqualTo(postResult.ReleaseMonth)); Assert.That(updateResult.ReleaseYear, Is.EqualTo(postResult.ReleaseYear)); Assert.That(updateResult.Sharing, Is.EqualTo(postResult.Sharing)); Assert.That(updateResult.TagList, Has.Member("Tag1")); Assert.That(updateResult.TagList, Has.Member("Tag2")); Assert.That(updateResult.Title, Is.EqualTo(postResult.Title)); Assert.That(updateResult.TrackType, Is.EqualTo(postResult.TrackType)); var deleteResult = await client.Tracks.DeleteAsync(updateResult); Assert.That(deleteResult.Error, Is.Null.Or.Empty); Assert.That(deleteResult.Errors, Is.Empty); }
public async Task Tracks_GetSecretToken() { var client = SoundCloudClient.CreateAuthorized(Settings.Token); var track = new Track { Id = TrackId }; var secretToken = await client.Tracks.GetSecretTokenAsync(track); Assert.That(string.IsNullOrEmpty(secretToken.Token), Is.False); }
public void Test_Tracks_GetSecretToken() { var client = SoundCloudClient.CreateAuthorized(_settings.Token); var track = new Track(); track.id = TrackId; var secretToken = client.Tracks.GetSecretToken(track); Assert.That(string.IsNullOrEmpty(secretToken.token), Is.False); }
public void Test_Groups_GetPendingTracks() { var client = SoundCloudClient.CreateAuthorized(_settings.Token); var group = new Group(); group.id = GroupId; var pendingTracks = client.Groups.GetPendingTracks(group).Take(100).ToList(); Assert.That(pendingTracks.Count, Is.GreaterThanOrEqualTo(0)); }
public void Test_Groups_GetContributions() { var client = SoundCloudClient.CreateAuthorized(_settings.Token); var group = new Group(); group.id = GroupId; var contributions = client.Groups.GetContributions(group).Take(100).ToList(); Assert.That(contributions.Count, Is.GreaterThan(0)); }
public void Test_Playlists_Post_Update_Delete() { var client = SoundCloudClient.CreateAuthorized(_settings.Token); var playlist = new Playlist(); playlist.title = "TestPlaylist"; playlist.tracks = new List <Track>(); playlist.tracks.Add(new Track { id = TrackId }); playlist.tag_list = new List <string> { "Sampletag", "Sampletag2" }; playlist.genre = "Sample"; playlist.playlist_type = PlaylistType.Compilation; var postResult = client.Playlists.Post(playlist); Assert.That(postResult.IsSuccess, Is.True); Assert.That(postResult.Data.tracks.Count, Is.EqualTo(1)); Assert.That(postResult.Data.tracks.Any(x => x.id == TrackId), Is.True); Assert.That(postResult.Data.tag_list.Count, Is.EqualTo(2)); Assert.That(postResult.Data.tag_list.Contains("Sampletag"), Is.True); Assert.That(postResult.Data.tag_list.Contains("Sampletag2"), Is.True); Assert.That(postResult.Data.genre, Is.EqualTo(playlist.genre)); Assert.That(postResult.Data.title, Is.EqualTo(playlist.title)); var postedPlaylist = postResult.Data; postedPlaylist.title = "New Title"; postedPlaylist.tag_list = new List <string> { "Sampletag3" }; postedPlaylist.genre = "Sample2"; var updatedPlaylist = client.Playlists.Update(postedPlaylist); Assert.That(updatedPlaylist.Data.tracks.Count, Is.EqualTo(1)); Assert.That(updatedPlaylist.Data.tracks.Any(x => x.id == TrackId), Is.True); Assert.That(updatedPlaylist.Data.tag_list.Count, Is.EqualTo(1)); Assert.That(updatedPlaylist.Data.tag_list.Contains("Sampletag3"), Is.True); Assert.That(updatedPlaylist.Data.genre, Is.EqualTo(postResult.Data.genre)); updatedPlaylist = client.Playlists.UploadArtwork(updatedPlaylist.Data, TestDataProvider.GetArtwork()); Assert.That(string.IsNullOrEmpty(updatedPlaylist.Data.artwork_url), Is.False); client.Playlists.Delete(postResult.Data); Assert.Pass(); }
/// <summary> /// Requests a pair of Access and RefreshToken based on the passed AccessToken. /// if successfull, initializes an authorized <see cref="SoundCloudClient"/>. /// </summary> /// <param name="accesstoken"></param> /// <returns></returns> public Result <SoundCloudAuthenticationStateEnum> Initialize(string accesstoken) { if (!string.IsNullOrEmpty(accesstoken)) { _client = SoundCloudClient.CreateAuthorized(accesstoken); Logger.Info("Authorized client initialized"); _messenger.Send(new SoundCloudAuthenticationMessage(SoundCloudAuthenticationStateEnum.LoggedInAuthenticated)); return(new SuccessResult <SoundCloudAuthenticationStateEnum>(SoundCloudAuthenticationStateEnum.LoggedInAuthenticated)); } return(Logout()); }
public async Task Playlists_Post_Update_Delete() { var client = SoundCloudClient.CreateAuthorized(Settings.Token); var playlist = new Playlist(); playlist.Title = "TestPlaylist"; playlist.Tracks = new List <Track> { new Track { Id = TrackId } }; playlist.TagList = new List <string> { "Sampletag", "Sampletag2" }; playlist.Genre = "Sample"; playlist.PlaylistType = PlaylistType.Compilation; var postResult = await client.Playlists.PostAsync(playlist); Assert.That(postResult.Tracks, Has.Exactly(1).Items); Assert.That(postResult.Tracks, Has.One.Matches <Track>(x => x.Id == TrackId)); Assert.That(postResult.TagList, Has.Exactly(2).Items); Assert.That(postResult.TagList, Has.Member("Sampletag")); Assert.That(postResult.TagList, Has.Member("Sampletag2")); Assert.That(postResult.Genre, Is.EqualTo(playlist.Genre)); Assert.That(postResult.Title, Is.EqualTo(playlist.Title)); postResult.Title = "New Title"; postResult.TagList = new List <string> { "Sampletag3" }; postResult.Genre = "Sample2"; var updateResult = await client.Playlists.UpdateAsync(postResult); Assert.That(updateResult.Tracks, Has.Exactly(1).Items); Assert.That(updateResult.Tracks, Has.One.Matches <Track>(x => x.Id == TrackId)); Assert.That(updateResult.TagList, Has.Exactly(1).Items); Assert.That(updateResult.TagList, Has.Member("Sampletag3")); Assert.That(updateResult.Genre, Is.EqualTo(postResult.Genre)); var uploadArtworkResult = await client.Playlists.UploadArtworkAsync(updateResult, TestDataProvider.GetArtwork()); Assert.That(uploadArtworkResult.ArtworkUrl, Is.Not.Empty); var deleteResult = await client.Playlists.DeleteAsync(postResult); Assert.That(deleteResult.Error, Is.Null.Or.Empty); Assert.That(deleteResult.Errors, Is.Empty); }
public void Me_Follow_Unknown_User() { const int userId = 999999999; var client = SoundCloudClient.CreateAuthorized(Settings.Token); var user = new User { Id = userId }; var exception = Assert.ThrowsAsync <SoundCloudApiException>(async() => await client.Me.FollowAsync(user)); Assert.That(exception.HttpStatusCode, Is.EqualTo(HttpStatusCode.NotFound)); }
public void Test_Tracks_Get() { var client = SoundCloudClient.CreateAuthorized(_settings.Token); var tracks = client.Tracks.Get(TrackId); Assert.That(tracks, Is.Not.Null); Assert.That(tracks.genre, Is.EqualTo("Sample")); Assert.That(tracks.playback_count, Is.GreaterThan(0)); Assert.That(tracks.uri.Query, Does.Contain("oauth_token=" + _settings.Token)); Assert.That(tracks.stream_url.Query, Does.Contain("oauth_token=" + _settings.Token)); Assert.That(tracks.user.uri.Query, Does.Contain("oauth_token=" + _settings.Token)); }
public void Test_Me_Follow_Unknown_User() { const int userId = 999999999; var client = SoundCloudClient.CreateAuthorized(_settings.Token); var user = new User(); user.id = userId; var result = client.Me.Follow(user); Assert.That(result.IsSuccess, Is.False); Assert.That(result.ErrorMessage, Is.EqualTo("404 - Not Found")); }