diff --git a/nova/scheduler/host_filter.py b/nova/scheduler/host_filter.py
index 117f0824..79e9f315 100644
--- a/nova/scheduler/host_filter.py
+++ b/nova/scheduler/host_filter.py
@@ -313,8 +313,3 @@ class HostFilterScheduler(zone_aware_scheduler.ZoneAwareScheduler):
         instance_type = request_spec['instance_type']
         name, query = driver.instance_type_to_filter(instance_type)
         return driver.filter_hosts(self.zone_manager, query)
-
-    def weigh_hosts(self, num, request_spec, hosts):
-        """Derived classes must override this method and return
-           a lists of hosts in [{weight, hostname}] format."""
-        return [dict(weight=1, hostname=host) for host, caps in hosts]
diff --git a/nova/tests/test_zone_aware_scheduler.py b/nova/tests/scheduler/test_zone_aware_scheduler.py
similarity index 100%
rename from nova/tests/test_zone_aware_scheduler.py
rename to nova/tests/scheduler/test_zone_aware_scheduler.py
diff --git a/nova/tests/test_host_filter.py b/nova/tests/test_host_filter.py
deleted file mode 100644
index 1a2a86a7..00000000
--- a/nova/tests/test_host_filter.py
+++ /dev/null
@@ -1,211 +0,0 @@
-# Copyright 2011 OpenStack LLC.
-# All Rights Reserved.
-#
-#    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.
-"""
-Tests For Scheduler Host Filter Drivers.
-"""
-
-import json
-
-from nova import exception
-from nova import flags
-from nova import test
-from nova.scheduler import host_filter
-
-FLAGS = flags.FLAGS
-
-
-class FakeZoneManager:
-    pass
-
-
-class HostFilterTestCase(test.TestCase):
-    """Test case for host filter drivers."""
-
-    def _host_caps(self, multiplier):
-        # Returns host capabilities in the following way:
-        # host1 = memory:free 10 (100max)
-        #         disk:available 100 (1000max)
-        # hostN = memory:free 10 + 10N
-        #         disk:available 100 + 100N
-        # in other words: hostN has more resources than host0
-        # which means ... don't go above 10 hosts.
-        return {'host_name-description': 'XenServer %s' % multiplier,
-                'host_hostname': 'xs-%s' % multiplier,
-                'host_memory_total': 100,
-                'host_memory_overhead': 10,
-                'host_memory_free': 10 + multiplier * 10,
-                'host_memory_free-computed': 10 + multiplier * 10,
-                'host_other-config': {},
-                'host_ip_address': '192.168.1.%d' % (100 + multiplier),
-                'host_cpu_info': {},
-                'disk_available': 100 + multiplier * 100,
-                'disk_total': 1000,
-                'disk_used': 0,
-                'host_uuid': 'xxx-%d' % multiplier,
-                'host_name-label': 'xs-%s' % multiplier}
-
-    def setUp(self):
-        super(HostFilterTestCase, self).setUp()
-        self.old_flag = FLAGS.default_host_filter_driver
-        FLAGS.default_host_filter_driver = \
-                            'nova.scheduler.host_filter.AllHostsFilter'
-        self.instance_type = dict(name='tiny',
-                memory_mb=50,
-                vcpus=10,
-                local_gb=500,
-                flavorid=1,
-                swap=500,
-                rxtx_quota=30000,
-                rxtx_cap=200)
-
-        self.zone_manager = FakeZoneManager()
-        states = {}
-        for x in xrange(10):
-            states['host%02d' % (x + 1)] = {'compute': self._host_caps(x)}
-        self.zone_manager.service_states = states
-
-    def tearDown(self):
-        FLAGS.default_host_filter_driver = self.old_flag
-        super(HostFilterTestCase, self).tearDown()
-
-    def test_choose_driver(self):
-        # Test default driver ...
-        driver = host_filter.choose_driver()
-        self.assertEquals(driver._full_name(),
-                        'nova.scheduler.host_filter.AllHostsFilter')
-        # Test valid driver ...
-        driver = host_filter.choose_driver(
-                        'nova.scheduler.host_filter.InstanceTypeFilter')
-        self.assertEquals(driver._full_name(),
-                        'nova.scheduler.host_filter.InstanceTypeFilter')
-        # Test invalid driver ...
-        try:
-            host_filter.choose_driver('does not exist')
-            self.fail("Should not find driver")
-        except exception.SchedulerHostFilterDriverNotFound:
-            pass
-
-    def test_all_host_driver(self):
-        driver = host_filter.AllHostsFilter()
-        cooked = driver.instance_type_to_filter(self.instance_type)
-        hosts = driver.filter_hosts(self.zone_manager, cooked)
-        self.assertEquals(10, len(hosts))
-        for host, capabilities in hosts:
-            self.assertTrue(host.startswith('host'))
-
-    def test_instance_type_driver(self):
-        driver = host_filter.InstanceTypeFilter()
-        # filter all hosts that can support 50 ram and 500 disk
-        name, cooked = driver.instance_type_to_filter(self.instance_type)
-        self.assertEquals('nova.scheduler.host_filter.InstanceTypeFilter',
-                          name)
-        hosts = driver.filter_hosts(self.zone_manager, cooked)
-        self.assertEquals(6, len(hosts))
-        just_hosts = [host for host, caps in hosts]
-        just_hosts.sort()
-        self.assertEquals('host05', just_hosts[0])
-        self.assertEquals('host10', just_hosts[5])
-
-    def test_json_driver(self):
-        driver = host_filter.JsonFilter()
-        # filter all hosts that can support 50 ram and 500 disk
-        name, cooked = driver.instance_type_to_filter(self.instance_type)
-        self.assertEquals('nova.scheduler.host_filter.JsonFilter', name)
-        hosts = driver.filter_hosts(self.zone_manager, cooked)
-        self.assertEquals(6, len(hosts))
-        just_hosts = [host for host, caps in hosts]
-        just_hosts.sort()
-        self.assertEquals('host05', just_hosts[0])
-        self.assertEquals('host10', just_hosts[5])
-
-        # Try some custom queries
-
-        raw = ['or',
-                   ['and',
-                       ['<', '$compute.host_memory_free', 30],
-                       ['<', '$compute.disk_available', 300]
-                   ],
-                   ['and',
-                       ['>', '$compute.host_memory_free', 70],
-                       ['>', '$compute.disk_available', 700]
-                   ]
-              ]
-        cooked = json.dumps(raw)
-        hosts = driver.filter_hosts(self.zone_manager, cooked)
-
-        self.assertEquals(5, len(hosts))
-        just_hosts = [host for host, caps in hosts]
-        just_hosts.sort()
-        for index, host in zip([1, 2, 8, 9, 10], just_hosts):
-            self.assertEquals('host%02d' % index, host)
-
-        raw = ['not',
-                  ['=', '$compute.host_memory_free', 30],
-              ]
-        cooked = json.dumps(raw)
-        hosts = driver.filter_hosts(self.zone_manager, cooked)
-
-        self.assertEquals(9, len(hosts))
-        just_hosts = [host for host, caps in hosts]
-        just_hosts.sort()
-        for index, host in zip([1, 2, 4, 5, 6, 7, 8, 9, 10], just_hosts):
-            self.assertEquals('host%02d' % index, host)
-
-        raw = ['in', '$compute.host_memory_free', 20, 40, 60, 80, 100]
-        cooked = json.dumps(raw)
-        hosts = driver.filter_hosts(self.zone_manager, cooked)
-
-        self.assertEquals(5, len(hosts))
-        just_hosts = [host for host, caps in hosts]
-        just_hosts.sort()
-        for index, host in zip([2, 4, 6, 8, 10], just_hosts):
-            self.assertEquals('host%02d' % index, host)
-
-        # Try some bogus input ...
-        raw = ['unknown command', ]
-        cooked = json.dumps(raw)
-        try:
-            driver.filter_hosts(self.zone_manager, cooked)
-            self.fail("Should give KeyError")
-        except KeyError, e:
-            pass
-
-        self.assertTrue(driver.filter_hosts(self.zone_manager, json.dumps([])))
-        self.assertTrue(driver.filter_hosts(self.zone_manager, json.dumps({})))
-        self.assertTrue(driver.filter_hosts(self.zone_manager, json.dumps(
-                ['not', True, False, True, False]
-            )))
-
-        try:
-            driver.filter_hosts(self.zone_manager, json.dumps(
-                'not', True, False, True, False
-            ))
-            self.fail("Should give KeyError")
-        except KeyError, e:
-            pass
-
-        self.assertFalse(driver.filter_hosts(self.zone_manager, json.dumps(
-                ['=', '$foo', 100]
-            )))
-        self.assertFalse(driver.filter_hosts(self.zone_manager, json.dumps(
-                ['=', '$.....', 100]
-            )))
-        self.assertFalse(driver.filter_hosts(self.zone_manager, json.dumps(
-            ['>', ['and', ['or', ['not', ['<', ['>=', ['<=', ['in', ]]]]]]]]
-        )))
-
-        self.assertFalse(driver.filter_hosts(self.zone_manager, json.dumps(
-                ['=', {}, ['>', '$missing....foo']]
-            )))
diff --git a/nova/tests/test_least_cost_scheduler.py b/nova/tests/test_least_cost_scheduler.py
deleted file mode 100644
index c8ce7892..00000000
--- a/nova/tests/test_least_cost_scheduler.py
+++ /dev/null
@@ -1,181 +0,0 @@
-# Copyright 2011 OpenStack LLC.
-# All Rights Reserved.
-#
-#    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.
-"""
-Tests For Least Cost Scheduler
-"""
-
-from nova import flags
-from nova import test
-from nova.scheduler import least_cost
-
-MB = 1024 * 1024
-FLAGS = flags.FLAGS
-
-
-class FakeHost(object):
-    def __init__(self, host_id, free_ram, io):
-        self.id = host_id
-        self.free_ram = free_ram
-        self.io = io
-
-
-class WeightedSumTestCase(test.TestCase):
-    def test_empty_domain(self):
-        domain = []
-        weighted_fns = []
-        result = least_cost.weighted_sum(domain, weighted_fns)
-        expected = []
-        self.assertEqual(expected, result)
-
-    def test_basic_costing(self):
-        hosts = [
-            FakeHost(1, 512 * MB, 100),
-            FakeHost(2, 256 * MB, 400),
-            FakeHost(3, 512 * MB, 100)
-        ]
-
-        weighted_fns = [
-            (1, lambda h: h.free_ram),  # Fill-first, free_ram is a *cost*
-            (2, lambda h: h.io),  # Avoid high I/O
-        ]
-
-        costs = least_cost.weighted_sum(
-            domain=hosts, weighted_fns=weighted_fns)
-
-        # Each 256 MB unit of free-ram contributes 0.5 points by way of:
-        #   cost = weight * (score/max_score) = 1 * (256/512) = 0.5
-        # Each 100 iops of IO adds 0.5 points by way of:
-        #   cost = 2 * (100/400) = 2 * 0.25 = 0.5
-        expected = [1.5, 2.5, 1.5]
-        self.assertEqual(expected, costs)
-
-
-# TODO(sirp): unify this with test_host_filter tests? possibility of sharing
-# test setup code
-class FakeZoneManager:
-    pass
-
-
-class LeastCostSchedulerTestCase(test.TestCase):
-    def _host_caps(self, multiplier):
-        # Returns host capabilities in the following way:
-        # host1 = memory:free 10 (100max)
-        #         disk:available 100 (1000max)
-        # hostN = memory:free 10 + 10N
-        #         disk:available 100 + 100N
-        # in other words: hostN has more resources than host0
-        # which means ... don't go above 10 hosts.
-        return {'host_name-description': 'XenServer %s' % multiplier,
-                'host_hostname': 'xs-%s' % multiplier,
-                'host_memory_total': 100,
-                'host_memory_overhead': 10,
-                'host_memory_free': 10 + multiplier * 10,
-                'host_memory_free-computed': 10 + multiplier * 10,
-                'host_other-config': {},
-                'host_ip_address': '192.168.1.%d' % (100 + multiplier),
-                'host_cpu_info': {},
-                'disk_available': 100 + multiplier * 100,
-                'disk_total': 1000,
-                'disk_used': 0,
-                'host_uuid': 'xxx-%d' % multiplier,
-                'host_name-label': 'xs-%s' % multiplier}
-
-    def setUp(self):
-        super(LeastCostSchedulerTestCase, self).setUp()
-        #self.old_flag = FLAGS.default_host_filter_driver
-        #FLAGS.default_host_filter_driver = \
-        #                    'nova.scheduler.host_filter.AllHostsFilter'
-        self.instance_type = dict(name='tiny',
-                memory_mb=50,
-                vcpus=10,
-                local_gb=500,
-                flavorid=1,
-                swap=500,
-                rxtx_quota=30000,
-                rxtx_cap=200)
-
-        zone_manager = FakeZoneManager()
-        states = {}
-        for x in xrange(10):
-            states['host%02d' % (x + 1)] = {'compute': self._host_caps(x)}
-        zone_manager.service_states = states
-
-        self.sched = least_cost.LeastCostScheduler()
-        self.sched.zone_manager = zone_manager
-
-    def tearDown(self):
-        #FLAGS.default_host_filter_driver = self.old_flag
-        super(LeastCostSchedulerTestCase, self).tearDown()
-
-    def assertWeights(self, expected, num, request_spec, hosts):
-        weighted = self.sched.weigh_hosts(num, request_spec, hosts)
-        self.assertDictListMatch(weighted, expected, approx_equal=True)
-
-    def test_no_hosts(self):
-        num = 1
-        request_spec = {}
-        hosts = []
-
-        expected = []
-        self.assertWeights(expected, num, request_spec, hosts)
-
-    def test_noop_cost_fn(self):
-        FLAGS.least_cost_scheduler_cost_functions = [
-            'nova.scheduler.least_cost.noop_cost_fn'
-        ]
-        FLAGS.noop_cost_fn_weight = 1
-
-        num = 1
-        request_spec = {}
-        hosts = self.sched.filter_hosts(num, request_spec)
-
-        expected = [dict(weight=1, hostname=hostname)
-                    for hostname, caps in hosts]
-        self.assertWeights(expected, num, request_spec, hosts)
-
-    def test_cost_fn_weights(self):
-        FLAGS.least_cost_scheduler_cost_functions = [
-            'nova.scheduler.least_cost.noop_cost_fn'
-        ]
-        FLAGS.noop_cost_fn_weight = 2
-
-        num = 1
-        request_spec = {}
-        hosts = self.sched.filter_hosts(num, request_spec)
-
-        expected = [dict(weight=2, hostname=hostname)
-                    for hostname, caps in hosts]
-        self.assertWeights(expected, num, request_spec, hosts)
-
-    def test_fill_first_cost_fn(self):
-        FLAGS.least_cost_scheduler_cost_functions = [
-            'nova.scheduler.least_cost.fill_first_cost_fn'
-        ]
-        FLAGS.fill_first_cost_fn_weight = 1
-
-        num = 1
-        request_spec = {}
-        hosts = self.sched.filter_hosts(num, request_spec)
-
-        expected = []
-        for idx, (hostname, caps) in enumerate(hosts):
-            # Costs are normalized so over 10 hosts, each host with increasing
-            # free ram will cost 1/N more. Since the lowest cost host has some
-            # free ram, we add in the 1/N for the base_cost
-            weight = 0.1 + (0.1 * idx)
-            weight_dict = dict(weight=weight, hostname=hostname)
-            expected.append(weight_dict)
-
-        self.assertWeights(expected, num, request_spec, hosts)
diff --git a/nova/tests/test_scheduler.py b/nova/tests/test_scheduler.py
deleted file mode 100644
index 54b3f80f..00000000
--- a/nova/tests/test_scheduler.py
+++ /dev/null
@@ -1,1118 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2010 United States Government as represented by the
-# Administrator of the National Aeronautics and Space Administration.
-# All Rights Reserved.
-#
-#    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.
-"""
-Tests For Scheduler
-"""
-
-import datetime
-import mox
-import novaclient.exceptions
-import stubout
-import webob
-
-from mox import IgnoreArg
-from nova import context
-from nova import db
-from nova import exception
-from nova import flags
-from nova import service
-from nova import test
-from nova import rpc
-from nova import utils
-from nova.auth import manager as auth_manager
-from nova.scheduler import api
-from nova.scheduler import manager
-from nova.scheduler import driver
-from nova.compute import power_state
-from nova.db.sqlalchemy import models
-
-
-FLAGS = flags.FLAGS
-flags.DECLARE('max_cores', 'nova.scheduler.simple')
-flags.DECLARE('stub_network', 'nova.compute.manager')
-flags.DECLARE('instances_path', 'nova.compute.manager')
-
-
-class TestDriver(driver.Scheduler):
-    """Scheduler Driver for Tests"""
-    def schedule(context, topic, *args, **kwargs):
-        return 'fallback_host'
-
-    def schedule_named_method(context, topic, num):
-        return 'named_host'
-
-
-class SchedulerTestCase(test.TestCase):
-    """Test case for scheduler"""
-    def setUp(self):
-        super(SchedulerTestCase, self).setUp()
-        self.flags(scheduler_driver='nova.tests.test_scheduler.TestDriver')
-
-    def _create_compute_service(self):
-        """Create compute-manager(ComputeNode and Service record)."""
-        ctxt = context.get_admin_context()
-        dic = {'host': 'dummy', 'binary': 'nova-compute', 'topic': 'compute',
-               'report_count': 0, 'availability_zone': 'dummyzone'}
-        s_ref = db.service_create(ctxt, dic)
-
-        dic = {'service_id': s_ref['id'],
-               'vcpus': 16, 'memory_mb': 32, 'local_gb': 100,
-               'vcpus_used': 16, 'memory_mb_used': 32, 'local_gb_used': 10,
-               'hypervisor_type': 'qemu', 'hypervisor_version': 12003,
-               'cpu_info': ''}
-        db.compute_node_create(ctxt, dic)
-
-        return db.service_get(ctxt, s_ref['id'])
-
-    def _create_instance(self, **kwargs):
-        """Create a test instance"""
-        ctxt = context.get_admin_context()
-        inst = {}
-        inst['user_id'] = 'admin'
-        inst['project_id'] = kwargs.get('project_id', 'fake')
-        inst['host'] = kwargs.get('host', 'dummy')
-        inst['vcpus'] = kwargs.get('vcpus', 1)
-        inst['memory_mb'] = kwargs.get('memory_mb', 10)
-        inst['local_gb'] = kwargs.get('local_gb', 20)
-        return db.instance_create(ctxt, inst)
-
-    def test_fallback(self):
-        scheduler = manager.SchedulerManager()
-        self.mox.StubOutWithMock(rpc, 'cast', use_mock_anything=True)
-        ctxt = context.get_admin_context()
-        rpc.cast(ctxt,
-                 'topic.fallback_host',
-                 {'method': 'noexist',
-                  'args': {'num': 7}})
-        self.mox.ReplayAll()
-        scheduler.noexist(ctxt, 'topic', num=7)
-
-    def test_named_method(self):
-        scheduler = manager.SchedulerManager()
-        self.mox.StubOutWithMock(rpc, 'cast', use_mock_anything=True)
-        ctxt = context.get_admin_context()
-        rpc.cast(ctxt,
-                 'topic.named_host',
-                 {'method': 'named_method',
-                  'args': {'num': 7}})
-        self.mox.ReplayAll()
-        scheduler.named_method(ctxt, 'topic', num=7)
-
-    def test_show_host_resources_host_not_exit(self):
-        """A host given as an argument does not exists."""
-
-        scheduler = manager.SchedulerManager()
-        dest = 'dummydest'
-        ctxt = context.get_admin_context()
-
-        self.assertRaises(exception.NotFound, scheduler.show_host_resources,
-                          ctxt, dest)
-        #TODO(bcwaldon): reimplement this functionality
-        #c1 = (e.message.find(_("does not exist or is not a "
-        #                       "compute node.")) >= 0)
-
-    def _dic_is_equal(self, dic1, dic2, keys=None):
-        """Compares 2 dictionary contents(Helper method)"""
-        if not keys:
-            keys = ['vcpus', 'memory_mb', 'local_gb',
-                    'vcpus_used', 'memory_mb_used', 'local_gb_used']
-
-        for key in keys:
-            if not (dic1[key] == dic2[key]):
-                return False
-        return True
-
-    def test_show_host_resources_no_project(self):
-        """No instance are running on the given host."""
-
-        scheduler = manager.SchedulerManager()
-        ctxt = context.get_admin_context()
-        s_ref = self._create_compute_service()
-
-        result = scheduler.show_host_resources(ctxt, s_ref['host'])
-
-        # result checking
-        c1 = ('resource' in result and 'usage' in result)
-        compute_node = s_ref['compute_node'][0]
-        c2 = self._dic_is_equal(result['resource'], compute_node)
-        c3 = result['usage'] == {}
-        self.assertTrue(c1 and c2 and c3)
-        db.service_destroy(ctxt, s_ref['id'])
-
-    def test_show_host_resources_works_correctly(self):
-        """Show_host_resources() works correctly as expected."""
-
-        scheduler = manager.SchedulerManager()
-        ctxt = context.get_admin_context()
-        s_ref = self._create_compute_service()
-        i_ref1 = self._create_instance(project_id='p-01', host=s_ref['host'])
-        i_ref2 = self._create_instance(project_id='p-02', vcpus=3,
-                                       host=s_ref['host'])
-
-        result = scheduler.show_host_resources(ctxt, s_ref['host'])
-
-        c1 = ('resource' in result and 'usage' in result)
-        compute_node = s_ref['compute_node'][0]
-        c2 = self._dic_is_equal(result['resource'], compute_node)
-        c3 = result['usage'].keys() == ['p-01', 'p-02']
-        keys = ['vcpus', 'memory_mb', 'local_gb']
-        c4 = self._dic_is_equal(result['usage']['p-01'], i_ref1, keys)
-        c5 = self._dic_is_equal(result['usage']['p-02'], i_ref2, keys)
-        self.assertTrue(c1 and c2 and c3 and c4 and c5)
-
-        db.service_destroy(ctxt, s_ref['id'])
-        db.instance_destroy(ctxt, i_ref1['id'])
-        db.instance_destroy(ctxt, i_ref2['id'])
-
-
-class ZoneSchedulerTestCase(test.TestCase):
-    """Test case for zone scheduler"""
-    def setUp(self):
-        super(ZoneSchedulerTestCase, self).setUp()
-        self.flags(scheduler_driver='nova.scheduler.zone.ZoneScheduler')
-
-    def _create_service_model(self, **kwargs):
-        service = db.sqlalchemy.models.Service()
-        service.host = kwargs['host']
-        service.disabled = False
-        service.deleted = False
-        service.report_count = 0
-        service.binary = 'nova-compute'
-        service.topic = 'compute'
-        service.id = kwargs['id']
-        service.availability_zone = kwargs['zone']
-        service.created_at = datetime.datetime.utcnow()
-        return service
-
-    def test_with_two_zones(self):
-        scheduler = manager.SchedulerManager()
-        ctxt = context.get_admin_context()
-        service_list = [self._create_service_model(id=1,
-                                                   host='host1',
-                                                   zone='zone1'),
-                        self._create_service_model(id=2,
-                                                   host='host2',
-                                                   zone='zone2'),
-                        self._create_service_model(id=3,
-                                                   host='host3',
-                                                   zone='zone2'),
-                        self._create_service_model(id=4,
-                                                   host='host4',
-                                                   zone='zone2'),
-                        self._create_service_model(id=5,
-                                                   host='host5',
-                                                   zone='zone2')]
-        self.mox.StubOutWithMock(db, 'service_get_all_by_topic')
-        arg = IgnoreArg()
-        db.service_get_all_by_topic(arg, arg).AndReturn(service_list)
-        self.mox.StubOutWithMock(rpc, 'cast', use_mock_anything=True)
-        rpc.cast(ctxt,
-                 'compute.host1',
-                 {'method': 'run_instance',
-                  'args': {'instance_id': 'i-ffffffff',
-                           'availability_zone': 'zone1'}})
-        self.mox.ReplayAll()
-        scheduler.run_instance(ctxt,
-                               'compute',
-                               instance_id='i-ffffffff',
-                               availability_zone='zone1')
-
-
-class SimpleDriverTestCase(test.TestCase):
-    """Test case for simple driver"""
-    def setUp(self):
-        super(SimpleDriverTestCase, self).setUp()
-        self.flags(connection_type='fake',
-                   stub_network=True,
-                   max_cores=4,
-                   max_gigabytes=4,
-                   network_manager='nova.network.manager.FlatManager',
-                   volume_driver='nova.volume.driver.FakeISCSIDriver',
-                   scheduler_driver='nova.scheduler.simple.SimpleScheduler')
-        self.scheduler = manager.SchedulerManager()
-        self.manager = auth_manager.AuthManager()
-        self.user = self.manager.create_user('fake', 'fake', 'fake')
-        self.project = self.manager.create_project('fake', 'fake', 'fake')
-        self.context = context.get_admin_context()
-
-    def tearDown(self):
-        self.manager.delete_user(self.user)
-        self.manager.delete_project(self.project)
-        super(SimpleDriverTestCase, self).tearDown()
-
-    def _create_instance(self, **kwargs):
-        """Create a test instance"""
-        inst = {}
-        inst['image_id'] = 1
-        inst['reservation_id'] = 'r-fakeres'
-        inst['user_id'] = self.user.id
-        inst['project_id'] = self.project.id
-        inst['instance_type_id'] = '1'
-        inst['mac_address'] = utils.generate_mac()
-        inst['vcpus'] = kwargs.get('vcpus', 1)
-        inst['ami_launch_index'] = 0
-        inst['availability_zone'] = kwargs.get('availability_zone', None)
-        inst['host'] = kwargs.get('host', 'dummy')
-        inst['memory_mb'] = kwargs.get('memory_mb', 20)
-        inst['local_gb'] = kwargs.get('local_gb', 30)
-        inst['launched_on'] = kwargs.get('launghed_on', 'dummy')
-        inst['state_description'] = kwargs.get('state_description', 'running')
-        inst['state'] = kwargs.get('state', power_state.RUNNING)
-        return db.instance_create(self.context, inst)['id']
-
-    def _create_volume(self):
-        """Create a test volume"""
-        vol = {}
-        vol['size'] = 1
-        vol['availability_zone'] = 'test'
-        return db.volume_create(self.context, vol)['id']
-
-    def _create_compute_service(self, **kwargs):
-        """Create a compute service."""
-
-        dic = {'binary': 'nova-compute', 'topic': 'compute',
-               'report_count': 0, 'availability_zone': 'dummyzone'}
-        dic['host'] = kwargs.get('host', 'dummy')
-        s_ref = db.service_create(self.context, dic)
-        if 'created_at' in kwargs.keys() or 'updated_at' in kwargs.keys():
-            t = datetime.datetime.utcnow() - datetime.timedelta(0)
-            dic['created_at'] = kwargs.get('created_at', t)
-            dic['updated_at'] = kwargs.get('updated_at', t)
-            db.service_update(self.context, s_ref['id'], dic)
-
-        dic = {'service_id': s_ref['id'],
-               'vcpus': 16, 'memory_mb': 32, 'local_gb': 100,
-               'vcpus_used': 16, 'local_gb_used': 10,
-               'hypervisor_type': 'qemu', 'hypervisor_version': 12003,
-               'cpu_info': ''}
-        dic['memory_mb_used'] = kwargs.get('memory_mb_used', 32)
-        dic['hypervisor_type'] = kwargs.get('hypervisor_type', 'qemu')
-        dic['hypervisor_version'] = kwargs.get('hypervisor_version', 12003)
-        db.compute_node_create(self.context, dic)
-        return db.service_get(self.context, s_ref['id'])
-
-    def test_doesnt_report_disabled_hosts_as_up(self):
-        """Ensures driver doesn't find hosts before they are enabled"""
-        # NOTE(vish): constructing service without create method
-        #             because we are going to use it without queue
-        compute1 = service.Service('host1',
-                                   'nova-compute',
-                                   'compute',
-                                   FLAGS.compute_manager)
-        compute1.start()
-        compute2 = service.Service('host2',
-                                   'nova-compute',
-                                   'compute',
-                                   FLAGS.compute_manager)
-        compute2.start()
-        s1 = db.service_get_by_args(self.context, 'host1', 'nova-compute')
-        s2 = db.service_get_by_args(self.context, 'host2', 'nova-compute')
-        db.service_update(self.context, s1['id'], {'disabled': True})
-        db.service_update(self.context, s2['id'], {'disabled': True})
-        hosts = self.scheduler.driver.hosts_up(self.context, 'compute')
-        self.assertEqual(0, len(hosts))
-        compute1.kill()
-        compute2.kill()
-
-    def test_reports_enabled_hosts_as_up(self):
-        """Ensures driver can find the hosts that are up"""
-        # NOTE(vish): constructing service without create method
-        #             because we are going to use it without queue
-        compute1 = service.Service('host1',
-                                   'nova-compute',
-                                   'compute',
-                                   FLAGS.compute_manager)
-        compute1.start()
-        compute2 = service.Service('host2',
-                                   'nova-compute',
-                                   'compute',
-                                   FLAGS.compute_manager)
-        compute2.start()
-        hosts = self.scheduler.driver.hosts_up(self.context, 'compute')
-        self.assertEqual(2, len(hosts))
-        compute1.kill()
-        compute2.kill()
-
-    def test_least_busy_host_gets_instance(self):
-        """Ensures the host with less cores gets the next one"""
-        compute1 = service.Service('host1',
-                                   'nova-compute',
-                                   'compute',
-                                   FLAGS.compute_manager)
-        compute1.start()
-        compute2 = service.Service('host2',
-                                   'nova-compute',
-                                   'compute',
-                                   FLAGS.compute_manager)
-        compute2.start()
-        instance_id1 = self._create_instance()
-        compute1.run_instance(self.context, instance_id1)
-        instance_id2 = self._create_instance()
-        host = self.scheduler.driver.schedule_run_instance(self.context,
-                                                           instance_id2)
-        self.assertEqual(host, 'host2')
-        compute1.terminate_instance(self.context, instance_id1)
-        db.instance_destroy(self.context, instance_id2)
-        compute1.kill()
-        compute2.kill()
-
-    def test_specific_host_gets_instance(self):
-        """Ensures if you set availability_zone it launches on that zone"""
-        compute1 = service.Service('host1',
-                                   'nova-compute',
-                                   'compute',
-                                   FLAGS.compute_manager)
-        compute1.start()
-        compute2 = service.Service('host2',
-                                   'nova-compute',
-                                   'compute',
-                                   FLAGS.compute_manager)
-        compute2.start()
-        instance_id1 = self._create_instance()
-        compute1.run_instance(self.context, instance_id1)
-        instance_id2 = self._create_instance(availability_zone='nova:host1')
-        host = self.scheduler.driver.schedule_run_instance(self.context,
-                                                           instance_id2)
-        self.assertEqual('host1', host)
-        compute1.terminate_instance(self.context, instance_id1)
-        db.instance_destroy(self.context, instance_id2)
-        compute1.kill()
-        compute2.kill()
-
-    def test_wont_sechedule_if_specified_host_is_down(self):
-        compute1 = service.Service('host1',
-                                   'nova-compute',
-                                   'compute',
-                                   FLAGS.compute_manager)
-        compute1.start()
-        s1 = db.service_get_by_args(self.context, 'host1', 'nova-compute')
-        now = datetime.datetime.utcnow()
-        delta = datetime.timedelta(seconds=FLAGS.service_down_time * 2)
-        past = now - delta
-        db.service_update(self.context, s1['id'], {'updated_at': past})
-        instance_id2 = self._create_instance(availability_zone='nova:host1')
-        self.assertRaises(driver.WillNotSchedule,
-                          self.scheduler.driver.schedule_run_instance,
-                          self.context,
-                          instance_id2)
-        db.instance_destroy(self.context, instance_id2)
-        compute1.kill()
-
-    def test_will_schedule_on_disabled_host_if_specified(self):
-        compute1 = service.Service('host1',
-                                   'nova-compute',
-                                   'compute',
-                                   FLAGS.compute_manager)
-        compute1.start()
-        s1 = db.service_get_by_args(self.context, 'host1', 'nova-compute')
-        db.service_update(self.context, s1['id'], {'disabled': True})
-        instance_id2 = self._create_instance(availability_zone='nova:host1')
-        host = self.scheduler.driver.schedule_run_instance(self.context,
-                                                           instance_id2)
-        self.assertEqual('host1', host)
-        db.instance_destroy(self.context, instance_id2)
-        compute1.kill()
-
-    def test_too_many_cores(self):
-        """Ensures we don't go over max cores"""
-        compute1 = service.Service('host1',
-                                   'nova-compute',
-                                   'compute',
-                                   FLAGS.compute_manager)
-        compute1.start()
-        compute2 = service.Service('host2',
-                                   'nova-compute',
-                                   'compute',
-                                   FLAGS.compute_manager)
-        compute2.start()
-        instance_ids1 = []
-        instance_ids2 = []
-        for index in xrange(FLAGS.max_cores):
-            instance_id = self._create_instance()
-            compute1.run_instance(self.context, instance_id)
-            instance_ids1.append(instance_id)
-            instance_id = self._create_instance()
-            compute2.run_instance(self.context, instance_id)
-            instance_ids2.append(instance_id)
-        instance_id = self._create_instance()
-        self.assertRaises(driver.NoValidHost,
-                          self.scheduler.driver.schedule_run_instance,
-                          self.context,
-                          instance_id)
-        for instance_id in instance_ids1:
-            compute1.terminate_instance(self.context, instance_id)
-        for instance_id in instance_ids2:
-            compute2.terminate_instance(self.context, instance_id)
-        compute1.kill()
-        compute2.kill()
-
-    def test_least_busy_host_gets_volume(self):
-        """Ensures the host with less gigabytes gets the next one"""
-        volume1 = service.Service('host1',
-                                   'nova-volume',
-                                   'volume',
-                                   FLAGS.volume_manager)
-        volume1.start()
-        volume2 = service.Service('host2',
-                                   'nova-volume',
-                                   'volume',
-                                   FLAGS.volume_manager)
-        volume2.start()
-        volume_id1 = self._create_volume()
-        volume1.create_volume(self.context, volume_id1)
-        volume_id2 = self._create_volume()
-        host = self.scheduler.driver.schedule_create_volume(self.context,
-                                                            volume_id2)
-        self.assertEqual(host, 'host2')
-        volume1.delete_volume(self.context, volume_id1)
-        db.volume_destroy(self.context, volume_id2)
-        dic = {'service_id': s_ref['id'],
-               'vcpus': 16, 'memory_mb': 32, 'local_gb': 100,
-               'vcpus_used': 16, 'memory_mb_used': 12, 'local_gb_used': 10,
-               'hypervisor_type': 'qemu', 'hypervisor_version': 12003,
-               'cpu_info': ''}
-
-    def test_doesnt_report_disabled_hosts_as_up(self):
-        """Ensures driver doesn't find hosts before they are enabled"""
-        compute1 = self.start_service('compute', host='host1')
-        compute2 = self.start_service('compute', host='host2')
-        s1 = db.service_get_by_args(self.context, 'host1', 'nova-compute')
-        s2 = db.service_get_by_args(self.context, 'host2', 'nova-compute')
-        db.service_update(self.context, s1['id'], {'disabled': True})
-        db.service_update(self.context, s2['id'], {'disabled': True})
-        hosts = self.scheduler.driver.hosts_up(self.context, 'compute')
-        self.assertEqual(0, len(hosts))
-        compute1.kill()
-        compute2.kill()
-
-    def test_reports_enabled_hosts_as_up(self):
-        """Ensures driver can find the hosts that are up"""
-        compute1 = self.start_service('compute', host='host1')
-        compute2 = self.start_service('compute', host='host2')
-        hosts = self.scheduler.driver.hosts_up(self.context, 'compute')
-        self.assertEqual(2, len(hosts))
-        compute1.kill()
-        compute2.kill()
-
-    def test_least_busy_host_gets_instance(self):
-        """Ensures the host with less cores gets the next one"""
-        compute1 = self.start_service('compute', host='host1')
-        compute2 = self.start_service('compute', host='host2')
-        instance_id1 = self._create_instance()
-        compute1.run_instance(self.context, instance_id1)
-        instance_id2 = self._create_instance()
-        host = self.scheduler.driver.schedule_run_instance(self.context,
-                                                           instance_id2)
-        self.assertEqual(host, 'host2')
-        compute1.terminate_instance(self.context, instance_id1)
-        db.instance_destroy(self.context, instance_id2)
-        compute1.kill()
-        compute2.kill()
-
-    def test_specific_host_gets_instance(self):
-        """Ensures if you set availability_zone it launches on that zone"""
-        compute1 = self.start_service('compute', host='host1')
-        compute2 = self.start_service('compute', host='host2')
-        instance_id1 = self._create_instance()
-        compute1.run_instance(self.context, instance_id1)
-        instance_id2 = self._create_instance(availability_zone='nova:host1')
-        host = self.scheduler.driver.schedule_run_instance(self.context,
-                                                           instance_id2)
-        self.assertEqual('host1', host)
-        compute1.terminate_instance(self.context, instance_id1)
-        db.instance_destroy(self.context, instance_id2)
-        compute1.kill()
-        compute2.kill()
-
-    def test_wont_sechedule_if_specified_host_is_down(self):
-        compute1 = self.start_service('compute', host='host1')
-        s1 = db.service_get_by_args(self.context, 'host1', 'nova-compute')
-        now = datetime.datetime.utcnow()
-        delta = datetime.timedelta(seconds=FLAGS.service_down_time * 2)
-        past = now - delta
-        db.service_update(self.context, s1['id'], {'updated_at': past})
-        instance_id2 = self._create_instance(availability_zone='nova:host1')
-        self.assertRaises(driver.WillNotSchedule,
-                          self.scheduler.driver.schedule_run_instance,
-                          self.context,
-                          instance_id2)
-        db.instance_destroy(self.context, instance_id2)
-        compute1.kill()
-
-    def test_will_schedule_on_disabled_host_if_specified(self):
-        compute1 = self.start_service('compute', host='host1')
-        s1 = db.service_get_by_args(self.context, 'host1', 'nova-compute')
-        db.service_update(self.context, s1['id'], {'disabled': True})
-        instance_id2 = self._create_instance(availability_zone='nova:host1')
-        host = self.scheduler.driver.schedule_run_instance(self.context,
-                                                           instance_id2)
-        self.assertEqual('host1', host)
-        db.instance_destroy(self.context, instance_id2)
-        compute1.kill()
-
-    def test_too_many_cores(self):
-        """Ensures we don't go over max cores"""
-        compute1 = self.start_service('compute', host='host1')
-        compute2 = self.start_service('compute', host='host2')
-        instance_ids1 = []
-        instance_ids2 = []
-        for index in xrange(FLAGS.max_cores):
-            instance_id = self._create_instance()
-            compute1.run_instance(self.context, instance_id)
-            instance_ids1.append(instance_id)
-            instance_id = self._create_instance()
-            compute2.run_instance(self.context, instance_id)
-            instance_ids2.append(instance_id)
-        instance_id = self._create_instance()
-        self.assertRaises(driver.NoValidHost,
-                          self.scheduler.driver.schedule_run_instance,
-                          self.context,
-                          instance_id)
-        db.instance_destroy(self.context, instance_id)
-        for instance_id in instance_ids1:
-            compute1.terminate_instance(self.context, instance_id)
-        for instance_id in instance_ids2:
-            compute2.terminate_instance(self.context, instance_id)
-        compute1.kill()
-        compute2.kill()
-
-    def test_least_busy_host_gets_volume(self):
-        """Ensures the host with less gigabytes gets the next one"""
-        volume1 = self.start_service('volume', host='host1')
-        volume2 = self.start_service('volume', host='host2')
-        volume_id1 = self._create_volume()
-        volume1.create_volume(self.context, volume_id1)
-        volume_id2 = self._create_volume()
-        host = self.scheduler.driver.schedule_create_volume(self.context,
-                                                            volume_id2)
-        self.assertEqual(host, 'host2')
-        volume1.delete_volume(self.context, volume_id1)
-        db.volume_destroy(self.context, volume_id2)
-        volume1.kill()
-        volume2.kill()
-
-    def test_too_many_gigabytes(self):
-        """Ensures we don't go over max gigabytes"""
-        volume1 = self.start_service('volume', host='host1')
-        volume2 = self.start_service('volume', host='host2')
-        volume_ids1 = []
-        volume_ids2 = []
-        for index in xrange(FLAGS.max_gigabytes):
-            volume_id = self._create_volume()
-            volume1.create_volume(self.context, volume_id)
-            volume_ids1.append(volume_id)
-            volume_id = self._create_volume()
-            volume2.create_volume(self.context, volume_id)
-            volume_ids2.append(volume_id)
-        volume_id = self._create_volume()
-        self.assertRaises(driver.NoValidHost,
-                          self.scheduler.driver.schedule_create_volume,
-                          self.context,
-                          volume_id)
-        for volume_id in volume_ids1:
-            volume1.delete_volume(self.context, volume_id)
-        for volume_id in volume_ids2:
-            volume2.delete_volume(self.context, volume_id)
-        volume1.kill()
-        volume2.kill()
-
-    def test_scheduler_live_migration_with_volume(self):
-        """scheduler_live_migration() works correctly as expected.
-
-        Also, checks instance state is changed from 'running' -> 'migrating'.
-
-        """
-
-        instance_id = self._create_instance()
-        i_ref = db.instance_get(self.context, instance_id)
-        dic = {'instance_id': instance_id, 'size': 1}
-        v_ref = db.volume_create(self.context, dic)
-
-        # cannot check 2nd argument b/c the addresses of instance object
-        # is different.
-        driver_i = self.scheduler.driver
-        nocare = mox.IgnoreArg()
-        self.mox.StubOutWithMock(driver_i, '_live_migration_src_check')
-        self.mox.StubOutWithMock(driver_i, '_live_migration_dest_check')
-        self.mox.StubOutWithMock(driver_i, '_live_migration_common_check')
-        driver_i._live_migration_src_check(nocare, nocare)
-        driver_i._live_migration_dest_check(nocare, nocare, i_ref['host'])
-        driver_i._live_migration_common_check(nocare, nocare, i_ref['host'])
-        self.mox.StubOutWithMock(rpc, 'cast', use_mock_anything=True)
-        kwargs = {'instance_id': instance_id, 'dest': i_ref['host']}
-        rpc.cast(self.context,
-                 db.queue_get_for(nocare, FLAGS.compute_topic, i_ref['host']),
-                 {"method": 'live_migration', "args": kwargs})
-
-        self.mox.ReplayAll()
-        self.scheduler.live_migration(self.context, FLAGS.compute_topic,
-                                      instance_id=instance_id,
-                                      dest=i_ref['host'])
-
-        i_ref = db.instance_get(self.context, instance_id)
-        self.assertTrue(i_ref['state_description'] == 'migrating')
-        db.instance_destroy(self.context, instance_id)
-        db.volume_destroy(self.context, v_ref['id'])
-
-    def test_live_migration_src_check_instance_not_running(self):
-        """The instance given by instance_id is not running."""
-
-        instance_id = self._create_instance(state_description='migrating')
-        i_ref = db.instance_get(self.context, instance_id)
-
-        try:
-            self.scheduler.driver._live_migration_src_check(self.context,
-                                                            i_ref)
-        except exception.Invalid, e:
-            c = (e.message.find('is not running') > 0)
-
-        self.assertTrue(c)
-        db.instance_destroy(self.context, instance_id)
-
-    def test_live_migration_src_check_volume_node_not_alive(self):
-        """Raise exception when volume node is not alive."""
-
-        instance_id = self._create_instance()
-        i_ref = db.instance_get(self.context, instance_id)
-        dic = {'instance_id': instance_id, 'size': 1}
-        v_ref = db.volume_create(self.context, {'instance_id': instance_id,
-                                                'size': 1})
-        t1 = datetime.datetime.utcnow() - datetime.timedelta(1)
-        dic = {'created_at': t1, 'updated_at': t1, 'binary': 'nova-volume',
-               'topic': 'volume', 'report_count': 0}
-        s_ref = db.service_create(self.context, dic)
-
-        self.assertRaises(exception.VolumeServiceUnavailable,
-                          self.scheduler.driver.schedule_live_migration,
-                          self.context, instance_id, i_ref['host'])
-
-        db.instance_destroy(self.context, instance_id)
-        db.service_destroy(self.context, s_ref['id'])
-        db.volume_destroy(self.context, v_ref['id'])
-
-    def test_live_migration_src_check_compute_node_not_alive(self):
-        """Confirms src-compute node is alive."""
-        instance_id = self._create_instance()
-        i_ref = db.instance_get(self.context, instance_id)
-        t = datetime.datetime.utcnow() - datetime.timedelta(10)
-        s_ref = self._create_compute_service(created_at=t, updated_at=t,
-                                             host=i_ref['host'])
-
-        self.assertRaises(exception.ComputeServiceUnavailable,
-                          self.scheduler.driver._live_migration_src_check,
-                          self.context, i_ref)
-
-        db.instance_destroy(self.context, instance_id)
-        db.service_destroy(self.context, s_ref['id'])
-
-    def test_live_migration_src_check_works_correctly(self):
-        """Confirms this method finishes with no error."""
-        instance_id = self._create_instance()
-        i_ref = db.instance_get(self.context, instance_id)
-        s_ref = self._create_compute_service(host=i_ref['host'])
-
-        ret = self.scheduler.driver._live_migration_src_check(self.context,
-                                                              i_ref)
-
-        self.assertTrue(ret is None)
-        db.instance_destroy(self.context, instance_id)
-        db.service_destroy(self.context, s_ref['id'])
-
-    def test_live_migration_dest_check_not_alive(self):
-        """Confirms exception raises in case dest host does not exist."""
-        instance_id = self._create_instance()
-        i_ref = db.instance_get(self.context, instance_id)
-        t = datetime.datetime.utcnow() - datetime.timedelta(10)
-        s_ref = self._create_compute_service(created_at=t, updated_at=t,
-                                             host=i_ref['host'])
-
-        self.assertRaises(exception.ComputeServiceUnavailable,
-                          self.scheduler.driver._live_migration_dest_check,
-                          self.context, i_ref, i_ref['host'])
-
-        db.instance_destroy(self.context, instance_id)
-        db.service_destroy(self.context, s_ref['id'])
-
-    def test_live_migration_dest_check_service_same_host(self):
-        """Confirms exceptioin raises in case dest and src is same host."""
-        instance_id = self._create_instance()
-        i_ref = db.instance_get(self.context, instance_id)
-        s_ref = self._create_compute_service(host=i_ref['host'])
-
-        self.assertRaises(exception.UnableToMigrateToSelf,
-                          self.scheduler.driver._live_migration_dest_check,
-                          self.context, i_ref, i_ref['host'])
-
-        db.instance_destroy(self.context, instance_id)
-        db.service_destroy(self.context, s_ref['id'])
-
-    def test_live_migration_dest_check_service_lack_memory(self):
-        """Confirms exception raises when dest doesn't have enough memory."""
-        instance_id = self._create_instance()
-        i_ref = db.instance_get(self.context, instance_id)
-        s_ref = self._create_compute_service(host='somewhere',
-                                             memory_mb_used=12)
-
-        self.assertRaises(exception.MigrationError,
-                          self.scheduler.driver._live_migration_dest_check,
-                          self.context, i_ref, 'somewhere')
-
-        db.instance_destroy(self.context, instance_id)
-        db.service_destroy(self.context, s_ref['id'])
-
-    def test_live_migration_dest_check_service_works_correctly(self):
-        """Confirms method finishes with no error."""
-        instance_id = self._create_instance()
-        i_ref = db.instance_get(self.context, instance_id)
-        s_ref = self._create_compute_service(host='somewhere',
-                                             memory_mb_used=5)
-
-        ret = self.scheduler.driver._live_migration_dest_check(self.context,
-                                                             i_ref,
-                                                             'somewhere')
-        self.assertTrue(ret is None)
-        db.instance_destroy(self.context, instance_id)
-        db.service_destroy(self.context, s_ref['id'])
-
-    def test_live_migration_common_check_service_orig_not_exists(self):
-        """Destination host does not exist."""
-
-        dest = 'dummydest'
-        # mocks for live_migration_common_check()
-        instance_id = self._create_instance()
-        i_ref = db.instance_get(self.context, instance_id)
-        t1 = datetime.datetime.utcnow() - datetime.timedelta(10)
-        s_ref = self._create_compute_service(created_at=t1, updated_at=t1,
-                                             host=dest)
-
-        # mocks for mounted_on_same_shared_storage()
-        fpath = '/test/20110127120000'
-        self.mox.StubOutWithMock(driver, 'rpc', use_mock_anything=True)
-        topic = FLAGS.compute_topic
-        driver.rpc.call(mox.IgnoreArg(),
-            db.queue_get_for(self.context, topic, dest),
-            {"method": 'create_shared_storage_test_file'}).AndReturn(fpath)
-        driver.rpc.call(mox.IgnoreArg(),
-            db.queue_get_for(mox.IgnoreArg(), topic, i_ref['host']),
-            {"method": 'check_shared_storage_test_file',
-             "args": {'filename': fpath}})
-        driver.rpc.call(mox.IgnoreArg(),
-            db.queue_get_for(mox.IgnoreArg(), topic, dest),
-            {"method": 'cleanup_shared_storage_test_file',
-             "args": {'filename': fpath}})
-
-        self.mox.ReplayAll()
-        self.assertRaises(exception.SourceHostUnavailable,
-                          self.scheduler.driver._live_migration_common_check,
-                          self.context, i_ref, dest)
-
-        db.instance_destroy(self.context, instance_id)
-        db.service_destroy(self.context, s_ref['id'])
-
-    def test_live_migration_common_check_service_different_hypervisor(self):
-        """Original host and dest host has different hypervisor type."""
-        dest = 'dummydest'
-        instance_id = self._create_instance()
-        i_ref = db.instance_get(self.context, instance_id)
-
-        # compute service for destination
-        s_ref = self._create_compute_service(host=i_ref['host'])
-        # compute service for original host
-        s_ref2 = self._create_compute_service(host=dest, hypervisor_type='xen')
-
-        # mocks
-        driver = self.scheduler.driver
-        self.mox.StubOutWithMock(driver, 'mounted_on_same_shared_storage')
-        driver.mounted_on_same_shared_storage(mox.IgnoreArg(), i_ref, dest)
-
-        self.mox.ReplayAll()
-        self.assertRaises(exception.InvalidHypervisorType,
-                          self.scheduler.driver._live_migration_common_check,
-                          self.context, i_ref, dest)
-
-        db.instance_destroy(self.context, instance_id)
-        db.service_destroy(self.context, s_ref['id'])
-        db.service_destroy(self.context, s_ref2['id'])
-
-    def test_live_migration_common_check_service_different_version(self):
-        """Original host and dest host has different hypervisor version."""
-        dest = 'dummydest'
-        instance_id = self._create_instance()
-        i_ref = db.instance_get(self.context, instance_id)
-
-        # compute service for destination
-        s_ref = self._create_compute_service(host=i_ref['host'])
-        # compute service for original host
-        s_ref2 = self._create_compute_service(host=dest,
-                                              hypervisor_version=12002)
-
-        # mocks
-        driver = self.scheduler.driver
-        self.mox.StubOutWithMock(driver, 'mounted_on_same_shared_storage')
-        driver.mounted_on_same_shared_storage(mox.IgnoreArg(), i_ref, dest)
-
-        self.mox.ReplayAll()
-        self.assertRaises(exception.DestinationHypervisorTooOld,
-                          self.scheduler.driver._live_migration_common_check,
-                          self.context, i_ref, dest)
-
-        db.instance_destroy(self.context, instance_id)
-        db.service_destroy(self.context, s_ref['id'])
-        db.service_destroy(self.context, s_ref2['id'])
-
-    def test_live_migration_common_check_checking_cpuinfo_fail(self):
-        """Raise excetion when original host doen't have compatible cpu."""
-
-        dest = 'dummydest'
-        instance_id = self._create_instance()
-        i_ref = db.instance_get(self.context, instance_id)
-
-        # compute service for destination
-        s_ref = self._create_compute_service(host=i_ref['host'])
-        # compute service for original host
-        s_ref2 = self._create_compute_service(host=dest)
-
-        # mocks
-        driver = self.scheduler.driver
-        self.mox.StubOutWithMock(driver, 'mounted_on_same_shared_storage')
-        driver.mounted_on_same_shared_storage(mox.IgnoreArg(), i_ref, dest)
-        self.mox.StubOutWithMock(rpc, 'call', use_mock_anything=True)
-        rpc.call(mox.IgnoreArg(), mox.IgnoreArg(),
-            {"method": 'compare_cpu',
-            "args": {'cpu_info': s_ref2['compute_node'][0]['cpu_info']}}).\
-             AndRaise(rpc.RemoteError("doesn't have compatibility to", "", ""))
-
-        self.mox.ReplayAll()
-        try:
-            self.scheduler.driver._live_migration_common_check(self.context,
-                                                               i_ref,
-                                                               dest)
-        except rpc.RemoteError, e:
-            c = (e.message.find(_("doesn't have compatibility to")) >= 0)
-
-        self.assertTrue(c)
-        db.instance_destroy(self.context, instance_id)
-        db.service_destroy(self.context, s_ref['id'])
-        db.service_destroy(self.context, s_ref2['id'])
-
-
-class FakeZone(object):
-    def __init__(self, id, api_url, username, password):
-        self.id = id
-        self.api_url = api_url
-        self.username = username
-        self.password = password
-
-
-def zone_get_all(context):
-    return [
-                FakeZone(1, 'http://example.com', 'bob', 'xxx'),
-           ]
-
-
-class FakeRerouteCompute(api.reroute_compute):
-    def _call_child_zones(self, zones, function):
-        return []
-
-    def get_collection_context_and_id(self, args, kwargs):
-        return ("servers", None, 1)
-
-    def unmarshall_result(self, zone_responses):
-        return dict(magic="found me")
-
-
-def go_boom(self, context, instance):
-    raise exception.InstanceNotFound(instance_id=instance)
-
-
-def found_instance(self, context, instance):
-    return dict(name='myserver')
-
-
-class FakeResource(object):
-    def __init__(self, attribute_dict):
-        for k, v in attribute_dict.iteritems():
-            setattr(self, k, v)
-
-    def pause(self):
-        pass
-
-
-class ZoneRedirectTest(test.TestCase):
-    def setUp(self):
-        super(ZoneRedirectTest, self).setUp()
-        self.stubs = stubout.StubOutForTesting()
-
-        self.stubs.Set(db, 'zone_get_all', zone_get_all)
-
-        self.enable_zone_routing = FLAGS.enable_zone_routing
-        FLAGS.enable_zone_routing = True
-
-    def tearDown(self):
-        self.stubs.UnsetAll()
-        FLAGS.enable_zone_routing = self.enable_zone_routing
-        super(ZoneRedirectTest, self).tearDown()
-
-    def test_trap_found_locally(self):
-        decorator = FakeRerouteCompute("foo")
-        try:
-            result = decorator(found_instance)(None, None, 1)
-        except api.RedirectResult, e:
-            self.fail(_("Successful database hit should succeed"))
-
-    def test_trap_not_found_locally(self):
-        decorator = FakeRerouteCompute("foo")
-        try:
-            result = decorator(go_boom)(None, None, 1)
-            self.assertFail(_("Should have rerouted."))
-        except api.RedirectResult, e:
-            self.assertEquals(e.results['magic'], 'found me')
-
-    def test_routing_flags(self):
-        FLAGS.enable_zone_routing = False
-        decorator = FakeRerouteCompute("foo")
-        self.assertRaises(exception.InstanceNotFound, decorator(go_boom),
-                          None, None, 1)
-
-    def test_get_collection_context_and_id(self):
-        decorator = api.reroute_compute("foo")
-        self.assertEquals(decorator.get_collection_context_and_id(
-            (None, 10, 20), {}), ("servers", 10, 20))
-        self.assertEquals(decorator.get_collection_context_and_id(
-            (None, 11,),  dict(instance_id=21)), ("servers", 11, 21))
-        self.assertEquals(decorator.get_collection_context_and_id(
-            (None,), dict(context=12, instance_id=22)), ("servers", 12, 22))
-
-    def test_unmarshal_single_server(self):
-        decorator = api.reroute_compute("foo")
-        self.assertEquals(decorator.unmarshall_result([]), {})
-        self.assertEquals(decorator.unmarshall_result(
-                [FakeResource(dict(a=1, b=2)), ]),
-                dict(server=dict(a=1, b=2)))
-        self.assertEquals(decorator.unmarshall_result(
-                [FakeResource(dict(a=1, _b=2)), ]),
-                dict(server=dict(a=1,)))
-        self.assertEquals(decorator.unmarshall_result(
-                [FakeResource(dict(a=1, manager=2)), ]),
-                dict(server=dict(a=1,)))
-        self.assertEquals(decorator.unmarshall_result(
-                [FakeResource(dict(_a=1, manager=2)), ]),
-                dict(server={}))
-
-
-class FakeServerCollection(object):
-    def get(self, instance_id):
-        return FakeResource(dict(a=10, b=20))
-
-    def find(self, name):
-        return FakeResource(dict(a=11, b=22))
-
-
-class FakeEmptyServerCollection(object):
-    def get(self, f):
-        raise novaclient.NotFound(1)
-
-    def find(self, name):
-        raise novaclient.NotFound(2)
-
-
-class FakeNovaClient(object):
-    def __init__(self, collection):
-        self.servers = collection
-
-
-class DynamicNovaClientTest(test.TestCase):
-    def test_issue_novaclient_command_found(self):
-        zone = FakeZone(1, 'http://example.com', 'bob', 'xxx')
-        self.assertEquals(api._issue_novaclient_command(
-                    FakeNovaClient(FakeServerCollection()),
-                    zone, "servers", "get", 100).a, 10)
-
-        self.assertEquals(api._issue_novaclient_command(
-                    FakeNovaClient(FakeServerCollection()),
-                    zone, "servers", "find", "name").b, 22)
-
-        self.assertEquals(api._issue_novaclient_command(
-                    FakeNovaClient(FakeServerCollection()),
-                    zone, "servers", "pause", 100), None)
-
-    def test_issue_novaclient_command_not_found(self):
-        zone = FakeZone(1, 'http://example.com', 'bob', 'xxx')
-        self.assertEquals(api._issue_novaclient_command(
-                    FakeNovaClient(FakeEmptyServerCollection()),
-                    zone, "servers", "get", 100), None)
-
-        self.assertEquals(api._issue_novaclient_command(
-                    FakeNovaClient(FakeEmptyServerCollection()),
-                    zone, "servers", "find", "name"), None)
-
-        self.assertEquals(api._issue_novaclient_command(
-                    FakeNovaClient(FakeEmptyServerCollection()),
-                    zone, "servers", "any", "name"), None)
-
-
-class FakeZonesProxy(object):
-    def do_something(*args, **kwargs):
-        return 42
-
-    def raises_exception(*args, **kwargs):
-        raise Exception('testing')
-
-
-class FakeNovaClientOpenStack(object):
-    def __init__(self, *args, **kwargs):
-        self.zones = FakeZonesProxy()
-
-    def authenticate(self):
-        pass
-
-
-class CallZoneMethodTest(test.TestCase):
-    def setUp(self):
-        super(CallZoneMethodTest, self).setUp()
-        self.stubs = stubout.StubOutForTesting()
-        self.stubs.Set(db, 'zone_get_all', zone_get_all)
-        self.stubs.Set(novaclient, 'OpenStack', FakeNovaClientOpenStack)
-
-    def tearDown(self):
-        self.stubs.UnsetAll()
-        super(CallZoneMethodTest, self).tearDown()
-
-    def test_call_zone_method(self):
-        context = {}
-        method = 'do_something'
-        results = api.call_zone_method(context, method)
-        expected = [(1, 42)]
-        self.assertEqual(expected, results)
-
-    def test_call_zone_method_not_present(self):
-        context = {}
-        method = 'not_present'
-        self.assertRaises(AttributeError, api.call_zone_method,
-                          context, method)
-
-    def test_call_zone_method_generates_exception(self):
-        context = {}
-        method = 'raises_exception'
-        results = api.call_zone_method(context, method)
-
-        # FIXME(sirp): for now the _error_trap code is catching errors and
-        # converting them to a ("ERROR", "string") tuples. The code (and this
-        # test) should eventually handle real exceptions.
-        expected = [(1, ('ERROR', 'testing'))]
-        self.assertEqual(expected, results)