def test_deploy_instance_and_check_metadata_service(self):
        """
        Test whether it is possible to deploy an instance and check if metadata service is working properly (PhoneHome)
        """

        # skip test if no PhoneHome service endpoint was given by configuration (either in settings or by environment)
        phonehome_endpoint = self.conf[PROPERTIES_CONFIG_TEST][PROPERTIES_CONFIG_TEST_PHONEHOME_ENDPOINT]
        if not phonehome_endpoint:
            self.skipTest("No value found for '{}.{}' setting".format(
                PROPERTIES_CONFIG_TEST, PROPERTIES_CONFIG_TEST_PHONEHOME_ENDPOINT))

        path_resource = PHONEHOME_DBUS_OBJECT_METADATA_PATH
        metadata_service_url = self.conf[PROPERTIES_CONFIG_TEST][PROPERTIES_CONFIG_METADATA_SERVICE_URL]

        # Load userdata from file and compile the template (replacing variable values)
        self.logger.debug("Loading userdata from file '%s'", PHONEHOME_USERDATA_METADATA_PATH)
        with open(PHONEHOME_USERDATA_METADATA_PATH, "r") as userdata_file:
            userdata_content = userdata_file.read()
            userdata_content = replace_template_properties(userdata_content, phonehome_endpoint=phonehome_endpoint,
                                                           path_resource=path_resource,
                                                           openstack_metadata_service_url=metadata_service_url)
            self.logger.debug("Userdata content: %s", userdata_content)

        suffix = datetime.utcnow().strftime('%Y%m%d%H%M%S')

        # Create Metadata
        metadata = {"region": self.region_name, "foo": "bar-" + suffix}

        # Deploy VM
        instance_name = TEST_SERVER_PREFIX + "_meta_" + suffix
        server_id = self.__deploy_instance_helper__(instance_name=instance_name,
                                                    metadata=metadata,
                                                    userdata=userdata_content)

        # VM should have this metadata associated
        expected_metadata = {'region': self.region_name, 'foo': 'bar-' + suffix}
        expected_instance_name = instance_name.replace("_", "-")

        # Create new DBus connection and wait for emitted signal from HTTP PhoneHome service
        client = DbusPhoneHomeClient(self.logger)

        result = client.connect_and_wait_for_phonehome_signal(PHONEHOME_DBUS_NAME, PHONEHOME_DBUS_OBJECT_METADATA_PATH,
                                                              PHONEHOME_METADATA_SIGNAL, expected_instance_name)
        self.assertIsNotNone(result, "PhoneHome request not received from VM '%s'" % server_id)
        self.logger.debug("Request received from VM when 'calling home': %s", result)

        # Get metadata from data received
        self.assertIn("meta", result, "PhoneHome request has been received but 'meta' param is not in")
        received_metadata = json.loads(str(result))["meta"]

        # Check metadata
        self.assertEqual(expected_metadata, received_metadata,
                         "Received metadata '%s' in PhoneHome request does not match with the expected metadata" %
                         received_metadata)
    def test_deploy_instance_and_check_metadata_service(self):
        """
        Test whether it is possible to deploy an instance and check if metadata service is working properly (PhoneHome)
        """

        # skip test if no PhoneHome service endpoint was given by configuration (either in settings or by environment)
        phonehome_endpoint = self.conf[PROPERTIES_CONFIG_TEST][PROPERTIES_CONFIG_TEST_PHONEHOME_ENDPOINT]
        if not phonehome_endpoint:
            self.skipTest("No value found for '{}.{}' setting".format(
                PROPERTIES_CONFIG_TEST, PROPERTIES_CONFIG_TEST_PHONEHOME_ENDPOINT))

        path_resource = PHONEHOME_DBUS_OBJECT_METADATA_PATH
        metadata_service_url = self.conf[PROPERTIES_CONFIG_TEST][PROPERTIES_CONFIG_METADATA_SERVICE_URL]

        # Load userdata from file and compile the template (replacing variable values)
        self.logger.debug("Loading userdata from file '%s'", PHONEHOME_USERDATA_METADATA_PATH)
        with open(PHONEHOME_USERDATA_METADATA_PATH, "r") as userdata_file:
            userdata_content = userdata_file.read()
            userdata_content = replace_template_properties(userdata_content, phonehome_endpoint=phonehome_endpoint,
                                                           path_resource=path_resource,
                                                           openstack_metadata_service_url=metadata_service_url)
            self.logger.debug("Userdata content: %s", userdata_content)

        suffix = datetime.utcnow().strftime('%Y%m%d%H%M%S')

        # Create Metadata
        metadata = {"region": self.region_name, "foo": "bar-" + suffix}

        # Deploy VM
        instance_name = TEST_SERVER_PREFIX + "_meta_" + suffix
        server_id = self.__deploy_instance_helper__(instance_name=instance_name,
                                                    metadata=metadata,
                                                    userdata=userdata_content)

        # VM should have this metadata associated
        expected_metadata = {'region': self.region_name, 'foo': 'bar-' + suffix}
        expected_instance_name = instance_name.replace("_", "-")

        # Create new DBus connection and wait for emitted signal from HTTP PhoneHome service
        client = DbusPhoneHomeClient(self.logger)
        result = client.connect_and_wait_for_phonehome_signal(PHONEHOME_DBUS_NAME, PHONEHOME_DBUS_OBJECT_METADATA_PATH,
                                                              PHONEHOME_METADATA_SIGNAL, expected_instance_name)
        self.assertIsNotNone(result, "PhoneHome request not received from VM '%s'" % server_id)
        self.logger.debug("Request received from VM when 'calling home': %s", result)

        # Get metadata from data received
        self.assertIn("meta", result, "PhoneHome request has been received but 'meta' param is not in")
        received_metadata = json.loads(str(result))["meta"]

        # Check metadata
        self.assertEqual(expected_metadata, received_metadata,
                         "Received metadata '%s' in PhoneHome request does not match with the expected metadata" %
                         received_metadata)
    def test_deploy_instance_and_e2e_snat_connection(self):
        """
        Test whether it is possible to deploy an instance and connect to INTERNET (PhoneHome service)
        """

        # skip test if no PhoneHome service endpoint was given by configuration (either in settings or by environment)
        phonehome_endpoint = self.conf[PROPERTIES_CONFIG_TEST][PROPERTIES_CONFIG_TEST_PHONEHOME_ENDPOINT]
        if not phonehome_endpoint:
            self.skipTest("No value found for '{}.{}' setting".format(
                PROPERTIES_CONFIG_TEST, PROPERTIES_CONFIG_TEST_PHONEHOME_ENDPOINT))

        path_resource = PHONEHOME_DBUS_OBJECT_PATH

        # Load userdata from file and compile the template (replacing variable values)
        self.logger.debug("Loading userdata from file '%s'", PHONEHOME_USERDATA_PATH)
        with open(PHONEHOME_USERDATA_PATH, "r") as userdata_file:
            userdata_content = userdata_file.read()
            userdata_content = replace_template_properties(userdata_content, phonehome_endpoint=phonehome_endpoint,
                                                           path_resource=path_resource)
            self.logger.debug("Userdata content: %s", userdata_content)

        # Deploy VM
        suffix = datetime.utcnow().strftime('%Y%m%d%H%M%S')
        instance_name = TEST_SERVER_PREFIX + "_snat_" + suffix
        server_id = self.__deploy_instance_helper__(instance_name=instance_name,
                                                    userdata=userdata_content)

        # VM will have as hostname, the instance_name with "-" instead of "_"
        expected_instance_name = instance_name.replace("_", "-")

        # Create new new DBus connection and wait for emitted signal from HTTP PhoneHome service
        client = DbusPhoneHomeClient(self.logger)
        result = client.connect_and_wait_for_phonehome_signal(PHONEHOME_DBUS_NAME, PHONEHOME_DBUS_OBJECT_PATH,
                                                              PHONEHOME_SIGNAL, expected_instance_name)
        self.assertIsNotNone(result, "PhoneHome request not received from VM '%s'" % server_id)
        self.logger.debug("Request received from VM when 'calling home': %s", result)

        # Get hostname from data received
        self.assertIn("hostname", result, "PhoneHome request has been received but 'hostname' param is not in")
        received_hostname = re.match(".*hostname=([\w-]*)", result).group(1)

        # Check hostname
        self.assertEqual(expected_instance_name, received_hostname,
                         "Received hostname '%s' in PhoneHome request does not match with the expected instance name" %
                         received_hostname)
    def test_deploy_instance_with_new_network_and_check_metadata_service(self):
        """
        Test whether it is possible to deploy an instance and check if metadata service is working properly (phonehome)
        """

        # skip test if suite couldn't start from an empty, clean list of allocated IPs (to avoid cascading failures)
        if self.suite_world['allocated_ips']:
            self.skipTest("There were pre-existing, not deallocated IPs")

        # skip test if no PhoneHome service endpoint was given by configuration (either in settings or by environment)
        phonehome_endpoint = self.conf[PROPERTIES_CONFIG_TEST][PROPERTIES_CONFIG_TEST_PHONEHOME_ENDPOINT]
        if not phonehome_endpoint:
            self.skipTest("No value found for '{}.{}' setting".format(
                PROPERTIES_CONFIG_TEST, PROPERTIES_CONFIG_TEST_PHONEHOME_ENDPOINT))

        path_resource = PHONEHOME_DBUS_OBJECT_METADATA_PATH
        metadata_service_url = self.conf[PROPERTIES_CONFIG_TEST][PROPERTIES_CONFIG_METADATA_SERVICE_URL]

        # Load userdata from file and compile the template (replacing variable values)
        self.logger.debug("Loading userdata from file '%s'", PHONEHOME_USERDATA_METADATA_PATH)
        with open(PHONEHOME_USERDATA_METADATA_PATH, "r") as userdata_file:
            userdata_content = userdata_file.read()
            userdata_content = replace_template_properties(userdata_content, phonehome_endpoint=phonehome_endpoint,
                                                           path_resource=path_resource,
                                                           openstack_metadata_service_url=metadata_service_url)

            self.logger.debug("Userdata content: %s", userdata_content)

        # Create Router with an external network gateway
        suffix = datetime.utcnow().strftime('%Y%m%d%H%M%S')
        router_name = TEST_ROUTER_PREFIX + "_meta_" + suffix
        external_network_id = self.__get_external_network_test_helper__()
        router_id = self.__create_router_test_helper__(router_name, external_network_id)

        # Create Network
        network_name = TEST_NETWORK_PREFIX + "_" + suffix
        network_id, subnet_id = self.__create_network_and_subnet_test_helper__(network_name)

        # Add interface to router
        port_id = self.neutron_operations.add_interface_router(router_id, subnet_id)
        self.test_world['ports'].append(port_id)

        # Create Metadata
        metadata = {"region": self.region_name, "foo": "bar-" + suffix}

        # Deploy VM
        instance_name = self.region_name.lower() + "_" + TEST_SERVER_PREFIX + "_meta_" + suffix
        server_id = self.__deploy_instance_helper__(instance_name=instance_name,
                                                    network_name=network_name, is_network_new=False,
                                                    metadata=metadata,
                                                    userdata=userdata_content)

        # VM should have this metadata associated
        expected_metadata = {'region': self.region_name, 'foo': 'bar-' + suffix}
        expected_instance_name = instance_name.replace("_", "-")

        # Create new DBus connection and wait for emitted signal from HTTP PhoneHome service
        client = DbusPhoneHomeClient(self.logger)

        result = client.connect_and_wait_for_phonehome_signal(PHONEHOME_DBUS_NAME, PHONEHOME_DBUS_OBJECT_METADATA_PATH,
                                                              PHONEHOME_METADATA_SIGNAL, expected_instance_name)

        # First, check that the DBus is registered on the system
        self.assertNotEqual(result, False, "PhoneHome bus or object not found. Please check the PhoneHome services.")

        self.assertIsNotNone(result, "PhoneHome request not received from VM '%s'" % server_id)
        self.logger.debug("Request received from VM when 'calling home': %s", result)

        # Get metadata from data received
        self.assertIn("meta", result, "PhoneHome request has been received but 'meta' param is not in")
        received_metadata = json.loads(str(result))["meta"]

        # Check metadata
        self.assertEqual(expected_metadata, received_metadata,
                         "Received metadata '%s' in PhoneHome request does not match with the expected metadata" %
                         received_metadata)
    def __e2e_snat_connection_test_helper__(self, use_shared_network=True):
        """
        HELPER. Test whether it is possible to deploy an instance and connect to the internet (PhoneHome service)

        :param use_shared_network: If True, use the existing shared network associated to the new instance
        """

        # skip test if suite couldn't start from an empty, clean list of allocated IPs (to avoid cascading failures)
        if self.suite_world['allocated_ips']:
            self.skipTest("There were pre-existing, not deallocated IPs")

        # skip test if no PhoneHome service endpoint was given by configuration (either in settings or by environment)
        phonehome_endpoint = self.conf[PROPERTIES_CONFIG_TEST][PROPERTIES_CONFIG_TEST_PHONEHOME_ENDPOINT]
        if not phonehome_endpoint:
            self.skipTest("No value found for '{}.{}' setting".format(
                PROPERTIES_CONFIG_TEST, PROPERTIES_CONFIG_TEST_PHONEHOME_ENDPOINT))

        path_resource = PHONEHOME_DBUS_OBJECT_PATH

        # Load userdata from file and compile the template (replacing variable values)
        self.logger.debug("Loading userdata from file '%s'", PHONEHOME_USERDATA_PATH)
        with open(PHONEHOME_USERDATA_PATH, "r") as userdata_file:
            userdata_content = userdata_file.read()
            userdata_content = replace_template_properties(userdata_content, phonehome_endpoint=phonehome_endpoint,
                                                           path_resource=_build_path_resource(path_resource))
            self.logger.debug("Userdata content: %s", userdata_content)

        suffix = datetime.utcnow().strftime('%Y%m%d%H%M%S')

        # Network
        if use_shared_network:
            network_name = self.__get_shared_network_test_helper__()
        else:
            # Create Router with an external network gateway
            router_name = TEST_ROUTER_PREFIX + "_snat_" + suffix
            external_network_id = self.__get_external_network_test_helper__()
            router_id = self.__create_router_test_helper__(router_name, external_network_id)

            # Create Network
            network_name = TEST_NETWORK_PREFIX + "_" + suffix
            network_id, subnet_id = self.__create_network_and_subnet_test_helper__(network_name)

            # Add interface to router
            port_id = self.neutron_operations.add_interface_router(router_id, subnet_id)
            self.test_world['ports'].append(port_id)

        # Deploy VM
        instance_name = self.region_name.lower() + "_" + TEST_SERVER_PREFIX + "_snat_" + suffix
        server_id = self.__deploy_instance_helper__(instance_name=instance_name,
                                                    network_name=network_name, is_network_new=False,
                                                    userdata=userdata_content)

        # VM will have as hostname, the instance_name with "-" instead of "_"
        expected_instance_name = instance_name.replace("_", "-")

        # Create new new DBus connection and wait for emitted signal from HTTP PhoneHome service
        client = DbusPhoneHomeClient(self.logger)
        result = client.connect_and_wait_for_phonehome_signal(PHONEHOME_DBUS_NAME, PHONEHOME_DBUS_OBJECT_PATH,
                                                              PHONEHOME_SIGNAL, expected_instance_name)
        self.assertIsNotNone(result, "PhoneHome request not received from VM '%s'" % server_id)
        self.logger.debug("Request received from VM when 'calling home': %s", result)

        # Get hostname from data received
        self.assertIn("hostname", result, "PhoneHome request has been received but 'hostname' param is not in")
        received_hostname = re.match(".*hostname=([\w-]*)", result).group(1)

        # Check hostname
        self.assertEqual(expected_instance_name, received_hostname,
                         "Received hostname '%s' in PhoneHome request does not match with the expected instance name" %
                         received_hostname)
    def test_deploy_instance_with_networks_and_e2e_snat_connection(self):
        """
        Test whether it is possible to deploy an instance with new network and connect to INTERNET (PhoneHome service)
        """

        # skip test if suite couldn't start from an empty, clean list of allocated IPs (to avoid cascading failures)
        if self.suite_world['allocated_ips']:
            self.skipTest("There were pre-existing, not deallocated IPs")

        # skip test if no PhoneHome service endpoint was given by configuration (either in settings or by environment)
        phonehome_endpoint = self.conf[PROPERTIES_CONFIG_TEST][PROPERTIES_CONFIG_TEST_PHONEHOME_ENDPOINT]
        if not phonehome_endpoint:
            self.skipTest("No value found for '{}.{}' setting".format(
                PROPERTIES_CONFIG_TEST, PROPERTIES_CONFIG_TEST_PHONEHOME_ENDPOINT))

        # Load userdata from file and compile the template (replacing {{phonehome_endpoint}} value)
        self.logger.debug("Loading userdata from file '%s'", PHONEHOME_USERDATA_PATH)
        with open(PHONEHOME_USERDATA_PATH, "r") as userdata_file:
            userdata_content = userdata_file.read()
            userdata_content = replace_template_properties(userdata_content, phonehome_endpoint=phonehome_endpoint)
            self.logger.debug("Userdata content: %s", userdata_content)
            phonehome_port = urlparse.urlsplit(phonehome_endpoint).port
            self.logger.debug("PhoneHome port to be used by server: %d", phonehome_port)

        # Create Router with an external network gateway
        suffix = datetime.utcnow().strftime('%Y%m%d%H%M%S')
        router_name = TEST_ROUTER_PREFIX + "_snat_" + suffix
        external_network_id = self.__get_external_network_test_helper__()
        router_id = self.__create_router_test_helper__(router_name, external_network_id)

        # Create Network
        network_name = TEST_NETWORK_PREFIX + "_" + suffix
        network_id, subnet_id = self.__create_network_and_subnet_test_helper__(network_name)

        # Add interface to router
        port_id = self.neutron_operations.add_interface_router(router_id, subnet_id)
        self.test_world['ports'].append(port_id)

        # Deploy VM
        instance_name = TEST_SERVER_PREFIX + "_snat_" + suffix
        server_id = self.__deploy_instance_helper__(instance_name=instance_name,
                                                    network_name=network_name, is_network_new=False,
                                                    userdata=userdata_content)

        # Create and launch a PhoneHome service listening at <localhost:phonehome_port>. Wait for request from VM
        http_phonehome_server = HttpPhoneHomeServer(logger=self.logger, port=phonehome_port, timeout=PHONEHOME_TIMEOUT)
        http_phonehome_server.start()
        self.assertIsNotNone(get_phonehome_content(), "Phone-Home request not received from VM '%s'" % server_id)
        call_content = get_phonehome_content()
        self.logger.debug("Request received from VM when 'calling home': %s", call_content)

        # Get hostname from data received
        self.assertIn("hostname", call_content, "Phone-Home request has been received but 'hostname' param is not in")
        hostname_received = re.match(".*hostname=([\w-]*)", call_content).group(1)

        # Check hostname (VM will have as hostname, the instance_name with "-" instead of "_")
        self.assertEqual(instance_name.replace("_", "-"), hostname_received,
                         "Received hostname '%s' in PhoneHome request does not match with the expected instance name" %
                         hostname_received)

        reset_phonehome_content()
    def test_deploy_instance_with_new_network_and_check_metadata_service(self):
        """
        Test whether it is possible to deploy an instance and check if metadata service is working properly (phonehome)
        """

        # skip test if suite couldn't start from an empty, clean list of allocated IPs (to avoid cascading failures)
        if self.suite_world['allocated_ips']:
            self.skipTest("There were pre-existing, not deallocated IPs")

        # skip test if no PhoneHome service endpoint was given by configuration (either in settings or by environment)
        phonehome_endpoint = self.conf[PROPERTIES_CONFIG_TEST][
            PROPERTIES_CONFIG_TEST_PHONEHOME_ENDPOINT]
        if not phonehome_endpoint:
            self.skipTest("No value found for '{}.{}' setting".format(
                PROPERTIES_CONFIG_TEST,
                PROPERTIES_CONFIG_TEST_PHONEHOME_ENDPOINT))

        path_resource = PHONEHOME_DBUS_OBJECT_METADATA_PATH
        metadata_service_url = self.conf[PROPERTIES_CONFIG_TEST][
            PROPERTIES_CONFIG_METADATA_SERVICE_URL]

        # Load userdata from file and compile the template (replacing variable values)
        self.logger.debug("Loading userdata from file '%s'",
                          PHONEHOME_USERDATA_METADATA_PATH)
        with open(PHONEHOME_USERDATA_METADATA_PATH, "r") as userdata_file:
            userdata_content = userdata_file.read()
            userdata_content = replace_template_properties(
                userdata_content,
                phonehome_endpoint=phonehome_endpoint,
                path_resource=path_resource,
                openstack_metadata_service_url=metadata_service_url)

            self.logger.debug("Userdata content: %s", userdata_content)

        # Create Router with an external network gateway
        suffix = datetime.utcnow().strftime('%Y%m%d%H%M%S')
        router_name = TEST_ROUTER_PREFIX + "_meta_" + suffix
        external_network_id = self.__get_external_network_test_helper__()
        router_id = self.__create_router_test_helper__(router_name,
                                                       external_network_id)

        # Create Network
        network_name = TEST_NETWORK_PREFIX + "_" + suffix
        network_id, subnet_id = self.__create_network_and_subnet_test_helper__(
            network_name)

        # Add interface to router
        port_id = self.neutron_operations.add_interface_router(
            router_id, subnet_id)
        self.test_world['ports'].append(port_id)

        # Create Metadata
        metadata = {"region": self.region_name, "foo": "bar-" + suffix}

        # Deploy VM
        instance_name = TEST_SERVER_PREFIX + "_meta_" + suffix
        server_id = self.__deploy_instance_helper__(
            instance_name=instance_name,
            network_name=network_name,
            is_network_new=False,
            metadata=metadata,
            userdata=userdata_content)

        # VM should have this metadata associated
        expected_metadata = {
            'region': self.region_name,
            'foo': 'bar-' + suffix
        }
        expected_instance_name = instance_name.replace("_", "-")

        # Create new DBus connection and wait for emitted signal from HTTP PhoneHome service
        client = DbusPhoneHomeClient(self.logger)

        result = client.connect_and_wait_for_phonehome_signal(
            PHONEHOME_DBUS_NAME, PHONEHOME_DBUS_OBJECT_METADATA_PATH,
            PHONEHOME_METADATA_SIGNAL, expected_instance_name)

        # First, check that the DBus is registered on the system
        self.assertNotEqual(
            result, False,
            "PhoneHome bus or object not found. Please check the PhoneHome services."
        )

        self.assertIsNotNone(
            result, "PhoneHome request not received from VM '%s'" % server_id)
        self.logger.debug("Request received from VM when 'calling home': %s",
                          result)

        # Get metadata from data received
        self.assertIn(
            "meta", result,
            "PhoneHome request has been received but 'meta' param is not in")
        received_metadata = json.loads(str(result))["meta"]

        # Check metadata
        self.assertEqual(
            expected_metadata, received_metadata,
            "Received metadata '%s' in PhoneHome request does not match with the expected metadata"
            % received_metadata)
    def __e2e_snat_connection_test_helper__(self, use_shared_network=True):
        """
        HELPER. Test whether it is possible to deploy an instance and connect to the internet (PhoneHome service)

        :param use_shared_network: If True, use the existing shared network associated to the new instance
        """

        # skip test if suite couldn't start from an empty, clean list of allocated IPs (to avoid cascading failures)
        if self.suite_world['allocated_ips']:
            self.skipTest("There were pre-existing, not deallocated IPs")

        # skip test if no PhoneHome service endpoint was given by configuration (either in settings or by environment)
        phonehome_endpoint = self.conf[PROPERTIES_CONFIG_TEST][
            PROPERTIES_CONFIG_TEST_PHONEHOME_ENDPOINT]
        if not phonehome_endpoint:
            self.skipTest("No value found for '{}.{}' setting".format(
                PROPERTIES_CONFIG_TEST,
                PROPERTIES_CONFIG_TEST_PHONEHOME_ENDPOINT))

        path_resource = self.__add_transaction_id(PHONEHOME_DBUS_OBJECT_PATH)

        # Load userdata from file and compile the template (replacing variable values)
        self.logger.debug("Loading userdata from file '%s'",
                          PHONEHOME_USERDATA_PATH)
        with open(PHONEHOME_USERDATA_PATH, "r") as userdata_file:
            userdata_content = userdata_file.read()
            userdata_content = replace_template_properties(
                userdata_content,
                phonehome_endpoint=phonehome_endpoint,
                path_resource=path_resource)
            self.logger.debug("Userdata content: %s", userdata_content)

        suffix = datetime.utcnow().strftime('%Y%m%d%H%M%S')

        # Network
        if use_shared_network:
            network_name = self.__get_shared_network_test_helper__()
        else:
            # Create Router with an external network gateway
            router_name = TEST_ROUTER_PREFIX + "_snat_" + suffix
            external_network_id = self.__get_external_network_test_helper__()
            router_id = self.__create_router_test_helper__(
                router_name, external_network_id)

            # Create Network
            network_name = TEST_NETWORK_PREFIX + "_" + suffix
            network_id, subnet_id = self.__create_network_and_subnet_test_helper__(
                network_name)

            # Add interface to router
            port_id = self.neutron_operations.add_interface_router(
                router_id, subnet_id)
            self.test_world['ports'].append(port_id)

        # Deploy VM
        instance_name = TEST_SERVER_PREFIX + "_snat_" + suffix
        server_id = self.__deploy_instance_helper__(
            instance_name=instance_name,
            network_name=network_name,
            is_network_new=False,
            userdata=userdata_content)

        # VM will have as hostname, the instance_name with "-" instead of "_"
        expected_instance_name = instance_name.replace("_", "-")

        # Create new new DBus connection and wait for emitted signal from HTTP PhoneHome service
        client = DbusPhoneHomeClient(self.logger)
        result = client.connect_and_wait_for_phonehome_signal(
            PHONEHOME_DBUS_NAME, PHONEHOME_DBUS_OBJECT_PATH, PHONEHOME_SIGNAL,
            expected_instance_name)
        self.assertIsNotNone(
            result, "PhoneHome request not received from VM '%s'" % server_id)
        self.logger.debug("Request received from VM when 'calling home': %s",
                          result)

        # Get hostname from data received
        self.assertIn(
            "hostname", result,
            "PhoneHome request has been received but 'hostname' param is not in"
        )
        received_hostname = re.match(".*hostname=([\w-]*)", result).group(1)

        # Check hostname
        self.assertEqual(
            expected_instance_name, received_hostname,
            "Received hostname '%s' in PhoneHome request does not match with the expected instance name"
            % received_hostname)