Merge "Renames filter to base_filter and weight to base_weight"

6 files changed, 139 insertions, 9 deletions

diff --git a/openstack/common/scheduler/filter.py b/openstack/common/scheduler/base_filter.py
index 52c18af..52c18af 100644
--- a/openstack/common/scheduler/filter.py
+++ b/openstack/common/scheduler/base_filter.py
diff --git a/openstack/common/scheduler/weight.py b/openstack/common/scheduler/base_weight.py
index 82f1d25..82f1d25 100644
--- a/openstack/common/scheduler/weight.py
+++ b/openstack/common/scheduler/base_weight.py
diff --git a/openstack/common/scheduler/filters/__init__.py b/openstack/common/scheduler/filters/__init__.py
index d3a99a5..6fb5a13 100644
--- a/openstack/common/scheduler/filters/__init__.py
+++ b/openstack/common/scheduler/filters/__init__.py
@@ -18,12 +18,12 @@ Scheduler host filters
 """
 
 from openstack.common import log as logging
-from openstack.common.scheduler import filter
+from openstack.common.scheduler import base_filter
 
 LOG = logging.getLogger(__name__)
 
 
-class BaseHostFilter(filter.BaseFilter):
+class BaseHostFilter(base_filter.BaseFilter):
     """Base class for host filters."""
     def _filter_one(self, obj, filter_properties):
         """Return True if the object passes the filter, otherwise False."""
@@ -36,6 +36,6 @@ class BaseHostFilter(filter.BaseFilter):
         raise NotImplementedError()
 
 
-class HostFilterHandler(filter.BaseFilterHandler):
+class HostFilterHandler(base_filter.BaseFilterHandler):
     def __init__(self, namespace):
         super(HostFilterHandler, self).__init__(BaseHostFilter, namespace)
diff --git a/openstack/common/scheduler/weights/__init__.py b/openstack/common/scheduler/weights/__init__.py
index c05c04e..e2eb04a 100644
--- a/openstack/common/scheduler/weights/__init__.py
+++ b/openstack/common/scheduler/weights/__init__.py
@@ -18,10 +18,10 @@ Scheduler host weights
 """
 
 
-from openstack.common.scheduler import weight
+from openstack.common.scheduler import base_weight
 
 
-class WeighedHost(weight.WeighedObject):
+class WeighedHost(base_weight.WeighedObject):
     def to_dict(self):
         return {
             'weight': self.weight,
@@ -33,12 +33,12 @@ class WeighedHost(weight.WeighedObject):
                 (self.obj.host, self.weight))
 
 
-class BaseHostWeigher(weight.BaseWeigher):
+class BaseHostWeigher(base_weight.BaseWeigher):
     """Base class for host weights."""
     pass
 
 
-class HostWeightHandler(weight.BaseWeightHandler):
+class HostWeightHandler(base_weight.BaseWeightHandler):
     object_class = WeighedHost
 
     def __init__(self, namespace):
diff --git a/tests/unit/scheduler/test_base_filter.py b/tests/unit/scheduler/test_base_filter.py
new file mode 100644
index 0000000..680e0de
--- /dev/null
+++ b/tests/unit/scheduler/test_base_filter.py
@@ -0,0 +1,129 @@
+# Copyright (c) 2013 OpenStack Foundation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import mox
+
+from openstack.common.scheduler import base_filter
+
+from tests import utils
+
+
+class TestBaseFilter(utils.BaseTestCase):
+
+    def setUp(self):
+        super(TestBaseFilter, self).setUp()
+        self.filter = base_filter.BaseFilter()
+        self.mox = mox.Mox()
+
+    def test_filter_one_is_called(self):
+        filters = [1, 2, 3, 4]
+        filter_properties = {'x': 'y'}
+        self.mox.StubOutWithMock(self.filter, '_filter_one')
+
+        self.filter._filter_one(1, filter_properties).AndReturn(False)
+        self.filter._filter_one(2, filter_properties).AndReturn(True)
+        self.filter._filter_one(3, filter_properties).AndReturn(True)
+        self.filter._filter_one(4, filter_properties).AndReturn(False)
+
+        self.mox.ReplayAll()
+
+        result = list(self.filter.filter_all(filters, filter_properties))
+        self.assertEqual([2, 3], result)
+
+
+class FakeExtension(object):
+
+    def __init__(self, plugin):
+        self.plugin = plugin
+
+
+class BaseFakeFilter(base_filter.BaseFilter):
+    pass
+
+
+class FakeFilter1(BaseFakeFilter):
+    """
+    * Should be included in the output of all_classes
+    * It derives from BaseFakeFilter
+    * AND
+    * It has a fake entry point defined (is returned by fake ExtensionManager)
+    """
+
+
+class FakeFilter2(BaseFakeFilter):
+    """
+    * Should be NOT included in all_classes
+    * Derives from BaseFakeFilter
+    * BUT
+    * It has no entry point
+    """
+
+
+class FakeFilter3(base_filter.BaseFilter):
+    """
+    * Should NOT be included
+    * Does NOT derive from BaseFakeFilter
+    """
+    pass
+
+
+class FakeFilter4(BaseFakeFilter):
+    """
+    Should be included
+    * Derives from BaseFakeFilter
+    * AND
+    * It has an entrypoint
+    """
+    pass
+
+
+class FakeFilter5(BaseFakeFilter):
+    """
+    Should NOT be included
+    * Derives from BaseFakeFilter
+    * BUT
+    * It has NO entrypoint
+    """
+    pass
+
+
+class FakeExtensionManager(list):
+
+    def __init__(self, namespace):
+        classes = [FakeFilter1, FakeFilter3, FakeFilter4]
+        exts = map(FakeExtension, classes)
+        super(FakeExtensionManager, self).__init__(exts)
+        self.namespace = namespace
+
+
+class TestBaseFilterHandler(utils.BaseTestCase):
+
+    def setUp(self):
+        super(TestBaseFilterHandler, self).setUp()
+        self.stubs.Set(base_filter.extension, 'ExtensionManager',
+                       FakeExtensionManager)
+        self.handler = base_filter.BaseFilterHandler(BaseFakeFilter,
+                                                     'fake_filters')
+
+    def test_get_all_classes(self):
+        # In order for a FakeFilter to be returned by get_all_classes, it has
+        # to comply with these rules:
+        # * It must be derived from BaseFakeFilter
+        #   AND
+        # * It must have a python entrypoint assigned (returned by
+        #   FakeExtensionManager)
+        expected = [FakeFilter1, FakeFilter4]
+        result = self.handler.get_all_classes()
+        self.assertEqual(expected, result)
diff --git a/tests/unit/scheduler/test_weights.py b/tests/unit/scheduler/test_weights.py
index d539ab3..21d3f3e 100644
--- a/tests/unit/scheduler/test_weights.py
+++ b/tests/unit/scheduler/test_weights.py
@@ -16,7 +16,7 @@
 Tests For Scheduler weights.
 """
 
-from openstack.common.scheduler import weight
+from openstack.common.scheduler import base_weight
 from tests.unit import fakes
 from tests import utils
 
@@ -24,7 +24,8 @@ from tests import utils
 class TestWeightHandler(utils.BaseTestCase):
     def test_get_all_classes(self):
         namespace = "openstack.common.tests.fakes.weights"
-        handler = weight.BaseWeightHandler(weight.BaseWeigher, namespace)
+        handler = base_weight.BaseWeightHandler(
+            base_weight.BaseWeigher, namespace)
         classes = handler.get_all_classes()
         self.assertTrue(fakes.FakeWeigher1 in classes)
         self.assertTrue(fakes.FakeWeigher2 in classes)