def share_with_social(self, check=True):
"""Step to share with social.
Args:
check (bool): flag whether check step or no
Raises:
AssertionError: if check is failed
"""
page = self.app.page_top_movies
page.button_share.click()
if check:
social_rows = page.list_social_share.rows
assert_that(social_rows[0].link_social.href,
starts_with('http://www.facebook.com/sharer'))
assert_that(social_rows[1].link_social.href,
starts_with('http://twitter.com/intent/tweet'))
assert_that(social_rows[2].link_social.href,
starts_with('mailto:?subject=Check'))
assert_that(social_rows[3].link_social.href,
starts_with('http://www.imdb.com/chart/top'))
social_rows[3].click()
assert_that(pyperclip.paste(),
equal_to('http://www.imdb.com/chart/top'))
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_plugin_echo_renders_node(caplog):
stream = StringIO('''
- name: test0
echo: "{{ node }}"
- name: test1
echo: "{{ node }}"
- name: test2
echo: "{{ node }}"
''')
document = loader.ordered_load(stream)
nodes = TopLevel.build(document)
context = Context()
for index, node in enumerate(nodes):
node.execute(context)
assert_that(len(caplog.records), equal_to(11))
assert_that(caplog.records[1].message,
starts_with("test%d is starting" % index))
assert_that(caplog.records[2].message,
starts_with("| %s" % platform.node()))
assert_that(caplog.records[3].message,
starts_with("test%d has finished" % index))
caplog.clear()
def test_get_cram_metadata(self):
meta_list = arrayexpress.get_cram_metadata('oryza_sativa')
assert_that(len(meta_list), greater_than(100))
first = meta_list[0]
assert_that(first.study_id, starts_with('DRP'))
assert_that(first.sample_ids[0], starts_with('SAMD'))
assert_that(first.biorep_id, starts_with('DRR'))
assert_that(first.run_ids[0], starts_with('DRR'))
assert_that(first.ftp_location, starts_with('ftp://ftp.ebi.ac.uk/pub/databases/arrayexpress/data/atlas/rnaseq'))
def test_traverse_to_nondict():
with assert_raises(ValueError) as caught:
registry.get_by_binding("some.example.here it goes bad")
assert_that(caught.exception.message,
starts_with("Cannot traverse subtree of type int"))
with assert_raises(ValueError) as caught:
registry.get_by_binding("data.here.setting.here it goes bad")
assert_that(caught.exception.message,
starts_with("Cannot traverse subtree of type list"))
def test_attaches_with_capture_exist(report_for, test):
report = report_for("""
import sys
def test_x():
sys.stdout.write('STDOUT HELLO')
sys.stderr.write('STDERR HELLO')
%s
""" % test)
assert_that(report.find('.//attachment'), contains_inanyorder(
has_entry('title', starts_with('Captured stdout')),
has_entry('title', starts_with('Captured stderr'))))
def test_traverse_to_nondict():
with assert_raises(ValueError) as caught:
registry.get_by_binding("some.example.here it goes bad")
assert_that(caught.exception.message,
starts_with("Cannot traverse subtree of type int"))
with assert_raises(ValueError) as caught:
registry.get_by_binding("data.here.setting.here it goes bad")
assert_that(caught.exception.message,
starts_with("Cannot traverse subtree of type list"))
def test_attaches_with_capture_exist(report_for, test):
report = report_for("""
import sys
def test_x():
sys.stdout.write('STDOUT HELLO')
sys.stderr.write('STDERR HELLO')
%s
""" % test)
assert_that(
report.find('.//attachment'),
contains_inanyorder(has_entry('title', starts_with('Captured stdout')),
has_entry('title',
starts_with('Captured stderr'))))
def assert_command_error(response, prefix, hint=None):
"""Verifies structure and basic content of command processor errors"""
print tostring(response)
err_el = response.find("error")
assert_that(err_el, is_not(None))
desc_el = err_el.find("desc")
assert_that(desc_el, is_not(None))
assert_that(desc_el.text, starts_with(prefix))
if hint:
hint_el = err_el.find("hint")
assert_that(hint_el, is_not(None))
assert_that(hint_el.text, starts_with(hint))
def test_create_device_null_parameters():
response = confd.devices.post(
mac=None,
template_id=None,
plugin=None,
vendor=None,
version=None,
description=None,
options=None,
)
response.assert_created('devices')
assert_that(
response.item,
has_entries(
mac=none(),
template_id=none(),
status='not_configured',
plugin=none(),
vendor=none(),
version=none(),
description=none(),
options=none(),
),
)
provd_device = provd.devices.get(response.item['id'])
assert_that(provd_device['config'], starts_with('autoprov'))
def test_basic_auth_default_realm():
"""
Basic auth uses the convention that the metadata's name is the realm.
"""
graph = create_object_graph(name="example", testing=True)
@graph.app.route("/unauthorized")
@graph.audit
@graph.basic_auth.required
def unauthorized():
raise Exception("Should not be raised!")
client = graph.app.test_client()
response = client.get("/unauthorized")
assert_that(response.status_code, is_(equal_to(401)))
data = loads(response.get_data().decode("utf-8"))
assert_that(data, has_entries(dict(
code=401,
message=starts_with("The server could not verify that you are authorized to access the URL requested"),
retryable=False,
context={"errors": []},
)))
assert_that(response.headers["WWW-Authenticate"], is_(equal_to('Basic realm="example"')))
def test_basic_auth():
"""
Basic auth prevents resource access.
"""
config = {
"BASIC_AUTH_REALM": "microcosm",
}
graph = create_object_graph(name="example", testing=True, loader=lambda metadata: config)
@graph.app.route("/unauthorized")
@graph.audit
@graph.basic_auth.required
def unauthorized():
raise Exception("Should not be raised!")
client = graph.app.test_client()
response = client.get("/unauthorized")
assert_that(response.status_code, is_(equal_to(401)))
data = loads(response.get_data().decode("utf-8"))
assert_that(data, has_entries(dict(
code=401,
message=starts_with("The server could not verify that you are authorized to access the URL requested"),
retryable=False,
context={"errors": []},
)))
assert_that(response.headers["WWW-Authenticate"], is_(equal_to('Basic realm="microcosm"')))
def test_auth_by_session(self):
response = self.deform_client.auth(
auth_type='session',
auth_key='test'
)
assert_that(response, instance_of(SessionAuthClient))
assert_that(response.auth_header, starts_with('SessionId'))
def track_edition_page(parent, number=None):
name_condition = starts_with(
"track_edition_page"
) if not number else "track_edition_page_" + str(number)
return TrackEditionPageDriver.find_single(parent, TrackEditionPage,
named(name_condition),
showing_on_screen())
def create_backup(self, volume_name, backup_name, description=None,
container=None, check=True):
"""Step to create volume backup."""
tab_volumes = self._tab_volumes()
with tab_volumes.table_volumes.row(
name=volume_name).dropdown_menu as menu:
menu.button_toggle.click()
menu.item_create_backup.click()
with tab_volumes.form_create_backup as form:
form.field_name.value = backup_name
if description is not None:
form.field_description.value = description
if container is not None:
form.field_container.value = container
form.submit()
if check:
self.close_notification('success')
row = self._tab_backups().table_backups.row(name=backup_name)
row.wait_for_status(status='Available')
if description is not None:
assert_that(row.cell('description').value,
starts_with(description[:30]))
def test_get():
response = confd.asterisk.pjsip.doc.get()
response.assert_ok()
assert_that(
response.json,
has_entries(
aor=has_entries(),
auth=has_entries(),
contact=has_entries(),
endpoint=all_of(
has_entries(direct_media_method=has_entries(
name='direct_media_method',
default='invite',
synopsis='Direct Media method type',
description=starts_with('Method for setting up'),
choices=has_entries(
invite='',
reinvite='Alias for the "invite" value.',
update='',
),
)),
not_(has_entries(type='endpoint')),
),
system=has_entries(),
transport=has_entries(),
),
)
def test_connect_timeout(self):
with self.assertRaises(ConnectTimeout) as expect:
self.client("10.0.0.0", "whatever", "whatever", connect_timeout=1)
assert_that(
str(expect.exception),
starts_with("Timed out while connecting to 10.0.0.0 on port"))
def yearly_account(context):
"""Check that the yearly membership information for an account is accurate."""
acct_repository = AccountRepository(context.db)
membership = acct_repository.get_active_account_membership(
context.accounts["foo"].id)
assert_that(membership.type, equal_to(YEARLY_MEMBERSHIP))
assert_that(membership.payment_account_id, starts_with("cus"))
def test_configure_engine():
"""
Engine factory should work with zero configuration.
"""
graph = create_object_graph(name="example", testing=True)
engine = graph.postgres
assert_that(engine, is_(instance_of(Engine)))
# engine has expected configuration
assert_that(
str(engine.url),
starts_with("postgresql://example:@"),
)
assert_that(
str(engine.url),
ends_with(":5432/example_test_db"),
)
# engine supports connections
with engine.connect() as connection:
row = connection.execute("SELECT 1;").fetchone()
assert_that(row[0], is_(equal_to(1)))
def test_get_failed_tests_returns_no_failed_tests_when_request_fails(mock_print, mock_get):
failed_tests = get_failed_tests([100, 101, 102], "test-url", "test-token")
check_mocked_functions_called(mock_get, mock_print)
assert_that(failed_tests, equal_to([]), "Failed tests should not be returned when the request failed")
request_failed_message = mock_print.call_args[0][0]
assert_that(request_failed_message, starts_with("##vso[task.logissue type=warning]No failed tests were found"))
def test_werkzeug_http_error():
"""
Explicit HTTP errors are reported as expected.
"""
graph = create_object_graph(name="example", testing=True)
@graph.app.route("/not_found")
@graph.audit
def not_found():
raise NotFound
client = graph.app.test_client()
response = client.get("/not_found")
assert_that(response.status_code, is_(equal_to(404)))
data = response.json
assert_that(
data,
has_entries(
dict(
code=404,
context={
"errors": [],
},
message=starts_with(
"The requested URL was not found on the server."),
retryable=False,
)))
def test_archive_manifest_url_request__url_with_auth(self):
url = self.archive_service.archive_manifest_url_request().set_path(
'/path/to/manifest.zip').set_ttl(600).url()
assert_that(
url,
starts_with('//archive-fish.wixmp.com/path/to/manifest.zip?auth='))
def test_column_field_can_be_marked_as_internal(engine):
Base = declarative_base()
class AuthorRecord(Base):
__tablename__ = "author"
c_id = Column(Integer, primary_key=True)
c_name = Column(Unicode, nullable=False)
class Author(SqlAlchemyObjectType):
__model__ = AuthorRecord
id = column_field(AuthorRecord.c_id, internal=True)
name = column_field(AuthorRecord.c_name)
class Root(RootType):
authors = many(lambda: select(Author))
Base.metadata.create_all(engine)
result = executor(Root)("""{
authors {
id
}
}""",
context=QueryContext(session=Session(engine)))
assert_that(
result,
is_invalid_result(errors=contains_inanyorder(
has_string(starts_with('Cannot query field "id"')), )),
)
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_dissociate_when_not_associated(line1, device1, line2, device2):
with a.line_device(line1, device1), a.line_device(line2, device2):
response = confd.lines(line1['id']).devices(device2['id']).delete()
response.assert_deleted()
provd_device1 = provd.devices.get(device1['id'])
assert_that(provd_device1['config'], not_(starts_with('autoprov')))
provd_device2 = provd.devices.get(device2['id'])
assert_that(provd_device2['config'], not_(starts_with('autoprov')))
response = confd.lines(line1['id']).get()
assert_that(response.item, has_entries(device_id=device1['id']))
response = confd.lines(line2['id']).get()
assert_that(response.item, has_entries(device_id=device2['id']))
def show_movie_details(self, movie_number, by_title=True, check=True):
"""Step to show detailed info about movie.
Args:
movie_number (int): number of movie item in movies list
by_title (bool): flag to use title link to navigate or icon link
check (bool): flag whether check step or no
Raises:
AssertionError: if check is failed
"""
page = self.app.page_top_movies
row_movie = page.table_movies.rows[movie_number]
movie_title = row_movie.link_title.value
movie_year = row_movie.label_year.value.strip('()')
movie_rating = row_movie.cell('imdb_rating').value
if by_title:
row_movie.link_title.click()
else:
row_movie.link_poster.click()
if check:
with self.app.page_movie_details as page:
assert_that(self.app.current_page, equal_to(page))
assert_that(page.label_title.value, starts_with(movie_title))
assert_that(page.link_year.value, equal_to(movie_year))
assert_that(page.label_rating.value, equal_to(movie_rating))
def test_sending_a_new_confirmation_mail(self, user):
email_uuid = user['emails'][0]['uuid']
self.client.users.request_confirmation_email(user['uuid'], email_uuid)
url = self.get_last_email_url()
url = url.replace('https://', 'http://')
result = requests.get(url)
assert_that(
result,
has_properties(
status_code=200,
headers=has_entries('Content-Type',
starts_with('text/x-test; charset=')),
text='Custom template',
),
)
updated_user = self.client.users.get(user['uuid'])
assert_that(
updated_user,
has_entries(emails=contains(
has_entries(address='*****@*****.**', confirmed=True))),
)
assert_http_error(409, self.client.users.request_confirmation_email,
user['uuid'], email_uuid)
assert_http_error(404, self.client.users.request_confirmation_email,
UNKNOWN_UUID, email_uuid)
assert_http_error(
404,
self.client.users.request_confirmation_email,
user['uuid'],
UNKNOWN_UUID,
)
def test_generate_ntiid(self):
ntiid = generate_ntiid(u'FOO', now=datetime.utcfromtimestamp(1000))
assert_that(
ntiid,
starts_with(
'tag:nextthought.com,2011-10:NTI-FOO-system_19700101001640_000000'
))
def create_backup(self, volume_name, backup_name=None, description=None,
container=None, check=True):
"""Step to create volume backup."""
backup_name = backup_name or next(utils.generate_ids('backup'))
page_volumes = self._page_volumes()
with page_volumes.table_volumes.row(
name=volume_name).dropdown_menu as menu:
menu.button_toggle.click()
menu.item_create_backup.click()
with page_volumes.form_create_backup as form:
form.field_name.value = backup_name
if description is not None:
form.field_description.value = description
if container is not None:
form.field_container.value = container
form.submit()
if check:
self.close_notification('success')
self._tab_backups().table_backups.row(
name=backup_name, status='Available').wait_for_presence(
config.UI_LONG_TIMEOUT)
row = self._tab_backups().table_backups.row(name=backup_name)
if description is not None:
assert_that(row.cell('description').value,
starts_with(description[:30]))
return backup_name
def test_list_path_with_non_leaf(self):
"""
Given
a path that contains a single non-leaf child node
When
path is listed
Then
return a single non-leaf node
"""
with patch_urlopen() as mock_urlopen:
mock_response = Mock()
mock_response.read.return_value = """
[
{
"leaf": 0,
"context": {},
"text" : "servers",
"expandable": 1,
"id": "servers",
"allowChildren": 1
}
]
"""
mock_urlopen.return_value = mock_response
result = self.ds.list_path(path=["a", "b", "c"])
T.assert_equal(1, len(result))
expected_servers_dict = {"type": "dir", "name": u"servers", "children": None}
T.assert_dicts_equal(expected_servers_dict, result[0])
mock_urlopen.assert_called_with(match(starts_with("http://dontcare.com:8080/metrics/find")))
mock_urlopen.assert_called_with(match(contains_string("query=a.b.c.*")))
def test_configure_engine():
"""
Engine factory should work with zero configuration.
"""
graph = create_object_graph(name="example", testing=True)
engine = graph.postgres
assert_that(engine, is_(instance_of(Engine)))
# engine has expected configuration
assert_that(
str(engine.url),
starts_with("postgresql://example:@"),
)
assert_that(
str(engine.url),
ends_with(":5432/example_test_db"),
)
# engine supports connections
with engine.connect() as connection:
row = connection.execute("SELECT 1;").fetchone()
assert_that(row[0], is_(equal_to(1)))
def create_snapshot(self,
volume_name,
snapshot_name=None,
description=None,
check=True):
"""Step to create volume snapshot."""
snapshot_name = snapshot_name or next(utils.generate_ids('snapshot'))
tab_volumes = self._tab_volumes()
with tab_volumes.table_volumes.row(
name=volume_name).dropdown_menu as menu:
menu.button_toggle.click()
menu.item_create_snapshot.click()
with tab_volumes.form_create_snapshot as form:
form.field_name.value = snapshot_name
if description is not None:
form.field_description.value = description
form.submit()
if check:
self.close_notification('info')
row = self._tab_snapshots().table_snapshots.row(name=snapshot_name)
row.wait_for_status('Available', timeout=config.EVENT_TIMEOUT * 2)
if description is not None:
assert_that(
row.cell('description').value,
starts_with(description[:30]))
return snapshot_name
def test_list_path_with_non_leaf(self):
"""
Given
a path that contains a single non-leaf child node
When
path is listed
Then
return a single non-leaf node
"""
with patch_urlopen() as mock_urlopen:
mock_response = Mock()
mock_response.read.return_value = """
[
{
"leaf": 0,
"context": {},
"text" : "servers",
"expandable": 1,
"id": "servers",
"allowChildren": 1
}
]
"""
mock_urlopen.return_value = mock_response
result = self.ds.list_path(path=['a','b','c'])
T.assert_equal(1, len(result))
expected_servers_dict = {'type': 'dir', 'name': u'servers', 'children': None}
T.assert_dicts_equal(expected_servers_dict, result[0])
mock_urlopen.assert_called_with(match(starts_with('http://dontcare.com:8080/metrics/find')))
mock_urlopen.assert_called_with(match(contains_string('query=a.b.c.*')))
def check_dissociate(line, device):
with a.line_device(line, device, check=False):
response = confd.lines(line['id']).devices(device['id']).delete()
response.assert_deleted()
provd_device = provd.devices.get(device['id'])
assert_that(provd_device['config'], starts_with('autoprov'))
def assert_provd_config(user, line, provd_config):
assert_that(
provd_config,
has_entries(
id=is_not(starts_with('autoprov')),
configdevice='defaultconfigdevice',
deletable=True,
parent_ids=has_items('base', 'defaultconfigdevice'),
raw_config=has_entries(
X_key='',
config_version=1,
X_xivo_user_uuid=user['uuid'],
X_xivo_phonebook_profile=line['context'],
exten_dnd='*25',
exten_fwd_unconditional='*21',
exten_fwd_no_answer='*22',
exten_fwd_busy='*23',
exten_fwd_disable_all='*20',
exten_pickup_call='*8',
exten_voicemail='*98',
exten_park=none(),
exten_pickup_group=none(),
),
),
)
def test_signals_project_to_open_when_open_action_triggered(driver, using):
signal = ValueMatcherProbe("open project", "project.tgit")
_ = show_page(make_project_history(make_snapshot(name="project", path="project.tgit")),
on_load_project=signal.received)
driver.open_recent_project(starts_with("project"), using=using)
driver.check(signal)
def test_auth_by_token_with_project_id(self):
response = self.deform_client.auth(
auth_type='token',
auth_key='test',
project_id='some_project'
)
assert_that(response, instance_of(ProjectClient))
assert_that(response.auth_header, starts_with('Token'))
def test_list(self):
NodeFactory(name='foo-node-1')
NodeFactory(name='foo-node-2')
status_code, json_response = self.get()
assert_that(status_code, is_(200))
assert_that(len(json_response), is_(2))
assert_that(json_response[0]['name'], starts_with('foo-node'))
def test_page_contents():
"""The setup page should appear correctly."""
assert_that(browser.url, ends_with("#/setup"))
assert_that(browser.title, starts_with("Dashboard Creation |"))
header = browser.find_by_css("body > .content-holder > .container > h1")
assert_that(header.first.text, is_("Dashboard Creation"))
assert browser.is_text_present(STEP_TITLES[1])
def test_called_ok_explicitly_twice_fail(desc):
expected = 'was called 3 times'
matcher = called_n_times(2)
mock = Mock()
mock()
mock()
mock()
ok = matcher.matches(mock, desc)
assert_that(ok, equal_to(False))
assert_that(str(desc), starts_with(expected))
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_submit_task(self):
task = SubmitToEna(species='oryza_sativa', study_id='DRP000315', sample_ids=['SAMD00009892', 'SAMD00009893'],
biorep_id='E-GEOD-35288', run_ids=['DRR000745', 'DRR000746'], assembly_used='IRGSP-1.0',
ftp_location='ftp://ftp.ebi.ac.uk/pub/databases/arrayexpress/data/atlas/rnaseq/DRR016/DRR016438/DRR016438.cram',
test=True)
has_completed = luigi.build([task], local_scheduler=True)
assert_that(has_completed, is_(True))
output = task.output().open('r').read()
expected = '\t'.join(['E-GEOD-35288', 'oryza_sativa',
'ftp://ftp.ebi.ac.uk/pub/databases/arrayexpress/data/atlas/rnaseq/DRR016/DRR016438/DRR016438.cram',
'298b38e7ab3342bd3b7c5c9fac07422c'])
assert_that(output, starts_with(expected))
assert_that(output, contains_string('\tERA'))
def test_spotlightify_handles_department_and_agency(self):
agency = AgencyWithDepartmentFactory()
self.dashboard.organisation = agency
self.dashboard.validate_and_save()
assert_that(
self.dashboard.spotlightify(),
has_entry(
'department',
has_entries({
'title': starts_with('department'),
'abbr': starts_with('abbreviation')
})
)
)
assert_that(
self.dashboard.spotlightify(),
has_entry(
'agency',
has_entries({
'title': starts_with('agency'),
'abbr': starts_with('abbreviation')
})
)
)
def test_request_has_correct_headers(self, mock_request):
mock_request.__name__ = 'request'
client = BaseClient('http://admin.api', 'token')
client._get('/foo')
mock_request.assert_called_with(
'GET',
'http://admin.api/foo',
headers=match_equality(has_entries({
'Accept': 'application/json',
'Authorization': 'Bearer token',
'User-Agent': starts_with('Performance Platform Client'),
})),
data=None,
)
def test_post_has_content_type_header(self, mock_request):
mock_request.__name__ = 'request'
client = BaseClient('http://admin.api', 'token')
client._post('/foo', 'bar')
mock_request.assert_called_with(
'POST',
'http://admin.api/foo',
headers = match_equality(has_entries({
'Accept': 'application/json',
'Authorization': 'Bearer token',
'User-Agent': starts_with('Performance Platform Client'),
'Content-Type': 'application/json',
})),
data='bar',
)
def test_class_level_list_for_spotlight_returns_minimal_json_array(self):
dashboard_two = DashboardFactory()
organisation = ServiceFactory()
dashboard_two.organisation = organisation
dashboard_two.service_cache = organisation
agency = organisation.parents.first()
dashboard_two.agency_cache = agency
dashboard_two.department_cache = agency.parents.first()
dashboard_two.validate_and_save()
DashboardFactory(published=False)
list_for_spotlight = Dashboard.list_for_spotlight()
assert_that(list_for_spotlight['page-type'], equal_to('browse'))
assert_that(len(list_for_spotlight['items']), equal_to(2))
assert_that(list_for_spotlight['items'][0],
has_entries({
'slug': starts_with('slug'),
'title': 'title',
'dashboard-type': 'transaction'
}))
assert_that(list_for_spotlight['items'][1],
has_entries({
'slug': starts_with('slug'),
'title': 'title',
'dashboard-type': 'transaction',
'department': has_entries({
'title': starts_with('department'),
'abbr': starts_with('abbreviation')
}),
'agency': has_entries({
'title': starts_with('agency'),
'abbr': starts_with('abbreviation')
}),
'service': has_entries({
'title': starts_with('service'),
'abbr': starts_with('abbreviation')
})
}))
def test_list_dashboards_lists_dashboards(self):
DashboardFactory(
slug='dashboard',
title='Dashboard',
status='published'
)
resp = self.client.get(
'/dashboards',
HTTP_AUTHORIZATION='Bearer development-oauth-access-token')
response_object = json.loads(resp.content)
public_url = ('http://spotlight.dev.gov.uk/performance/dashboard')
internal_url = ('http://stagecraft.dev.gov.uk/dashboard/')
base_expectation = {
'title': 'Dashboard',
'public-url': public_url,
'published': True,
}
assert_that(response_object[0], has_entries(base_expectation))
assert_that(response_object[0], has_key('id'))
assert_that(response_object[0]['url'], starts_with(internal_url))
def test_data_single_metric(self):
sources = [["servers", "admin1", "loadavg", "01"]]
start = 1391047920
end = 1391048100
with patch_urlopen() as mock_urlopen:
mock_response = Mock()
mock_response.read.return_value = """
[
{
"target": "servers.admin1.loadavg.01",
"datapoints": [
[2.0, 1391047920],
[6.0, 1391047980],
[9.0, 1391048040],
[null,1391048100]
]
}
]
"""
mock_urlopen.return_value = mock_response
result_json = self.ds.data(sources, start, end, width=100)
expected_results = [
{"t": 1391047920, "v": [2.0]},
{"t": 1391047980, "v": [6.0]},
{"t": 1391048040, "v": [9.0]},
{"t": 1391048100, "v": [None]},
]
result_list = json.loads(result_json)
T.assert_equal(4, len(result_list))
for i, expected_result in enumerate(expected_results):
T.assert_dicts_equal(expected_result, result_list[i])
mock_urlopen.assert_called_with(match(starts_with("http://dontcare.com:8080/render")))
mock_urlopen.assert_called_with(match(contains_string(".".join(sources[0]))))
def select_identity(self, name):
self.is_active()
self.results_list.select_item(with_item_text(starts_with(name)))
def assert_device_has_autoprov_config(self, device):
assert_that(device[u'config'], starts_with(u'autoprov'))
def external_hostname_is_not_local(provider):
with provider.start(_IMAGE_NAME) as machine:
hostname = machine.external_hostname()
assert_that(hostname, hamcrest.is_not(hamcrest.equal_to("localhost")))
assert_that(hostname, hamcrest.is_not(hamcrest.starts_with("127")))
def test_gives_a_graph_representation_of_itself(self):
start = self.build_workflow_def()
g = StringIO()
start.write_graph(g)
assert_that(g.getvalue(), starts_with("digraph Test"))
def test_connect_timeout(self):
with self.assertRaises(ConnectTimeout) as expect:
self.client("10.0.0.0", "whatever", "whatever", connect_timeout=1)
assert_that(str(expect.exception), starts_with("Timed out while connecting to 10.0.0.0 on port"))
def test_get_type_fields(self):
t = UnityType(_id='type')
assert_that(t.fields_str, starts_with(
'name,description,documentation,type,attributes.name'))
def test_get_minute_folders(self):
folders = list(get_minute_folders('root'))
for folder in folders:
assert_that(folder, starts_with('root'))
assert_that(folder, ends_with('minline'))
def test_fields_str(self):
t = UnityType(_id='lun', cli=t_rest())
assert_that(t.fields_str, starts_with('auSize,creationTime,'))
def test_should_pass_username_to_dispatcher(self):
service = ServiceBase(mvip="127.0.0.1",
api_version=9.0,
username="******")
assert_that(service._dispatcher._credentials,
starts_with("fake_username"))