~andreserl/maas/python3_qa_lab_tests

import os
import time
import yaml
from contextlib import closing
from itertools import count

import api
from config import (
    ADMIN_USER,
    BMC_START_IP,
    BMC_END_IP,
    HTTP_PROXY,
    MAAS_URL,
    MAIN_ARCHIVE,
    REGION_DHCP_CONFIG,
    LAB_DNS_CONFIG,
    LENOVO_LAB,
    PASSWORD,
    PORTS_ARCHIVE,
    POWER_USER,
    POWER_PASS,
    SLAVE_HOSTNAME,
    SLAVE_IP,
    SLAVE_MAC,
    USER_DATA_URL,
)
from utils import (
    assertCommandReturnCode,
    pause_until_released,
    get_rack_interface_link,
    get_rack_systemid_on_region,
    get_ssh_key,
    ipmi_power_off,
    ipmi_power_on,
    retries,
    run_command,
    setup_ssh,
)
from timeout import timeout
from unittest import skipIf
from testtools.content import (
    content_from_stream,
    text_content,
)
from testtools.matchers import (
    Contains,
    ContainsDict,
    Equals,
    GreaterThan,
    MatchesDict,
    MatchesListwise,
    MatchesRegex,
    Not,
)
import requests

from urllib.request import urlopen
from urllib.error import HTTPError
from urllib.parse import urljoin

from maasserver.enum import NODE_STATUS

from common import TestMAASIntegration  # noqa


MAAS4 = '00:E0:81:DD:D1:0B'


class TestMAASAPI(api.APITestCase):

    def _wait_maas_running(self):
        for _ in range(10):
            try:
                urlopen(MAAS_URL).code
            except HTTPError:
                time.sleep(30)
                continue
            return True
        return False

    def _boot_machines(self):
        for machine in LENOVO_LAB.values():
            ipmi_power_off(self, machine, POWER_USER, POWER_PASS)
            ipmi_power_on(self, machine, POWER_USER, POWER_PASS)

    def test_create_admin(self):
        """Run maas createadmin."""
        ret, _, _ = run_command([
            "maas", "createadmin",
            "--username={}".format(ADMIN_USER),
            "--password={}".format(PASSWORD),
            "--email=example@canonical.com",
        ])
        self.assertThat(ret, Equals(0))

    @skipIf(
        os.path.exists("/etc/maas/maas_local_settings.py"),
        "local_config_set is not available")
    def test_update_maas_url(self):
        # XXX: allenap: Using a debconf file to set the initial value of the
        # MAAS URL should not work; see test_update_maas_url_old(), but I'm
        # not sure if that's true.
        cmd = [
            "maas-region", "local_config_set", "--maas-url",
            "http://10.245.136.6/MAAS",
        ]
        assertCommandReturnCode(self, cmd, "")
        # Restart apache2.
        cmd = ["systemctl", "restart", "maas-regiond"]
        for _ in retries(delay=10, timeout=60):
            retcode, _, _ = run_command(cmd)
            if retcode == 0:
                break
        else:
            self.fail("maas-regiond cannot be restarted")

    def test_update_maas_url_rack(self):
        cmd = [
            "maas-rack", "config", "--region-url",
            "http://10.245.136.6:5240/MAAS",
        ]
        assertCommandReturnCode(self, cmd, "")
        # Restart apache2.
        cmd = ["systemctl", "restart", "maas-rackd"]
        for _ in retries(delay=10, timeout=60):
            retcode, _, _ = run_command(cmd)
            if retcode == 0:
                break
        else:
            self.fail("maas-rackd could not be restarted")

    def test_check_initial_services_systemctl(self):
        cmd = ["systemctl", "status", "maas-rackd"]
        retcode, output, err = run_command(cmd)
        self.assertEqual(0, retcode)
        self.assertIn('Active: active (running)', output)
        self.assertEqual('', err)

    def test_check_rpc_info(self):
        # Ensure that the region is publishing RPC info to the clusters. This
        # is a reasonable indication that the region is running correctly.
        url = "%s/rpc/" % MAAS_URL.rstrip("/")
        self.addDetail('url', text_content(url))
        errors = []
        attempts = count(1)
        for elapsed, _ in retries(timeout=300, delay=10):
            attempt = next(attempts)
            try:
                with closing(urlopen(url)) as response:
                    details = content_from_stream(response, buffer_now=True)
            except HTTPError as error:
                errors.append(error)
            else:
                self.addDetail('info', details)
                break
        else:
            self.addDetail('errors', text_content(
                "\n--\n".join([error for error in errors])))
            self.fail(
                "RPC info not published after %d attempts over %d seconds."
                % (attempt, elapsed))

    def _get_token_str(self):
        _, out, _ = run_command(
            ["maas", "apikey", "--username={}".format(ADMIN_USER)]
        )
        return out.strip()

    def test_login_api(self):
        self.assertTrue(self._wait_maas_running())
        token_str = self._get_token_str()
        os.environ['MAAS_API_KEY'] = token_str
        api_url = MAAS_URL + "/api/2.0/"
        cmd = ["maas", "login", "maas", api_url, token_str]
        expected_output = "\nYou are now logged in to the MAAS server"
        for _ in range(30):
            retcode, output, err = run_command(cmd, env=os.environ.copy())
            if retcode == 0:
                break
            elif retcode == 1 and 'Expected application/json' in err:
                # The cli may error with 'Expected application/json, got:
                # text/html; charset=utf-8\n' with retcode 1 before all pieces
                # are up and running.
                time.sleep(10)  # We need to give MAAS some time.
        self.assertIn(expected_output, output)

    def test_maas_logged_in(self):
        """Make sure MAAS is successfully logged in. Also, it signals a handy
        place to put a pause."""
        cmd = ["maas", "list"]
        retcode, _, err = run_command(cmd)
        self.assertEqual(0, retcode)
        self.assertEqual('', err)

    def test_maashandler_auth_set_config_main_archive(self):
        uri = api.MAAS_API + "maas/?op=set_config"
        data = {
            'name': 'main_archive',
            'value': MAIN_ARCHIVE,
        }
        response = requests.post(
            uri,
            data=data,
            auth=self.oauth,
            headers=api.APP_JSON_HEADER,
        )
        self.assertTrue(response.ok, response.text)

    def test_maashandler_auth_get_config_main_archive(self):
        uri = api.MAAS_API + "maas/?op=get_config"
        params = {
            'name': 'main_archive'
        }
        response = requests.get(
            uri,
            params=params,
            auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        self.assertThat(
            response.text, Equals('"{}"'.format(MAIN_ARCHIVE))
        )

    def test_main_archive_in_enlist_userdata_apt_config(self):
        output = urlopen(USER_DATA_URL).read().decode('utf-8')
        # Old APT configuration.
        self.assertThat(yaml.safe_load(output), ContainsDict({
            'system_info': ContainsDict({
                'package_mirrors': MatchesListwise([
                    MatchesDict({
                        "arches": Equals(["i386", "amd64"]),
                        "search": MatchesDict({
                            "primary": Equals([MAIN_ARCHIVE]),
                            "security": Equals([MAIN_ARCHIVE]),
                            }),
                        "failsafe": MatchesDict({
                            "primary": Equals(
                                "http://archive.ubuntu.com/ubuntu"),
                            "security": Equals(
                                "http://security.ubuntu.com/ubuntu"),
                            })
                        }),
                    MatchesDict({
                        "arches": Equals(["default"]),
                        "search": MatchesDict({
                            "primary": Equals([PORTS_ARCHIVE]),
                            "security": Equals([PORTS_ARCHIVE]),
                            }),
                        "failsafe": MatchesDict({
                            "primary": Equals(
                                "http://ports.ubuntu.com/ubuntu-ports"),
                            "security": Equals(
                                "http://ports.ubuntu.com/ubuntu-ports"),
                            })
                        }),
                    ]),
                }),
            }))
        # New APT configuration.
        self.assertThat(yaml.safe_load(output), ContainsDict({
            'apt': ContainsDict({
                'preserve_sources_list': Equals(False),
                'primary': MatchesListwise([
                    MatchesDict({
                        "arches": Equals(["amd64", "i386"]),
                        "uri": Equals(MAIN_ARCHIVE),
                    }),
                    MatchesDict({
                        "arches": Equals(["default"]),
                        "uri": Equals(PORTS_ARCHIVE),
                    }),
                ]),
            })
        }))

    def test_maashandler_auth_set_config_http_proxy(self):
        uri = api.MAAS_API + "maas/?op=set_config"
        data = {
            'name': 'http_proxy',
            # TODO: Get this from the env
            'value': HTTP_PROXY,
        }
        response = requests.post(
            uri, data=data, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)

    def test_maashandler_auth_get_config_http_proxy(self):
        uri = api.MAAS_API + "maas/?op=get_config"
        params = {
            'name': 'http_proxy'
        }
        response = requests.get(
            uri,
            params=params,
            auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        self.assertThat(
            response.text, Equals('"{}"'.format(HTTP_PROXY))
        )

    def _list_auth_tokens_and_check_ok(self):
        uri = api.MAAS_API + "/account/?op=list_authorisation_tokens"
        response = requests.get(
            uri, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        return response.json()

    def test_accounthandler_auth_list_authorisation_tokens(self):
        # Initially only one token should be returned
        account_tokens = self._list_auth_tokens_and_check_ok()
        self.assertThat(len(account_tokens), Equals(1))
        token = account_tokens[0]
        self.assertThat(token, MatchesDict({
            'name': Equals("MAAS consumer"),
            'token': MatchesRegex(r"^\w{18}:\w{18}:\w{32}$"),
        }))

    def test_accounthandler_auth_create_authorisation_token(self):
        uri = api.MAAS_API + "/account/?op=create_authorisation_token"
        data = {'name': 'apitest'}
        response = requests.post(
            uri, data=data, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        # Save it as we need it to delete the same
        created_token = response.json()
        processed_token = {
            'name': created_token['name'],
            'token': ':'.join([
                created_token['consumer_key'],
                created_token['token_key'],
                created_token['token_secret'],
            ]),
        }
        self.shelf['token'] = processed_token
        self.assertThat(response.json(), MatchesDict({
            'consumer_key': MatchesRegex(r'\w{18}'),
            'token_key': MatchesRegex(r'\w{18}'),
            'token_secret': MatchesRegex(r'\w{32}'),
            'name': Equals('apitest'),
        }))
        account_tokens = self._list_auth_tokens_and_check_ok()
        self.assertThat(len(account_tokens), Equals(2))
        self.assertThat(account_tokens, Contains(processed_token))

    def test_accounthandler_auth_update_token_name(self):
        uri = api.MAAS_API + "/account/?op=update_token_name"
        data = {
            'name': 'newname',
            'token': self.shelf['token']['token'],
        }
        response = requests.post(  # Yes it really is POST
            uri, data=data, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        updated = self.shelf['token']
        updated['name'] = 'newname'
        account_tokens = self._list_auth_tokens_and_check_ok()
        self.assertThat(account_tokens, Contains(updated))

    def test_accounthandler_auth_delete_authorisation_token(self):
        uri = api.MAAS_API + "/account/?op=delete_authorisation_token"
        data = {'token_key': self.shelf['token']['token'].split(':')[1]}
        response = requests.post(  # Yes it really is POST
            uri, data=data, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        # Succesful response has no text
        self.assertThat(response.text, Equals(""))
        # Check that list of account tokens doesn't contain the one we deleted
        account_tokens = self._list_auth_tokens_and_check_ok()
        self.assertThat(len(account_tokens), Equals(1))
        self.assertThat(account_tokens, Not(Contains(self.shelf['token'])))

    def test_sshkeyshandler_auth_create(self):
        """Add our ssh key to the admin account."""
        setup_ssh()
        data = {'key': get_ssh_key()}
        uri = api.MAAS_API + "account/prefs/sshkeys/"
        response = requests.post(
            uri, data=data, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        self.shelf['sshkey'] = response.json()

    def test_sshkeyshandler_auth_read(self):
        uri = api.MAAS_API + "account/prefs/sshkeys/"
        response = requests.get(
            uri, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        self.assertThat(response.json()[0]['key'], Equals(get_ssh_key()))

    def _get_rack_controllers(self):
        uri = api.MAAS_API + "rackcontrollers/"
        return requests.get(
            uri, auth=self.oauth, headers=api.APP_JSON_HEADER
        )

    def test_rackcontrollershandler_auth_read(self):
        response = self._get_rack_controllers()
        self.assertTrue(response.ok, response.text)
        self.shelf['rackcontrollers'] = response.json()

    def _get_rack(self, rack_id):
        uri = api.MAAS_API + "rackcontrollers/{rack}/".format(
            rack=rack_id
        )
        return requests.get(
            uri, auth=self.oauth, headers=api.APP_JSON_HEADER
        )

    def test_rackcontrollerhandler_auth_read(self):
        primary_rack_sid = get_rack_systemid_on_region(
            self.shelf['rackcontrollers']
        )
        response = self._get_rack(primary_rack_sid)
        self.assertTrue(response.ok, response.text)
        self.shelf['primaryrack'] = response.json()

    def _get_master_rack(self):
        response = self._get_rack_controllers()
        rack_controllers = response.json()
        if len(rack_controllers) > 0:
            return rack_controllers[0]
        return None

    def get_rack_service_status(self, rack_id, service_name):
        rack_info = self._get_rack(rack_id).json()
        for service in rack_info['service_set']:
            if service['name'] == service_name:
                return service['status']
        return ''

    def test_region_rack_connected(self):
        # The master cluster is connected and changed the uuid field of the
        # nodegroup object from 'master' to its UUID.
        while self._get_master_rack() is None:
            time.sleep(10)
        rack_id = self._get_master_rack()['system_id']
        while self.get_rack_service_status(rack_id, 'rackd') != 'running':
            time.sleep(10)

    def test_bootresourceshandler_auth_stop_import(self):
        uri = api.MAAS_API + "boot-resources/?op=stop_import"
        response = requests.post(
            uri, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)

    def test_bootresourceshandler_auth_import(self):
        uri = api.MAAS_API + "boot-resources/?op=import"
        response = requests.post(
            uri, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)

    def test_deviceshandler_auth_create(self):
        uri = api.MAAS_API + "devices/"
        data = {
            'hostname': SLAVE_HOSTNAME,
            'mac_addresses': SLAVE_MAC,
        }
        response = requests.post(
            uri, data=data,
            auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        self.shelf['device'] = response.json()
        rack_interface_link = get_rack_interface_link(
            self.shelf['primaryrack'],
            REGION_DHCP_CONFIG['ip'],
        )
        self.shelf['device_subnet'] = rack_interface_link['subnet']['name']
        self.shelf['device_vlan'] = rack_interface_link['subnet']['vlan']['id']

    def test_interfacehandler_auth_update(self):
        device_id = self.shelf['device']['system_id']
        interface_id = "{}".format(
            self.shelf['device']['interface_set'][0]['id']
        )
        uri = api.MAAS_API + "nodes/{system_id}/interfaces/{interface_id}/"
        interface_uri = uri.format(
            system_id=device_id,
            interface_id=interface_id,
        )
        data = {'vlan': self.shelf['device_vlan']}
        response = requests.put(
            interface_uri,
            data=data,
            auth=self.oauth,
            headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        self.assertThat(
            response.json()['vlan']['id'],
            Equals(self.shelf['device_vlan'])
        )

    def test_interfacehandler_auth_link_subnet(self):
        device_id = self.shelf['device']['system_id']
        interface_id = "{}".format(
            self.shelf['device']['interface_set'][0]['id']
        )
        uri = api.MAAS_API + ("nodes/{system_id}/interfaces"
                              "/{interface_id}/?op=link_subnet")
        link_subnet_uri = uri.format(
            system_id=device_id,
            interface_id=interface_id,
        )
        data = {
            'mode': 'STATIC',
            'subnet': self.shelf['device_subnet'],
            'ip_address': SLAVE_IP,
        }
        response = requests.post(
            link_subnet_uri,
            data=data,
            auth=self.oauth,
            headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        self.assertThat(
            response.json()['links'][0]['ip_address'],
            Equals(SLAVE_IP),
        )

    def test_iprangeshandler_auth_create(self):
        # Create dynamic range
        uri = api.MAAS_API + "ipranges/"
        data = {
            'type': 'dynamic',
            'start_ip': REGION_DHCP_CONFIG['ip_range_low'],
            'end_ip': REGION_DHCP_CONFIG['ip_range_high'],
        }
        response = requests.post(
            uri, json=data, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        self.shelf['dynamicrange'] = response.json()

        # Create BMC range
        uri = api.MAAS_API + "ipranges/"
        data = {
            'type': 'reserved',
            'start_ip': BMC_START_IP,
            'end_ip': BMC_END_IP,
            'comment': 'BMCs',
        }
        response = requests.post(
            uri, json=data, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        self.shelf['bmcrange'] = response.json()

    def test_iprangeshandler_auth_read(self):
        uri = api.MAAS_API + "ipranges/"
        response = requests.get(
            uri, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        self.assertThat(response.json(), Contains(self.shelf['dynamicrange']))
        self.assertThat(response.json(), Contains(self.shelf['bmcrange']))

    def test_subnetshandler_auth_read(self):
        uri = api.MAAS_API + "subnets/"
        response = requests.get(
            uri, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)

    def _check_dhcp_service_status(self, rack_sid):
        uri = api.MAAS_API + "rackcontrollers/{rack}/".format(
            rack=rack_sid
        )
        response = requests.get(
            uri, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        for service in response.json()['service_set']:
            if service['name'] == 'dhcpd':
                return service['status']

    def test_vlanhandler_auth_update(self):
        primary_rack = self.shelf['primaryrack']
        rack_interface_link = get_rack_interface_link(
            primary_rack,
            REGION_DHCP_CONFIG['ip'],
        )
        rack_fabric = rack_interface_link['subnet']['vlan']['fabric']
        rack_vlan = rack_interface_link['subnet']['vlan']['name']

        data = {
            'dhcp_on': True,
            'primary_rack': primary_rack['system_id'],
        }
        uri = api.MAAS_API + "fabrics/{fabric_id}/vlans/{vid}/".format(
            fabric_id=rack_fabric,
            vid=rack_vlan,
        )
        response = requests.put(
            uri, data=data, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        self.assertTrue(response.json()['dhcp_on'], 'DHCP not on')
        while self._check_dhcp_service_status(
                primary_rack['system_id']) != 'running':
            time.sleep(30)

    def test_check_dhcp_service_systemctl(self):
        cmd = ["systemctl", "status", "maas-dhcpd"]
        # systemd will return 3 if a 'condition failed. This typically means
        # that /var/lib/maas/dhcpd.conf is not there yet, and we should wait
        # for a bit to see if the config is written and maas-dhcp is brought up
        # by the rack.
        retcode, output, err = run_command(cmd)
        while retcode != 0:
            # query systemd every 3 seconds to see if maas-dhcpd us running
            time.sleep(3)
            retcode, output, err = run_command(cmd)
        self.assertEqual(0, retcode)
        self.assertIn('Active: active (running)', output)
        self.assertEqual('', err)

    def test_update_dns_config_systemctl(self):
        dns_config = open("/etc/bind/named.conf.options", 'w')
        dns_config.write(LAB_DNS_CONFIG)
        dns_config.close()
        cmd = ["systemctl", "restart", "bind9"]
        retcode, output, err = run_command(cmd)
        self.assertEqual(0, retcode)
        self.assertEqual('', output)  # No news is good news
        self.assertEqual('', err)

    def _get_boot_resource_path(self):
        return os.path.join(
            os.path.dirname(os.path.realpath(__file__)),
            'boot-resource.tgz'
        )

    def _create_file(self):
        uri = api.MAAS_API + "files/"
        data = {'filename': 'apitest'}
        files = {'file': open(self._get_boot_resource_path(), 'rb')}
        response = requests.post(
            uri,
            data=data,
            files=files,
            auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        return response

    def test_fileshandler_auth_create(self):
        response = self._create_file()
        self.assertTrue(response.ok, response.text)

    def test_fileshandler_auth_read(self):
        uri = api.MAAS_API + "files/"
        response = requests.get(
            uri, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        self.assertThat(len(response.json()), Equals(1))
        self.assertThat(response.json()[0]['filename'], Equals('apitest'))

    def test_fileshandler_auth_get(self):
        uri = api.MAAS_API + "files/?op=get"
        params = {
            'filename': 'apitest'
        }
        response = requests.get(
            uri,
            params=params,
            auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        self.assertThat(len(response.text), GreaterThan(0))

    def test_filehandler_auth_read(self):
        uri = api.MAAS_API + "files/{filename}/".format(
            filename='apitest'
        )
        response = requests.get(
            uri, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        self.shelf['file'] = response.json()
        self.assertThat(response.json()['filename'], Equals('apitest'))

    def test_fileshandler_auth_get_by_key(self):
        uri = urljoin(api.MAAS_API, self.shelf['file']['anon_resource_uri'])
        response = requests.get(
            uri, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        self.assertThat(len(response.text), GreaterThan(0))

    def test_fileshandler_auth_delete(self):
        uri = api.MAAS_API + "files/"
        params = {'filename': 'apitest'}
        response = requests.delete(
            uri,
            params=params,
            auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)

    def test_filehandler_auth_delete(self):
        response = self._create_file()
        uri = api.MAAS_API + "files/apitest/"
        response = requests.delete(
            uri,
            auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)

    def test_tagshandler_auth_create(self):
        uri = api.MAAS_API + "tags/"

        params = {
            'name': 'apitest',
            'comment': 'lorem ipsum',
            'definition': '//node[@id="display"]/clock > 1000000000',
        }

        response = requests.post(
            uri, data=params, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        self.shelf['tag'] = response.json()

    def test_tagshandler_auth_read(self):
        uri = api.MAAS_API + "tags/"
        response = requests.get(
            uri, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        names = [tag['name'] for tag in response.json()]
        self.assertThat(names, Contains('apitest'))

    def test_taghandler_auth_read(self):
        name = self.shelf['tag']['name']
        uri = api.MAAS_API + "tags/{name}/".format(name=name)
        response = requests.get(
            uri, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        self.assertThat(response.json(), Equals(self.shelf['tag']))

    def test_fabricshandler_auth_read(self):
        uri = api.MAAS_API + "fabrics/"

        response = requests.get(
            uri, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)

    def test_fabricshandler_auth_create(self):
        uri = api.MAAS_API + "fabrics/"
        params = {
            'name': 'apitest',
            'description': 'lorem ipsum',
            'class_type': 'generic',
        }
        response = requests.post(
            uri, data=params, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        self.shelf['fabric'] = response.json()

    def test_fabrichandler_auth_update(self):
        fabric_id = self.shelf['fabric']['id']
        uri = api.MAAS_API + "fabrics/{fabric_id}/".format(fabric_id=fabric_id)
        params = {'name': 'newname'}
        response = requests.put(
            uri, data=params, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)

    def test_fabrichandler_auth_read(self):
        fabric_id = self.shelf['fabric']['id']
        uri = api.MAAS_API + "fabrics/{fabric_id}/".format(fabric_id=fabric_id)
        response = requests.get(
            uri, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        expected_fabric = self.shelf['fabric']
        expected_fabric['name'] = 'newname'
        expected_fabric['vlans'][0]['fabric'] = 'newname'
        self.assertThat(response.json(), Equals(expected_fabric))

    def test_fabrichandler_auth_delete(self):
        fabric_id = self.shelf['fabric']['id']
        uri = api.MAAS_API + "fabrics/{fabric_id}/".format(fabric_id=fabric_id)
        response = requests.delete(
            uri, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)

    def _wait_boot_resources_synced(self):
        expected_resources = set([
            (u'ubuntu/xenial', 'amd64/ga-16.04'),
        ])
        complete_resources = set()
        # Wait for sync on region
        while not expected_resources.issubset(complete_resources):
            uri = api.MAAS_API + "boot-resources/"
            response = requests.get(
                uri, auth=self.oauth, headers=api.APP_JSON_HEADER
            )
            for boot_resource in response.json():
                resource_id = boot_resource['id']
                resource_name = boot_resource['name']
                resource_arch = boot_resource['architecture']
                uri = api.MAAS_API + "boot-resources/{id}/".format(
                    id=resource_id,
                )
                response = requests.get(
                    uri, auth=self.oauth, headers=api.APP_JSON_HEADER
                )
                for _, resource_set in response.json()['sets'].items():
                    if resource_set['complete']:
                        complete_resources.add((resource_name, resource_arch))
            time.sleep(5)
        # Wait for sync on rack
        while True:
            racks_uri = api.MAAS_API + "/rackcontrollers/"
            response = requests.get(
                racks_uri, auth=self.oauth, headers=api.APP_JSON_HEADER
            )
            rack_system_id = get_rack_systemid_on_region(response.json())
            rack_images_uri = api.MAAS_API + "/rackcontrollers/{id}/".format(
                id=rack_system_id,
            ) + "?op=list_boot_images"
            response = requests.get(
                rack_images_uri,
                auth=self.oauth, headers=api.APP_JSON_HEADER,
            )
            if response.json()['status'] == 'synced':
                break
            time.sleep(5)

    @timeout(60*60)
    def test_bootresourceshandler_auth_read(self):
        uri = api.MAAS_API + "boot-resources/"

        response = requests.get(
            uri, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)

        self._wait_boot_resources_synced()

    def test_bootresourceshandler_auth_create(self):
        uri = api.MAAS_API + "boot-resources/"

        params = {
            'name': 'apitest',
            'title': 'API Test boot resource',
            'architecture': 'amd64/generic',
            'filetype': 'tgz',
        }
        files = {
            'content': open(self._get_boot_resource_path(), 'rb')
        }
        response = requests.post(
            uri,
            data=params,
            files=files,
            auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        self.shelf['bootresource'] = response.json()

    def test_bootresourcehandler_auth_read(self):
        boot_resource_id = self.shelf['bootresource']['id']
        uri = api.MAAS_API + "boot-resources/{}/".format(boot_resource_id)
        response = requests.get(
            uri, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        self.assertThat(response.json(), Equals(self.shelf['bootresource']))

    def test_bootresourcehandler_auth_delete(self):
        boot_resource_id = self.shelf['bootresource']['id']
        uri = api.MAAS_API + "boot-resources/{}/".format(boot_resource_id)
        response = requests.delete(
            uri, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)

    def test_zoneshandler_auth_create(self):
        uri = api.MAAS_API + "zones/"

        params = {
            'name': 'apitest',
            'description': 'lorem ipsum',
        }

        response = requests.post(
            uri, data=params, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        self.shelf['zone_create'] = response.json()
        self.assertThat(response.json()['name'], Equals('apitest'))
        self.assertThat(response.json()['description'], Equals('lorem ipsum'))

    def test_zoneshandler_auth_read(self):
        uri = api.MAAS_API + "zones/"

        response = requests.get(
            uri, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        names = [zone['name'] for zone in response.json()]
        descriptions = [zone['description'] for zone in response.json()]
        self.assertThat(names, Contains('default'))
        self.assertThat(names, Contains('apitest'))
        self.assertThat(descriptions, Contains('lorem ipsum'))

    def test_zonehandler_auth_update(self):
        name = self.shelf['zone_create']['name']

        uri = api.MAAS_API + "zones/{name}/".format(name=name)

        data = {'name': 'newname'}

        response = requests.put(
            uri, data=data, auth=self.oauth, headers=api.APP_JSON_HEADER
        )

        self.assertTrue(response.ok, response.text)
        self.assertThat(response.json()['name'], Equals('newname'))
        self.shelf['zone_updated'] = response.json()

    def test_zonehandler_auth_read(self):
        name = self.shelf['zone_updated']['name']
        uri = api.MAAS_API + "zones/{name}/".format(
            name=name
        )

        response = requests.get(
            uri, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        zone = self.shelf['zone_updated']
        self.assertTrue(response.ok, response.text)
        self.assertThat(response.json()['name'], Equals(zone['name']))
        self.assertThat(
            response.json()['description'],
            Equals(zone['description'])
        )

    def test_zonehandler_auth_delete(self):
        name = self.shelf['zone_updated']['name']
        uri = api.MAAS_API + "zones/{name}/".format(
            name=name
        )

        response = requests.delete(
            uri, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)

    def test_deviceshandler_auth_set_zone(self):
        system_id = self.shelf['device']['system_id']
        uri = api.MAAS_API + "devices/?op=set_zone"
        data = {
            'zone': 'newname',
            'nodes': system_id
        }
        response = requests.post(
            uri, data=data, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)

    def test_devicehandler_auth_set_owner_data(self):
        system_id = self.shelf['device']['system_id']
        uri = api.MAAS_API + "devices/{system_id}/".format(
            system_id=system_id
        ) + "?op=set_owner_data"
        data = {"foo": "bar"}
        response = requests.post(
            uri,
            data=data,
            auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        self.shelf['device'] = response.json()
        self.assertThat(response.json()['owner_data'], Equals(data))

    def test_devicehandler_auth_update(self):
        system_id = self.shelf['device']['system_id']
        uri = api.MAAS_API + "devices/{system_id}/".format(
            system_id=system_id
        )
        data = {
            'hostname': 'apitest'
        }
        response = requests.put(
            uri,
            data=data,
            auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        self.shelf['device'] = response.json()
        self.assertThat(response.json()['hostname'], Equals('apitest'))

    def test_deviceshandler_auth_read(self):
        uri = api.MAAS_API + "devices/"

        response = requests.get(
            uri, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        expected_device = self.shelf['device']
        expected_device['zone'] = self.shelf['zone_updated']
        self.assertThat(response.json()[0], Equals(self.shelf['device']))

    def test_devicehandler_auth_details(self):
        system_id = self.shelf['device']['system_id']
        uri = api.MAAS_API + "devices/{system_id}/".format(
            system_id=system_id
        ) + "?op=details"
        response = requests.get(
            uri, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        self.assertThat(len(response.text), GreaterThan(0))

    def test_devicehandler_auth_restore_default_configuration(self):
        system_id = self.shelf['device']['system_id']
        uri = api.MAAS_API + "devices/{system_id}/".format(
            system_id=system_id
        ) + "?op=restore_default_configuration"
        response = requests.post(
            uri, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)

    def test_devicehandler_auth_restore_networking_configuration(self):
        system_id = self.shelf['device']['system_id']
        uri = api.MAAS_API + "devices/{system_id}/".format(
            system_id=system_id
        ) + "?op=restore_networking_configuration"
        response = requests.post(
            uri, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)

    def test_devicehandler_auth_delete(self):
        system_id = self.shelf['device']['system_id']
        uri = api.MAAS_API + "devices/{system_id}/".format(system_id=system_id)
        response = requests.delete(
            uri, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)

    @timeout(60*60)
    def test_machineshandler_auth_create(self):
        # First enlist a VM
        # TODO: Maybe this should be in a seperate test function
        self._boot_machines()
        self._wait_machines_in_state(NODE_STATUS.NEW)
        uri = api.MAAS_API + "machines/"
        params = {
            'architecture': 'amd64/generic',
            'mac_addresses': self.random_mac(),
            'power_type': 'manual',
        }
        response = requests.post(
            uri, data=params, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        self.shelf['machine_create'] = response.json()

    def test_machineshandler_auth_read(self):
        uri = api.MAAS_API + "/machines/"

        response = requests.get(
            uri, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        machines = response.json()
        created_machine = None
        for m in machines:
            if m['system_id'] == self.shelf['machine_create']['system_id']:
                created_machine = m
            else:
                self.shelf['other_machine'] = m
        self.assertIsNotNone(created_machine)

    def test_machineshandler_auth_accept(self):
        system_id = self.shelf['other_machine']['system_id']
        uri = api.MAAS_API + "machines/?op=accept"
        params = {'system_ids': system_id}
        response = requests.post(
            uri, data=params, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)

    def test_machineshandler_auth_set_zone(self):
        uri = api.MAAS_API + "machines/?op=set_zone"
        zone = self.shelf['zone_updated']['name']
        system_id = self.shelf['machine_create']['system_id']
        params = {
            'zone': zone,
            'nodes': system_id,
        }
        response = requests.post(
            uri, data=params, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)

    def test_machinehandler_auth_read(self):
        system_id = self.shelf['machine_create']['system_id']
        uri = api.MAAS_API + "/machines/{system_id}/".format(
            system_id=system_id
        )
        response = requests.get(
            uri, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        # The zone was updated
        machine = self.shelf['machine_create']
        machine['zone'] = self.shelf['zone_updated']
        self.assertThat(response.json(), Equals(machine))

    @timeout(30*60)
    def test_machinehandler_auth_commission(self):
        system_id = self.shelf['other_machine']['system_id']
        self._wait_power_state('off', system_id)
        uri = api.MAAS_API + "/machines/{system_id}/".format(
            system_id=system_id
        ) + "?op=commission"
        response = requests.post(
            uri, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        self._wait_machines_in_state(NODE_STATUS.READY, [system_id])

    def test_machinehandler_auth_set_storage_layout(self):
        system_id = self.shelf['other_machine']['system_id']
        uri = api.MAAS_API + "machines/{system_id}/".format(
            system_id=system_id
        ) + "?op=set_storage_layout"
        data = {
            'storage_layout': 'lvm'
        }
        response = requests.post(
            uri, data=data, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)

    def test_machinehandler_auth_restore_storage_configuration(self):
        system_id = self.shelf['other_machine']['system_id']
        uri = api.MAAS_API + "machines/{system_id}/".format(
            system_id=system_id
        ) + "?op=restore_storage_configuration"
        response = requests.post(
            uri, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)

    def test_machinehandler_auth_restore_networking_configuration(self):
        system_id = self.shelf['other_machine']['system_id']
        uri = api.MAAS_API + "machines/{system_id}/".format(
            system_id=system_id
        ) + "?op=restore_networking_configuration"
        response = requests.post(
            uri, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)

    def test_machinehandler_auth_get_curtin_config(self):
        system_id = self.shelf['other_machine']['system_id']
        uri = api.MAAS_API + "machines/{system_id}/".format(
            system_id=system_id
        ) + "?op=get_curtin_config"
        response = requests.get(
            uri, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)

    def test_blockdeviceshandler_auth_read(self):
        system_id = self.shelf['other_machine']['system_id']
        uri = api.MAAS_API + "nodes/{system_id}/blockdevices/".format(
            system_id=system_id
        )
        response = requests.get(
            uri, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        self.shelf['blockdevices'] = response.json()

    def test_blockdevicehandler_auth_add_tag(self):
        system_id = self.shelf['other_machine']['system_id']
        device_id = self.shelf['blockdevices'][0]['id']
        uri = api.MAAS_API + (
            "nodes/{system_id}/blockdevices/{device_id}/".format(
                system_id=system_id,
                device_id=device_id,
            ) + "?op=add_tag"
        )
        data = {
            'tag': 'apitest'
        }
        response = requests.post(
            uri, data=data, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)

    def test_taghandler_auth_devices(self):
        name = self.shelf['tag']['name']

        uri = api.MAAS_API + "tags/{name}/".format(
            name=name
        ) + "?op=devices"

        response = requests.get(
            uri, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)

    def test_machineshandler_auth_allocate(self):
        uri = api.MAAS_API + "machines/?op=allocate"
        params = {
            'system_id': self.shelf['other_machine']['system_id']
        }
        response = requests.post(
            uri, data=params, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)

    def test_machineshandler_auth_list_allocated(self):
        uri = api.MAAS_API + "machines/?op=list_allocated"
        response = requests.get(
            uri, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        self.assertThat(len(response.json()), Equals(1))
        self.assertThat(
            response.json()[0]['system_id'],
            Equals(self.shelf['other_machine']['system_id'])
        )

    def test_machinehandler_auth_deploy(self):
        system_id = self.shelf['other_machine']['system_id']
        uri = api.MAAS_API + "machines/{system_id}/".format(
            system_id=system_id
        ) + "?op=deploy"
        response = requests.post(
            uri, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        self._wait_machines_in_state(NODE_STATUS.DEPLOYED, [system_id])

    def test_machinehandler_auth_power_off(self):
        system_id = self.shelf['other_machine']['system_id']
        uri = api.MAAS_API + "machines/{system_id}/".format(
            system_id=system_id
        ) + "?op=power_off"
        response = requests.post(
            uri, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        self._wait_power_state('off', system_id)

    def test_machinehandler_auth_query_power_state(self):
        system_id = self.shelf['other_machine']['system_id']
        uri = api.MAAS_API + "machines/{system_id}/".format(
            system_id=system_id
        ) + "?op=query_power_state"
        response = requests.get(
            uri, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        self.assertThat(response.json()['state'], Equals('off'))

    def test_machinehandler_auth_power_on(self):
        system_id = self.shelf['other_machine']['system_id']
        uri = api.MAAS_API + "machines/{system_id}/".format(
            system_id=system_id
        ) + "?op=power_on"
        response = requests.post(
            uri, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)

    def test_machinehandler_auth_set_owner_data(self):
        system_id = self.shelf['machine_create']['system_id']
        uri = api.MAAS_API + "machines/{system_id}/".format(
            system_id=system_id
        ) + "?op=set_owner_data"
        params = {"foo": "bar"}
        response = requests.post(
            uri, data=params, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        self.assertThat(response.json()['owner_data'], Equals(params))

    def test_machinehandler_auth_mark_broken(self):
        system_id = self.shelf['machine_create']['system_id']
        uri = api.MAAS_API + "machines/{system_id}/".format(
            system_id=system_id
        ) + "?op=mark_broken"

        response = requests.post(
            uri, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        self.assertThat(response.json()['system_id'], Equals(system_id))
        self.assertThat(response.json()['status_name'], Equals('Broken'))
        self.assertThat(
            response.json()['status_action'], Equals('mark broken')
        )

    def test_machinehandler_auth_mount_special(self):
        system_id = self.shelf['other_machine']['system_id']
        uri = api.MAAS_API + "machines/{system_id}/".format(
            system_id=system_id
        ) + "?op=mount_special"
        data = {
            'fstype': 'tmpfs',
            'mount_point': '/tmp/'
        }
        response = requests.post(
            uri,
            data=data,
            auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        self.assertThat(
            response.json()['special_filesystems'][0]['fstype'],
            Equals('tmpfs')
        )
        self.assertThat(
            response.json()['special_filesystems'][0]['mount_point'],
            Equals('/tmp/')
        )

    def test_machinehandler_auth_unmount_special(self):
        system_id = self.shelf['other_machine']['system_id']
        uri = api.MAAS_API + "machines/{system_id}/".format(
            system_id=system_id
        ) + "?op=unmount_special"
        data = {
            'mount_point': '/tmp/'
        }
        response = requests.post(
            uri,
            data=data,
            auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        self.assertThat(
            response.json()['special_filesystems'],
            Equals([])
        )

    def test_machinehandler_auth_mark_fixed(self):
        system_id = self.shelf['machine_create']['system_id']
        uri = api.MAAS_API + "machines/{system_id}/".format(
            system_id=system_id
        ) + "?op=mark_fixed"

        response = requests.post(
            uri, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        self.assertThat(response.json()['system_id'], Equals(system_id))
        self.assertThat(response.json()['status_name'], Equals('Ready'))
        self.assertThat(response.json()['status_action'], Equals('mark fixed'))

    def test_machinehandler_auth_details(self):
        system_id = self.shelf['machine_create']['system_id']
        uri = api.MAAS_API + "machines/{system_id}/".format(
            system_id=system_id
        ) + "?op=details"

        response = requests.get(
            uri, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        self.assertThat(len(response.text), GreaterThan(0))

    def test_machinehandler_auth_release(self):
        system_id = self.shelf['other_machine']['system_id']
        uri = api.MAAS_API + "machines/{system_id}/".format(
            system_id=system_id
        ) + "?op=release"
        response = requests.post(
            uri, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        self.assertThat(response.json()['system_id'], Equals(system_id))
        self._wait_machines_in_state(NODE_STATUS.READY, [system_id])

    def test_machinehandler_auth_abort(self):
        system_id = self.shelf['other_machine']['system_id']

        # Need to start the machine commissioning before aborting
        commission_uri = api.MAAS_API + "machines/{system_id}/".format(
            system_id=system_id
        ) + "?op=commission"
        response = requests.post(
            commission_uri,
            auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        self._wait_machines_in_state(NODE_STATUS.COMMISSIONING, [system_id])
        time.sleep(10)
        # Now abort
        uri = api.MAAS_API + "machines/{system_id}/".format(
            system_id=system_id
        ) + "?op=abort"
        response = requests.post(
            uri, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)
        self.assertThat(response.json()['system_id'], Equals(system_id))
        self._wait_machines_in_state(NODE_STATUS.NEW, [system_id])

    def test_machinehandler_auth_delete(self):
        uri = api.MAAS_API + "machines/{system_id}/"
        system_id = self.shelf['machine_create']['system_id']
        uri = uri.format(system_id=system_id)

        response = requests.delete(
            uri, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)

    def test_taghandler_auth_delete(self):
        tag_name = self.shelf['tag']['name']
        uri = api.MAAS_API + "tags/{name}/".format(name=tag_name)
        response = requests.delete(
            uri, auth=self.oauth, headers=api.APP_JSON_HEADER
        )
        self.assertTrue(response.ok, response.text)