Home | History | Annotate | Download | only in py_utils 
      1 # Copyright 2013 The Chromium Authors. All rights reserved.
      2 # Use of this source code is governed by a BSD-style license that can be
      3 # found in the LICENSE file.
      4 import os
      5 import unittest
      6 
      7 from py_utils import discover
      8 
      9 
     10 class DiscoverTest(unittest.TestCase):
     11 
     12   def setUp(self):
     13     self._base_dir = os.path.join(os.path.dirname(__file__), 'test_data')
     14     self._start_dir = os.path.join(self._base_dir, 'discoverable_classes')
     15     self._base_class = Exception
     16 
     17   def testDiscoverClassesWithIndexByModuleName(self):
     18     classes = discover.DiscoverClasses(self._start_dir,
     19                                        self._base_dir,
     20                                        self._base_class,
     21                                        index_by_class_name=False)
     22 
     23     actual_classes = dict((name, cls.__name__)
     24                           for name, cls in classes.iteritems())
     25     expected_classes = {
     26         'another_discover_dummyclass': 'DummyExceptionWithParameterImpl1',
     27         'discover_dummyclass': 'DummyException',
     28         'parameter_discover_dummyclass': 'DummyExceptionWithParameterImpl2'
     29     }
     30     self.assertEqual(actual_classes, expected_classes)
     31 
     32   def testDiscoverDirectlyConstructableClassesWithIndexByClassName(self):
     33     classes = discover.DiscoverClasses(self._start_dir,
     34                                        self._base_dir,
     35                                        self._base_class,
     36                                        directly_constructable=True)
     37 
     38     actual_classes = dict((name, cls.__name__)
     39                           for name, cls in classes.iteritems())
     40     expected_classes = {
     41         'dummy_exception': 'DummyException',
     42         'dummy_exception_impl1': 'DummyExceptionImpl1',
     43         'dummy_exception_impl2': 'DummyExceptionImpl2',
     44     }
     45     self.assertEqual(actual_classes, expected_classes)
     46 
     47   def testDiscoverClassesWithIndexByClassName(self):
     48     classes = discover.DiscoverClasses(self._start_dir, self._base_dir,
     49                                        self._base_class)
     50 
     51     actual_classes = dict((name, cls.__name__)
     52                           for name, cls in classes.iteritems())
     53     expected_classes = {
     54         'dummy_exception': 'DummyException',
     55         'dummy_exception_impl1': 'DummyExceptionImpl1',
     56         'dummy_exception_impl2': 'DummyExceptionImpl2',
     57         'dummy_exception_with_parameter_impl1':
     58             'DummyExceptionWithParameterImpl1',
     59         'dummy_exception_with_parameter_impl2':
     60             'DummyExceptionWithParameterImpl2'
     61     }
     62     self.assertEqual(actual_classes, expected_classes)
     63 
     64   def testDiscoverClassesWithPatternAndIndexByModule(self):
     65     classes = discover.DiscoverClasses(self._start_dir,
     66                                        self._base_dir,
     67                                        self._base_class,
     68                                        pattern='another*',
     69                                        index_by_class_name=False)
     70 
     71     actual_classes = dict((name, cls.__name__)
     72                           for name, cls in classes.iteritems())
     73     expected_classes = {
     74         'another_discover_dummyclass': 'DummyExceptionWithParameterImpl1'
     75     }
     76     self.assertEqual(actual_classes, expected_classes)
     77 
     78   def testDiscoverDirectlyConstructableClassesWithPatternAndIndexByClassName(
     79       self):
     80     classes = discover.DiscoverClasses(self._start_dir,
     81                                        self._base_dir,
     82                                        self._base_class,
     83                                        pattern='another*',
     84                                        directly_constructable=True)
     85 
     86     actual_classes = dict((name, cls.__name__)
     87                           for name, cls in classes.iteritems())
     88     expected_classes = {
     89         'dummy_exception_impl1': 'DummyExceptionImpl1',
     90         'dummy_exception_impl2': 'DummyExceptionImpl2',
     91     }
     92     self.assertEqual(actual_classes, expected_classes)
     93 
     94   def testDiscoverClassesWithPatternAndIndexByClassName(self):
     95     classes = discover.DiscoverClasses(self._start_dir,
     96                                        self._base_dir,
     97                                        self._base_class,
     98                                        pattern='another*')
     99 
    100     actual_classes = dict((name, cls.__name__)
    101                           for name, cls in classes.iteritems())
    102     expected_classes = {
    103         'dummy_exception_impl1': 'DummyExceptionImpl1',
    104         'dummy_exception_impl2': 'DummyExceptionImpl2',
    105         'dummy_exception_with_parameter_impl1':
    106             'DummyExceptionWithParameterImpl1',
    107     }
    108     self.assertEqual(actual_classes, expected_classes)
    109 
    110 
    111 class ClassWithoutInitDefOne:  # pylint: disable=old-style-class, no-init
    112   pass
    113 
    114 
    115 class ClassWithoutInitDefTwo(object):
    116   pass
    117 
    118 
    119 class ClassWhoseInitOnlyHasSelf(object):
    120   def __init__(self):
    121     pass
    122 
    123 
    124 class ClassWhoseInitWithDefaultArguments(object):
    125   def __init__(self, dog=1, cat=None, cow=None, fud='a'):
    126     pass
    127 
    128 
    129 class ClassWhoseInitWithDefaultArgumentsAndNonDefaultArguments(object):
    130   def __init__(self, x, dog=1, cat=None, fish=None, fud='a'):
    131     pass
    132 
    133 
    134 class IsDirectlyConstructableTest(unittest.TestCase):
    135 
    136   def testIsDirectlyConstructableReturnsTrue(self):
    137     self.assertTrue(discover.IsDirectlyConstructable(ClassWithoutInitDefOne))
    138     self.assertTrue(discover.IsDirectlyConstructable(ClassWithoutInitDefTwo))
    139     self.assertTrue(discover.IsDirectlyConstructable(ClassWhoseInitOnlyHasSelf))
    140     self.assertTrue(
    141         discover.IsDirectlyConstructable(ClassWhoseInitWithDefaultArguments))
    142 
    143   def testIsDirectlyConstructableReturnsFalse(self):
    144     self.assertFalse(
    145         discover.IsDirectlyConstructable(
    146             ClassWhoseInitWithDefaultArgumentsAndNonDefaultArguments))
    147