def assert_that_volume_entity_is_created(self, tenant_id):
entities = self.almanachHelper.get_entities(tenant_id, "2016-01-01 00:00:00.000")
assert_that(len(entities), equal_to(2))
assert_that(entities[0], is_not(has_entry("end", None)))
assert_that(entities[0], has_entry("size", 10))
assert_that(entities[1], has_entry("end", None))
assert_that(entities[1], has_entry("size", 100))
def GetCompletions_ClangCompleter_UnknownExtraConfException_test():
app = TestApp( handlers.app )
filepath = PathToTestFile( 'basic.cpp' )
completion_data = BuildRequest( filepath = filepath,
filetype = 'cpp',
contents = open( filepath ).read(),
line_num = 11,
column_num = 7,
force_semantic = True )
response = app.post_json( '/completions',
completion_data,
expect_errors = True )
eq_( response.status_code, httplib.INTERNAL_SERVER_ERROR )
assert_that( response.json,
has_entry( 'exception',
has_entry( 'TYPE', UnknownExtraConf.__name__ ) ) )
app.post_json( '/ignore_extra_conf_file',
{ 'filepath': PathToTestFile( '.ycm_extra_conf.py' ) } )
response = app.post_json( '/completions',
completion_data,
expect_errors = True )
eq_( response.status_code, httplib.INTERNAL_SERVER_ERROR )
assert_that( response.json,
has_entry( 'exception',
has_entry( 'TYPE', NoExtraConfDetected.__name__ ) ) )
def test_it_should_force_reply(self):
self.register('sendMessage')
self.telegram.send_message(CHAT_ID, TEXT, force_reply=True)
assert_that(self.sent_json,
has_entry('reply_markup', has_entry('force_reply', True)))
def step_with(name, start, stop, status):
return has_properties(name=name,
title=name,
attrib=all_of(
has_entry('start', has_float(greater_than_or_equal_to(start))),
has_entry('stop', has_float(less_than_or_equal_to(stop))),
has_entry('status', status)))
def test_dashboard_with_section_slug_returns_module_and_children(self):
dashboard = DashboardFactory(slug='my-first-slug')
dashboard.owners.add(self.user)
module_type = ModuleTypeFactory()
parent = ModuleFactory(
type=module_type,
slug='section-we-want',
order=1,
dashboard=dashboard
)
ModuleFactory(
type=module_type,
slug='module-we-want',
order=2,
dashboard=dashboard,
parent=parent)
resp = self.client.get(
'/public/dashboards', {'slug': 'my-first-slug/section-we-want'})
data = json.loads(resp.content)
assert_that(data['modules'],
contains(has_entry('slug', 'section-we-want')))
assert_that(len(data['modules']), equal_to(1))
assert_that(data['modules'][0]['modules'],
contains(has_entry('slug', 'module-we-want')))
assert_that(data, has_entry('page-type', 'module'))
def test_list_transforms_for_dataset_and_type_with_no_group(self):
data_set = DataSetFactory()
set_transform = TransformFactory(
input_group=data_set.data_group,
input_type=data_set.data_type,
)
type_transform = TransformFactory(
input_type=data_set.data_type,
)
resp = self.client.get(
'/data-sets/{}/transform'.format(data_set.name),
HTTP_AUTHORIZATION='Bearer development-oauth-access-token')
assert_that(resp.status_code, is_(200))
resp_json = json.loads(resp.content)
assert_that(len(resp_json), is_(2))
assert_that(
resp_json,
has_item(has_entry('id', str(set_transform.id))))
assert_that(
resp_json,
has_item(has_entry('id', str(type_transform.id))))
def test_readonly_override(self):
class IA(Interface):
field = Attribute("A field")
schema = jsonschema.JsonSchemafier(IA, readonly_override=True).make_schema()
assert_that(schema, has_entry('field', has_entry('readonly', True)))
def GetCompletions_UnknownExtraConfException_test( app ):
filepath = PathToTestFile( 'basic.cpp' )
completion_data = BuildRequest( filepath = filepath,
filetype = 'cpp',
contents = ReadFile( filepath ),
line_num = 11,
column_num = 7,
force_semantic = True )
response = app.post_json( '/completions',
completion_data,
expect_errors = True )
eq_( response.status_code, requests.codes.internal_server_error )
assert_that( response.json,
has_entry( 'exception',
has_entry( 'TYPE', UnknownExtraConf.__name__ ) ) )
app.post_json(
'/ignore_extra_conf_file',
{ 'filepath': PathToTestFile( '.ycm_extra_conf.py' ) } )
response = app.post_json( '/completions',
completion_data,
expect_errors = True )
eq_( response.status_code, requests.codes.internal_server_error )
assert_that( response.json,
has_entry( 'exception',
has_entry( 'TYPE',
NoExtraConfDetected.__name__ ) ) )
def test_update_entity_change_flavor_of_closed(self):
instance_create_query = "{url}/project/{project}/instance"
project_id = "my_test_project_id"
instance_id = str(uuid4())
data = {'id': instance_id,
'created_at': '2016-01-01T18:30:00Z',
'name': 'integration_test_instance_FlavorA',
'flavor': 'FlavorA',
'os_type': 'Linux',
'os_distro': 'Ubuntu',
'os_version': '14.04'}
self.almanachHelper.post(url=instance_create_query, data=data, project=project_id)
instance_delete_query = "{url}/instance/{instance_id}"
delete_data = {'date': '2016-01-01T18:50:00Z'}
self.almanachHelper.delete(url=instance_delete_query, data=delete_data, instance_id=instance_id)
response = self.almanachHelper.put(url="{url}/entity/instance/{instance_id}?start={start}&end={end}",
start="2016-01-01 18:29:59.0",
end="2016-01-01 18:50:00.0",
data={"flavor": "FlavorB",
"end_date": "2016-01-02 18:50:00.0Z"},
instance_id=instance_id,
)
assert_that(response.status_code, equal_to(200))
assert_that(response.json(), has_entry("flavor", "FlavorB"))
assert_that(response.json(), has_entry("end", "2016-01-02 18:50:00+00:00"))
def test_serialize_with_dataset_but_no_query_parameters(self):
module = ModuleFactory(
slug='a-module',
type=self.module_type,
data_set=self.data_set,
order=1,
dashboard=self.dashboard_a)
serialization = module.serialize()
assert_that(serialization['slug'], equal_to('a-module'))
assert_that(
serialization['type']['id'],
equal_to(str(self.module_type.id)))
assert_that(
serialization['dashboard']['id'],
equal_to(str(self.dashboard_a.id)))
assert_that(serialization['query_parameters'], equal_to(None))
assert_that(
serialization,
has_entry(
'data_group', equal_to(self.data_set.data_group.name)))
assert_that(
serialization,
has_entry(
'data_type', equal_to(self.data_set.data_type.name)))
def test_run_only(report_for, severities):
"""
Checks that running for given severities runs only selected tests
"""
report = report_for("""
import pytest
@pytest.allure.CRITICAL
def test_a():
pass
@pytest.allure.MINOR
def test_b():
pass
def test_c():
pass
""", extra_run_args=['--allure_severities', ','.join(severities)])
a_status, b_status, c_status = [Status.PASSED if s in severities else Status.CANCELED for s in [Severity.CRITICAL, Severity.MINOR, Severity.NORMAL]]
assert_that(report.xpath(".//test-case"), contains(
all_of(has_property('name', 'test_a'), has_property('attrib', has_entry('status', a_status))),
all_of(has_property('name', 'test_b'), has_property('attrib', has_entry('status', b_status))),
all_of(has_property('name', 'test_c'), has_property('attrib', has_entry('status', c_status)))
))
def test_list_returns_all_if_omniscient_nd_collector_view_but_no_ownership(
self):
view = TestResourceViewCollector()
request = HttpRequest()
request.method = 'GET'
request.META['HTTP_AUTHORIZATION'] = \
'Bearer correct-token'
settings.USE_DEVELOPMENT_USERS = False
signon = govuk_signon_mock(
permissions=['omniscient', 'collector-view'])
with HTTMock(signon):
response = view.get(request)
try:
json_response = json.loads(response.content)
except ValueError:
json_response = None
assert_that(response.status_code, is_(200))
assert_that(len(json_response), is_(2))
assert_that(json_response, contains_inanyorder(
has_entry("name", starts_with(
self.__class__.collector_type1.name)),
has_entry("name", starts_with(
self.__class__.collector_type2.name))))
def test_application_info(self):
app_info = {
'text_key': u'a value',
'byte_key': b'bytes',
'int_key': 7,
'list_key': [42,]
}
class IA(Interface):
field = Attribute("A field")
field.setTaggedValue(jsonschema.TAG_APPLICATION_INFO, app_info)
schema = TranslateTestSchema(IA, context=u' TEST').make_schema()
assert_that(schema, has_key("field"))
field = schema['field']
assert_that(field, has_key("application_info"))
# The dict itself was copied
assert_that(field['application_info'], is_not(same_instance(app_info)))
# as were its contents
assert_that(field['application_info'], has_entry('list_key', is_([42])))
assert_that(field['application_info'],
has_entry('list_key', is_not(same_instance(app_info['list_key']))))
# Text strings were translated
assert_that(field['application_info'], has_entry('text_key', u'a value TEST'))
# Byte strings were not (is that even legel in json?)
assert_that(field['application_info'], has_entry('byte_key', b'bytes'))
def Subcommands_StopServer_Timeout_test( app ):
filepath = PathToTestFile( 'testy', 'GotoTestCase.cs' )
contents = ReadFile( filepath )
event_data = BuildRequest( filepath = filepath,
filetype = 'cs',
contents = contents,
event_name = 'FileReadyToParse' )
app.post_json( '/event_notification', event_data )
WaitUntilCompleterServerReady( app, 'cs' )
app.post_json(
'/run_completer_command',
BuildRequest(
filetype = 'cs',
filepath = filepath,
command_arguments = [ 'StopServer' ]
)
)
request_data = BuildRequest( filetype = 'cs', filepath = filepath )
assert_that( app.post_json( '/debug_info', request_data ).json,
has_entry(
'completer',
has_entry( 'servers', contains(
has_entry( 'is_running', False )
) )
) )
def EventNotification_FileReadyToParse_SyntaxKeywords_ClearCacheIfRestart_test(
ycm, *args ):
current_buffer = VimBuffer( name = 'current_buffer',
filetype = 'some_filetype' )
with patch( 'ycm.client.event_notification.EventNotification.'
'PostDataToHandlerAsync' ) as post_data_to_handler_async:
with MockVimBuffers( [ current_buffer ], [ current_buffer ] ):
ycm.OnFileReadyToParse()
assert_that(
# Positional arguments passed to PostDataToHandlerAsync.
post_data_to_handler_async.call_args[ 0 ],
contains(
has_entry( 'syntax_keywords', has_items( 'foo', 'bar' ) ),
'event_notification'
)
)
# Send again the syntax keywords after restarting the server.
ycm.RestartServer()
WaitUntilReady()
ycm.OnFileReadyToParse()
assert_that(
# Positional arguments passed to PostDataToHandlerAsync.
post_data_to_handler_async.call_args[ 0 ],
contains(
has_entry( 'syntax_keywords', has_items( 'foo', 'bar' ) ),
'event_notification'
)
)
def ServerManagement_ServerDies_test( app ):
StartJavaCompleterServerInDirectory(
app,
PathToTestFile( 'simple_eclipse_project' ) )
request_data = BuildRequest( filetype = 'java' )
debug_info = app.post_json( '/debug_info', request_data ).json
print( 'Debug info: {0}'.format( debug_info ) )
pid = debug_info[ 'completer' ][ 'servers' ][ 0 ][ 'pid' ]
print( 'pid: {0}'.format( pid ) )
process = psutil.Process( pid )
process.terminate()
for tries in range( 0, 10 ):
request_data = BuildRequest( filetype = 'java' )
debug_info = app.post_json( '/debug_info', request_data ).json
if not debug_info[ 'completer' ][ 'servers' ][ 0 ][ 'is_running' ]:
break
time.sleep( 0.5 )
assert_that( debug_info,
has_entry(
'completer',
has_entry( 'servers', contains(
has_entry( 'is_running', False )
) )
) )
def test_add_a_module_to_a_dashboard(self):
existing_modules_count = len(Module.objects.all())
resp = self.client.post(
'/dashboard/{}/module'.format(self.dashboard.slug),
data=json.dumps({
'slug': 'a-module',
'type_id': str(self.module_type.id),
'title': 'Some module',
'description': 'Some text about the module',
'info': ['foo'],
'options': {
'thing': 'a value',
},
'objects': "some object",
'order': 1,
'modules': [],
}),
HTTP_AUTHORIZATION='Bearer development-oauth-access-token',
content_type='application/json')
assert_that(resp.status_code, is_(equal_to(200)))
assert_that(
len(Module.objects.all()),
greater_than(existing_modules_count))
resp_json = json.loads(resp.content)
assert_that(resp_json, has_key('id'))
assert_that(resp_json, has_entry('slug', 'a-module'))
assert_that(resp_json, has_entry('options', {'thing': 'a value'}))
stored_module = Module.objects.get(id=resp_json['id'])
assert_that(stored_module, is_not(None))
def test_basic_query_with_time_limits(self):
self._save_all('foo_bar',
{'_timestamp': d_tz(2012, 12, 12)},
{'_timestamp': d_tz(2012, 12, 14)},
{'_timestamp': d_tz(2012, 12, 11)})
# start at
results = self.engine.execute_query('foo_bar', Query.create(
start_at=d_tz(2012, 12, 12, 13)))
assert_that(results,
contains(
has_entry('_timestamp', d_tz(2012, 12, 14))))
# end at
results = self.engine.execute_query('foo_bar', Query.create(
end_at=d_tz(2012, 12, 11, 13)))
assert_that(results,
contains(
has_entry('_timestamp', d_tz(2012, 12, 11))))
# both
results = self.engine.execute_query('foo_bar', Query.create(
start_at=d_tz(2012, 12, 11, 12),
end_at=d_tz(2012, 12, 12, 12)))
assert_that(results,
contains(
has_entry('_timestamp', d_tz(2012, 12, 12))))
def UnknownExtraConfException_test( self ):
filepath = self._PathToTestFile( 'basic.cpp' )
completion_data = self._BuildRequest( filepath = filepath,
filetype = 'cpp',
contents = ReadFile( filepath ),
line_num = 11,
column_num = 7,
force_semantic = True )
response = self._app.post_json( '/completions',
completion_data,
expect_errors = True )
eq_( response.status_code, http.client.INTERNAL_SERVER_ERROR )
assert_that( response.json,
has_entry( 'exception',
has_entry( 'TYPE', UnknownExtraConf.__name__ ) ) )
self._app.post_json(
'/ignore_extra_conf_file',
{ 'filepath': self._PathToTestFile( '.ycm_extra_conf.py' ) } )
response = self._app.post_json( '/completions',
completion_data,
expect_errors = True )
eq_( response.status_code, http.client.INTERNAL_SERVER_ERROR )
assert_that( response.json,
has_entry( 'exception',
has_entry( 'TYPE',
NoExtraConfDetected.__name__ ) ) )
def GetCompletions_Basic_test( app ):
filepath = PathToTestFile( 'basic.py' )
completion_data = BuildRequest( filepath = filepath,
filetype = 'python',
contents = ReadFile( filepath ),
line_num = 7,
column_num = 3 )
results = app.post_json( '/completions',
completion_data ).json[ 'completions' ]
assert_that( results,
has_items(
CompletionEntryMatcher( 'a',
'self.a = 1',
{
'extra_data': has_entry(
'location', has_entries( {
'line_num': 3,
'column_num': 10,
'filepath': filepath
} )
)
} ),
CompletionEntryMatcher( 'b',
'self.b = 2',
{
'extra_data': has_entry(
'location', has_entries( {
'line_num': 4,
'column_num': 10,
'filepath': filepath
} )
)
} )
) )
completion_data = BuildRequest( filepath = filepath,
filetype = 'python',
contents = ReadFile( filepath ),
line_num = 7,
column_num = 4 )
results = app.post_json( '/completions',
completion_data ).json[ 'completions' ]
assert_that( results,
all_of(
has_item(
CompletionEntryMatcher( 'a',
'self.a = 1',
{
'extra_data': has_entry(
'location', has_entries( {
'line_num': 3,
'column_num': 10,
'filepath': filepath
} )
)
} ) ),
is_not( has_item( CompletionEntryMatcher( 'b' ) ) )
) )
def GetDetailedDiagnostic_JediCompleter_DoesntWork_test():
app = TestApp(handlers.app)
diag_data = BuildRequest(contents="foo = 5", line_num=2, filetype="python")
response = app.post_json("/detailed_diagnostic", diag_data, expect_errors=True)
eq_(response.status_code, httplib.INTERNAL_SERVER_ERROR)
assert_that(response.json, has_entry("exception", has_entry("TYPE", NoDiagnosticSupport.__name__)))
def test_ui_type(self):
class IA(Interface):
field = Attribute("A field")
field.setTaggedValue(jsonschema.TAG_UI_TYPE, 'MyType')
schema = jsonschema.JsonSchemafier(IA).make_schema()
assert_that(schema, has_entry('field', has_entry('type', 'MyType')))
def then_i_see_an_ami_message_on_the_queue(step, event_name, queue):
events = bus_helper.get_messages_from_bus(queue)
matcher_dict = dict((event_line['header'], matches_regexp(event_line['value']))
for event_line in step.hashes)
assert_that(events, has_item(all_of(has_entry('name', event_name),
has_entry('data', has_entries(matcher_dict)))))
def test_index_empty_directory():
target = 'foo/'
scanner = [(target, [], [])]
index = dir2json.create_index(target, scanner)
assert_that(index, has_entry('type', 'directory'))
assert_that(index, has_entry('index', empty()))
def _assert_type(t, name='field',
**kwargs):
schema = TranslateTestSchema(IA, context=' TEST').make_schema()
assert_that(schema, has_entry(name, has_entry('type', t)))
for nested_name, matcher in kwargs.items():
assert_that(schema, has_entry(name, has_entry(nested_name, matcher)))
return schema
def has_parameter(name, value):
return has_entry('parameters',
has_item(
all_of(
has_entry('name', equal_to(name)),
has_entry('value', equal_to(value))
)
))
def has_step(name, *matchers):
return has_entry('steps',
has_item(
all_of(
has_entry('name', equal_to(name)),
*matchers
)
))
def has_link(url, link_type=None, name=None):
return has_entry('links',
has_item(
all_of(
*[has_entry(key, value) for key, value in
zip(('url', 'type', 'name'), (url, link_type, name)) if value is not None]
)
))
def test_creates_default_chain_of_title_from_metadata():
source_metadata = metadata(lyricist=["Joel Miller"], composer=["John Roney"], publisher=["Effendi Records"])
track = make_track(metadata_from=source_metadata)
assert_that(track.chain_of_title.contributors,
all_of(has_author_composer("John Roney", has_entry("name", "John Roney")),
has_author_composer("Joel Miller", has_entry("name", "Joel Miller")),
has_publisher("Effendi Records", has_entry("name", "Effendi Records"))),
"The chain of title")
def test_period_queries_get_sorted_by__week_start_at(self):
self.setup__timestamp_data()
query = Query.create(period=WEEK)
result = self.data_set.execute_query(query)
assert_that(result, contains(
has_entry('_start_at', d_tz(2012, 12, 31)),
has_entry('_start_at', d_tz(2013, 1, 28)),
has_entry('_start_at', d_tz(2013, 2, 25))
))
def Diagnostics_Multiline_test(app):
contents = """
struct Foo {
Foo(int z) {}
};
int main() {
Foo foo("goo");
}
"""
filepath = PathToTestFile('foo.cc')
request = {'contents': contents, 'filepath': filepath, 'filetype': 'cpp'}
test = {'request': request, 'route': '/receive_messages'}
RunAfterInitialized(app, test)
diag_data = BuildRequest(line_num=7,
contents=contents,
filepath=filepath,
filetype='cpp')
results = app.post_json('/detailed_diagnostic', diag_data).json
assert_that(results, has_entry('message', contains_string("\n")))
def DebugInfo_ServerIsNotRunning_NoSolution_test(app):
request_data = BuildRequest(filetype='cs')
assert_that(
app.post_json('/debug_info', request_data).json,
has_entry(
'completer',
has_entries({
'name':
'C#',
'servers':
contains_exactly(
has_entries({
'name': 'OmniSharp',
'is_running': False,
'executable': instance_of(str),
'pid': None,
'address': None,
'port': None,
'logfiles': empty()
})),
'items':
empty()
})))
def DebugInfo_FlagsWhenGlobalExtraConfAndCompilationDatabaseLoaded_test( app ):
with TemporaryTestDir() as tmp_dir:
compile_commands = [
{
'directory': tmp_dir,
'command': 'clang++ -I. -I/absolute/path -Wall',
'file': os.path.join( tmp_dir, 'test.cc' ),
},
]
with TemporaryClangProject( tmp_dir, compile_commands ):
request_data = BuildRequest(
filepath = os.path.join( tmp_dir, 'test.cc' ),
filetype = 'cpp' )
assert_that(
app.post_json( '/debug_info', request_data ).json,
has_entry( 'completer', has_entries( {
'name': 'C-family',
'servers': empty(),
'items': contains(
has_entries( {
'key': 'compilation database path',
'value': instance_of( str )
} ),
has_entries( {
'key': 'flags',
'value': matches_regexp(
"\\[u?'clang\\+\\+', u?'-x', u?'c\\+\\+', .*, u?'-Wall', .*\\]"
)
} ),
has_entries( {
'key': 'translation unit',
'value': os.path.join( tmp_dir, 'test.cc' ),
} )
)
} ) )
)
def test__shouldReturnListOfTransitionMeta(self):
initial_state = State.objects.create(label="state-1")
state_2 = State.objects.create(label="state-2")
state_3 = State.objects.create(label="state-3")
content_type = ContentType.objects.first()
workflow = Workflow.objects.create(initial_state=initial_state,
content_type=content_type,
field_name="test-field")
transition_meta_1 = TransitionMeta.objects.create(
workflow=workflow,
source_state=initial_state,
destination_state=state_2)
transition_meta_2 = TransitionMeta.objects.create(
workflow=workflow,
source_state=initial_state,
destination_state=state_3)
response = self.client.get('/workflow/transition-meta/list/%d/' %
workflow.id)
assert_that(response.status_code, equal_to(HTTP_200_OK))
assert_that(response.data, has_length(2))
assert_that(
response.data,
has_item(
all_of(
has_entry("id", equal_to(transition_meta_1.id)),
has_entry("source_state",
equal_to(transition_meta_1.source_state.id)),
has_entry("destination_state",
equal_to(
transition_meta_1.destination_state.id)))))
assert_that(
response.data,
has_item(
all_of(
has_entry("id", equal_to(transition_meta_2.id)),
has_entry("source_state",
equal_to(transition_meta_2.source_state.id)),
has_entry("destination_state",
equal_to(
transition_meta_2.destination_state.id)))))
def test_Diagnostics_Multiline(self, app):
contents = """
struct Foo {
Foo(int z) {}
};
int main() {
Foo foo("goo");
}
"""
diag_data = BuildRequest(compilation_flags=['-x', 'c++'],
line_num=7,
contents=contents,
filetype='cpp')
event_data = diag_data.copy()
event_data.update({
'event_name': 'FileReadyToParse',
})
app.post_json('/event_notification', event_data)
results = app.post_json('/detailed_diagnostic', diag_data).json
assert_that(results, has_entry('message', contains_string("\n")))
def DebugInfo_FlagsWhenGlobalExtraConfAndNoCompilationDatabase_test( app ):
request_data = BuildRequest( filepath = PathToTestFile( 'basic.cpp' ),
filetype = 'cpp' )
assert_that(
app.post_json( '/debug_info', request_data ).json,
has_entry( 'completer', has_entries( {
'name': 'C-family',
'servers': empty(),
'items': contains(
has_entries( {
'key': 'compilation database path',
'value': 'None'
} ),
has_entries( {
'key': 'flags',
'value': matches_regexp( "\\[u?'-x', u?'c\\+\\+', .*\\]" )
} ),
has_entries( {
'key': 'translation unit',
'value': PathToTestFile( 'basic.cpp' )
} )
)
} ) )
)
def test_address_field(self):
params = {'emails': [ONE, SIX]}
assert_that(
calling(self.admin_schema.load).with_args(params),
raises(
ValidationError,
has_property(
"messages",
has_entries(emails=has_entry(1, has_key('address')))),
),
)
params = {'emails': [ONE, TWO, TWO]}
assert_that(
calling(self.admin_schema.load).with_args(params),
raises(
ValidationError,
has_property(
"messages",
has_entries(_schema=contains_exactly(
'The same address can only be used once')),
),
),
)
def GetDetailedDiagnostic_ClangCompleter_Works_test():
app = TestApp(handlers.app)
contents = """
struct Foo {
int x // semicolon missing here!
int y;
int c;
int d;
};
"""
diag_data = BuildRequest(compilation_flags=['-x', 'c++'],
line_num=3,
contents=contents,
filetype='cpp')
event_data = diag_data.copy()
event_data.update({
'event_name': 'FileReadyToParse',
})
app.post_json('/event_notification', event_data)
results = app.post_json('/detailed_diagnostic', diag_data).json
assert_that(results, has_entry('message', contains_string("expected ';'")))
def test_Diagnostics_DetailedDiags(self, app):
filepath = PathToTestFile('common', 'src', 'main.rs')
contents = ReadFile(filepath)
with open(filepath, 'w') as f:
f.write(contents)
event_data = BuildRequest(event_name='FileSave',
contents=contents,
filepath=filepath,
filetype='rust')
app.post_json('/event_notification', event_data)
WaitForDiagnosticsToBeReady(app, filepath, contents, 'rust')
request_data = BuildRequest(contents=contents,
filepath=filepath,
filetype='rust',
line_num=14,
column_num=13)
results = app.post_json('/detailed_diagnostic', request_data).json
assert_that(
results,
has_entry(
'message',
'no field `build_` on type `test::Builder`\nunknown field'))
def Diagnostics_Basic_test(app):
filepath = PathToTestFile('testy', 'Program.cs')
with WrapOmniSharpServer(app, filepath):
contents = ReadFile(filepath)
event_data = BuildRequest(filepath=filepath,
event_name='FileReadyToParse',
filetype='cs',
contents=contents)
app.post_json('/event_notification', event_data)
diag_data = BuildRequest(filepath=filepath,
filetype='cs',
contents=contents,
line_num=11,
column_num=2)
results = app.post_json('/detailed_diagnostic', diag_data).json
assert_that(
results,
has_entry(
'message',
contains_string(
"Unexpected symbol `}'', expecting identifier")))
def test_DebugInfo_ExtraConf_Global( self, app ):
request_data = BuildRequest( filepath = PathToTestFile( 'foo.cpp' ),
contents = '',
filetype = 'cpp' )
test = { 'request': request_data }
request_data[ 'contents' ] = ''
RunAfterInitialized( app, test )
assert_that(
app.post_json( '/debug_info', request_data ).json,
has_entry( 'completer', has_entries( {
'name': 'C-family',
'servers': contains_exactly( has_entries( {
'name': 'Clangd',
'is_running': True,
'extras': contains_exactly(
has_entries( {
'key': 'Server State',
'value': 'Initialized',
} ),
has_entries( {
'key': 'Project Directory',
'value': PathToTestFile(),
} ),
has_entries( {
'key': 'Settings',
'value': '{}',
} ),
has_entries( {
'key': 'Compilation Command',
'value': has_items( '-I', 'test' ),
} ),
),
} ) ),
'items': empty()
} ) )
)
def test_that_importing_a_contact_with_an_existing_uuid(self):
csv = textwrap.dedent(
'''\
firstname
alice
'''
)
result = self.import_personal(csv, VALID_TOKEN_MAIN_TENANT)
for user in result['created']:
uuid = user['id']
break
csv = textwrap.dedent(
'''\
id,firstname
{},not alice
29d4aec1-db4c-4c67-80a0-b83136c58a47,bob
'''.format(
uuid
)
)
result = self.import_personal(csv, VALID_TOKEN_MAIN_TENANT)
assert_that(result['failed'], contains(has_entry('line', 2)))
def test_dashboard_with_nonexistent_tab_slug_returns_nothing(self):
dashboard = DashboardFactory(slug='my-first-slug')
module_type = ModuleTypeFactory()
ModuleFactory(type=module_type,
dashboard=dashboard,
slug='module',
info=['module-info'],
title='module-title',
options={
'tabs': [{
'slug': 'tab-we-want',
'title': 'tab-title'
}, {
'slug': 'tab-we-dont-want',
}]
})
ModuleFactory(type=module_type,
dashboard=dashboard,
slug='module-we-dont-want')
resp = self.client.get(
'/public/dashboards',
{'slug': 'my-first-slug/module/module-non-existent-tab'})
data = json.loads(resp.content)
assert_that(data, has_entry('status', 'error'))
def test__shouldCreateTransitionMetaWithGivenPriority(self):
initial_state = State.objects.create(label="state-1")
state_2 = State.objects.create(label="state-2")
content_type = ContentType.objects.first()
workflow = Workflow.objects.create(initial_state=initial_state,
content_type=content_type,
field_name="test-field")
response = self.client.post('/transition-meta/create/',
data={
"workflow": workflow.id,
"source_state": initial_state.id,
"destination_state": state_2.id
})
assert_that(response.status_code, equal_to(HTTP_200_OK))
created_transition_meta = TransitionMeta.objects.first()
assert_that(response.data,
has_entry("id", equal_to(created_transition_meta.pk)))
assert_that(created_transition_meta,
has_property("source_state", equal_to(initial_state)))
assert_that(created_transition_meta,
has_property("destination_state", equal_to(state_2)))
def test_DebugInfo_TypeScriptCompleter(self, 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 DebugInfo_test(app):
request_data = BuildRequest(filetype='javascript')
assert_that(
app.post_json('/debug_info', request_data).json,
has_entry(
'completer',
has_entries({
'name':
'JavaScript',
'servers':
contains(
has_entries({
'name':
'Tern',
'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)),
'extras':
contains(
has_entries({
'key': 'configuration file',
'value': instance_of(str)
}))
})),
'items':
empty()
})))
def DebugInfo_test(app):
request_data = BuildRequest(filetype='python')
assert_that(
app.post_json('/debug_info', request_data).json,
has_entry(
'completer',
has_entries({
'name':
'Python',
'items':
contains_exactly(
has_entries({
'key': 'Python interpreter',
'value': instance_of(str)
}),
has_entries({
'key': 'Python root',
'value': instance_of(str)
}),
has_entries({
'key': 'Python path',
'value': instance_of(str)
}),
has_entries({
'key': 'Python version',
'value': instance_of(str)
}),
has_entries({
'key': 'Jedi version',
'value': instance_of(str)
}),
has_entries({
'key': 'Parso version',
'value': instance_of(str)
}))
})))
def test_EventNotification_FileReadyToParse_SyntaxKeywords_SeedWithCache(
self, ycm, *args):
current_buffer = VimBuffer(name='current_buffer',
filetype='some_filetype')
with patch('ycm.client.event_notification.EventNotification.'
'PostDataToHandlerAsync') as post_data_to_handler_async:
with MockVimBuffers([current_buffer], [current_buffer]):
ycm.OnFileReadyToParse()
assert_that(
# Positional arguments passed to PostDataToHandlerAsync.
post_data_to_handler_async.call_args[0],
contains_exactly(
has_entry('syntax_keywords', has_items('foo', 'bar')),
'event_notification'))
# Do not send again syntax keywords in subsequent requests.
ycm.OnFileReadyToParse()
assert_that(
# Positional arguments passed to PostDataToHandlerAsync.
post_data_to_handler_async.call_args[0],
contains_exactly(is_not(has_key('syntax_keywords')),
'event_notification'))
def test_decrypt_data_file(self, mock_getpass):
ciphertext = (
b'Salted__\xbe\x82\x11\xc4\x01\xe6\x94\xfc\x93\xb5\x8aF\xeb\x8chEy"'
b'\xd0\xb4\x04\xf3g\xb3.UX\x18\x17\x95\xe7 x7\x16\xa4{\x805~z\xe5\xad\xdc\xc4\xdc'
b'\xd43\x8e\xfd\xda\x108\xbfv\xf8yW\x1f\xd2\xd73j\x0f\xce\x0f(4\x95\xe3{&~{\xdf'
b'\x8ekm\xbb\x01\x17\xf28\x97\xd4\xfaSL\x99\xb5I\xfb\xc4\t\xb8\xeeH\x97\x02\\\xc8\xd6dw'
)
fd, cast_file_path = tempfile.mkstemp(suffix=".cast5",
prefix="passwords_test")
self.addCleanup(os.remove, cast_file_path)
os.write(fd, ciphertext)
os.close(fd)
mock_getpass.is_callable().returns('temp001')
buildout = NoDefaultBuildout()
options = {'file': cast_file_path, 'output-file': 'decrypted'}
section = DecryptFile(buildout, 'passwords', options)
assert_that(options, has_entry('_input_mod_time', not_none()))
section.install()
assert_that(
os.path.isfile(os.path.join('parts', 'passwords', 'plaintext')))
assert_that(
os.path.isfile(os.path.join('parts', 'passwords', 'checksum')))
assert_that(os.path.isfile('decrypted'))
with open('decrypted', 'rb') as f:
data = f.read()
self.assertIn(b'[passwords]', data)
def LanguageServerCompleter_GetCompletions_UnsupportedKinds_test( app ):
completer = MockCompleter()
request_data = RequestWrap( BuildRequest() )
completion_response = { 'result': [ { 'label': 'test',
'kind': len( lsp.ITEM_KIND ) + 1 } ] }
resolve_responses = [
{ 'result': { 'label': 'test' } },
]
with patch.object( completer, '_is_completion_provider', True ):
with patch.object( completer.GetConnection(),
'GetResponse',
side_effect = [ completion_response ] +
resolve_responses ):
assert_that(
completer.ComputeCandidatesInner( request_data, 1 ),
contains_exactly(
has_items( all_of( has_entry( 'insertion_text', 'test' ),
is_not( has_key( 'kind' ) ) ) ),
False
)
)
def test_given_call_logs_when_list_cdr_with_number_then_list_matching_cdr(
self):
result = self.call_logd.cdr.list(number='_45')
assert_that(
result,
has_entries(filtered=2,
total=4,
items=contains_inanyorder(
has_entry('source_extension', '12345'),
has_entry('destination_extension', '45'),
)))
result = self.call_logd.cdr.list(number='45')
assert_that(
result,
has_entries(filtered=1,
total=4,
items=contains_inanyorder(
has_entry('destination_extension', '45'), )))
result = self.call_logd.cdr.list(number='_23_')
assert_that(
result,
has_entries(filtered=2,
total=4,
items=contains_inanyorder(
has_entry('source_extension', '12345'),
has_entry('source_extension', '123'),
)))
result = self.call_logd.cdr.list(number='4_')
assert_that(
result,
has_entries(filtered=1,
total=4,
items=contains_inanyorder(
has_entry('destination_extension', '45'), )))
result = self.call_logd.cdr.list(number='0123456789')
assert_that(result, has_entries(filtered=0, total=4, items=empty()))
def test__shouldReturnListOfStates(self):
function_1 = Function.objects.create(name="test-function-1",
body="function-body")
function_2 = Function.objects.create(name="test-function-2",
body="function-body")
response = self.client.get('/function/list/')
assert_that(response.status_code, equal_to(HTTP_200_OK))
assert_that(response.data, has_length(2))
assert_that(
response.data,
has_item(
all_of(has_entry("id", equal_to(function_1.id)),
has_entry("name", equal_to(function_1.name)),
has_entry("body", equal_to(function_1.body)))))
assert_that(
response.data,
has_item(
all_of(has_entry("id", equal_to(function_2.id)),
has_entry("name", equal_to(function_2.name)),
has_entry("body", equal_to(function_2.body)))))
def ServerManagement_StopServerTwice_test( app ):
StartJavaCompleterServerInDirectory(
app, PathToTestFile( 'simple_eclipse_project' ) )
app.post_json(
'/run_completer_command',
BuildRequest(
filetype = 'java',
command_arguments = [ 'StopServer' ],
),
)
request_data = BuildRequest( filetype = 'java' )
assert_that( app.post_json( '/debug_info', request_data ).json,
has_entry(
'completer',
has_entry( 'servers', contains(
has_entry( 'is_running', False )
) )
) )
# Stopping a stopped server is a no-op
app.post_json(
'/run_completer_command',
BuildRequest(
filetype = 'java',
command_arguments = [ 'StopServer' ],
),
)
request_data = BuildRequest( filetype = 'java' )
assert_that( app.post_json( '/debug_info', request_data ).json,
has_entry(
'completer',
has_entry( 'servers', contains(
has_entry( 'is_running', False )
) )
) )
def test_swagger(self):
response = self.client.get("/api/swagger")
assert_that(response.status_code, is_(equal_to(200)))
data = loads(response.data)["paths"]["/foo"]["post"]
assert_that(
data["parameters"],
has_items(
has_entry(
"in",
"body",
),
has_entry(
"schema",
has_entry(
"$ref",
"#/definitions/FooRequest",
),
),
),
)
assert_that(
data["responses"],
all_of(
has_key("200"),
is_not(has_key("204")),
has_entry(
"200",
has_entry(
"schema",
has_entry(
"$ref",
"#/definitions/FooList",
),
),
),
),
)
def test_removed_unserializable(self):
import warnings
marker = object()
ext = {
'x': 1,
'y': [1, 2, marker],
'z': marker,
'a': {3, 4},
'b': {
'c': (marker, 1)
}
}
with warnings.catch_warnings(
record=True): # removed_unserializable is deprecated
assert_that(removed_unserializable((1, 2, 3)), is_([1, 2, 3]))
assert_that(removed_unserializable([[(1, 2, 3)]]),
is_([[[1, 2, 3]]]))
removed_unserializable(ext)
assert_that(ext, has_entry('x', is_(1)))
assert_that(ext, has_entry('y', is_([1, 2, None])))
assert_that(ext, has_entry('a', is_([3, 4])))
assert_that(ext, has_entry('z', is_(none())))
assert_that(ext, has_entry('b', has_entry('c', is_([None, 1]))))
def test_list_multi_tenant(main, sub):
response = confd.agents.skills.get(wazo_tenant=MAIN_TENANT)
assert_that(
response.items,
all_of(
has_item(has_entry('id', main['id'])),
not_(has_item(has_entry('id', sub['id']))),
),
)
response = confd.agents.skills.get(wazo_tenant=SUB_TENANT)
assert_that(
response.items,
all_of(
has_item(has_entry('id', sub['id'])),
not_(has_item(has_entry('id', main['id']))),
),
)
response = confd.agents.skills.get(wazo_tenant=MAIN_TENANT, recurse=True)
assert_that(
response.items,
has_items(has_entry('id', main['id']), has_entry('id', sub['id'])),
)
def test_build_document():
gapy_response = {
"metrics": {
"visits": "12345"
},
"dimensions": {
"date": "2013-04-02"
}
}
data = build_document(gapy_response, "weeklyvisits", date(2013, 4, 1))
assert_that(
data,
has_entry(
"_id",
"d2Vla2x5dmlzaXRzXzIwMTMwMzMxMjMwMDAwX3dlZWtfMjAxMy0wNC0wMg=="))
assert_that(data, has_entry("dataType", "weeklyvisits"))
assert_that(
data, has_entry("_timestamp", dt(2013, 4, 1, 0, 0, 0,
"Europe/London")))
assert_that(data, has_entry("timeSpan", "week"))
assert_that(data, has_entry("date", "2013-04-02"))
assert_that(data, has_entry("visits", 12345))
def test_given_mobile_destination_when_load_then_location_empty(self):
relocate = dict(VALID_RELOCATE)
relocate['destination'] = 'mobile'
assert_that(user_relocate_request_schema.load(relocate),
has_entry('location', {}))
def calld_is_ready():
status = integration_test.calld.status()
assert_that(status, has_entries({
'ari': has_entry('status', 'ok'),
'bus_consumer': has_entry('status', 'ok')
}))
def MessageMatcher( msg ): return has_entry( 'message', contains_string( msg ) )
