def test_Closure_hashability(self):
def another_function(*args, **kwargs):
return args, kwargs
self.assertEqual(another_function(*tuple(), **dict()), (tuple(), dict()))
another_kwarg = 'another_kwarg'
closure = Closure(function, arg, kwarg=kwarg)
closure_duplicate = Closure(function, arg, kwarg=kwarg)
extended_closure = Closure(function, arg, kwarg=kwarg, another_kwarg=another_kwarg)
different_closure = Closure(another_function, 'different_arg', different_kwarg='different_kwarg')
self.assertEqual(hash(closure), hash(closure_duplicate))
self.assertNotEqual(hash(closure), hash(extended_closure))
self.assertNotEqual(hash(closure), hash(different_closure))
def test_Pipeline_Fitting(self, mock_input, mock_exists, mock_file):
filename = 'this/file.txt'
file = FakeFile()
question = b'How are you?'
reply = 'I\'m fine.'
mock_file.return_value = file
mock_exists.return_value = True
mock_input.side_effect = [filename, reply]
read_input = ReadInput('Which file?')
action_types = [
Pipeline.Fitting(
action=Write,
reaction=Call(Closure(bytes.decode)),
**{'append': True, 'to_write': question},
),
Read, # retrieve question from FakeFile
ReadInput # pose question to user
]
pipeline = Pipeline(read_input, *action_types, should_raise=True)
result = pipeline.perform(should_raise=True)
self.assertEqual(file.read(), question + b'\n')
self.assertIsInstance(result, Result)
self.assertEqual(result.value, reply)
def test_can_repeatedly_perform_Pipeline_with_Receiver(self, mock_input, mock_exists, mock_file):
filename = 'this/file.txt'
file = FakeFile()
reply = b'The machines have worked perfectly up till now.'
mock_file.return_value = file
mock_exists.return_value = True
mock_input.return_value = reply
read_input = ReadInput('What would you like to record?')
action_types = [
Pipeline.Fitting(
action=Write,
reaction=Call(Closure(bytes.decode)),
**{'append': True, 'filename': filename, 'to_write': Pipeline.Receiver},
)
]
pipeline = Pipeline(read_input, *action_types, should_raise=True)
result = pipeline.perform(should_raise=True)
self.assertEqual(file.read(), reply + b'\n')
self.assertIsInstance(result, Result)
self.assertEqual(result.value, f'{cwd()}/{filename}')
second_result = pipeline.perform(should_raise=True)
self.assertEqual(file.read(), reply + b'\n' + reply + b'\n')
self.assertIsInstance(second_result, Result)
self.assertEqual(second_result.value, f'{cwd()}/{filename}')
def test_Closure_instantiation(self):
closure = Closure(function, arg, kwarg=kwarg)
args, kwargs = closure()
self.assertIsInstance(args, tuple)
self.assertEqual(args[0], arg)
self.assertIsInstance(kwargs, dict)
self.assertEqual(kwargs[kwarg], kwarg)
def flush(self, given_action: Optional[Action] = None) -> Action:
next_action_type = next(self)
if next_action_type:
params_dict = OrderedDict(signature(next_action_type.__init__).parameters.items())
params_dict.pop('self', None)
params = list(params_dict.keys())
keyed_result = dict(zip(params, [given_action.perform(should_raise=self.should_raise).value]))
if next_action_type.__name__ == Pipeline.Fitting.__name__:
params_dict = OrderedDict(signature(next_action_type.action.__init__).parameters.items())
params_dict.pop('self', None)
params = list(params_dict.keys())
conduit = first(params)
key = key_for(Pipeline.Receiver, dict(next_action_type.kwargs))
if conduit in next_action_type.kwargs and key:
params = swap(params, 0, params.index(key))
keyed_result = dict(zip(params, [keyed_result['action']]))
if conduit == 'closure':
keyed_result['closure'] = Closure(next_action_type.enclose, keyed_result['closure'])
next_action_type.kwargs.update(keyed_result)
next_action = next_action_type.action(**next_action_type.kwargs)
next_action_type.kwargs[key] = Pipeline.Receiver
else:
next_action = next_action_type(**keyed_result)
return self.flush(next_action)
return given_action
def test_Closure_repr(self):
closure = Closure(function, arg, kwarg=kwarg)
self.assertIn(function.__name__, repr(closure))
self.assertIn(str(arg), repr(closure))
self.assertIn(str(kwarg), repr(closure))
def test_Closure_does_not_accept_lambdas(self):
value = 'no good.'
function = lambda: value
self.assertEqual(function(), value)
with self.assertRaises(Closure.LambdaNotAllowed):
Closure(function, 'this', should='fail')
def test_Closure_repr_contains_params(self):
closure = Closure(function, arg, kwarg=kwarg)
self.assertIn(str(arg), repr(closure))
self.assertIn(str(kwarg), repr(closure))
def setUp(self):
self.arg = 'arg'
self.kwarg = 'kwarg'
self.closure = Closure(self.function, self.arg, kwarg=self.kwarg)
self.action = Call(closure=self.closure)