Import patches-unapplied version 2.2.2-0ubuntu1 to ubuntu/zesty-proposed

Imported using git-ubuntu import.

Changelog parent: 63d399807de30a64456e672063e7c20babf7aadc

New changelog entries:
  * New upstream release (LP: #1651128)
    - d/patches/fix-auto-update.patch,
      d/patches/lp1623570-adjust-walinuxagent-service-after-and-wants.patch:
      - Dropped as changes have been applied upstream
    - Refreshed debian/patches/disable_import_test.patch

4 files changed, 324 insertions, 32 deletions

diff --git a/tests/protocol/mockmetadata.py b/tests/protocol/mockmetadata.py
index dce3367..d41ce88 100644
--- a/tests/protocol/mockmetadata.py
+++ b/tests/protocol/mockmetadata.py
@@ -22,8 +22,11 @@ from azurelinuxagent.common.utils.cryptutil import CryptUtil
 DATA_FILE = {
         "identity": "metadata/identity.json",
         "certificates": "metadata/certificates.json",
+        "certificates_data": "metadata/certificates_data.json",
         "ext_handlers": "metadata/ext_handlers.json",
         "ext_handler_pkgs": "metadata/ext_handler_pkgs.json",
+        "trans_prv": "metadata/trans_prv",
+        "trans_cert": "metadata/trans_cert",        
 }
 
 DATA_FILE_NO_EXT = DATA_FILE.copy()
@@ -33,8 +36,11 @@ class MetadataProtocolData(object):
     def __init__(self, data_files):
         self.identity = load_data(data_files.get("identity"))
         self.certificates = load_data(data_files.get("certificates"))
+        self.certificates_data = load_data(data_files.get("certificates_data"))
         self.ext_handlers = load_data(data_files.get("ext_handlers"))
         self.ext_handler_pkgs = load_data(data_files.get("ext_handler_pkgs"))
+        self.trans_prv = load_data(data_files.get("trans_prv"))
+        self.trans_cert = load_data(data_files.get("trans_cert"))
         
     def mock_http_get(self, url, *args, **kwargs):
         content = None
@@ -42,6 +48,8 @@ class MetadataProtocolData(object):
             content = self.identity
         elif url.count(u"certificates") > 0:
             content = self.certificates
+        elif url.count(u"certificates_data") > 0:
+            content = self.certificates_data
         elif url.count(u"extensionHandlers") > 0:
             content = self.ext_handlers
         elif url.count(u"versionUri") > 0:
diff --git a/tests/protocol/test_hostplugin.py b/tests/protocol/test_hostplugin.py
index 65c8465..3b99050 100644
--- a/tests/protocol/test_hostplugin.py
+++ b/tests/protocol/test_hostplugin.py
@@ -15,23 +15,32 @@
 # Requires Python 2.4+ and Openssl 1.0+
 #
 
-from tests.tools import *
 import unittest
-import azurelinuxagent.common.protocol.wire as wire
+
 import azurelinuxagent.common.protocol.restapi as restapi
+import azurelinuxagent.common.protocol.wire as wire
+import azurelinuxagent.common.protocol.hostplugin as hostplugin
+from tests.protocol.mockwiredata import WireProtocolData, DATA_FILE
+from tests.tools import *
 
 wireserver_url = "168.63.129.16"
 sas_url = "http://sas_url"
+testtype = 'BlockBlob'
 api_versions = '["2015-09-01"]'
 
 
 class TestHostPlugin(AgentTestCase):
     def test_fallback(self):
-        with patch.object(wire.HostPluginProtocol,
-                          "put_vm_status") as patch_put:
-            with patch.object(wire.StatusBlob, "upload") as patch_upload:
-                patch_upload.return_value = False
+        """
+        Validate fallback to upload status using HostGAPlugin is happening when status reporting via
+        default method is unsuccessful
+        """
+        test_goal_state = wire.GoalState(WireProtocolData(DATA_FILE).goal_state)
+
+        with patch.object(wire.HostPluginProtocol, "put_vm_status") as patch_put:
+            with patch.object(wire.StatusBlob, "upload", return_value=False) as patch_upload:
                 wire_protocol_client = wire.WireProtocol(wireserver_url).client
+                wire_protocol_client.get_goal_state = Mock(return_value=test_goal_state)
                 wire_protocol_client.ext_conf = wire.ExtensionsConfig(None)
                 wire_protocol_client.ext_conf.status_upload_blob = sas_url
                 wire_protocol_client.upload_status_blob()
@@ -39,7 +48,43 @@ class TestHostPlugin(AgentTestCase):
                                 "Fallback was not engaged")
                 self.assertTrue(patch_put.call_args[0][1] == sas_url)
 
+    def test_validate_http_request(self):
+        """Validate correct set of data is sent to HostGAPlugin when reporting VM status"""
+        from azurelinuxagent.common.protocol.hostplugin import API_VERSION
+        from azurelinuxagent.common.utils import restutil
+        exp_method = 'PUT'
+        exp_url = 'http://{0}:32526/status'.format(wireserver_url)
+        exp_data = '{"content": "eyJkdW1teSI6ICJkYXRhIn0=", "headers": [{"headerName": ' \
+                   '"x-ms-version", "headerValue": "2014-02-14"}, ' \
+                   '{"headerName": "x-ms-blob-type", "headerValue": "BlockBlob"}], ' \
+                   '"requestUri": "http://sas_url"}'
+        test_goal_state = wire.GoalState(WireProtocolData(DATA_FILE).goal_state)
+
+        with patch.object(restutil, "http_request") as patch_http:
+            wire_protocol_client = wire.WireProtocol(wireserver_url).client
+            wire_protocol_client.get_goal_state = Mock(return_value=test_goal_state)
+            plugin = wire_protocol_client.get_host_plugin()
+            blob = wire_protocol_client.status_blob
+            blob.vm_status = restapi.VMStatus()
+            blob.data = '{"dummy": "data"}'
+            with patch.object(plugin, 'get_api_versions') as patch_api:
+                patch_api.return_value = API_VERSION
+                plugin.put_vm_status(blob, sas_url, testtype)
+                self.assertTrue(patch_http.call_count == 1)
+                self.assertTrue(patch_http.call_args[0][0] == exp_method)
+                self.assertTrue(patch_http.call_args[0][1] == exp_url)
+                self.assertTrue(patch_http.call_args[0][2] == exp_data)
+
+                # Assert headers
+                headers = patch_http.call_args[1]['headers']
+                self.assertEqual(headers['x-ms-containerid'], test_goal_state.container_id)
+                self.assertEqual(headers['x-ms-host-config-name'], test_goal_state.role_config_name)
+
     def test_no_fallback(self):
+        """
+        Validate fallback to upload status using HostGAPlugin is not happening when status reporting via
+        default method is successful
+        """
         with patch.object(wire.HostPluginProtocol,
                           "put_vm_status") as patch_put:
             with patch.object(wire.StatusBlob, "upload") as patch_upload:
@@ -51,21 +96,29 @@ class TestHostPlugin(AgentTestCase):
                 self.assertTrue(patch_put.call_count == 0,
                                 "Fallback was engaged")
 
-    def test_init_put(self):
+    def test_validate_http_put(self):
+        """Validate correct set of data is sent to HostGAPlugin when reporting VM status"""
+        test_goal_state = wire.GoalState(WireProtocolData(DATA_FILE).goal_state)
         expected_url = "http://168.63.129.16:32526/status"
-        expected_headers = {'x-ms-version': '2015-09-01'}
-        expected_content = '{"content": "b2s=", ' \
+        expected_headers = {'x-ms-version': '2015-09-01',
+                            "Content-type": "application/json",
+                            "x-ms-containerid": test_goal_state.container_id,
+                            "x-ms-host-config-name": test_goal_state.role_config_name}
+        expected_content = '{"content": "eyJkdW1teSI6ICJkYXRhIn0=", ' \
                            '"headers": [{"headerName": "x-ms-version", ' \
                            '"headerValue": "2014-02-14"}, ' \
                            '{"headerName": "x-ms-blob-type", "headerValue": ' \
                            '"BlockBlob"}], ' \
                            '"requestUri": "http://sas_url"}'
 
-        host_client = wire.HostPluginProtocol(wireserver_url)
+        host_client = wire.HostPluginProtocol(wireserver_url,
+                                              test_goal_state.container_id,
+                                              test_goal_state.role_config_name)
         self.assertFalse(host_client.is_initialized)
         self.assertTrue(host_client.api_versions is None)
         status_blob = wire.StatusBlob(None)
-        status_blob.vm_status = "ok"
+        status_blob.vm_status = restapi.VMStatus()
+        status_blob.data = '{"dummy": "data"}'
         status_blob.type = "BlockBlob"
         with patch.object(wire.HostPluginProtocol,
                           "get_api_versions") as patch_get:
@@ -77,9 +130,39 @@ class TestHostPlugin(AgentTestCase):
                 self.assertFalse(host_client.api_versions is None)
                 self.assertTrue(patch_put.call_count == 1)
                 self.assertTrue(patch_put.call_args[0][0] == expected_url)
-                self.assertTrue(patch_put.call_args[0][1] == expected_content)
-                self.assertTrue(patch_put.call_args[0][2] == expected_headers)
+                self.assertTrue(patch_put.call_args[1]['data'] == expected_content)
+                self.assertTrue(patch_put.call_args[1]['headers'] == expected_headers)
+
+    def test_validate_get_extension_artifacts(self):
+        test_goal_state = wire.GoalState(WireProtocolData(DATA_FILE).goal_state)
+        expected_url = hostplugin.URI_FORMAT_GET_EXTENSION_ARTIFACT.format(wireserver_url, hostplugin.HOST_PLUGIN_PORT)
+        expected_headers = {'x-ms-version': '2015-09-01',
+                            "x-ms-containerid": test_goal_state.container_id,
+                            "x-ms-host-config-name": test_goal_state.role_config_name,
+                            "x-ms-artifact-location": sas_url}
+
+        host_client = wire.HostPluginProtocol(wireserver_url,
+                                              test_goal_state.container_id,
+                                              test_goal_state.role_config_name)
+        self.assertFalse(host_client.is_initialized)
+        self.assertTrue(host_client.api_versions is None)
+
+        with patch.object(wire.HostPluginProtocol, "get_api_versions", return_value=api_versions) as patch_get:
+            actual_url, actual_headers = host_client.get_artifact_request(sas_url)
+            self.assertTrue(host_client.is_initialized)
+            self.assertFalse(host_client.api_versions is None)
+            self.assertEqual(expected_url, actual_url)
+            for k in expected_headers:
+                self.assertTrue(k in actual_headers)
+                self.assertEqual(expected_headers[k], actual_headers[k])
+
+class MockResponse:
+    def __init__(self, body, status_code):
+        self.body = body
+        self.status = status_code
 
+    def read(self):
+        return self.body
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/tests/protocol/test_metadata.py b/tests/protocol/test_metadata.py
index e2ef57a..f390f7a 100644
--- a/tests/protocol/test_metadata.py
+++ b/tests/protocol/test_metadata.py
@@ -22,7 +22,7 @@ from azurelinuxagent.common.protocol.metadata import MetadataProtocol
 
 @patch("time.sleep")
 @patch("azurelinuxagent.common.protocol.metadata.restutil")
-class TestWireProtocolGetters(AgentTestCase):
+class TestMetadataProtocolGetters(AgentTestCase):
     def _test_getters(self, test_data, mock_restutil ,_):
         mock_restutil.http_get.side_effect = test_data.mock_http_get
 
diff --git a/tests/protocol/test_wire.py b/tests/protocol/test_wire.py
index bd3acaf..8c9cc02 100644
--- a/tests/protocol/test_wire.py
+++ b/tests/protocol/test_wire.py
@@ -15,31 +15,23 @@
 # Requires Python 2.4+ and Openssl 1.0+
 #
 
-from tests.tools import *
+from azurelinuxagent.common.protocol.wire import *
 from tests.protocol.mockwiredata import *
-import uuid
-import unittest
-import os
-import time
-from azurelinuxagent.common.utils.restutil import httpclient
-from azurelinuxagent.common.utils.cryptutil import CryptUtil
-from azurelinuxagent.common.protocol.restapi import *
-from azurelinuxagent.common.protocol.wire import WireClient, WireProtocol, \
-                                          TRANSPORT_PRV_FILE_NAME, \
-                                          TRANSPORT_CERT_FILE_NAME
 
 data_with_bom = b'\xef\xbb\xbfhehe'
+testurl = 'http://foo'
+testtype = 'BlockBlob'
+wireserver_url = '168.63.129.16'
 
 @patch("time.sleep")
 @patch("azurelinuxagent.common.protocol.wire.CryptUtil")
 @patch("azurelinuxagent.common.protocol.wire.restutil")
 class TestWireProtocolGetters(AgentTestCase):
-    
     def _test_getters(self, test_data, mock_restutil, MockCryptUtil, _):
         mock_restutil.http_get.side_effect = test_data.mock_http_get
         MockCryptUtil.side_effect = test_data.mock_crypt_util
 
-        protocol = WireProtocol("foo.bar")
+        protocol = WireProtocol(wireserver_url)
         protocol.detect()
         protocol.get_vminfo()
         protocol.get_certs()
@@ -47,9 +39,9 @@ class TestWireProtocolGetters(AgentTestCase):
         for ext_handler in ext_handlers.extHandlers:
             protocol.get_ext_handler_pkgs(ext_handler)
 
-        crt1 = os.path.join(self.tmp_dir, 
-                           '33B0ABCE4673538650971C10F7D7397E71561F35.crt')
-        crt2 = os.path.join(self.tmp_dir, 
+        crt1 = os.path.join(self.tmp_dir,
+                            '33B0ABCE4673538650971C10F7D7397E71561F35.crt')
+        crt2 = os.path.join(self.tmp_dir,
                             '4037FBF5F1F3014F99B5D6C7799E9B20E6871CB3.crt')
         prv2 = os.path.join(self.tmp_dir,
                             '4037FBF5F1F3014F99B5D6C7799E9B20E6871CB3.prv')
@@ -57,7 +49,7 @@ class TestWireProtocolGetters(AgentTestCase):
         self.assertTrue(os.path.isfile(crt1))
         self.assertTrue(os.path.isfile(crt2))
         self.assertTrue(os.path.isfile(prv2))
-    
+
     def test_getters(self, *args):
         """Normal case"""
         test_data = WireProtocolData(DATA_FILE)
@@ -72,11 +64,220 @@ class TestWireProtocolGetters(AgentTestCase):
         """Extensions without any settings"""
         test_data = WireProtocolData(DATA_FILE_EXT_NO_SETTINGS)
         self._test_getters(test_data, *args)
-        
+
     def test_getters_ext_no_public(self, *args):
         """Extensions without any public settings"""
         test_data = WireProtocolData(DATA_FILE_EXT_NO_PUBLIC)
         self._test_getters(test_data, *args)
 
+    def test_call_storage_kwargs(self,
+                                 mock_restutil,
+                                 mock_cryptutil,
+                                 mock_sleep):
+        from azurelinuxagent.common.utils import restutil
+        with patch.object(restutil, 'http_get') as http_patch:
+            http_req = restutil.http_get
+            url = testurl
+            headers = {}
+
+            # no kwargs
+            WireClient.call_storage_service(http_req)
+            # kwargs, no chk_proxy
+            WireClient.call_storage_service(http_req,
+                                            url,
+                                            headers)
+            # kwargs, chk_proxy False
+            WireClient.call_storage_service(http_req,
+                                            url,
+                                            headers,
+                                            chk_proxy=False)
+            # kwargs, chk_proxy True
+            WireClient.call_storage_service(http_req,
+                                            url,
+                                            headers,
+                                            chk_proxy=True)
+            # assert
+            self.assertTrue(http_patch.call_count == 4)
+            for c in http_patch.call_args_list:
+                self.assertTrue(c[-1]['chk_proxy'] == True)
+
+    def test_status_blob_parsing(self, *args):
+        wire_protocol_client = WireProtocol(wireserver_url).client
+        wire_protocol_client.ext_conf = ExtensionsConfig(WireProtocolData(DATA_FILE).ext_conf)
+        self.assertEqual(wire_protocol_client.ext_conf.status_upload_blob,
+                         u'https://yuezhatest.blob.core.windows.net/vhds/test'
+                         u'-cs12.test-cs12.test-cs12.status?sr=b&sp=rw&se'
+                         u'=9999-01-01&sk=key1&sv=2014-02-14&sig'
+                         u'=hfRh7gzUE7sUtYwke78IOlZOrTRCYvkec4hGZ9zZzXo%3D')
+        self.assertEqual(wire_protocol_client.ext_conf.status_upload_blob_type,
+                         u'BlockBlob')
+        pass
+
+    def test_get_host_ga_plugin(self, *args):
+        wire_protocol_client = WireProtocol(wireserver_url).client
+        goal_state = GoalState(WireProtocolData(DATA_FILE).goal_state)
+
+        with patch.object(WireClient, "get_goal_state", return_value = goal_state) as patch_get_goal_state:
+            host_plugin = wire_protocol_client.get_host_plugin()
+            self.assertEqual(goal_state.container_id, host_plugin.container_id)
+            self.assertEqual(goal_state.role_config_name, host_plugin.role_config_name)
+            patch_get_goal_state.assert_called_once()
+
+    def test_download_ext_handler_pkg_fallback(self, *args):
+        ext_uri = 'extension_uri'
+        host_uri = 'host_uri'
+        mock_host = HostPluginProtocol(host_uri, 'container_id', 'role_config')
+        with patch.object(restutil,
+                          "http_request",
+                          side_effect=IOError) as patch_http:
+            with patch.object(WireClient,
+                              "get_host_plugin",
+                              return_value=mock_host):
+                with patch.object(HostPluginProtocol,
+                                  "get_artifact_request",
+                                  return_value=[host_uri, {}]) as patch_request:
+
+                    WireProtocol(wireserver_url).download_ext_handler_pkg(ext_uri)
+
+                    self.assertEqual(patch_http.call_count, 2)
+                    self.assertEqual(patch_request.call_count, 1)
+
+                    self.assertEqual(patch_http.call_args_list[0][0][1],
+                                     ext_uri)
+                    self.assertEqual(patch_http.call_args_list[1][0][1],
+                                     host_uri)
+
+    def test_upload_status_blob_default(self, *args):
+        wire_protocol_client = WireProtocol(wireserver_url).client
+        wire_protocol_client.ext_conf = ExtensionsConfig(None)
+        wire_protocol_client.ext_conf.status_upload_blob = testurl
+
+        with patch.object(WireClient, "get_goal_state") as patch_get_goal_state:
+            with patch.object(HostPluginProtocol, "put_vm_status") as patch_host_ga_plugin_upload:
+                with patch.object(StatusBlob, "upload", return_value = True) as patch_default_upload:
+                    wire_protocol_client.upload_status_blob()
+
+                    patch_default_upload.assert_called_once_with(testurl)
+                    patch_get_goal_state.assert_not_called()
+                    patch_host_ga_plugin_upload.assert_not_called()
+
+    def test_upload_status_blob_host_ga_plugin(self, *args):
+        wire_protocol_client = WireProtocol(wireserver_url).client
+        wire_protocol_client.ext_conf = ExtensionsConfig(None)
+        wire_protocol_client.ext_conf.status_upload_blob = testurl
+        wire_protocol_client.ext_conf.status_upload_blob_type = testtype
+        goal_state = GoalState(WireProtocolData(DATA_FILE).goal_state)
+
+        with patch.object(HostPluginProtocol, "put_vm_status") as patch_host_ga_plugin_upload:
+            with patch.object(StatusBlob, "upload", return_value=False) as patch_default_upload:
+                wire_protocol_client.get_goal_state = Mock(return_value = goal_state)
+                wire_protocol_client.upload_status_blob()
+
+                patch_default_upload.assert_called_once_with(testurl)
+                wire_protocol_client.get_goal_state.assert_called_once()
+                patch_host_ga_plugin_upload.assert_called_once_with(wire_protocol_client.status_blob, testurl, testtype)
+
+    def test_get_in_vm_artifacts_profile_blob_not_available(self, *args):
+        wire_protocol_client = WireProtocol(wireserver_url).client
+        wire_protocol_client.ext_conf = ExtensionsConfig(None)
+
+        # Test when artifacts_profile_blob is null/None
+        self.assertEqual(None, wire_protocol_client.get_artifacts_profile())
+
+        #Test when artifacts_profile_blob is whitespace
+        wire_protocol_client.ext_conf.artifacts_profile_blob = "  "
+        self.assertEqual(None, wire_protocol_client.get_artifacts_profile())
+
+    def test_get_in_vm_artifacts_profile_response_body_not_valid(self, *args):
+        wire_protocol_client = WireProtocol(wireserver_url).client
+        wire_protocol_client.ext_conf = ExtensionsConfig(None)
+        wire_protocol_client.ext_conf.artifacts_profile_blob = testurl
+        goal_state = GoalState(WireProtocolData(DATA_FILE).goal_state)
+        wire_protocol_client.get_goal_state = Mock(return_value=goal_state)
+
+        with patch.object(HostPluginProtocol, "get_artifact_request",
+                          return_value = ['dummy_url', {}]) as host_plugin_get_artifact_url_and_headers:
+            #Test when response body is None
+            wire_protocol_client.call_storage_service = Mock(return_value=MockResponse(None, 200))
+            in_vm_artifacts_profile = wire_protocol_client.get_artifacts_profile()
+            self.assertTrue(in_vm_artifacts_profile is None)
+
+            #Test when response body is None
+            wire_protocol_client.call_storage_service = Mock(return_value=MockResponse('   '.encode('utf-8'), 200))
+            in_vm_artifacts_profile = wire_protocol_client.get_artifacts_profile()
+            self.assertTrue(in_vm_artifacts_profile is None)
+
+            #Test when response body is None
+            wire_protocol_client.call_storage_service = Mock(return_value=MockResponse('{ }'.encode('utf-8'), 200))
+            in_vm_artifacts_profile = wire_protocol_client.get_artifacts_profile()
+            self.assertEqual(dict(), in_vm_artifacts_profile.__dict__,
+                             'If artifacts_profile_blob has empty json dictionary, in_vm_artifacts_profile '
+                             'should contain nothing')
+
+            host_plugin_get_artifact_url_and_headers.assert_called_with(testurl)
+
+
+    def test_get_in_vm_artifacts_profile_default(self, *args):
+        wire_protocol_client = WireProtocol(wireserver_url).client
+        wire_protocol_client.ext_conf = ExtensionsConfig(None)
+        wire_protocol_client.ext_conf.artifacts_profile_blob = testurl
+        goal_state = GoalState(WireProtocolData(DATA_FILE).goal_state)
+        wire_protocol_client.get_goal_state = Mock(return_value=goal_state)
+
+        wire_protocol_client.call_storage_service = Mock(return_value=MockResponse('{"onHold": "true"}'.encode('utf-8'), 200))
+        in_vm_artifacts_profile = wire_protocol_client.get_artifacts_profile()
+        self.assertEqual(dict(onHold='true'), in_vm_artifacts_profile.__dict__)
+        self.assertTrue(in_vm_artifacts_profile.is_on_hold())
+
+    @patch("time.sleep")
+    def test_fetch_manifest_fallback(self, patch_sleep,  *args):
+        uri1 = ExtHandlerVersionUri()
+        uri1.uri = 'ext_uri'
+        uris = DataContractList(ExtHandlerVersionUri)
+        uris.append(uri1)
+        host_uri = 'host_uri'
+        mock_host = HostPluginProtocol(host_uri,
+                                       'container_id',
+                                       'role_config')
+        client = WireProtocol(wireserver_url).client
+        with patch.object(WireClient,
+                          "fetch",
+                          return_value=None) as patch_fetch:
+            with patch.object(WireClient,
+                              "get_host_plugin",
+                              return_value=mock_host):
+                with patch.object(HostPluginProtocol,
+                                  "get_artifact_request",
+                                  return_value=[host_uri, {}]):
+                    self.assertRaises(ProtocolError, client.fetch_manifest, uris)
+                    self.assertEqual(patch_fetch.call_count, 2)
+                    self.assertEqual(patch_fetch.call_args_list[0][0][0], uri1.uri)
+                    self.assertEqual(patch_fetch.call_args_list[1][0][0], host_uri)
+
+    def test_get_in_vm_artifacts_profile_host_ga_plugin(self, *args):
+        wire_protocol_client = WireProtocol(wireserver_url).client
+        wire_protocol_client.ext_conf = ExtensionsConfig(None)
+        wire_protocol_client.ext_conf.artifacts_profile_blob = testurl
+        goal_state = GoalState(WireProtocolData(DATA_FILE).goal_state)
+        wire_protocol_client.get_goal_state = Mock(return_value=goal_state)
+        wire_protocol_client.fetch = Mock(side_effect=[None, '{"onHold": "true"}'.encode('utf-8')])
+        with patch.object(HostPluginProtocol,
+                          "get_artifact_request",
+                          return_value=['dummy_url', {}]) as artifact_request:
+            in_vm_artifacts_profile = wire_protocol_client.get_artifacts_profile()
+            self.assertTrue(in_vm_artifacts_profile is not None)
+            self.assertEqual(dict(onHold='true'), in_vm_artifacts_profile.__dict__)
+            self.assertTrue(in_vm_artifacts_profile.is_on_hold())
+            artifact_request.assert_called_once_with(testurl)
+
+
+class MockResponse:
+    def __init__(self, body, status_code):
+        self.body = body
+        self.status = status_code
+
+    def read(self):
+        return self.body
+
 if __name__ == '__main__':
     unittest.main()