def test_watch_not_needed(self): """ :return: """ support.create_project(self, 'betty') support.add_step(self) project = cd.project.internal_project project.current_step = project.steps[0] self.assertFalse( reloading.refresh(mime_text), Message('Should not reload if the step has not been run before') ) support.run_command('run') project.current_step = project.steps[0] self.assertFalse( reloading.refresh(mime_text), Message('Should not reload if module has not changed recently') ) project.current_step = None support.run_command('close')
def test_print_start(self): """ should properly print at the beginning of a step """ response = support.create_project(self, 'chicago') self.assertFalse( response.failed, Message('should have created project', response=response) ) print_string = string.ascii_lowercase code = '\n'.join([ 'import cauldron as cd', 'print("{}")'.format(print_string), 'cd.display.text("Hello World")' ]) support.add_step(self, contents=code) response = support.run_command('run -f') self.assertFalse( response.failed, Message('should have run step', response=response) ) project = cauldron.project.get_internal_project() dom = project.steps[0].dom # type: str self.assertEqual( dom.count(print_string), 2, 'should have printed ascii lowercase' )
def test_standard_error(self): """ should include standard error output """ response = support.create_project(self, 'bozeman') self.assertFalse( response.failed, Message('should have created project', response=response)) error_string = 'This is a standard error test' code = '\n'.join( ['import sys', 'sys.stderr.write("{}")'.format(error_string)]) support.add_step(self, contents=code) response = support.run_command('run -f') self.assertFalse(response.failed, Message('should have run step', response=response)) project = cauldron.project.get_internal_project() self.assertTrue(project.steps[0].dom.find(error_string) > 0, 'should have included error string') self.assertTrue(project.steps[0].dom.find('cd-StdErr') > 0, 'should have included StdErr dom')
def assert_has_error_code(self, response, code: str): """ :param response: :param code: :return: """ self.assertTrue( response.failed, Message('Did not Fail', 'Response should have failed if expecting an error', response=response)) self.assertGreater( len(response.errors), 0, Message('No Errors Found', 'There should have been an error in the response', response=response)) codes = [error.code for error in response.errors] self.assertIn( code, codes, Message('Error Code Not Found', 'The error code "{}" was not found in the response errors', response=response))
def test_solo_error(self): """ should display an error """ response = support.create_project(self, 'bismark') self.assertFalse( response.failed, Message('should have created project', response=response)) code = 'x = 1 + "abcdefg"' support.add_step(self, contents=code) response = support.run_command('run -f') self.assertTrue(response.failed, Message('should have failed', response=response)) project = cauldron.project.internal_project self.assertTrue(project.steps[0].dom.find('cd-CodeError') > 0, 'should have included error dom') self.assertTrue(project.steps[0].dom.find('abcdefg') > 0, 'should have included error line of code') support.run_command('close')
def test_print_solo(self): """ should properly print in a step that does nothing but print """ response = support.create_project(self, 'minneapolis') self.assertFalse( response.failed, Message('should have created project', response=response) ) print_string = string.ascii_lowercase code = '\n'.join([ 'values = [x ** 2 for x in range(100)]', 'print("{}")'.format(print_string) ]) support.add_step(self, contents=code) response = support.run_command('run -f') self.assertFalse( response.failed, Message('should have run step', response=response) ) project = cauldron.project.get_internal_project() dom = project.steps[0].dom # type: str self.assertEqual( dom.count(print_string), 2, 'should have printed ascii lowercase' )
def test_print_multiple(self): """ should properly print multiple times within a step """ response = support.create_project(self, 'omaha') self.assertFalse( response.failed, Message('should have created project', response=response)) code = '\n'.join([ 'import cauldron as cd', 'import string', 'print(string.ascii_lowercase)', 'cd.display.text("Hello World")', 'print(string.ascii_uppercase)', 'print(string.hexdigits)' ]) support.add_step(self, contents=code) response = support.run_command('run -f') self.assertFalse(response.failed, Message('should have run step', response=response)) project = cauldron.project.internal_project dom = project.steps[0].dom # type: str self.assertEqual(dom.count(string.ascii_lowercase), 1, 'should have printed ascii lowercase') self.assertEqual(dom.count(string.ascii_uppercase), 1, 'should have printed ascii uppercase') self.assertEqual(dom.count(string.hexdigits), 1, 'should have printed hex digits') support.run_command('close')
def test_modify_move(self): """ :return: """ support.create_project(self, 'harvey') support.add_step(self, contents='#S1') support.add_step(self, contents='#S2') r = support.run_command('steps list') step = r.data['steps'][-1] r = support.run_command( 'steps modify {} --position=0'.format(step['name']) ) self.assertFalse(r.failed, Message( 'Failed to move step 2 to the beginning', response=r )) r = support.run_command('steps list') step = r.data['steps'][0] with open(step['source_path'], 'r') as f: contents = f.read() self.assertEqual(contents.strip(), '#S2', Message( 'Step 2 should now be Step 1', response=r )) support.run_command('close')
def test_steps_modify(self): """ """ response = support.create_project(self, 'lindsey') self.assertFalse( response.failed, Message( 'should not have failed to create project', response=response ) ) project = cauldron.project.internal_project directory = project.source_directory r = support.run_command('steps add first.py') self.assertFalse(r.failed, 'should not have failed') self.assertTrue(os.path.exists(os.path.join(directory, 'S01-first.py'))) r = support.run_command('steps modify S01-first.py --name="second.py"') self.assertFalse(r.failed, 'should not have failed') self.assertFalse( os.path.exists(os.path.join(directory, 'S01-first.py')) ) self.assertTrue( os.path.exists(os.path.join(directory, 'S01-second.py')) ) support.run_command('close')
def test_slow_printing(self): """Should not repeat print statements during slow running steps""" response = support.create_project(self, 'duluth') self.assertFalse( response.failed, Message('should have created project', response=response) ) code = '\n'.join([ 'import time', 'for letter in "BCFHMNOPRSTUVWX":', ' print("{}AT".format(letter))', ' time.sleep(0.5)' ]) support.add_step(self, contents=code) response = commander.execute('run', '-f') response.thread.join(2) step = cauldron.project.get_internal_project().steps[0] dom = step.dumps() self.assertEqual(dom.count('BAT'), 1, 'first check failed') response.thread.join(1) dom = step.dumps() self.assertEqual(dom.count('BAT'), 1, 'second check failed') response.thread.join() dom = step.dumps() self.assertEqual(dom.count('BAT'), 1, 'third check failed') self.assertLess(dom.count('SAT'), 2, 'fourth check failed')
def assert_no_errors(self, response: environ.Response): """ asserts that the response object contains no errors """ self.assertEqual( 0, len(response.errors), Message('Errors found', 'should not have had errors', response=response))
def test_watch_not_needed(self): """Don't reload modules that haven't changed.""" support.create_project(self, 'betty') support.add_step(self) project = cd.project.get_internal_project() project.current_step = project.steps[0] self.assertFalse( reloading.refresh(mime_text), Message('Expect no reload if the step has not been run before.')) support.run_command('run') project.current_step = project.steps[0] self.assertFalse( reloading.refresh(mime_text), Message('Expect no reload if module has not changed recently.'))
def test_list_all(self): """ should list configurations """ response = support.run_command('configure --list') self.assertFalse( response.failed, Message('Failed To List Configurations' 'should not have failed', response=response))
def test_purge_all(self): """ should purge current results directory """ response = support.run_command('purge --force --all') self.assertFalse( response.failed, Message('FAILED PURGE ALL', 'should not have failed to purge all in results directory', response=response))
def create_project( tester: scaffolds.ResultsTest, name: str, path: str = None, forget: bool = True, confirm: bool = True, remote_connection: cli.CommandContext = None, **kwargs ) -> 'environ.Response': """ :param tester: :param name: :param path: :param forget: :param confirm: :param remote_connection: :param kwargs: :return: """ version = ''.join(['{}'.format(s) for s in sys.version_info]) if path is None: path = tester.get_temp_path('project-{}-{}-'.format(name, version)) args = [name, path] for key, value in kwargs.items(): args.append('--{}="{}"'.format(key, value)) if forget: args.append('--forget') args = ' '.join([a for a in args if a and len(a) > 0]) r = commander.execute('create', args, remote_connection=remote_connection) if r.thread: r.thread.join() # Prevent threading race conditions check_count = 0 while confirm and r.success and not cauldron.project.internal_project: if check_count > 100: break check_count += 1 time.sleep(0.25) if confirm: tester.assertFalse(r.failed, Message( 'support.create_project', ['project should have been created'], response=r )) tester.assertIsNotNone(cauldron.project.internal_project) return r
def test_watch_bad_argument(self): """ :return: """ self.assertFalse( reloading.refresh(datetime, force=True), Message('Should not reload not a module') )
def test_watch_recursive(self): """ :return: """ self.assertTrue( reloading.refresh('email', recursive=True, force=True), Message('Should reload the email module') )
def test_watch_good_argument(self): """ :return: """ self.assertTrue( reloading.refresh('datetime', force=True), Message('Should reload the datetime module') )
def assert_has_success_code(self, response, code: str): """ :param response: :param code: """ self.assertGreater( len(response.messages), 0, Message('No Messages Found', 'There should have been a message in the response', response=response)) codes = [message.code for message in response.messages] self.assertIn( code, codes, Message('Notification Code Not Found', 'The code "{}" was not found in the response messages', response=response))
def test_snapshot_fail(self): """ """ support.run_command('close') r = support.run_command('snapshot add fake --no-show') self.assertTrue(r.failed, Message( 'should have failed with no project', response=r ))
def test_snapshot_open(self): """ """ r = support.create_project(self, 'gerald') self.assertFalse(r.failed) self.assertIsNotNone(cauldron.project.internal_project) r = support.run_command('snapshot add fake --no-show') self.assertFalse(r.failed, Message( 'should have created snapshot', response=r )) r = support.run_command('snapshot open fake --no-show') self.assertFalse(r.failed, Message( 'should have opened snapshot', response=r )) support.run_command('close')
def test_snapshot_no_command(self): """ """ support.create_project(self, 'ted') r = support.run_command('snapshot') self.assertTrue(r.failed, Message( 'Should fail if there is no command action', response=r )) support.run_command('close')
def run_project(self, project_id: str, project_directory: str): directory = self.get_temp_path(project_id) result = run_project(project_directory, directory) self.assertFalse( result.response.failed, Message('Failed to run project', response=result.response)) self.assertTrue(os.path.exists(result.results_directory)) self.assertTrue( os.path.exists( os.path.join(result.results_directory, 'display.html'))) self.assertTrue(os.path.exists(result.logging_path)) self.assertTrue(os.path.getsize(result.logging_path) > 0) self.assertTrue(os.path.exists(result.reader_path))
def test_steps_list(self): """Should list steps""" support.create_project(self, 'angelica') r = support.run_command('steps list') self.assertEqual( len(r.data['steps']), 0, Message('New project should have no steps to list', response=r)) for v in ['a.py', 'b.md', 'c.html', 'd.rst']: r = support.run_command('steps add "{}"'.format(v)) self.assertFalse(r.failed, 'should not have failed') r = support.run_command('steps list') self.assertFalse(r.failed, 'should not have failed')
def test_remote(self): """Should function remotely""" support.create_project(self, 'nails') project = cauldron.project.get_internal_project() support.run_remote_command('open "{}" --forget'.format( project.source_directory)) project = cauldron.project.get_internal_project() added_response = support.run_remote_command('steps add') self.assertTrue(added_response.success, Message('Add Step Failed', response=added_response)) self.assertEqual(len(project.steps), 1)
def run_project(self, project_id: str, project_directory: str): directory = self.get_temp_path(project_id) output_directory = os.path.join(directory, 'test', 'results') logging_path = os.path.join(directory, 'logging', 'test.log') response = cauldron.run_project(project_directory=project_directory, output_directory=output_directory, logging_path=logging_path) self.assertFalse(response.failed, Message('Failed to run project', response=response)) self.assertTrue(os.path.exists(output_directory)) self.assertTrue( os.path.exists(os.path.join(output_directory, 'display.html'))) self.assertTrue(os.path.exists(logging_path)) self.assertTrue(os.path.getsize(logging_path) > 0)
def test_snapshot_remove_all(self): """ """ support.create_project(self, 'veronica') support.run_command('snapshot add first --no-show') support.run_command('snapshot add second --no-show') patch_target = 'cauldron.cli.commands.snapshot.actions.query.confirm' with patch(patch_target, return_value=True): r = support.run_command('snapshot remove') self.assertFalse(r.failed, Message( 'should have removed all snapshots', response=r )) support.run_command('close')
def test_failed_step_changes(self, get_running_step_changes): """ should fail if unable to get changes for the running step """ get_running_step_changes.side_effect = ValueError('Fake Error') active_response = self.activate_execution('failed-step-changes') run_status = self.get('/run-status/{}'.format( active_response.identifier)) self.assertEqual(run_status.flask.status_code, 200) response = run_status.response self.assertFalse(response.failed, Message('Failed Response', response=response)) self.assertEqual(response.data['run_status'], 'running') self.assertIsNone(response.data['step_changes']) self.deactivate_execution(active_response.identifier)
def test_not_running(self): """ should succeed even if the step is no longer running """ active_response = self.activate_execution('no-step-running', False) run_status = self.get('/run-status/{}'.format( active_response.identifier)) self.assertEqual(run_status.flask.status_code, 200) response = run_status.response self.assertFalse(response.failed, Message('Response Failed', response=response)) self.assertEqual(response.data['run_status'], 'complete') self.assertNotIn(active_response.identifier, server_runner.active_execution_responses) self.deactivate_execution(active_response.identifier)
def test_watch_recursive(self): """Should reload the email module.""" self.assertTrue(reloading.refresh('email', recursive=True, force=True), Message('Expected email module to be reloaded.'))