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"));
}
