1#!/usr/bin/env python
2# -*- coding: utf-8 -*-
3# Copyright (c) 2021 Huawei Device Co., Ltd.
4# Licensed under the Apache License, Version 2.0 (the "License");
5# you may not use this file except in compliance with the License.
6# You may obtain a copy of the License at
7#
8# http://www.apache.org/licenses/LICENSE-2.0
9#
10# Unless required by applicable law or agreed to in writing, software
11# distributed under the License is distributed on an "AS IS" BASIS,
12# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13# See the License for the specific language governing permissions and
14# limitations under the License.
15
16import os
17import shutil
18import unittest
19import sys
20import zipfile
21
22from build_update import increment_image_processing
23from build_update import main
24from build_update import check_update_package
25from build_update import check_miss_private_key
26from build_update import check_target_package_path
27from test.create_package_data import clear_package
28from test.create_package_data import create_input_package
29from script_generator import VerseScript
30from build_update import check_incremental_args
31from test.fake_data import RSA_PRIVATE_KEY_DATA
32from utils import OPTIONS_MANAGER
33from utils import clear_resource
34from build_update import check_package_version
35from build_update import private_key_check
36
37
38class TestUpdateUtils(unittest.TestCase):
39
40    def setUp(self):
41        print("set up")
42
43    def tearDown(self):
44        print("tear down")
45
46    def test_update_pkg(self):
47        """
48        The whole process
49        :return:
50        """
51        create_input_package("test_target_package")
52        create_input_package("test_source_package", package_type="source")
53        if not os.path.exists("./output_test"):
54            os.mkdir("./output_test")
55        sys.argv.clear()
56        sys.argv.append("build_update.py")
57        sys.argv.append("./test_target_package/")
58        sys.argv.append("./output_test/demo")
59        sys.argv.append("-s")
60        sys.argv.append("./test_source_package.zip")
61        sys.argv.append("-pk")
62        sys.argv.append("./rsa_private_key2048.pem")
63        main()
64        output = "./output_test/demo"
65        pkg_re = os.path.join(output, os.listdir(output)[0]).endswith('zip')
66        shutil.rmtree("./output_test")
67        self.assertEqual(pkg_re, True)
68        clear_package("test_target_package")
69        clear_package("test_source_package")
70
71    def test_updater_partitions(self):
72        """
73        Update partitions
74        :return:
75        """
76        create_input_package(
77            "test_target_package_updater_partition",
78            package_type="source", is_updater_partitions=True)
79        if not os.path.exists("./output_test"):
80            os.mkdir("./output_test")
81        sys.argv.clear()
82        sys.argv.append("build_update.py")
83        sys.argv.append(
84            "./test_target_package_updater_partition.zip")
85        sys.argv.append("./output_test/demo")
86        sys.argv.append("-pk")
87        sys.argv.append("./rsa_private_key2048.pem")
88        sys.argv.append("-pf")
89        sys.argv.append("./partition_file.xml")
90        main()
91        output = "./output_test/demo"
92        pkg_re = os.path.join(output, os.listdir(output)[0]).endswith('zip')
93        shutil.rmtree("./output_test")
94        self.assertEqual(pkg_re, True)
95        clear_package("test_target_package_updater_partition")
96
97    def test_updater_partitions2(self):
98        """
99        Update partitions，The incoming file does not exist:
100        nonexistent_path.xml
101        :return:
102        """
103        create_input_package(
104            "test_target_package_updater_partition",
105            package_type="source", is_updater_partitions=True)
106        if not os.path.exists("./output_test"):
107            os.mkdir("./output_test")
108        sys.argv.clear()
109        sys.argv.append("build_update.py")
110        sys.argv.append(
111            "./test_target_package_updater_partition.zip")
112        sys.argv.append("./output_test/demo")
113        sys.argv.append("-pk")
114        sys.argv.append("./rsa_private_key2048.pem")
115        sys.argv.append("-pf")
116        sys.argv.append("../nonexistent_path.xml")
117        main()
118        output = "./output_test"
119        pkg_re = len(os.listdir(output))
120        self.assertEqual(pkg_re, 0)
121        shutil.rmtree("./output_test")
122        clear_resource()
123        clear_package("test_target_package_updater_partition")
124
125    def test_update_pkg_nozip(self):
126        """
127        The whole process, no zip mode
128        :return:
129        """
130        create_input_package(
131            "test_target_package_nozip", package_type="source")
132        if not os.path.exists("./output_test"):
133            os.mkdir("./output_test")
134        sys.argv.clear()
135        sys.argv.append("build_update.py")
136        sys.argv.append("./test_target_package_nozip.zip")
137        sys.argv.append("./output_test/demo")
138        sys.argv.append("-nz")
139        sys.argv.append("-pk")
140        sys.argv.append("./rsa_private_key2048.pem")
141        main()
142        output = "./output_test/demo"
143        pkg_re = os.path.join(output, os.listdir(output)[0]).endswith('bin')
144        shutil.rmtree("./output_test")
145        self.assertEqual(pkg_re, True)
146        clear_package("test_target_package_nozip")
147
148    def test_type_check(self):
149        """
150        Input parameter type detection, type_check return False,
151        -s parameter does not exist.
152        :return:
153        """
154        create_input_package(
155            "test_target_package_nozip", package_type="source")
156        if not os.path.exists("./output_test"):
157            os.mkdir("./output_test")
158        sys.argv.clear()
159        sys.argv.append("build_update.py")
160        sys.argv.append("./test_target_package_nozip.zip")
161        sys.argv.append("./output_test/demo")
162        sys.argv.append("-s")
163        sys.argv.append("../test_type_check.test")
164        sys.argv.append("-pk")
165        sys.argv.append("./rsa_private_key2048.pem")
166        main()
167        output = "./output_test/"
168        pkg_re = len(os.listdir(output))
169        shutil.rmtree("./output_test")
170        self.assertEqual(pkg_re, 0)
171        clear_resource()
172        clear_package("test_target_package_nozip")
173
174    def test_check_update_package(self):
175        """
176        Input parameter type detection, check_update_package return False,
177        update_package parameter does not exist.
178        :return:
179        """
180        create_input_package(
181            "test_target_package_nozip", package_type="source")
182        if not os.path.exists("./output_test"):
183            os.mkdir("./output_test")
184        output = "./output_test/demo"
185        if os.path.exists(output):
186            shutil.rmtree(output)
187        sys.argv.clear()
188        sys.argv.append("build_update.py")
189        sys.argv.append("./test_target_package_nozip.zip")
190        sys.argv.append("test_build_update.py")
191        sys.argv.append("-pk")
192        sys.argv.append("./rsa_private_key2048.pem")
193        main()
194        output = "./output_test/"
195        pkg_re = len(os.listdir(output))
196        shutil.rmtree("./output_test")
197        self.assertEqual(pkg_re, 0)
198        clear_resource()
199        clear_package("test_target_package_nozip")
200
201    def test_check_update_package1(self):
202        """
203        Input parameter type detection, check_update_package return False,
204        update_package parameter is file.
205        :return:
206        """
207        arg = check_update_package("test_build_update.py")
208        self.assertEqual(arg, False)
209
210    def test_check_update_package2(self):
211        """
212        Input parameter type detection, check_update_package return False,
213        make update_package failed.
214        :return:
215        """
216        arg = check_update_package("")
217        self.assertEqual(arg, False)
218
219    def test_check_miss_private_key(self):
220        """
221        check_miss_private_key, -pk parameter is None.
222        :return:
223        """
224        check_re = check_miss_private_key(None)
225        self.assertEqual(check_re, False)
226
227    def test_check_target_package_path(self):
228        """
229        Input parameter type detection, check_target_package_path return False,
230        target_package parameter does not exist.
231        :return:
232        """
233        target_package = "nonexistent_path.test"
234        check_re = check_target_package_path(target_package)
235        self.assertEqual(check_re, False)
236
237    def test_check_target_package_path2(self):
238        """
239        Input parameter type detection, check_target_package_path return False,
240        Check target_package dir.
241        :return:
242        """
243        target_package = "test.zip"
244        zip_obj = zipfile.ZipFile(target_package, "w")
245        with open('test.file', 'w') as w_f:
246            w_f.write('test')
247        zip_obj.write('test.file', 'test.file')
248        zip_obj.write('test.file', 'test2.file')
249        zip_obj.close()
250
251        check_re = check_target_package_path(target_package)
252        os.remove(target_package)
253        os.remove('test.file')
254        self.assertEqual(check_re, False)
255
256    def test_check_incremental_args(self):
257        """
258        check_incremental_args, Parameter exception, return False
259        :return:
260        """
261        create_input_package(
262            "test_source_package", package_type="source")
263        check_re = check_incremental_args(False, None, None, ["vendor"])
264        self.assertEqual(check_re, False)
265
266        check_re = check_incremental_args(True, None, "", ["vendor"])
267        self.assertEqual(check_re, False)
268
269        check_re = check_incremental_args(False, "", "", ["vendor"])
270        self.assertEqual(check_re, False)
271
272        OPTIONS_MANAGER.source_package_dir = "./"
273        check_re = check_incremental_args(False, None, "", ["vendor"])
274        self.assertEqual(check_re, False)
275
276        OPTIONS_MANAGER.target_package_version = \
277            "Hi3516DV300-eng 10 QP1A.190711.019"
278        check_re = check_incremental_args(
279            False, None, "./test_source_package.zip", ["vendor"])
280        clear_resource()
281        self.assertEqual(check_re, False)
282        clear_package("test_source_package")
283
284    def test_check_userdata_image(self):
285        """
286        check_userdata_image, userdata does not upgrade not allowed.
287        :return:
288        """
289        create_input_package(
290            "test_target_package_userdata", package_type="source",
291            has_userdata=True)
292        if not os.path.exists("./output_test"):
293            os.mkdir("./output_test")
294        sys.argv.clear()
295        sys.argv.append("build_update.py")
296        sys.argv.append(
297            "./test_target_package_userdata.zip")
298        sys.argv.append("./output_test/demo")
299        sys.argv.append("-pk")
300        sys.argv.append("./rsa_private_key2048.pem")
301        main()
302        output = "./output_test/demo"
303        pkg_re = os.path.exists(output)
304        shutil.rmtree("./output_test")
305        self.assertEqual(pkg_re, False)
306        clear_resource()
307        clear_package("test_target_package_userdata")
308
309    def test_check_images_list(self):
310        """
311        check_images_list, Both full list and inc list are empty.
312        :return:
313        """
314        create_input_package(
315            "test_target_package_inc_full_all_none", package_type="source",
316            is_inc_full_none=True)
317        if not os.path.exists("./output_test"):
318            os.mkdir("./output_test")
319        sys.argv.clear()
320        sys.argv.append("build_update.py")
321        sys.argv.append(
322            "./test_target_package_inc_full_all_none.zip")
323        sys.argv.append("./output_test/demo")
324        sys.argv.append("-pk")
325        sys.argv.append("./rsa_private_key2048.pem")
326        main()
327        output = "./output_test/demo"
328        pkg_re = os.path.exists(output)
329        shutil.rmtree("./output_test")
330        self.assertEqual(pkg_re, False)
331        clear_resource()
332        clear_package("test_target_package_inc_full_all_none")
333
334    def test_check_package_version(self):
335        """
336        check_package_version, Exception in version number comparison.
337        :return:
338        """
339        target_package_version = \
340            "test version num"
341        check_re = check_package_version(
342            target_package_version, "Hi3516DV300-eng 10 QP1A.190711.020")
343        clear_resource()
344        self.assertEqual(check_re, False)
345
346    def test_increment_image_processing(self):
347        """
348        increment_image_processing，Exception in inc process, return False
349        :return:
350        """
351        create_input_package("test_target_package", package_type="target")
352        create_input_package("test_target_package_miss_image",
353                             package_type="target",
354                             is_miss_image=True)
355        create_input_package(
356            "test_source_package_miss_image", package_type="source",
357            is_miss_image=True)
358        if not os.path.exists("./output_test"):
359            os.mkdir("./output_test")
360        verse_script = VerseScript()
361        # miss source .img
362        check_re = increment_image_processing(
363            verse_script, ['test'], "", "")
364        self.assertEqual(check_re, False)
365
366        # miss target .img
367        check_re = increment_image_processing(
368            verse_script, ['vendor'], "./test_target_package/",
369            "./test_target_package/")
370        self.assertEqual(check_re, False)
371
372        with open('vendor.img', 'w') as f_w:
373            f_w.write('test content')
374        with open('vendor.map', 'w') as f_w:
375            f_w.write('test content')
376        check_re = increment_image_processing(
377            verse_script, ['vendor'], "", "")
378        os.remove('vendor.img')
379        os.remove('vendor.map')
380        self.assertEqual(check_re, False)
381
382        sys.argv.clear()
383        sys.argv.append("build_update.py")
384        sys.argv.append(
385            "./test_target_package_miss_image")
386        sys.argv.append("./output_test/demo")
387        sys.argv.append("-s")
388        sys.argv.append("./test_source_package_miss_image.zip")
389        sys.argv.append("-pk")
390        sys.argv.append("./rsa_private_key2048.pem")
391        main()
392        output = "./output_test/demo"
393        pkg_re = os.path.exists(output)
394        self.assertEqual(pkg_re, False)
395        shutil.rmtree("./output_test")
396        clear_resource()
397        clear_package("test_target_package")
398        clear_package("test_target_package_miss_image")
399        clear_package("test_source_package_miss_image")
400
401    def test_target_package_path_return(self):
402        """
403        check_target_package_path, return False
404        :return:
405        """
406        with open("./rsa_private_key2048.pem", "wb") as w_f:
407            w_f.write(RSA_PRIVATE_KEY_DATA)
408        if not os.path.exists("./output_test"):
409            os.mkdir("./output_test")
410        sys.argv.clear()
411        sys.argv.append("build_update.py")
412        sys.argv.append("./")
413        sys.argv.append("./output_test/demo")
414        sys.argv.append("-pk")
415        sys.argv.append("./rsa_private_key2048.pem")
416        main()
417        output = "./output_test/demo"
418        pkg_re = os.path.exists(output)
419        shutil.rmtree("./output_test")
420        self.assertEqual(pkg_re, False)
421        clear_resource()
422        if os.path.exists("./rsa_private_key2048.pem"):
423            os.remove("./rsa_private_key2048.pem")
424
425    def test_get_update_info_return(self):
426        """
427        get_update_info, return False
428        :return:
429        """
430        create_input_package(
431            "test_target_package_miss_version_list", package_type="source",
432            is_miss_version_list=True)
433        if not os.path.exists("./output_test"):
434            os.mkdir("./output_test")
435        sys.argv.clear()
436        sys.argv.append("build_update.py")
437        sys.argv.append(
438            "./test_target_package_miss_version_list.zip")
439        sys.argv.append("./output_test/demo")
440        sys.argv.append("-pk")
441        sys.argv.append("./rsa_private_key2048.pem")
442        main()
443        output = "./output_test/demo"
444        pkg_re = os.path.exists(output)
445        shutil.rmtree("./output_test")
446        self.assertEqual(pkg_re, False)
447        clear_resource()
448        clear_package("test_target_package_miss_version_list")
449
450    def test_build_update_package(self):
451        """
452        build_update_package, return False
453        :return:
454        """
455        create_input_package(
456            "test_target_package_miss_updater_binary", package_type="source",
457            is_miss_updater_binary=True)
458        if not os.path.exists("./output_test"):
459            os.mkdir("./output_test")
460        sys.argv.clear()
461        sys.argv.append("build_update.py")
462        sys.argv.append(
463            "./test_target_package_miss_updater_binary.zip")
464        sys.argv.append("./output_test/")
465        sys.argv.append("-pk")
466        sys.argv.append("./rsa_private_key2048.pem")
467        main()
468        output = "./output_test/"
469        pkg_re = os.path.exists(output)
470        shutil.rmtree("./output_test")
471        self.assertEqual(pkg_re, True)
472        clear_resource()
473        clear_package("test_target_package_miss_updater_binary")
474
475    def test_on_server(self):
476        """
477        Signing on server.
478        :return:
479        """
480        create_input_package(
481            "test_target_package_on_server", package_type="source")
482        if not os.path.exists("./output_test"):
483            os.mkdir("./output_test")
484        sys.argv.clear()
485        sys.argv.append("build_update.py")
486        sys.argv.append(
487            "./test_target_package_on_server.zip")
488        sys.argv.append("./output_test/demo")
489        sys.argv.append("-pk")
490        sys.argv.append("ON_SERVER")
491        main()
492        output = "./output_test/demo"
493        pkg_re = os.path.exists(output)
494        shutil.rmtree("./output_test")
495        self.assertEqual(pkg_re, True)
496        clear_resource()
497        clear_package("test_target_package_on_server")
498
499    def test_private_key_check(self):
500        """
501        private_key_check, check private key param.
502        :return:
503        """
504        check_re = private_key_check("test_private_key_check")
505        self.assertEqual(check_re, False)
506