public void Execute_ShouldThrowFormatException_WhenParametersCannotBeParsed(string firstParameter, string secondParameter, string thirdParameter)
{
var mockSchoolSystemData = new Mock <ISchoolSystemData>();
var mockStudentsDataCollection = new Mock <ISchoolSystemDataCollection <IStudent> >();
var mockTeachersDataCollection = new Mock <ISchoolSystemDataCollection <ITeacher> >();
var mockStudent = new Mock <IStudent>();
var mockTeacher = new Mock <ITeacher>();
mockSchoolSystemData.SetupGet(ssd => ssd.Students).Returns(mockStudentsDataCollection.Object);
mockSchoolSystemData.SetupGet(ssd => ssd.Teachers).Returns(mockTeachersDataCollection.Object);
mockStudentsDataCollection.Setup(sdc => sdc.GetById(It.IsAny <int>())).Returns(mockStudent.Object);
mockTeachersDataCollection.Setup(tdc => tdc.GetById(It.IsAny <int>())).Returns(mockTeacher.Object);
var parameters = new List <string>()
{
firstParameter,
secondParameter,
thirdParameter
};
var teacherAddMarkCommand = new TeacherAddMarkCommand();
Assert.That(
() => teacherAddMarkCommand.Execute(parameters, mockSchoolSystemData.Object),
Throws.InstanceOf <FormatException>());
}
public void Execute_ShouldInvokeSchoolSystemDataStudentsCollection_GetByIdWithCorrectParameter()
{
var mockSchoolSystemData = new Mock <ISchoolSystemData>();
var mockStudentsDataCollection = new Mock <ISchoolSystemDataCollection <IStudent> >();
var mockTeachersDataCollection = new Mock <ISchoolSystemDataCollection <ITeacher> >();
var mockStudent = new Mock <IStudent>();
var mockTeacher = new Mock <ITeacher>();
mockSchoolSystemData.SetupGet(ssd => ssd.Students).Returns(mockStudentsDataCollection.Object);
mockSchoolSystemData.SetupGet(ssd => ssd.Teachers).Returns(mockTeachersDataCollection.Object);
mockStudentsDataCollection.Setup(sdc => sdc.GetById(It.IsAny <int>())).Returns(mockStudent.Object);
mockTeachersDataCollection.Setup(tdc => tdc.GetById(It.IsAny <int>())).Returns(mockTeacher.Object);
var parameters = new List <string>()
{
"1",
"2",
"3.3"
};
var teacherAddMarkCommand = new TeacherAddMarkCommand();
teacherAddMarkCommand.Execute(parameters, mockSchoolSystemData.Object);
mockStudentsDataCollection.Verify(sdc => sdc.GetById(2), Times.Once());
}
public void AddTheMarkToTheCollectionOfMarksOfTheStudent()
{
// Arrange
string teacherId = "0";
string studentId = "1";
string mark = "3.5";
IList <string> parameters = new List <string>()
{
teacherId,
studentId,
mark
};
var getStudentAndTeacherMock = new Mock <IGetStudentAndTeacher>();
var studentMock = new Mock <IStudent>();
var teacherMock = new Mock <ITeacher>();
getStudentAndTeacherMock.Setup(st => st.GetStudent(int.Parse(studentId))).Returns(studentMock.Object);
getStudentAndTeacherMock.Setup(st => st.GetTeacher(int.Parse(teacherId))).Returns(teacherMock.Object);
teacherMock.Setup(t => t.AddMark(studentMock.Object, float.Parse(mark)));
ICommand teacherAddMarkCommand = new TeacherAddMarkCommand(getStudentAndTeacherMock.Object);
// Act
teacherAddMarkCommand.Execute(parameters);
// Assert
teacherMock.Verify(t => t.AddMark(studentMock.Object, float.Parse(mark)), Times.Once());
}
public void Execute_ShouldThrowArgumentOutOfRangeException_WhenParametersAreLessThanThree()
{
var mockSchoolSystemData = new Mock <ISchoolSystemData>();
var mockStudentsDataCollection = new Mock <ISchoolSystemDataCollection <IStudent> >();
var mockTeachersDataCollection = new Mock <ISchoolSystemDataCollection <ITeacher> >();
var mockStudent = new Mock <IStudent>();
var mockTeacher = new Mock <ITeacher>();
mockSchoolSystemData.SetupGet(ssd => ssd.Students).Returns(mockStudentsDataCollection.Object);
mockSchoolSystemData.SetupGet(ssd => ssd.Teachers).Returns(mockTeachersDataCollection.Object);
mockStudentsDataCollection.Setup(sdc => sdc.GetById(It.IsAny <int>())).Returns(mockStudent.Object);
mockTeachersDataCollection.Setup(tdc => tdc.GetById(It.IsAny <int>())).Returns(mockTeacher.Object);
var parameters = new List <string>()
{
"1",
"1"
};
var teacherAddMarkCommand = new TeacherAddMarkCommand();
Assert.That(
() => teacherAddMarkCommand.Execute(parameters, mockSchoolSystemData.Object),
Throws.InstanceOf <ArgumentOutOfRangeException>());
}
public void TestExecute_PassValidParameters_ShouldCallFactoryCreate()
{
// Arrange
var parameters = new string[] { "0", " 0", " 2" };
var teacher = new Teacher("Foo", "Bar", Subject.Bulgarian);
var student = new Student("Foo", "Bar", Grade.Eighth);
var mark = new Mark(Subject.Bulgarian, float.Parse(parameters[2]));
var mockedFactory = new Mock <IMarkFactory>();
mockedFactory.Setup(f => f.CreateMark(It.IsAny <Subject>(), It.IsAny <float>())).Returns(mark);
var mockedStudentService = new Mock <IStudentService>();
mockedStudentService.Setup(s => s.GetStudentById(It.IsAny <int>())).Returns(student);
var mockedTeacherService = new Mock <ITeacherService>();
mockedTeacherService.Setup(s => s.GetTeacherById(It.IsAny <int>())).Returns(teacher);
var command = new TeacherAddMarkCommand(mockedFactory.Object, mockedStudentService.Object, mockedTeacherService.Object);
// Act
command.Execute(parameters);
// Assert
mockedFactory.Verify(s => s.CreateMark(mark.Subject, mark.Value));
}
public void ReturnCorrectStringResult()
{
var parameters = new List <string>()
{
"0", "0", "3"
};
var mockedStudent = new Mock <IStudent>();
mockedStudent.Setup(x => x.FirstName).Returns("John");
mockedStudent.Setup(x => x.LastName).Returns("Smith");
var mockedTeacher = new Mock <ITeacher>();
mockedTeacher.Setup(x => x.FirstName).Returns("Tara");
mockedTeacher.Setup(x => x.LastName).Returns("Johnson");
mockedTeacher.Setup(x => x.Subject).Returns(Subject.Bulgarian);
var mockedStorage = new Mock <IStorage>();
mockedStorage.Setup(x => x.Students).Returns(new Dictionary <int, IStudent>()
{
{ 0, mockedStudent.Object }
});
mockedStorage.Setup(x => x.Teachers).Returns(new Dictionary <int, ITeacher>()
{
{ 0, mockedTeacher.Object }
});
var teacherAddMarkCommand = new TeacherAddMarkCommand(mockedStorage.Object);
var expected = $"Teacher {mockedTeacher.Object.FirstName} {mockedTeacher.Object.LastName} added mark {parameters[2]} to student {mockedStudent.Object.FirstName} {mockedStudent.Object.LastName} in {mockedTeacher.Object.Subject}.";
var actual = teacherAddMarkCommand.Execute(parameters);
Assert.AreEqual(expected, actual);
}
public void TestExecute_PassValidParameters_ShouldCallServiceGetStudentCorrectly()
{
var parameters = new string[] { "0", " 0", " 2" };
var mockedTeacher = new Mock<ITeacher>();
mockedTeacher.Setup(t => t.FirstName).Returns("pesho");
mockedTeacher.Setup(t => t.LastName).Returns("pesho");
mockedTeacher.Setup(m => m.Subject).Returns(It.IsAny<Subject>());
var mockedStudent = new Mock<IStudent>();
mockedStudent.Setup(t => t.FirstName).Returns("pesho");
mockedStudent.Setup(t => t.LastName).Returns("pesho");
var mockedMark = new Mock<IMark>();
mockedMark.Setup(m => m.Value).Returns(float.Parse(parameters[2]));
mockedMark.Setup(m => m.Subject).Returns(It.IsAny<Subject>());
var mockedFactory = new Mock<IMarkFactory>();
mockedFactory.Setup(f => f.CreateMark(It.IsAny<Subject>(), It.IsAny<float>())).Returns(mockedMark.Object);
var mockedService = new Mock<ISchoolService>();
mockedService.Setup(s => s.GetStudentById(It.IsAny<int>())).Returns(mockedStudent.Object);
mockedService.Setup(s => s.GetTeacherById(It.IsAny<int>())).Returns(mockedTeacher.Object);
var command = new TeacherAddMarkCommand(mockedFactory.Object, mockedService.Object);
command.Execute(parameters);
mockedService.Verify(s => s.GetStudentById(int.Parse(parameters[1])));
}
public void AddNewMarkInStudentMarkCollection()
{
var parameters = new List <string>()
{
"0", "0", "3"
};
var mockedMark = new Mock <IMark>();
var mockedStudent = new Mock <IStudent>();
mockedStudent.Setup(x => x.Marks).Returns(new List <IMark>());
var mockedTeacher = new Mock <ITeacher>();
mockedTeacher.Setup(x => x.AddMark(mockedStudent.Object, float.Parse(parameters[2]))).Callback(() => mockedStudent.Object.Marks.Add(mockedMark.Object));
var mockedStorage = new Mock <IStorage>();
mockedStorage.Setup(x => x.Students).Returns(new Dictionary <int, IStudent>()
{
{ 0, mockedStudent.Object }
});
mockedStorage.Setup(x => x.Teachers).Returns(new Dictionary <int, ITeacher>()
{
{ 0, mockedTeacher.Object }
});
var teacherAddMarkCommand = new TeacherAddMarkCommand(mockedStorage.Object);
var expected = mockedStorage.Object.Students[0].Marks.Count + 1;
teacherAddMarkCommand.Execute(parameters);
Assert.AreEqual(expected, mockedStorage.Object.Students[0].Marks.Count);
}
public void TestExecute_PassValidParameters_ShouldCallFactoryCreateMarkCorrectly()
{
var parameters = new string[] { "0", " 0", " 2" };
var mockedTeacher = new Mock<ITeacher>();
mockedTeacher.Setup(t => t.FirstName).Returns("pesho");
mockedTeacher.Setup(t => t.LastName).Returns("pesho");
mockedTeacher.Setup(m => m.Subject).Returns(It.IsAny<Subject>());
var mockedStudent = new Mock<IStudent>();
mockedStudent.Setup(t => t.FirstName).Returns("pesho");
mockedStudent.Setup(t => t.LastName).Returns("pesho");
var mockedMark = new Mock<IMark>();
mockedMark.Setup(m => m.Value).Returns(float.Parse(parameters[2]));
mockedMark.Setup(m => m.Subject).Returns(It.IsAny<Subject>());
var mockedFactory = new Mock<IMarkFactory>();
mockedFactory.Setup(f => f.CreateMark(It.IsAny<Subject>(), It.IsAny<float>())).Returns(mockedMark.Object);
var mockedService = new Mock<ISchoolService>();
mockedService.Setup(s => s.GetStudentById(It.IsAny<int>())).Returns(mockedStudent.Object);
mockedService.Setup(s => s.GetTeacherById(It.IsAny<int>())).Returns(mockedTeacher.Object);
var command = new TeacherAddMarkCommand(mockedFactory.Object, mockedService.Object);
command.Execute(parameters);
mockedFactory.Verify(s => s.CreateMark(mockedMark.Object.Subject, mockedMark.Object.Value));
}
public void GetTheTeacher_WithThePassedId()
{
// Arrange
string teacherId = "0";
string studentId = "1";
string mark = "3.5";
IList <string> parameters = new List <string>()
{
teacherId,
studentId,
mark
};
var getStudentAndTeacherMock = new Mock <IGetStudentAndTeacher>();
var studentMock = new Mock <IStudent>();
var teacherMock = new Mock <ITeacher>();
getStudentAndTeacherMock.Setup(st => st.GetStudent(int.Parse(studentId))).Returns(studentMock.Object);
getStudentAndTeacherMock.Setup(st => st.GetTeacher(int.Parse(teacherId))).Returns(teacherMock.Object);
ICommand teacherAddMarkCommand = new TeacherAddMarkCommand(getStudentAndTeacherMock.Object);
// Act
teacherAddMarkCommand.Execute(parameters);
// Assert
getStudentAndTeacherMock.Verify(st => st.GetTeacher(int.Parse(teacherId)), Times.Once());
}
public void Execute_ShouldTeacherAddMarkMethodWithCorrectParameters_WhenValidArgumentsArePassed(
string teacher,
string student,
string mark)
{
//Arrange
var parameters = new List <string> {
teacher, student, mark
};
var teacherId = int.Parse(teacher);
var studentId = int.Parse(student);
var parsedMark = float.Parse(mark);
var mockedStudent = new Mock <IStudent>();
var mockedTeacher = new Mock <ITeacher>();
mockedTeacher.Setup(t => t.AddMark(mockedStudent.Object, parsedMark));
var mockedEngine = new Mock <ISchoolSystemEngine>();
mockedEngine.Setup(e => e.Data.Students.GetById(studentId))
.Returns(mockedStudent.Object);
mockedEngine.Setup(e => e.Data.Teachers.GetById(teacherId))
.Returns(mockedTeacher.Object);
var command = new TeacherAddMarkCommand();
//Act
command.Execute(parameters, mockedEngine.Object.Data);
//Assert
mockedTeacher.Verify(t => t.AddMark(mockedStudent.Object, parsedMark), Times.Once());
}
public void CallRetrievedTeacheAddMarkMetodWithCorrectParameters_WhenPassedArgumentsAreValid()
{
// arrange
int teacherId = int.Parse(parameters[0]);
int studentId = int.Parse(parameters[1]);
float mark = float.Parse(parameters[2]);
var student = new Mock <IStudent>();
var teacher = new Mock <ITeacher>();
var schoolSystemData = new Mock <ISchoolSystemData>();
var teacherAddMarkCommand = new TeacherAddMarkCommand(schoolSystemData.Object);
schoolSystemData
.Setup(x => x.GetStudent(It.IsAny <int>()))
.Returns(student.Object);
schoolSystemData
.Setup(x => x.GetTeacher(It.IsAny <int>()))
.Returns(teacher.Object);
// act
teacherAddMarkCommand.Execute(this.parameters);
// assert
teacher.Verify(x => x.AddMark(student.Object, mark), Times.Once);
}
public void CallTeacherAddMarkMethod()
{
// Arrange
var mockedEngine = new Mock <IEngine>();
var mockedStudent = new Mock <IStudent>();
var mockedTeacher = new Mock <ITeacher>();
var fakeStudents = new Dictionary <int, IStudent>();
var fakeTeachers = new Dictionary <int, ITeacher>();
var command = new TeacherAddMarkCommand(mockedEngine.Object);
var parameters = new string[] { "1", "1", "3.5" };
fakeStudents.Add(1, mockedStudent.Object);
fakeTeachers.Add(1, mockedTeacher.Object);
mockedEngine.Setup(x => x.Students).Returns(fakeStudents);
mockedEngine.Setup(x => x.Teachers).Returns(fakeTeachers);
mockedTeacher.Setup(x => x.AddMark(It.IsAny <IStudent>(), It.IsAny <float>())).Verifiable();
// Act
command.Execute(parameters);
// Assert
mockedTeacher.Verify(x => x.AddMark(It.IsAny <IStudent>(), It.IsAny <float>()), Times.Once);
}
public void ConstructorWithParametersShouldSetCorrect()
{
Mock <ISchoolRegister> mockedSchoolRegister = new Mock <ISchoolRegister>();
TeacherAddMarkCommand removeStudentCommand = new TeacherAddMarkCommand(mockedSchoolRegister.Object);
Assert.IsInstanceOf <TeacherAddMarkCommand>(removeStudentCommand);
}
public void NotToThrow_IfPassedParametersAreValid()
{
var mockedEngine = new Mock <IEngine>();
var command = new TeacherAddMarkCommand(mockedEngine.Object);
Assert.AreEqual(typeof(TeacherAddMarkCommand), command.GetType());
}
public void AddMarkOnlyToSpecifiedStudent()
{
// Arrange
string studentFirstName1 = "pesho";
string studentLastName1 = "peshov";
string studentFirstName2 = "gosho";
string studentLastName2 = "goshev";
string grade = "7";
string teacherFirstName = "ivan";
string teacherLastName = "ivanov";
string subject = "1";
string mark = "2";
IList <string> studentArgs1 = new List <string>()
{
studentFirstName1, studentLastName1, grade
};
IList <string> studentArgs2 = new List <string>()
{
studentFirstName2, studentLastName2, grade
};
IList <string> teacherArgs = new List <string>()
{
teacherFirstName, teacherLastName, subject
};
var studentFactory = new StudentFactory();
var createStudentCommand = new CreateStudentCommand(studentFactory);
var teacherFactory = new TeacherFactory();
var createTeacherCommand = new CreateTeacherCommand(teacherFactory);
var teacherAddMarkCommand = new TeacherAddMarkCommand();
// Act
createStudentCommand.Execute(studentArgs1);
createStudentCommand.Execute(studentArgs2);
createTeacherCommand.Execute(teacherArgs);
var addMarkMessage = teacherAddMarkCommand.Execute(new List <string>()
{
"0", "0", mark
});
// Assert
Assert.IsTrue(Engine.Students[0].Marks.Count == 1);
Assert.IsTrue(Engine.Students[1].Marks.Count == 0);
}
public void Execute_ShouldThrowArgumentNullException_WhenNullArgumentsArePassed(
string teacherId,
string studentId,
string mark)
{
//Arrange
var parameters = new List <string> {
teacherId, studentId, mark
};
var mockedEngine = new Mock <ISchoolSystemEngine>();
var command = new TeacherAddMarkCommand();
//Act
Assert.Throws <ArgumentNullException>(() => command.Execute(parameters, mockedEngine.Object.Data));
}
public void ReturnSuccessMessage_WhenTheMarkIsAdded()
{
// Arrange
string teacherId = "0";
string teacherFirstName = "Teacher first name";
string teacherLastName = "Teacher last name";
Subject subject = Subject.Bulgarian;
string studentId = "1";
string studentFirstName = "Student first name";
string studentLastName = "Student last name";
string mark = "3.5";
IList <string> parameters = new List <string>()
{
teacherId,
studentId,
mark
};
string successMessage = $"Teacher {teacherFirstName} {teacherLastName} added mark {mark} to student {studentFirstName} {studentLastName} in {subject}.";
var getStudentAndTeacherMock = new Mock <IGetStudentAndTeacher>();
var studentMock = new Mock <IStudent>();
var teacherMock = new Mock <ITeacher>();
getStudentAndTeacherMock.Setup(st => st.GetStudent(int.Parse(studentId))).Returns(studentMock.Object);
getStudentAndTeacherMock.Setup(st => st.GetTeacher(int.Parse(teacherId))).Returns(teacherMock.Object);
teacherMock.Setup(t => t.FirstName).Returns(teacherFirstName);
teacherMock.Setup(t => t.LastName).Returns(teacherLastName);
teacherMock.Setup(t => t.Subject).Returns(subject);
teacherMock.Setup(t => t.AddMark(studentMock.Object, float.Parse(mark)));
studentMock.Setup(s => s.FirstName).Returns(studentFirstName);
studentMock.Setup(s => s.LastName).Returns(studentLastName);
ICommand teacherAddMarkCommand = new TeacherAddMarkCommand(getStudentAndTeacherMock.Object);
// Act
string executionResult = teacherAddMarkCommand.Execute(parameters);
// Assert
StringAssert.Contains(successMessage, executionResult);
}
public void ReturnCorrectMessage_WithCorrectTeacherAndStudentInformation()
{
// Arrange
string studentFirstName = "pesho";
string studentLastName = "peshov";
string grade = "7";
string teacherFirstName = "ivan";
string teacherLastName = "ivanov";
string subject = "1";
string mark = "2";
string subjectEnum = "English";
IList <string> studentArgs = new List <string>()
{
studentFirstName, studentLastName, grade
};
IList <string> teacherArgs = new List <string>()
{
teacherFirstName, teacherLastName, subject
};
var studentFactory = new StudentFactory();
var createStudentCommand = new CreateStudentCommand(studentFactory);
var teacherFactory = new TeacherFactory();
var createTeacherCommand = new CreateTeacherCommand(teacherFactory);
var teacherAddMarkCommand = new TeacherAddMarkCommand();
string expectedMessage = $"Teacher {teacherFirstName} {teacherLastName} added mark {mark} to student {studentFirstName} {studentLastName} in {subjectEnum}.";
// Act
createStudentCommand.Execute(studentArgs);
createTeacherCommand.Execute(teacherArgs);
var addMarkMessage = teacherAddMarkCommand.Execute(new List <string>()
{
"0", "0", mark
});
// Assert
//Assert.IsTrue(addMarkMessage.Contains($"{teacherFirstName} {teacherLastName}") && addMarkMessage.Contains($"{studentFirstName} {studentLastName}"));
Assert.IsTrue(addMarkMessage == expectedMessage);
}
public void MethodExecuteWithCorectParametersShouldAddMarkOnStudent()
{
IList <string> studentAndTeacherIdsAndMark = new List <string>()
{
"5", "5", "2"
};
Mock <ITeacher> mockedTeacher = new Mock <ITeacher>();
mockedTeacher.Setup(x => x.FirstName).Returns("Gosho");
mockedTeacher.Setup(x => x.LastName).Returns("Goshov");
mockedTeacher.Setup(x => x.Subject).Returns(Subject.Programming);
Mock <IMark> mockedMark = new Mock <IMark>();
mockedMark.Setup(x => x.Subject).Returns(Subject.Programming);
mockedMark.Setup(s => s.Value).Returns(2);
var marksList = new List <Mark>();
Mock <IStudent> mockedStudent = new Mock <IStudent>();
mockedStudent.Setup(x => x.FirstName).Returns("Pesho");
mockedStudent.Setup(x => x.LastName).Returns("Petrov");
mockedStudent.Setup(x => x.Grade).Returns(Grade.Eighth);
mockedStudent.Setup(x => x.Marks);
var students = new Dictionary <int, IStudent>();
students.Add(5, mockedStudent.Object);
var teachers = new Dictionary <int, ITeacher>();
teachers.Add(5, mockedTeacher.Object);
Mock <ISchoolRegister> mockedSchoolRegister = new Mock <ISchoolRegister>();
mockedSchoolRegister.Setup(x => x.Students).Returns(students);
mockedSchoolRegister.Setup(x => x.Teachers).Returns(teachers);
TeacherAddMarkCommand addMark = new TeacherAddMarkCommand(mockedSchoolRegister.Object);
addMark.Execute(studentAndTeacherIdsAndMark);
Assert.AreEqual(2, mockedMark.Object.Value);
}
public void AddMarkToStudent_WhenParametersAreCorrect(IList <string> parameters)
{
// Arrange
var parametersTuple = GetParameters(parameters);
var studentMock = new Mock <IStudent>();
var teacherMock = new Mock <ITeacher>();
var getStudentAndTeacherMock = new Mock <IGetStudentAndTeacher>();
getStudentAndTeacherMock.Setup(g => g.GetStudent(parametersTuple.Item2)).Returns(studentMock.Object);
getStudentAndTeacherMock.Setup(g => g.GetTeacher(parametersTuple.Item1)).Returns(teacherMock.Object);
var teacherAddMarkCommand = new TeacherAddMarkCommand(getStudentAndTeacherMock.Object);
// Act
teacherAddMarkCommand.Execute(parameters);
// Assert
teacherMock.Verify(t => t.AddMark(studentMock.Object, parametersTuple.Item3), Times.Once());
}
public void ReturnCorrectMessage_WhenMarkHasBeenAddedToStudentSuccessfully()
{
// arrange
int teacherId = int.Parse(parameters[0]);
int studentId = int.Parse(parameters[1]);
float mark = float.Parse(parameters[2]);
var student = new Mock <IStudent>();
var teacher = new Mock <ITeacher>();
var schoolSystemData = new Mock <ISchoolSystemData>();
var teacherAddMarkCommand = new TeacherAddMarkCommand(schoolSystemData.Object);
schoolSystemData
.Setup(x => x.GetStudent(It.IsAny <int>()))
.Returns(student.Object);
schoolSystemData
.Setup(x => x.GetTeacher(It.IsAny <int>()))
.Returns(teacher.Object);
string teacherFirstName = "Profesora";
string teacherLastName = "Umniq";
Subject teacherSubject = Subject.Programming;
string studentFirstName = "Vankata";
string studentLastName = "Petkov";
teacher.Setup(x => x.FirstName).Returns(teacherFirstName);
teacher.Setup(x => x.LastName).Returns(teacherLastName);
teacher.Setup(x => x.Subject).Returns(teacherSubject);
student.Setup(x => x.FirstName).Returns(studentFirstName);
student.Setup(x => x.LastName).Returns(studentLastName);
string expectedMessage = $"Teacher {teacherFirstName} {teacherLastName} added mark {mark} to student {studentFirstName} {studentLastName} in {teacherSubject}.";
// act
string actualMessage = teacherAddMarkCommand.Execute(this.parameters);
// assert
StringAssert.Contains(expectedMessage, actualMessage);
}
public void Execute_ShouldReturnCorrectValue_WhenValidArgumentsArePassed()
{
//Arrange
const string Name = "Pesho";
const string ExpectedMessage =
"Teacher Pesho Pesho added mark 2 to student Pesho Pesho in Bulgarian.";
var parameters = new List <string> {
"1", "1", "2"
};
var mockedStudent = new Mock <IStudent>();
mockedStudent.Setup(s => s.FirstName)
.Returns(Name);
mockedStudent.Setup(s => s.LastName)
.Returns(Name);
var mockedTeacher = new Mock <ITeacher>();
mockedTeacher.Setup(s => s.FirstName)
.Returns(Name);
mockedTeacher.Setup(s => s.LastName)
.Returns(Name);
mockedTeacher.Setup(s => s.Subject)
.Returns(Subject.Bulgarian);
var mockedEngine = new Mock <ISchoolSystemEngine>();
mockedEngine.Setup(e => e.Data.Students.GetById(1))
.Returns(mockedStudent.Object);
mockedEngine.Setup(e => e.Data.Teachers.GetById(1))
.Returns(mockedTeacher.Object);
var command = new TeacherAddMarkCommand();
//Act
var result = command.Execute(parameters, mockedEngine.Object.Data);
//Assert
Assert.AreEqual(ExpectedMessage, result);
}
public void Execute_ShouldReturnCorrectString()
{
var mockSchoolSystemData = new Mock <ISchoolSystemData>();
var mockStudentsDataCollection = new Mock <ISchoolSystemDataCollection <IStudent> >();
var mockTeachersDataCollection = new Mock <ISchoolSystemDataCollection <ITeacher> >();
var mockStudent = new Mock <IStudent>();
var mockTeacher = new Mock <ITeacher>();
mockTeacher.SetupGet(t => t.FirstName).Returns("teacher-first");
mockTeacher.SetupGet(t => t.LastName).Returns("teacher-last");
mockTeacher.SetupGet(t => t.Subject).Returns(Subject.Programming);
mockStudent.SetupGet(s => s.FirstName).Returns("student-first");
mockStudent.SetupGet(s => s.LastName).Returns("student-last");
mockSchoolSystemData.SetupGet(ssd => ssd.Students).Returns(mockStudentsDataCollection.Object);
mockSchoolSystemData.SetupGet(ssd => ssd.Teachers).Returns(mockTeachersDataCollection.Object);
mockStudentsDataCollection.Setup(sdc => sdc.GetById(It.IsAny <int>())).Returns(mockStudent.Object);
mockTeachersDataCollection.Setup(tdc => tdc.GetById(It.IsAny <int>())).Returns(mockTeacher.Object);
var parameters = new List <string>()
{
"1",
"2",
"3.3"
};
var mark = 3.3f;
var expectedString = $"Teacher {mockTeacher.Object.FirstName} {mockTeacher.Object.LastName} added mark {mark} to student {mockStudent.Object.FirstName} {mockStudent.Object.LastName} in {mockTeacher.Object.Subject}.";
var teacherAddMarkCommand = new TeacherAddMarkCommand();
var actualString = teacherAddMarkCommand.Execute(parameters, mockSchoolSystemData.Object);
Assert.True(actualString == expectedString);
}
public void Execute_ShouldCallGetByIdMethodsWithCorrectParameters_WhenValidArgumentsArePassed()
{
//Arrange
var parameters = new List <string> {
"1", "1", "2"
};
var mockedStudent = new Mock <IStudent>();
var mockedTeacher = new Mock <ITeacher>();
var mockedEngine = new Mock <ISchoolSystemEngine>();
mockedEngine.Setup(e => e.Data.Students.GetById(1))
.Returns(mockedStudent.Object);
mockedEngine.Setup(e => e.Data.Teachers.GetById(1))
.Returns(mockedTeacher.Object);
var command = new TeacherAddMarkCommand();
//Act
command.Execute(parameters, mockedEngine.Object.Data);
//Assert
mockedEngine.Verify(e => e.Data.Students.GetById(1), Times.Once);
mockedEngine.Verify(e => e.Data.Teachers.GetById(1), Times.Once);
}
public void AddMarkMethod_MustBeCalledOnce()
{
var parameters = new List <string>()
{
"0", "0", "3"
};
var mockedStudent = new Mock <IStudent>();
var mockedTeacher = new Mock <ITeacher>();
var mockedStorage = new Mock <IStorage>();
mockedStorage.Setup(x => x.Students).Returns(new Dictionary <int, IStudent>()
{
{ 0, mockedStudent.Object }
});
mockedStorage.Setup(x => x.Teachers).Returns(new Dictionary <int, ITeacher>()
{
{ 0, mockedTeacher.Object }
});
var teacherAddMarkCommand = new TeacherAddMarkCommand(mockedStorage.Object);
var actual = teacherAddMarkCommand.Execute(parameters);
mockedTeacher.Verify(x => x.AddMark(mockedStudent.Object, float.Parse(parameters[2])), Times.Once);
}
public void ReturnSuccessMessage_WhenParametersAreCorrect(IList <string> parameters)
{
// Arrange
var parametersTuple = GetParameters(parameters);
var studentFirstName = "studentFirstName";
var studentLastName = "studentLastName";
var studentMock = new Mock <IStudent>();
studentMock.SetupGet(s => s.FirstName).Returns(studentFirstName);
studentMock.SetupGet(s => s.LastName).Returns(studentLastName);
var teacherFirstName = "teacherFirstName";
var teacherLastName = "teacherLastName";
var teacherSubject = Subject.English;
var teacherMock = new Mock <ITeacher>();
teacherMock.SetupGet(s => s.FirstName).Returns(teacherFirstName);
teacherMock.SetupGet(s => s.LastName).Returns(teacherLastName);
teacherMock.SetupGet(s => s.Subject).Returns(teacherSubject);
var getStudentAndTeacherMock = new Mock <IGetStudentAndTeacher>();
getStudentAndTeacherMock.Setup(g => g.GetStudent(parametersTuple.Item2)).Returns(studentMock.Object);
getStudentAndTeacherMock.Setup(g => g.GetTeacher(parametersTuple.Item1)).Returns(teacherMock.Object);
var expectedResult = string.Format(SuccessMessageTemplate, teacherFirstName, teacherLastName,
parametersTuple.Item3, studentFirstName, studentLastName, teacherSubject);
var teacherAddMarkCommand = new TeacherAddMarkCommand(getStudentAndTeacherMock.Object);
// Act
var result = teacherAddMarkCommand.Execute(parameters);
// Assert
Assert.AreEqual(expectedResult, result);
}
