// Deleting a Upload music object from the database
public async Task <UploadMusic> DeleteUploadedMusicAsync(UploadMusic uploadedMusic2BDeleted)
{
_context.UploadMusic.Remove(uploadedMusic2BDeleted);
await _context.SaveChangesAsync();
return(uploadedMusic2BDeleted);
}
private static string AddAlbum(UploadMusic tmp)
{
string firstpath = GetElementPath(tmp.MusicPart.Musics.First().Author);
string path = Path.Combine(firstpath, string.Join("", tmp.MusicPart.Name.Split(Path.GetInvalidFileNameChars())));
Directory.CreateDirectory(path);
return(path);
}
private static void AddAuthor(UploadMusic tmp)
{
var music = tmp.MusicPart.Musics.First();
string path = Path.Combine("c:\\AllMusics", music.Author.Name);
Directory.CreateDirectory(path);
ServerMusics.Add(new Author(music.Author.Name, path));
}
// Adding a Upload music object to the database
public async Task <UploadMusic> AddUploadedMusicAsync(UploadMusic newUploadedMusic)
{
await _context.UploadMusic.AddAsync(newUploadedMusic);
await _context.SaveChangesAsync();
return(newUploadedMusic);
}
public void MusicPlayListUploadMusicShouldBeSet()
{
UploadMusic upload = new UploadMusic {
Name = "Test"
};
testMusicPlaylist.UploadMusic = upload;
Assert.Equal("Test", testMusicPlaylist.UploadMusic.Name);
}
public async Task AddUploadMusicShouldAddUploadMusic()
{
var uploadMusic = new UploadMusic();
_mixerBLMock.Setup(x => x.AddUploadedMusicAsync(It.IsAny <UploadMusic>())).Returns(Task.FromResult <UploadMusic>(uploadMusic));
var uploadMusicController = new UploadMusicController(_mixerBLMock.Object);
var result = await uploadMusicController.AddUploadedMusicAsync(new UploadMusic());
Assert.IsAssignableFrom <CreatedAtActionResult>(result);
_mixerBLMock.Verify(x => x.AddUploadedMusicAsync((It.IsAny <UploadMusic>())));
}
// Updating a uploaded music object by getting the old object, setting its information with the new object passed into it, and then saving it to the database
public async Task <UploadMusic> UpdateUploadedMusicAsync(UploadMusic uploadedMusic2BUpdated)
{
UploadMusic oldUploadedMusic = await _context.UploadMusic.Where(um => um.Id == uploadedMusic2BUpdated.Id).FirstOrDefaultAsync();
_context.Entry(oldUploadedMusic).CurrentValues.SetValues(uploadedMusic2BUpdated);
await _context.SaveChangesAsync();
_context.ChangeTracker.Clear();
return(uploadedMusic2BUpdated);
}
public async Task DeleteUploadedMusicAsyncShouldDeleteUploadedMusic()
{
var newUpload = new UploadMusic();
_musicBLMock.Setup(x => x.DeleteUploadedMusicAsync(It.IsAny <UploadMusic>())).Returns(Task.FromResult <UploadMusic>(newUpload));
var newMusicBL = new UploadedMusicBL(_musicBLMock.Object);
var result = await newMusicBL.DeleteUploadedMusicAsync(newUpload);
Assert.Equal(result, newUpload);
_musicBLMock.Verify(x => x.DeleteUploadedMusicAsync(It.IsAny <UploadMusic>()));
}
public async Task GetUploadedMusicByIdAsyncShouldGetUploadedMusic()
{
var uploadId = 1;
var newUpload = new UploadMusic();
_musicBLMock.Setup(x => x.GetUploadedMusicByIDAsync(It.IsAny <int>())).Returns(Task.FromResult <UploadMusic>(newUpload));
var newMusicBL = new UploadedMusicBL(_musicBLMock.Object);
var result = await newMusicBL.GetUploadedMusicByIDAsync(uploadId);
Assert.Equal(result, newUpload);
_musicBLMock.Verify(x => x.GetUploadedMusicByIDAsync(It.IsAny <int>()));
}
public async Task DeleteUploadMusicShouldDeleteUploadMusic()
{
var uploadMusic = new UploadMusic {
Id = 1
};
_mixerBLMock.Setup(x => x.DeleteUploadedMusicAsync(It.IsAny <UploadMusic>())).Returns(Task.FromResult <UploadMusic>(uploadMusic));
var uploadMusicController = new UploadMusicController(_mixerBLMock.Object);
var result = await uploadMusicController.DeleteUploadedMusicAsync(uploadMusic.Id);
Assert.IsAssignableFrom <NoContentResult>(result);
_mixerBLMock.Verify(x => x.DeleteUploadedMusicAsync((It.IsAny <UploadMusic>())));
}
public async Task <IActionResult> UpdateUploadedMusicAsync(int id, [FromBody] UploadMusic uploadedMusic)
{
try
{
await _mixerBL.UpdateUploadedMusicAsync(uploadedMusic);
return(NoContent());
}
catch
{
return(StatusCode(500));
}
}
public async Task AddUploadedMusicAsyncShouldAddUploadedMusic()
{
var newUpload = new UploadMusic {
Name = "Test", MusicFilePath = "Test"
};
_musicBLMock.Setup(x => x.AddUploadedMusicAsync(It.IsAny <UploadMusic>())).Returns(Task.FromResult <UploadMusic>(newUpload));
var newMusicBL = new UploadedMusicBL(_musicBLMock.Object);
var result = await newMusicBL.AddUploadedMusicAsync(newUpload);
Assert.Equal(result, newUpload);
_musicBLMock.Verify(x => x.AddUploadedMusicAsync(It.IsAny <UploadMusic>()));
}
public async Task GetUploadMusicAsyncShouldReturnUploadMusic()
{
//arrange
UploadMusic uploadMusic = new UploadMusic();
_mixerBLMock.Setup(i => i.GetUploadedMusicAsync());
UploadMusicController uploadMusicController = new UploadMusicController(_mixerBLMock.Object);
//act
var result = await uploadMusicController.GetUploadedMusicAsync();
//assert
Assert.IsType <OkObjectResult>(result);
}
private void TreatUploadMusic(Socket socket, UploadMusic uploadMusic)
{
if (Indexation.AddElement(uploadMusic) && (int)Program.MyServer.Clients.GetUser(socket).Rank > 1)
{
new UploadReport(null, true).Send(socket);
Program.MyServer.Log.Warn($"The music { uploadMusic.MusicPart.Name } has been upload");
}
else
{
new UploadReport(null, false).Send(socket);
Program.MyServer.Log.Warn($"The music { uploadMusic.MusicPart.Name } has been upload");
Program.MyServer.Log.Warn("Upload completed with success");
}
}
public async Task GetUploadByUserIdShouldGetUploadMusic()
{
var uploadMusicId = 1;
var uploadMusic = new UploadMusic {
UserId = uploadMusicId
};
_mixerBLMock.Setup(x => x.GetUploadedMusicByIDAsync(It.IsAny <int>())).Returns(Task.FromResult(uploadMusic));
var uploadMusicController = new UploadMusicController(_mixerBLMock.Object);
var result = await uploadMusicController.GetUploadedMusicByIDAsync(uploadMusicId);
Assert.Equal(uploadMusicId, ((UploadMusic)((OkObjectResult)result).Value).UserId);
_mixerBLMock.Verify(x => x.GetUploadedMusicByIDAsync(uploadMusicId));
}
public async Task <IActionResult> AddUploadedMusicAsync([FromBody] UploadMusic uploadedMusic)
{
try
{
await _mixerBL.AddUploadedMusicAsync(uploadedMusic);
Log.Logger.Information($"new song with ID {uploadedMusic.Id} created");
return(CreatedAtAction("AddUploadedMusic", uploadedMusic));
}
catch (Exception e)
{
Log.Logger.Error($"Error thrown uploading music: {e.Message}");
return(Ok(e.Message));
}
}
// Adding a new song
public async Task <UploadMusic> AddUploadedMusicAsync(UploadMusic newUploadedMusic)
{
// creating a new UploadMusic object to add to the database
UploadMusic uploadMusic2Add = new UploadMusic();
uploadMusic2Add.Id = newUploadedMusic.Id;
uploadMusic2Add.MusicFilePath = newUploadedMusic.MusicFilePath;
uploadMusic2Add.Name = newUploadedMusic.Name;
uploadMusic2Add.UploadDate = DateTime.Now;
uploadMusic2Add.UserId = newUploadedMusic.UserId;
uploadMusic2Add.IsPrivate = newUploadedMusic.IsPrivate;
uploadMusic2Add.IsApproved = newUploadedMusic.IsApproved;
uploadMusic2Add.IsLocked = newUploadedMusic.IsPrivate;
return(await _repo.AddUploadedMusicAsync(uploadMusic2Add));
}
public async Task DeleteUploadedMusicAsync_ShouldReturnNoContent_WhenUploadMusicIsValid()
{
//arrange
int uploadedMusicID = 1;
UploadMusic uploadMusic = new UploadMusic();
_uploadMusicBLMock.Setup(x => x.DeleteUploadedMusicAsync(uploadMusic)).ReturnsAsync(uploadMusic);
UploadMusicController uploadedMusicController = new UploadMusicController(_uploadMusicBLMock.Object);
//act
var result = await uploadedMusicController.DeleteUploadedMusicAsync(uploadedMusicID);
//assert
Assert.IsType <NoContentResult>(result);
// Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsInstanceOfType(result, typeof(NoContentResult));
}
public async Task GetUploadedMusicByUserIdAsync_ShouldReturn_OKObjectResult_WhenIDIsValid()
{
//arrange
int userID = 2;
UploadMusic uploadMusic = new UploadMusic();
_uploadMusicBLMock.Setup(x => x.GetUploadedMusicByIDAsync(userID)).ReturnsAsync(uploadMusic);
UploadMusicController uploadedMusicController = new UploadMusicController(_uploadMusicBLMock.Object);
//act
var result = await uploadedMusicController.GetUploadedMusicByIDAsync(userID);
//assert
Assert.IsType <OkObjectResult>(result);
// Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsInstanceOfType(result, typeof(OkObjectResult));
}
public async Task AddUploadedMusicAsyncShouldAddUploadedMusic()
{
using (var context = new MusicDBContext(options))
{
IMusicRepoDB _repo = new MusicRepoDB(context);
UploadMusic testUploadMusic = new UploadMusic();
testUploadMusic.UserId = 1;
testUploadMusic.MusicFilePath = "cool_song";
testUploadMusic.Name = "Jumping Jacks";
testUploadMusic.UploadDate = DateTime.Parse("2021-03-15 18:17:00");
testUploadMusic.Likes = 3409;
testUploadMusic.Plays = 9084;
var newUploadMusic = await _repo.AddUploadedMusicAsync(testUploadMusic);
Assert.Equal("Jumping Jacks", newUploadMusic.Name);
}
}
public static bool AddElement(UploadMusic tmp)
{
if (!Indexation.IsElementExisting(tmp.MusicPart.Musics.First().Author))
{
AddAuthor(tmp);
}
if (Indexation.IsElementExisting(tmp.MusicPart))
{
if (IsElementExisting(tmp.MusicPart.Musics.First()))
{
return(false);
}
else
{
if (AddMusic(tmp))
{
return(true);
}
}
}
else
{
string path = AddAlbum(tmp);
var music = tmp.MusicPart.Musics.First();
string MusicPath = Path.Combine(path, music.Title + music.Format);
System.IO.File.WriteAllBytes(MusicPath, tmp.MusicPart.Musics.First().FileBinary);
MusicsInfo.SaveMusicInfo(tmp.MusicPart.Musics.First());
foreach (var a in ServerMusics)
{
if (a.MID == music.Author.MID)
{
music.FileBinary = null;
music.ServerPath = MusicPath;
music.Author = a;
Album tmpAl = new Album(a, tmp.MusicPart.Name, path);
music.Album = tmpAl;
tmpAl.Add(music);
a.Albums.Add(tmpAl);
return(true);
}
}
}
return(false);
}
public async Task DeleteUploadedMusicAsync_ShouldReturnStatusCode500_WhenInvalid()
{
//arrange
int uploadMusicID = -2;
UploadMusic uploadMusic = null;
_uploadMusicBLMock.Setup(x => x.DeleteUploadedMusicAsync(uploadMusic)).Throws(new Exception());
UploadMusicController uploadedMusicController = new UploadMusicController(_uploadMusicBLMock.Object);
//act
var result = await uploadedMusicController.DeleteUploadedMusicAsync(uploadMusicID);
//assert
Assert.IsType <StatusCodeResult>(result);
Assert.Equal(500, ((StatusCodeResult)result).StatusCode);
//Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsInstanceOfType(result, typeof(StatusCodeResult));
// Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(500, ((StatusCodeResult)result).StatusCode);
}
public static bool AddMusic(UploadMusic tmp)
{
var music = tmp.MusicPart.Musics.First();
string path = Path.Combine(GetElementPath(tmp.MusicPart), music.Title + music.Format);
System.IO.File.WriteAllBytes(path, tmp.MusicPart.Musics.First().FileBinary);
MusicsInfo.SaveMusicInfo(tmp.MusicPart.Musics.First());
var album = GetAlbum(tmp.MusicPart.MID);
if (album != null)
{
music.FileBinary = null;
music.ServerPath = path;
music.Author = album.Author;
music.Album = album;
album.Add(music);
return(true);
}
return(false);
}
public async Task DeleteUploadedMusicAsyncShouldDeleteUploadedMusic()
{
using (var context = new MusicDBContext(options))
{
IMusicRepoDB _repo = new MusicRepoDB(context);
UploadMusic testUploadMusic = new UploadMusic();
testUploadMusic.Id = 4;
testUploadMusic.UserId = 1;
testUploadMusic.MusicFilePath = "cool_song";
testUploadMusic.Name = "Jumping Jacks";
testUploadMusic.UploadDate = DateTime.Parse("2021-03-15 18:17:00");
testUploadMusic.Likes = 3409;
testUploadMusic.Plays = 9084;
var newUploadMusic = await _repo.AddUploadedMusicAsync(testUploadMusic);
var deletedUploadMusic = await _repo.DeleteUploadedMusicAsync(testUploadMusic);
using (var assertContext = new MusicDBContext(options))
{
var result = assertContext.UploadMusic.Find(4);
Assert.Null(result);
}
}
}
// Updating a song track
public async Task <UploadMusic> UpdateUploadedMusicAsync(UploadMusic uploadedMusic2BUpdated)
{
return(await _repo.UpdateUploadedMusicAsync(uploadedMusic2BUpdated));
}
// Deleting a song
public async Task <UploadMusic> DeleteUploadedMusicAsync(UploadMusic uploadedMusic2BDeleted)
{
return(await _repo.DeleteUploadedMusicAsync(uploadedMusic2BDeleted));
}
