Import patches-unapplied version 2.1.2-0ubuntu1 to ubuntu/xenial-proposed

Imported using git-ubuntu import.

Changelog parent: 04946cba49f19c0b6b876bccdbb36d47334af002

New changelog entries:
  * New upstream release (LP: #1523715):
    - Bug fixes for Ubuntu 15.10 on Azure
    - Enablement for Azure Stack
    - Dropped patch for systemd job as upstream now includes it.

10 files changed, 362 insertions, 106 deletions

diff --git a/tests/test_certificates.py b/tests/test_certificates.py
index 2950c6b..18f28c4 100644
--- a/tests/test_certificates.py
+++ b/tests/test_certificates.py
@@ -184,7 +184,8 @@ class TestCertificates(unittest.TestCase):
                             transport_cert)
         fileutil.write_file(os.path.join('/tmp', "TransportPrivate.pem"), 
                             transport_private)
-        config = v1.Certificates(certs_sample)
+        client = v1.WireClient("http://foo.bar")
+        config = v1.Certificates(client, certs_sample)
         self.assertNotEquals(None, config)
         self.assertTrue(os.path.isfile(crt1))
         self.assertTrue(os.path.isfile(crt2))
diff --git a/tests/test_datacontract.py b/tests/test_datacontract.py
new file mode 100644
index 0000000..4d4edd7
--- /dev/null
+++ b/tests/test_datacontract.py
@@ -0,0 +1,54 @@
+# Copyright 2014 Microsoft Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Requires Python 2.4+ and Openssl 1.0+
+#
+# Implements parts of RFC 2131, 1541, 1497 and
+# http://msdn.microsoft.com/en-us/library/cc227282%28PROT.10%29.aspx
+# http://msdn.microsoft.com/en-us/library/cc227259%28PROT.13%29.aspx
+
+import tests.env
+from tests.tools import *
+import uuid
+import unittest
+import os
+import shutil
+import time
+from azurelinuxagent.protocol.common import *
+
+class SampleDataContract(DataContract):
+    def __init__(self):
+        self.foo = None
+        self.bar = DataContractList(int)
+
+class TestDataContract(unittest.TestCase):
+    def test_get_properties(self):
+        obj = SampleDataContract()
+        obj.foo = "foo"
+        obj.bar.append(1)
+        data = get_properties(obj)
+        self.assertEquals("foo", data["foo"])
+        self.assertEquals(list, type(data["bar"]))
+
+    def test_set_properties(self):
+        obj = SampleDataContract()
+        data = {
+                'foo' : 1, 
+                'baz': 'a'
+        }
+        set_properties('sample', obj, data)
+        self.assertFalse(hasattr(obj, 'baz'))
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/test_ext.py b/tests/test_ext.py
index 126c0ec..a68a851 100644
--- a/tests/test_ext.py
+++ b/tests/test_ext.py
@@ -51,8 +51,8 @@ ext_sample_json = {
         }]
     }
 }
-ext_sample = prot.Extension()
-prot.set_properties(ext_sample, ext_sample_json)
+ext_sample = prot.ExtHandler()
+prot.set_properties("extensions", ext_sample, ext_sample_json)
 
 pkd_list_sample_str={
     "versions": [{
@@ -67,8 +67,8 @@ pkd_list_sample_str={
          }]
     }]
 }
-pkg_list_sample = prot.ExtensionPackageList()
-prot.set_properties(pkg_list_sample, pkd_list_sample_str)
+pkg_list_sample = prot.ExtHandlerPackageList()
+prot.set_properties("packages", pkg_list_sample, pkd_list_sample_str)
 
 manifest_sample_str = {
     "handlerManifest":{
@@ -81,11 +81,50 @@ manifest_sample_str = {
 }
 manifest_sample = ext.HandlerManifest(manifest_sample_str)
 
+ext_status_sample="""
+[{
+    "version": 1.0,
+    "timestampUTC": "2015-11-12T06:59:48Z",
+    "status": {
+        "name": "<Handler workload name>",
+        "operation": "<name of the operation being performed>",
+        "configurationAppliedTime": "2015-11-12T06:59:48Z",
+        "status": "error",
+        "code": 0,
+        "formattedMessage": {
+            "lang": "en-US",
+            "message": "formatted user message"
+        },
+        "substatus": [{
+            "name": "<Handler workload subcomponent name>",
+            "status": "error",
+            "code": 0 ,
+            "formattedMessage": {
+                "lang": "lang[-locale]",
+                "message": "formatted user message"
+            }
+        },{
+            "status": "error"
+        }]
+    }
+}]
+"""
+
+ext_status_sample_min="""
+[{
+    "version": 1.0,
+    "timestampUTC": "2015-11-12T06:59:48Z",
+    "status": {
+        "status": "error"
+    }
+}]
+"""
+
 def mock_load_manifest(self):
     return manifest_sample
 
 mock_launch_command = MockFunc()
-mock_set_handler_status = MockFunc()
+mock_set_state = MockFunc()
 
 def mock_download(self):
     fileutil.mkdir(self.get_base_dir())
@@ -106,14 +145,16 @@ class TestExtensions(unittest.TestCase):
         self.assertEqual('2.1', test_ext)
 
     def test_getters(self):
-        test_ext = ext.ExtensionInstance(ext_sample, pkg_list_sample, 
-                                        ext_sample.properties.version, False)
+        test_ext = ext.ExtHandlerInstance(ext_sample, pkg_list_sample, 
+                                          ext_sample.properties.version, False)
         self.assertEqual("/tmp/TestExt-2.0", test_ext.get_base_dir())
         self.assertEqual("/tmp/TestExt-2.0/status", test_ext.get_status_dir())
         self.assertEqual("/tmp/TestExt-2.0/status/0.status", 
                          test_ext.get_status_file())
-        self.assertEqual("/tmp/TestExt-2.0/config/HandlerState", 
+        self.assertEqual("/tmp/handler_state/TestExt-2.0/0.state", 
                          test_ext.get_handler_state_file())
+        self.assertEqual("/tmp/handler_state/TestExt-2.0/0.error", 
+                         test_ext.get_handler_state_err_file())
         self.assertEqual("/tmp/TestExt-2.0/config", test_ext.get_conf_dir())
         self.assertEqual("/tmp/TestExt-2.0/config/0.settings", 
                          test_ext.get_settings_file())
@@ -125,53 +166,57 @@ class TestExtensions(unittest.TestCase):
                          test_ext.get_env_file())
         self.assertEqual("/tmp/log/TestExt/2.0", test_ext.get_log_dir())
 
-        test_ext = ext.ExtensionInstance(ext_sample, pkg_list_sample, "2.1", False)
+        test_ext = ext.ExtHandlerInstance(ext_sample, pkg_list_sample, 
+                                          "2.1", False)
         self.assertEqual("/tmp/TestExt-2.1", test_ext.get_base_dir())
         self.assertEqual("2.1", test_ext.get_target_version())
    
-    @mock(ext.ExtensionInstance, 'load_manifest', mock_load_manifest)
-    @mock(ext.ExtensionInstance, 'launch_command', mock_launch_command)
-    @mock(ext.ExtensionInstance, 'set_handler_status', mock_set_handler_status)
+    @mock(ext.ExtHandlerInstance, 'load_manifest', mock_load_manifest)
+    @mock(ext.ExtHandlerInstance, 'launch_command', mock_launch_command)
+    @mock(ext.ExtHandlerInstance, 'set_state', mock_set_state)
     def test_handle_uninstall(self):
         mock_launch_command.args = None
-        mock_set_handler_status.args = None
-        test_ext = ext.ExtensionInstance(ext_sample, pkg_list_sample, 
-                                        ext_sample.properties.version, False)
+        mock_set_state.args = None
+        test_ext = ext.ExtHandlerInstance(ext_sample, pkg_list_sample, 
+                                          ext_sample.properties.version, False)
+        if not os.path.isdir(test_ext.get_base_dir()):
+            os.makedirs(test_ext.get_base_dir())
         test_ext.handle_uninstall()
         self.assertEqual(None, mock_launch_command.args)
-        self.assertEqual(None, mock_set_handler_status.args)
-        self.assertEqual(None, test_ext.get_curr_op())
+        self.assertEqual(None, mock_set_state.args)
 
-        test_ext = ext.ExtensionInstance(ext_sample, pkg_list_sample, 
-                                        ext_sample.properties.version, True)
+        test_ext = ext.ExtHandlerInstance(ext_sample, pkg_list_sample, 
+                                          ext_sample.properties.version, True)
+        if not os.path.isdir(test_ext.get_base_dir()):
+            os.makedirs(test_ext.get_base_dir())
         test_ext.handle_uninstall()
-        self.assertEqual(manifest_sample.get_uninstall_command(), mock_launch_command.args[0])
-        self.assertEqual("UnInstall", test_ext.get_curr_op())
-        self.assertEqual("NotReady", mock_set_handler_status.args[0])
-
-    @mock(ext.ExtensionInstance, 'load_manifest', mock_load_manifest)
-    @mock(ext.ExtensionInstance, 'launch_command', mock_launch_command)
-    @mock(ext.ExtensionInstance, 'download', mock_download)
-    @mock(ext.ExtensionInstance, 'get_handler_status', MockFunc(retval="enabled"))
-    @mock(ext.ExtensionInstance, 'set_handler_status', mock_set_handler_status)
-    def test_handle(self):
+        self.assertEqual(manifest_sample.get_uninstall_command(), 
+                         mock_launch_command.args[0])
+    
+    @mock(ext.ExtHandlerInstance, 'upgrade', MockFunc())
+    @mock(ext.ExtHandlerInstance, 'enable', MockFunc())
+    @mock(ext.ExtHandlerInstance, 'download', MockFunc())
+    @mock(ext.ExtHandlerInstance, 'init_dir', MockFunc())
+    @mock(ext.ExtHandlerInstance, 'install', MockFunc())
+    def test_handle_enable(self):
         #Test enable
-        test_ext = ext.ExtensionInstance(ext_sample, pkg_list_sample, 
-                                        ext_sample.properties.version, False)
-        test_ext.init_logger()
-        self.assertEqual(1, len(test_ext.logger.appenders) - len(logger.DEFAULT_LOGGER.appenders))
-        test_ext.handle()
-        
+        test_ext = ext.ExtHandlerInstance(ext_sample, pkg_list_sample, 
+                                          ext_sample.properties.version, False)
+        test_ext.handle_enable()
+     
         #Test upgrade 
-        test_ext = ext.ExtensionInstance(ext_sample, pkg_list_sample, 
-                                        ext_sample.properties.version, False)
-        test_ext.init_logger()
-        self.assertEqual(1, len(test_ext.logger.appenders) - len(logger.DEFAULT_LOGGER.appenders))
-        test_ext.handle()
+        test_ext = ext.ExtHandlerInstance(ext_sample, pkg_list_sample, 
+                                          "2.0" , True)
+        test_ext.handle_enable()
 
     def test_status_convert(self):
-        ext_status = json.loads('[{"status": {"status": "success", "formattedMessage": {"lang": "en-US", "message": "Script is finished"}, "operation": "Enable", "code": "0", "name": "Microsoft.OSTCExtensions.CustomScriptForLinux"}, "version": "1.0", "timestampUTC": "2015-06-27T08:34:50Z"}]')
-        ext.ext_status_to_v2(ext_status[0], 0)
+        data = json.loads(ext_status_sample)
+        ext_status = prot.ExtensionStatus()
+        ext.parse_ext_status(ext_status, data)
+
+        data = json.loads(ext_status_sample_min)
+        ext_status = prot.ExtensionStatus()
+        ext.parse_ext_status(ext_status, data)
 
 
 if __name__ == '__main__':
diff --git a/tests/test_extensionsconfig.py b/tests/test_extensionsconfig.py
index 4dbf30d..505c73d 100644
--- a/tests/test_extensionsconfig.py
+++ b/tests/test_extensionsconfig.py
@@ -128,7 +128,7 @@ EmptyPublicSettings=u"""\
 class TestExtensionsConfig(unittest.TestCase):
     def test_extensions_config(self):
         config = v1.ExtensionsConfig(ext_conf_sample)
-        extensions = config.ext_list.extensions
+        extensions = config.ext_handlers.extHandlers
         self.assertNotEquals(None, extensions)
         self.assertEquals(1, len(extensions))
         self.assertNotEquals(None, extensions[0])
diff --git a/tests/test_logger.py b/tests/test_logger.py
index 121a8fe..20e9259 100644
--- a/tests/test_logger.py
+++ b/tests/test_logger.py
@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright 2014 Microsoft Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -30,7 +31,7 @@ class TestLogger(unittest.TestCase):
     def test_no_appender(self):
         #The logger won't throw exception even if no appender.
         _logger = logger.Logger()
-        _logger.verbose("Assert no exception")
+        _logger.verb("Assert no exception")
         _logger.info("Assert no exception")
         _logger.warn("Assert no exception")
         _logger.error("Assert no exception")
@@ -40,14 +41,14 @@ class TestLogger(unittest.TestCase):
         _logger.info("This is an exception {0}", Exception("Test"))
         _logger.info("This is an number {0}", 0)
         _logger.info("This is an boolean {0}", True)
-        _logger.verbose("{0}")
-        _logger.verbose("{0} {1}", 0, 1)
+        _logger.verb("{0}")
+        _logger.verb("{0} {1}", 0, 1)
         _logger.info("{0} {1}", 0, 1)
         _logger.warn("{0} {1}", 0, 1)
         _logger.error("{0} {1}", 0, 1)
-        _logger.info("this is a unicode {0}", '\u6211')
-        _logger.info("this is a utf-8 {0}", '\u6211'.encode('utf-8'))
-        _logger.info("this is a gbk {0}", 0xff )
+        _logger.add_appender(logger.AppenderType.STDOUT, 
+                             logger.LogLevel.INFO, None)
+        _logger.info(u"啊哈this is a utf-8 {0}", u'呵呵')
 
     def test_file_appender(self):
         _logger = logger.Logger()
@@ -60,12 +61,9 @@ class TestLogger(unittest.TestCase):
         self.assertTrue(tools.simple_file_grep('/tmp/testlog', msg))
 
         msg = text(uuid.uuid4())
-        _logger.verbose("Verbose should not be logged: {0}", msg)
+        _logger.verb("Verbose should not be logged: {0}", msg)
         self.assertFalse(tools.simple_file_grep('/tmp/testlog', msg))
 
-        _logger.info("this is a unicode {0}", '\u6211')
-        _logger.info("this is a utf-8 {0}", '\u6211'.encode('utf-8'))
-        _logger.info("this is a gbk {0}", 0xff)
 
     def test_concole_appender(self):
         _logger = logger.Logger()
@@ -78,7 +76,7 @@ class TestLogger(unittest.TestCase):
         self.assertTrue(tools.simple_file_grep('/tmp/testlog', msg))
 
         msg = text(uuid.uuid4())
-        _logger.verbose("Test logger: {0}", msg)
+        _logger.verb("Test logger: {0}", msg)
         self.assertFalse(tools.simple_file_grep('/tmp/testlog', msg))
 
 
diff --git a/tests/test_protocol.py b/tests/test_protocol.py
index 3eff197..de74443 100644
--- a/tests/test_protocol.py
+++ b/tests/test_protocol.py
@@ -19,8 +19,7 @@
 # http://msdn.microsoft.com/en-us/library/cc227259%28PROT.13%29.aspx
 
 import tests.env
-import tests.tools as tools
-from .tools import *
+from tests.tools import *
 import uuid
 import unittest
 import os
@@ -33,29 +32,15 @@ extensionDataStr = """
     "vmAgent": {
         "agentVersion": "2.4.1198.689",
         "status": "Ready",
-        "message": "GuestAgent is running and accepting new configurations."
-    },
-    "extensionHandlers": [{
-            "handlerName": "Microsoft.Compute.CustomScript",
-            "handlerVersion": "1.0.0.0",
+        "message": "GuestAgent is running and accepting new configurations.",
+        "extensionHandlers": [{
+            "name": "Microsoft.Compute.CustomScript",
+            "version": "1.0.0.0",
             "status": "Ready",
             "message": "Plugin enabled (name: Microsoft.Compute.CustomScript, version: 1.0.0.0).",
-            "extensionStatusList": [{
-                "name": "MyDomainJoinScript",
-                "configurationAppliedTime": "2014-08-12T19:20:18Z",
-                "operation": "CommandExecutionFinished",
-                "status": "Success",
-                "sequenceNumber": "0",
-                "substatusList": [{
-                    "name": "StdOut",
-                    "status": "Info",
-                    "code": "0",
-                    "message": "Joiningdomainfoo"
-                }]
-            }]
-        }
-
-    ]
+            "extensions": []
+        }]
+    }
 }
 """
 
@@ -63,25 +48,24 @@ class TestProtocolContract(unittest.TestCase):
     def test_get_properties(self):
         data = get_properties(VMInfo())
         data = get_properties(Cert())
-        data = get_properties(ExtensionPackageList())
-        data = get_properties(InstanceMetadata())
+        data = get_properties(ExtHandlerPackageList())
         data = get_properties(VMStatus())
         data = get_properties(TelemetryEventList())
-        data = get_properties(Extension(name="hehe"))
+        data = get_properties(ExtHandler(name="hehe"))
         self.assertTrue("name" in data)
         self.assertTrue("properties" in data)
         self.assertEquals(dict, type(data["properties"]))
-        self.assertTrue("versionUris" not in data)
+        self.assertTrue("versionUris" in data)
 
     def test_set_properties(self):
         data = json.loads(extensionDataStr)
         obj = VMStatus()
-        set_properties(obj, data)
+        set_properties("vmStatus", obj, data)
         self.assertNotEquals(None, obj.vmAgent)
         self.assertEquals(VMAgentStatus, type(obj.vmAgent))
         self.assertNotEquals(None, obj.vmAgent.status)
-        self.assertNotEquals(None, obj.extensionHandlers)
-        self.assertEquals(DataContractList, type(obj.extensionHandlers))
+        self.assertNotEquals(None, obj.vmAgent.extensionHandlers)
+        self.assertEquals(DataContractList, type(obj.vmAgent.extensionHandlers))
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/tests/test_shell_util.py b/tests/test_shell_util.py
index 9862745..9f84c6d 100644
--- a/tests/test_shell_util.py
+++ b/tests/test_shell_util.py
@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright 2014 Microsoft Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -25,15 +26,19 @@ import unittest
 import os
 import azurelinuxagent.utils.shellutil as shellutil
 import test
+from azurelinuxagent.future import text
 
 class TestrunCmd(unittest.TestCase):
     def test_run_get_output(self):
-        output = shellutil.run_get_output("ls /")
+        output = shellutil.run_get_output(u"ls /")
         self.assertNotEquals(None, output)
         self.assertEquals(0, output[0])
 
-        err = shellutil.run_get_output("ls /not-exists")
+        err = shellutil.run_get_output(u"ls /not-exists")
         self.assertNotEquals(0, err[0])
             
+        err = shellutil.run_get_output(u"ls 我")
+        self.assertNotEquals(0, err[0])
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/tests/test_text_util.py b/tests/test_text_util.py
index b29beff..5c0016c 100644
--- a/tests/test_text_util.py
+++ b/tests/test_text_util.py
@@ -25,10 +25,13 @@ import unittest
 import os
 from azurelinuxagent.future import text
 import azurelinuxagent.utils.textutil as textutil
+from azurelinuxagent.utils.textutil import Version
 
 class TestTextUtil(unittest.TestCase):
     def test_get_password_hash(self):
-        password_hash = textutil.gen_password_hash("asdf", True, 6, 10)
+        password_hash = textutil.gen_password_hash("asdf", 6, 10)
+        self.assertNotEquals(None, password_hash)
+        password_hash = textutil.gen_password_hash("asdf", 6, 0)
         self.assertNotEquals(None, password_hash)
 
     def test_remove_bom(self):
@@ -42,6 +45,22 @@ class TestTextUtil(unittest.TestCase):
         data = textutil.remove_bom(data)
         self.assertEquals(u"h", data[0])
 
-   
+    def test_version_compare(self) :
+        self.assertTrue(Version("1.0") < Version("1.1"))
+        self.assertTrue(Version("1.9") < Version("1.10"))
+        self.assertTrue(Version("1.9.9") < Version("1.10.0"))
+        self.assertTrue(Version("1.0.0.0") < Version("1.2.0.0"))
+
+        self.assertTrue(Version("1.0") <= Version("1.1"))
+        self.assertTrue(Version("1.1") > Version("1.0"))
+        self.assertTrue(Version("1.1") >= Version("1.0"))
+
+        self.assertTrue(Version("1.0") == Version("1.0"))
+        self.assertTrue(Version("1.0") >= Version("1.0"))
+        self.assertTrue(Version("1.0") <= Version("1.0"))
+
+        self.assertTrue(Version("1.9") < "1.10")
+        self.assertTrue("1.9" < Version("1.10"))
+        
 if __name__ == '__main__':
     unittest.main()
diff --git a/tests/test_v1.py b/tests/test_v1.py
index 02225af..5a1b36b 100644
--- a/tests/test_v1.py
+++ b/tests/test_v1.py
@@ -35,7 +35,7 @@ from tests.test_sharedconfig import shared_config_sample
 from tests.test_certificates import certs_sample, transport_cert
 from tests.test_extensionsconfig import ext_conf_sample, manifest_sample
 
-def mock_fetch_uri(url, headers=None, chk_proxy=False):
+def mock_fetch_config(self, url, headers=None, chk_proxy=False):
     content = None
     if "versions" in url:
         content = VersionInfoSample
@@ -55,10 +55,10 @@ def mock_fetch_uri(url, headers=None, chk_proxy=False):
         raise Exception("Bad url {0}".format(url))
     return content
 
-def mock_fetch_manifest(uris):
+def mock_fetch_manifest(self, uris):
     return manifest_sample
 
-def mock_fetch_cache(file_path):
+def mock_fetch_cache(self, file_path):
     content = None
     if "Incarnation" in file_path:
         content = 1
@@ -90,13 +90,23 @@ class MockResp(object):
     def read(self):
         return self.data
 
+def mock_403():
+    return MockResp(status = v1.httpclient.FORBIDDEN)
+
+def mock_410():
+    return MockResp(status = v1.httpclient.GONE)
+
+def mock_503():
+    return MockResp(status = v1.httpclient.SERVICE_UNAVAILABLE)
+
 class TestWireClint(unittest.TestCase):
 
     @mock(v1.restutil, 'http_get', MockFunc(retval=MockResp(data=data_with_bom)))
     def test_fetch_uri_with_bom(self):
-        v1._fetch_uri("http://foo.bar", None)
+        client = v1.WireClient("http://foo.bar/")
+        client.fetch_config("http://foo.bar", None)
 
-    @mock(v1, '_fetch_cache', mock_fetch_cache)
+    @mock(v1.WireClient, 'fetch_cache', mock_fetch_cache)
     def test_get(self):
         os.chdir('/tmp')
         client = v1.WireClient("foobar")
@@ -110,14 +120,15 @@ class TestWireClint(unittest.TestCase):
         self.assertNotEquals(None, extensionsConfig)
    
     
-    @mock(v1, '_fetch_cache', mock_fetch_cache)
+    @mock(v1.WireClient, 'fetch_cache', mock_fetch_cache)
     def test_get_head_for_cert(self):
         client = v1.WireClient("foobar")
         header = client.get_header_for_cert()
         self.assertNotEquals(None, header)
 
     @mock(v1.WireClient, 'get_header_for_cert', MockFunc()) 
-    @mock(v1, '_fetch_uri', mock_fetch_uri)
+    @mock(v1.WireClient, 'fetch_config', mock_fetch_config)
+    @mock(v1.WireClient, 'fetch_manifest', mock_fetch_manifest)
     @mock(v1.fileutil, 'write_file', MockFunc())
     def test_update_goal_state(self):
         client = v1.WireClient("foobar")
@@ -131,35 +142,54 @@ class TestWireClint(unittest.TestCase):
         ext_conf = client.get_ext_conf()
         self.assertNotEquals(None, ext_conf)
 
+    @mock(v1.time, "sleep", MockFunc())
+    def test_call_wireserver(self):
+        client = v1.WireClient("foobar")
+        self.assertRaises(v1.ProtocolError, client.call_wireserver, mock_403)
+        self.assertRaises(v1.WireProtocolResourceGone, client.call_wireserver, 
+                          mock_410)
+
+    @mock(v1.time, "sleep", MockFunc())
+    def test_call_storage_service(self):
+        client = v1.WireClient("foobar")
+        self.assertRaises(v1.ProtocolError, client.call_storage_service, 
+                          mock_503)
+
+
 class TestStatusBlob(unittest.TestCase):
     def testToJson(self):
         vm_status = v1.VMStatus()
-        status_blob = v1.StatusBlob(vm_status)
+        status_blob = v1.StatusBlob(v1.WireClient("http://foo.bar/"))
+        status_blob.set_vm_status(vm_status)
         self.assertNotEquals(None, status_blob.to_json())
 
     @mock(v1.restutil, 'http_put', MockFunc(retval=MockResp(httpclient.CREATED)))
     @mock(v1.restutil, 'http_head', MockFunc(retval=MockResp(httpclient.OK)))
     def test_put_page_blob(self):
         vm_status = v1.VMStatus()
-        status_blob = v1.StatusBlob(vm_status)
+        status_blob = v1.StatusBlob(v1.WireClient("http://foo.bar/"))
+        status_blob.set_vm_status(vm_status)
         data = 'a' * 100
         status_blob.put_page_blob("http://foo.bar", data)
 
 class TestConvert(unittest.TestCase):
     def test_status(self):
         vm_status = v1.VMStatus() 
-        handler_status = v1.ExtensionHandlerStatus()
-        substatus = v1.ExtensionSubStatus()
-        ext_status = v1.ExtensionStatus()
+        handler_status = v1.ExtHandlerStatus(name="foo")
 
-        vm_status.extensionHandlers.append(handler_status)
-        v1.vm_status_to_v1(vm_status)
+        ext_statuses = {}
 
-        handler_status.extensionStatusList.append(ext_status)
-        v1.vm_status_to_v1(vm_status)
+        ext_name="bar"
+        ext_status = v1.ExtensionStatus()
+        handler_status.extensions.append(ext_name)
+        ext_statuses[ext_name] = ext_status
 
+        substatus = v1.ExtensionSubStatus()
         ext_status.substatusList.append(substatus)
-        v1.vm_status_to_v1(vm_status)
+
+        vm_status.vmAgent.extensionHandlers.append(handler_status)
+        v1_status = v1.vm_status_to_v1(vm_status, ext_statuses)
+        print(v1_status)
 
     def test_param(self):
         param = v1.TelemetryEventParam()
diff --git a/tests/test_v2.py b/tests/test_v2.py
new file mode 100644
index 0000000..c4a0b4d
--- /dev/null
+++ b/tests/test_v2.py
@@ -0,0 +1,120 @@
+# Copyright 2014 Microsoft Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Requires Python 2.4+ and Openssl 1.0+
+#
+# Implements parts of RFC 2131, 1541, 1497 and
+# http://msdn.microsoft.com/en-us/library/cc227282%28PROT.10%29.aspx
+# http://msdn.microsoft.com/en-us/library/cc227259%28PROT.13%29.aspx
+
+import tests.env
+from tests.tools import *
+import unittest
+import json
+import azurelinuxagent.protocol.v2 as v2
+
+SAMPLE_IDENTITY=u"""{
+    "vmName":"foo", 
+    "subscriptionId":"bar"
+}"""
+
+SAMPLE_CERTS=u"""{
+    "certificates":[{
+        "name":"foo", 
+        "thumbprint":"bar",
+        "certificateDataUri":"baz"
+    }]
+}"""
+
+SAMPLE_EXT_HANDLER=u"""[{
+    "name":"foo",
+    "properties":{
+        "version":"bar",
+        "upgradePolicy": "manual",
+        "state": "enabled",
+        "extensions":[{
+            "name":"baz",
+            "sequenceNumber":0,
+            "publicSettings":{
+                "commandToExecute": "echo 123",
+                "uris":[]
+            }
+        }]
+    },
+    "versionUris":[{
+        "uri":"versionUri.foo"
+    }]
+}]"""
+
+SAMPLE_EXT_HANDLER_PKGS=u"""{
+    "versions": [{
+        "version":"foo",
+        "uris":[{
+            "uri":"bar"
+        },{
+            "uri":"baz"
+        }]
+    }]
+}"""
+
+def mock_get_data(self, url, headers=None):
+    data = u"{}"
+    if url.count(u"identity") > 0:
+        data = SAMPLE_IDENTITY
+    elif url.count(u"certificates") > 0:
+        data = SAMPLE_CERTS
+    elif url.count(u"extensionHandlers") > 0:
+        data = SAMPLE_EXT_HANDLER
+    elif url.count(u"versionUri") > 0:
+        data = SAMPLE_EXT_HANDLER_PKGS
+    return json.loads(data)
+
+class TestMetadataProtocol(unittest.TestCase):
+    @mock(v2.MetadataProtocol, '_get_data', mock_get_data)
+    def test_getters(self):
+        protocol = v2.MetadataProtocol()
+        vminfo = protocol.get_vminfo()
+        self.assertNotEquals(None, vminfo)
+        self.assertNotEquals(None, vminfo.vmName)
+        self.assertNotEquals(None, vminfo.subscriptionId)
+
+        protocol.get_certs()
+
+        ext_handers = protocol.get_ext_handlers()
+        self.assertNotEquals(None, ext_handers)
+        self.assertNotEquals(None, ext_handers.extHandlers)
+        self.assertNotEquals(0, len(ext_handers.extHandlers))
+        
+        ext_hander = ext_handers.extHandlers[0] 
+        self.assertNotEquals(None, ext_hander)
+        self.assertNotEquals(0, len(ext_hander.properties.extensions))
+
+        ext = ext_hander.properties.extensions[0]
+        self.assertNotEquals(None, ext)
+        self.assertNotEquals(None, ext.publicSettings)
+        self.assertEquals("echo 123", ext.publicSettings.get('commandToExecute'))
+
+        packages = protocol.get_ext_handler_pkgs(ext_handers.extHandlers[0])
+        self.assertNotEquals(None, packages)
+    
+    @mock(v2.MetadataProtocol, '_put_data', MockFunc())
+    def test_reporters(self):
+        protocol = v2.MetadataProtocol()
+        protocol.report_provision_status(v2.ProvisionStatus())
+        protocol.report_vm_status(v2.VMStatus())
+        protocol.report_ext_status("foo", "baz", v2.ExtensionStatus())
+        protocol.report_event(v2.TelemetryEventList())
+
+if __name__ == '__main__':
+    unittest.main()