def test_circular(self):
        FLAGS = Flags('ONE', 'TWO')
        registry = FlagRegistry()

        @registry.register(flag=FLAGS.ONE, depends_on=FLAGS.TWO, key='one')
        def method_one():
            pass

        @registry.register(flag=FLAGS.TWO, depends_on=FLAGS.ONE, key='two')
        def method_two():
            pass

        with self.assertRaises(Exception) as context:
            registry._do_method_pass([method_one, method_two],
                                     0,
                                     dict(),
                                     False,
                                     flags=FLAGS.ONE | FLAGS.TWO)
            self.assertTrue(
                'Circular Dependency Error' in str(context.exception))

        with self.assertRaises(Exception) as context:
            registry._calculate_dependency_flag(method_two)
            self.assertTrue(
                'Circular Dependency Error' in str(context.exception))
Exemple #2
0
    def test_validate_flags(self):
        FLAGS = Flags("ONE", "TWO", "THREE", "FOUR")
        registry = FlagRegistry()

        @registry.register(flag=FLAGS.ONE, key="one")
        def method_one():
            pass

        @registry.register(flag=FLAGS.TWO, depends_on=FLAGS.ONE, key="two")
        def method_two():
            pass

        @registry.register(flag=FLAGS.THREE, key="three")
        def method_three():
            pass

        @registry.register(flag=FLAGS.FOUR, depends_on=FLAGS.TWO, key="four")
        def method_four():
            pass

        self.assertEqual(
            registry._calculate_dependency_flag(method_four), FLAGS.ONE | FLAGS.TWO
        )

        self.assertEqual(
            set(registry._find_methods_matching_flag(FLAGS.ONE | FLAGS.THREE)),
            set([method_one, method_three]),
        )

        self.assertEqual(
            set(registry._find_methods_matching_flag(FLAGS.FOUR)), set([method_four])
        )

        # Asking for FOUR, which depends on TWO, which depends on ONE
        flag = FLAGS.FOUR
        self.assertEqual(
            registry._validate_flags(flag), FLAGS.ONE | FLAGS.TWO | FLAGS.FOUR
        )

        flag = FLAGS.THREE
        self.assertEqual(registry._validate_flags(flag), FLAGS.THREE)

        flag = FLAGS.TWO
        self.assertEqual(registry._validate_flags(flag), FLAGS.ONE | FLAGS.TWO)
    def test_validate_flags(self):
        FLAGS = Flags('ONE', 'TWO', 'THREE', 'FOUR')
        registry = FlagRegistry()

        @registry.register(flag=FLAGS.ONE, key='one')
        def method_one():
            pass

        @registry.register(flag=FLAGS.TWO, depends_on=FLAGS.ONE, key='two')
        def method_two():
            pass

        @registry.register(flag=FLAGS.THREE, key='three')
        def method_three():
            pass

        @registry.register(flag=FLAGS.FOUR, depends_on=FLAGS.TWO, key='four')
        def method_four():
            pass

        self.assertEqual(registry._calculate_dependency_flag(method_four),
                         FLAGS.ONE | FLAGS.TWO)

        self.assertEqual(
            set(registry._find_methods_matching_flag(FLAGS.ONE | FLAGS.THREE)),
            set([method_one, method_three]))

        self.assertEqual(set(registry._find_methods_matching_flag(FLAGS.FOUR)),
                         set([method_four]))

        # Asking for FOUR, which depends on TWO, which depends on ONE
        flag = FLAGS.FOUR
        self.assertEqual(registry._validate_flags(flag),
                         FLAGS.ONE | FLAGS.TWO | FLAGS.FOUR)

        flag = FLAGS.THREE
        self.assertEqual(registry._validate_flags(flag), FLAGS.THREE)

        flag = FLAGS.TWO
        self.assertEqual(registry._validate_flags(flag), FLAGS.ONE | FLAGS.TWO)