def test_get_file(sound):
client = _new_sound_file_client()
client.url.sounds(sound['name']).files('ivr').put(
content='ivr_slin_fr_FR', query_string={'format': 'slin', 'language': 'fr_FR'}
).assert_updated()
client.url.sounds(sound['name']).files('ivr').put(
content='ivr_ogg_fr_FR', query_string={'format': 'ogg', 'language': 'fr_FR'}
).assert_updated()
client.url.sounds(sound['name']).files('ivr').put(
content='ivr_ogg_fr_CA', query_string={'format': 'ogg', 'language': 'fr_CA'}
).assert_updated()
response = confd.sounds(sound['name']).files('ivr').get(format='ogg')
assert_that(response.raw, any_of('ivr_ogg_fr_FR', 'ivr_ogg_fr_CA'))
response.assert_content_disposition('ivr.ogg')
response = (
confd.sounds(sound['name']).files('ivr').get(format='ogg', language='fr_FR')
)
assert_that(response.raw, equal_to('ivr_ogg_fr_FR'))
response.assert_content_disposition('ivr.ogg')
response = confd.sounds(sound['name']).files('ivr').get(language='fr_FR')
assert_that(response.raw, any_of('ivr_ogg_fr_FR', 'ivr_slin_fr_FR'))
response = (
confd.sounds(sound['name'])
.files('ivr')
.get(wazo_tenant=MAIN_TENANT, format='slin', language='fr_FR')
)
assert_that(response.raw, equal_to('ivr_slin_fr_FR'))
response.assert_content_disposition('ivr.wav')
def test_get_file_system():
asterisk_sound.create_directory('fr_FR')
asterisk_sound.create_directory('fr_CA')
asterisk_sound.create_file('fr_FR/asterisk-sound.ogg',
content='asterisk_sound_ogg_fr_FR')
asterisk_sound.create_file('fr_FR/asterisk-sound.wav',
content='asterisk_sound_slin_fr_FR')
asterisk_sound.create_file('fr_CA/asterisk-sound.ogg',
content='asterisk_sound_ogg_fr_CA')
sound = {
'id':
'asterisk-sound',
'formats': [
{
'language': 'fr_FR',
'format': 'slin'
},
{
'language': 'fr_FR',
'format': 'ogg'
},
{
'language': 'fr_CA',
'format': 'ogg'
},
],
'text':
'Asterisk Sound test',
}
ari.set_sound(sound)
response = confd.sounds('system').files(sound['id']).get(format='ogg')
assert_that(response.raw,
any_of('asterisk_sound_ogg_fr_FR', 'asterisk_sound_ogg_fr_CA'))
response.assert_content_disposition('asterisk-sound.ogg')
response = (confd.sounds('system').files(sound['id']).get(
format='ogg', language='fr_FR'))
assert_that(response.raw, any_of('asterisk_sound_ogg_fr_FR'))
response.assert_content_disposition('asterisk-sound.ogg')
response = confd.sounds('system').files(sound['id']).get(language='fr_FR')
assert_that(
response.raw,
any_of('asterisk_sound_ogg_fr_FR', 'asterisk_sound_slin_fr_FR'))
response = (confd.sounds('system').files(sound['id']).get(
format='slin', language='fr_FR'))
assert_that(response.raw, any_of('asterisk_sound_slin_fr_FR'))
response.assert_content_disposition('asterisk-sound.wav')
ari.reset()
def DebugInfo_test(app):
request_data = BuildRequest(filetype='rust')
assert_that(
app.post_json('/debug_info', request_data).json,
has_entry(
'completer',
has_entries({
'name':
'Rust',
'servers':
contains(
has_entries({
'name':
'Racerd',
'is_running':
instance_of(bool),
'executable':
instance_of(str),
'pid':
instance_of(int),
'address':
instance_of(str),
'port':
instance_of(int),
'logfiles':
contains(instance_of(str), instance_of(str))
})),
'items':
contains(
has_entries({
'key': 'Rust sources',
'value': any_of(none(), instance_of(str))
}))
})))
def MiscHandlers_DebugInfo_ExtraConfLoaded_test(app):
filepath = PathToTestFile('extra_conf', 'project', '.ycm_extra_conf.py')
app.post_json('/load_extra_conf_file', {'filepath': filepath})
request_data = BuildRequest(filepath=filepath)
assert_that(
app.post_json('/debug_info', request_data).json,
has_entries({
'python':
has_entries({
'executable': instance_of(str),
'version': instance_of(str),
}),
'clang':
has_entries({
'has_support': instance_of(bool),
'version': any_of(None, instance_of(str))
}),
'extra_conf':
has_entries({
'path': instance_of(str),
'is_loaded': True
}),
'completer':
None
}))
def test_that_empty_fields_are_not_valid(self):
username, password, email_address = 'foobar', 'b3h01D', '*****@*****.**'
valid_body = {
'username': username,
'password': password,
'email_address': email_address,
}
for field in ['username', 'password', 'email_address']:
body = dict(valid_body)
body[field] = ''
result = self.app.post(self.url, json=body)
assert_that(result.status_code, equal_to(400), field)
assert_that(
result.json,
has_entries(
'error_id',
'invalid-data',
'resource',
'users',
'details',
has_entries(
field, has_entries('constraint_id', any_of('length', 'type'))
),
),
field,
)
def test_given_id_when_get_cdr_by_id_csv_then_get_cdr_by_id_csv(self):
result_raw = self.call_logd.cdr.get_by_id_csv(12)
result = list(csv.DictReader(StringIO(result_raw)))[0]
assert_that(
result,
has_entries(
id='12',
tenant_uuid=MASTER_TENANT,
answered='True',
start='2017-03-23T00:00:00+00:00',
answer='2017-03-23T00:01:00+00:00',
end='2017-03-23T00:02:27+00:00',
destination_extension='3378',
destination_name='dést,ination',
destination_internal_extension='3245',
destination_internal_context='internal',
duration='87',
requested_name='réques,ted',
requested_extension='3958',
requested_internal_extension='3490',
requested_internal_context='internal',
call_direction='internal',
source_extension='7687',
source_name='soùr.',
source_internal_extension='5938',
source_internal_context='internal',
source_user_uuid=USER_1_UUID,
tags=any_of('rh;Poudlard', 'Poudlard;rh'),
),
)
def DebugInfo_TypeScriptCompleter_test(app):
request_data = BuildRequest(filetype='javascript')
assert_that(
app.post_json('/debug_info', request_data).json,
has_entry(
'completer',
has_entries({
'name':
'TypeScript',
'servers':
contains_exactly(
has_entries({
'name':
'TSServer',
'is_running':
True,
'executable':
instance_of(str),
'pid':
instance_of(int),
'address':
None,
'port':
None,
'logfiles':
contains_exactly(instance_of(str)),
'extras':
contains_exactly(
has_entries({
'key': 'version',
'value': any_of(None, instance_of(str))
}))
}))
})))
def GetCompletions_MaxDetailedCompletion_test( app ):
RunTest( app, {
'expect': {
'data': has_entries( {
'completions': all_of(
contains_inanyorder(
CompletionEntryMatcher( 'methodA' ),
CompletionEntryMatcher( 'methodB' ),
CompletionEntryMatcher( 'methodC' ),
),
is_not( any_of(
has_item(
CompletionEntryMatcher( 'methodA', extra_params = {
'menu_text': 'methodA (method) Foo.methodA(): void' } ) ),
has_item(
CompletionEntryMatcher( 'methodB', extra_params = {
'menu_text': 'methodB (method) Foo.methodB(): void' } ) ),
has_item(
CompletionEntryMatcher( 'methodC', extra_params = {
'menu_text': ( 'methodC (method) Foo.methodC(a: '
'{ foo: string; bar: number; }): void' ) } ) )
) )
)
} )
}
} )
def has_test_case(name, *matchers):
return has_property(
'test_cases',
has_item(
all_of(
any_of(has_entry('fullName', ends_with(name)),
has_entry('name', starts_with(name))), *matchers)))
def check_volume_status(self,
volume,
statuses,
transit_statuses=(),
timeout=0):
"""Check step volume status.
Args:
volume (object|str): cinder volume to check status or its id
statuses (list): list of statuses to check
transit_statuses (tuple): possible volume transitional statuses
timeout (int): seconds to wait a result of check
Raises:
TimeoutExpired|AssertionError: if check failed after timeout
"""
transit_matchers = [
equal_to_ignoring_case(status) for status in transit_statuses
]
if not hasattr(volume, 'id'):
volume = self.get_volume_by_id(volume)
def _check_volume_status():
volume.get()
return waiter.expect_that(volume.status,
is_not(any_of(*transit_matchers)))
waiter.wait(_check_volume_status, timeout_seconds=timeout)
matchers = [equal_to_ignoring_case(status) for status in statuses]
assert_that(volume.status, any_of(*matchers))
def test_dict_to_filter_unity_resource(self):
ret = UnityClient.dict_to_filter_string({
'a': 1,
'b': UnityLun(_id='lun_1')
})
assert_that(
ret, any_of('a eq 1 and b eq "lun_1"', 'b eq "lun_1" and a eq 1'))
def test_should_return_shortest_distances_and_predecessors_for_equally_weighted_graph_with_many_paths(
self):
dg = nx.DiGraph()
dg.add_weighted_edges_from([(0, 1, 1), (0, 2, 1), (1, 3, 1),
(2, 3, 1)])
distances, predecessors = dijkstra(graph=graph.Graph(dg),
source_node=0,
distance_struct=self.struct)
assert_that(distances, has_length(4))
assert_that(distances, has_entries({0: 0, 1: 1, 2: 1, 3: 2}))
assert_that(predecessors, has_length(3))
assert_that(
predecessors,
any_of(has_entries({
1: 0,
2: 0,
3: 2
}), has_entries({
1: 0,
2: 0,
3: 1
})))
def test_select_by_testcase_id_test(ids, expected_tests, allured_testdir):
"""
>>> import allure
>>> @allure.id("1")
... def test_number_one():
... pass
>>> @allure.id("2")
... def test_number_two():
... pass
>>> @allure.id("3")
... @allure.id("3+")
... def test_number_three():
... pass
>>> def test_without_number():
... pass
"""
allured_testdir.parse_docstring_source()
if ids:
py_path = allured_testdir.testdir.makefile(".json", json.dumps(ids))
os.environ["AS_TESTPLAN_PATH"] = py_path.strpath
else:
del os.environ["AS_TESTPLAN_PATH"]
allured_testdir.run_with_allure()
test_cases = [test_case["fullName"] for test_case in allured_testdir.allure_report.test_cases]
assert_that(test_cases, only_contains(
any_of(
*[ends_with(name) for name in expected_tests]
)
))
def test_reverse_when_multi_result(self):
result = self.reverse('1111', 'default', VALID_UUID)
assert_that(
result,
any_of(self.alice_result, self.qwerty_result_1,
self.qwerty_result_2))
def test_given_call_logs_when_list_cdr_in_csv_then_list_cdr_in_csv(self):
result_raw = self.call_logd.cdr.list_csv()
result = list(csv.DictReader(StringIO(result_raw)))
assert_that(
result,
contains_inanyorder(
has_entries(id='12',
answered='True',
start='2017-03-23T00:00:00+00:00',
answer='2017-03-23T00:01:00+00:00',
end='2017-03-23T00:02:27+00:00',
destination_extension='3378',
destination_name='dést,ination',
duration='87',
call_direction='internal',
source_extension='7687',
source_name='soùr.',
tags=any_of('rh;Poudlard', 'Poudlard;rh')),
has_entries(id='34',
answered='False',
start='2017-03-23T11:11:11+00:00',
answer='',
end='2017-03-23T11:13:29+00:00',
destination_extension='8733',
destination_name='noitani,tsèd',
duration='',
call_direction='outbound',
source_extension='7867',
source_name='.rùos',
tags='')), 'CSV received: {}'.format(result_raw))
def is_feature(props: dict) -> BaseMatcher:
"""Return matcher for Feature with given feature & properties."""
return has_entries({
"type": "Feature",
"geometry": any_of(None, is_multipoly()),
"properties": has_entries(props),
})
def has_failure(test_name, message=anything()):
return has_property('{}test-cases',
has_property('test-case',
has_item(
has_properties({'name': equal_to(test_name),
'failure': any_of(
has_property('stack-trace', equal_to(message)),
has_property('message', equal_to(message)))}))))
def has_failure(test_name, message=anything()):
return has_property('{}test-cases',
has_property('test-case',
has_item(
has_properties({'name': equal_to(test_name),
'failure': any_of(
has_property('stack-trace', equal_to(message)),
has_property('message', equal_to(message)))}))))
def has_only_n_test_cases(name, num, *matchers):
return has_property(
'test_cases',
ContainsExactly(
num,
all_of(
any_of(has_entry('fullName', ends_with(name)),
has_entry('name', ends_with(name))), *matchers)))
def matcher(self):
"""Return matcher."""
matcher = super().matcher
if self.optional:
matcher = any_of(none(), matcher)
else:
matcher = all_of(not_none(), matcher)
return has_entries(data=matcher)
def _check_snapshot_status():
if hasattr(snapshot, 'id'):
snapshot_id = snapshot.id
else:
snapshot_id = snapshot
status = self.get_snapshot_by_id(snapshot_id).status
return waiter.expect_that(status, any_of(*matchers))
def test_response(self, order_with_item, json, response):
# I use the direct status_code check because the DRF test is just an
# abstraction for checking what the REST Framework returns. If I stop
# using the tool, there will be less rewriting left for me.
# For pytest_drf, we can use the Returns200 mixin to test the response code.
assert response.status_code == HTTPStatus.OK
assert json["count"] == order_with_item.events.count() > 0
assert_that(
json["results"],
only_contains(
has_entries({
"id": instance_of(int),
"event_type": instance_of(str),
"subtype": any_of(instance_of(str), none()),
"user": none(),
"difference": any_of(instance_of(str), none()),
})))
def test_should_execute_work_if_the_solution_list_contains_two_non_dominated_solutions(self):
solution1 = Solution(2, 2)
solution1.variables = [1.0, 2.0]
solution2 = Solution(2, 2)
solution2.variables = [0.0, 3.0]
solution_list = [solution1, solution2]
assert_that(any_of(solution1, solution2), self.selection.execute(solution_list))
def evaluate(self):
""" Converts the current expression into a single matcher, applying
coordination operators to operands according to their binding rules
"""
# Apply Shunting Yard algorithm to convert the infix expression
# into Reverse Polish Notation. Since we have a very limited
# set of operators and binding rules, the implementation becomes
# really simple. The expression is formed of hamcrest matcher instances
# and operators identifiers (ints).
ops = []
rpn = []
for token in self.expr:
if isinstance(token, int):
while len(ops) and token <= ops[-1]:
rpn.append(ops.pop())
ops.append(token)
else:
rpn.append(token)
# Append the remaining operators
while len(ops):
rpn.append(ops.pop())
# Walk the RPN expression to create AllOf/AnyOf matchers
stack = []
for token in rpn:
if isinstance(token, int):
# Handle the NOT case in a special way since it's unary
if token == OPERATOR.NOT:
stack[-1] = IsNot(stack[-1])
continue
# Our operators always need two operands
if len(stack) < 2:
raise RuntimeError('Unable to build a valid expression. Not enough operands available.')
# Check what kind of matcher we need to create
if token == OPERATOR.OR:
matcher = hc.any_of(*stack[-2:])
else: # AND, BUT
matcher = hc.all_of(*stack[-2:])
stack[-2:] = [matcher]
else:
stack.append(token)
if len(stack) != 1:
raise RuntimeError('Unable to build a valid expression. The RPN stack should have just one item.')
matcher = stack.pop()
# If a description has been given include it in the matcher
if self.description:
matcher = hc.described_as(self.description, matcher)
return matcher
def test_removes_contributor_from_chain_of_title():
chain_of_title = make_chain_of_title(
authors_composers=[joel_miller(), john_roney(), contributor("Yoko Ono"), contributor("John Lennon")],
publishers=[effendi_records(), contributor("Effendi Records")])
chain_of_title.update(lyricists=["Joel Miller"], composers=["John Lennon"], publishers=["Effendi Records"])
assert_that(chain_of_title, not_(any_of(has_key("John Roney"), has_key("Yoko Ono"), has_key("Universals"))),
"The chain of title")
def evaluate(self):
""" Converts the current expression into a single matcher, applying
coordination operators to operands according to their binding rules
"""
# Apply Shunting Yard algorithm to convert the infix expression
# into Reverse Polish Notation. Since we have a very limited
# set of operators and binding rules, the implementation becomes
# really simple. The expression is formed of hamcrest matcher instances
# and operators identifiers (ints).
ops = []
rpn = []
for token in self.expr:
if isinstance(token, int):
while len(ops) and token <= ops[-1]:
rpn.append(ops.pop())
ops.append(token)
else:
rpn.append(token)
# Append the remaining operators
while len(ops):
rpn.append(ops.pop())
# Walk the RPN expression to create AllOf/AnyOf matchers
stack = []
for token in rpn:
if isinstance(token, int):
# Handle the NOT case in a special way since it's unary
if token == OPERATOR.NOT:
stack[-1] = IsNot(stack[-1])
continue
# Our operators always need two operands
if len(stack) < 2:
raise RuntimeError('Unable to build a valid expression. Not enough operands available.')
# Check what kind of matcher we need to create
if token == OPERATOR.OR:
matcher = hc.any_of(*stack[-2:])
else: # AND, BUT
matcher = hc.all_of(*stack[-2:])
stack[-2:] = [matcher]
else:
stack.append(token)
if len(stack) != 1:
raise RuntimeError('Unable to build a valid expression. The RPN stack should have just one item.')
matcher = stack.pop()
# If a description has been given include it in the matcher
if self.description:
matcher = hc.described_as(self.description, matcher)
return matcher
def test_hamcrest(self):
# 通过：校验hamcrest.has_item函数的参数是否在前面assert_that的第一个参数中
# assert_that(['a','v','b'],hamcrest.has_item('a'))
# 通过：校验hamcrest.has_items函数的参数是否全部都在前面assert_that的第一个参数中
# assert_that(['a','v','b'],hamcrest.has_items('a','v'))
# 不通过
# assert_that(['a','b','c'], hamcrest.has_items('a','x'))
# 通过
assert_that(['a', 'v'], any_of(['a', 'v'], 'b'))
def test_it_should_search_stations_by_name(self):
query = 'callEaVapiés'
stations = list(self.stations.by_search(query))
assert_that(stations, only_contains(any_of(
has_property('nombre', contains_string('Lavapies')),
has_property('address', contains_string('Lavapies')),
)))
assert_that(stations, has_length(greater_than(0)))
def matcher(self) -> BaseMatcher:
"""Return matcher."""
matcher = self.resource_matcher
if self.many:
matcher = all_of(instance_of(list), only_contains(matcher))
if self.optional:
matcher = any_of(empty(), matcher)
elif self.optional:
matcher = any_of(none(), matcher)
else:
matcher = all_of(not_none(), matcher)
include_matcher = any_of(
not_(has_key("included")),
has_entries(
included=any_of(empty(), only_contains(
*self.included_matchers))),
)
return all_of(has_entries(data=matcher), include_matcher)
def test_find_user_two_users_same_name(self):
firstname = 'Lord'
lastname = 'Sanderson'
user1 = self.add_user(firstname=firstname, lastname=lastname)
user2 = self.add_user(firstname=firstname, lastname=lastname)
result = user_dao.find_user(firstname, lastname)
assert_that(result, has_property('id', any_of(user1.id, user2.id)))
def test_request_current_sessions_user_unauthorized(self):
github_session = GithubSession()
_, headers, _ = github_session.request_api('/user')
assert_that(headers, not_none())
assert_that(headers["Status"], is_(any_of(UNAUTHORIZED, FORBIDDEN)))
if headers["Status"] == UNAUTHORIZED:
assert_that(int(headers[RATE_REMAINING]), is_(greater_than(0)))
if headers["Status"] == FORBIDDEN:
assert_that(int(headers[RATE_REMAINING]), is_(0))
def test_request_github_api_root(self):
github_session = GithubSession()
_, headers, _ = github_session.request_api('/')
assert_that(headers, not_none())
assert_that(headers["Status"], is_(any_of(OK, FORBIDDEN)))
if headers["Status"] == OK:
assert_that(int(headers[RATE_REMAINING]), is_(greater_than(0)))
if headers["Status"] == FORBIDDEN:
assert_that(int(headers[RATE_REMAINING]), is_(0))
def assert_input_has_correct_label_and_value(self, element_id, label, response, value):
assert_that(response.normal_body, contains_string(label))
workbench_input = re.search('<input[^>]* id="{}"[^>]*>'.format(element_id), response.normal_body)
assert_that(workbench_input, not_none(), "input file exists with id of {}".format(element_id))
if value is None or value is "":
assert_that(workbench_input.group(0), any_of(
contains_string('value=""'.format(value)),
is_not(contains_string('value="'))
))
else:
assert_that(workbench_input.group(0), contains_string('value="{}"'.format(value)))
def test_dump_dictionary_target():
ns = Namespace('')
@ns.template('entry', ('@key', '@value'))
def entry(key, value):
return (key, int(value))
entry.serialiser(lambda values, obj: values(*obj))
@ns.template('object', ((AsDict, 'entry'),))
def obj(entries):
return entries
omx = OMX([ns], [['testcase', 'object']])
data = etree.tostring(omx.dump({'foo': 10, 'bar': 7}))
if not isinstance(data, str):
data = data.decode('utf-8')
assert_that(data, any_of(contains_string('<entry key="bar" value="7"/>'),
contains_string('<entry value="7" key="bar"/>')))
assert_that(data, any_of(contains_string('<entry key="foo" value="10"/>'),
contains_string('<entry value="10" key="foo"/>')))
def has_only_n_test_cases(name, num, *matchers):
return has_property('test_cases',
ContainsExactly(num,
all_of(
any_of(
has_entry('fullName', ends_with(name)),
has_entry('name', ends_with(name))
),
*matchers
)
)
)
def has_test_case(name, *matchers):
return has_property('test_cases',
has_item(
all_of(
any_of(
has_entry('fullName', ends_with(name)),
has_entry('name', starts_with(name))
),
*matchers
)
)
)
def test_it_should_search_stations_by_name(self):
query = 'callEaVapiés'
stations = list(self.stations.by_search(query))
assert_that(
stations,
only_contains(
any_of(
has_property('nombre', contains_string('Lavapies')),
has_property('address', contains_string('Lavapies')),
)))
assert_that(stations, has_length(greater_than(0)))
def test_extract_specific_error_id_from_fields_when_field_with_multiple_errors(
self):
fields = {
'name': ['Missing data for required field'
'Not a valid choice']
}
error_ids = ConfdErrorExtractor.extract_specific_error_id_from_fields(
fields)
expected1 = {'name': 'required'}
expected2 = {'name': 'invalid-choice'}
assert_that(error_ids, any_of(expected1, expected2))
def test_select_by_severity_level(allured_testdir, severities, expected_tests):
allured_testdir.parse_docstring_path()
allured_testdir.run_with_allure("--allure-severities",
",".join(severities))
test_cases = [
test_case["fullName"]
for test_case in allured_testdir.allure_report.test_cases
]
assert_that(
test_cases,
only_contains(any_of(*[ends_with(name) for name in expected_tests])))
def test_select_by_bdd_label(allured_testdir, options, expected_tests):
allured_testdir.parse_docstring_path()
params = []
for key in options.keys():
params.append("--allure-{key}".format(key=key))
params.append(",".join(options[key]))
allured_testdir.run_with_allure(*params)
test_cases = [test_case["fullName"] for test_case in allured_testdir.allure_report.test_cases]
assert_that(test_cases, only_contains(
any_of(
*[ends_with(name) for name in expected_tests]
)
))
def MiscHandlers_DebugInfo_NoExtraConfFound_test( app ):
request_data = BuildRequest()
assert_that(
app.post_json( '/debug_info', request_data ).json,
has_entries( {
'python': has_entries( {
'executable': instance_of( str ),
'version': instance_of( str ),
} ),
'clang': has_entries( {
'has_support': instance_of( bool ),
'version': any_of( None, instance_of( str ) )
} ),
'extra_conf': has_entries( {
'path': None,
'is_loaded': False
} ),
'completer': None
} )
)
def DebugInfo_test( app ):
request_data = BuildRequest( filetype = 'typescript' )
assert_that(
app.post_json( '/debug_info', request_data ).json,
has_entry( 'completer', has_entries( {
'name': 'TypeScript',
'servers': contains( has_entries( {
'name': 'TSServer',
'is_running': True,
'executable': instance_of( str ),
'pid': instance_of( int ),
'address': None,
'port': None,
'logfiles': contains( instance_of( str ) ),
'extras': contains( has_entries( {
'key': 'version',
'value': any_of( None, instance_of( str ) )
} ) )
} ) )
} ) )
)
def MiscHandlers_DebugInfo_ExtraConfFoundButNotLoaded_test( app ):
filepath = PathToTestFile( 'extra_conf', 'project', '.ycm_extra_conf.py' )
request_data = BuildRequest( filepath = filepath )
assert_that(
app.post_json( '/debug_info', request_data ).json,
has_entries( {
'python': has_entries( {
'executable': instance_of( str ),
'version': instance_of( str ),
} ),
'clang': has_entries( {
'has_support': instance_of( bool ),
'version': any_of( None, instance_of( str ) )
} ),
'extra_conf': has_entries( {
'path': instance_of( str ),
'is_loaded': False
} ),
'completer': None
} )
)
def DebugInfo_test( app ):
request_data = BuildRequest( filetype = 'rust' )
assert_that(
app.post_json( '/debug_info', request_data ).json,
has_entry( 'completer', has_entries( {
'name': 'Rust',
'servers': contains( has_entries( {
'name': 'Racerd',
'is_running': instance_of( bool ),
'executable': instance_of( str ),
'pid': instance_of( int ),
'address': instance_of( str ),
'port': instance_of( int ),
'logfiles': contains( instance_of( str ),
instance_of( str ) )
} ) ),
'items': contains( has_entries( {
'key': 'Rust sources',
'value': any_of( none(), instance_of( str ) )
} ) )
} ) )
)
def test_ends_like_composite():
assert_that('hello', any_of(ends_like('bella'), ends_like('chello')))
def test_dict_to_filter_string_normal(self):
ret = UnityClient.dict_to_filter_string({'a': 1, 'b': 'c'})
assert_that(ret, any_of('a eq 1 and b eq "c"', 'b eq "c" and a eq 1'))
def __init__(self, *element_matchers):
delegates = [hc.has_item(e) for e in element_matchers]
self.matcher_all = hc.all_of(*delegates)
self.matcher_any = hc.any_of(*delegates)
self.matcher_order = hc.contains(*element_matchers)
self.order_seq = None
def test_site_sync(self):
for site in _SITES:
assert_that(_find_site_components((site.__name__,)),
is_(not_none()))
with mock_db_trans() as conn:
for site in _SITES:
assert_that(_find_site_components((site.__name__,)),
is_(not_none()))
ds = conn.root()['nti.dataserver']
assert ds is not None
sites = ds['++etc++hostsites']
for site in _SITES:
assert_that(sites, does_not(has_key(site.__name__)))
synchronize_host_policies()
synchronize_host_policies()
assert_that(self._events, has_length(len(_SITES)))
# These were put in in order
# assert_that( self._events[0][0].__parent__,
# has_property('__name__', EVAL.__name__))
# XXX These two lines are cover only.
get_host_site(DEMO.__name__)
get_host_site('DNE', True)
assert_that(calling(get_host_site).with_args('dne'),
raises(LookupError))
with mock_db_trans() as conn:
for site in _SITES:
assert_that(_find_site_components((site.__name__,)),
is_(not_none()))
ds = conn.root()['nti.dataserver']
assert ds is not None
sites = ds['++etc++hostsites']
assert_that(sites, has_key(EVAL.__name__))
assert_that(sites[EVAL.__name__], verifiably_provides(ISite))
# If we ask the demoalpha persistent site for an ITestSyteSync,
# it will find us, because it goes to the demo global site
assert_that(sites[DEMOALPHA.__name__].getSiteManager().queryUtility(ITestSiteSync),
is_(ASync))
# However, if we put something in the demo *persistent* site, it
# will find that
sites[DEMO.__name__].getSiteManager().registerUtility(OtherSync())
assert_that(sites[DEMOALPHA.__name__].getSiteManager().queryUtility(ITestSiteSync),
is_(OtherSync))
# Verify the resolution order too
def _name(x):
if x.__name__ == '++etc++site':
return 'P' + str(x.__parent__.__name__)
return x.__name__
assert_that([_name(x) for x in ro.ro(sites[DEMOALPHA.__name__].getSiteManager())],
is_([u'Pdemo-alpha.nextthoughttest.com',
u'demo-alpha.nextthoughttest.com',
u'Pdemo.nextthoughttest.com',
u'demo.nextthoughttest.com',
u'Peval.nextthoughttest.com',
u'eval.nextthoughttest.com',
u'Pdataserver2',
u'PNone',
'base']))
# including if we ask to travers from top to bottom
names = list()
def func():
names.append(_name(component.getSiteManager()))
run_job_in_all_host_sites(func)
# Note that PDemo and Peval-alpha are arbitrary, they both
# descend from eval;
# TODO: why aren't we maintaining alphabetical order?
# we should be, but sometimes we don't
assert_that(names, is_(any_of(
[u'Peval.nextthoughttest.com',
u'Pdemo.nextthoughttest.com',
u'Peval-alpha.nextthoughttest.com',
u'Pdemo-alpha.nextthoughttest.com'],
[u'Peval.nextthoughttest.com',
u'Peval-alpha.nextthoughttest.com',
u'Pdemo.nextthoughttest.com',
u'Pdemo-alpha.nextthoughttest.com'])))
# And that it's what we get back if we ask for it
assert_that(get_site_for_site_names((DEMOALPHA.__name__,)),
is_(same_instance(sites[DEMOALPHA.__name__])))
# No new sites created
assert_that(self._events, has_length(len(_SITES)))
def test_dict_to_filter_list(self):
ret = UnityClient.dict_to_filter_string({'a': [2, 4]})
assert_that(ret, any_of('a eq 2 or a eq 4', 'a eq 4 or a eq 2'))
ret = UnityClient.dict_to_filter_string({'a': ["m", "n"]})
assert_that(ret, any_of('a eq "m" or a eq "n"',
'a eq "n" or a eq "m"'))
def test_dict_to_filter_string_enum_list(self):
levels = [ServiceLevelEnum.SILVER, ServiceLevelEnum.PLATINUM]
ret = UnityClient.dict_to_filter_string({'a': levels})
assert_that(ret, any_of('a eq 2 or a eq 4', 'a eq 4 or a eq 2'))
def _matches(self, item):
return has_property('test_cases',
only_contains(any_of(*self.matchers))
).matches(item)
def test_is_five_or_four():
assert_that(4, any_of(is_four(), is_five()))
def _filter_expected_needles(haystack, needles):
matcher = h.any_of(*_expected_needles(needles))
return [v for v in haystack if matcher.matches(v)]
def _is_five_or_even(item):
assert_that(item, any_of(is_five(), is_even()))
