def test_setting_default_color_collection(sdk: mtds.Looker40SDK):
"""Given a color collection id, set_default_color_collection() should change the default collection."""
original = sdk.default_color_collection()
assert isinstance(original, ml.ColorCollection)
assert isinstance(original.id, str)
color_collections = sdk.all_color_collections()
other: ml.ColorCollection = next(
filter(lambda c: c.id != original.id, color_collections))
assert isinstance(other.id, str)
actual = sdk.set_default_color_collection(other.id)
assert actual.id == other.id
updated = sdk.set_default_color_collection(original.id)
assert updated.id == original.id
def test_it_updates_session(sdk: mtds.Looker40SDK):
"""update_session() should allow us to change the current workspace."""
# Switch workspace to dev mode
sdk.update_session(ml.WriteApiSession(workspace_id="dev"))
current_session = sdk.session()
assert isinstance(current_session, ml.ApiSession)
assert current_session.workspace_id == "dev"
# Switch workspace back to production
current_session = sdk.update_session(
ml.WriteApiSession(workspace_id="production"))
assert isinstance(current_session, ml.ApiSession)
assert current_session.workspace_id == "production"
def test_netrc_does_not_override_ini_creds(sdk: mtds.Looker40SDK):
"""The requests library overrides HTTP authorization headers if the auth= parameter
is not specified, resulting in an authentication error. This test makes sure this
does not happen when netrc files are found on the system.
"""
me = sdk.me()
assert isinstance(me, ml.User)
def test_me_returns_correct_result(sdk: mtds.Looker40SDK):
"""me() should return the current authenticated user"""
me = sdk.me()
assert isinstance(me, ml.User)
assert isinstance(me.credentials_api3, list)
assert len(me.credentials_api3) > 0
assert isinstance(me.credentials_api3[0], ml.CredentialsApi3)
def get_looker_version(looker_client: methods.Looker40SDK) -> str:
"""Checks the version for the Looker instance.
Returns:
The current Looker version for the instance.
"""
return looker_client.versions(
fields='looker_release_version').looker_release_version
def test_search_looks_returns_looks(sdk: mtds.Looker40SDK):
"""search_looks() should return a list of looks."""
search_results = sdk.search_looks()
assert isinstance(search_results, list)
assert len(search_results) > 0
look = search_results[0]
assert isinstance(look, ml.Look)
assert look.title != ""
assert look.created_at is not None
def test_enum(sdk: mtds.Looker40SDK):
# TODO: there is currently no example in the Looker API of a "bare"
# ForwardRef property on a model that is returned by the API. We
# have unittests deserializing into "bare" ForwardRef properties,
# that will have to do for now.
query = ml.WriteQuery(
model="system__activity",
view="dashboard",
fields=["dashboard.id", "dashboard.title", "dashboard.count"],
)
query_id = sdk.create_query(query).id
assert query_id
task = ml.WriteCreateQueryTask(query_id=query_id,
source="test",
result_format=ml.ResultFormat.csv)
created = sdk.create_query_task(task)
# created.result_format is type str, not ResultFormat.csv
assert ml.ResultFormat.csv.value == created.result_format
def test_search_looks_title_fields_filter(sdk: mtds.Looker40SDK):
"""search_looks() should be able to filter on title."""
search_results = sdk.search_looks(title="An SDK%", fields="id, title")
assert isinstance(search_results, list)
assert len(search_results) > 0
look = search_results[0]
assert isinstance(look.id, int)
assert look.id > 0
assert "SDK" in look.title
assert look.description is None
def create_test_users(sdk40: methods40.Looker40SDK,
users: List[Dict[str, str]], email_domain: str):
user_ids: List[int] = []
for u in users:
# TODO: if the test crashes it doesn't clean up the users.
user = sdk40.create_user(
models40.WriteUser(first_name=u["first_name"],
last_name=u["last_name"]))
if user.id:
user_ids.append(user.id)
email = f"{u['first_name']}.{u['last_name']}{email_domain}"
sdk40.create_user_credentials_email(
user.id, models40.WriteCredentialsEmail(email=email))
yield
for user_id in user_ids:
sdk40.delete_user(user_id)
def test_search_looks_fields_filter(sdk: mtds.Looker40SDK):
"""search_looks() should only return the requested fields passed in the fields
argument of the request.
"""
search_results = sdk.search_looks(fields="id, title, description")
assert isinstance(search_results, list)
assert len(search_results) > 0
look = search_results[0]
assert isinstance(look, ml.Look)
assert look.title is not None
assert look.created_at is None
def test_it_runs_inline_query(sdk: mtds.Looker40SDK,
queries_system_activity: TQueries):
"""run_inline_query() should run a query and return its results."""
for q in queries_system_activity:
limit = cast(str, q["limit"]) or "10"
request = create_query_request(q, limit)
json_resp = sdk.run_inline_query("json", request)
assert isinstance(json_resp, str)
json_: List[Dict[str, Any]] = json.loads(json_resp)
assert len(json_) == int(limit)
row = json_[0]
if q.get("fields"):
for field in q["fields"]:
assert field in row.keys()
csv = sdk.run_inline_query("csv", request)
assert isinstance(csv, str)
assert len(re.findall(r"\n", csv)) == int(limit) + 1
def test_me_field_filters(sdk: mtds.Looker40SDK):
"""me() should return only the requested fields."""
me = sdk.me("id, first_name, last_name")
assert isinstance(me, ml.User)
assert isinstance(me.id, int)
assert isinstance(me.first_name, str)
assert me.first_name != ""
assert isinstance(me.last_name, str)
assert me.last_name != ""
assert not me.display_name
assert not me.email
assert not me.personal_folder_id
def test_search_look_and_run(sdk: mtds.Looker40SDK):
"""run_look() should return CSV and JSON
CSV will use column descriptions
JSON will use column names
JSON_LABEL will use column descriptions
"""
search_results = sdk.search_looks(title="An SDK Look", fields="id, title")
assert isinstance(search_results, list)
assert len(search_results) > 0
look = search_results[0]
assert isinstance(look.id, int)
assert look.id > 0
assert "SDK" in look.title
assert look.description is None
actual = sdk.run_look(look_id=look.id, result_format="csv")
assert "Dashboard Count" in actual
assert "Dashboard ID" in actual
actual = sdk.run_look(look_id=look.id, result_format="json")
assert "dashboard.count" in actual
assert "dashboard.id" in actual
actual = sdk.run_look(look_id=look.id, result_format="json_label")
assert "Dashboard Count" in actual
assert "Dashboard ID" in actual
def test_it_matches_email_domain_and_returns_sorted(sdk: mtds.Looker40SDK,
email_domain: str,
users: List[Dict[str,
str]]):
"""search_users_names() should search users matching a given pattern and return
sorted results if sort fields are specified.
"""
search_results = sdk.search_users_names(pattern=f"%{email_domain}",
sorts="last_name, first_name")
assert len(search_results) == len(users)
sorted_test_data: List[Dict[str, str]] = sorted(users,
key=itemgetter(
"last_name",
"first_name"))
for actual, expected in zip(search_results, sorted_test_data):
assert actual.first_name == expected["first_name"]
assert actual.last_name == expected["last_name"]
def test_crud_look(sdk: mtds.Looker40SDK, looks):
"""Test creating, retrieving, updating and deleting a look."""
for l in looks:
request = create_query_request(l["query"][0], "10")
query = sdk.create_query(request)
look = sdk.create_look(
ml.WriteLookWithQuery(
title=l.get("title"),
description=l.get("description"),
deleted=l.get("deleted"),
is_run_on_load=l.get("is_run_on_load"),
public=l.get("public"),
query_id=query.id,
folder_id=l.get("folder_id")
or str(sdk.me().personal_folder_id),
))
assert isinstance(look, ml.LookWithQuery)
assert look.title == l.get("title")
assert look.description == l.get("description")
assert look.deleted == l.get("deleted")
assert look.is_run_on_load == l.get("is_run_on_load")
# TODO this is broken for local dev but works for CI...
# assert look.public == l.get("public")
assert look.query_id == query.id
assert look.folder_id == l.get("folder_id") or sdk.me().home_folder_id
assert look.user_id == l.get("user_id") or sdk.me().id
# Update
assert isinstance(look.id, int)
updated_look = sdk.update_look(look.id,
ml.WriteLookWithQuery(deleted=True))
assert updated_look.deleted
assert updated_look.title == look.title
look = sdk.update_look(look.id, ml.WriteLookWithQuery(deleted=False))
assert not look.deleted
def test_crud_dashboard(sdk: mtds.Looker40SDK, queries_system_activity,
dashboards):
"""Test creating, retrieving, updating and deleting a dashboard.
"""
qhash: Dict[Union[str, int], ml.Query] = {}
for idx, q in enumerate(queries_system_activity):
limit = "10"
request = create_query_request(q, limit)
key = q.get("id") or str(idx)
qhash[key] = sdk.create_query(request)
for d in dashboards:
dashboard = sdk.create_dashboard(
ml.WriteDashboard(
description=d.get("description"),
hidden=d.get("hidden"),
query_timezone=d.get("query_timezone"),
refresh_interval=d.get("refresh_interval"),
title=d.get("title"),
background_color=d.get("background_color"),
load_configuration=d.get("load_configuration"),
lookml_link_id=d.get("lookml_link_id"),
show_filters_bar=d.get("show_filters_bar"),
show_title=d.get("show_title"),
slug=d.get("slug"),
folder_id=d.get("folder_id") or sdk.me().home_folder_id,
text_tile_text_color=d.get("text_tile_text_color"),
tile_background_color=d.get("tile_background_color"),
tile_text_color=d.get("tile_text_color"),
title_color=d.get("title_color"),
))
assert isinstance(dashboard, ml.Dashboard)
if d.get("background_color"):
assert d["background_color"] == dashboard.background_color
if d.get("text_tile_text_color"):
assert d["text_tile_text_color"] == dashboard.text_tile_text_color
if d.get("tile_background_color"):
assert d[
"tile_background_color"] == dashboard.tile_background_color
if d.get("tile_text_color"):
assert d["tile_text_color"] == dashboard.tile_text_color
if d.get("title_color"):
assert d["title_color"] == dashboard.title_color
# Update dashboard
assert isinstance(dashboard.id, str)
update_response = sdk.update_dashboard(dashboard.id,
ml.WriteDashboard(deleted=True))
assert update_response.deleted
assert update_response.title == dashboard.title
dashboard = sdk.update_dashboard(dashboard.id,
ml.WriteDashboard(deleted=False))
assert isinstance(dashboard.id, str)
assert not dashboard.deleted
if d.get("filters"):
for f in d["filters"]:
filter = sdk.create_dashboard_filter(
ml.WriteCreateDashboardFilter(
dashboard_id=dashboard.id,
name=f.get("name"),
title=f.get("title"),
type=f.get("type"),
default_value=f.get("default_value"),
model=f.get("model"),
explore=f.get("explore"),
dimension=f.get("dimension"),
row=f.get("row"),
listens_to_filters=f.get("listens_to_filters"),
allow_multiple_values=f.get("allow_multiple_values"),
required=f.get("required"),
))
assert isinstance(filter, ml.DashboardFilter)
assert filter.name == f.get("name")
assert filter.title == f.get("title")
assert filter.type == f.get("type")
assert filter.default_value == f.get("default_value")
assert filter.model == f.get("model")
assert filter.explore == f.get("explore")
assert filter.dimension == f.get("dimension")
assert filter.row == f.get("row")
assert filter.allow_multiple_values == f.get(
"allow_multiple_values", False)
assert filter.required == f.get("required", False)
if d.get("tiles"):
for t in d["tiles"]:
tile = sdk.create_dashboard_element(
ml.WriteDashboardElement(
body_text=t.get("body_text"),
dashboard_id=dashboard.id,
look=t.get("look"),
look_id=t.get("look_id"),
merge_result_id=t.get("merge_result_id"),
note_display=t.get("note_display"),
note_state=t.get("note_state"),
note_text=t.get("note_text"),
query=t.get("query"),
query_id=get_query_id(qhash, t.get("query_id")),
refresh_interval=t.get("refresh_interval"),
subtitle_text=t.get("subtitle_text"),
title=t.get("title"),
title_hidden=t.get("title_hidden"),
type=t.get("type"),
))
assert isinstance(tile, ml.DashboardElement)
assert tile.dashboard_id == dashboard.id
assert tile.title == t.get("title")
assert tile.type == t.get("type")
def remove_test_looks(sdk40: methods40.Looker40SDK, looks):
for l in looks:
search_results = sdk40.search_looks(title=l["title"])
if len(search_results) > 0:
for look in search_results:
sdk40.delete_look(cast(int, look.id))
def test_bad_user_search_returns_no_results(sdk: mtds.Looker40SDK):
"""search_users() should return an empty list when no match is found."""
resp = sdk.search_users(first_name="Bad", last_name="News")
assert isinstance(resp, list)
assert len(resp) == 0
def test_crud_user(sdk: mtds.Looker40SDK):
"""Test creating, retrieving, updating and deleting a user."""
# Create user
user = sdk.create_user(
ml.WriteUser(
first_name=TEST_FIRST_NAME,
last_name=TEST_LAST_NAME,
is_disabled=False,
locale="fr",
))
assert isinstance(user, ml.User)
assert isinstance(user.id, int)
assert user.first_name == TEST_FIRST_NAME
assert user.last_name == TEST_LAST_NAME
assert not user.is_disabled
assert user.locale == "fr"
# sudo checks
user_id = user.id
sdk.login_user(user_id)
user = sdk.me()
assert user.first_name == TEST_FIRST_NAME
assert user.last_name == TEST_LAST_NAME
sdk.logout()
user = sdk.me()
assert user.first_name != TEST_FIRST_NAME
assert user.last_name != TEST_LAST_NAME
# Update user and check fields we didn't intend to change didn't change
update_user = ml.WriteUser(is_disabled=True, locale="uk")
sdk.update_user(user_id, update_user)
user = sdk.user(user_id)
assert user.first_name == TEST_FIRST_NAME
assert user.last_name == TEST_LAST_NAME
assert user.locale == "uk"
assert user.is_disabled
# Update user and check fields we intended to wipe out are now None
# first way to specify nulling out a field
update_user = ml.WriteUser(first_name=ml.EXPLICIT_NULL)
# second way
update_user.last_name = ml.EXPLICIT_NULL
sdk.update_user(user_id, update_user)
user = sdk.user(user_id)
assert user.first_name == ""
assert user.last_name == ""
# Try adding email creds
sdk.create_user_credentials_email(
user_id, ml.WriteCredentialsEmail(email="*****@*****.**"))
user = sdk.user(user_id)
assert isinstance(user.credentials_email, ml.CredentialsEmail)
assert user.credentials_email.email == "*****@*****.**"
# Delete user
resp = sdk.delete_user(user_id)
assert resp == ""
def test_it_retrieves_session(sdk: mtds.Looker40SDK):
"""session() should return the current session."""
current_session = sdk.session()
assert current_session.workspace_id == "production"
