FreeCAD

1
# SPDX-License-Identifier: LGPL-2.1-or-later
2
# ***************************************************************************
3
# *                                                                         *
4
# *   Copyright (c) 2023 FreeCAD Project Association                        *
5
# *                                                                         *
6
# *   This file is part of FreeCAD.                                         *
7
# *                                                                         *
8
# *   FreeCAD is free software: you can redistribute it and/or modify it    *
9
# *   under the terms of the GNU Lesser General Public License as           *
10
# *   published by the Free Software Foundation, either version 2.1 of the  *
11
# *   License, or (at your option) any later version.                       *
12
# *                                                                         *
13
# *   FreeCAD is distributed in the hope that it will be useful, but        *
14
# *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
15
# *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU      *
16
# *   Lesser General Public License for more details.                       *
17
# *                                                                         *
18
# *   You should have received a copy of the GNU Lesser General Public      *
19
# *   License along with FreeCAD. If not, see                               *
20
# *   <https://www.gnu.org/licenses/>.                                      *
21
# *                                                                         *
22
# ***************************************************************************
23
import os
24
import sys
25
import tempfile
26
import unittest
27
import unittest.mock
28

29
Mock = unittest.mock.MagicMock
30

31
sys.path.append("../../")
32

33

34
class TestVersion(unittest.TestCase):
35
    def setUp(self) -> None:
36
        if "addonmanager_metadata" in sys.modules:
37
            sys.modules.pop("addonmanager_metadata")
38
        self.packaging_version = None
39
        if "packaging.version" in sys.modules:
40
            self.packaging_version = sys.modules["packaging.version"]
41
            sys.modules.pop("packaging.version")
42

43
    def tearDown(self) -> None:
44
        if self.packaging_version is not None:
45
            sys.modules["packaging.version"] = self.packaging_version
46

47
    def test_init_from_string_manual(self):
48
        import addonmanager_metadata as amm
49

50
        version = amm.Version()
51
        version._parse_string_to_tuple = unittest.mock.MagicMock()
52
        version._init_from_string("1.2.3beta")
53
        self.assertTrue(version._parse_string_to_tuple.called)
54

55
    def test_init_from_list_good(self):
56
        """Initialization from a list works for good input"""
57
        import addonmanager_metadata as amm
58

59
        test_cases = [
60
            {"input": (1,), "output": [1, 0, 0, ""]},
61
            {"input": (1, 2), "output": [1, 2, 0, ""]},
62
            {"input": (1, 2, 3), "output": [1, 2, 3, ""]},
63
            {"input": (1, 2, 3, "b1"), "output": [1, 2, 3, "b1"]},
64
        ]
65
        for test_case in test_cases:
66
            with self.subTest(test_case=test_case):
67
                v = amm.Version(from_list=test_case["input"])
68
                self.assertListEqual(test_case["output"], v.version_as_list)
69

70
    def test_parse_string_to_tuple_normal(self):
71
        """Parsing of complete version string works for normal cases"""
72
        import addonmanager_metadata as amm
73

74
        cases = {
75
            "1": [1, 0, 0, ""],
76
            "1.2": [1, 2, 0, ""],
77
            "1.2.3": [1, 2, 3, ""],
78
            "1.2.3beta": [1, 2, 3, "beta"],
79
            "12_345.6_7.8pre-alpha": [12345, 67, 8, "pre-alpha"],
80
            # The above test is mostly to point out that Python gets permits underscore
81
            # characters in a number.
82
        }
83
        for inp, output in cases.items():
84
            with self.subTest(inp=inp, output=output):
85
                version = amm.Version()
86
                version._parse_string_to_tuple(inp)
87
                self.assertListEqual(version.version_as_list, output)
88

89
    def test_parse_string_to_tuple_invalid(self):
90
        """Parsing of invalid version string raises an exception"""
91
        import addonmanager_metadata as amm
92

93
        cases = {"One", "1,2,3", "1-2-3", "1/2/3"}
94
        for inp in cases:
95
            with self.subTest(inp=inp):
96
                with self.assertRaises(ValueError):
97
                    version = amm.Version()
98
                    version._parse_string_to_tuple(inp)
99

100
    def test_parse_final_entry_normal(self):
101
        """Parsing of the final entry works for normal cases"""
102
        import addonmanager_metadata as amm
103

104
        cases = {
105
            "3beta": (3, "beta"),
106
            "42.alpha": (42, ".alpha"),
107
            "123.45.6": (123, ".45.6"),
108
            "98_delta": (98, "_delta"),
109
            "1 and some words": (1, " and some words"),
110
        }
111
        for inp, output in cases.items():
112
            with self.subTest(inp=inp, output=output):
113
                number, text = amm.Version._parse_final_entry(inp)
114
                self.assertEqual(number, output[0])
115
                self.assertEqual(text, output[1])
116

117
    def test_parse_final_entry_invalid(self):
118
        """Invalid input raises an exception"""
119
        import addonmanager_metadata as amm
120

121
        cases = ["beta", "", ["a", "b"]]
122
        for case in cases:
123
            with self.subTest(case=case):
124
                with self.assertRaises(ValueError):
125
                    amm.Version._parse_final_entry(case)
126

127
    def test_operators_internal(self):
128
        """Test internal (non-package) comparison operators"""
129
        sys.modules["packaging.version"] = None
130
        import addonmanager_metadata as amm
131

132
        cases = self.given_comparison_cases()
133
        for case in cases:
134
            with self.subTest(case=case):
135
                first = amm.Version(case[0])
136
                second = amm.Version(case[1])
137
                self.assertEqual(first < second, case[0] < case[1])
138
                self.assertEqual(first > second, case[0] > case[1])
139
                self.assertEqual(first <= second, case[0] <= case[1])
140
                self.assertEqual(first >= second, case[0] >= case[1])
141
                self.assertEqual(first == second, case[0] == case[1])
142

143
    @staticmethod
144
    def given_comparison_cases():
145
        return [
146
            ("0.0.0alpha", "1.0.0alpha"),
147
            ("0.0.0alpha", "0.1.0alpha"),
148
            ("0.0.0alpha", "0.0.1alpha"),
149
            ("0.0.0alpha", "0.0.0beta"),
150
            ("0.0.0alpha", "0.0.0alpha"),
151
            ("1.0.0alpha", "0.0.0alpha"),
152
            ("0.1.0alpha", "0.0.0alpha"),
153
            ("0.0.1alpha", "0.0.0alpha"),
154
            ("0.0.0beta", "0.0.0alpha"),
155
        ]
156

157

158
class TestDependencyType(unittest.TestCase):
159
    """Ensure that the DependencyType dataclass converts to the correct strings"""
160

161
    def setUp(self) -> None:
162
        from addonmanager_metadata import DependencyType
163

164
        self.DependencyType = DependencyType
165

166
    def test_string_conversion_automatic(self):
167
        self.assertEqual(str(self.DependencyType.automatic), "automatic")
168

169
    def test_string_conversion_internal(self):
170
        self.assertEqual(str(self.DependencyType.internal), "internal")
171

172
    def test_string_conversion_addon(self):
173
        self.assertEqual(str(self.DependencyType.addon), "addon")
174

175
    def test_string_conversion_python(self):
176
        self.assertEqual(str(self.DependencyType.python), "python")
177

178

179
class TestUrlType(unittest.TestCase):
180
    """Ensure that the UrlType dataclass converts to the correct strings"""
181

182
    def setUp(self) -> None:
183
        from addonmanager_metadata import UrlType
184

185
        self.UrlType = UrlType
186

187
    def test_string_conversion_website(self):
188
        self.assertEqual(str(self.UrlType.website), "website")
189

190
    def test_string_conversion_repository(self):
191
        self.assertEqual(str(self.UrlType.repository), "repository")
192

193
    def test_string_conversion_bugtracker(self):
194
        self.assertEqual(str(self.UrlType.bugtracker), "bugtracker")
195

196
    def test_string_conversion_readme(self):
197
        self.assertEqual(str(self.UrlType.readme), "readme")
198

199
    def test_string_conversion_documentation(self):
200
        self.assertEqual(str(self.UrlType.documentation), "documentation")
201

202
    def test_string_conversion_discussion(self):
203
        self.assertEqual(str(self.UrlType.discussion), "discussion")
204

205

206
class TestMetadataAuxiliaryFunctions(unittest.TestCase):
207
    def test_get_first_supported_freecad_version_simple(self):
208
        from addonmanager_metadata import (
209
            Metadata,
210
            Version,
211
            get_first_supported_freecad_version,
212
        )
213

214
        expected_result = Version(from_string="0.20.2beta")
215
        metadata = self.given_metadata_with_freecadmin_set(expected_result)
216
        first_version = get_first_supported_freecad_version(metadata)
217
        self.assertEqual(expected_result, first_version)
218

219
    @staticmethod
220
    def given_metadata_with_freecadmin_set(min_version):
221
        from addonmanager_metadata import Metadata
222

223
        metadata = Metadata()
224
        metadata.freecadmin = min_version
225
        return metadata
226

227
    def test_get_first_supported_freecad_version_with_content(self):
228
        from addonmanager_metadata import (
229
            Metadata,
230
            Version,
231
            get_first_supported_freecad_version,
232
        )
233

234
        expected_result = Version(from_string="0.20.2beta")
235
        metadata = self.given_metadata_with_freecadmin_in_content(expected_result)
236
        first_version = get_first_supported_freecad_version(metadata)
237
        self.assertEqual(expected_result, first_version)
238

239
    @staticmethod
240
    def given_metadata_with_freecadmin_in_content(min_version):
241
        from addonmanager_metadata import Metadata, Version
242

243
        v_list = min_version.version_as_list
244
        metadata = Metadata()
245
        wb1 = Metadata()
246
        wb1.freecadmin = Version(from_list=[v_list[0] + 1, v_list[1], v_list[2], v_list[3]])
247
        wb2 = Metadata()
248
        wb2.freecadmin = Version(from_list=[v_list[0], v_list[1] + 1, v_list[2], v_list[3]])
249
        wb3 = Metadata()
250
        wb3.freecadmin = Version(from_list=[v_list[0], v_list[1], v_list[2] + 1, v_list[3]])
251
        m1 = Metadata()
252
        m1.freecadmin = min_version
253
        metadata.content = {"workbench": [wb1, wb2, wb3], "macro": [m1]}
254
        return metadata
255

256

257
class TestMetadataReader(unittest.TestCase):
258
    """Test reading metadata from XML"""
259

260
    def setUp(self) -> None:
261
        if "xml.etree.ElementTree" in sys.modules:
262
            sys.modules.pop("xml.etree.ElementTree")
263
        if "addonmanager_metadata" in sys.modules:
264
            sys.modules.pop("addonmanager_metadata")
265

266
    def tearDown(self) -> None:
267
        if "xml.etree.ElementTree" in sys.modules:
268
            sys.modules.pop("xml.etree.ElementTree")
269
        if "addonmanager_metadata" in sys.modules:
270
            sys.modules.pop("addonmanager_metadata")
271

272
    def test_from_file(self):
273
        from addonmanager_metadata import MetadataReader
274

275
        MetadataReader.from_bytes = Mock()
276
        with tempfile.NamedTemporaryFile(delete=False) as temp:
277
            temp.write(b"Some data")
278
            temp.close()
279
            MetadataReader.from_file(temp.name)
280
            self.assertTrue(MetadataReader.from_bytes.called)
281
            MetadataReader.from_bytes.assert_called_once_with(b"Some data")
282
            os.unlink(temp.name)
283

284
    @unittest.skip("Breaks other tests, needs to be fixed")
285
    def test_from_bytes(self):
286
        import xml.etree.ElementTree
287

288
        with unittest.mock.patch("xml.etree.ElementTree") as element_tree_mock:
289
            from addonmanager_metadata import MetadataReader
290

291
            MetadataReader._process_element_tree = Mock()
292
            MetadataReader.from_bytes(b"Some data")
293
            element_tree_mock.parse.assert_called_once_with(b"Some data")
294

295
    def test_process_element_tree(self):
296
        from addonmanager_metadata import MetadataReader
297

298
        MetadataReader._determine_namespace = Mock(return_value="")
299
        element_tree_mock = Mock()
300
        MetadataReader._create_node = Mock()
301
        MetadataReader._process_element_tree(element_tree_mock)
302
        MetadataReader._create_node.assert_called_once()
303

304
    def test_determine_namespace_found_full(self):
305
        from addonmanager_metadata import MetadataReader
306

307
        root = Mock()
308
        root.tag = "{https://wiki.freecad.org/Package_Metadata}package"
309
        found_ns = MetadataReader._determine_namespace(root)
310
        self.assertEqual(found_ns, "{https://wiki.freecad.org/Package_Metadata}")
311

312
    def test_determine_namespace_found_empty(self):
313
        from addonmanager_metadata import MetadataReader
314

315
        root = Mock()
316
        root.tag = "package"
317
        found_ns = MetadataReader._determine_namespace(root)
318
        self.assertEqual(found_ns, "")
319

320
    def test_determine_namespace_not_found(self):
321
        from addonmanager_metadata import MetadataReader
322

323
        root = Mock()
324
        root.find = Mock(return_value=False)
325
        with self.assertRaises(RuntimeError):
326
            MetadataReader._determine_namespace(root)
327

328
    def test_parse_child_element_simple_strings(self):
329
        from addonmanager_metadata import Metadata, MetadataReader
330

331
        tags = ["name", "date", "description", "icon", "classname", "subdirectory"]
332
        for tag in tags:
333
            with self.subTest(tag=tag):
334
                text = f"Test Data for {tag}"
335
                child = self.given_mock_tree_node(tag, text)
336
                mock_metadata = Metadata()
337
                MetadataReader._parse_child_element("", child, mock_metadata)
338
                self.assertEqual(mock_metadata.__dict__[tag], text)
339

340
    def test_parse_child_element_version(self):
341
        from addonmanager_metadata import Metadata, Version, MetadataReader
342

343
        mock_metadata = Metadata()
344
        child = self.given_mock_tree_node("version", "1.2.3")
345
        MetadataReader._parse_child_element("", child, mock_metadata)
346
        self.assertEqual(Version("1.2.3"), mock_metadata.version)
347

348
    def test_parse_child_element_version_bad(self):
349
        from addonmanager_metadata import Metadata, Version, MetadataReader
350

351
        mock_metadata = Metadata()
352
        child = self.given_mock_tree_node("version", "1-2-3")
353
        MetadataReader._parse_child_element("", child, mock_metadata)
354
        self.assertEqual(Version("0.0.0"), mock_metadata.version)
355

356
    def test_parse_child_element_lists_of_strings(self):
357
        from addonmanager_metadata import Metadata, MetadataReader
358

359
        tags = ["file", "tag"]
360
        for tag in tags:
361
            with self.subTest(tag=tag):
362
                mock_metadata = Metadata()
363
                expected_results = []
364
                for i in range(10):
365
                    text = f"Test {i} for {tag}"
366
                    expected_results.append(text)
367
                    child = self.given_mock_tree_node(tag, text)
368
                    MetadataReader._parse_child_element("", child, mock_metadata)
369
                self.assertEqual(len(mock_metadata.__dict__[tag]), 10)
370
                self.assertListEqual(mock_metadata.__dict__[tag], expected_results)
371

372
    def test_parse_child_element_lists_of_contacts(self):
373
        from addonmanager_metadata import Metadata, Contact, MetadataReader
374

375
        tags = ["maintainer", "author"]
376
        for tag in tags:
377
            with self.subTest(tag=tag):
378
                mock_metadata = Metadata()
379
                expected_results = []
380
                for i in range(10):
381
                    text = f"Test {i} for {tag}"
382
                    email = f"Email {i} for {tag}" if i % 2 == 0 else None
383
                    expected_results.append(Contact(name=text, email=email))
384
                    child = self.given_mock_tree_node(tag, text, {"email": email})
385
                    MetadataReader._parse_child_element("", child, mock_metadata)
386
                self.assertEqual(len(mock_metadata.__dict__[tag]), 10)
387
                self.assertListEqual(mock_metadata.__dict__[tag], expected_results)
388

389
    def test_parse_child_element_list_of_licenses(self):
390
        from addonmanager_metadata import Metadata, License, MetadataReader
391

392
        mock_metadata = Metadata()
393
        expected_results = []
394
        tag = "license"
395
        for i in range(10):
396
            text = f"Test {i} for {tag}"
397
            file = f"Filename {i} for {tag}" if i % 2 == 0 else None
398
            expected_results.append(License(name=text, file=file))
399
            child = self.given_mock_tree_node(tag, text, {"file": file})
400
            MetadataReader._parse_child_element("", child, mock_metadata)
401
        self.assertEqual(len(mock_metadata.__dict__[tag]), 10)
402
        self.assertListEqual(mock_metadata.__dict__[tag], expected_results)
403

404
    def test_parse_child_element_list_of_urls(self):
405
        from addonmanager_metadata import Metadata, Url, UrlType, MetadataReader
406

407
        mock_metadata = Metadata()
408
        expected_results = []
409
        tag = "url"
410
        for i in range(10):
411
            text = f"Test {i} for {tag}"
412
            url_type = UrlType(i % len(UrlType))
413
            type = str(url_type)
414
            branch = ""
415
            if type == "repository":
416
                branch = f"Branch {i} for {tag}"
417
            expected_results.append(Url(location=text, type=url_type, branch=branch))
418
            child = self.given_mock_tree_node(tag, text, {"type": type, "branch": branch})
419
            MetadataReader._parse_child_element("", child, mock_metadata)
420
        self.assertEqual(len(mock_metadata.__dict__[tag]), 10)
421
        self.assertListEqual(mock_metadata.__dict__[tag], expected_results)
422

423
    def test_parse_child_element_lists_of_dependencies(self):
424
        from addonmanager_metadata import (
425
            Metadata,
426
            Dependency,
427
            DependencyType,
428
            MetadataReader,
429
        )
430

431
        tags = ["depend", "conflict", "replace"]
432
        attributes = {
433
            "version_lt": "1.0.0",
434
            "version_lte": "1.0.0",
435
            "version_eq": "1.0.0",
436
            "version_gte": "1.0.0",
437
            "version_gt": "1.0.0",
438
            "condition": "$BuildVersionMajor<1",
439
            "optional": True,
440
        }
441

442
        for tag in tags:
443
            for attribute, attr_value in attributes.items():
444
                with self.subTest(tag=tag, attribute=attribute):
445
                    mock_metadata = Metadata()
446
                    expected_results = []
447
                    for i in range(10):
448
                        text = f"Test {i} for {tag}"
449
                        dependency_type = DependencyType(i % len(DependencyType))
450
                        dependency_type_str = str(dependency_type)
451
                        expected = Dependency(package=text, dependency_type=dependency_type)
452
                        expected.__dict__[attribute] = attr_value
453
                        expected_results.append(expected)
454
                        child = self.given_mock_tree_node(
455
                            tag,
456
                            text,
457
                            {"type": dependency_type_str, attribute: str(attr_value)},
458
                        )
459
                        MetadataReader._parse_child_element("", child, mock_metadata)
460
                    self.assertEqual(len(mock_metadata.__dict__[tag]), 10)
461
                    self.assertListEqual(mock_metadata.__dict__[tag], expected_results)
462

463
    def test_parse_child_element_ignore_unknown_tag(self):
464
        from addonmanager_metadata import Metadata, MetadataReader
465

466
        tag = "invalid_tag"
467
        text = "Shouldn't matter"
468
        child = self.given_mock_tree_node(tag, text)
469
        mock_metadata = Metadata()
470
        MetadataReader._parse_child_element("", child, mock_metadata)
471
        self.assertNotIn(tag, mock_metadata.__dict__)
472

473
    def test_parse_child_element_versions(self):
474
        from addonmanager_metadata import Metadata, Version, MetadataReader
475

476
        tags = ["version", "freecadmin", "freecadmax", "pythonmin"]
477
        for tag in tags:
478
            with self.subTest(tag=tag):
479
                mock_metadata = Metadata()
480
                text = "3.4.5beta"
481
                child = self.given_mock_tree_node(tag, text)
482
                MetadataReader._parse_child_element("", child, mock_metadata)
483
                self.assertEqual(mock_metadata.__dict__[tag], Version(from_string=text))
484

485
    def given_mock_tree_node(self, tag, text, attributes=None):
486
        class MockTreeNode:
487
            def __init__(self):
488
                self.tag = tag
489
                self.text = text
490
                self.attrib = attributes if attributes is not None else []
491

492
        return MockTreeNode()
493

494
    def test_parse_content_valid(self):
495
        from addonmanager_metadata import MetadataReader
496

497
        valid_content_items = ["workbench", "macro", "preferencepack"]
498
        MetadataReader._create_node = Mock()
499
        for content_type in valid_content_items:
500
            with self.subTest(content_type=content_type):
501
                tree_mock = [self.given_mock_tree_node(content_type, None)]
502
                metadata_mock = Mock()
503
                MetadataReader._parse_content("", metadata_mock, tree_mock)
504
                MetadataReader._create_node.assert_called_once()
505
                MetadataReader._create_node.reset_mock()
506

507
    def test_parse_content_invalid(self):
508
        from addonmanager_metadata import MetadataReader
509

510
        MetadataReader._create_node = Mock()
511
        content_item = "no_such_content_type"
512
        tree_mock = [self.given_mock_tree_node(content_item, None)]
513
        metadata_mock = Mock()
514
        MetadataReader._parse_content("", metadata_mock, tree_mock)
515
        MetadataReader._create_node.assert_not_called()
516

517

518
class TestMetadataReaderIntegration(unittest.TestCase):
519
    """Full-up tests of the MetadataReader class (no mocking)."""
520

521
    def setUp(self) -> None:
522
        self.test_data_dir = os.path.join(os.path.dirname(__file__), "..", "data")
523
        remove_list = []
524
        for key in sys.modules:
525
            if "addonmanager_metadata" in key:
526
                remove_list.append(key)
527
        for key in remove_list:
528
            print(f"Removing {key}")
529
            sys.modules.pop(key)
530

531
    def test_loading_simple_metadata_file(self):
532
        from addonmanager_metadata import (
533
            Contact,
534
            Dependency,
535
            License,
536
            MetadataReader,
537
            Url,
538
            UrlType,
539
            Version,
540
        )
541

542
        filename = os.path.join(self.test_data_dir, "good_package.xml")
543
        metadata = MetadataReader.from_file(filename)
544
        self.assertEqual("Test Workbench", metadata.name)
545
        self.assertEqual("A package.xml file for unit testing.", metadata.description)
546
        self.assertEqual(Version("1.0.1"), metadata.version)
547
        self.assertEqual("2022-01-07", metadata.date)
548
        self.assertEqual("Resources/icons/PackageIcon.svg", metadata.icon)
549
        self.assertListEqual([License(name="LGPL-2.1", file="LICENSE")], metadata.license)
550
        self.assertListEqual(
551
            [Contact(name="FreeCAD Developer", email="developer@freecad.org")],
552
            metadata.maintainer,
553
        )
554
        self.assertListEqual(
555
            [
556
                Url(
557
                    location="https://github.com/chennes/FreeCAD-Package",
558
                    type=UrlType.repository,
559
                    branch="main",
560
                ),
561
                Url(
562
                    location="https://github.com/chennes/FreeCAD-Package/blob/main/README.md",
563
                    type=UrlType.readme,
564
                ),
565
            ],
566
            metadata.url,
567
        )
568
        self.assertListEqual(["Tag0", "Tag1"], metadata.tag)
569
        self.assertIn("workbench", metadata.content)
570
        self.assertEqual(len(metadata.content["workbench"]), 1)
571
        wb_metadata = metadata.content["workbench"][0]
572
        self.assertEqual("MyWorkbench", wb_metadata.classname)
573
        self.assertEqual("./", wb_metadata.subdirectory)
574
        self.assertListEqual(["TagA", "TagB", "TagC"], wb_metadata.tag)
575

576
    def test_multiple_workbenches(self):
577
        from addonmanager_metadata import MetadataReader
578

579
        filename = os.path.join(self.test_data_dir, "workbench_only.xml")
580
        metadata = MetadataReader.from_file(filename)
581
        self.assertIn("workbench", metadata.content)
582
        self.assertEqual(len(metadata.content["workbench"]), 3)
583
        expected_wb_classnames = [
584
            "MyFirstWorkbench",
585
            "MySecondWorkbench",
586
            "MyThirdWorkbench",
587
        ]
588
        for wb in metadata.content["workbench"]:
589
            self.assertIn(wb.classname, expected_wb_classnames)
590
            expected_wb_classnames.remove(wb.classname)
591
        self.assertEqual(len(expected_wb_classnames), 0)
592

593
    def test_multiple_macros(self):
594
        from addonmanager_metadata import MetadataReader
595

596
        filename = os.path.join(self.test_data_dir, "macro_only.xml")
597
        metadata = MetadataReader.from_file(filename)
598
        self.assertIn("macro", metadata.content)
599
        self.assertEqual(len(metadata.content["macro"]), 2)
600
        expected_wb_files = ["MyMacro.FCStd", "MyOtherMacro.FCStd"]
601
        for wb in metadata.content["macro"]:
602
            self.assertIn(wb.file[0], expected_wb_files)
603
            expected_wb_files.remove(wb.file[0])
604
        self.assertEqual(len(expected_wb_files), 0)
605

606
    def test_multiple_preference_packs(self):
607
        from addonmanager_metadata import MetadataReader
608

609
        filename = os.path.join(self.test_data_dir, "prefpack_only.xml")
610
        metadata = MetadataReader.from_file(filename)
611
        self.assertIn("preferencepack", metadata.content)
612
        self.assertEqual(len(metadata.content["preferencepack"]), 3)
613
        expected_packs = ["MyFirstPack", "MySecondPack", "MyThirdPack"]
614
        for wb in metadata.content["preferencepack"]:
615
            self.assertIn(wb.name, expected_packs)
616
            expected_packs.remove(wb.name)
617
        self.assertEqual(len(expected_packs), 0)
618

619
    def test_content_combination(self):
620
        from addonmanager_metadata import MetadataReader
621

622
        filename = os.path.join(self.test_data_dir, "combination.xml")
623
        metadata = MetadataReader.from_file(filename)
624
        self.assertIn("preferencepack", metadata.content)
625
        self.assertEqual(len(metadata.content["preferencepack"]), 1)
626
        self.assertIn("macro", metadata.content)
627
        self.assertEqual(len(metadata.content["macro"]), 1)
628
        self.assertIn("workbench", metadata.content)
629
        self.assertEqual(len(metadata.content["workbench"]), 1)
630

631

632
if __name__ == "__main__":
633
    unittest.main()
634