def test_get_udp(requests_mock):
requests_mock.get(API_URL, json={"api_version": "1.0.0"})
conn = Connection(API_URL)
udp = conn.user_defined_process('evi')
assert udp.user_defined_process_id == 'evi'
def test_load_collection_arguments_040(requests_mock):
requests_mock.get(API_URL, json={"api_version": "0.4.0"})
conn = Connection(API_URL)
requests_mock.get(API_URL + "collections/FOO",
json={
"properties": {
"eo:bands": [{
"name": "red"
}, {
"name": "green"
}, {
"name": "blue"
}]
}
})
spatial_extent = {"west": 1, "south": 2, "east": 3, "north": 4}
temporal_extent = ["2019-01-01", "2019-01-22"]
im = conn.load_collection("FOO",
spatial_extent=spatial_extent,
temporal_extent=temporal_extent,
bands=["red", "green"])
node = im.graph[im.node_id]
assert node["process_id"] == "load_collection"
assert node["arguments"] == {
"id": "FOO",
"spatial_extent": spatial_extent,
"temporal_extent": temporal_extent,
"bands": ["red", "green"]
}
def test_load_collection_arguments_100(requests_mock):
requests_mock.get(API_URL, json={"api_version": "1.0.0"})
conn = Connection(API_URL)
requests_mock.get(API_URL + "collections/FOO",
json={
"summaries": {
"eo:bands": [{
"name": "red"
}, {
"name": "green"
}, {
"name": "blue"
}]
}
})
spatial_extent = {"west": 1, "south": 2, "east": 3, "north": 4}
temporal_extent = ["2019-01-01", "2019-01-22"]
im = conn.load_collection("FOO",
spatial_extent=spatial_extent,
temporal_extent=temporal_extent,
bands=["red", "green"])
assert im._pg.process_id == "load_collection"
assert im._pg.arguments == {
"id": "FOO",
"spatial_extent": spatial_extent,
"temporal_extent": temporal_extent,
"bands": ["red", "green"]
}
def test_authenticate_oidc_100_single_implicit(requests_mock):
requests_mock.get(API_URL, json={"api_version": "1.0.0"})
client_id = "myclient"
requests_mock.get(API_URL + 'credentials/oidc',
json={
"providers": [{
"id": "fauth",
"issuer": "https://fauth.test",
"title": "Foo Auth",
"scopes": ["openid", "im"]
}]
})
oidc_mock = OidcMock(
requests_mock=requests_mock,
expected_grant_type="authorization_code",
expected_client_id=client_id,
expected_fields={"scope": "im openid"},
oidc_discovery_url=
"https://fauth.test/.well-known/openid-configuration",
scopes_supported=["openid", "im"],
)
# With all this set up, kick off the openid connect flow
conn = Connection(API_URL)
assert isinstance(conn.auth, NullAuth)
conn.authenticate_OIDC(client_id=client_id,
webbrowser_open=oidc_mock.webbrowser_open)
assert isinstance(conn.auth, BearerAuth)
assert conn.auth.bearer == 'oidc/fauth/' + oidc_mock.state["access_token"]
def test_capabilities_caching(requests_mock):
m = requests_mock.get("https://oeo.test/", json={"api_version": "1.0.0"})
con = Connection(API_URL)
assert con.capabilities().api_version() == "1.0.0"
assert m.call_count == 1
assert con.capabilities().api_version() == "1.0.0"
assert m.call_count == 1
def test_authenticate_oidc_100_multiple_wrong_id(requests_mock):
requests_mock.get(API_URL, json={"api_version": "1.0.0"})
client_id = "myclient"
requests_mock.get(API_URL + 'credentials/oidc',
json={
"providers": [
{
"id": "fauth",
"issuer": "https://fauth.test",
"title": "Foo Auth",
"scopes": ["openid", "w"]
},
{
"id": "bauth",
"issuer": "https://bauth.test",
"title": "Bar Auth",
"scopes": ["openid", "w"]
},
]
})
# With all this set up, kick off the openid connect flow
conn = Connection(API_URL)
assert isinstance(conn.auth, NullAuth)
match = r"'lol' not available\. Should be one of \[('fauth', 'bauth'|'bauth', 'fauth')\]\."
with pytest.raises(OpenEoClientException, match=match):
conn.authenticate_OIDC(client_id=client_id,
provider_id="lol",
webbrowser_open=pytest.fail)
def test_create_public_udp(requests_mock):
requests_mock.get(API_URL, json={"api_version": "1.0.0"})
requests_mock.get(API_URL + "processes",
json={"processes": [{
"id": "add"
}]})
conn = Connection(API_URL)
new_udp = load_json_resource("data/1.0.0/udp_details.json")
def check_body(request):
body = request.json()
assert body['process_graph'] == new_udp['process_graph']
assert body['parameters'] == new_udp['parameters']
assert body['public']
return True
adapter = requests_mock.put(API_URL + "process_graphs/evi",
additional_matcher=check_body)
conn.save_user_defined_process(user_defined_process_id='evi',
process_graph=new_udp['process_graph'],
parameters=new_udp['parameters'],
public=True)
assert adapter.called
def test_execute_100(requests_mock):
requests_mock.get(API_URL, json={"api_version": "1.0.0"})
conn = Connection(API_URL)
with mock.patch.object(conn, "request") as request:
conn.execute({"foo1": {"process_id": "foo"}})
assert request.call_args_list == [
mock.call("post", path="/result", json={"process": {"process_graph": {"foo1": {"process_id": "foo"}}}})
]
def test_list_file_formats(requests_mock):
requests_mock.get(API_URL, json={"api_version": "1.0.0"})
conn = Connection(API_URL)
file_formats = {
"input": {"GeoJSON": {"gis_data_type": ["vector"]}},
"output": {"GTiff": {"gis_data_types": ["raster"]}},
}
requests_mock.get(API_URL + "file_formats", json=file_formats)
assert conn.list_file_formats() == file_formats
def test_authenticate_oidc_resource_owner_password_credentials(requests_mock):
requests_mock.get(API_URL, json={"api_version": "1.0.0"})
client_id = "myclient"
client_secret = "$3cr3t"
username, password = "******", "j0hn"
issuer = "https://oidc.test"
oidc_discovery_url = "https://oidc.test/.well-known/openid-configuration"
requests_mock.get(API_URL + 'credentials/oidc',
json={
"providers": [{
"id": "oi",
"issuer": issuer,
"title": "example",
"scopes": ["openid"]
}]
})
oidc_mock = OidcMock(
requests_mock=requests_mock,
expected_grant_type="password",
expected_client_id=client_id,
expected_fields={
"username": username,
"password": password,
"scope": "openid",
"client_secret": client_secret
},
oidc_discovery_url=oidc_discovery_url,
)
# With all this set up, kick off the openid connect flow
refresh_token_store = mock.Mock()
conn = Connection(API_URL, refresh_token_store=refresh_token_store)
assert isinstance(conn.auth, NullAuth)
conn.authenticate_oidc_resource_owner_password_credentials(
client_id=client_id,
username=username,
password=password,
client_secret=client_secret)
assert isinstance(conn.auth, BearerAuth)
assert conn.auth.bearer == 'oidc/oi/' + oidc_mock.state["access_token"]
assert refresh_token_store.mock_calls == []
# Again but store refresh token
conn.authenticate_oidc_resource_owner_password_credentials(
client_id=client_id,
username=username,
password=password,
client_secret=client_secret,
store_refresh_token=True)
assert isinstance(conn.auth, BearerAuth)
assert conn.auth.bearer == 'oidc/oi/' + oidc_mock.state["access_token"]
assert refresh_token_store.mock_calls == [
mock.call.set_refresh_token(
client_id=client_id,
issuer=issuer,
refresh_token=oidc_mock.state["refresh_token"])
]
def test_connection_with_session():
session = mock.Mock()
response = session.request.return_value
response.status_code = 200
response.json.return_value = {"foo": "bar", "api_version": "0.4.0"}
conn = Connection("https://oeo.net/", session=session)
assert conn.capabilities().capabilities["foo"] == "bar"
session.request.assert_any_call(
url="https://oeo.net/", method="get", headers=mock.ANY, stream=mock.ANY, auth=mock.ANY, timeout=None
)
def test_authenticate_oidc_100_single_wrong_id(requests_mock):
requests_mock.get(API_URL, json={"api_version": "1.0.0"})
client_id = "myclient"
requests_mock.get(API_URL + 'credentials/oidc', json={
"providers": [{"id": "foidc", "issuer": "https://auth.foidc.net", "title": "FOIDC", "scopes": ["openid", "w"]}]
})
# With all this set up, kick off the openid connect flow
conn = Connection(API_URL)
assert isinstance(conn.auth, NullAuth)
with pytest.raises(OpenEoClientException, match=r"'nopenope' not available\. Should be one of \['foidc'\]\."):
conn.authenticate_OIDC(client_id=client_id, provider_id="nopenope", webbrowser_open=pytest.fail)
def test_api_error_non_json(requests_mock):
requests_mock.get('https://oeo.net/', json={"api_version": "0.4.0"})
conn = Connection(API_URL)
requests_mock.get('https://oeo.net/collections/foobar', status_code=500, text="olapola")
with pytest.raises(OpenEoApiError) as exc_info:
conn.describe_collection("foobar")
exc = exc_info.value
assert exc.http_status_code == 500
assert exc.code == "unknown"
assert exc.message == "olapola"
assert exc.id is None
assert exc.url is None
def test_list_udps(requests_mock):
requests_mock.get(API_URL, json={"api_version": "1.0.0"})
conn = Connection(API_URL)
udp = load_json_resource("data/1.0.0/udp_details.json")
requests_mock.get(API_URL + "process_graphs", json={'processes': [udp]})
user_udps = conn.list_user_defined_processes()
assert len(user_udps) == 1
assert user_udps[0] == udp
def test_authenticate_basic(requests_mock):
conn = Connection(API_URL)
def text_callback(request, context):
assert request.headers["Authorization"] == "Basic am9objpqMGhu"
return '{"access_token":"w3lc0m3"}'
requests_mock.get('https://oeo.net/credentials/basic', text=text_callback)
assert isinstance(conn.auth, NullAuth)
conn.authenticate_basic(username="******", password="******")
assert isinstance(conn.auth, BearerAuth)
assert conn.auth.bearer == "w3lc0m3"
def test_api_error(requests_mock):
requests_mock.get('https://oeo.net/', json={"api_version": "0.4.0"})
conn = Connection(API_URL)
requests_mock.get('https://oeo.net/collections/foobar', status_code=404, json={
"code": "CollectionNotFound", "message": "No such things as a collection 'foobar'", "id": "54321"
})
with pytest.raises(OpenEoApiError) as exc_info:
conn.describe_collection("foobar")
exc = exc_info.value
assert exc.http_status_code == 404
assert exc.code == "CollectionNotFound"
assert exc.message == "No such things as a collection 'foobar'"
assert exc.id == "54321"
assert exc.url is None
def test_authenticate_oidc(oidc_test_setup):
# see test/rest/conftest.py for `oidc_test_setup` fixture
client_id = "myclient"
oidc_discovery_url = "https://oeo.net/credentials/oidc"
state, webbrowser_open = oidc_test_setup(
client_id=client_id, oidc_discovery_url=oidc_discovery_url)
# With all this set up, kick off the openid connect flow
conn = Connection(API_URL)
assert isinstance(conn.auth, NullAuth)
conn.authenticate_OIDC(client_id=client_id,
webbrowser_open=webbrowser_open)
assert isinstance(conn.auth, BearerAuth)
assert conn.auth.bearer == state["access_token"]
def test_authenticate_oidc_device_flow(requests_mock):
requests_mock.get(API_URL, json={"api_version": "1.0.0"})
client_id = "myclient"
client_secret = "$3cr3t"
issuer = "https://oidc.test"
oidc_discovery_url = "https://oidc.test/.well-known/openid-configuration"
requests_mock.get(API_URL + 'credentials/oidc',
json={
"providers": [{
"id": "oi",
"issuer": issuer,
"title": "example",
"scopes": ["openid"]
}]
})
oidc_mock = OidcMock(
requests_mock=requests_mock,
expected_grant_type="urn:ietf:params:oauth:grant-type:device_code",
expected_client_id=client_id,
expected_fields={
"scope": "openid",
"client_secret": client_secret
},
oidc_discovery_url=oidc_discovery_url,
)
# With all this set up, kick off the openid connect flow
refresh_token_store = mock.Mock()
conn = Connection(API_URL, refresh_token_store=refresh_token_store)
assert isinstance(conn.auth, NullAuth)
oidc_mock.state["device_code_callback_timeline"] = ["great success"]
conn.authenticate_oidc_device(client_id=client_id,
client_secret=client_secret)
assert isinstance(conn.auth, BearerAuth)
assert conn.auth.bearer == 'oidc/oi/' + oidc_mock.state["access_token"]
assert refresh_token_store.mock_calls == []
# Again but store refresh token
oidc_mock.state["device_code_callback_timeline"] = ["great success"]
conn.authenticate_oidc_device(client_id=client_id,
client_secret=client_secret,
store_refresh_token=True)
assert isinstance(conn.auth, BearerAuth)
assert conn.auth.bearer == 'oidc/oi/' + oidc_mock.state["access_token"]
assert refresh_token_store.mock_calls == [
mock.call.set_refresh_token(
client_id=client_id,
issuer=issuer,
refresh_token=oidc_mock.state["refresh_token"])
]
def test_authenticate_oidc_100_multiple_no_id(requests_mock):
requests_mock.get(API_URL, json={"api_version": "1.0.0"})
client_id = "myclient"
requests_mock.get(API_URL + 'credentials/oidc', json={
"providers": [
{"id": "foidc", "issuer": "https://auth.foidc.net", "title": "FOIDC", "scopes": ["openid", "w"]},
{"id": "baroi", "issuer": "https://acco.baroi.net", "title": "BarOI", "scopes": ["openid", "w"]},
]
})
# With all this set up, kick off the openid connect flow
conn = Connection(API_URL)
assert isinstance(conn.auth, NullAuth)
match = r"No provider_id given. Available: \[('foidc', 'baroi'|'baroi', 'foidc')\]\."
with pytest.raises(OpenEoClientException, match=match):
conn.authenticate_OIDC(client_id=client_id, webbrowser_open=pytest.fail)
def test_authenticate_basic(requests_mock, api_version):
requests_mock.get(API_URL, json={"api_version": api_version})
conn = Connection(API_URL)
def text_callback(request, context):
assert request.headers["Authorization"] == "Basic am9objpqMGhu"
return '{"access_token":"w3lc0m3"}'
requests_mock.get(API_URL + 'credentials/basic', text=text_callback)
assert isinstance(conn.auth, NullAuth)
conn.authenticate_basic(username="******", password="******")
assert isinstance(conn.auth, BearerAuth)
if ComparableVersion(api_version).at_least("1.0.0"):
assert conn.auth.bearer == "basic//w3lc0m3"
else:
assert conn.auth.bearer == "w3lc0m3"
def test_authenticate_oidc_040(requests_mock):
client_id = "myclient"
oidc_discovery_url = "https://oeo.test/credentials/oidc"
oidc_mock = OidcMock(requests_mock=requests_mock,
expected_grant_type="authorization_code",
expected_client_id=client_id,
expected_fields={"scope": "openid"},
oidc_discovery_url=oidc_discovery_url)
requests_mock.get(API_URL, json={"api_version": "0.4.0"})
# With all this set up, kick off the openid connect flow
conn = Connection(API_URL)
assert isinstance(conn.auth, NullAuth)
conn.authenticate_OIDC(client_id=client_id,
webbrowser_open=oidc_mock.webbrowser_open)
assert isinstance(conn.auth, BearerAuth)
assert conn.auth.bearer == oidc_mock.state["access_token"]
def test_authenticate_oidc_auth_code_pkce_flow(requests_mock):
requests_mock.get(API_URL, json={"api_version": "1.0.0"})
client_id = "myclient"
issuer = "https://oidc.test"
oidc_discovery_url = "https://oidc.test/.well-known/openid-configuration"
requests_mock.get(API_URL + 'credentials/oidc',
json={
"providers": [{
"id": "oi",
"issuer": issuer,
"title": "example",
"scopes": ["openid"]
}]
})
oidc_mock = OidcMock(
requests_mock=requests_mock,
expected_grant_type="authorization_code",
expected_client_id=client_id,
expected_fields={"scope": "openid"},
oidc_discovery_url=oidc_discovery_url,
scopes_supported=["openid"],
)
# With all this set up, kick off the openid connect flow
refresh_token_store = mock.Mock()
conn = Connection(API_URL, refresh_token_store=refresh_token_store)
assert isinstance(conn.auth, NullAuth)
conn.authenticate_oidc_authorization_code(
client_id=client_id, webbrowser_open=oidc_mock.webbrowser_open)
assert isinstance(conn.auth, BearerAuth)
assert conn.auth.bearer == 'oidc/oi/' + oidc_mock.state["access_token"]
assert refresh_token_store.mock_calls == []
# Again but store refresh token
conn.authenticate_oidc_authorization_code(
client_id=client_id,
webbrowser_open=oidc_mock.webbrowser_open,
store_refresh_token=True)
assert isinstance(conn.auth, BearerAuth)
assert conn.auth.bearer == 'oidc/oi/' + oidc_mock.state["access_token"]
assert refresh_token_store.mock_calls == [
mock.call.set_refresh_token(
client_id=client_id,
issuer=issuer,
refresh_token=oidc_mock.state["refresh_token"])
]
def test_authenticate_basic_from_config(requests_mock, api_version):
user, pwd = "john281", "J0hndo3"
requests_mock.get(API_URL, json={"api_version": api_version})
def text_callback(request, context):
assert request.headers[
"Authorization"] == requests.auth._basic_auth_str(username=user,
password=pwd)
return '{"access_token":"w3lc0m3"}'
requests_mock.get(API_URL + 'credentials/basic', text=text_callback)
AuthConfig().set_basic_auth(backend=API_URL, username=user, password=pwd)
conn = Connection(API_URL)
assert isinstance(conn.auth, NullAuth)
conn.authenticate_basic()
assert isinstance(conn.auth, BearerAuth)
if ComparableVersion(api_version).at_least("1.0.0"):
assert conn.auth.bearer == "basic//w3lc0m3"
else:
assert conn.auth.bearer == "w3lc0m3"
def test_download_content_encoding(requests_mock, tmp_path, content_encoding,
compress):
tmp_path = Path(str(tmp_path)) # Python 3.5 workaround
requests_mock.get(API_URL, json={"api_version": "1.0.0"})
tiff_data = b"hello world, I'm a tiff file."
if content_encoding:
response_data = compress(tiff_data)
response_headers = {"Content-Encoding": content_encoding}
else:
response_data = tiff_data
response_headers = {}
requests_mock.post(API_URL + "result",
content=response_data,
headers=response_headers)
conn = Connection(API_URL)
output = tmp_path / "result.tiff"
conn.download(graph={}, outputfile=output)
with output.open("rb") as f:
assert f.read() == tiff_data
def test_create_connection_lazy_refresh_token_store(requests_mock):
user, pwd = "john262", "J0hndo3"
client_id = "myclient"
client_secret = "$3cr3t"
requests_mock.get(API_URL, json={"api_version": "1.0.0"})
issuer = "https://oidc.test"
oidc_discovery_url = "https://oidc.test/.well-known/openid-configuration"
requests_mock.get(API_URL + 'credentials/oidc',
json={
"providers": [{
"id": "oi",
"issuer": issuer,
"title": "example",
"scopes": ["openid"]
}]
})
oidc_mock = OidcMock(
requests_mock=requests_mock,
expected_grant_type="client_credentials",
expected_client_id=client_id,
expected_fields={"client_secret": client_secret},
oidc_discovery_url=oidc_discovery_url,
)
with mock.patch(
'openeo.rest.connection.RefreshTokenStore') as RefreshTokenStore:
conn = Connection(API_URL)
assert RefreshTokenStore.call_count == 0
# Create RefreshTokenStore lazily when necessary
conn.authenticate_oidc_client_credentials(client_id=client_id,
client_secret=client_secret,
store_refresh_token=True)
assert RefreshTokenStore.call_count == 1
RefreshTokenStore.return_value.set_refresh_token.assert_called_with(
issuer=issuer,
client_id=client_id,
refresh_token=oidc_mock.state["refresh_token"])
def test_authenticate_oidc_client_credentials_client_from_config(
requests_mock):
requests_mock.get(API_URL, json={"api_version": "1.0.0"})
client_id = "myclient"
client_secret = "$3cr3t"
issuer = "https://oidc.test"
oidc_discovery_url = "https://oidc.test/.well-known/openid-configuration"
requests_mock.get(API_URL + 'credentials/oidc',
json={
"providers": [{
"id": "oi",
"issuer": issuer,
"title": "example",
"scopes": ["openid"]
}]
})
oidc_mock = OidcMock(
requests_mock=requests_mock,
expected_grant_type="client_credentials",
expected_client_id=client_id,
expected_fields={"client_secret": client_secret},
oidc_discovery_url=oidc_discovery_url,
)
AuthConfig().set_oidc_client_config(backend=API_URL,
provider_id="oi",
client_id=client_id,
client_secret=client_secret)
# With all this set up, kick off the openid connect flow
refresh_token_store = mock.Mock()
conn = Connection(API_URL, refresh_token_store=refresh_token_store)
assert isinstance(conn.auth, NullAuth)
conn.authenticate_oidc_client_credentials()
assert isinstance(conn.auth, BearerAuth)
assert conn.auth.bearer == 'oidc/oi/' + oidc_mock.state["access_token"]
assert refresh_token_store.mock_calls == []
def test_create_connection_lazy_auth_config(requests_mock, api_version):
user, pwd = "john262", "J0hndo3"
requests_mock.get(API_URL, json={"api_version": api_version})
def text_callback(request, context):
assert request.headers[
"Authorization"] == requests.auth._basic_auth_str(username=user,
password=pwd)
return '{"access_token":"w3lc0m3"}'
requests_mock.get(API_URL + 'credentials/basic', text=text_callback)
with mock.patch('openeo.rest.connection.AuthConfig') as AuthConfig:
# Don't create default AuthConfig when not necessary
conn = Connection(API_URL)
assert AuthConfig.call_count == 0
conn.authenticate_basic(user, pwd)
assert AuthConfig.call_count == 0
# call `authenticate_basic` so that fallback AuthConfig is created/used lazily
AuthConfig.return_value.get_basic_auth.return_value = (user, pwd)
conn.authenticate_basic()
assert AuthConfig.call_count == 1
conn.authenticate_basic()
assert AuthConfig.call_count == 1
def test_file_formats(requests_mock):
requests_mock.get("https://oeo.test/", json={"api_version": "1.0.0"})
m = requests_mock.get(
"https://oeo.test/file_formats",
json={"output": {
"GTiff": {
"gis_data_types": ["raster"]
}
}})
con = Connection(API_URL)
assert con.list_file_formats() == {
"output": {
"GTiff": {
"gis_data_types": ["raster"]
}
}
}
assert m.call_count == 1
assert con.list_output_formats() == {
"GTiff": {
"gis_data_types": ["raster"]
}
}
assert m.call_count == 1
def test_authenticate_oidc_100_multiple_success(requests_mock):
requests_mock.get(API_URL, json={"api_version": "1.0.0"})
client_id = "myclient"
requests_mock.get(API_URL + 'credentials/oidc', json={
"providers": [
{"id": "foidc", "issuer": "https://auth.foidc.net", "title": "FOIDC", "scopes": ["openid", "mu"]},
{"id": "baroi", "issuer": "https://acco.baroi.net", "title": "BarOI", "scopes": ["openid", "mu"]},
]
})
oidc_mock = OidcMock(
requests_mock=requests_mock,
expected_grant_type="authorization_code",
expected_client_id=client_id,
expected_fields={"scope": "mu openid"},
oidc_discovery_url="https://acco.baroi.net/.well-known/openid-configuration",
scopes_supported=["openid", "mu"],
)
# With all this set up, kick off the openid connect flow
conn = Connection(API_URL)
assert isinstance(conn.auth, NullAuth)
conn.authenticate_OIDC(client_id=client_id, provider_id="baroi", webbrowser_open=oidc_mock.webbrowser_open)
assert isinstance(conn.auth, BearerAuth)
assert conn.auth.bearer == 'oidc/baroi/' + oidc_mock.state["access_token"]
def test_get_job(requests_mock):
requests_mock.get(API_URL, json={"api_version": "1.0.0"})
conn = Connection(API_URL)
my_job = conn.job("the_job_id")
assert my_job is not None