public async Task HandleWithValidUpdateRequestCallUpdateAsExpectedResult()
{
// Arrange
var watchListEntity = new WatchList { MovieId = 299536, Comments = "Avengers: Infinity War is good" };
var watchListModel = new WatchListModel { MovieId = 299536, Comments = "Avengers: Infinity is good" };
var config = new MapperConfiguration(m => { m.CreateMap<WatchList, WatchListModel>(); });
var mapper = new Mapper(config);
repository = new Mock<IRepository>();
repository.Setup(m => m.Get<WatchList>(It.IsAny<int>()))
.Returns(watchListEntity);
updateWatchList = new UpdateWatchList(repository.Object, mapper);
updateWatchListRequest = new UpdateWatchListRequest(watchListModel);
// Act
CancellationToken cancellationToken;
var result = await updateWatchList.Handle(updateWatchListRequest, cancellationToken);
// Assert
Assert.NotNull(result);
Assert.Equal(watchListModel.Comments, result.Comments);
Assert.Equal(watchListModel.MovieId, result.MovieId);
}
public async Task HandleWithNullCreateRequestCallRetrunNullWithThrowsException()
{
// Arrange
var watchListEntity = new WatchList {
MovieId = 299536, Comments = "Avengers: Infinity War is good"
};
var watchListModel = new WatchListModel {
MovieId = 299536, Comments = "Avengers: Infinity War"
};
var config = new MapperConfiguration(m => { m.CreateMap <WatchList, WatchListModel>(); });
var mapper = new Mapper(config);
repository = new Mock <IRepository>();
repository.Setup(m => m.Get <WatchList>(It.IsAny <int>()))
.Returns(watchListEntity);
createWatchList = new CreateBooking(repository.Object, mapper);
createWatchListRequest = new CreateBookingRequest(watchListModel);
// Act
CancellationToken cancellationToken;
var result = await createWatchList.Handle(createWatchListRequest, cancellationToken);
// Assert
Assert.Null(result);
}
/// <summary>
/// Method to fetch watch list entity model based on watch list ID.
/// </summary>
/// <param name="watchListId">Id of watch list entity to be fetched.</param>
/// <returns>Watch list model corresponding to the model.</returns>
private WatchListModel GetWatchListEntityModel(int watchListId)
{
IWatchListBusiness iWatchListBusiness = new WatchListBusiness();
var watchListEntities = iWatchListBusiness.SearchWatchList(new GridSearchCriteriaEntity(), watchListId);
return(WatchListModel.ConvertWatchListEntityToModel(watchListEntities[0]));
}
public IQueryable <WatchListModel> GetWatchList()
{
var watchList = new List <WatchListModel>();
this._ConnectionString = string.Format(this._ConnectionString, this.DataSource);
using (var conn = new OleDbConnection(this._ConnectionString))
{
this._SelectAllCommand = string.Format(@"SELECT * FROM [{0}]", this.FileName);
using (var cmd = new OleDbCommand(this._SelectAllCommand, conn))
{
try
{
if (conn.State != System.Data.ConnectionState.Open)
{
conn.Open();
}
var dataAdapter = new OleDbDataAdapter(cmd);
this._DataSet = new DataSet();
dataAdapter.Fill(this._DataSet);
this._DataTable = this._DataSet.Tables[0];
WatchListModel watchListModelDataEntry = null;
for (int i = 0; i < this._DataTable.Rows.Count; ++i)
{
watchListModelDataEntry = new WatchListModel();
watchListModelDataEntry.WatchListID = Convert.ToInt32(_DataTable.Rows[i]["Id"]);
watchListModelDataEntry.BseSymbol = Convert.ToString(_DataTable.Rows[i]["BSESymbol"]);
watchListModelDataEntry.NseSymbol = Convert.ToString(_DataTable.Rows[i]["NSESymbol"]);
watchListModelDataEntry.Name = Convert.ToString(_DataTable.Rows[i]["Name"]);
watchListModelDataEntry.AltNameOne = Convert.ToString(_DataTable.Rows[i]["AltName1"]);
watchListModelDataEntry.AltNameTwo = Convert.ToString(_DataTable.Rows[i]["AltName2"]);
watchListModelDataEntry.TempName = Convert.ToString(_DataTable.Rows[i]["TempName"]);
watchListModelDataEntry.IsActive = Convert.ToBoolean(Convert.ToInt32(_DataTable.Rows[i]["Active"]));
watchListModelDataEntry.AlertRequired = Convert.ToBoolean(Convert.ToInt32(_DataTable.Rows[i]["Alert"]));
watchListModelDataEntry.ModifiedOn = _DataTable.Rows[i]["ModifiedOn"].ToString();
watchListModelDataEntry.CreatedOn = _DataTable.Rows[i]["CreatedOn"].ToString();
watchList.Add(watchListModelDataEntry);
}
}
catch (Exception e)
{
Console.WriteLine("[Error] GetAll() failed.", this.DataSource);
Console.WriteLine(e.Message);
}
finally
{
conn.Close();
}
}
}
return(watchList.AsQueryable());
}
public ActionResult EditWatchList(int?id)
{
var watchListModel = new WatchListModel();
// Fetch watchlist details if it is in edit mode else simply pass an empty model to the view.
if (id != null && id.Value > 0)
{
watchListModel = this.GetWatchListEntityModel(id.Value);
}
return(View("Edit", watchListModel));
}
public JsonResult test([FromJson] GridContext gridContext)
{
IWatchListBusiness iWatchListBusiness = new WatchListBusiness();
var searchCriteria = new GridSearchCriteriaEntity();
var watchListEntities = iWatchListBusiness.SearchWatchList(searchCriteria, 0);
var watchListModels = watchListEntities.Select(x => WatchListModel.ConvertWatchListEntityToModel(x)).ToList();
watchListModels.RemoveAt(3);
var gridModel = this.GetGridModel(watchListModels, searchCriteria.RecordCount);
return(Json(gridModel, JsonRequestBehavior.AllowGet));
}
public static WatchListViewModel ToViewModel(this WatchListModel value)
{
if (value == null)
{
return(null);
}
return(new WatchListViewModel
{
WatchListId = value.WatchListId,
WatchListName = value.WatchListName,
UserId = value.UserId,
Stocks = value.Stocks.Select(s => s.ToViewModel())
});
}
public ActionResult Index()
{
IWatchListBusiness iWatchListBusiness = new WatchListBusiness();
var searchCriteria = new GridSearchCriteriaEntity();
var watchListEntities = iWatchListBusiness.SearchWatchList(searchCriteria, 0);
var watchListModels = watchListEntities.Select(x => WatchListModel.ConvertWatchListEntityToModel(x)).ToList();
//watchListModels.Clear();
var gridModel = this.GetGridModel(watchListModels, searchCriteria.RecordCount);
ViewData["gridModel"] = gridModel;
return(View());
}
public void WatchListModelMappingProfileShouldMapModelWatchListToEntityWatchListAsExpected()
{
// Arrange
var modelWatchList = new WatchListModel {
MovieId = 383498, Comments = "Deadpool 2 is review good"
};
config = new MapperConfiguration(s => { s.AddProfile <BookingMappingProfile>(); });
// Act
var result = config.CreateMapper().Map <WatchList>(modelWatchList);
// Assert
Assert.Equal(modelWatchList.MovieId, result.MovieId);
Assert.Equal(modelWatchList.Comments, result.Comments);
}
public async Task DeleteCallsMediatRWithExpectedResult()
{
// Arrange
var watchListModel = new WatchListModel {
MovieId = 383498, Comments = "Deadpool 2 is review good"
};
mediatR = new Mock <IMediator>();
mediatR.Setup(m => m.Send(It.IsAny <DeleteWatchListRequest>(), It.IsAny <CancellationToken>())).Returns(Task.FromResult(watchListModel));
controller = new WatchListController(mediatR.Object);
// Act
var result = await controller.Delete(1) as OkObjectResult;
// Assert
Assert.NotNull(result);
Assert.Equal(200, result.StatusCode);
}
public async Task PostCallsWithInValidModelStateExpectedNotFoundResult()
{
// Arrange
var watchListModel = new WatchListModel {
MovieId = 383498
};
mediatR = new Mock <IMediator>();
controller = new WatchListController(mediatR.Object);
controller.ModelState.AddModelError("Comments", "Comments is Required");
// Act
var result = await controller.Post(watchListModel) as BadRequestObjectResult;
// Assert
Assert.NotNull(result);
Assert.Equal(400, result.StatusCode);
}
public async Task PostCallsMediatRWithExpectedNotFoundResult()
{
// Arrange
var watchListModel = new WatchListModel {
MovieId = 383498, Comments = "Deadpool 2 is review good"
};
mediatR = new Mock <IMediator>();
mediatR.Setup(m => m.Send(It.IsAny <CreateBookingRequest>(), It.IsAny <CancellationToken>())).Returns(Task.FromResult <WatchListModel>(null));
controller = new WatchListController(mediatR.Object);
// Act
var result = await controller.Post(watchListModel) as ObjectResult;
// Assert
mediatR.Verify(m => m.Send(It.IsAny <CreateBookingRequest>(), It.IsAny <CancellationToken>()), Times.Once());
Assert.NotNull(result);
Assert.Equal(409, result.StatusCode);
}
public async Task PutCallsWithInValidModelStateExpectedNotFoundResult()
{
// Arrange
var watchListModel = new WatchListModel {
MovieId = 383498, Comments = "Deadpool 2 is review good"
};
mediatR = new Mock <IMediator>();
mediatR.Setup(m => m.Send(It.IsAny <UpdateWatchListRequest>(), It.IsAny <CancellationToken>())).Returns(Task.FromResult <WatchListModel>(null));
controller = new WatchListController(mediatR.Object);
controller.ModelState.AddModelError("Comments", "Comments is Required");
// Act
var result = await controller.Put(watchListModel) as BadRequestObjectResult;
// Assert
Assert.NotNull(result);
Assert.Equal(400, result.StatusCode);
}
public JsonResult EditWatchList(WatchListModel watchListModel)
{
// Set the date of creation and modification.
if (watchListModel.WatchListID > 0)
{
watchListModel.ModifiedOn = DataFormatter.FormatDateToString(DateTime.Now);
}
else
{
watchListModel.CreatedOn = DataFormatter.FormatDateToString(DateTime.Now);
}
// Save the changes and return new grid model as JSON result if the save is successful.
this.SaveWatchListItem(watchListModel);
return(Json(this.CreateWatchListGridModel(new GridContext {
SortInfo = new GridSortInfo {
SortOn = "Name"
}
})));
}
public async Task PostCallsMediatRWithExpectedResult()
{
// Arrange
var watchListModel = new WatchListModel {
MovieId = 383498, Comments = "Deadpool 2 is review good"
};
mediatR = new Mock <IMediator>();
mediatR.Setup(m => m.Send(It.IsAny <CreateBookingRequest>(), It.IsAny <CancellationToken>())).Returns(Task.FromResult(watchListModel));
controller = new WatchListController(mediatR.Object);
// Act
var result = await controller.Post(watchListModel) as CreatedResult;
// Assert
Assert.NotNull(result);
Assert.Equal(201, result.StatusCode);
var watchListModels = result.Value as WatchListModel;
Assert.NotNull(watchListModels);
Assert.Equal("Deadpool 2 is review good", watchListModels.Comments);
}
/// <summary>
/// Method to save watch list entity.
/// </summary>
/// <param name="watchListModel">The watch list model to be saved.</param>
/// <returns>Id of the watch list item that has been saved.</returns>
private int SaveWatchListItem(WatchListModel watchListModel)
{
IWatchListBusiness iWatchListBusiness = new WatchListBusiness();
return(iWatchListBusiness.SaveWatchListItem(WatchListModel.ConvertModelToWatchListEntity(watchListModel)));
}
