def test_find_all_by(self):
line1 = self.add_line(device='deviceid', provisioningid=123456)
line2 = self.add_line(device='deviceid', provisioningid=234567)
result = line_dao.find_all_by(device='deviceid')
assert_that(result, has_items(has_property('id', line1.id),
has_property('id', line2.id)))
def test_associate_secondary_user_with_line(self):
main_user = self.add_user()
secondary_user = self.add_user()
line = self.add_line()
self.add_user_line(user_id=main_user.id,
line_id=line.id,
extension_id=None,
main_user=True,
main_line=True)
user_line_dao.associate(secondary_user, line)
result = (self.session.query(UserLine)
.filter(UserLine.line_id == line.id)
.all())
assert_that(result, contains_inanyorder(
all_of(has_property('user_id', main_user.id),
has_property('line_id', line.id),
has_property('extension_id', None),
has_property('main_user', True),
has_property('main_line', True)),
all_of(has_property('user_id', secondary_user.id),
has_property('line_id', line.id),
has_property('extension_id', None),
has_property('main_user', False),
has_property('main_line', True))))
def test_it_should_sort_by_field(self):
result = self.filter(sort('id'), (AVAILABLE_STATION, FIRST_STATION))
assert_that(result, contains(
has_property('idestacion', FIRST_STATION['idestacion']),
has_property('idestacion', AVAILABLE_STATION['idestacion'])
))
def test_aq_property(self):
class IBaz(Interface):
pass
class IFoo(Interface):
ob = Object(IBaz)
@implementer(IBaz)
class Baz(object):
pass
class BazAQ(Implicit, Baz):
pass
@implementer(IFoo)
class Foo(Base):
ob = AcquisitionFieldProperty(IFoo['ob'])
assert_that(Foo, has_property('ob', is_(AcquisitionFieldProperty)))
# pylint:disable=blacklisted-name
foo = Foo()
assert_that(foo, has_property('ob', none()))
foo.ob = Baz()
assert_that(foo, has_property('ob', is_not(aq_inContextOf(foo))))
foo.ob = BazAQ()
assert_that(foo, has_property('ob', aq_inContextOf(foo)))
def test_bulk_with_report(self):
results = self.store.bulk(
actions=[
("index", self.kevin),
("delete", self.steph),
],
batch_size=2,
)
assert_that(
self.store.retrieve(self.kevin.id),
all_of(
has_property("id", self.kevin.id),
has_property("first", "Kevin"),
has_property("middle", none()),
has_property("last", "Durant"),
),
)
result = results[0]
# Updated items
assert_that(result[0], is_(equal_to(1)))
# Report on failed to delete items
assert_that(result[1], contains(
has_key('delete'),
))
assert_that(result[1][0]['delete'], has_entry('result', 'not_found'))
def test_unmarshal(self):
event = ConcreteUserCtiProfileConfigEvent.unmarshal(self.msg)
assert_that(event, all_of(
has_property('user_id', USER_ID),
has_property('cti_profile_id', CTI_PROFILE_ID),
has_property('enabled', True)))
def test_unmarshal(self):
event = ConcreteUserVoicemailConfigEvent.unmarshal(self.msg)
assert_that(event, all_of(
has_property('user_id', USER_ID),
has_property('voicemail_id', VOICEMAIL_ID),
has_property('enabled', ENABLED)))
def testProxyHostComps(self):
pers_comps = BaseComponents(BASE, 'persistent', (BASE,))
host_comps = BaseComponents(BASE, 'example.com', (BASE,))
host_sm = HSM('example.com', 'siteman', host_comps, pers_comps)
host_site = MockSite(host_sm)
host_site.__name__ = host_sm.__name__
setSite(host_site)
new_comps = BaseComponents(BASE, 'sub_site', (pers_comps,))
new_site = MockSite(new_comps)
new_site.__name__ = new_comps.__name__
interface.alsoProvides(new_site, IFoo)
threadSiteSubscriber(new_site, None)
cur_site = getSite()
# It should implement the static and dynamic
# ifaces
assert_that(cur_site, validly_provides(IFoo))
assert_that(cur_site, validly_provides(IMock))
# It should have the marker property
assert_that(cur_site.getSiteManager(),
has_property('host_components',
host_comps))
assert_that(ro.ro(cur_site.getSiteManager()),
contains(
# The first entry is synthesized
has_property('__name__', new_comps.__name__),
pers_comps,
# The host comps appear after all the bases
# in the ro of the new site
host_comps,
BASE))
def test_find_last_unprocessed_under_limit(self):
limit = 10
cel_id_1, cel_id_2 = self.add_cel(linkedid='1'), self.add_cel(linkedid='2')
result = cel_dao.find_last_unprocessed(limit)
assert_that(result, contains(has_property('id', cel_id_1),
has_property('id', cel_id_2)))
def test_find_from_linked_id(self):
linked_id = '666'
cel_id_1, cel_id_2, cel_id_3 = self.add_cel(linkedid='666'), self.add_cel(linkedid='3'), self.add_cel(linkedid='666')
result = cel_dao.find_from_linked_id(linked_id)
assert_that(result, contains_inanyorder(has_property('id', cel_id_1),
has_property('id', cel_id_3)))
def has_error(message='', trace='', status=Status.FAILED):
return has_property('{}test-cases',
has_property('test-case',
all_of(has_property('attrib', has_entry('status', status)),
has_property('failure',
has_properties({'message': message,
'stack-trace': has_string(trace)
})))))
def test_find_last_unprocessed_under_limit_exceeding_limit_to_complete_call(self):
limit = 1
cel_id_1, cel_id_2 = self.add_cel(linkedid='1'), self.add_cel(linkedid='1')
result = cel_dao.find_last_unprocessed(limit)
assert_that(result, contains(has_property('id', cel_id_1),
has_property('id', cel_id_2)))
def test_get_by_extension_id_with_line(self):
user_line_row = self.add_user_line_with_exten()
line_extension = dao.get_by_extension_id(user_line_row.extension_id)
assert_that(line_extension, all_of(
has_property('line_id', user_line_row.line_id),
has_property('extension_id', user_line_row.extension_id)))
def test_find(self):
extension_row = self.add_extension(exten='1234', context='default')
result = extension_dao.find(extension_row.id)
assert_that(result, all_of(
has_property('exten', extension_row.exten),
has_property('context', extension_row.context)))
def has_error(message='', trace=''):
return has_property('{}test-cases',
has_property('test-case',
has_property('failure',
has_properties({
'message': message,
'stack-trace': has_string(trace)
}))))
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 test_instance_of_new_class(self):
value1 = 'value1'
value2 = 'value2'
model = StubModel(field1=value1, field2=value2)
assert_that(model, all_of(
has_property('field1', value1),
has_property('field2', value2)
))
def assert_result(self, *matchers, **kwargs):
result = kwargs.get(u'result', self.result)
assert_that(result, all_of(
has_property(u'exit_code', kwargs.pop(u'exit_code', 0)),
has_property(u'output', kwargs.pop(u'output', anything())),
has_properties(**kwargs),
*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_collection_error(report_for):
report = report_for(test_broken_module="""
def test(
""")
assert_that(report, all_of(
has_property('{}test-cases', has_property('test-case', contains(
has_property('{}name', 'test_broken_module')))),
has_property('{}title', 'Collection phase')))
def test_get_by_user_id_with_voicemail(self):
user_row, voicemail_row = self.create_user_and_voicemail(firstname='King', exten='1000', context='default')
result = user_voicemail_dao.get_by_user_id(user_row.id)
assert_that(result, instance_of(UserVoicemail))
assert_that(result,
has_property('user_id', user_row.id),
has_property('voicemail_id', voicemail_row.uniqueid))
def test_get_by_extension_id_with_multiple_users(self):
main_ule = self.add_user_line_with_exten()
secondary_ule = self.prepare_secondary_user_associated(main_ule)
line_extension = dao.get_by_extension_id(secondary_ule.extension_id)
assert_that(line_extension, all_of(
has_property('line_id', main_ule.line_id),
has_property('extension_id', main_ule.extension_id)))
def has_label(test_name, label_name=anything(), label_value=anything()):
return has_property('{}test-cases',
has_property('test-case',
has_item(
has_properties({'name': equal_to(test_name),
'labels': has_property('label',
has_item(
has_property('attrib', equal_to(
{'name': label_name,
'value': label_value}))))}))))
def test_find_all_one_user_commented(self):
firstname = 'Pascal'
user = self.add_user(firstname=firstname, commented=1)
users = user_dao.find_all()
assert_that(users, has_length(1))
user_found = users[0]
assert_that(user_found, has_property('id', user.id))
assert_that(user_found, has_property('firstname', firstname))
def test_find_all_by_user_id(self):
user_line = self.add_user_line_without_exten()
result = user_line_dao.find_all_by_user_id(user_line.user_id)
assert_that(result, has_items(
all_of(
has_property('user_id', user_line.user_id),
has_property('line_id', user_line.line_id))
))
def test_it_should_calculate_0_as_distance_to_same_point(self):
"""Check it actually computes distances"""
position = AVAILABLE_STATION['latitud'], AVAILABLE_STATION['longitud']
result = self.filter(distance(position),
(AVAILABLE_STATION, NO_BIKES_STATION))
assert_that(result, contains(
has_property('distance', 0.0),
has_property('distance', all_of(greater_than(1401), less_than(1402)))
))
def test_find_last_unprocessed_with_processed_and_unprocessed(self):
limit = 10
self._add_processed_cel(linkedid='1')
self._add_processed_cel(linkedid='1')
cel_id_3, cel_id_4 = self.add_cel(linkedid='2'), self.add_cel(linkedid='2')
result = cel_dao.find_last_unprocessed(limit)
assert_that(result, contains(has_property('id', cel_id_3),
has_property('id', cel_id_4)))
def test_find_last_unprocessed_under_limit_exceeding_limit_to_reprocess_partially_processed_call(self):
limit = 2
cel_id_1, cel_id_2 = self._add_processed_cel(linkedid='1'), self.add_cel(linkedid='1')
cel_id_3, cel_id_4 = self._add_processed_cel(linkedid='2'), self.add_cel(linkedid='2')
result = cel_dao.find_last_unprocessed(limit)
assert_that(result, contains(has_property('id', cel_id_1),
has_property('id', cel_id_2),
has_property('id', cel_id_3),
has_property('id', cel_id_4)))
def test_find_by_voicemail_id_when_voicemail_associated_to_user(self):
user_row, voicemail_row = self.create_user_and_voicemail(firstname='Dolly',
exten='1000',
context='default')
result = user_voicemail_dao.find_by_voicemail_id(voicemail_row.uniqueid)
assert_that(result, instance_of(UserVoicemail))
assert_that(result,
has_property('user_id', user_row.id),
has_property('voicemail_id', voicemail_row.uniqueid))
def test_update_from_data_with_only_one_changes(self):
data = {
'field1': 'new_value1',
}
model = StubModel(field1='value1', field2='value2')
model.update_from_data(data)
assert_that(model, all_of(
has_property('field1', 'new_value1'),
has_property('field2', 'value2')))
def _assert_that_raises_http_error(status_code, fn, *args, **kwargs):
assert_that(
calling(fn).with_args(*args, **kwargs),
raises(requests.HTTPError).matching(
has_property('response', has_properties('status_code', status_code))
),
)
def ExtraConfStore_ModuleForSourceFile_NoConfirmation_test( app ): filename = PathToTestFile( 'extra_conf', 'project', 'some_file' ) module = extra_conf_store.ModuleForSourceFile( filename ) assert_that( inspect.ismodule( module ) ) assert_that( inspect.getfile( module ), equal_to( PROJECT_EXTRA_CONF ) ) assert_that( module, has_property( 'is_global_ycm_extra_conf' ) ) assert_that( module.is_global_ycm_extra_conf, equal_to( False ) )
def ExtraConfStore_ModuleForSourceFile_GlobalExtraConf_WinEnvVar_test( app ): filename = PathToTestFile( 'extra_conf', 'some_file' ) module = extra_conf_store.ModuleForSourceFile( filename ) assert_that( inspect.ismodule( module ) ) assert_that( inspect.getfile( module ), equal_to( GLOBAL_EXTRA_CONF ) ) assert_that( module, has_property( 'is_global_ycm_extra_conf' ) ) assert_that( module.is_global_ycm_extra_conf, equal_to( True ) )
def testBackfillCommands(self, mock_add):
command_1, command_2, command_3 = command_manager.CreateCommands(
request_id=self.request.key.id(),
command_infos=[
datastore_entities.CommandInfo(
command_line='long command line',
shard_count=3,
run_target='foo',
run_count=1,
cluster='foobar'),
datastore_entities.CommandInfo(
command_line='longer_command_line',
shard_count=3,
run_target='foo',
run_count=1,
cluster='foobar'),
datastore_entities.CommandInfo(
command_line='short_cmd',
shard_count=3,
run_target='foo',
run_count=1,
cluster='foobar'),
],
shard_indexes=list(range(3)),
request_plugin_data={
'ants_invocation_id': 'i123',
'ants_work_unit_id': 'w123'
})
command_1.state = common.CommandState.QUEUED
command_1.put()
command_2.state = common.CommandState.QUEUED
command_2.put()
command_3.state = common.CommandState.RUNNING
command_3.put()
response = self.testapp.post_json(
'/_ah/api/CoordinatorApi.BackfillCommands', {})
self.assertEqual('200 OK', response.status)
mock_add.assert_has_calls(
[
mock.call(
hamcrest.match_equality(
hamcrest.has_property('key', command_1.key))),
mock.call(
hamcrest.match_equality(
hamcrest.has_property('key', command_2.key))),
], any_order=True)
self.assertEqual(2, mock_add.call_count)
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 test_signals_when_user_signs_in(listener):
session = make_anonymous_session()
listener.should_receive("user_signed_in").with_args(
matching(has_property("email", equal_to("*****@*****.**")))).once()
session.user_signed_in.subscribe(listener.user_signed_in)
session.login_as("*****@*****.**", "api-key", ())
def test_attribute_access():
"""
Configuration can be accessed by attribute and key.
"""
config = Configuration(
key="value",
nested=dict(
nested_key="nested_value",
other_key=range(10),
)
)
assert_that(config, has_entry("key", "value"))
assert_that(config, has_property("key", "value"))
assert_that(config["nested"], is_(instance_of(Configuration)))
assert_that(config["nested"], has_entry("nested_key", "nested_value"))
assert_that(config.nested, has_property("nested_key", "nested_value"))
def test_when_delete_then_raises(self):
assert_that(
calling(self.client.backends.delete_source).with_args(
backend=self.BACKEND,
source_uuid='a-non-existing-source-uuid',
),
raises(requests.HTTPError).matching(
has_property('response', has_properties('status_code', 404))))
def test_find_factories_sets_name(self):
class AP(AutoPackage):
@classmethod
def _ap_enumerate_module_names(cls):
return ()
reg = AP._ap_find_factories('nti.externalization.tests')
assert_that(reg, has_property('__name__', 'nti.externalization.tests'))
def test_load_end_before_start_different_length(self):
context_range = dict(start='02', end='001')
assert_that(
calling(self.schema.load).with_args(context_range),
raises(ValidationError, has_property('messages',
has_key('_schema'))),
)
def test_update_persistent_object(self):
from persistent import Persistent
external = {}
class Obj(Persistent):
updated = False
def updateFromExternalObject(self, ext):
self.updated = True
contained = Obj()
self._callFUT(contained, external)
assert_that(contained, has_property('updated', True))
assert_that(
contained,
has_property('_v_updated_from_external_source',
is_(same_instance(external))))
def test_it_should_find_by_field(self):
"""Should return a station with given spec"""
result = self.filter(find('id', int(AVAILABLE_STATION['idestacion'])),
(AVAILABLE_STATION, NO_BIKES_STATION))
assert_that(
result,
is_(has_property('idestacion', AVAILABLE_STATION['idestacion'])))
def test_delegate_properties(self):
class Base(object):
b = 1
base = Base()
mon = ActivityMonitor(base)
assert_that(mon, has_property('b', 1))
def test_scan_no_name(self):
class O(object):
__external_can_create__ = True
self._addFactory(O)
xmlconfig.string(self.SCAN_THIS_MODULE.replace('PLACEHOLDER', ''))
factory = component.getUtility(IClassObjectFactory, 'O')
assert_that(factory, has_property('_callable', equal_to(O)))
def test_validate_auth_username(self):
body = {'auth_username': '******', 'remote_host': 'remote_host'}
assert_that(
calling(self.schema.load).with_args(body),
raises(ValidationError,
has_property('messages', has_key('auth_username'))),
)
def test_given_non_user_subscription_when_user_delete_http_subscription_then_404(self, subscription_):
token = 'my-token'
auth = self.make_auth()
auth.set_token(MockUserToken(token, USER_1_UUID))
webhookd = self.make_webhookd(token)
assert_that(calling(webhookd.subscriptions.delete_as_user).with_args(subscription_['uuid']),
raises(WebhookdError, has_property('status_code', 404)))
def test_given_microsoft_when_fetch_all_contacts_with_error_endpoint(
self, office365_api):
assert_that(
calling(self.client.backends.list_contacts_from_source).with_args(
backend=self.BACKEND, source_uuid=self.source['uuid']),
raises(requests.HTTPError).matching(
has_property('response', has_properties('status_code', 503))),
)
def test_search_paging(self):
with self.store.flushing():
self.store.create(self.kevin)
with patch.object(self.store, "new_timestamp") as mocked:
# ensure we have >= 1s created at delta
mocked.return_value = self.kevin.created_at + timedelta(
seconds=1).seconds * 1000
self.store.create(self.steph)
assert_that(
self.store.search(offset=1, limit=1),
contains(has_property("id", self.kevin.id), ),
)
assert_that(
self.store.search(offset=0, limit=1),
contains(has_property("id", self.steph.id), ),
)
def test_update_mapping_with_kwargs_context(self):
class ContainedObject(object):
updated = False
args = None
context = None
def updateFromExternalObject(self, ext, context=None, **kwargs):
self.updated = True
self.args = kwargs
self.context = context
return True
contained = ContainedObject()
self._callFUT(contained, {}, context=42)
assert_that(contained, has_property('updated', True))
assert_that(contained, has_property('args', {}))
assert_that(contained, has_property('context', 42))
def test_interpret_chan_start(self):
line_identity = 'sip/asldfj'
cel = Mock(channame=line_identity + '-0000001')
call = Mock(RawCallLog)
result = self.callee_cel_interpretor.interpret_chan_start(cel, call)
assert_that(result, has_property('destination_line_identity', line_identity))
def test_smoke_simple(report_for, statement):
report = report_for("""
import pytest
def test():
%s
""" % statement)
assert_that(report.findall('.//test-case'), contains(has_property('name')))
def test_it_should_filter_stations_with_no_spaces(self):
result = self.filter(with_spaces,
(AVAILABLE_STATION, NO_SPACES_STATION))
assert_that(
result,
only_contains(
has_property('idestacion', AVAILABLE_STATION['idestacion'])))
def test_smoke_decorated_success(report_for, test):
report = report_for("""
import pytest
%s:
assert 0
""" % test)
assert_that(report.findall('.//test-case'), contains(has_property('name')))
def test_shouldRemoveTheHookingWhenWorkflowObjectIsDeleted(self):
workflow_object = BasicTestModelObjectFactory().model
hooking_hash = '%s.%s_object%s_field_name%s' % (PostTransitionHooking.__module__, PostTransitionHooking.__name__, workflow_object.pk, self.field_name)
assert_that(self.handler_backend.callbacks, is_not(has_key(hooking_hash)))
assert_that(self.handler_backend.callbacks, is_not(has_value(has_property("__name__", test_callback.__name__))))
self.handler_backend.register(PostTransitionHooking, test_callback, workflow_object, self.field_name)
assert_that(self.handler_backend.callbacks, has_key(hooking_hash))
assert_that(self.handler_backend.callbacks, has_value(has_property("__name__", test_callback.__name__)))
workflow_object.delete()
assert_that(self.handler_backend.callbacks, is_not(has_key(hooking_hash)))
assert_that(self.handler_backend.callbacks, is_not(has_value(has_property("__name__", test_callback.__name__))))
def test_shouldReturnTheRegisteredHooking(self):
workflow_object = BasicTestModelObjectFactory().model
self.handler_backend.register(PostTransitionHooking, test_callback, workflow_object, self.field_name)
callbacks = self.handler_backend.get_callbacks(PostTransitionHooking, workflow_object, self.field_name)
assert_that(callbacks, has_length(1))
assert_that(callbacks, has_item(has_property("__name__", test_callback.__name__)))
