← Back to branch summary

~ubuntu-branches/debian/stretch/waagent/stretch

« back to all changes in this revision

Viewing changes to tests/test_ext.py

  • Committer: Package Import Robot
  • Author(s): Bastian Blank
  • Date: 2016-02-01 13:11:28 UTC
  • mfrom: (1.2.2)
  • Revision ID: package-import@ubuntu.com-20160201131128-4wxc2tklmq3x40xe
Tags: 2.1.2-1
* New upstream version.
* Depend on host, needed by Microsofts custom script stuff.
* Use cloud-init:
  - Use Ubuntu provisioning handler, disable provisioning.
  - Depend on new enough version of cloud-init.
  - Update dependencies in init script and service.
  - Disable recursive agent invocation and hostname bounce in clout-init.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/test_ext.py
18
18
# http://msdn.microsoft.com/en-us/library/cc227282%28PROT.10%29.aspx
19
19
# http://msdn.microsoft.com/en-us/library/cc227259%28PROT.13%29.aspx
20
20
 
21
 
import env
 
21
import tests.env
22
22
from tests.tools import *
23
23
import uuid
24
24
import unittest
25
25
import os
26
26
import json
27
27
import azurelinuxagent.logger as logger
28
 
from azurelinuxagent.utils.osutil import OSUtil
 
28
from azurelinuxagent.utils.osutil import OSUTIL
29
29
import azurelinuxagent.utils.fileutil as fileutil
30
30
import azurelinuxagent.protocol as prot
31
31
import azurelinuxagent.distro.default.extension as ext
32
32
 
33
 
extensionData = {
 
33
ext_sample_json = {
34
34
    "name":"TestExt",
35
35
    "properties":{
36
36
        "version":"2.0",
51
51
        }]
52
52
    }
53
53
}
54
 
extension = prot.Extension()
55
 
prot.set_properties(extension, extensionData)
 
54
ext_sample = prot.ExtHandler()
 
55
prot.set_properties("extensions", ext_sample, ext_sample_json)
56
56
 
57
 
packageListData={
 
57
pkd_list_sample_str={
58
58
    "versions": [{
59
59
        "version": "2.0",
60
60
        "uris":[{
67
67
         }]
68
68
    }]
69
69
}
70
 
packageList = prot.ExtensionPackageList()
71
 
prot.set_properties(packageList, packageListData)
 
70
pkg_list_sample = prot.ExtHandlerPackageList()
 
71
prot.set_properties("packages", pkg_list_sample, pkd_list_sample_str)
72
72
 
73
 
manJson = {
 
73
manifest_sample_str = {
74
74
    "handlerManifest":{
75
75
        "installCommand": "echo 'install'",
76
76
        "uninstallCommand": "echo 'uninstall'",
79
79
        "disableCommand": "echo 'disable'",
80
80
    }
81
81
}
82
 
man = ext.HandlerManifest(manJson)
83
 
 
84
 
def MockLoadManifest(self):
85
 
    return man
86
 
 
87
 
MockLaunchCommand = MockFunc()
88
 
MockSetHandlerStatus = MockFunc()
89
 
 
90
 
def MockDownload(self):
91
 
    fileutil.CreateDir(self.getBaseDir())
92
 
    fileutil.SetFileContents(self.getManifestFile(), json.dumps(manJson))
 
82
manifest_sample = ext.HandlerManifest(manifest_sample_str)
 
83
 
 
84
ext_status_sample="""
 
85
[{
 
86
    "version": 1.0,
 
87
    "timestampUTC": "2015-11-12T06:59:48Z",
 
88
    "status": {
 
89
        "name": "<Handler workload name>",
 
90
        "operation": "<name of the operation being performed>",
 
91
        "configurationAppliedTime": "2015-11-12T06:59:48Z",
 
92
        "status": "error",
 
93
        "code": 0,
 
94
        "formattedMessage": {
 
95
            "lang": "en-US",
 
96
            "message": "formatted user message"
 
97
        },
 
98
        "substatus": [{
 
99
            "name": "<Handler workload subcomponent name>",
 
100
            "status": "error",
 
101
            "code": 0 ,
 
102
            "formattedMessage": {
 
103
                "lang": "lang[-locale]",
 
104
                "message": "formatted user message"
 
105
            }
 
106
        },{
 
107
            "status": "error"
 
108
        }]
 
109
    }
 
110
}]
 
111
"""
 
112
 
 
113
ext_status_sample_min="""
 
114
[{
 
115
    "version": 1.0,
 
116
    "timestampUTC": "2015-11-12T06:59:48Z",
 
117
    "status": {
 
118
        "status": "error"
 
119
    }
 
120
}]
 
121
"""
 
122
 
 
123
def mock_load_manifest(self):
 
124
    return manifest_sample
 
125
 
 
126
mock_launch_command = MockFunc()
 
127
mock_set_state = MockFunc()
 
128
 
 
129
def mock_download(self):
 
130
    fileutil.mkdir(self.get_base_dir())
 
131
    fileutil.write_file(self.get_manifest_file(), json.dumps(manifest_sample_str))
93
132
 
94
133
#logger.LoggerInit("/dev/null", "/dev/stdout")
95
134
class TestExtensions(unittest.TestCase):
96
135
 
97
136
    def test_load_ext(self):
98
 
        libDir = OSUtil.GetLibDir()
99
 
        testExt1 = os.path.join(libDir, 'TestExt-1.0')
100
 
        testExt2 = os.path.join(libDir, 'TestExt-2.0')
101
 
        testExt2 = os.path.join(libDir, 'TestExt-2.1')
102
 
        for path in [testExt1, testExt2]:
 
137
        libDir = OSUTIL.get_lib_dir()
 
138
        test_ext1 = os.path.join(libDir, 'TestExt-1.0')
 
139
        test_ext2 = os.path.join(libDir, 'TestExt-2.0')
 
140
        test_ext2 = os.path.join(libDir, 'TestExt-2.1')
 
141
        for path in [test_ext1, test_ext2]:
103
142
            if not os.path.isdir(path):
104
143
                os.mkdir(path)
105
 
        testExt = ext.GetInstalledExtensionVersion('TestExt')
106
 
        self.assertEqual('2.1', testExt)
 
144
        test_ext = ext.get_installed_version('TestExt')
 
145
        self.assertEqual('2.1', test_ext)
107
146
 
108
147
    def test_getters(self):
109
 
        testExt = ext.ExtensionInstance(extension, packageList, 
110
 
                                        extension.properties.version, False)
111
 
        self.assertEqual("/tmp/TestExt-2.0", testExt.getBaseDir())
112
 
        self.assertEqual("/tmp/TestExt-2.0/status", testExt.getStatusDir())
 
148
        test_ext = ext.ExtHandlerInstance(ext_sample, pkg_list_sample, 
 
149
                                          ext_sample.properties.version, False)
 
150
        self.assertEqual("/tmp/TestExt-2.0", test_ext.get_base_dir())
 
151
        self.assertEqual("/tmp/TestExt-2.0/status", test_ext.get_status_dir())
113
152
        self.assertEqual("/tmp/TestExt-2.0/status/0.status", 
114
 
                         testExt.getStatusFile())
115
 
        self.assertEqual("/tmp/TestExt-2.0/config/HandlerState", 
116
 
                         testExt.getHandlerStateFile())
117
 
        self.assertEqual("/tmp/TestExt-2.0/config", testExt.getConfigDir())
 
153
                         test_ext.get_status_file())
 
154
        self.assertEqual("/tmp/handler_state/TestExt-2.0/0.state", 
 
155
                         test_ext.get_handler_state_file())
 
156
        self.assertEqual("/tmp/handler_state/TestExt-2.0/0.error", 
 
157
                         test_ext.get_handler_state_err_file())
 
158
        self.assertEqual("/tmp/TestExt-2.0/config", test_ext.get_conf_dir())
118
159
        self.assertEqual("/tmp/TestExt-2.0/config/0.settings", 
119
 
                         testExt.getSettingsFile())
 
160
                         test_ext.get_settings_file())
120
161
        self.assertEqual("/tmp/TestExt-2.0/heartbeat.log", 
121
 
                         testExt.getHeartbeatFile())
 
162
                         test_ext.get_heartbeat_file())
122
163
        self.assertEqual("/tmp/TestExt-2.0/HandlerManifest.json", 
123
 
                         testExt.getManifestFile())
 
164
                         test_ext.get_manifest_file())
124
165
        self.assertEqual("/tmp/TestExt-2.0/HandlerEnvironment.json", 
125
 
                         testExt.getEnvironmentFile())
126
 
        self.assertEqual("/tmp/log/TestExt/2.0", testExt.getLogDir())
 
166
                         test_ext.get_env_file())
 
167
        self.assertEqual("/tmp/log/TestExt/2.0", test_ext.get_log_dir())
127
168
 
128
 
        testExt = ext.ExtensionInstance(extension, packageList, "2.1", False)
129
 
        self.assertEqual("/tmp/TestExt-2.1", testExt.getBaseDir())
130
 
        self.assertEqual("2.1", testExt.getTargetVersion())
 
169
        test_ext = ext.ExtHandlerInstance(ext_sample, pkg_list_sample, 
 
170
                                          "2.1", False)
 
171
        self.assertEqual("/tmp/TestExt-2.1", test_ext.get_base_dir())
 
172
        self.assertEqual("2.1", test_ext.get_target_version())
131
173
   
132
 
    @Mockup(ext.ExtensionInstance, 'loadManifest', MockLoadManifest)
133
 
    @Mockup(ext.ExtensionInstance, 'launchCommand', MockLaunchCommand)
134
 
    @Mockup(ext.ExtensionInstance, 'setHandlerStatus', MockSetHandlerStatus)
 
174
    @mock(ext.ExtHandlerInstance, 'load_manifest', mock_load_manifest)
 
175
    @mock(ext.ExtHandlerInstance, 'launch_command', mock_launch_command)
 
176
    @mock(ext.ExtHandlerInstance, 'set_state', mock_set_state)
135
177
    def test_handle_uninstall(self):
136
 
        MockLaunchCommand.args = None
137
 
        MockSetHandlerStatus.args = None
138
 
        testExt = ext.ExtensionInstance(extension, packageList, 
139
 
                                        extension.properties.version, False)
140
 
        testExt.handleUninstall()
141
 
        self.assertEqual(None, MockLaunchCommand.args)
142
 
        self.assertEqual(None, MockSetHandlerStatus.args)
143
 
        self.assertEqual(None, testExt.getCurrOperation())
144
 
 
145
 
        testExt = ext.ExtensionInstance(extension, packageList, 
146
 
                                        extension.properties.version, True)
147
 
        testExt.handleUninstall()
148
 
        self.assertEqual(man.getUninstallCommand(), MockLaunchCommand.args[0])
149
 
        self.assertEqual("UnInstall", testExt.getCurrOperation())
150
 
        self.assertEqual("NotReady", MockSetHandlerStatus.args[0])
151
 
 
152
 
    @Mockup(ext.ExtensionInstance, 'loadManifest', MockLoadManifest)
153
 
    @Mockup(ext.ExtensionInstance, 'launchCommand', MockLaunchCommand)
154
 
    @Mockup(ext.ExtensionInstance, 'download', MockDownload)
155
 
    @Mockup(ext.ExtensionInstance, 'getHandlerStatus', MockFunc(retval="enabled"))
156
 
    @Mockup(ext.ExtensionInstance, 'setHandlerStatus', MockSetHandlerStatus)
157
 
    def test_handle(self):
 
178
        mock_launch_command.args = None
 
179
        mock_set_state.args = None
 
180
        test_ext = ext.ExtHandlerInstance(ext_sample, pkg_list_sample, 
 
181
                                          ext_sample.properties.version, False)
 
182
        if not os.path.isdir(test_ext.get_base_dir()):
 
183
            os.makedirs(test_ext.get_base_dir())
 
184
        test_ext.handle_uninstall()
 
185
        self.assertEqual(None, mock_launch_command.args)
 
186
        self.assertEqual(None, mock_set_state.args)
 
187
 
 
188
        test_ext = ext.ExtHandlerInstance(ext_sample, pkg_list_sample, 
 
189
                                          ext_sample.properties.version, True)
 
190
        if not os.path.isdir(test_ext.get_base_dir()):
 
191
            os.makedirs(test_ext.get_base_dir())
 
192
        test_ext.handle_uninstall()
 
193
        self.assertEqual(manifest_sample.get_uninstall_command(), 
 
194
                         mock_launch_command.args[0])
 
195
    
 
196
    @mock(ext.ExtHandlerInstance, 'upgrade', MockFunc())
 
197
    @mock(ext.ExtHandlerInstance, 'enable', MockFunc())
 
198
    @mock(ext.ExtHandlerInstance, 'download', MockFunc())
 
199
    @mock(ext.ExtHandlerInstance, 'init_dir', MockFunc())
 
200
    @mock(ext.ExtHandlerInstance, 'install', MockFunc())
 
201
    def test_handle_enable(self):
158
202
        #Test enable
159
 
        testExt = ext.ExtensionInstance(extension, packageList, 
160
 
                                        extension.properties.version, False)
161
 
        testExt.initLog()
162
 
        self.assertEqual(1, len(testExt.logger.appenders) - len(logger.DefaultLogger.appenders))
163
 
        testExt.handle()
164
 
        
 
203
        test_ext = ext.ExtHandlerInstance(ext_sample, pkg_list_sample, 
 
204
                                          ext_sample.properties.version, False)
 
205
        test_ext.handle_enable()
 
206
     
165
207
        #Test upgrade 
166
 
        testExt = ext.ExtensionInstance(extension, packageList, 
167
 
                                        extension.properties.version, False)
168
 
        testExt.initLog()
169
 
        self.assertEqual(1, len(testExt.logger.appenders) - len(logger.DefaultLogger.appenders))
170
 
        testExt.handle()
 
208
        test_ext = ext.ExtHandlerInstance(ext_sample, pkg_list_sample, 
 
209
                                          "2.0" , True)
 
210
        test_ext.handle_enable()
171
211
 
172
212
    def test_status_convert(self):
173
 
        extStatus = 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"}]')
174
 
        ext.extension_status_to_v2(extStatus[0], 0)
 
213
        data = json.loads(ext_status_sample)
 
214
        ext_status = prot.ExtensionStatus()
 
215
        ext.parse_ext_status(ext_status, data)
 
216
 
 
217
        data = json.loads(ext_status_sample_min)
 
218
        ext_status = prot.ExtensionStatus()
 
219
        ext.parse_ext_status(ext_status, data)
175
220
 
176
221
 
177
222
if __name__ == '__main__':