public void Get_WhenDatabaseHasSongs_Returns_ListOfSongResponses_With_CorrectData()
{
var song = new Song
{
Id = Guid.NewGuid(),
Artist = "artist",
Level = 1,
Difficulty = "ESP",
Name = "name"
};
var expectedResponse = new SongResponse
{
Artist = song.Artist,
Difficulty = song.Difficulty,
Id = song.Id,
Level = song.Level,
Name = song.Name
};
_fixture._context.Songs.Add(song);
_fixture._context.SaveChanges();
var actionResult = _songsController.Get(null);
var okObjectResult = Assert.IsType <OkObjectResult>(actionResult.Result);
var songs = Assert.IsAssignableFrom <IEnumerable <SongResponse> >(okObjectResult.Value);
Assert.Collection(songs,
element => Assert.Equal(expectedResponse, element)
);
}
public void Get_WhenSongIdsAreProvided_Returns_ListOfSongsIncludedInRequest()
{
var song1 = new Song
{
Id = Guid.NewGuid(),
Level = 1
};
var song2 = new Song
{
Id = Guid.NewGuid(),
Level = 1
};
_fixture._context.Songs.Add(song1);
var songToGet = _fixture._context.Songs.Add(song2).Entity;
_fixture._context.SaveChanges();
var expectedSong = SongResponse.FromEntity(songToGet);
var actionResult = _songsController.Get(new Guid[] { songToGet.Id });
var okObjectResult = Assert.IsType <OkObjectResult>(actionResult.Result);
var songs = Assert.IsAssignableFrom <IEnumerable <SongResponse> >(okObjectResult.Value);
Assert.Collection(songs,
song => Assert.Equal(song, expectedSong)
);
}
public IActionResult DeleteSong(int id)
{
var songResponse = new SongResponse();
try
{
var songToDelete = _songRepository.Get(id);
if (songToDelete == null)
{
songResponse.AlertMessage = string.Format(MagicString.SongWithIdDoesntExist, id);
return(BadRequest(songResponse));
}
_songRepository.Remove(songToDelete);
if (!_songRepository.Save())
{
songResponse.AlertMessage = MagicString.ProblemOucuredDuringSavingSongToDatabase;
return(BadRequest(songResponse));
}
_googleSlides.Remove(songToDelete.PresentationId);
return(Ok());
}
catch (Exception ex)
{
songResponse.AlertMessage = ex.Message;
return(BadRequest(songResponse));
}
}
public IActionResult GetSong(int id)
{
var songResponse = new SongResponse();
try
{
var songToReturn = _songRepository.Get(id);
if (songToReturn == null)
{
songResponse.AlertMessage = string.Format(MagicString.SongWithIdDoesntExist, id);
return(BadRequest(songResponse));
}
var song = Mapper.Map <SongDto>(songToReturn);
songResponse.Songs = new List <SongDto>()
{
song
};
return(Ok(songResponse));
}
catch (Exception ex)
{
songResponse.AlertMessage = ex.Message;
return(BadRequest(songResponse));
}
}
public static async Task <List <SongListItem> > GetTopSongs()
{
HttpWebRequest request = HttpWebRequest.Create(Constants.URLs.TopSongs) as HttpWebRequest;
HttpWebResponse response = await request.GetResponseAsync() as HttpWebResponse;
return(SongResponse.GetTopSongs(response));
}
public void GetSong_When_SongExists_Returns_SongResponse()
{
var song = new Song
{
Id = Guid.NewGuid(),
Artist = "artist",
Level = 1,
Difficulty = "ESP",
Name = "name"
};
var expectedResponse = new SongResponse
{
Artist = song.Artist,
Difficulty = song.Difficulty,
Id = song.Id,
Level = song.Level,
Name = song.Name
};
_fixture._context.Songs.Add(song);
_fixture._context.SaveChanges();
var actionResult = _songsController.GetSong(song.Id);
var okObjectResult = Assert.IsType <OkObjectResult>(actionResult.Result);
var songResponse = Assert.IsAssignableFrom <SongResponse>(okObjectResult.Value);
Assert.Equal(expectedResponse, songResponse);
}
public static async Task <Song> GetDetails(int id)
{
string url = string.Format(Constants.URLs.SongDetails, id);
HttpWebRequest request = HttpWebRequest.Create(url) as HttpWebRequest;
HttpWebResponse response = await request.GetResponseAsync() as HttpWebResponse;
return(SongResponse.GetDetails(response));
}
public static async Task <List <SongSource> > GetSources(string query, int page = 1)
{
string url = string.Format(Constants.URLs.SongSources, TextTools.GetTidyText(query), page);
HttpWebRequest request = HttpWebRequest.Create(url) as HttpWebRequest;
HttpWebResponse response = await request.GetResponseAsync() as HttpWebResponse;
return(SongResponse.GetSources(response));
}
public async Task GetSongs()
{
foreach (ulong songId in _inputData.Songs)
{
SongResponse song = await _geniusClient.SongClient.GetSong(songId);
Assert.IsNotNull(song.Response.Song);
}
}
public IActionResult GetSongs()
{
var songResponse = new SongResponse();
try
{
var songs = _songRepository.Get();
var results = Mapper.Map <IEnumerable <SongDto> >(songs);
songResponse.Songs = results;
return(Ok(songResponse));
}
catch (Exception ex)
{
songResponse.AlertMessage = ex.Message;
return(BadRequest(songResponse));
}
}
public IActionResult CreateSong(string songName)
{
if (songName == "")
{
return(BadRequest());
}
var presentationId = "";
var songResponse = new SongResponse();
try
{
presentationId = _googleSlides.Create(songName);
var song = new Song()
{
Name = songName, PresentationId = presentationId
};
if (!_songRepository.Add(song))
{
_googleSlides.Remove(presentationId);
songResponse.AlertMessage = MagicString.ProblemOucuredDuringSavingSongToDatabase;
return(BadRequest(songResponse));
}
var createdSong = Mapper.Map <SongDto>(song);
var historyEntity = new History()
{
CreateDate = DateTime.Now,
CreatedBy = GetUserInformation().FullName,
Information = $"Dodano nową piosnkę z Id: {createdSong.Id} o tytule {createdSong.Name}"
};
return(Ok(createdSong));
}
catch (Exception ex)
{
_googleSlides.Remove(presentationId);
songResponse.AlertMessage = ex.Message;
return(BadRequest(songResponse));
}
}
public async Task Put_GivenSongExists_UpdateExistingSongInDatabase()
{
var song = new Song
{
Artist = "artist",
Difficulty = "difficulty",
Level = 5,
Name = "name"
};
var songEntity = await _fixture._context.Songs.AddAsync(song);
await _fixture._context.SaveChangesAsync();
song = songEntity.Entity;
var expectedSongResponse = new SongResponse
{
Artist = "newArtist",
Difficulty = "difficulty",
Level = 15,
Name = "name",
Id = song.Id
};
var actionResult = await _songsController.Put(
song.Id,
new SongRequest
{
Artist = "newArtist",
Difficulty = "difficulty",
Level = 15,
Name = "name",
});
var songFromDatabase = await _fixture._context.Songs.FindAsync(song.Id);
var songFromDatabaseAsResponse = SongResponse.FromEntity(songFromDatabase);
var okObjectResult = Assert.IsType <OkObjectResult>(actionResult.Result);
var songResponse = Assert.IsAssignableFrom <SongResponse>(okObjectResult.Value);
Assert.Equal(songFromDatabaseAsResponse, songResponse);
Assert.Equal(expectedSongResponse, songResponse);
}
public async Task <SongResponse> Create([FromBody] CreateSongRequest request)
{
var artist = await _authenticatedUser.GetArtistAsync();
var album = await _albumCollection.GetAlbumByIdAsync(request.AlbumId);
if ((await album.GetArtistAsync()).Id != artist.Id)
{
throw new HttpException(HttpStatusCode.Unauthorized);
}
var song = await album.CreateSongAsync(request.Name, request.Duration);
if (song == null)
{
throw new HttpException(HttpStatusCode.InternalServerError);
}
return(await SongResponse.CreateFromSongAsync(song));
}
public IActionResult UpdateSong(int id, SongForUpdateDto song)
{
if (song == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var songResponse = new SongResponse();
try
{
var songToUpdate = _songRepository.Get(id);
if (songToUpdate == null)
{
songResponse.AlertMessage = string.Format(MagicString.SongWithIdDoesntExist, id);
return(BadRequest(songResponse));
}
Mapper.Map(song, songToUpdate);
if (!_songRepository.Save())
{
songResponse.AlertMessage = MagicString.ProblemOucuredDuringSavingSongToDatabase;
return(BadRequest(songResponse));
}
return(Ok());
}
catch (Exception ex)
{
songResponse.AlertMessage = ex.Message;
return(BadRequest(songResponse));
}
}
public async Task Post_ShouldReturnNewSong_With_SongEndpoint()
{
var songRequest = new SongRequest
{
Artist = "Artist1",
Difficulty = "Hard",
Level = 5,
Name = "Song1"
};
var songGuid = Guid.Parse("F531D138-44F2-4400-A21B-C3D9A3C8D485");
var expectedSongResponse = new SongResponse
{
Artist = songRequest.Artist,
Difficulty = songRequest.Difficulty,
Id = songGuid,
Level = songRequest.Level,
Name = songRequest.Name
};
_songService.Add(Arg.Any <Song>()).Returns(
args => Task.FromResult <Song>(new Song
{
Id = songGuid,
Artist = args.ArgAt <Song>(0).Artist,
Difficulty = args.ArgAt <Song>(0).Difficulty,
Level = args.ArgAt <Song>(0).Level,
Name = args.ArgAt <Song>(0).Name
}));
var actionResult = await _songsController.Post(songRequest);
var createdResult = Assert.IsType <CreatedResult>(actionResult.Result);
Assert.Equal($"/songs/{songGuid}", createdResult.Location);
var songResponse = Assert.IsType <SongResponse>(createdResult.Value);
Assert.Equal(expectedSongResponse, songResponse);
await _coreDataService.Received(1).SaveChanges();
}
public void GetSong_WhenSongIsFound_ReturnsOkObjectResult_With_SongResponse()
{
var song = new Song
{
Id = Guid.NewGuid(),
Artist = "Artist1",
Difficulty = "Difficulty",
Level = 15,
Name = "Name1"
};
var expectedSongResponse = SongResponse.FromEntity(song);
_songService.Get(Arg.Is <Guid>(song.Id)).Returns(song);
var actionResult = _songsController.GetSong(song.Id);
var okObjectResult = Assert.IsType <OkObjectResult>(actionResult.Result);
var songResponse = Assert.IsType <SongResponse>(okObjectResult.Value);
Assert.Equal(expectedSongResponse, songResponse);
}
private Song FetchSong(SongResponse s) =>
_library.TryGetSong(s.SongId, out Song song)
? song
: new Song(s.SongId, Guid.NewGuid(), s.Artist.FirstOrDefault(), s.Album, s.Label, s.Track, s.File);
