public async Task SongController_Destroy_ShouldReturnRedirectWithSuccessTempData()
{
//Arrenge
string successMessage = null;
int songId = 1;
var songService = this.GetAdminSongServiceBaseMock();
songService
.Setup(s => s.DeleteAsync(It.IsAny <int>()))
.ReturnsAsync(true);
var tempDate = new Mock <ITempDataDictionary>();
tempDate.SetupSet(t => t[WebConstants.TempDataSuccessMessageKey] = It.IsAny <string>())
.Callback((string key, object message) => successMessage = message as string);
var controller = new SongsController(null, songService.Object);
controller.TempData = tempDate.Object;
//Act
var result = await controller.Destroy(songId);
//Assert
successMessage.Should().Be("Song has been deleted successfully");
result.Should().BeOfType <RedirectToActionResult>();
result.As <RedirectToActionResult>().ActionName.Should().Be("ListAll");
}
public void Get_Songs_From_Moq()
{
var serviceMock = new Mock <ISongsService>();
serviceMock.Setup(x => x.GetAll()).Returns(() => new List <Song> {
new Song()
{
Id = new Guid("5DC85CE0-D978-4112-AC5D-9A30CE70F175"),
Title = "Er zit meer in een liedje dan je denkt",
IsDeleted = false
},
new Song()
{
Id = new Guid("25A5C147-7F60-421C-8213-3FBCC6293A7D"),
Title = "Er zit meer in een liedje dan je denkt",
IsDeleted = false
},
new Song()
{
Id = new Guid("C47F59CA-0007-4E16-93F5-93C5A5848209"),
Title = "Er zit meer in een liedje dan je denkt",
IsDeleted = false
}
});
var controller = new SongsController(serviceMock.Object);
var result = _songsController.Get();
Assert.IsType <OkObjectResult>(result);
}
public async Task ReturnViewWithoutModelWhenSongIsUploadedSuccessfully()
{
string expectedMessage = "successfully";
var fileStub = new Mock <IFormFile>();
fileStub.Setup(f => f.ContentType).Returns(() => "audio");
fileStub.Setup(f => f.Length).Returns(() => SongMaxLength - 1);
var uploadSongStub = new Mock <ICommandService <UploadSong> >();
SongFormModel model = new SongFormModel()
{
File = fileStub.Object
};
// Arrange
SongsController sut = CreateSongsController(
uploadSong: uploadSongStub.Object);
// Act
var result = await sut.Upload(model) as WithMessageResult;
var realAction = result.Action as ViewResult;
// Assert
Assert.IsNull(realAction.Model);
}
public SongsControllerTests()
{
_service = new Mock <ISongService>();
_service.Setup(x => x.GetAllAsync()).ReturnsAsync(GetTestSongs());
_service.Setup(x => x.GetAllAsync()).ReturnsAsync(GetTestSongs());
_controller = new SongsController(_service.Object);
}
public async Task ReturnViewWithErrorMessageWhenCommandServiceThrowNotFoundException()
{
string expectedMessage = "Fake message";
var fileStub = new Mock <IFormFile>();
fileStub.Setup(f => f.ContentType).Returns(() => "audio");
fileStub.Setup(f => f.Length).Returns(() => SongMaxLength - 1);
var editSongStub = new Mock <ICommandService <EditSong> >();
editSongStub.Setup(u => u.ExecuteAsync(It.IsAny <EditSong>()))
.Throws(new NotFoundException(expectedMessage));
SongFormModel model = new SongFormModel()
{
File = fileStub.Object
};
// Arrange
SongsController sut = CreateSongsController(
editSong: editSongStub.Object);
// Act
var result = await sut.Edit(It.IsAny <string>(), model) as WithMessageResult;
// Assert
Assert.AreEqual(typeof(WithMessageResult), result.GetType());
Assert.AreEqual("danger", result.Type);
Assert.AreEqual(expectedMessage, result.Message);
}
public async Task ReturnViewWithSuccessMessageWhenSongIsEditedSuccessfully()
{
string expectedMessage = "edited successfully";
var fileStub = new Mock <IFormFile>();
fileStub.Setup(f => f.ContentType).Returns(() => "audio");
fileStub.Setup(f => f.Length).Returns(() => SongMaxLength - 1);
var editSongMock = new Mock <ICommandService <EditSong> >();
SongFormModel model = new SongFormModel()
{
File = fileStub.Object
};
// Arrange
SongsController sut = CreateSongsController(
editSong: editSongMock.Object);
// Act
var result = await sut.Edit(It.IsAny <string>(), model) as WithMessageResult;
// Assert
Assert.AreEqual(typeof(WithMessageResult), result.GetType());
Assert.AreEqual("success", result.Type);
StringAssert.Contains(expectedMessage, result.Message);
}
public void SongsGet()
{
var testSubject = new SongsController(_testRepo);
var result = testSubject.Get();
Assert.IsTrue(result.Value.ToList().Count > 19);
}
public void SongsDelete()
{
var testSubject = new SongsController(_testRepo);
var testObject = _testRepo.Get(0);
testSubject.Delete(testObject.Id);
Assert.IsTrue(_testRepo.GetAll().Count < 20);
}
public SongsControllerTests()
{
_logger = Substitute.For <ILogger <SongsController> >();
_songService = Substitute.For <ISong>();
_fileStorage = Substitute.For <IFileStorage>();
_coreDataService = Substitute.For <ICoreData>();
_songsController = new SongsController(_logger, _coreDataService, _fileStorage, _songService);
}
public void HaveRequiredAttribute(Type attrType)
{
// Arrange
SongsController sut = CreateSongsController(Mock.Of <ICommandService <EditSong> >());
// Act && Assert
Assert.IsTrue(MethodHasAttribute(
() => sut.Edit(It.IsAny <string>(), default(SongFormModel)),
attrType));
}
public void MockTest()
{
var mock = new Mock <IGetDataRepository>();
mock.Setup(p => p.GetSongById(1)).Returns("Summer of 69");
SongsController song = new SongsController(mock.Object);
string result = song.GetSongById(1);
NUnit.Framework.Assert.AreEqual("Summer of 69", result);
}
public void InitializeSongsControllerCorrectly_WhenDependenciesAreNotNull()
{
var mapperMock = new Mock <IMapper>();
var songServiceMock = new Mock <ISongService>();
var genreServiceMock = new Mock <IGenreService>();
var controller = new SongsController(songServiceMock.Object, mapperMock.Object);
Assert.IsNotNull(controller);
}
public void SongsPut()
{
var testSubject = new SongsController(_testRepo);
var newObject = new Song()
{
Id = 1, Artist = "TestArtist"
};
testSubject.Put(1, newObject);
Assert.IsTrue(_testRepo.Get(1).Artist == "TestArtist");
}
public void SongsPost()
{
var testSubject = new SongsController(_testRepo);
var testObject = new Song()
{
Id = 20, Artist = "TestArtist"
};
testSubject.Post(testObject);
Assert.IsTrue(_testRepo.GetAll().Count > 20);
}
public void Delete()
{
// Arrange
SongsController controller = new SongsController();
// Act
ViewResult result = controller.Delete(6) as ViewResult;
// Assert
Assert.IsNotNull(result);
}
public void Edit()
{
// Arrange
SongsController controller = new SongsController();
// Act
ViewResult result = controller.Edit(5) as ViewResult;
// Assert
Assert.IsNotNull(result);
}
public void SongsFilter() //TODO figure out where this argument null exception comes from
{
var testSubject = new SongsController(_testRepo);
var result = testSubject.Get("Hans2");
//var fact = _testRepo.GetQueryable().Where(x => x.Artist == "Hans2").ToList();
Assert.IsTrue(result != null);
var resultList = result.Value;
var resultItem = resultList.FirstOrDefault();
Assert.IsTrue(resultItem.Artist == "Hans2");
}
public void Index()
{
// Arrange
SongsController _controller = new SongsController();
// Act
ViewResult result = _controller.Index() as ViewResult;
// Assert
NUnit.Framework.Assert.IsNotNull(result);
NUnit.Framework.Assert.AreSame(result.ViewData["Message"], "I made this project to keep track of songs that I have.");
}
public SongsControllerTests(PostgresDatabaseFixture fixture)
{
_fixture = fixture;
_logger = new Logger <SongsController>(new NullLoggerFactory());
_coreDataService = new DbCoreData(_fixture._context);
_fileStorage = Substitute.For <IFileStorage>();
_songService = new DbSong(_fixture._context);
_songsController = new SongsController(_logger, _coreDataService, _fileStorage, _songService);
Setup.DropAllRows(_fixture._context);
}
public void EditArtist()
{
// Arrange
SongsController controller = new SongsController();
// Act
ViewResult result = controller.Edit(5) as ViewResult;
// Assert
Assert.AreEqual("ACDC", result.ViewBag.Artist);
Assert.AreNotEqual("Greenday", result.ViewBag.Artist);
Assert.IsNull(result.ViewBag.Artist);
Assert.IsNotNull(result.ViewBag);
}
public void Create()
{
// Arrange
SongsController controller = new SongsController();
// Act
ViewResult result = controller.Create() as ViewResult;
// Assert
Assert.IsNotNull(result);
Assert.AreSame(controller.User.Identity.Name, "Abc@123");
Assert.AreSame(controller.Create(), "Jason");
Assert.AreSame(controller.Request.Headers["X-Requested-With"].ToString(), "XMLHttpRequest");
}
public SongsControllerUnitTest()
{
_testSongs = new List <Song>
{
new Song
{
Duration = TimeSpan.FromSeconds(100),
Id = 1,
Lyrics = "lyrics",
Rating = 5,
Title = "Song1"
},
new Song
{
Duration = TimeSpan.FromSeconds(200),
Id = 2,
Lyrics = "lyrics",
Rating = 5,
Title = "Song1"
},
new Song
{
Duration = TimeSpan.FromSeconds(300),
Id = 3,
Lyrics = "lyrics",
Rating = 5,
Title = "Song3"
}
}.AsQueryable();
var mockSet = new Mock <DbSet <Song> >();
mockSet.As <IAsyncEnumerable <Song> >()
.Setup(d => d.GetEnumerator())
.Returns(new TestDbAsyncEnumerator <Song>(_testSongs.GetEnumerator()));
mockSet.As <IQueryable <Song> >().Setup(m => m.Provider)
.Returns(new TestAsyncQueryProvider <Song>(_testSongs.Provider));
mockSet.As <IQueryable <Song> >().Setup(m => m.Expression).Returns(_testSongs.Expression);
mockSet.As <IQueryable <Song> >().Setup(m => m.ElementType).Returns(_testSongs.ElementType);
mockSet.As <IQueryable <Song> >().Setup(m => m.GetEnumerator()).Returns(_testSongs.GetEnumerator());
var dbContext = new Mock <DataContext>();
dbContext.Setup(dc => dc.Songs).Returns(mockSet.Object);
dbContext.Setup(dc => dc.Set <Song>()).Returns(mockSet.Object);
_controller = new SongsController(dbContext.Object);
}
public async Task ReturnViewWithErrorMessageWhenSongFileIsNull()
{
SongFormModel model = new SongFormModel();
// Arrange
SongsController sut = CreateSongsController(Mock.Of <ICommandService <UploadSong> >());
// Act
var result = await sut.Upload(model) as WithMessageResult;
// Assert
Assert.AreEqual(typeof(WithMessageResult), result.GetType());
Assert.AreEqual("danger", result.Type);
StringAssert.Contains("choose a file", result.Message);
}
public async Task SongController_GetEdit_ShouldReturnBadRequestWhenSongIsNull()
{
//Arrenge
var adminSongService = this.GetAdminSongServiceBaseMock();
adminSongService
.Setup(s => s.GetByIdAsync(It.IsAny <int>()))
.ReturnsAsync((AdminSongEditServiceModel)null);
var controller = new SongsController(null, adminSongService.Object);
//Act
var result = await controller.Edit(1);
//Assert
result.Should().BeOfType <BadRequestResult>();
}
public async Task SongController_GetDetails_ShouldReturnBadRequestWhenSongDoesNotExist()
{
//Arrenge
var adminSongService = this.GetAdminSongServiceBaseMock();
adminSongService
.Setup(s => s.DetailsAsync(It.IsAny <int>()))
.ReturnsAsync((AdminSongDetailsServiceModel)null);
var controller = new SongsController(null, adminSongService.Object);
//Act
var result = await controller.Details(10);
//Assert
result.Should().BeOfType <BadRequestResult>();
}
public async Task ReturnViewWithTheSameModelWhenSongFileIsNull()
{
SongFormModel model = new SongFormModel();
// Arrange
SongsController sut = CreateSongsController(Mock.Of <ICommandService <UploadSong> >());
// Act
var result = await sut.Upload(model) as WithMessageResult;
var realAction = result.Action as ViewResult;
// Assert
Assert.IsNotNull(realAction.Model);
Assert.AreSame(model, realAction.Model);
}
/// <summary>
/// does the pot action for the table specified
/// </summary>
/// <param name="table">the table(API)</param>
private static void postAPICall(string table)
{
if (table.Equals("songs"))
{
Assignment2.song s = getSongPostInfo();
SongsController cont = new SongsController();
string result = cont.PostSong(s);
Console.WriteLine(result);
}
else if (table.Equals("reviews"))
{
Assignment2.review r = getReviewPostInfo();
ReviewsController cont = new ReviewsController();
string result = cont.PostReview(r);
Console.WriteLine(result);
}
}
public void Create()
{
// arrange
var optionsBuilder = new DbContextOptionsBuilder <ApplicationDbContext>().UseInMemoryDatabase("test");
var context = new ApplicationDbContext(optionsBuilder.Options);
context.Database.EnsureDeleted();
context.Database.EnsureCreated();
var controller = new SongsController(context);
//act
//assert
}
public async Task SongController_ListAll_ShouldreturnViewWithSongs()
{
//Arrange
const int TotalSongs = 2;
var adminSongService = this.GetAdminSongServiceBaseMock();
adminSongService
.Setup(s => s.AllAsync(It.IsAny <int>()))
.ReturnsAsync(new List <AdminSongListingServiceModel>
{
new AdminSongListingServiceModel {
Id = FirstUserId, Name = FirstUserName, Artist = FirstArtistName
},
new AdminSongListingServiceModel {
Id = SecondUserId, Name = SecondUserName, Artist = SecondArtistName
}
});
adminSongService
.Setup(s => s.TotalAsync())
.ReturnsAsync(TotalSongs);
var controller = new SongsController(null, adminSongService.Object);
//Act
var result = await controller.ListAll(1);
//Assert
result.Should().BeOfType <ViewResult>();
var model = result.As <ViewResult>().Model;
model.Should().BeOfType <SongListingViewModel>();
var formModel = model.As <SongListingViewModel>();
formModel.AllSongs.Should().Match(s => s.Count() == 2);
formModel.CurrentPage.Should().Be(1);
formModel.TotalSongs.Should().Be(TotalSongs);
formModel.AllSongs.First().Should().Match(s => s.As <AdminSongListingServiceModel>().Id == FirstUserId);
formModel.AllSongs.First().Should().Match(s => s.As <AdminSongListingServiceModel>().Name == FirstUserName);
formModel.AllSongs.First().Should().Match(s => s.As <AdminSongListingServiceModel>().Artist == FirstArtistName);
formModel.AllSongs.Last().Should().Match(s => s.As <AdminSongListingServiceModel>().Id == SecondUserId);
formModel.AllSongs.Last().Should().Match(s => s.As <AdminSongListingServiceModel>().Name == SecondUserName);
formModel.AllSongs.Last().Should().Match(s => s.As <AdminSongListingServiceModel>().Artist == SecondArtistName);
}
public void GetRetunsString()
{
var options = new DbContextOptionsBuilder <MusicDbContext>()
.UseInMemoryDatabase(databaseName: "ReturnStringTest")
.Options;
//Arrange
using (var context = new MusicDbContext(options))
{
var controller = new SongsController(context);
//Act
var result = controller.Get(5);
//Assert
Assert.IsType <string>(result);
}
}
