public void TestDeleteSportReturnsToIndexMethod()
{
//Arrange
var sports = new[]
{
new Sport {
Name = "Voetbal", SportId = 1
},
new Sport {
Name = "Basketbal", SportId = 2
},
new Sport {
Name = "Hockey", SportId = 3
},
new Sport {
Name = "Volleybal", SportId = 4
},
};
var mockManager = new Mock <ISportManager>();
var mockTempData = new Mock <ITempDataDictionary>();
var controller = new SportController(mockManager.Object)
{
TempData = mockTempData.Object
};
mockManager.Setup(x => x.DeleteSport(It.IsAny <Sport>())).Throws <Exception>();
mockManager.Setup(x => x.Read(It.IsAny <int>())).Returns(sports[1]);
//Act
var result = controller.Delete(sports[1].SportId);
//Assert
Assert.IsType(typeof(RedirectToActionResult), result);
}
public void Post_Valid_Test()
{
// Arrange
Sport sportObjAsInput = new Sport();
sportObjAsInput.name = "Sport 1";
sportObjAsInput.userId = 1;
var mockRepository = new Mock <ISportRepository>();
mockRepository.Setup(x => x.InsertSport(sportObjAsInput))
.Returns(1);
var controller = new SportController(mockRepository.Object);
controller.Request = new HttpRequestMessage();
controller.Configuration = new HttpConfiguration();
// Act
HttpResponseMessage response = controller.Post(sportObjAsInput);
// Assert
string responseJSONStr = response.Content.ReadAsStringAsync().Result;
string responseStr = Helper.Deserialize <string>(responseJSONStr);
Assert.IsNotNull(response);
Assert.AreEqual(response.StatusCode, HttpStatusCode.OK);
Assert.AreEqual(responseStr, "Sport added successfully.");
}
public void IndexMethodWithSortOrderDescendingReturnsCorrectCollectionOfSportsSortedDescending()
{
//Arrange
var sports = new[]
{
new Sport {
Name = "Voetbal"
},
new Sport {
Name = "Basketbal"
},
new Sport {
Name = "Hockey"
},
new Sport {
Name = "Volleybal"
}
};
var mockManager = new Mock <ISportManager>();
var controller = new SportController(mockManager.Object);
mockManager.Setup(a => a.SportsList()).Returns(sports);
//Act
var result = controller.Index("name_desc", null, null, 1);
var pageList = (PagedList <Sport>)result.ViewData.Model;
//Assert
Assert.IsType(typeof(PagedList <Sport>), result.ViewData.Model);
Assert.Same("Volleybal", pageList[0].Name);
}
public void TestUpdateSportObjectRedirectsToIndexAction()
{
//Arrange
var model = new SportObjectModel
{
Sport = new Sport {
SportId = 1, Name = "testsport"
},
SportObject = new SportObject {
SportObjectId = 3, Name = "TestOBJECT"
}
};
var mockManager = new Mock <ISportManager>();
var mockTempData = new Mock <ITempDataDictionary>();
var controller = new SportController(mockManager.Object)
{
TempData = mockTempData.Object
};
mockManager.Setup(x => x.UpdateSportObject(It.IsAny <SportObject>())).Throws <Exception>();
var objectToTest = new SportObject
{
SportObjectId = 3,
Name = "Test"
};
//Act
var result = controller.UpdateObject(objectToTest);
//Assert
Assert.IsType(typeof(RedirectToActionResult), result);
}
public void TestAddInvalidSportObjectReturnsCurrentView()
{
//Arrange
var model = new SportObjectModel
{
Sport = new Sport {
SportId = 1, Name = "testsport"
},
SportObject = new SportObject {
SportObjectId = 3, Name = "TestOBJECT"
}
};
var mockManager = new Mock <ISportManager>();
var mockTempData = new Mock <ITempDataDictionary>();
var controller = new SportController(mockManager.Object)
{
TempData = mockTempData.Object
};
controller.ModelState.AddModelError("", "");
mockManager.Setup(x => x.AddSportObject(It.IsAny <Sport>(), It.IsAny <SportObject>())).Throws <Exception>();
//Act
var result = (ViewResult)controller.AddObject(model, 1);
//Asert
Assert.True(result.ViewName == "AddObject");
}
public void Put_InValid_UserId_Test()
{
// Arrange
Sport sportObjAsInput = new Sport();
sportObjAsInput.id = 1;
sportObjAsInput.name = "Sport 1";
sportObjAsInput.userId = -1;
var mockRepository = new Mock <ISportRepository>();
var controller = new SportController(mockRepository.Object);
controller.Request = new HttpRequestMessage();
controller.Configuration = new HttpConfiguration();
// Act
HttpResponseMessage response = controller.Put(sportObjAsInput);
// Assert
string responseJSONStr = response.Content.ReadAsStringAsync().Result;
string responseStr = Helper.Deserialize <string>(responseJSONStr);
Assert.IsNotNull(response);
Assert.AreEqual(response.StatusCode, HttpStatusCode.PartialContent);
Assert.AreEqual(responseStr, "User Id is invalid.");
}
public void TestUpdateInvalidSportObjectRedirectsToIndexAction()
{
var model = new SportObjectModel
{
Sport = new Sport {
SportId = 1, Name = "testsport"
},
SportObject = new SportObject {
SportObjectId = 3, Name = "TestOBJECT"
}
};
var mockManager = new Mock <ISportManager>();
var mockTempData = new Mock <ITempDataDictionary>();
var controller = new SportController(mockManager.Object)
{
TempData = mockTempData.Object
};
controller.ModelState.AddModelError("", "");
mockManager.Setup(x => x.UpdateSportObject(It.IsAny <SportObject>())).Throws <Exception>();
var objectToTest = new SportObject
{
SportObjectId = 3,
Name = "Test"
};
//Act
var result = (ViewResult)controller.UpdateObject(objectToTest);
//Assert
Assert.True(result.ViewName == "UpdateObject");
}
public void TestDeleteSportObjectReturnsToIndexMethod()
{
//Arrange
var sportObjects = new[]
{
new SportObject {
Name = "testobject 1"
},
new SportObject {
Name = "testobject 2"
},
new SportObject {
Name = "testobject 3"
},
new SportObject {
Name = "testobject 4"
},
};
var mockManager = new Mock <ISportManager>();
var mockTempData = new Mock <ITempDataDictionary>();
var controller = new SportController(mockManager.Object)
{
TempData = mockTempData.Object
};
mockManager.Setup(x => x.DeleteSportObject(It.IsAny <SportObject>())).Throws <Exception>();
mockManager.Setup(x => x.ReadSportObject(It.IsAny <int>())).Returns(sportObjects[1]);
//Act
var results = controller.DeleteObject(sportObjects[1].SportObjectId);
//Assert
Assert.IsType(typeof(RedirectToActionResult), results);
}
public void IndexMethodWithSearchStringReturnsCorrectCollectionOfSports()
{
//Arrange
var sports = new[]
{
new Sport {
Name = "Voetbal"
},
new Sport {
Name = "Basketbal"
},
new Sport {
Name = "Hockey"
},
new Sport {
Name = "Volleybal"
}
};
var mockManager = new Mock <ISportManager>();
mockManager.Setup(x => x.SportsList()).Returns(sports);
var controller = new SportController(mockManager.Object);
//Act
var result = controller.Index(null, null, "bal", 1);
//Assert
Assert.IsType(typeof(PagedList <Sport>), result.ViewData.Model);
Assert.Equal(3, result.ViewData.Count);
}
public void TestAddInvalidSportReturnsCurrentView()
{
//Arrange
var dummysport = new Sport
{
Name = "KongBall",
};
var mockManager = new Mock <ISportManager>();
var mockTempData = new Mock <ITempDataDictionary>();
var controller = new SportController(mockManager.Object)
{
TempData = mockTempData.Object
};
controller.ModelState.AddModelError("", "");
mockManager.Setup(x => x.AddSport(It.IsAny <Sport>())).Throws <Exception>();
//Act
var result = (ViewResult)controller.Add(dummysport);
//Assert
Assert.True(result.ViewName == "Add");
}
public void AmountOfPagesOnIndexMethodIsCorrect()
{
//Arrange
var sports = new[]
{
new Sport {
Name = "Voetbal"
},
new Sport {
Name = "Basketbal"
},
new Sport {
Name = "Hockey"
},
new Sport {
Name = "Volleybal"
},
new Sport {
Name = "Trefbal"
},
new Sport {
Name = "Tennis"
},
new Sport {
Name = "Darten"
},
new Sport {
Name = "Karate"
},
new Sport {
Name = "Dansen"
},
new Sport {
Name = "Yoga"
},
new Sport {
Name = "Badminton"
},
new Sport {
Name = "Softbal"
}
};
var mockManager = new Mock <ISportManager>();
var controller = new SportController(mockManager.Object);
mockManager.Setup(a => a.SportsList()).Returns(sports);
//Act
var result = controller.Index(null, null, null, 1);
var pageList = (PagedList <Sport>)result.ViewData.Model;
//Assert
Assert.Equal(2, pageList.PageCount);
Assert.Equal(12, pageList.TotalItemCount);
}
public void TestUpdateInvalidSporReturnsCurrentView()
{
//Arrange
var dummysport = new Sport
{
Name = "KongBall",
};
var sports = new[]
{
new Sport {
Name = "Voetbal"
},
new Sport {
Name = "Basketbal"
},
new Sport {
Name = "Hockey"
},
new Sport {
Name = "Volleybal"
}
};
var mockManager = new Mock <ISportManager>();
var mockTempData = new Mock <ITempDataDictionary>();
var controller = new SportController(mockManager.Object)
{
TempData = mockTempData.Object
};
controller.ModelState.AddModelError("", "");
mockManager.Setup(x => x.UpdateSport(It.IsAny <Sport>())).Throws <Exception>();
//Act
var result = (ViewResult)controller.Update(dummysport);
//Assert
Assert.True(result.ViewName == "Update");
}
public async void TestDeleteSport()
{
//Arrange
var serviceMock = new Mock <ISportService>();
var sport2Delete = new Sport {
Id = 1, Name = "Sport"
};
serviceMock.Setup(x => x.Remove(sport2Delete.Id)).Returns(Task.FromResult(result: sport2Delete.Id));
serviceMock.Setup(y => y.GetSportByIdAsync(sport2Delete.Id)).
Returns(Task.FromResult(sport2Delete));
var controller = new SportController(serviceMock.Object);
//Act
var result = await controller.Delete(1) as ViewResult;
var model = (Sport)result.ViewData.Model;
//Assert
Assert.Equal(expected: 1, actual: model.Id);
}
public void Post_Null_Input_Test()
{
// Arrange
var mockRepository = new Mock <ISportRepository>();
var controller = new SportController(mockRepository.Object);
controller.Request = new HttpRequestMessage();
controller.Configuration = new HttpConfiguration();
// Act
HttpResponseMessage response = controller.Post(null);
// Assert
string responseJSONStr = response.Content.ReadAsStringAsync().Result;
string responseStr = Helper.Deserialize <string>(responseJSONStr);
Assert.IsNotNull(response);
Assert.AreEqual(response.StatusCode, HttpStatusCode.NoContent);
Assert.AreEqual(responseStr, "Invalid JSON Passed.");
}
public void TestUpdateSportReturnsToIndexMethod()
{
//Arrange
var dummysport = new Sport
{
Name = "KongBall",
};
var sports = new[]
{
new Sport {
Name = "Voetbal"
},
new Sport {
Name = "Basketbal"
},
new Sport {
Name = "Hockey"
},
new Sport {
Name = "Volleybal"
}
};
var mockManager = new Mock <ISportManager>();
var mockTempData = new Mock <ITempDataDictionary>();
var controller = new SportController(mockManager.Object)
{
TempData = mockTempData.Object
};
mockManager.Setup(x => x.UpdateSport(It.IsAny <Sport>())).Throws <Exception>();
//Act
var result = controller.Update(dummysport);
//Assert
Assert.IsType(typeof(RedirectToActionResult), result);
}
public async void TestGetSportByID()
{
// Arrange
int SportId = 2;
var mockService = new Mock <ISportService>();
mockService.Setup(x => x.GetSportByIdAsync(SportId))
.Returns(Task.FromResult(new Sport {
Id = 2, Name = "Swimming"
}));
var controller = new SportController(mockService.Object);
// Act
var result = await controller.Details(SportId) as ViewResult;
var model = (Sport)result.ViewData.Model;
// Assert
var contentResult = Assert.IsType <ViewResult>(result);
Assert.Equal("Swimming", model.Name);
}
public void Delete_Valid_Test()
{
// Arrange
var mockRepository = new Mock <ISportRepository>();
mockRepository.Setup(x => x.DeleteSport(1))
.Returns(true);
var controller = new SportController(mockRepository.Object);
controller.Request = new HttpRequestMessage();
controller.Configuration = new HttpConfiguration();
// Act
HttpResponseMessage response = controller.Delete(1);
// Assert
string responseJSONStr = response.Content.ReadAsStringAsync().Result;
string responseStr = Helper.Deserialize <string>(responseJSONStr);
Assert.IsNotNull(response);
Assert.AreEqual(response.StatusCode, HttpStatusCode.OK);
Assert.AreEqual(responseStr, "Sport successfully deleted.");
}
public void Get_Sport_Test()
{
// Arrange
Sport sportObjAsOutput = new Sport();
sportObjAsOutput.name = "Sport 1";
sportObjAsOutput.userId = 1;
var mockRepository = new Mock <ISportRepository>();
mockRepository.Setup(x => x.GetSport(1))
.Returns(sportObjAsOutput);
var controller = new SportController(mockRepository.Object);
controller.Request = new HttpRequestMessage();
controller.Configuration = new HttpConfiguration();
// Act
Sport sportsObj = controller.Get(1);
// Assert
Assert.AreEqual <Sport>(sportsObj, sportObjAsOutput);
}
public void Setup()
{
context = TestUtils.GetMockContext();
controller = new SportController(context);
controller.ControllerContext.HttpContext = TestUtils.SetUserContext(context, 0);
}
