public void Start_ShouldInvokeCommandProviderFindCommandWithName_WithCorrectParameter(string command, string commandName)
{
var startIndex = 0;
var commandsStrings = new List <string>()
{
command,
"End"
};
var userInterface = new Mock <IUserInterfaceProvider>();
userInterface.Setup(ui => ui.ReadLine()).Returns(() =>
{
return(commandsStrings[startIndex++]);
});
var commandProvider = new Mock <ICommandProvider>();
commandProvider.Setup(cp => cp.FindCommandExecutorWithName(It.IsAny <string>())).Returns(new Mock <ICommand>().Object);
var engine = new SchoolSystemEngine(userInterface.Object, commandProvider.Object);
engine.Start();
commandProvider.Verify(cp => cp.FindCommandExecutorWithName(commandName), Times.Once());
}
public void Start_ShouldInvokeUserInterfaceWriteLineWithCorrectMessage_WhenCommandIsNotFound()
{
var startIndex = 0;
var commandsStrings = new List <string>()
{
"NotExistingCommand 1 2 3",
"End"
};
var userInterface = new Mock <IUserInterfaceProvider>();
userInterface.Setup(ui => ui.ReadLine()).Returns(() =>
{
return(commandsStrings[startIndex++]);
});
var commandProvider = new Mock <ICommandProvider>();
commandProvider.Setup(cp => cp.FindCommandExecutorWithName(It.IsAny <string>())).Returns(() => null);
var engine = new SchoolSystemEngine(userInterface.Object, commandProvider.Object);
engine.Start();
userInterface.Verify(ui => ui.WriteLine("The passed command is not found!"), Times.Once());
}
public void Start_ShouldInvokeUserInterfaceWriteLine_WithCorrectMessageWhenCommandHasExecutedCorrectly()
{
var expectedMessage = "expected message";
var startIndex = 0;
var commandsStrings = new List <string>()
{
"CreateTeacher 1 2 3",
"End"
};
var userInterface = new Mock <IUserInterfaceProvider>();
userInterface.Setup(ui => ui.ReadLine()).Returns(() =>
{
return(commandsStrings[startIndex++]);
});
var mockCommand = new Mock <ICommand>();
mockCommand.Setup(command => command.Execute(It.IsAny <IList <string> >(), It.IsAny <ISchoolSystemEngine>()))
.Returns(expectedMessage);
var commandProvider = new Mock <ICommandProvider>();
commandProvider.Setup(cp => cp.FindCommandExecutorWithName(It.IsAny <string>())).Returns(mockCommand.Object);
var engine = new SchoolSystemEngine(userInterface.Object, commandProvider.Object);
engine.Start();
userInterface.Verify(ui => ui.WriteLine(expectedMessage), Times.Once());
}
public void Start_ShouldInvokeTheCommand_WithCorrectParameters()
{
var startIndex = 0;
var commandsStrings = new List <string>()
{
"NotExistingCommand 1 2 3",
"End"
};
var commandParameters = new List <string>()
{
"1", "2", "3"
};
var userInterface = new Mock <IUserInterfaceProvider>();
userInterface.Setup(ui => ui.ReadLine()).Returns(() =>
{
return(commandsStrings[startIndex++]);
});
var mockCommand = new Mock <ICommand>();
var commandProvider = new Mock <ICommandProvider>();
commandProvider.Setup(cp => cp.FindCommandExecutorWithName(It.IsAny <string>())).Returns(mockCommand.Object);
var engine = new SchoolSystemEngine(userInterface.Object, commandProvider.Object);
engine.Start();
mockCommand.Verify(command => command.Execute(commandParameters, It.IsAny <ISchoolSystemEngine>()), Times.Once());
}
public void AddStudent_WhenStudentIsNull_ShouldThrowArgumentNullException()
{
var id = 100;
IStudent nullStudent = null;
var ex = Assert.Throws <ArgumentNullException>(() => SchoolSystemEngine.AddStudent(id, nullStudent));
StringAssert.Contains("cannot be null or empty", ex.Message);
}
public void AddStudent_ShouldAddStudentToListOfStudent()
{
var expectedId = 10;
var mockedStudent = new Mock <IStudent>();
SchoolSystemEngine.AddStudent(expectedId, mockedStudent.Object);
Assert.AreSame(SchoolSystemEngine.Students[expectedId], mockedStudent.Object);
}
public void AddTeacher_WhenTeacherIsNull_ShouldThrowArgumentNullException()
{
var id = 100;
ITeacher nullTeacher = null;
var ex = Assert.Throws <ArgumentNullException>(() => SchoolSystemEngine.AddTeacher(id, nullTeacher));
StringAssert.Contains("cannot be null or empty", ex.Message);
}
public void AddTeacher_WhenIdIsInvalid_ShouldThrowArgumentOutOfRangeException()
{
var invalidID = -1;
var mockedTeacher = new Mock <ITeacher>();
var ex = Assert.Throws <ArgumentOutOfRangeException>(() => SchoolSystemEngine.AddTeacher(invalidID, mockedTeacher.Object));
StringAssert.Contains("cannot be less than 0!", ex.Message);
}
public void AddTeacher_ShouldAddTeacherToListOfTeachers()
{
var expectedId = 10;
var mockedTeacher = new Mock <ITeacher>();
SchoolSystemEngine.AddTeacher(expectedId, mockedTeacher.Object);
Assert.AreSame(SchoolSystemEngine.Teachers[expectedId], mockedTeacher.Object);
}
public void RemoveTeacher_ShouldRemoveAddedTeacherFromList()
{
var expectedId = 11;
var mockedTeacher = new Mock <ITeacher>();
SchoolSystemEngine.AddTeacher(expectedId, mockedTeacher.Object);
SchoolSystemEngine.RemoveTeacher(expectedId);
Assert.IsFalse(SchoolSystemEngine.Teachers.ContainsKey(expectedId));
}
private static void Main()
{
var consoleReader = new ConsoleReader();
var consoleWriter = new ConsoleWriter();
var students = new Dictionary <int, IStudent>();
var teachers = new Dictionary <int, ITeacher>();
var commandFactory = new CommandFactory();
var engine = new SchoolSystemEngine(consoleReader, consoleWriter, teachers, students, commandFactory);
engine.Start();
}
public void RemoveStudent_ShouldRemoveStudentInStudents()
{
var expectedId = 11;
var mockedStudent = new Mock <IStudent>();
SchoolSystemEngine.AddStudent(expectedId, mockedStudent.Object);
SchoolSystemEngine.RemoveStudent(expectedId);
Assert.IsFalse(SchoolSystemEngine.Students.ContainsKey(expectedId));
}
/// <summary>
/// Executes the CreateStudentCommand and returns the result.
/// </summary>
/// <param name="parameters">The Student parameters.</param>
/// <returns>A string describing the new student.</returns>
public string Execute(IList <string> parameters)
{
var firstName = parameters[0];
var lastName = parameters[1];
var grade = (Grade)int.Parse(parameters[2]);
var studentToAdd = new Student(firstName, lastName, grade);
SchoolSystemEngine.AddStudent(id, studentToAdd);
return($"A new student with name {studentToAdd.FirstName} {studentToAdd.LastName}, grade {studentToAdd.Grade} and ID {id++} was created.");
}
/// <summary>
/// Executes the CreateTeacherCommand and returns the result.
/// </summary>
/// <param name="parameters">The Teacher parameters.</param>
/// <returns>A string describing the new teacher.</returns>
public string Execute(IList <string> parameters)
{
var firstName = parameters[0];
var lastName = parameters[1];
var subject = (Subject)int.Parse(parameters[2]);
var teacherToAdd = new Teacher(firstName, lastName, subject);
SchoolSystemEngine.AddTeacher(id, teacherToAdd);
return($"A new teacher with name {teacherToAdd.FirstName} {teacherToAdd.LastName}, subject {teacherToAdd.Subject} and ID {id++} was created.");
}
/// <summary>
/// Executes the RemoveTeacherCommand and returns the result.
/// </summary>
/// <param name="parameters">The teacher ID.</param>
/// <returns>A string describing the result of the operation.</returns>
public string Execute(IList <string> parameters)
{
var teacherId = int.Parse(parameters[0]);
if (SchoolSystemEngine.RemoveTeacher(teacherId))
{
return($"Teacher with ID {teacherId} was sucessfully removed.");
}
else
{
return($"Teacher with ID {teacherId} was not found.");
}
}
/// <summary>
/// Executes the RemoveStudentCommand and returns the result.
/// </summary>
/// <param name="parameters">The student ID.</param>
/// <returns>A string describing the result of the operation.</returns>
public string Execute(IList <string> parameters)
{
var studentId = int.Parse(parameters[0]);
if (SchoolSystemEngine.RemoveStudent(studentId))
{
return($"Student with ID {studentId} was sucessfully removed.");
}
else
{
return($"Student with ID {studentId} was not found.");
}
}
public void Start_ShouldInvokeUserInterfaceReadLineOnce_IfTheFirstCommandIsEnd()
{
var commandsString = "End";
var stringReader = new StringReader(commandsString);
var userInterface = new Mock <IUserInterfaceProvider>();
userInterface.Setup(ui => ui.ReadLine()).Returns(stringReader.ReadLine());
var commandProvider = new Mock <ICommandProvider>();
var engine = new SchoolSystemEngine(userInterface.Object, commandProvider.Object);
engine.Start();
userInterface.Verify(ui => ui.ReadLine(), Times.Once());
}
public void Start_ShouldCallReadLineOnceAndReturn_WhenEndCommandIsRead()
{
var mockedWriter = new Mock <IWriter>();
var teachers = new Dictionary <int, ITeacher>();
var students = new Dictionary <int, IStudent>();
var mockedCommandFactory = new Mock <ICommandFactory>();
var mockedReader = new Mock <IReader>();
mockedReader.Setup(x => x.ReadLine()).Returns("End");
var result = new SchoolSystemEngine(
mockedReader.Object,
mockedWriter.Object,
teachers,
students,
mockedCommandFactory.Object);
result.Start();
mockedReader.Verify(x => x.ReadLine(), Times.Once());
}
public void Ctor_WhenValidParamsArePassed_ShouldReturnCorrectSchoolSystemEngineObject()
{
var mockedReader = new Mock <IReader>();
var mockedWriter = new Mock <IWriter>();
var teachers = new Dictionary <int, ITeacher>();
var students = new Dictionary <int, IStudent>();
var mockedCommandFactory = new Mock <ICommandFactory>();
var result = new SchoolSystemEngine(
mockedReader.Object,
mockedWriter.Object,
teachers,
students,
mockedCommandFactory.Object);
var privateObjectResult = new PrivateObject(result);
Assert.AreSame(mockedCommandFactory.Object, privateObjectResult.GetField("commandFactory"));
Assert.AreSame(mockedReader.Object, privateObjectResult.GetField("reader"));
Assert.AreSame(mockedWriter.Object, privateObjectResult.GetField("writer"));
Assert.AreSame(teachers, SchoolSystemEngine.Teachers);
Assert.AreSame(students, SchoolSystemEngine.Students);
}
public void Start_ShouldCallReadLineTwiceCreateACommandAndExecuteIt_WhenCommandIsPassed()
{
var teachers = new Dictionary <int, ITeacher>();
var students = new Dictionary <int, IStudent>();
var mockedCommand = new Mock <ICommand>();
mockedCommand.Setup(x => x.Execute(It.IsAny <IList <string> >()))
.Returns("EXECUTED!");
var mockedWriter = new Mock <IWriter>();
mockedWriter.Setup(x => x.WriteLine("EXECUTED!"));
var mockedCommandFactory = new Mock <ICommandFactory>();
mockedCommandFactory.Setup(x => x.CreateCommand(It.Is <string>(y => y == "CreateStudent")))
.Returns(new Mock <ICommand>().Object);
var mockedReader = new Mock <IReader>();
mockedReader.SetupSequence(x => x.ReadLine())
.Returns("CreateStudent FirstName LastName 1")
.Returns("End");
var result = new SchoolSystemEngine(
mockedReader.Object,
mockedWriter.Object,
teachers,
students,
mockedCommandFactory.Object);
result.Start();
mockedCommandFactory.Verify(x => x.CreateCommand(It.Is <string>(y => y == "CreateStudent")), Times.Once());
mockedReader.Verify(x => x.ReadLine(), Times.Exactly(2));
mockedWriter.Verify(x => x.WriteLine(It.IsAny <string>()), Times.Once());
}
public void Start_ShouldInvokeUserInterfaceWriteLineWithCorrectMessage_WhenInputIsAnEmptyLine()
{
var startIndex = 0;
var commandsStrings = new List <string>()
{
"",
"End"
};
var userInterface = new Mock <IUserInterfaceProvider>();
userInterface.Setup(ui => ui.ReadLine()).Returns(() =>
{
return(commandsStrings[startIndex++]);
});
var commandProvider = new Mock <ICommandProvider>();
var engine = new SchoolSystemEngine(userInterface.Object, commandProvider.Object);
engine.Start();
userInterface.Verify(ui => ui.WriteLine("The passed command is not found!"), Times.Once());
}
private static ISchoolSystemEngine GetEngine(IUserInterfaceProvider userInterface, ICommandProvider commandProvider)
{
var engine = new SchoolSystemEngine(userInterface, commandProvider);
return(engine);
}
