public new void SetUp()
{
base.SetUp();
MockLotService = new Mock <ILotService>();
SystemUnderTest = new LotsController(MockLotService.Object, MockUserIdentityProvider.Object);
}
public void Lot_Unexist_Test()
{
// Arrange
Mock <ILotsRepository> mock = new Mock <ILotsRepository>();
mock.Setup(m => m.Lots).Returns(new []
{
new Lot {
LotID = 1, Name = "P1"
},
}.AsQueryable());
LotsController target = new LotsController(mock.Object, null)
{
PageSize = 3
};
//Act
var result = target.Lot(null);
var result1 = target.Lot(3);
//Assert
Assert.IsInstanceOfType(result, typeof(RedirectToRouteResult));
RedirectToRouteResult routeResult = result as RedirectToRouteResult;
Assert.AreEqual(routeResult.RouteValues["action"], "List");
Assert.IsInstanceOfType(result1, typeof(RedirectToRouteResult));
RedirectToRouteResult routeResult1 = result1 as RedirectToRouteResult;
Assert.AreEqual(routeResult1.RouteValues["action"], "List");
}
public void SetUp()
{
MockLotService = new Mock <ILotService>();
MockUserIdentityProvider = new Mock <IUserIdentityProvider>();
LotsControler = new LotsController(MockLotService.Object, MockUserIdentityProvider.Object);
}
public void Remove_Test()
{
// Arrange - create a Lot
Lot prod = new Lot {
LotID = 2, Name = "Test"
};
// Arrange - create the mock repository
Mock <ILotsRepository> mock = new Mock <ILotsRepository>();
mock.Setup(m => m.Lots).Returns(new Lot[]
{
new Lot {
LotID = 1, Name = "P1"
},
prod,
new Lot {
LotID = 3, Name = "P3"
},
}.AsQueryable());
// Arrange - create the controller
LotsController target = new LotsController(mock.Object, null);
// Act - delete the Lot
target.Remove(prod.LotID, null);
// Assert - ensure that the repository delete method was
// called with the correct Lot
mock.Verify(m => m.Remove(prod));
}
public async Task GetLotReturnsBadRequestResultWhenIdIsNull()
{
var mockLotService = new Mock <ILotService>();
var controller = new LotsController(null, mockLotService.Object, null);
var result = await controller.CreateLot(null);
Assert.IsType <BadRequestObjectResult>(result);
}
public async Task GetLotReturnsNotFoundResultWhenLotNotFound()
{
var mockLotService = new Mock <ILotService>();
var controller = new LotsController(null, mockLotService.Object, null);
var result = await controller.GetLotWithBids(-1);
Assert.IsType <NotFoundResult>(result);
}
public void Paginate_Tes()
{
// Arrange
Mock <ICategoriesRepository> category = new Mock <ICategoriesRepository>();
category.Setup(m => m.Categories).Returns(new[]
{
new Category
{
CategoryId = 1,
CategoryName = "Cat1",
Lots = new List <Lot>()
},
new Category
{
CategoryId = 2,
CategoryName = "Cat2",
Lots = new List <Lot>()
},
new Category
{
CategoryId = 3,
CategoryName = "Cat3",
Lots = new List <Lot>()
}
}.AsQueryable());
Mock <ILotsRepository> mock = new Mock <ILotsRepository>();
mock.Setup(m => m.Lots).Returns(new[] {
new Lot {
LotID = 1, Name = "P1", IsCompleted = false
},
new Lot {
LotID = 2, Name = "P2", IsCompleted = false
},
new Lot {
LotID = 3, Name = "P3", IsCompleted = false
},
new Lot {
LotID = 4, Name = "P4", IsCompleted = false
},
}.AsQueryable());
LotsController controller = new LotsController(mock.Object, category.Object)
{
PageSize = 3
};
// Act
LotsListViewModel result = (LotsListViewModel)controller.List(null, 2).Model;
//Assert
Lot[] prodArray = result.Lots.ToArray();
Assert.IsTrue(prodArray.Length == 1);
Assert.AreEqual(prodArray[0].Name, "P4");
}
public void LotsController_Create_ReturnsProperView()
{
var mockLotService = new Mock <ILotService>();
var lotsController = new LotsController(mockLotService.Object);
var result = lotsController.Create();
Assert.IsNotNull(result);
Assert.IsInstanceOf(typeof(ViewResult), result);
Assert.IsInstanceOf(typeof(LotModel), ((ViewResult)result).Model);
}
public void LotsController_ActiveLots_ReturnsActiveLots()
{
var mockLotService = new Mock <ILotService>();
mockLotService
.Setup(m => m.SearchLotModels(It.IsAny <SearchModel>()))
.Returns(GetTestLotsModels());
var lotsController = new LotsController(mockLotService.Object);
var result = (ViewResult)(lotsController.ActiveLots(null, null));
Assert.IsNotNull(result);
Assert.IsInstanceOf(typeof(LotViewModel), result.Model);
Assert.AreEqual(GetTestLotsModels().Count(l => l.IsActive), ((LotViewModel)result.Model).Lots.Count());
}
public async Task LotsController_Details_WithNotExistingLotReturnsNotFound()
{
var mockLotService = new Mock <ILotService>();
mockLotService
.Setup(m => m.GetByIdAsync(It.IsAny <int>()))
.ReturnsAsync((LotModel)null);
var lotsController = new LotsController(mockLotService.Object);
var result = await lotsController.Details(0);
Assert.IsNotNull(result);
Assert.IsInstanceOf(typeof(RedirectToRouteResult), result);
Assert.AreEqual("Errors", ((RedirectToRouteResult)result).RouteValues["controller"]);
Assert.AreEqual("NotFound", ((RedirectToRouteResult)result).RouteValues["action"]);
}
public void Lot_Exist_Test()
{
// Arrange
Mock <ILotsRepository> mock = new Mock <ILotsRepository>();
mock.Setup(m => m.Lots).Returns(new Lot[]
{
new Lot {
LotID = 1, Name = "P1"
},
new Lot {
LotID = 2, Name = "P2"
},
new Lot {
LotID = 3, Name = "P2"
},
new Lot {
LotID = 4, Name = "P2"
},
new Lot {
LotID = 5, Name = "P2"
},
new Lot {
LotID = 6, Name = "P2"
},
new Lot {
LotID = 7, Name = "P2"
}
}.AsQueryable());
LotsController target = new LotsController(mock.Object, null)
{
PageSize = 3
};
//Act
var result = target.Lot(1);
var vResult = result as ViewResult;
//Assert
if (vResult == null)
{
Assert.Fail();
}
var model = (Lot)vResult.Model;
Assert.AreEqual(model.Name, "P1");
}
public void SearchImage_Test()
{
// Arrange
Mock <ILotsRepository> mock = new Mock <ILotsRepository>();
mock.Setup(m => m.Lots).Returns(new Lot[]
{
new Lot {
LotID = 1, Name = "P1"
},
new Lot {
LotID = 2, Name = "P2"
},
new Lot {
LotID = 3, Name = "P2"
},
new Lot {
LotID = 4, Name = "P2"
},
new Lot {
LotID = 5, Name = "P2"
},
new Lot {
LotID = 6, Name = "P2"
},
new Lot {
LotID = 7, Name = "P2"
}
}.AsQueryable());
LotsController target = new LotsController(mock.Object, null)
{
PageSize = 3
};
//Act
var vResult = target.SearchLot("P1") as ViewResult;;
var result = (LotsListViewModel)vResult.Model;
//Assert
Lot[] prodArray = result.Lots.ToArray();
Assert.IsTrue(prodArray.Length == 1);
Assert.AreEqual(prodArray[0].Name, "P1");
}
public async Task LotsController_Sell_SellsLot()
{
var lot = GetTestLotsModels().First();
var mockLotService = new Mock <ILotService>();
mockLotService
.Setup(m => m.SellLot(It.IsAny <int>(), It.IsAny <int>()))
.ReturnsAsync(new InternetAuction.BLL.Infrastructure.OperationDetails(true));
var lotsController = new LotsController(mockLotService.Object);
var result = await lotsController.Sell(lot.Id, lot.Bets.First().Id);
Assert.IsNotNull(result);
Assert.IsInstanceOf(typeof(RedirectToRouteResult), result);
var res = ((RedirectToRouteResult)result);
Assert.AreEqual("Lots", res.RouteValues["controller"]);
Assert.AreEqual("Details", res.RouteValues["action"]);
Assert.AreEqual("Lot sold successfully", lotsController.TempData["Success"]);
}
public async Task LotsController_Details_ReturnsViewProperLot()
{
var lot = GetTestLotsModels().First();
var mockLotService = new Mock <ILotService>();
mockLotService
.Setup(m => m.GetByIdAsync(It.IsAny <int>()))
.ReturnsAsync(lot);
var lotsController = new LotsController(mockLotService.Object);
var result = (ViewResult)(await lotsController.Details(lot.Id));
Assert.IsNotNull(result);
Assert.IsInstanceOf(typeof(LotModel), result.Model);
var model = (LotModel)result.Model;
Assert.AreEqual(lot.Id, model.Id);
Assert.AreEqual(lot.StartPrice, model.StartPrice);
Assert.AreEqual(lot.SellerId, model.SellerId);
}
public void Recive_Invalid_Id_Image_Test()
{
// Arrange
Mock <ILotsRepository> mock = new Mock <ILotsRepository>();
mock.Setup(m => m.Lots).Returns(new Lot[]
{
new Lot {
LotID = 1, Name = "P1"
},
new Lot {
LotID = 2, Name = "P2"
}
}.AsQueryable());
LotsController target = new LotsController(mock.Object, null);
// Act
ActionResult result = target.GetImage(100, 0);
// Assert
Assert.IsNull(result);
}
public void SetUp()
{
_mockLotService = new Mock <IParkingLotsService>();
_mockLotService
.Setup(m => m.Get())
.Returns(() => new[] {
new ParkingLotGET {
Name = "Lot 1", AvailableSpaces = 0
},
new ParkingLotGET {
Name = "Lot 2", AvailableSpaces = 100
},
new ParkingLotGET {
Name = "Structure 1", AvailableSpaces = 0
},
new ParkingLotGET {
Name = "Structure 2", AvailableSpaces = 100
}
});
_controller = new LotsController(_mockLotService.Object);
}
public void Get_Image_Test()
{
// Arrange - create a Lot with image data
Lot prod = new Lot
{
LotID = 2,
Name = "Test",
Images = new List <Image>
{
new Image
{
ImageData = new byte[] {},
ImageMimeType = "image/png"
}
}
};
// Arrange - create the mock repository
Mock <ILotsRepository> mock = new Mock <ILotsRepository>();
mock.Setup(m => m.Lots).Returns(new Lot[] {
new Lot {
LotID = 1, Name = "P1"
},
prod,
new Lot {
LotID = 3, Name = "P3"
}
}.AsQueryable());
// Arrange - create the controller
LotsController target = new LotsController(mock.Object, null);
// Act - call the GetImage action method
ActionResult result = target.GetImage(2, 0);
// Assert
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(FileResult));
Assert.AreEqual(prod.Images.First().ImageMimeType, ((FileResult)result).ContentType);
}
public void LotsController_ActiveLots_WithFiltersReturnsProperLots()
{
var mockLotService = new Mock <ILotService>();
mockLotService
.Setup(m => m.SearchLotModels(It.IsAny <SearchModel>()))
.Returns(GetTestLotsModels());
var lotsController = new LotsController(mockLotService.Object);
var searchModel = new SearchModel
{
MinPrice = 1500,
MaxPrice = 3000
};
var result = (ViewResult)(lotsController.ActiveLots(searchModel, null));
Assert.IsNotNull(result);
Assert.IsInstanceOf(typeof(LotViewModel), result.Model);
Assert.AreEqual(GetTestLotsModels().Count(l => l.StartPrice > 500 &&
l.StartPrice < 3000 &&
l.IsActive),
((LotViewModel)result.Model).Lots.Count());
}
public void ListView_Model()
{
// Arrange
Mock <ICategoriesRepository> category = new Mock <ICategoriesRepository>();
category.Setup(m => m.Categories).Returns(new[]
{
new Category
{
CategoryId = 1,
CategoryName = "Cat1",
Lots = new List <Lot>()
},
new Category
{
CategoryId = 2,
CategoryName = "Cat2",
Lots = new List <Lot>()
},
new Category
{
CategoryId = 3,
CategoryName = "Cat3",
Lots = new List <Lot>()
}
}.AsQueryable());
Mock <ILotsRepository> mock = new Mock <ILotsRepository>();
mock.Setup(m => m.Lots).Returns(new Lot[]
{
new Lot {
LotID = 1, Name = "P1"
},
new Lot {
LotID = 2, Name = "P2"
},
new Lot {
LotID = 3, Name = "P3"
},
new Lot {
LotID = 4, Name = "P4"
},
new Lot {
LotID = 5, Name = "P5"
}
}.AsQueryable());
LotsController controller = new LotsController(mock.Object, category.Object);
controller.PageSize = 3;
// Act
LotsListViewModel result = (LotsListViewModel)controller.List(null, 2).Model;
// Assert
PageModel pageInfo = result.PageModel;
Assert.AreEqual(pageInfo.CurrentPage, 2);
Assert.AreEqual(pageInfo.ItemsPerPage, 3);
Assert.AreEqual(pageInfo.TotalItems, 5);
Assert.AreEqual(pageInfo.TotalPages, 2);
}
public void Filter_Lots_Test()
{
// Arrange
Mock <ICategoriesRepository> category = new Mock <ICategoriesRepository>();
category.Setup(m => m.Categories).Returns(new[]
{
new Category
{
CategoryId = 1,
CategoryName = "Cat1",
Lots = new List <Lot>()
},
new Category
{
CategoryId = 2,
CategoryName = "Cat2",
Lots = new List <Lot>()
},
new Category
{
CategoryId = 3,
CategoryName = "Cat3",
Lots = new List <Lot>()
}
}.AsQueryable());
Mock <ILotsRepository> mock = new Mock <ILotsRepository>();
mock.Setup(m => m.Lots).Returns(new[]
{
new Lot {
LotID = 1, Name = "P1", Category = category.Object.Categories.ToList()[0]
},
new Lot {
LotID = 2, Name = "P2", Category = category.Object.Categories.ToList()[1]
},
new Lot {
LotID = 3, Name = "P3", Category = category.Object.Categories.ToList()[0]
},
new Lot {
LotID = 4, Name = "P4", Category = category.Object.Categories.ToList()[1]
},
new Lot {
LotID = 5, Name = "P5", Category = category.Object.Categories.ToList()[2]
}
}.AsQueryable());
category.Object.Categories.ToList()[1].Lots.Add(mock.Object.Lots.ToList()[1]);
category.Object.Categories.ToList()[1].Lots.Add(mock.Object.Lots.ToList()[3]);
LotsController controller = new LotsController(mock.Object, category.Object)
{
PageSize = 3
};
// Action
Lot[] result = ((LotsListViewModel)controller.List(2, 1).Model).Lots.ToArray();
// Assert
Assert.AreEqual(result.Length, 2);
Assert.IsTrue(result[0].Name == "P2" && result[0].Category.CategoryName == "Cat2");
Assert.IsTrue(result[1].Name == "P4" && result[1].Category.CategoryName == "Cat2");
}
//Dependency Inversion
//Instead of being dependent on the database
//Change the dependency direction
public LotTest()
{
this.mockLotRepo = new Mock <ILotRepo>();
this.mockLotTypeRepo = new Mock <ILotTypeRepo>();
controller = new LotsController(mockLotRepo.Object, mockLotTypeRepo.Object);
}
public void Lot_Count_Test()
{
// Arrange
// - create the mock repository
// Arrange
Mock <ICategoriesRepository> category = new Mock <ICategoriesRepository>();
category.Setup(m => m.Categories).Returns(new[]
{
new Category
{
CategoryId = 1,
CategoryName = "Cat1",
Lots = new List <Lot>()
},
new Category
{
CategoryId = 2,
CategoryName = "Cat2",
Lots = new List <Lot>()
},
new Category
{
CategoryId = 3,
CategoryName = "Cat3",
Lots = new List <Lot>()
}
}.AsQueryable());
Mock <ILotsRepository> mock = new Mock <ILotsRepository>();
mock.Setup(m => m.Lots).Returns(new[]
{
new Lot {
LotID = 1, Name = "P1", Category = category.Object.Categories.ToList()[0], IsCompleted = false
},
new Lot {
LotID = 2, Name = "P2", Category = category.Object.Categories.ToList()[1], IsCompleted = false
},
new Lot {
LotID = 3, Name = "P3", Category = category.Object.Categories.ToList()[0], IsCompleted = false
},
new Lot {
LotID = 4, Name = "P4", Category = category.Object.Categories.ToList()[1], IsCompleted = false
},
new Lot {
LotID = 5, Name = "P5", Category = category.Object.Categories.ToList()[2], IsCompleted = false
}
}.AsQueryable());
category.Object.Categories.ToList()[0].Lots.Add(mock.Object.Lots.ToList()[0]);
category.Object.Categories.ToList()[1].Lots.Add(mock.Object.Lots.ToList()[1]);
category.Object.Categories.ToList()[0].Lots.Add(mock.Object.Lots.ToList()[2]);
category.Object.Categories.ToList()[1].Lots.Add(mock.Object.Lots.ToList()[3]);
category.Object.Categories.ToList()[2].Lots.Add(mock.Object.Lots.ToList()[4]);
// Arrange - create a controller and make the page size 3 items
LotsController target = new LotsController(mock.Object, category.Object);
target.PageSize = 3;
// Action - test the Lot counts for different categories
int res1 = ((LotsListViewModel)target
.List(1).Model).PageModel.TotalItems;
int res2 = ((LotsListViewModel)target
.List(2).Model).PageModel.TotalItems;
int res3 = ((LotsListViewModel)target
.List(3).Model).PageModel.TotalItems;
int resAll = ((LotsListViewModel)target
.List(0).Model).PageModel.TotalItems;
// Assert
Assert.AreEqual(res1, 2);
Assert.AreEqual(res2, 2);
Assert.AreEqual(res3, 1);
Assert.AreEqual(resAll, 5);
}
