def test_update(self, testapp, db):
capsule_id = str(db.capsule1.id)
addon_id = str(db.addon1.id)
with patch.object(oidc, "validate_token", return_value=True), \
patch("utils.check_user_role", return_value=db.user1), \
patch.object(NATS, "publish_addon_present") as publish_method:
new_addon = self.build_addon(db)
res = testapp.put_json(
f"{api_version}/capsules/{capsule_id}/addons/{addon_id}",
new_addon,
status=200).json
publish_method.assert_called_once()
dict_contains(res, new_addon)
def test_get_all(self, testapp, db):
sshkeys_output = self.build_output(db)
with patch.object(oidc, "validate_token", return_value=True), \
patch("utils.check_user_role", return_value=db.admin_user):
res = testapp.get(api_version + "/sshkeys", status=200).json
assert dict_contains(res, sshkeys_output)
def test_get(self, testapp, db):
apptokens_output = self.build_output(db)
with patch.object(oidc, "validate_token", return_value=True), \
patch("utils.check_user_role", return_value=db.user3):
res = testapp.get(api_version + "/apptokens", status=200).json
assert dict_contains(apptokens_output[0], res[0])
def test_update_unexisting_runtime(self, testapp, db):
with patch.object(oidc, 'validate_token', return_value=True), \
patch("utils.check_user_role", return_value=db.superadmin_user):
res = testapp.put_json(api_version + '/runtimes/' + unexisting_id,
self._runtime_input,
status=201).json
assert dict_contains(res, self._runtime_input)
def test_create(self, testapp, db):
with patch.object(oidc, "validate_token", return_value=True), \
patch("utils.check_user_role", return_value=db.user1):
res = testapp.post_json(api_version + "/apptokens",
self._apptoken_input,
status=201).json
assert dict_contains(res, self._apptoken_input)
def test_create(self, testapp, db):
with patch.object(oidc, "validate_token", return_value=True), \
patch("utils.check_user_role", return_value=db.user1), \
patch.object(NATS, "publish_webapp_present") as publish_method:
res = testapp.post_json(api_version + "/sshkeys",
self._sshkey_input,
status=201).json
publish_method.assert_called_once()
assert dict_contains(res, self._sshkey_input)
def test_get_self_user(self, testapp, db):
user_output = user_schema.dump(db.user1)
with patch.object(oidc, "validate_token", return_value=True), \
patch("utils.check_user_role", return_value=db.user1):
res = testapp.get(
api_version + "/users",
status=200
).json
assert dict_contains(res[0], user_output)
def test_get_verbose(self, testapp, db):
capsule_output = self.build_verbose_output(db)
with patch.object(oidc, "validate_token", return_value=True), \
patch("utils.check_user_role", return_value=db.user1):
res = testapp.get(
api_version + "/capsules?verbose=True",
status=200
).json
assert dict_contains(res[0], capsule_output)
def test_create_without_rules(self, testapp, db):
with patch.object(oidc, 'validate_token', return_value=True), \
patch("utils.check_user_role", return_value=db.superadmin_user):
new_runtime = dict(self._runtime_input)
new_runtime['available_opts'][0].pop('validation_rules')
res = testapp.post_json(api_version + '/runtimes',
new_runtime,
status=201).json
assert dict_contains(res, new_runtime)
def test_get(self, testapp, db):
capsule_id = str(db.capsule1.id)
owners_output = self.build_output(db)
with patch.object(oidc, "validate_token", return_value=True), \
patch("utils.check_user_role", return_value=db.user1):
res = testapp.get(api_version + "/capsules/" + capsule_id +
"/owners",
status=200).json
assert dict_contains(res, owners_output)
def test_get(self, testapp, db):
capsule_id = str(db.capsule1.id)
cron_output = self.build_output(db)
with patch.object(oidc, "validate_token", return_value=True), \
patch("utils.check_user_role", return_value=db.user1):
res = testapp.get(
f"{api_version}/capsules/{capsule_id}/webapp/crons",
status=200).json
assert dict_contains(res[0], cron_output)
def test_get_runtime(self, testapp, db):
runtime_output = runtime_schema.dump(db.runtime1)
with patch.object(oidc, "validate_token", return_value=True), \
patch("utils.check_user_role", return_value=db.fake_user):
# Get the runtime id
runtime_id = str(db.runtime1.id)
# Get this runtime by id
runtime = testapp.get(api_version + "/runtimes/" + runtime_id,
status=200).json
assert dict_contains(runtime, runtime_output)
def test_get_user(self, testapp, db):
user_output = user_schema.dump(db.user1)
with patch.object(oidc, "validate_token", return_value=True), \
patch("utils.check_user_role", return_value=db.admin_user):
user_id = db.user1.name
# Get this user by id
user = testapp.get(
api_version + "/users/" + user_id,
status=200
).json
assert dict_contains(user, user_output)
def test_get_capsule_verbose(self, testapp, db):
capsule_output = self.build_verbose_output(db)
with patch.object(oidc, "validate_token", return_value=True), \
patch("utils.check_user_role", return_value=db.user1):
# Get the capsule id
capsule_id = str(db.capsule1.id)
# Get this capsule by id
capsule = testapp.get(
api_version + "/capsules/" + capsule_id + '?verbose=True',
status=200,
).json
assert dict_contains(capsule, capsule_output)
def test_get(self, testapp, db):
from pprint import pprint
pprint(db.runtime1)
runtime_output = [
runtime_schema.dump(db.runtime1),
runtime_schema.dump(db.runtime2),
]
with patch.object(oidc, 'validate_token', return_value=True), \
patch("utils.check_user_role", return_value=db.user1):
res = testapp.get(api_version + '/runtimes', status=200).json
assert dict_contains(res, runtime_output)
def test_update_cron_with_only_command(self, testapp, db):
capsule_id = str(db.capsule1.id)
cron_id = str(db.cron1.id)
with patch.object(oidc, "validate_token", return_value=True), \
patch("utils.check_user_role", return_value=db.user1), \
patch.object(NATS, "publish_webapp_present") as publish_method:
cron = {"command": "test"}
base_uri = f"{api_version}/capsules/{capsule_id}/webapp/crons"
res = testapp.put_json(f"{base_uri}/{cron_id}", cron,
status=200).json
publish_method.assert_called_once()
assert dict_contains(res, cron)
def test_create(self, testapp, db):
with patch.object(oidc, "validate_token", return_value=True), \
patch("utils.check_user_role", return_value=db.admin_user), \
patch.object(NATS, "publish_webapp_present") as publish_method:
capsule_id = str(db.capsule1.id)
# Create fqdn
res = testapp.post_json(api_version + '/capsules/' + capsule_id +
'/fqdns',
self._fqdn_input,
status=201).json
publish_method.assert_called_once()
assert dict_contains(res, self._fqdn_input)
def test_update_runtime(self, testapp, db):
with patch.object(oidc, "validate_token", return_value=True), \
patch("utils.check_user_role", return_value=db.superadmin_user):
# Get the runtime id
runtime_id = str(db.runtime2.id)
# Update this runtime by id
temp_runtime = dict(self._runtime_input)
temp_runtime["name"] = "New runtime"
runtime = testapp.put_json(api_version + "/runtimes/" + runtime_id,
temp_runtime,
status=200).json
assert dict_contains(runtime, temp_runtime)
def test_create(self, testapp, db):
capsule_id = str(db.capsule1.id)
with patch.object(oidc, "validate_token", return_value=True), \
patch("utils.check_user_role", return_value=db.user1), \
patch.object(NATS, "publish_addon_present") as publish_method:
# Create addon
new_addon = self.build_addon(db)
res = testapp.post_json(api_version + '/capsules/' + capsule_id +
'/addons',
new_addon,
status=201).json
publish_method.assert_called_once()
assert dict_contains(res, new_addon)
def test_patch(self, testapp, db):
capsule_id = str(db.capsule1.id)
with patch.object(oidc, "validate_token", return_value=True), \
patch("utils.check_user_role", return_value=db.admin_user), \
patch.object(NATS, "publish_webapp_present") as publish_method:
res = testapp.patch_json(api_version + "/capsules/" + capsule_id +
"/tls",
self._tls_input,
status=200).json
publish_method.assert_called_once()
# crt and key are not displayed in result...
input = dict(self._tls_input)
input.pop('crt')
input.pop('key')
assert dict_contains(res, input)
def test_create(self, testapp, db):
with patch.object(oidc, "validate_token", return_value=True), \
patch("utils.check_user_role", return_value=db.admin_user), \
patch("api.capsules.check_owners_on_keycloak"):
res = testapp.post_json(
api_version + "/capsules",
self._capsule_input,
status=201
).json
res.pop('authorized_keys')
clean_input = dict(self._capsule_input)
clean_input.pop('authorized_keys')
assert dict_contains(res, clean_input)
def test_update(self, testapp, db):
capsule_id = str(db.capsule1.id)
fqdn_id = str(db.fqdn1.id)
with patch.object(oidc, "validate_token", return_value=True), \
patch("utils.check_user_role", return_value=db.admin_user), \
patch.object(NATS, "publish_webapp_present") as publish_method:
current_fqdn = self.build_output(db)
current_fqdn['name'] = "new.fqdn.com"
current_fqdn.pop('id')
res = testapp.put_json(
f'{api_version}/capsules/{capsule_id}/fqdns/{fqdn_id}',
current_fqdn,
status=200).json
publish_method.assert_called_once()
assert dict_contains(res, current_fqdn)
def test_create(self, testapp, db):
capsule_id = str(db.capsule1.id)
cron_id = str(db.cron1.id)
with patch.object(oidc, "validate_token", return_value=True), \
patch("utils.check_user_role", return_value=db.user1), \
patch.object(NATS, "publish_webapp_present") as publish_method:
# Remove existing cron (only one cron per webapp)
testapp.delete(
f"{api_version}/capsules/{capsule_id}/webapp/crons/{cron_id}",
status=204)
publish_method.assert_called_once()
res = testapp.post_json(
f"{api_version}/capsules/{capsule_id}/webapp/crons",
self._cron_input,
status=201).json
assert dict_contains(res, self._cron_input)
def test_update_unexisting_webapp(self, testapp, db):
capsule_id = str(db.capsule1.id)
with patch.object(oidc, "validate_token", return_value=True), \
patch("utils.check_user_role", return_value=db.user1), \
patch.object(NATS, "publish_webapp_absent") as publish_method1, \
patch.object(NATS, "publish_webapp_present") as publish_method2:
# Remove existing webapp
testapp.delete(api_version + '/capsules/' + capsule_id + '/webapp',
status=204)
publish_method1.assert_called_once()
new_webapp = self.build_webapp(db)
res = testapp.put_json(api_version + '/capsules/' + capsule_id +
'/webapp',
new_webapp,
status=201).json
publish_method2.assert_called_once()
assert dict_contains(res, new_webapp)
def test_update(self, testapp, db):
capsule_id = str(db.capsule1.id)
with patch.object(oidc, "validate_token", return_value=True), \
patch("utils.check_user_role", return_value=db.admin_user), \
patch.object(NATS, "publish_webapp_present") as publish_method:
current_webapp = self.build_output(db)
current_webapp.pop('id')
current_webapp.pop('created_at')
current_webapp.pop('updated_at')
current_webapp["env"] = {
"HTTP_PROXY": "http://proxy.example.com:3128/",
"HTTPS_PROXY": "http://proxy.example.com:3128/",
}
current_webapp["runtime_id"] = str(db.runtime4.id)
current_webapp.pop('opts')
res = testapp.put_json(api_version + '/capsules/' + capsule_id +
'/webapp',
current_webapp,
status=200).json
publish_method.assert_called_once()
assert dict_contains(res, current_webapp)
