public void CreateInstructor_UnderNormalConditions_ReturnsOkResponse()
{
//Arrange
var instructorToBeCreated = new InstructorDto()
{
InstructorId = 10,
InstructorName = "Wayne Gretzky",
IsActive = true
};
Mock.Arrange(() => _instructorService.Create(instructorToBeCreated))
.Returns(instructorToBeCreated)
.OccursOnce();
var instructorController = new InstructorController(_instructorService)
{
Request = new HttpRequestMessage()
{
RequestUri = new Uri("http://localhost/api/instructor/create")
}
};
//Act
var actual = instructorController.Post(instructorToBeCreated) as CreatedNegotiatedContentResult <InstructorDto>;
var actualContent = actual.Content;
//Assert
Mock.Assert(_instructorService);
Assert.That(actual, Is.Not.Null);
Assert.That(actualContent, Is.EqualTo(instructorToBeCreated));
Assert.That(actual, Is.TypeOf <CreatedNegotiatedContentResult <InstructorDto> >());
}
public void UpdateInstructor_WhereInstructorExists_UpdatesEntityWithoutError([Values(1, 2, 3)] int idOfInstructorToUpdate)
{
//Arrange
var expected = _mockInstructorList.First(x => x.InstructorId == idOfInstructorToUpdate);
expected.InstructorName = "UPDATED";
Mock.Arrange(() => _instructorService.Update(expected)).Returns(expected).OccursOnce();
var instructorController = new InstructorController(_instructorService)
{
Request = new HttpRequestMessage()
{
RequestUri = new Uri("http://localhost/api/instructor/create")
}
};
////Act
var actual = instructorController.Put(expected) as OkNegotiatedContentResult <InstructorDto>;
var actualContent = actual.Content;
//Assert
Mock.Assert(_instructorService);
Assert.That(actual, Is.Not.Null);
Assert.That(actual, Is.TypeOf <OkNegotiatedContentResult <InstructorDto> >());
Assert.That(actualContent, Is.EqualTo(expected));
}
private void TextBoxSnumber_TextChanged(object sender, EventArgs e)
{
textBoxAnumber.Text = InstructorController.PerformCalculation(
textBoxFnumber.Text,
textBoxSnumber.Text,
comboBoxOperators.Text).ToString();
}
public async Task GetReturnsInstructorOut()
{
//Arrange
var route = _configMock.Object.Routes.MapHttpRoute("default", "api/{controller}/{id}");
_routeDataMock = new Mock <HttpRouteData>(route, new HttpRouteValueDictionary {
{ "controller", "Instructor" }
});
_instructorServiceMock.Setup(mock => mock.GetInstructor(3)).ReturnsAsync(() => _instructorOut);
var controller = new InstructorController(_instructorServiceMock.Object);
controller.ControllerContext = new HttpControllerContext(_configMock.Object, _routeDataMock.Object, _requestMock.Object);
controller.Request = _requestMock.Object;
controller.Request.Properties[HttpPropertyKeys.HttpConfigurationKey] = _configMock.Object;
//Act
IHttpActionResult actionResult = await controller.Get(3);
var contentResult = actionResult as OkNegotiatedContentResult <InstructorOut>;
InstructorOut instructor = contentResult.Content as InstructorOut;
//Assert
Assert.IsNotNull(contentResult);
Assert.IsNotNull(contentResult.Content);
Assert.IsInstanceOfType(instructor, typeof(InstructorOut));
Assert.AreEqual(instructor.Id, 3);
}
public async Task GetReturnsCollectionOfInstructorOut()
{
//Arrange
var route = _configMock.Object.Routes.MapHttpRoute("default", "api/{controller}/{id}");
_routeDataMock = new Mock <HttpRouteData>(route, new HttpRouteValueDictionary {
{ "controller", "Instructor" }
});
_instructorServiceMock.Setup(mock => mock.GetAllInstructors()).ReturnsAsync(() => _instructorsOut);
var controller = new InstructorController(_instructorServiceMock.Object)
{
ControllerContext = new HttpControllerContext(_configMock.Object, _routeDataMock.Object, _requestMock.Object),
Request = _requestMock.Object
};
controller.Request.Properties[HttpPropertyKeys.HttpConfigurationKey] = _configMock.Object;
//Act
IHttpActionResult actionResult = await controller.Get();
var contentResult = actionResult as OkNegotiatedContentResult <IEnumerable <InstructorOut> >;
List <InstructorOut> instructors = contentResult.Content as List <InstructorOut>;
//Assert
Assert.IsNotNull(contentResult);
Assert.IsNotNull(contentResult.Content);
Assert.AreEqual(5, instructors.Count);
}
public void When_selecting_course_enrollments_displayed()
{
var fakeSchoolContext = new FakeSchoolContext();
var instructor = new Instructor()
{
ID = 1,
Courses = new List <Course>()
{
new Course()
{
CourseID = 1,
Enrollments = new List <Enrollment>()
{
new Enrollment()
{
EnrollmentID = 1
}
}
}
}
};
fakeSchoolContext.Instructors.Add(instructor);
var controller = new InstructorController(fakeSchoolContext);
// Testing the Controller.GetInstructorIndexData() method
var viewModel = controller.GetInstructorIndexData(1, 1);
Assert.NotNull(viewModel.Enrollments.FirstOrDefault());
Assert.Equal(1, viewModel.Enrollments.Count());
}
public void InstructorController_Index_returns_correct_viewBag_values()
{
var controller = new InstructorController(new SchoolContext());
var result = (ViewResult)controller.Index(9, null);
Assert.Equal(9, result.ViewBag.InstructorId);
}
public void Setup()
{
instructorService = new Mock <IInstructorService>();
instructorService.Setup(repo => repo.GetInstructorsAsync()).ReturnsAsync(GetTestInstructors());
controller = new InstructorController(null, instructorService.Object);
instructors = new List <Entities.Instructor>()
{
new Entities.Instructor()
{
Id = "1",
Email = "*****@*****.**",
FirstName = "Test",
LastName = "Person",
Phone = "905-123-4567"
},
new Entities.Instructor()
{
Id = "2",
Email = "*****@*****.**",
FirstName = "Tester",
LastName = "Account",
Phone = "905-123-4567"
}
};
}
public void Initialize()
{
httpContext = new MockHttpContextWrapper();
controllerToTest = new InstructorController();
controllerToTest.ControllerContext = new ControllerContext(httpContext.Context.Object, new RouteData(), controllerToTest);
dbContext = new DAL.SchoolContext(this.ConnectionString);
controllerToTest.DbContext = dbContext;
}
public void InstructorController_GetInstructorIndexData()
{
//Instructor: Kim Abercrombie Id: 9
var controller = new InstructorController(new SchoolContext());
var instructorIndexData = controller.GetInstructorIndexData(9, null);
_output.WriteLine(instructorIndexData.Courses.ToJSON());
}
public void When_selecting_instructor_instructor_courses_displayed()
{
Setup1Instructor1Course1Enrollment();
var controller = new InstructorController(_fakeDb);
// Testing the Controller.GetInstructorIndexData() method
var viewModel = controller.GetInstructorIndexData(1, null);
Assert.Equal(1, viewModel.Instructors.FirstOrDefault().Courses.Count());
}
public void Index()
{
// Arrange
InstructorController controller = new InstructorController();
// Act
ViewResult result = controller.Index() as ViewResult;
// Assert
Assert.IsNotNull(result);
}
static void Main(string[] args)
{
var SQLLibConn = new BCConnection();
SQLLibConn.Connect(@"localhost\sqlexpress", "EdDb", "trusted_connection = true");
StudentController.BCConnection = SQLLibConn;
MajorController.BCConnection = SQLLibConn;
InstructorController.BCConnection = SQLLibConn;
var majors = MajorController.GetAllMajors();
foreach (var major in majors)
{
Console.WriteLine(major);
}
var Students = StudentController.GetAllStudents();
foreach (Student student in Students)
{
Console.WriteLine(student);
}
var Instructors = InstructorController.GetAllInstructors();
foreach (Instructor instructor in Instructors)
{
Console.WriteLine(instructor);
}
#region specifics instances for modification
//var newStudent = new Student {
// Id = 660,
// Firstname = "Timmy",
// Lastname = "Nook",
// SAT = 810,
// GPA = 2.90,
// MajorId = 1
//};
//Console.WriteLine(StudentController.InsertStudent(newStudent));
//var studentById = StudentController.GetByPK(100);
//if (studentById == null) {
// Console.WriteLine("Could not find a student with that primary key.");
//} else {
// Console.WriteLine(studentById);
//}
#endregion
SQLLibConn.Disconnect();
}
public void DeleteInstructor_WhereInstructorExists_ReturnsOkResponse([Values(1, 2, 3)] int idOfInstructorToDelete)
{
//Arrange
Mock.Arrange(() => _instructorService.Delete(idOfInstructorToDelete)).OccursOnce();
var instructorController = new InstructorController(_instructorService);
////Act
var actual = instructorController.Delete(idOfInstructorToDelete) as OkResult;
//Assert
Mock.Assert(_instructorService);
Assert.That(actual, Is.TypeOf <OkResult>());
}
public void GetById_WhereIdExists_ReturnsInstructorWithThatId([Values(1, 2, 3)] int idToRetrieve)
{
//Arrange
Mock.Arrange(() => _instructorService.Get(idToRetrieve)).Returns(_mockInstructorList.First(x => x.InstructorId == idToRetrieve)).OccursOnce();
var expected = _mockInstructorList.First(x => x.InstructorId == idToRetrieve);
var instructorController = new InstructorController(_instructorService);
////Act
var actual = instructorController.Get(idToRetrieve) as OkNegotiatedContentResult <InstructorDto>;
var actualContent = actual.Content;
//Assert
Mock.Assert(_instructorService);
Assert.That(actualContent, Is.EqualTo(expected));
}
public void GetAll_UnderNormalConditions_ReturnsMultipleInstructors()
{
//Arrange
Mock.Arrange(() => _instructorService.GetAll()).Returns(_mockInstructorList).OccursOnce();
var expected = _mockInstructorList;
var instructorController = new InstructorController(_instructorService);
////Act
var actual = instructorController.GetAll() as OkNegotiatedContentResult <List <InstructorDto> >;
var actualContent = actual.Content;
//Assert
Mock.Assert(_instructorService);
Assert.That(actualContent, Is.EqualTo(expected));
}
public void GetById_WhereIdDoesntExist_ReturnsEmptyCollection([Values(4, 5, 6)] int idToRetrieve)
{
//Arrange
Mock.Arrange(() => _instructorService.Get(idToRetrieve)).Returns(_mockInstructorList.FirstOrDefault(x => x.InstructorId == idToRetrieve)).OccursOnce();
var expected = _mockInstructorList.FirstOrDefault(x => x.InstructorId == idToRetrieve);
var instructorController = new InstructorController(_instructorService);
////Act
var actual = instructorController.Get(idToRetrieve) as OkNegotiatedContentResult <InstructorDto>;
var actualContent = actual.Content;
//Assert
Mock.Assert(_instructorService);
Assert.IsNull(actualContent);
Assert.IsNull(expected);
}
public async Task AddNewInstructor()
{
Mock <IInstructorRepository> mockInstructorRepository =
new Mock <IInstructorRepository>();
Instructor addedInstructor = null;
mockInstructorRepository.Setup(m => m.AddInstructor(It.IsAny <Instructor>()))
.Returns(Task.CompletedTask).Callback <Instructor>(m => addedInstructor = m);
InstructorController instructorController =
new InstructorController(mockInstructorRepository.Object);
Instructor instructor = new Instructor("Nanda", "Surendra", "NaSurendra@Mix", 1);
instructor.InstructorID = 14;
//Act
var result = await instructorController.AddInstructor(instructor);
Assert.Equal(instructor.InstructorLastName, addedInstructor.InstructorLastName);
Assert.Equal(instructor, addedInstructor);
}
public async Task GetReturnsInstructorOutNotFound()
{
//Arrange
var route = _configMock.Object.Routes.MapHttpRoute("default", "api/{controller}/{id}");
_routeDataMock = new Mock <HttpRouteData>(route, new HttpRouteValueDictionary {
{ "controller", "Instructor" }
});
_instructorServiceMock.Setup(mock => mock.GetInstructor(3)).ReturnsAsync(() => _instructorOut);
var controller = new InstructorController(_instructorServiceMock.Object);
controller.ControllerContext = new HttpControllerContext(_configMock.Object, _routeDataMock.Object, _requestMock.Object);
controller.Request = _requestMock.Object;
controller.Request.Properties[HttpPropertyKeys.HttpConfigurationKey] = _configMock.Object;
//Act
IHttpActionResult actionResult = await controller.Get(9999999);
//Assert
Assert.IsInstanceOfType(actionResult, typeof(NotFoundResult));
}
public void ReturnViewForListAllInstructors()
{
Mock <IInstructorRepository> mockInstructorRepository =
new Mock <IInstructorRepository>();
List <Instructor> mockInstructorList = PopulateInstructors();
mockInstructorRepository.Setup(m => m.ListAllInstructors())
.Returns(mockInstructorList);
InstructorController instructorController =
new InstructorController(mockInstructorRepository.Object);
var result = instructorController.ListAllInstructors();
ViewResult viewResult = Assert.IsType <ViewResult>(result);
List <Instructor> viewResultModel = (List <Instructor>)viewResult.Model;
// ^ this is called "casting" tells the
//program to accept that it will be what we say it is
int expectedNumberOfInstructors = 4;
Assert.Equal(expectedNumberOfInstructors, viewResultModel.Count);
string expectedEmail = "NaSurendra@Mix";
string actualEmail = viewResultModel.
Find(m => m.InstructorID == 1).InstructorEmail;
Assert.Equal(expectedEmail, actualEmail);
Assert.Equal(mockInstructorList, viewResultModel);
}// end of Return ListAllInstructors
public async Task EditInstructor()
{
Mock <IInstructorRepository> mockInstructorRepository =
new Mock <IInstructorRepository>();
Instructor editedInstructor = null;
mockInstructorRepository.Setup(m => m.AddInstructor(It.IsAny <Instructor>()))
.Returns(Task.CompletedTask).Callback <Instructor>(repo => editedInstructor = repo);
InstructorController instructorController =
new InstructorController(mockInstructorRepository.Object);
Instructor instructor = new Instructor("Nanda", "Surendra", "NaSurendra@Mix", 1);
instructor.InstructorID = 14;
//Act
var result = await instructorController.EditInstructor(instructor);
Assert.IsType <RedirectToActionResult>(result);
//Assert.Equal(instructor.InstructorLastName, editedInstructor.InstructorLastName);
//Assert.Equal(instructor, editedInstructor);
}
public void When_editing_an_instructor()
{
Setup1Instructor1Course1Enrollment();
var controller = new InstructorController(_fakeDb);
controller.ControllerContext = new ControllerContext();
var form = new FormCollection()
{
{ "ID", "9" },
{ "LastName", "Abercrombie" },
{ "FirstMidName", "Kim" },
{ "HireDate", "3/11/1995" },
{ "OfficeAssignment.Location", "" }
};
controller.ValueProvider = form.ToValueProvider();
var instructorId = 1;
var selectedCourses = new string[] { "1" };
controller.Edit(instructorId, selectedCourses);
_output.WriteLine(controller.ModelState.ToJSON());
}
static void Main(string[] args)
{
var sqllib = new BcConnection();
sqllib.Connect(@"localhost", "EdDb", "trusted_connection=true");
MajorController.bcConnection = sqllib;
var majors = MajorController.GetAllMajors();
foreach (var major in majors)
{
Console.WriteLine(major);
}
StudentController.bcConnection = sqllib;
//var newStudent = new Student {
// Id = 667,
// FirstName = "Chuck",
// LastName = "Intern of Darkness",
// SAT = 000,
// GPA = 4.0,
// MajorId = null
//};
//var success = StudentController.InsertStudent(newStudent);
var student100 = StudentController.GetByPk(888);
if (student100 == null)
{
Console.WriteLine("Student not found");
}
else
{
Console.WriteLine(student100);
}
//student100.FirstName = "Jackie";
//student100.LastName = "Chan";
//var success = StudentController.UpdateStudent(student100);
//
//var studentToDelete = new Student {
// Id = 777
//};
//success = StudentController.DeleteStudent(888);
var students = StudentController.GetAllStudents();
foreach (var student in students)
{
Console.WriteLine(student);
}
var m = MajorController.GetByPk(1);
foreach (var major in majors)
{
Console.WriteLine(m);
}
InstructorController.bcConnection = sqllib;
var instructors = InstructorController.GetAllInstructors();
foreach (var instructor in instructors)
{
Console.WriteLine(instructor);
}
var instructPK = InstructorController.GetByPk(30);
if (instructPK == null)
{
Console.WriteLine("Instructor not found");
}
else
{
Console.WriteLine(instructPK);
}
ClassController.bcConnection = sqllib;
var classes = ClassController.GetAllClasses();
foreach (var cla in classes)
{
Console.WriteLine(cla);
}
sqllib.Disconnect();
}
static void Main(string[] args)
{
var sqllib = new BcConnection();
sqllib.Connect(@"localhost\sqlexpress", "EdDb", "trusted_connection=true");
StudentController.bcConnection = sqllib;
MajorController.bcConnection = sqllib;
InstructorController.bcConnection = sqllib;
#region Instructor methods
var instructors = InstructorController.GetAllInstructors();
foreach (var i in instructors)
{
Console.WriteLine(i);
}
var instructor = InstructorController.GetInstructorByPk(10);
if (instructor == null)
{
Console.WriteLine("Instructor not found!");
}
else
{
Console.WriteLine(instructor);
}
#endregion
#region Major Controller methods
var major = MajorController.GetMajorByPK(1);
if (major == null)
{
Console.WriteLine("Major not found!");
}
else
{
Console.WriteLine(major);
}
var majors = MajorController.GetAllMajors();
foreach (var m in majors)
{
Console.WriteLine(m);
}
#endregion
#region Student Controller methods
//var newStudent = new Student {
// Id = 999,
// Firstname = "Lazy",
// Lastname = "Larry",
// SAT = 1600,
// GPA = 4.0,
// MajorId = 3
//};
//var success = StudentController.InsertStudent(newStudent);
var student = StudentController.GetStudentByPk(888);
if (student == null)
{
Console.WriteLine("Student not found");
}
else
{
Console.WriteLine(student);
}
//var studentToDelete = new Student {
// Id = 999
//};
//var success = StudentController.DeleteStudent(999);
//student.Firstname = "Charlie";
//student.Lastname = "Chan";
//var success = StudentController.UpdateStudent(student);
var students = StudentController.GetAllStudents();
foreach (var student0 in students)
{
Console.WriteLine(student0);
}
#endregion
sqllib.Disconnect();
}
private void ReceiveCallback(IAsyncResult AR)
{
try
{
// Socket exception will raise here when client closes
int received = clientSocket.EndReceive(AR);
if (received == 0)
{
return;
}
// The received data is deserialized in the EquationProperties.
string message = Encoding.ASCII.GetString(buffer);
// Any excess characters are stipped of the end
int index = message.IndexOf("}");
message = message.Substring(0, index + 1);
// Deserialize the json string into the equation object
equation = JsonConvert.DeserializeObject <Equations>(message);
// Create new node and add to nodelist
Invoke((Action) delegate
{
LinkListNode node = new LinkListNode(equation);
equationNodeList.AddEquationNode(node);
});
//add the node to the binary tree
if (tree.root == null)
{
//if tree is emtpy, set the node as the root
tree.root = new BinaryTreeNode(equation);
}
else
{
//add the node to the bindary tree
tree.Add(equation);
}
Invoke((Action) delegate
{
rtbAsked.Clear();
//the default print order for the binary tree is in-order
//rtbAsked.Text = BinaryTree.PrintInOrder(tree);
SendBtn.Enabled = true;
});
// Check if answer is incorrect
if (equation.IsCorrect == false)
{
Invoke((Action) delegate
{
if (equation.IsCorrect == false)
{
rtbWrong.Text = InstructorController.PrintLinkList(equationNodeList);
}
});
}
// Start receiving data again.
clientSocket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, ReceiveCallback, null);
}
// Avoid catching all exceptions handling in cases like these.
catch (SocketException ex)
{
ShowErrorDialog(ex.Message);
Invoke((Action) delegate
{
//lbl_clientCount.Text = "No connected clients";
});
}
catch (ObjectDisposedException ex)
{
ShowErrorDialog(ex.Message);
}
}
