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)
