X-Git-Url: https://osm.etsi.org/gitweb/?p=osm%2FN2VC.git;a=blobdiff_plain;f=modules%2Flibjuju%2Ftests%2Fintegration%2Ftest_model.py;h=58766b4c5bbd5eb2bae04203355de67830a920a9;hp=ba2da92a48c5162c29864808fedad77cfe30ae4d;hb=19c5cfca317615597be6bf1051e9d2fa903adb97;hpb=c3e6c2ec9a1fddfc8e9bd31509b366e633b6d99e diff --git a/modules/libjuju/tests/integration/test_model.py b/modules/libjuju/tests/integration/test_model.py index ba2da92..58766b4 100644 --- a/modules/libjuju/tests/integration/test_model.py +++ b/modules/libjuju/tests/integration/test_model.py @@ -2,10 +2,17 @@ import asyncio import mock from concurrent.futures import ThreadPoolExecutor from pathlib import Path +import paramiko from juju.client.client import ConfigValue, ApplicationFacade from juju.model import Model, ModelObserver from juju.utils import block_until, run_with_interrupt +from juju.errors import JujuError + +import os +import pylxd +import time +import uuid import pytest @@ -19,8 +26,7 @@ SSH_KEY = 'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCsYMJGNGG74HAJha3n2CFmWYsOOaORn @base.bootstrapped @pytest.mark.asyncio -async def test_deploy_local_bundle(event_loop): - from pathlib import Path +async def test_deploy_local_bundle_dir(event_loop): tests_dir = Path(__file__).absolute().parent.parent bundle_path = tests_dir / 'bundle' mini_bundle_file_path = bundle_path / 'mini-bundle.yaml' @@ -29,8 +35,62 @@ async def test_deploy_local_bundle(event_loop): await model.deploy(str(bundle_path)) await model.deploy(str(mini_bundle_file_path)) - for app in ('wordpress', 'mysql', 'myapp'): - assert app in model.applications + wordpress = model.applications.get('wordpress') + mysql = model.applications.get('mysql') + assert wordpress and mysql + await block_until(lambda: (len(wordpress.units) == 1 and + len(mysql.units) == 1), + timeout=60 * 4) + + +@base.bootstrapped +@pytest.mark.asyncio +async def test_deploy_local_bundle_file(event_loop): + tests_dir = Path(__file__).absolute().parent.parent + bundle_path = tests_dir / 'bundle' + mini_bundle_file_path = bundle_path / 'mini-bundle.yaml' + + async with base.CleanModel() as model: + await model.deploy(str(mini_bundle_file_path)) + + dummy_sink = model.applications.get('dummy-sink') + dummy_subordinate = model.applications.get('dummy-subordinate') + assert dummy_sink and dummy_subordinate + await block_until(lambda: (len(dummy_sink.units) == 1 and + len(dummy_subordinate.units) == 1), + timeout=60 * 4) + + +@base.bootstrapped +@pytest.mark.asyncio +async def test_deploy_invalid_bundle(event_loop): + tests_dir = Path(__file__).absolute().parent.parent + bundle_path = tests_dir / 'bundle' / 'invalid.yaml' + async with base.CleanModel() as model: + with pytest.raises(JujuError): + await model.deploy(str(bundle_path)) + + +@base.bootstrapped +@pytest.mark.asyncio +async def test_deploy_local_charm(event_loop): + from pathlib import Path + tests_dir = Path(__file__).absolute().parent.parent + charm_path = tests_dir / 'charm' + + async with base.CleanModel() as model: + await model.deploy(str(charm_path)) + assert 'charm' in model.applications + + +@base.bootstrapped +@pytest.mark.asyncio +async def test_deploy_invalid_bundle(event_loop): + tests_dir = Path(__file__).absolute().parent.parent + bundle_path = tests_dir / 'bundle' / 'invalid.yaml' + async with base.CleanModel() as model: + with pytest.raises(JujuError): + await model.deploy(str(bundle_path)) @base.bootstrapped @@ -110,6 +170,115 @@ async def test_add_machine(event_loop): assert len(model.machines) == 0 +@base.bootstrapped +@pytest.mark.asyncio +async def test_add_manual_machine_ssh(event_loop): + + # Verify controller is localhost + async with base.CleanController() as controller: + cloud = await controller.get_cloud() + if cloud != "localhost": + pytest.skip('Skipping because test requires lxd.') + + async with base.CleanModel() as model: + private_key_path = os.path.expanduser( + "~/.local/share/juju/ssh/juju_id_rsa" + ) + public_key_path = os.path.expanduser( + "~/.local/share/juju/ssh/juju_id_rsa.pub" + ) + + # connect using the local unix socket + client = pylxd.Client() + + test_name = "test-{}-add-manual-machine-ssh".format( + uuid.uuid4().hex[-4:] + ) + + # create profile w/cloud-init and juju ssh key + public_key = "" + with open(public_key_path, "r") as f: + public_key = f.readline() + + profile = client.profiles.create( + test_name, + config={'user.user-data': '#cloud-config\n' + 'ssh_authorized_keys:\n' + '- {}'.format(public_key)}, + devices={ + 'root': {'path': '/', 'pool': 'default', 'type': 'disk'}, + 'eth0': { + 'nictype': 'bridged', + 'parent': 'lxdbr0', + 'type': 'nic' + } + } + ) + + # create lxc machine + config = { + 'name': test_name, + 'source': { + 'type': 'image', + 'alias': 'xenial', + 'mode': 'pull', + 'protocol': 'simplestreams', + 'server': 'https://cloud-images.ubuntu.com/releases', + }, + 'profiles': [test_name], + } + container = client.containers.create(config, wait=True) + container.start(wait=True) + + def wait_for_network(container, timeout=30): + """Wait for eth0 to have an ipv4 address.""" + starttime = time.time() + while(time.time() < starttime + timeout): + time.sleep(1) + if 'eth0' in container.state().network: + addresses = container.state().network['eth0']['addresses'] + if len(addresses) > 0: + if addresses[0]['family'] == 'inet': + return addresses[0] + return None + + host = wait_for_network(container) + assert host, 'Failed to get address for machine' + + # HACK: We need to give sshd a chance to bind to the interface, + # and pylxd's container.execute seems to be broken and fails and/or + # hangs trying to properly check if the service is up. + time.sleep(5) + + for attempt in range(1, 4): + try: + # add a new manual machine + machine1 = await model.add_machine(spec='ssh:{}@{}:{}'.format( + "ubuntu", + host['address'], + private_key_path, + )) + except paramiko.ssh_exception.NoValidConnectionsError: + if attempt == 3: + raise + # retry the ssh connection a few times if it fails + time.sleep(attempt * 5) + else: + break + + assert len(model.machines) == 1 + + res = await machine1.destroy(force=True) + + assert res is None + assert len(model.machines) == 0 + + container.stop(wait=True) + container.delete(wait=True) + + profile.delete() + + @base.bootstrapped @pytest.mark.asyncio async def test_relate(event_loop): @@ -160,7 +329,7 @@ async def test_relate(event_loop): my_relation = await run_with_interrupt(model.add_relation( 'ubuntu', 'nrpe', - ), timeout, event_loop) + ), timeout, loop=event_loop) assert isinstance(my_relation, Relation) @@ -184,7 +353,9 @@ async def test_explicit_loop_threaded(event_loop): with ThreadPoolExecutor(1) as executor: f = executor.submit( new_loop.run_until_complete, - _deploy_in_loop(new_loop, model_name, model._connector.jujudata)) + _deploy_in_loop(new_loop, + model_name, + model._connector.jujudata)) f.result() await model._wait_for_new('application', 'ubuntu') assert 'ubuntu' in model.applications @@ -224,6 +395,29 @@ async def test_store_resources_bundle(event_loop): # ghost will go in to blocked (or error, for older # charm revs) if the resource is missing assert ghost.units[0].workload_status == 'active' + resources = await ghost.get_resources() + assert resources['ghost-stable'].revision >= 12 + + +@base.bootstrapped +@pytest.mark.asyncio +async def test_store_resources_bundle_revs(event_loop): + async with base.CleanModel() as model: + bundle = str(Path(__file__).parent / 'bundle/bundle-resource-rev.yaml') + await model.deploy(bundle) + assert 'ghost' in model.applications + ghost = model.applications['ghost'] + terminal_statuses = ('active', 'error', 'blocked') + await model.block_until( + lambda: ( + len(ghost.units) > 0 and + ghost.units[0].workload_status in terminal_statuses) + ) + # ghost will go in to blocked (or error, for older + # charm revs) if the resource is missing + assert ghost.units[0].workload_status == 'active' + resources = await ghost.get_resources() + assert resources['ghost-stable'].revision == 11 @base.bootstrapped @@ -269,6 +463,15 @@ async def test_config(event_loop): assert result['extra-info'].source == 'model' assert result['extra-info'].value == 'booyah' + +@base.bootstrapped +@pytest.mark.asyncio +async def test_set_constraints(event_loop): + async with base.CleanModel() as model: + await model.set_constraints({'cpu-power': 1}) + cons = await model.get_constraints() + assert cons['cpu_power'] == 1 + # @base.bootstrapped # @pytest.mark.asyncio # async def test_grant(event_loop)