class FlowWithCommon(MockSubFlow):
common = {parameter1_name: "common_value"}
blocks = (create_reader_block(inject_name=parameter1_name,
inject_value="common_value",
default="default_value"),
create_reader_block(inject_name=parameter2_name,
inject_value="params_value",
default="default_value").params(
**{parameter2_name: "params_value"}))
def test_parameters_priority(self):
"""Test priorities behavior of the common object and parameters.
* Values passed from the parent are always stronger.
* In the same level - parameterizing block is higher priority.
* In the same level - Common values are the weakest.
"""
parameter1_name = 'field1'
parameter1_topflow_value = 'value_good'
parameter1_subflow_value = 'value_bad1'
parameter1_common_value = 'value_bad2'
parameter2_name = 'field2'
parameter2_subflow_value = 'value_good'
parameter2_common_value = 'value_bad1'
CheckingParameter1Block = create_reader_block(
inject_name=parameter1_name,
inject_value=parameter1_subflow_value)
CheckingParameter2Block = create_reader_block(
inject_name=parameter2_name,
inject_value=parameter2_subflow_value)
class SubFlow(MockSubFlow):
common = {parameter1_name: parameter1_common_value,
parameter2_name: parameter2_common_value}
blocks = (CheckingParameter1Block.parametrize(
**{parameter1_name: parameter1_subflow_value}),
CheckingParameter2Block.parametrize(
**{parameter2_name: parameter2_subflow_value}))
class MainFlow(MockFlow):
blocks = (SubFlow.parametrize(
**{parameter1_name: parameter1_topflow_value}),)
test_flow = MainFlow()
self.run_test(test_flow)
self.assertTrue(self.result.wasSuccessful(),
'Flow failed when it should have succeeded')
self.assertEqual(self.result.testsRun, 1,
"Result didn't run the correct number of tests")
class FlowWithCommon(MockFlow):
common = {'pipe_target': PipeTo('wrong_field')}
blocks = (create_writer_block(inject_name='wrong_field',
inject_value='wrong_value').params(
wrong_field='wrong_value'), # To pass input validation
create_writer_block(inject_name='some_name',
inject_value='some_value'),
create_reader_block(inject_name='pipe_target',
inject_value='some_value').params(
pipe_target='some_value'))
def test_inputs_static_check(self):
"""Test static check of inputs validation of blocks.
Run a flow with a block that expects an input it doesn't get,
then expect it to have an error.
"""
MockFlow.blocks = (create_reader_block(inject_name="missing_input",
inject_value=5),)
with self.assertRaises(AttributeError):
MockFlow()
def test_input_default_value(self):
"""Test that blocks' inputs' default value is injected by default."""
MockFlow.blocks = (create_reader_block(inject_value='default_value',
default='default_value'),)
test_flow = MockFlow()
self.run_test(test_flow)
self.assertTrue(self.result.wasSuccessful(),
'Flow failed when it should have succeeded')
self.validate_blocks(test_flow, successes=1)
def test_shared_data_priority(self):
"""Test that shared data has higher priority than default values."""
MockFlow.blocks = (create_writer_block(inject_value='some_value'),
create_reader_block(inject_value='some_value',
default='default_value'))
test_flow = MockFlow()
self.run_test(test_flow)
self.assertTrue(self.result.wasSuccessful(),
'Flow failed when it should have succeeded')
self.validate_blocks(test_flow, successes=2)
def test_pipes_happy_flow(self):
"""Validate parametrize behavior when using pipes."""
MockFlow.blocks = (
create_writer_block(inject_name='some_name'),
create_reader_block(inject_name='pipe_target').params(
pipe_target=PipeTo('some_name')))
test_flow = MockFlow()
self.run_test(test_flow)
self.assertTrue(self.result.wasSuccessful(),
'Flow failed when it should have succeeded')
self.validate_blocks(test_flow, successes=2)
def test_optional_inputs_static_check(self):
"""Test static check of optional inputs validation of blocks.
Run a flow with a block that has an optional input,
then expect it to succeed.
"""
MockFlow.blocks = (create_reader_block(inject_name="missing_input",
inject_value=4,
default=5),)
test_flow = MockFlow()
self.run_test(test_flow)
self.assertFalse(self.result.wasSuccessful(),
'Flow succeeded when it should have failed')
self.validate_blocks(test_flow, failures=1)
def test_inputs_happy_flow(self):
"""Test behavior of inputs validation of blocks in positive case.
* The flow locks a resource.
* It's first block shares a value.
* The second block validates it has both the result and the shared
value using the 'inputs' field.
"""
MockFlow.blocks = (create_writer_block(inject_value='some_value'),
create_reader_block(inject_value='some_value'))
test_flow = MockFlow()
self.run_test(test_flow)
self.assertTrue(self.result.wasSuccessful(),
'Flow failed when it should have succeeded')
self.validate_blocks(test_flow, successes=2)
def test_common(self):
"""Check that test-flows' initial common data is injected at start."""
parameter_value = 'some_value2'
parameter_name = 'some_parameter2'
class FlowWithCommon(MockFlow):
common = {parameter_name: parameter_value}
FlowWithCommon.blocks = (create_reader_block(
inject_name=parameter_name, inject_value=parameter_value), )
test_flow = FlowWithCommon()
self.run_test(test_flow)
self.assertTrue(self.result.wasSuccessful(),
'Flow failed when it should have succeeded')
self.validate_blocks(test_flow, successes=1)
def test_inputs_check(self):
"""Test runtime validation of inputs of blocks.
Run a flow with a block that pretends to share data and a block that
needs this data as an input.
"""
class PretendToShareDataBlock(SuccessBlock):
pretend_output = BlockOutput()
MockFlow.blocks = (PretendToShareDataBlock,
create_reader_block(inject_name='pretend_output').
params(mode=MODE_FINALLY))
test_flow = MockFlow()
self.run_test(test_flow)
self.assertFalse(self.result.wasSuccessful(),
'Flow succeeded when it should have failed')
self.validate_blocks(test_flow, successes=1, failures=1)
def test_pipes_in_common(self):
"""Validate parametrize behavior when using pipes in common."""
ReadingBlock = create_reader_block(inject_name='pipe_target',
inject_value=5)
# The params is just so the input validation can find the piped field
WritingBlock = create_writer_block(inject_name='some_name',
inject_value=5).params(some_name=3)
class FlowWithCommon(MockFlow):
common = {'pipe_target': PipeTo('some_name')}
blocks = (WritingBlock, ReadingBlock)
test_flow = FlowWithCommon()
self.run_test(test_flow)
self.assertTrue(self.result.wasSuccessful(),
'Flow failed when it should have succeeded')
self.validate_blocks(test_flow, successes=2)
def test_setup_flow(self):
"""Check that test-flows' setUp method is called before the blocks."""
parameter_value = 'some_value'
parameter_name = 'some_parameter'
class FlowWithSetup(MockFlow):
def setUp(self):
self.share_data(**{parameter_name: parameter_value})
FlowWithSetup.blocks = (create_reader_block(
inject_name=parameter_name,
inject_value=parameter_value,
default='wrong_value'),)
test_flow = FlowWithSetup()
self.run_test(test_flow)
self.assertTrue(self.result.wasSuccessful(),
'Flow failed when it should have succeeded')
self.validate_blocks(test_flow, successes=1)
def test_parametrize(self):
"""Validate parametrize behavior.
* Checks that passing values via parametrize passes the 'inputs' check.
* Checks that the values set via parametrize are correct.
* Checks that passing values via parametrize is local to the block.
"""
parameter_value = 'some_value'
parameter_name = 'some_parameter'
parameters = {parameter_name: parameter_value}
MockFlow.blocks = (create_reader_block(
inject_name=parameter_name,
inject_value=parameter_value).params(**parameters),)
test_flow = MockFlow()
self.run_test(test_flow)
self.assertTrue(self.result.wasSuccessful(),
'Flow failed when it should have succeeded')
self.validate_blocks(test_flow, successes=1)
class FlowWithCommon(MockFlow):
common = {'pipe_target': 'wrong_value'}
blocks = (create_writer_block(inject_name='some_name'),
create_reader_block(inject_name='pipe_target').params(
pipe_target=PipeTo('some_name')))
