def test_can_work_on_with_work_existing_action_instance(self, os): controller = WorkController() controller.app = Mock() controller.app.rapid_config.executor_count = 1 os.listdir.return_value = ['rapid-11-11111'] eq_(False, controller.can_work_on(Mock(action_instance_id=11)))
def test_work_cancel_should_not_cancel_if_action_instance_not_found( self, response, mock_os, store_service): controller = WorkController() store_service.check_for_pidfile.return_value = None controller.work_cancel(12345) eq_(501, response.call_args_list[0][0][1])
def test_prepare_payload(self): handler = RemoteNotificationHandler() eq_({'testing': 'trial'}, handler.prepare_payload({'payload': { 'testing': '{testing}' }}, MagicMock(), MagicMock(), {'testing': 'trial'}))
def test_mark_workflow_instance_complete(self): workflow_instance = WorkflowInstance() InstanceWorkflowEngine._mark_workflow_instance_complete( workflow_instance, StatusConstants.FAILED) eq_(StatusConstants.FAILED, workflow_instance.status_id) ok_(workflow_instance.end_date is not None)
def test_mark_stage_instance_complete(self): stage_instance = StageInstance() InstanceWorkflowEngine._mark_stage_instance_complete( stage_instance, StatusConstants.SUCCESS) eq_(StatusConstants.SUCCESS, stage_instance.status_id) ok_(stage_instance.end_date is not None)
def test_evaluate_condition(self): handler = RemoteNotificationHandler() eq_('2 == 2 and 1 == 1 and 4 == 4', handler._prepare_conditional('pipelineInstance.status_id == 2 and actionInstance.action.id == 1 and actionInstance.status_id == 4', MagicMock(status_id=2), MagicMock(action=MagicMock(id=1), status_id=4)))
def test(self): """ 文章が適切に形態素に分解される """ text = u'吾輩は猫である' expect = [u'吾輩', u'は', u'猫', u'で', u'ある'] tokens = tokenize(text) eq_(tokens, expect)
def test_mark_pipeline_instance_complete(self): pipeline_instance = PipelineInstance() InstanceWorkflowEngine._mark_pipeline_instance_complete( pipeline_instance, StatusConstants.FAILED) eq_(StatusConstants.FAILED, pipeline_instance.status_id) ok_(pipeline_instance.end_date is not None)
def test_get_workable_work_requests_work_request_validation( self, get_db_session): action_dal = ActionDal() session = WrapperHelper() get_db_session.return_value = [session] action_instance = ActionInstance(id=1, pipeline_instance_id=1, workflow_instance_id=1) pipeline_parameters = PipelineParameters(parameter="foo", value="bar") action_instance_config = ActionInstanceConfig() pipeline_parameters_2 = PipelineParameters(parameter="foo2", value="bar2") action_instance_config2 = ActionInstanceConfig() session.results.append( (action_instance, pipeline_parameters, action_instance_config)) session.results.append( (action_instance, pipeline_parameters_2, action_instance_config2)) work_requests = action_dal.get_workable_work_requests() work_request = work_requests[0] eq_(1, len(work_requests)) eq_(1, work_request.action_instance_id) eq_(1, work_request.pipeline_instance_id) eq_(1, work_request.workflow_instance_id) eq_({"foo": "bar", "foo2": "bar2"}, work_request.environment)
def test_no_explicit_urlconf(self): response = make_response_for_request( 'language-list', {'developer': self.developer1.pk}, None, ) eq_(200, response.status_code)
def test_mark_action_instance_complete(self): action_instance = ActionInstance() InstanceWorkflowEngine._mark_action_instance_complete( action_instance, StatusConstants.SUCCESS) eq_(StatusConstants.SUCCESS, action_instance.status_id) ok_(action_instance.end_date is not None)
def test_register_rules(self): app = Mock() controller = WorkController() url_rules = [['/work/request', 'work_request', {'type_is': 'decorated_view', 'name': 'work_request', 'co_filename': '{}'.format(rapid.lib.__file__.replace('.pyc', '.py'))}], ['/work/execute', 'work_execute', {'type_is': 'decorated_view', 'name': 'work_execute', 'co_filename': '{}'.format(rapid.lib.__file__.replace('.pyc', '.py'))}, {'methods': ['POST']}]] registered_rules = {} def set_url(*args, **kwargs): arguments = list(args) if sys.version.startswith('2'): # TODO: Remove after moved to python3 arguments[2] = {'type_is': args[2].func_code.co_name, 'name': args[2].func_name, 'co_filename': args[2].func_code.co_filename} else: arguments[2] = {'type_is': args[2].__code__.co_name, 'name': args[2].__wrapped__.__func__.__name__, 'co_filename': args[2].__code__.co_filename} if kwargs: arguments.append(kwargs) registered_rules[args[0]] = arguments app.add_url_rule = set_url controller.register_url_rules(app) for assertions in url_rules: eq_(registered_rules[assertions[0]], assertions)
def test_work_cancel_should_not_cancel_if_pid_not_found(self, response, mock_os, store_service): controller = WorkController() store_service.check_for_pidfile.return_value = "testing-1-2-3" mock_os.kill.side_effect = Exception("Booo") controller.work_cancel(124545) eq_(501, response.call_args_list[0][0][1])
def test_action_instance_cancels_current_running_clients( self, workflow_engine, db_session, get_action_instance, store_service): """ @rapid-unit Workflow:Cancel Action Instance:Should cancel active client :param db_session: :type db_session: :param get_action_instance: :type get_action_instance: :param store_service: :type store_service: :return: :rtype: """ db_session.return_value = [Mock()] mock_workflow = Mock() workflow_engine.return_value = mock_workflow get_action_instance.return_value = Mock( assigned_to='12345', status_id=StatusConstants.INPROGRESS) setattr(get_action_instance, 'id', '54321') mock_constants = Mock() action_dal = ActionDal(flask_app=Mock(), queue_constants=mock_constants) eq_("Action Instance has been canceled.", action_dal.cancel_action_instance(123455)['message']) mock_workflow.complete_an_action.assert_called_with( 123455, StatusConstants.CANCELED) mock_constants.cancel_worker.assert_called_with( get_action_instance().serialize())
def test_can_work_on_with_work(self, os): controller = WorkController() controller.app = Mock() controller.app.rapid_config.executor_count = 1 os.listdir.return_value = [] eq_(True, controller.can_work_on(Mock(action_instance_id=1111)))
def test_str(self): """ パスからラッパーオブジェクトを作る """ wrapper = FileObjectWrapper("/dev/null") eq_(wrapper.name, "/dev/null") with wrapper.file as f: f.read(1)
def test(self): """ バイト列をユニコード文字列に変換する """ expect = u"吾輩は猫である" binary = expect.encode("utf-8") text = binary2unicode(binary) eq_(text, expect)
def test_parse_default(self): sys.argv = ['rabbitracer'] args = _parse_args() eq_(args.hostname, 'localhost') eq_(args.username, 'guest') eq_(args.password, 'guest') eq_(args.virtualhost, '/') eq_(args.pretty_print, False)
def test_dirichlet_noise_of_mask(): legal_moves = 47289423 bc = bit_count(legal_moves) noise = dirichlet_noise_of_mask(legal_moves, 0.5) assert_almost_equal(1, np.sum(noise)) eq_(bc, np.sum(noise > 0)) ary = bit_to_array(legal_moves, 64) eq_(list(noise), list(noise * ary))
def test_parse_default(self): sys.argv = ['pydevinit'] args = _parse_args() eq_(args.project_name, None) eq_(args.source_path, None) eq_(args.python_type, 'python') eq_(args.python_version, 2.7) eq_(args.python_interpreter, 'Default')
def test(self): ''' 正常系: 構文解析器を使った置換をテストする ''' strategy = TokenReplaceStrategy(u'後で', u'あとで') replaced_text = strategy(u'前後で後で') eq_(replaced_text, u'前後であとで')
def test_check_version_different_versions_is_updating(self, store_service): controller = WorkController() controller.app = Mock() store_service.is_updating.return_value = True eq_( False, controller.check_version( Mock(headers={version.Version.HEADER: "1"})))
def test_build(self): params = { 'command': 'listUsers', 'keyword': 'ad', } builder = SignatureBuilder(self.APIKEY, self.SECRETKEY) signature = builder.build(params) eq_(signature, b'QEq3xbEHhBmSfFw4RwVzkWyQYWc=')
def test_get_headers(self): client = Client(None, None, None, None, 'trial', False) eq_( { 'X-Rapidci-Version': version.__version__, 'Content-Type': 'application/json', 'X-Rapidci-Api-Key': "trial" }, client.get_headers())
def test_success_hit(self): ''' 正常系: 単一の行の中に目当ての文字列が含まれている ''' text = 'ほげほげ。更に、ふがふが' hit_list = list(detect(text)) eq_(hit_list[0].lineno, 1)
def test_success_miss(self): ''' 正常系: 単一の行の中に目当ての文字列が含まれていない ''' text = 'ほげほげ。ふがふが' hit_list = list(detect(text)) eq_(len(hit_list), 0)
def test_call_with(self): evaluator = get_boolean_evaluator( 'age < const:majority & "o" in name & birthdate > "1983-02-02"', self.sample, {'majority': 18}, grammar_tokens={'belongs_to': 'in'} ) for s, expected in zip(self.sample, (False, False, False, True)): eq_(evaluator(s), expected)
def test_ok_currency_usd(self): sys.argv = [ 'mtg', '-c', 'USD', ] args = _parse_args() eq_(args.currency, 'USD') eq_(args.annual_salary, Currencies.salary('USD'))
def test_std(self): """ sys.stdin からラッパーオブジェクトを作る """ wrapper = FileObjectWrapper(sys.stdin) eq_(wrapper.name, "<stdin>") ok_(hasattr(wrapper.file, "read")) with wrapper.file as _: pass
def test_get_status(self): status_dal = Mock() status = Status(id=1, name="Something") status_dal.get_status_by_id.return_value = status workflow_engine = InstanceWorkflowEngine(status_dal, Mock()) eq_(status, workflow_engine._get_status(1)) eq_({1: status}, workflow_engine.status_cache)
def test_success(self): ''' 正常系: 単一の行に目当ての文字列が含まれている ''' text = 'ほげほげ。更に、ふがふが' expect = 'ほげほげ。さらに、ふがふが' result = replace(text) eq_(result, expect)
def test_file(self): """ ファイルオブジェクトからラッパーオブジェクトを作る """ f = open("/dev/null") wrapper = FileObjectWrapper(f) eq_(wrapper.name, "/dev/null") with wrapper.file as f: f.read(1)
def test_miss(self): """ 形態素にもとづいて文章にマッチしない """ query = u'輩' detector = StreamDetector(query) line = u'吾輩は猫である' trove = detector.feed(line) eq_(trove, None)
def test_get_verify_working_verify_join(self, get_db_session): action_dal = ActionDal() session = WrapperHelper() get_db_session.return_value = [session] action_dal.get_verify_working(10) eq_(PipelineInstance, session.join_args[0])
def test_inverse(self): """ マッチしない言葉を探す """ query = u'輩' detector = StreamDetector(query, inverse=True) line = u'吾輩は猫である' trove = detector.feed(line) eq_(trove.line, line)
def test_hit(self): """ 形態素にもとづいて文章にマッチする """ query = u'吾輩' detector = StreamDetector(query) line = u'吾輩は猫である' trove = detector.feed(line) eq_(trove.line, line) eq_(trove.position, 0)
def test_multi_custom_duration_format(self): dv = DurationVariable( 'ctx_name', [r'^((?P<days>\d+?) ?j(ours?)?)?', r'^((?P<days>\d+?) ?d(ías)?)?']) assert_raises(ValueError, dv._from_native_string, "1s") eq_(dv._from_native_string('1j'), datetime.timedelta(days=1)) eq_(dv._from_native_string('1jour'), datetime.timedelta(days=1)) eq_(dv._from_native_string('1jours'), datetime.timedelta(days=1)) eq_(dv._from_native_string('1d'), datetime.timedelta(days=1)) eq_(dv._from_native_string('1días'), datetime.timedelta(days=1))
def test_hit_tokens(self): """ 複数の形態素でも文章にマッチする """ query = u'は猫で' detector = StreamDetector(query) line = u'吾輩は猫である' trove = detector.feed(line) eq_(trove.line, line) eq_(trove.position, 2)
def test_default(self): sys.argv = [ 'mtg', ] args = _parse_args() eq_(args.annual_salary, Currencies.salary(DEFAULT_CURRENCY)) eq_(args.currency, DEFAULT_CURRENCY) eq_(args.hours_worked_per_day, DEFAULT_HOURS_WORKED_PER_DAY) eq_(args.days_worked_per_month, DEFAULT_DAYS_WORKED_PER_MONTH) eq_(args.number_of_participants, DEFAULT_NUMBER_OF_PARTICIPANTS)
def test_check_version_different_versions_is_not_updating( self, store_service, threading): controller = WorkController() controller.app = Mock() store_service.is_updating.return_value = False eq_( False, controller.check_version( Mock(headers={version.Version.HEADER: "1"}))) eq_(1, threading.Thread.call_count)
def test_success_hit_on_2nd_line(self): ''' 正常系: 二行目に目当ての文字列が含まれている ''' text = '''ほげほげ 更に、ふがふが ばずばず ''' hit_list = (list(detect(text))) eq_(hit_list[0].lineno, 2)
def test_load_pipeline(self): action, workflow, stage, pipeline = self._pipeline_helper() workflow_engine = WorkflowEngine(pipeline) loaded_pipeline = workflow_engine._load_pipeline() eq_(pipeline, workflow_engine.pipeline) eq_(pipeline, loaded_pipeline) eq_({1: stage}, workflow_engine.stage_mapper) eq_({1: workflow}, workflow_engine.workflow_mapper) eq_({1: action}, workflow_engine.action_mapper)
def test_send_work(self, requests): client = Client(None, None, None, False) work_request = WorkRequest() client.send_work(work_request) eq_(1, requests.post.call_count) requests.post.assert_called_with(client.get_work_uri(), json=work_request.__dict__, headers=client.get_headers(), verify=True, timeout=4)
def test_pickle(self): """ Pickle 化、非 Pickle 化する """ wrapper = FileObjectWrapper("/dev/null") binary = pickle.dumps(wrapper) restored_object = pickle.loads(binary) eq_(restored_object.name, "/dev/null") with restored_object.file as f: f.read(1)
def test_activate_next_action_all_complete_with_inprogress(self): workflow_engine = InstanceWorkflowEngine(Mock(), Mock()) action_instances = [ ActionInstance(status_id=StatusConstants.SUCCESS, order=0), ActionInstance(status_id=StatusConstants.INPROGRESS, order=1), ActionInstance(status_id=StatusConstants.NEW, order=2) ] workflow_engine._activate_next_action_all_complete(action_instances) eq_(StatusConstants.INPROGRESS, action_instances[1].status_id) eq_(StatusConstants.NEW, action_instances[2].status_id)
def test(self): """ 文字列モードのファイルライクオブジェクトからバイト列を取り出す """ message = u"こんにちは、世界" file_ = io.StringIO(message) wrapper = ByteWrapper(file_) with wrapper as f: data = f.read() expect = message.encode("utf-8") eq_(data, expect)
def test_contains_slash(self): params = { 'command': 'createZone', 'dns1': '203.0.113.1', 'internaldns1': '198.51.100.1', 'name': 'sample-zone', 'networktype': 'Advanced', 'guestcidraddress': '192.0.2.0/24', } builder = SignatureBuilder(self.APIKEY, self.SECRETKEY) signature = builder.build(params) eq_(signature, b'4+XLXpBJuqKH/BVg2WNYRcPFjTY=')
def test_pickle_unicode_file(self): """ 文字列モードで開いたファイルからバイト列を取り出す """ message = u"こんにちは、世界" file_ = io.StringIO(message) byte_wrapper = ByteWrapper(file_) file_wrapper = FileObjectWrapper(byte_wrapper) with file_wrapper.file as f: binary = f.read() expect = message.encode(encoding="utf-8") eq_(expect, binary)
def test_sleep_for_executors_time_out(self, store_service): self.count = [1, 2, 3, 4] def decrease(*args, **kwargs): self.count.pop(0) return self.count store_service.get_executors = decrease WorkController._sleep_for_executors(0, 2) eq_([3, 4], self.count)
def test_convert_to_instance(self, model): model_map = self.mapping[model] additional_kws = model_map['check_fields'] if 'check_fields' in model_map else {} model_instance = model(name='Testing', id=1, **additional_kws) instance_conversion = model_instance.convert_to_instance() ok_(model_map['clz'] == type(instance_conversion)) eq_(1, getattr(instance_conversion, model_map['parent_id'])) if 'check_fields' in model_map: for key, value in model_map['check_fields'].items(): eq_(value, getattr(instance_conversion, key))
def test_handle_selenium_without_colon(self): file = PythonFile(None, None) file.handle_selenium(" @rapid-selenium Area:Feature:Behavior point") eq_( file._current_settings, { file.AREA: 'Area', file.FEATURE: 'Feature', file.BP: 'Behavior point', 'level': 'selenium' })
def test_get_verify_working_verify_results(self, get_db_session): action_dal = ActionDal() session = WrapperHelper() get_db_session.return_value = [session] action_instance = Mock(id=1, pipeline_instance_id=1) session.results.append(action_instance) results = action_dal.get_verify_working(10) eq_([action_instance.serialize()], results)
def test_handle_unit_with_colon(self): file = PythonFile(None, None) file.handle_unit(" @rapid-unit: Area:Feature:Behavior point") eq_( file._current_settings, { file.AREA: 'Area', file.FEATURE: 'Feature', file.BP: 'Behavior point', 'level': 'unit' })
def _assert_permission_granted_to_child_resource_list( self, parent_view_set, child_view_set, user=None, ): response = self._get_response_from_child_resource_list( parent_view_set, child_view_set, user=user, ) eq_(200, response.status_code)
def test_get_json_value(self): mock_config = MagicMock() controller = GithubController(MagicMock(), MagicMock(), mock_config, MagicMock()) eq_( 'something', controller._get_json_value( {'test': { 'trial': { 'value': 'something' } }}, 'test.trial.value'))
def test_template_render(self): testfile = path.join(path.dirname(__file__), 'data/ssh.config') template = path.join(path.dirname(__file__), 'data/inventory_template') expectfile = path.join(path.dirname(__file__), 'data/inventory_expect') with open(expectfile) as fd: expect = ''.join(fd.readlines()) with open(testfile) as fd: lines = fd.readlines() args_mock = namedtuple( 'ArgumentParserMock', ['template_file'] )(template) result = execute(lines, args_mock) eq_(result, expect)
def _assert_permission_denied_to_child_resource_list( self, parent_view_set, child_view_set, url_name=None, urlvars=None, ): response = self._get_response_from_child_resource_list( parent_view_set, child_view_set, url_name, urlvars, ) eq_(403, response.status_code)
def _assert_permission_granted_to_child_resource( self, parent_view_set, child_view_set, url_name=None, environ_items=None, ): response = self._get_response_from_child_resource( parent_view_set, child_view_set, environ_items=environ_items, url_name=url_name, ) eq_(200, response.status_code)
def test_success_multiple_lines(self): ''' 正常系: 複数行に目当ての文字列が含まれている ''' text = '''ほげほげ 更に、ふがふが 更に、ばずばず ''' expect = '''ほげほげ さらに、ふがふが さらに、ばずばず ''' result = replace(text) eq_(result, expect)
def test(self): """ 正常系/異常系: 色々な文字を使って判定する """ eq_(is_kanji(u"あ"), False) eq_(is_kanji(u"亜"), True) eq_(is_kanji(u" "), False) eq_(is_kanji(u"_"), False)