Exemple #1
0
    def test_dynamic_keys_clash(self):
        """Dynamic key clash captured correctly"""
        data = {"A": "foo", "{A}": "bar", "foo": "B"}

        with self.assertRaises(api.DynamicKeyClashError):
            api.compute(data, allow_key_clash=False)

        # Allow to pass (even if unpredictable result)
        api.compute(data, allow_key_clash=True)
Exemple #2
0
    def test_cycle(self):
        """Cycle error is correctly detected in dynamic environment"""
        data = {"X": "{Y}", "Y": "{X}"}

        with self.assertRaises(api.CycleError):
            api.compute(data, allow_cycle=False)

        # If we compute the cycle the result is unknown, it can be either {Y}
        # or {X} for both values so we just check whether are equal
        result = api.compute(data, allow_cycle=True)
        self.assertEqual(result["X"], result["Y"])
Exemple #3
0
    def test_nesting_deep(self):
        """Deep nested dynamic environment computes correctly"""

        data = {
            "A": "bla",
            "B": "{A}",
            "C": "{B}",
            "D": "{A}{B}",
            "E": "{A}{B}{C}{D}",
            "F": "{D}",
            "G": "{F}_{E}",
            "H": "{G}",
            "I": "deep_{H}"
        }

        result = api.compute(data)

        self.assertEqual(
            result, {
                "A": "bla",
                "B": "bla",
                "C": "bla",
                "D": "blabla",
                "E": "blablablablabla",
                "F": "blabla",
                "G": "blabla_blablablablabla",
                "H": "blabla_blablablablabla",
                "I": "deep_blabla_blablablablabla"
            })
Exemple #4
0
    def test_compute_tools(self):

        self.setup_sample("sample1")
        env = api.get_tools(["maya_2018"], platform_name="windows")

        env = api.compute(env)
        self.assertEqual(env["MAYA_LOCATION"],
                         "C:/Program Files/Autodesk/Maya2018")
Exemple #5
0
    def test_compute_preserve_reference_to_self(self):
        """api.compute() does not format key references to itself"""

        data = {"PATH": "{PATH}", "PYTHONPATH": "x;y/{PYTHONPATH}"}
        data = api.compute(data)
        self.assertEqual(data, {
            "PATH": "{PATH}",
            "PYTHONPATH": "x;y/{PYTHONPATH}"
        })
Exemple #6
0
    def test_dynamic_keys(self):
        """Computing dynamic keys works"""
        data = {"A": "D", "B": "C", "{A}": "this is D", "{B}": "this is C"}

        env = api.compute(data)

        self.assertEqual(env, {
            "A": "D",
            "B": "C",
            "C": "this is C",
            "D": "this is D",
        })