class Execution(object): """ Represents the parameters of a call to the command stub. """ def __init__(self, command, arguments, stdin, expected=False): """ initializes a new execution with the given properties. If arguments is not given it will be initialized as empty list. """ self.command_input = CommandInput(command, arguments, stdin) self.expected = expected def as_dictionary(self): """ returns a dictionary representation of the execution. """ return { 'command_input': self.command_input.as_dictionary(), 'expected': self.expected } def mark_as_expected(self): """ marks the execution as expected which means the execution fulfills a stub configuration. """ self.expected = True def __eq__(self, other): return self.command_input == other.command_input \ and self.expected == other.expected def __ne__(self, other): return not (self == other) def __str__(self): """ returns a string representation using as_dictionary. """ return 'Execution %s' % (self.as_dictionary()) @staticmethod def from_dictionary(dictionary): """ returns a new execution object with the properties from the given dictionary. """ command_input_dictionary = dictionary['command_input'] return Execution(command_input_dictionary['command'], command_input_dictionary['arguments'], command_input_dictionary['stdin'], dictionary['expected'])
def test_should_convert_object_to_dictionary(self): command_input = CommandInput( 'any_command', ['any_arg1', 'any_arg2'], 'any_stdin') actual_dictionary = command_input.as_dictionary() expected_dictionary = {'command': 'any_command', 'arguments': ['any_arg1', 'any_arg2'], 'stdin': 'any_stdin'} self.assertEqual(expected_dictionary, actual_dictionary)
class StubConfiguration(object): """ Represents the configuration of a command stub and contains the corresponding answers. """ def __init__(self, command, arguments=[], stdin=None, answers=[], initial_answer=0): """ will initialize a new object with the given properties. answers and initial_answer are not mandatory. """ self.command_input = CommandInput(command, arguments, stdin) self.answers = [] self.current_answer = initial_answer for answer in answers: self.answers.append(answer) self.and_input = self.with_input def as_dictionary(self): """ returns a dictionary representation of this stub configuration. """ answers_list = [] for answer in self.answers: answer_dictionary = answer.as_dictionary() answers_list.append(answer_dictionary) result = { 'command_input': self.command_input.as_dictionary(), 'answers': answers_list, 'current_answer': self.current_answer } return result def next_answer(self): """ returns the next answer in the list of answers or if the end of the list is reached it will repeatedly return the last answer of the list. """ if len(self.answers) == 0: raise Exception('List of answers is empty!') result = self.answers[self.current_answer] if self.current_answer < len(self.answers) - 1: self.current_answer += 1 return result def then(self, answer): """ will append the given answer to the list of answers and return the object itself for invocation chaining. """ self.answers.append(answer) return self def then_answer(self, stdout=None, stderr=None, return_code=0, milliseconds_to_wait=None): """ a convenience method to "then" which will create a new answer object with the given properties. """ return self.then( Answer(stdout, stderr, return_code, milliseconds_to_wait)) def then_return(self, return_code, milliseconds_to_wait=None): """ a convenience method to "then" which will create a new answer object with the given return_code. """ return self.then_answer(return_code=return_code, milliseconds_to_wait=milliseconds_to_wait) def then_write(self, stdout=None, stderr=None, milliseconds_to_wait=None): """ a convenience method to "then" which will create a new answer object with the given stdout and stderr output. """ return self.then_answer(stdout=stdout, stderr=stderr, milliseconds_to_wait=milliseconds_to_wait) def at_least_with_arguments(self, *arguments): """ sets the given arguments and returns self for invocation chaining """ self.command_input.arguments = list(arguments) return self def with_input(self, stdin): """ sets the given arguments and returns self for invocation chaining """ self.command_input.stdin = stdin return self def __eq__(self, other): return self.command_input == other.command_input \ and self.current_answer == other.current_answer \ and self.answers == other.answers def __str__(self): """ returns a string representation of this stub configuration using the method "as_dictionary" """ return 'StubConfiguration %s' % (self.as_dictionary()) @staticmethod def from_dictionary(dictionary): """ returns a new stub configuration object with the properties from the given dictionary """ answers = [] for answer_dictionary in dictionary['answers']: answer = Answer.from_dictionary(answer_dictionary) answers.append(answer) command_input_dictionary = dictionary['command_input'] stub_configuration = StubConfiguration( command_input_dictionary['command'], command_input_dictionary['arguments'], command_input_dictionary['stdin'], answers, dictionary['current_answer']) return stub_configuration