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')))