Merge lp:~rohitk/nova/libvirt_unittests into lp:~hudson-openstack/nova/trunk

[Rohit Karajgi]

I have added the following test methods for LibvirtConnTestCase class in tests/test_libvirt.py to cover and test code in connection.py. These are pure unit-test cases, and not integration unit-test cases. Most of the tests use mocks, stubs and fakes to eliminate dependencies on third party modules, db, file system and network.
This also fixes bugs in the test_spawn_with_network_info module.
Code coverage for libvirt/connection.py has increased to about 96% post this change.
Some tests (#72,73) have been skipped due to Bug:807764.
This effort is towards the Diablo-testing blueprint (https://blueprints.launchpad.net/nova/+spec/diablo-testing).

1 test_live_migration_readonly_connection
2 test_live_migration_authorized_connection
3 test_spawn_with_network_info
4 test_spawn_with_network_info_instance_not_found_error
5 test_destroy
6 test_destroy_raises_loopingcall_done
7 test_destroy_no_domain_exception
8 test_destroy_undefine_raises_libvirt_error_already_shutoff
9 test_destroy_raises_libvirt_error_running_state
10 test_reboot
11 test_reboot_fails_instance_not_found
12 test_list_instances_blank_list
13 test_list_instances_detail
14 test_pause
15 test_unpause
16 test_suspend
17 test_resume
18 test_rescue
19 test_rescue_instance_not_found_error
20 test_unrescue
21 test_attach_volume
22 test_attach_volume_raises_invalid_device_path_exception
23 test_detach_volume
24 test_detach_volume_raises_disk_not_found_exception
25 test_get_disks
26 test_get_disks_libxml_exception_returns_blank_list
27 test_get_interfaces
28 test_get_interfaces_libxml_exception
29 test_get_info
30 test_get_cpu_info
31 test_get_cpu_info_nocpus
32 test_get_cpu_info_nokeys
33 test_compare_cpu
34 test_compare_cpu_invalid_exception
35 test_compare_cpu_libvirt_error
36 test_init_host_running
37 test_init_host_not_running
38 test_init_host_instance_not_found
39 test_get_console_output
40 test_get_console_output_for_xen
41 test_get_console_output_for_lxc
42 test_get_ajax_console
43 test_get_ajax_console_raises_exception
44 test_get_vnc_console
45 test_get_diagnostics_not_supported
46 test_get_vcpu_total_not_implemented_exception
47 test_block_stats
48 test_interface_stats
49 test_get_console_pool_info
50 test_refresh_security_group_rules
51 test_refresh_security_group_members
52 test_refresh_provider_fw_rules
53 test_unfilter_instance
54 test_get_vcpu_used
55 test_cache_image_with_cow
56 test_cache_image_no_cow
57 test_fetch_image_with_size
58 test_fetch_image_no_size
59 test_create_local
60 test_lookup_by_name
61 test_lookup_by_name_raises_instance_not_found_exception
62 test_lookup_by_name_raises_lookuo_error
63 test_get_disk_xml
64 test_get_disk_xml_returns_none
65 test_flush_xen_console
66 test_flush_xen_console_no_device
67 test_append_to_file
68 test_dump_file
69 test_volume_in_mapping_returns_true
70 test_volume_in_mapping_returns_false
71 test_create_image_lxc_no_network_info_no_v6
72 test_create_image_lxc_tiny_instance_has_kernel_ramdisk
73 test_create_image_lxc_unknown_disk_image_ipv6
74 test_get_connection
75 test_test_connection
76 test_test_connection_broken
77 test_test_connection_raises_exception_for_unknown_error
78 test_connect_read_only
79 test_connect_with_auth
80 test_map_to_instance_info
81 test_cleanup

[Mandell (mdegerne)]

Only two minor pep8 violations (lines 309, and 2915 - adding a comma will make them go away). Also, a nit about the whitespace in the XML (lines 321 to 332). Other than that, it looks good.

[Rohit Karajgi (rohitk)]

Fixed, however, please use latest pep8 (0.6.1). The code was validated for pep8 0.6.1. Thanks!

[Brian Lamar (blamar)]

22 +from StringIO import StringIO

Although other imports in the file don't follow this, we should only be importing modules, not classes. So technically this should be just "import StringIO"

44 + 'injected': 1}

Minor nitpick, this indent should be consistent with the others.

116 + except_msg = "Test failed with an unknown exception"

This is an interesting strategy, but I would suggest when something happens and you don't know what went wrong to just do a self.fail(error_message), where 'error_message' is the exception contents. Just saying "unknown exception" isn't very helpful when trying to debug, but the failure message will help out greatly.

For example:

524 + try:
525 + conn.spawn(instance, network_info)
526 + except Exception, e:
527 + fail = 1
528 + time.sleep(1)
529 +
530 + self.assertFalse(fail, msg=self.except_msg)

Would give me a generic failure message, but:

524 + try:
525 + conn.spawn(instance, network_info)
526 + except Exception as err:
527 + self.fail(err)

Would give the reason, while still making sure the test failed.

Lines 300 - 307, you shouldn't need those backslashes and if you could, where applicable, line up parameters under the space after the method's opening "(" like this:

300 + conn.firewall_driver.setattr('setup_basic_filtering',
301 + self.fake_none)

In all of the tests, FLAGS are auto-magically reset, so feel free to just edit them directly:

348 + fake_flag = 'VIR_MIGRATE_UNDEFINE_SOURCE,VIR_MIGRATE_PEER2PEER'
349 + self.mox.StubOutWithMock(connection.FLAGS, 'live_migration_flag')
350 + connection.FLAGS.live_migration_flag = fake_flag

Could safely become:

348 + migration_flag = 'VIR_MIGRATE_UNDEFINE_SOURCE,VIR_MIGRATE_PEER2PEER'
349 + FLAGS.live_migration_flag = migration_flag

There are existing structures for Mocks and Stubs, so this:

451 + self.mox.StubOutWithMock(connection.LibvirtConnection, 'get_info')
452 + connection.LibvirtConnection.get_info = fake_get_info

could just be:

451 + self.stubs.Set(connection.LibvirtConnection, 'get_info', fake_get_info)

if you wanted to do it in a single line.

As a general comment, if you find yourself repeating test "setup", such as creating a connection and setting some test parameters, you might consider breaking similar tests into their own TestCase classes and putting the common code in setUp().

I'm going to keep looking at this, as it's a good number of tests...but hopefully this will kick off some discussion.

Thanks for the tests!

review: Needs Fixing

[Brian Lamar (blamar)]

test_get_cpu_info
test_get_cpu_info_nocpus
test_get_cpu_info_nokeys
test_get_disks
test_get_interfaces
test_get_interfaces_libxml_exception

These tests are failing when libvirt isn't installed on the testing machine. Can you skip these tests if libvirt isn't installed?

[Rohit Karajgi (rohitk)]

Thanks Brian for the comments till now. I'll make those fixes wherever applicable.

[Rohit Karajgi (rohitk)]

Brian, request you to please review the branch for merging. I have implemented all the review comments by you. Thanks.

[Jay Pipes (jaypipes)]

Hi Rohit!

Awesome work on these tests :)

One little nit from me...

 import shutil
 import sys
+import time
 import tempfile

+import StringIO
 from xml.etree.ElementTree import fromstring as xml_to_tree

That actually needs to be in alphabetical order, and StringIO is a standard lib module and so should be above tempfile import..., so like this:

import shutil
import StringIO
import sys
import tempfile
import time

from xml.etree.ElementTree import fromstring as xml_to_tree

Cheers!
jay

review: Needs Fixing

[Rohit Karajgi (rohitk)]

Thanks Jay. Fixed the import sequence and other regressions cropped due to trunk changes. All tests have passed at my end.

[Jay Pipes (jaypipes)]

Looks great!

review: Approve

[Brian Lamar (blamar)]

Getting 3 test errors: http://paste.openstack.org/show/2381/

review: Needs Fixing

[Rohit Karajgi (rohitk)]

The first two errors are fixed. I am not able to reproduce the third error, from test_virt_drivers.py, and this file(or it's dependencies) was not modified by this branch. Also noticed large test failures in current trunk due to which full cobertura report is not being generated.
Please review branch for modified files. Thanks!

[William Wolf (throughnothing)]

I'm getting the third error with your most recent changes as well from a fresh, unmodified checkout. Not sure why you're not getting it.

[William Wolf (throughnothing)]

One thought, make sure you run the entire test suite, not just that one file or class of tests....it may be conflicting with something run in other tests...which would be bad.

[Rohit Karajgi (rohitk)]

Hi William,

The issue was with the method test_map_to_instance_info that directly set the driver.InstanceInfo object to invalid test values and failed to unset during teardown. I have removed that code and modified the test to use only FakeVirtDomain object, and now the tests are passing without affecting test_virt_drivers tests. Thank you for pointing it out.

I have run the full suite and tests have passed. Please review.

[Rohit Karajgi (rohitk)]

Run tests output at http://paste.openstack.org/show/2474/

[William Wolf (throughnothing)]

Everything passes for me now Rohit. Thanks, looks good.

review: Approve

[Matt Dietz (cerberus)]

Awesome to see a new collection of unit tests in the project! Everything passes for me.

review: Approve

[Brian Lamar (blamar)]

Hey, I gave some bad advice earlier, which is 100% my fault. Unfortunately I was wrong when I said that you should set flags like "FLAGS.live_migration_flag = migration_flag". In tests flags seem to be reset only when you set them like this:

self.flags(live_migration_flag=migration_flag)

So just to be safe I think that these tests should follow that principle. Have you spoken with Soren? He also has a major branch for libvirt tests (lp:~soren/nova/virt-test-improvements), although I don't know how much they will conflict.

Sorry for taking so long to get back to you on this branch!

review: Needs Fixing

[Rohit Karajgi (rohitk)]

> self.flags(live_migration_flag=migration_flag)
>
> So just to be safe I think that these tests should follow that principle.
>
Changed wherever applicable.

> Have you spoken with Soren? He also has a major branch for libvirt tests
> (lp:~soren/nova/virt-test-improvements), although I don't know how much they
> will conflict.

I just checked Soren's branch. Although there isn't any conflicting code or tests, I think the fake images library he has added will help me with not having to create the fakes in test_libvirt. I am putting the branch push on hold till I sync with Soren.

Thanks for checking my branch.

Unmerged revisions

1258. By Rohit Karajgi on 2011-09-19

Removed failing skipped tests till Bugs 853602 and 854009 are fixed

1257. By Rohit Karajgi on 2011-09-19

Merge Trunk

1256. By Rohit Karajgi on 2011-09-07

post merge

1255. By Rohit Karajgi on 2011-09-07

added fake gateway_v6

1254. By Rohit Karajgi on 2011-09-05

Fixed import sequence and some regressions

1253. By Rohit Karajgi on 2011-09-05

Merge trunk

1252. By Rohit Karajgi on 2011-09-05

Resolved conflicts on merge

1251. By Rohit Karajgi on 2011-08-09

Merge Trunk

1250. By Rohit Karajgi on 2011-08-02

Modified affected tests after changes to virt.connection due to Midokura's network refactoring branch

1249. By Rohit Karajgi on 2011-08-01

Merge trunk

=== modified file 'Authors'
--- Authors	2011-09-08 18:47:56 +0000
+++ Authors	2011-09-19 17:37:28 +0000
@@ -94,6 +94,7 @@
 Rick Clark <[e-mail]>
 Rick Harris <[e-mail]>
 Rob Kost <[e-mail]>
+Rohit Karajgi <[e-mail]>
 Ryan Lane <[e-mail]>
 Ryan Lucio <[e-mail]>
 Ryu Ishimoto <[e-mail]>

=== modified file 'nova/tests/fake_network.py'
--- nova/tests/fake_network.py	2011-09-13 19:48:10 +0000
+++ nova/tests/fake_network.py	2011-09-19 17:37:28 +0000
@@ -54,6 +54,9 @@
             'extra_params': 'fake',
         }
 
+    def unplug(self, *args):
+        return True
+
 
 class FakeModel(dict):
     """Represent a model from the db"""

=== modified file 'nova/tests/test_libvirt.py'
--- nova/tests/test_libvirt.py	2011-09-19 14:22:34 +0000
+++ nova/tests/test_libvirt.py	2011-09-19 17:37:28 +0000
@@ -20,8 +20,10 @@
 import os
 import re
 import shutil
+import StringIO
 import sys
 import tempfile
+import time
 
 from xml.etree.ElementTree import fromstring as xml_to_tree
 from xml.dom.minidom import parseString as xml_to_dom
@@ -39,6 +41,8 @@
 from nova.virt.libvirt import connection
 from nova.virt.libvirt import firewall
 from nova.tests import fake_network
+from nova.tests import fake_utils
+
 
 libvirt = None
 FLAGS = flags.FLAGS
@@ -68,14 +72,25 @@
             self._fake_dom_xml = fake_xml
         else:
             self._fake_dom_xml = """
-                <domain type='kvm'>
-                    <devices>
-                        <disk type='file'>
-                            <source file='filename'/>
-                        </disk>
-                    </devices>
-                </domain>
-            """
+                    <domain type='kvm'>
+                        <devices>
+                            <disk type='file'>
+                                <source file='filename'/>
+                                <target dev='vdb' bus='ide'/>
+                            </disk>
+                            <interface type='bridge'>
+                                <source bridge='br0'/>
+                                <target dev='vnet'/>
+                                <mac address="00:11:22:33:44:55"/>
+                            </interface>
+                            <serial type='pty'>
+                                <source path='/dev/pts/3'/>
+                                <target port='0'/>
+                            </serial>
+                            <graphics type='vnc' port='5904'/>
+                        </devices>
+                    </domain>
+                    """
 
     def snapshotCreateXML(self, *args):
         return FakeVirDomainSnapshot(self)
@@ -86,6 +101,64 @@
     def XMLDesc(self, *args):
         return self._fake_dom_xml
 
+    def create(self):
+        pass
+
+    def managedSave(self, *args):
+        pass
+
+    def destroy(self, *args):
+        pass
+
+    def undefine(self, *args):
+        pass
+
+    def reboot(self, *args):
+        pass
+
+    def pause(self, *args):
+        pass
+
+    def unpause(self, *args):
+        pass
+
+    def suspend(self, *args):
+        pass
+
+    def resume(self, *args):
+        pass
+
+    def info(self, *args):
+        return {'state': 1,
+                'max_mem': 10,
+                'mem': 10,
+                'num_cpu': 1,
+                'cpu_time': 1}
+
+    def setAutostart(self, *args):
+        pass
+
+    def attachDevice(self, *args):
+        pass
+
+    def detachDevice(self, *args):
+        pass
+
+    def compareCPU(self, *args):
+        return 1
+
+    def blockStats(self, *args):
+        pass
+
+    def interfaceStats(self, *args):
+        pass
+
+    def migrateToURI(self, *args):
+        pass
+
+    def name(self, *args):
+        return 'fake'
+
 
 class CacheConcurrencyTestCase(test.TestCase):
     def setUp(self):
@@ -98,11 +171,8 @@
                 return True
             return False
 
-        def fake_execute(*args, **kwargs):
-            pass
-
         self.stubs.Set(os.path, 'exists', fake_exists)
-        self.stubs.Set(utils, 'execute', fake_execute)
+        fake_utils.stub_out_utils_execute(self.stubs)
 
     def test_same_fname_concurrency(self):
         """Ensures that the same fname cache runs at a sequentially"""
@@ -146,7 +216,6 @@
 
 
 class LibvirtConnTestCase(test.TestCase):
-
     def setUp(self):
         super(LibvirtConnTestCase, self).setUp()
         connection._late_load_cheetah()
@@ -159,6 +228,7 @@
         self.flags(instances_path='')
         self.call_libvirt_dependant_setup = False
 
+    test_ip = '10.11.12.13'
     test_instance = {'memory_kb':     '1024000',
                      'basepath':      '/some/path',
                      'bridge_name':   'br100',
@@ -186,12 +256,13 @@
     def create_fake_libvirt_mock(self, **kwargs):
         """Defining mocks for LibvirtConnection(libvirt is not used)."""
 
-        # A fake libvirt.virConnect
         class FakeLibvirtConnection(object):
+            def createXML(self, *args):
+                pass
+
             def defineXML(self, xml):
                 return FakeVirtDomain()
 
-        # Creating mocks
         fake = FakeLibvirtConnection()
         # Customizing above fake if necessary
         for key, val in kwargs.items():
@@ -201,11 +272,13 @@
         fw_driver = "nova.tests.fake_network.FakeIptablesFirewallDriver"
         self.flags(firewall_driver=fw_driver)
         self.flags(libvirt_vif_driver="nova.tests.fake_network.FakeVIFDriver")
-
         self.mox.StubOutWithMock(connection.LibvirtConnection, '_conn')
         connection.LibvirtConnection._conn = fake
 
-    def fake_lookup(self, instance_name):
+    def fake_none(self, *args, **kwargs):
+        return
+
+    def fake_lookup(self, *args):
         return FakeVirtDomain()
 
     def fake_execute(self, *args):
@@ -490,6 +563,7 @@
             (lambda t: _ipv4_like(t.find(parameter).get('value'), '192.168'),
              True),
             (lambda t: t.findall(parameter)[1].get('name'), 'DHCPSERVER'),
+            (lambda t: t.findall(parameter)[1].get('value'), '192.168.0.1'),
             (lambda t: _ipv4_like(t.findall(parameter)[1].get('value'),
                                   '192.168.*.1'), True),
             (lambda t: t.find('./devices/serial/source').get(
@@ -609,17 +683,12 @@
 
     def test_ensure_filtering_rules_for_instance_timeout(self):
         """ensure_filtering_fules_for_instance() finishes with timeout."""
-        # Skip if non-libvirt environment
         if not self.lazy_load_library_exists():
             return
 
-        # Preparing mocks
         def fake_none(self, *args):
             return
 
-        def fake_raise(self):
-            raise libvirt.libvirtError('ERR')
-
         class FakeTime(object):
             def __init__(self):
                 self.counter = 0
@@ -633,13 +702,15 @@
         instance_ref = db.instance_create(self.context, self.test_instance)
         network_info = _fake_network_info(self.stubs, 1)
 
-        # Start test
         self.mox.ReplayAll()
         try:
             conn = connection.LibvirtConnection(False)
-            conn.firewall_driver.setattr('setup_basic_filtering', fake_none)
-            conn.firewall_driver.setattr('prepare_instance_filter', fake_none)
-            conn.firewall_driver.setattr('instance_filter_exists', fake_none)
+            conn.firewall_driver.setattr('setup_basic_filtering',
+                                        self.fake_none)
+            conn.firewall_driver.setattr('prepare_instance_filter',
+                                        self.fake_none)
+            conn.firewall_driver.setattr('instance_filter_exists',
+                                        self.fake_none)
             conn.ensure_filtering_rules_for_instance(instance_ref,
                                                      network_info,
                                                      time=fake_timer)
@@ -652,13 +723,57 @@
 
         db.instance_destroy(self.context, instance_ref['id'])
 
+    def test_live_migration_readonly_connection(self):
+        if not self.lazy_load_library_exists():
+            return
+
+        self.compute = utils.import_object(FLAGS.compute_manager)
+        instance_dict = {'host': 'fake', 'state': power_state.RUNNING,
+                        'state_description': 'running'}
+        instance_ref = db.instance_create(self.context, self.test_instance)
+        instance_ref = db.instance_update(self.context, instance_ref['id'],
+                                            instance_dict)
+
+        migration_flag = 'VIR_MIGRATE_UNDEFINE_SOURCE,VIR_MIGRATE_PEER2PEER'
+        FLAGS.live_migration_flag = migration_flag
+        self.mox.StubOutWithMock(connection.LibvirtConnection, '_conn')
+        connection.LibvirtConnection._conn.lookupByName = self.fake_lookup
+        self.mox.ReplayAll()
+        conn = connection.LibvirtConnection(True)
+        try:
+            conn._live_migration(self.context, instance_ref, 'dest',
+                        self.fake_none, self.compute.rollback_live_migration)
+        except Exception, err:
+            self.fail(err)
+
+    def test_live_migration_authorized_connection(self):
+        if not self.lazy_load_library_exists():
+            return
+
+        self.compute = utils.import_object(FLAGS.compute_manager)
+        instance_dict = {'host': 'fake', 'state': power_state.RUNNING,
+                         'state_description': 'running'}
+        instance_ref = db.instance_create(self.context, self.test_instance)
+        instance_ref = db.instance_update(self.context, instance_ref['id'],
+                                          instance_dict)
+
+        migration_flag = 'VIR_MIGRATE_UNDEFINE_SOURCE,VIR_MIGRATE_PEER2PEER'
+        FLAGS.live_migration_flag = migration_flag
+        self.mox.StubOutWithMock(connection.LibvirtConnection, '_conn')
+        connection.LibvirtConnection._conn.lookupByName = self.fake_lookup
+        self.mox.ReplayAll()
+        conn = connection.LibvirtConnection(False)
+        try:
+            conn._live_migration(self.context, instance_ref, 'dest',
+                        self.fake_none, self.compute.rollback_live_migration)
+        except Exception, err:
+            self.fail(err)
+
     def test_live_migration_raises_exception(self):
         """Confirms recover method is called when exceptions are raised."""
-        # Skip if non-libvirt environment
         if not self.lazy_load_library_exists():
             return
 
-        # Preparing data
         self.compute = utils.import_object(FLAGS.compute_manager)
         instance_dict = {'host': 'fake',
                          'power_state': power_state.RUNNING,
@@ -671,13 +786,12 @@
         db.volume_attached(self.context, volume_ref['id'], instance_ref['id'],
                            '/dev/fake')
 
-        # Preparing mocks
         vdmock = self.mox.CreateMock(libvirt.virDomain)
         self.mox.StubOutWithMock(vdmock, "migrateToURI")
         vdmock.migrateToURI(FLAGS.live_migration_uri % 'dest',
                             mox.IgnoreArg(),
-                            None, FLAGS.live_migration_bandwidth).\
-                            AndRaise(libvirt.libvirtError('ERR'))
+                            None, FLAGS.live_migration_bandwidth).AndRaise(
+                                                libvirt.libvirtError('ERR'))
 
         def fake_lookup(instance_name):
             if instance_name == instance_ref.name:
@@ -691,7 +805,6 @@
         self.compute.rollback_live_migration(self.context, instance_ref,
                                             'dest', False)
 
-        #start test
         self.mox.ReplayAll()
         conn = connection.LibvirtConnection(False)
         self.assertRaises(libvirt.libvirtError,
@@ -798,39 +911,1633 @@
         db.instance_destroy(self.context, instance_ref['id'])
 
     def test_spawn_with_network_info(self):
-        # Skip if non-libvirt environment
-        if not self.lazy_load_library_exists():
-            return
-
-        # Preparing mocks
-        def fake_none(self, instance):
-            return
-
-        self.create_fake_libvirt_mock()
-        instance = db.instance_create(self.context, self.test_instance)
-
-        # Start test
-        self.mox.ReplayAll()
-        conn = connection.LibvirtConnection(False)
-        conn.firewall_driver.setattr('setup_basic_filtering', fake_none)
-        conn.firewall_driver.setattr('prepare_instance_filter', fake_none)
-
-        network_info = _fake_network_info(self.stubs, 1)
-
-        try:
-            conn.spawn(self.context, instance, network_info)
-        except Exception, e:
-            count = (0 <= str(e.message).find('Unexpected method call'))
-
-        shutil.rmtree(os.path.join(FLAGS.instances_path, instance.name))
-        shutil.rmtree(os.path.join(FLAGS.instances_path, '_base'))
+        '''Test spawn method with network info passed'''
+        if not self.lazy_load_library_exists():
+            return
+
+        instance = db.instance_create(self.context, self.test_instance)
+
+        def fake_get_info(*args):
+            return {'state': 1}
+
+        def fake_method(*args, **kwargs):
+            return
+
+        self.create_fake_libvirt_mock()
+        self.stubs.Set(connection.LibvirtConnection, 'get_info', fake_get_info)
+        self.stubs.Set(connection.LibvirtConnection, 'to_xml', fake_method)
+        network_info = _fake_network_info(self.stubs, 1)
+        self.mox.ReplayAll()
+
+        conn = connection.LibvirtConnection(False)
+        conn._create_image = self.fake_none
+        conn._create_new_domain = self.fake_lookup
+        conn.firewall_driver.setattr('setup_basic_filtering', self.fake_none)
+        conn.firewall_driver.setattr('prepare_instance_filter', self.fake_none)
+        conn.firewall_driver.setattr('apply_instance_filter', self.fake_none)
+        FLAGS.start_guests_on_host_boot = 1
+
+        try:
+            conn.spawn(self.context, instance, network_info)
+        except Exception, err:
+            self.fail(err)
+        time.sleep(1)
+
+    def test_spawn_with_network_info_instance_not_found_error(self):
+        '''Test spawn method when no instance state info is returned'''
+        if not self.lazy_load_library_exists():
+            return
+
+        instance = db.instance_create(self.context, self.test_instance)
+
+        def fake_get_info(*args):
+            raise exception.NotFound
+
+        def fake_method(*args, **kwargs):
+            return
+
+        self.create_fake_libvirt_mock()
+        self.stubs.Set(connection.LibvirtConnection, 'get_info', fake_get_info)
+        self.stubs.Set(connection.LibvirtConnection, 'to_xml', fake_method)
+        network_info = _fake_network_info(self.stubs, 1)
+        self.mox.ReplayAll()
+
+        conn = connection.LibvirtConnection(False)
+        conn._create_image = self.fake_none
+        conn._create_new_domain = self.fake_lookup
+        conn.firewall_driver.setattr('setup_basic_filtering', self.fake_none)
+        conn.firewall_driver.setattr('prepare_instance_filter', self.fake_none)
+        conn.firewall_driver.setattr('apply_instance_filter', self.fake_none)
+
+        FLAGS.start_guests_on_host_boot = 1
+        try:
+            conn.spawn(self.context, instance, network_info)
+        except Exception, err:
+            self.fail(err)
+        time.sleep(1)
 
     def test_get_host_ip_addr(self):
+        '''Test correct ip is returned'''
         conn = connection.LibvirtConnection(False)
         ip = conn.get_host_ip_addr()
         self.assertEquals(ip, FLAGS.my_ip)
 
+    def test_destroy(self):
+        '''Test destroy method for a valid instance'''
+        if not self.lazy_load_library_exists():
+            return
+        instance_ref = db.instance_create(self.context, self.test_instance)
+        network_info = _fake_network_info(self.stubs, 1)
+
+        def fake_get_info(*args):
+            return {'state': '5'}
+
+        self.create_fake_libvirt_mock(lookupByName=self.fake_lookup)
+        self.stubs.Set(connection.LibvirtConnection, 'get_info', fake_get_info)
+        self.mox.ReplayAll()
+        conn = connection.LibvirtConnection(False)
+        conn.firewall_driver.setattr('unfilter_instance', self.fake_none)
+        try:
+            result = conn.destroy(instance_ref, network_info)
+        except Exception, err:
+            self.fail(err)
+
+        time.sleep(1)
+        self.assertTrue(result)
+
+    def test_destroy_raises_loopingcall_done(self):
+        '''Test destroy method when instance is destroyed properly'''
+        if not self.lazy_load_library_exists():
+            return
+        instance_ref = db.instance_create(self.context, self.test_instance)
+        network_info = _fake_network_info(self.stubs, 1)
+
+        def fake_get_info(*args):
+            raise exception.NotFound
+
+        self.create_fake_libvirt_mock(lookupByName=self.fake_lookup)
+        self.stubs.Set(connection.LibvirtConnection, 'get_info', fake_get_info)
+        self.mox.ReplayAll()
+        conn = connection.LibvirtConnection(False)
+        conn.firewall_driver.setattr('unfilter_instance', self.fake_none)
+        try:
+            result = conn.destroy(instance_ref, network_info)
+        except Exception, err:
+            self.fail(err)
+
+        time.sleep(1)
+        self.assertTrue(result)
+
+    def test_destroy_no_domain_exception(self):
+        '''Negative test to check exception if invalid instance is passed'''
+        if not self.lazy_load_library_exists():
+            return
+
+        instance_ref = {'name': 'Invalid'}
+        network_info = _fake_network_info(self.stubs, 1)
+
+        self.create_fake_libvirt_mock()
+        self.mox.StubOutWithMock(connection.LibvirtConnection,
+                                '_lookup_by_name')
+        connection.LibvirtConnection._lookup_by_name(mox.IgnoreArg()
+                                        ).AndRaise(exception.NotFound)
+        self.mox.ReplayAll()
+        conn = connection.LibvirtConnection(False)
+        conn.firewall_driver.setattr('unfilter_instance', self.fake_none)
+        try:
+            result = conn.destroy(instance_ref, network_info)
+        except Exception, err:
+            self.fail(err)
+
+        self.assertTrue(result)
+
+    def test_destroy_undefine_raises_libvirt_error_already_shutoff(self):
+        '''Test destroy raises libvirt error during undefine'''
+        if not self.lazy_load_library_exists():
+                return
+        instance_ref = db.instance_create(self.context, self.test_instance)
+        network_info = _fake_network_info(self.stubs, 1)
+
+        def fake_get_last_error():
+            return [55, 0, 'fake message']
+
+        def fake_lookup(self, *args):
+
+            class FakeVirtDomain:
+                def __init__(self):
+                    pass
+
+                def destroy(self):
+                    raise libvirt.libvirtError('virDomainDestroy() failed',
+                                                conn=self)
+
+                def info(self):
+                    return (5, 10, 10, 1, 1)
+
+                def undefine(self):
+                    raise libvirt.libvirtError('virDomainDestroy() failed',
+                                                conn=self)
+
+            return FakeVirtDomain()
+
+        self.stubs.Set(connection.LibvirtConnection, '_lookup_by_name',
+                        fake_lookup)
+        self.stubs.Set(connection.libvirt, 'virGetLastError',
+                        fake_get_last_error)
+        self.mox.ReplayAll()
+        conn = connection.LibvirtConnection(False)
+        self.assertRaises(libvirt.libvirtError, conn.destroy, instance_ref,
+                        network_info)
+
+    def test_destroy_raises_libvirt_error_running_state(self):
+        '''Test destroy raises libvirt error, instance is still running'''
+        if not self.lazy_load_library_exists():
+            return
+        instance_ref = db.instance_create(self.context, self.test_instance)
+        network_info = _fake_network_info(self.stubs, 1)
+
+        def fake_get_last_error():
+            return [55, 0, 'fake message']
+
+        def fake_lookup(self, *args):
+
+            class FakeVirtDomain:
+                def __init__(self):
+                    pass
+
+                def destroy(self):
+                    raise libvirt.libvirtError('virDomainDestroy() failed,',
+                                                conn=self)
+
+                def info(self):
+                    return (1, 10, 10, 1, 1)
+
+            return FakeVirtDomain()
+
+        self.stubs.Set(connection.LibvirtConnection, '_lookup_by_name',
+                        fake_lookup)
+        self.stubs.Set(connection.libvirt, 'virGetLastError',
+                        fake_get_last_error)
+        self.mox.ReplayAll()
+        conn = connection.LibvirtConnection(False)
+        self.assertRaises(libvirt.libvirtError, conn.destroy, instance_ref,
+                        network_info)
+
+    def test_reboot(self):
+        '''Test reboot method insrance rebooted successfully'''
+        if not self.lazy_load_library_exists():
+            return
+        instance_ref = db.instance_create(self.context, self.test_instance)
+        network_info = _fake_network_info(self.stubs, 1)
+
+        def fake_get_info(*args):
+            return {'state': 1}
+
+        self.create_fake_libvirt_mock(lookupByName=self.fake_lookup)
+        self.stubs.Set(connection.LibvirtConnection, 'get_info', fake_get_info)
+        self.mox.ReplayAll()
+
+        conn = connection.LibvirtConnection(False)
+        conn.firewall_driver.setattr('setup_basic_filtering', self.fake_none)
+        conn.firewall_driver.setattr('prepare_instance_filter', self.fake_none)
+        conn.firewall_driver.setattr('apply_instance_filter', self.fake_none)
+        conn.firewall_driver.setattr('unfilter_instance', self.fake_none)
+        try:
+            conn.reboot(instance_ref, network_info, 'fake')
+        except Exception, err:
+            self.fail(err)
+        time.sleep(1)
+
+    def test_reboot_fails_instance_not_found(self):
+        '''Test reboot method instance disappears'''
+        if not self.lazy_load_library_exists():
+            return
+        instance_ref = db.instance_create(self.context, self.test_instance)
+        network_info = _fake_network_info(self.stubs, 1)
+
+        def fake_get_info(*args):
+            raise exception.NotFound
+
+        self.create_fake_libvirt_mock(lookupByName=self.fake_lookup)
+        self.stubs.Set(connection.LibvirtConnection, 'get_info', fake_get_info)
+        self.mox.ReplayAll()
+
+        conn = connection.LibvirtConnection(False)
+        conn.firewall_driver.setattr('setup_basic_filtering', self.fake_none)
+        conn.firewall_driver.setattr('prepare_instance_filter', self.fake_none)
+        conn.firewall_driver.setattr('apply_instance_filter', self.fake_none)
+        conn.firewall_driver.setattr('unfilter_instance', self.fake_none)
+        try:
+            conn.reboot(instance_ref, network_info, 'fake')
+        except Exception, err:
+            self.fail(err)
+        time.sleep(1)
+
+    def test_list_instances_blank_list(self):
+        '''Test returns blank list if no domains are available '''
+
+        def listDomainsID():
+            return []
+
+        self.create_fake_libvirt_mock(listDomainsID=listDomainsID,
+                                        lookupByID=self.fake_lookup)
+
+        self.mox.ReplayAll()
+        conn = connection.LibvirtConnection(False)
+        try:
+            inst = conn.list_instances()
+        except Exception, err:
+            self.fail(err)
+
+        self.assertEquals(len(inst), 0)
+
+    def test_list_instances_detail(self):
+        '''Test list instances detail returns correct list'''
+
+        def listDomainsID():
+            return [1, 2, 3, 4]
+
+        def lookupByID(*args):
+            return 'test'
+
+        def map_instance_info(*args):
+            return 'test_info'
+
+        class FakeLibvirtConnection(object):
+            pass
+
+        self.mox.StubOutWithMock(connection.LibvirtConnection, '_conn')
+        connection.LibvirtConnection._conn = FakeLibvirtConnection()
+        connection.LibvirtConnection._conn.listDomainsID = listDomainsID
+        connection.LibvirtConnection._conn.lookupByID = lookupByID
+        self.stubs.Set(connection.LibvirtConnection, '_map_to_instance_info',
+                        map_instance_info)
+
+        self.create_fake_libvirt_mock(listDomainsID=listDomainsID,
+                                        lookupByID=self.fake_lookup)
+
+        self.mox.ReplayAll()
+        conn = connection.LibvirtConnection(False)
+        try:
+            inst = conn.list_instances_detail()
+        except Exception, err:
+            self.fail(err)
+
+        self.assertEquals(len(inst), 4)
+
+    def test_pause(self):
+        '''Test pause method suspends an instance'''
+        if not self.lazy_load_library_exists():
+            return
+        instance_ref = db.instance_create(self.context, self.test_instance)
+
+        self.mox.StubOutWithMock(connection.LibvirtConnection, '_conn')
+        connection.LibvirtConnection._conn.lookupByName = self.fake_lookup
+        self.mox.ReplayAll()
+
+        conn = connection.LibvirtConnection(False)
+        callback = self.fake_none()
+        try:
+            conn.pause(instance_ref, callback)
+        except Exception, err:
+            self.fail(err)
+
+    def test_unpause(self):
+        '''Test unpause resumes an instance'''
+        if not self.lazy_load_library_exists():
+            return
+        instance_ref = db.instance_create(self.context, self.test_instance)
+
+        self.mox.StubOutWithMock(connection.LibvirtConnection, '_conn')
+        connection.LibvirtConnection._conn.lookupByName = self.fake_lookup
+        self.mox.ReplayAll()
+
+        conn = connection.LibvirtConnection(False)
+        callback = self.fake_none()
+        try:
+            conn.unpause(instance_ref, callback)
+        except Exception, err:
+            self.fail(err)
+
+    def test_suspend(self):
+        '''Test suspend suspends an instance'''
+        if not self.lazy_load_library_exists():
+            return
+        instance_ref = db.instance_create(self.context, self.test_instance)
+
+        self.mox.StubOutWithMock(connection.LibvirtConnection, '_conn')
+        connection.LibvirtConnection._conn.lookupByName = self.fake_lookup
+        self.mox.ReplayAll()
+        conn = connection.LibvirtConnection(False)
+        callback = self.fake_none()
+        try:
+                conn.suspend(instance_ref, callback)
+        except Exception, err:
+            self.fail(err)
+
+    def test_resume(self):
+        '''Test resume resumes an instance'''
+        if not self.lazy_load_library_exists():
+            return
+        instance_ref = db.instance_create(self.context, self.test_instance)
+
+        self.mox.StubOutWithMock(connection.LibvirtConnection, '_conn')
+        connection.LibvirtConnection._conn.lookupByName = self.fake_lookup
+        self.mox.ReplayAll()
+        conn = connection.LibvirtConnection(False)
+        callback = self.fake_none()
+        try:
+            conn.resume(instance_ref, callback)
+        except Exception, err:
+            self.fail(err)
+
+    def test_rescue(self):
+        '''Test rescue brings the instance state back to running'''
+        if not self.lazy_load_library_exists():
+            return
+
+        def fake_to_xml(*args, **kwargs):
+            pass
+
+        def fake_get_info(*args):
+            return {'state': 1}
+
+        def fake_open(*args):
+            return StringIO.StringIO("one,two,three\n1,2,3")
+
+        import __builtin__
+        self.stubs.Set(__builtin__, 'open', fake_open)
+        network_info = _fake_network_info(self.stubs, 1)
+        self.create_fake_libvirt_mock()
+        instance = db.instance_create(self.context, self.test_instance)
+        self.mox.StubOutWithMock(connection.LibvirtConnection, '_conn')
+        connection.LibvirtConnection._conn.lookupByName = self.fake_lookup
+        self.stubs.Set(connection.LibvirtConnection, 'get_info', fake_get_info)
+        self.stubs.Set(connection.LibvirtConnection, 'to_xml', fake_to_xml)
+        self.mox.ReplayAll()
+        conn = connection.LibvirtConnection(False)
+        conn.firewall_driver.setattr('unfilter_instance', self.fake_none)
+        conn.firewall_driver.setattr('setup_basic_filtering', self.fake_none)
+        conn.firewall_driver.setattr('prepare_instance_filter', self.fake_none)
+        conn._create_image = self.fake_none
+        conn._create_new_domain = self.fake_lookup
+        try:
+            conn.rescue(self.context, instance, 'fake_callback', network_info)
+        except Exception, err:
+            self.fail(err)
+        time.sleep(1)
+
+    def test_unrescue(self):
+        '''Test reboot by unrescue method'''
+        if not self.lazy_load_library_exists():
+            return
+        instance_ref = db.instance_create(self.context, self.test_instance)
+        network_info = _fake_network_info(self.stubs, 1)
+
+        def fake_reboot(*args, **kwargs):
+            pass
+
+        def fake_open(*args):
+            return StringIO.StringIO("one,two,three\n1,2,3")
+
+        def fake_remove(*args):
+            pass
+
+        import __builtin__
+        self.stubs.Set(__builtin__, 'open', fake_open)
+        self.stubs.Set(os, 'remove', fake_remove)
+        self.stubs.Set(connection.LibvirtConnection, 'reboot', fake_reboot)
+        callback = self.fake_none
+        self.mox.ReplayAll()
+
+        conn = connection.LibvirtConnection(False)
+        try:
+            conn.unrescue(instance_ref, callback, network_info)
+        except Exception, err:
+            self.fail(err)
+
+    def test_attach_volume(self):
+        '''Test attach volume method attaches device to instance using xml '''
+        instance = db.instance_create(self.context, self.test_instance)
+        instance_name = instance['name']
+        test_device_path = ["/dev/vdb", "testproto:testname"]
+        test_mountpoint = "/mnt/testvol"
+        self.create_fake_libvirt_mock()
+        connection.LibvirtConnection._conn.lookupByName = self.fake_lookup
+        self.mox.ReplayAll()
+
+        conn = connection.LibvirtConnection(False)
+        for device_path in test_device_path:
+            try:
+                conn.attach_volume(instance_name, device_path, test_mountpoint)
+            except Exception, err:
+                self.fail(err)
+
+    def test_attach_volume_raises_invalid_device_path_exception(self):
+        '''Test attach volume raises exception for an invalid device path'''
+        instance = db.instance_create(self.context, self.test_instance)
+        instance_name = instance['name']
+        test_device_path = "testPath"
+        test_mountpoint = "/mnt/testvol"
+        self.create_fake_libvirt_mock()
+        connection.LibvirtConnection._conn.lookupByName = self.fake_lookup
+        self.mox.ReplayAll()
+        conn = connection.LibvirtConnection(False)
+        expected_msg = ('The supplied device path (%s) is invalid.' %
+                        test_device_path)
+        try:
+            conn.attach_volume(instance_name, test_device_path,
+                                test_mountpoint)
+        except Exception, msg:
+            self.assertTrue(str(msg).find(expected_msg) != -1)
+
+    def test_detach_volume(self):
+        '''Test detach volume detaches device from instance'''
+        instance = db.instance_create(self.context, self.test_instance)
+        instance_name = instance['name']
+        test_mountpoint = "/mnt/testvol"
+
+        def fake_xml(self, *args):
+            test_xml = """<disk type='block'>
+                          <driver name='qemu' type='raw'/>
+                          <source dev='test'/>
+                          <target dev='test' bus='virtio'/>
+                      </disk>"""
+            return test_xml
+
+        self.create_fake_libvirt_mock()
+        connection.LibvirtConnection._conn.lookupByName = self.fake_lookup
+        self.stubs.Set(connection.LibvirtConnection, '_get_disk_xml', fake_xml)
+        self.mox.ReplayAll()
+        conn = connection.LibvirtConnection(False)
+        try:
+            conn.detach_volume(instance_name, test_mountpoint)
+        except Exception, err:
+            self.fail(err)
+
+    def test_detach_volume_raises_disk_not_found_exception(self):
+        '''Test detach volume raises DiskNotFound if xml is not found'''
+        instance = db.instance_create(self.context, self.test_instance)
+        instance_name = instance['name']
+        test_mountpoint = "/mnt/testvol"
+        expected_msg = 'No disk at testvol'
+
+        def fake_xml(self, *args):
+            return None
+
+        self.create_fake_libvirt_mock()
+        connection.LibvirtConnection._conn.lookupByName = self.fake_lookup
+        self.stubs.Set(connection.LibvirtConnection, '_get_disk_xml', fake_xml)
+        self.mox.ReplayAll()
+        conn = connection.LibvirtConnection(False)
+        try:
+            conn.detach_volume(instance_name, test_mountpoint)
+        except Exception, msg:
+            self.assertTrue(str(msg).find(expected_msg) != -1)
+
+    def test_get_disks(self):
+        '''Test get disks returns single list of all block devices'''
+        if not self.lazy_load_library_exists():
+            return
+
+        instance = db.instance_create(self.context, self.test_instance)
+        instance_name = instance['name']
+
+        self.mox.StubOutWithMock(connection.LibvirtConnection, '_conn')
+        connection.LibvirtConnection._conn.lookupByName = self.fake_lookup
+        self.mox.ReplayAll()
+        conn = connection.LibvirtConnection(False)
+        try:
+            disk_list = conn.get_disks(instance_name)
+        except Exception, err:
+            self.fail(err)
+
+        self.assertEquals(disk_list[0], 'vdb')
+
+    def test_get_disks_libxml_exception_returns_blank_list(self):
+        '''Test blank list returned for unloaded libxml for xml is incorrect'''
+        if not self.lazy_load_library_exists():
+            return
+
+        instance = db.instance_create(self.context, self.test_instance)
+        instance_name = instance['name']
+
+        def parseDoc(*args):
+            raise
+
+        self.mox.StubOutWithMock(connection.LibvirtConnection, '_conn')
+        connection.LibvirtConnection._conn.lookupByName = self.fake_lookup
+        self.stubs.Set(connection.libxml2, 'parseDoc', parseDoc)
+        self.mox.ReplayAll()
+
+        conn = connection.LibvirtConnection(False)
+        try:
+            disk_list = conn.get_disks(instance_name)
+        except Exception, err:
+            self.fail(err)
+
+        self.assertEquals(len(disk_list), 0)
+
+    def test_get_interfaces(self):
+        '''Test correct list of interfaces is returned'''
+        if not self.lazy_load_library_exists():
+            return
+
+        instance = db.instance_create(self.context, self.test_instance)
+        instance_name = instance['name']
+
+        self.mox.StubOutWithMock(connection.LibvirtConnection, '_conn')
+        connection.LibvirtConnection._conn.lookupByName = self.fake_lookup
+        self.mox.ReplayAll()
+        conn = connection.LibvirtConnection(False)
+        try:
+            interface_list = conn.get_interfaces(instance_name)
+        except Exception, err:
+            self.fail(err)
+
+        self.assertEquals(interface_list[0], 'vnet')
+
+    def test_get_interfaces_libxml_exception(self):
+        '''Test blank list returned for unloaded libxml2'''
+        if not self.lazy_load_library_exists():
+            return
+
+        instance = db.instance_create(self.context, self.test_instance)
+        instance_name = instance['name']
+
+        def parseDoc(*args):
+            raise
+
+        self.mox.StubOutWithMock(connection.LibvirtConnection, '_conn')
+        connection.LibvirtConnection._conn.lookupByName = self.fake_lookup
+        self.stubs.Set(connection.libxml2, 'parseDoc', parseDoc)
+        self.mox.ReplayAll()
+
+        conn = connection.LibvirtConnection(False)
+        try:
+            interface_list = conn.get_interfaces(instance_name)
+        except Exception, err:
+            self.fail(err)
+
+        self.assertEquals(len(interface_list), 0)
+
+    def test_get_info(self):
+        instance = db.instance_create(self.context, self.test_instance)
+        instance_name = instance['name']
+
+        self.mox.StubOutWithMock(connection.LibvirtConnection, '_conn')
+        connection.LibvirtConnection._conn.lookupByName = self.fake_lookup
+        self.mox.ReplayAll()
+        conn = connection.LibvirtConnection(False)
+        try:
+            conn.get_info(instance_name)
+        except Exception, err:
+            self.fail(err)
+
+    def test_get_cpu_info(self):
+        if not self.lazy_load_library_exists():
+            return
+
+        def fake_get_capabs():
+            xml = '''<capabilities>
+                        <host>
+                            <cpu>
+                            <arch>x86_64</arch>
+                            <model>coreduo</model>
+                            <vendor>AMD</vendor>
+                            <topology sockets='1' cores='2' threads='1'>
+                            <cells num='1'>
+                                <cell id='0'>
+                                    <cpus num='2'>
+                                        <cpu id='0'/>
+                                        <cpu id='1'/>
+                                    </cpus>
+                                </cell>
+                            </cells>
+                            </topology>
+                            <feature policy='disable' name='lahf_lm'/>
+                            </cpu>
+                        </host>
+                    </capabilities>'''
+            return xml
+        self.mox.StubOutWithMock(connection.LibvirtConnection, '_conn')
+        connection.LibvirtConnection._conn.getCapabilities = fake_get_capabs
+        self.mox.ReplayAll()
+        conn = connection.LibvirtConnection(False)
+        try:
+            cpu_info = conn.get_cpu_info()
+        except Exception, err:
+            self.fail(err)
+
+        self.assertEquals(len(cpu_info), 140, msg="Invalid CPU Info returned")
+
+    def test_get_cpu_info_nocpus(self):
+        if not self.lazy_load_library_exists():
+            return
+
+        def fake_get_capabs():
+            return '''<capabilities>
+                        <host>
+                        </host>
+                      </capabilities>'''
+        self.mox.StubOutWithMock(connection.LibvirtConnection, '_conn')
+        connection.LibvirtConnection._conn.getCapabilities = fake_get_capabs
+        self.mox.ReplayAll()
+        conn = connection.LibvirtConnection(False)
+        self.assertRaises(exception.InvalidCPUInfo, conn.get_cpu_info)
+
+    def test_get_cpu_info_nokeys(self):
+        if not self.lazy_load_library_exists():
+            return
+
+        def fake_get_capabs():
+            xml = '''<capabilities>
+           <host>
+             <cpu>
+               <arch>x86_64</arch>
+               <model>coreduo</model>
+               <vendor>AMD</vendor>
+               <topology>
+               <cells num='1'>
+                 <cell id='0'>
+                    <cpus num='2'>
+                      <cpu id='0'/>
+                      <cpu id='1'/>
+                    </cpus>
+                 </cell>
+               </cells>
+               </topology>
+               <feature policy='disable' name='lahf_lm'/>
+             </cpu>
+            </host>
+          </capabilities>'''
+            return xml
+
+        self.mox.StubOutWithMock(connection.LibvirtConnection, '_conn')
+        connection.LibvirtConnection._conn.getCapabilities = fake_get_capabs
+        self.mox.ReplayAll()
+        conn = connection.LibvirtConnection(False)
+        self.assertRaises(exception.InvalidCPUInfo, conn.get_cpu_info)
+
+    def test_compare_cpu(self):
+        cpu_info_json = '''{"vendor": "AMD", "model": "coreduo", "arch":
+                            "x86_64", "features": ["disable"], "topology":
+                            {"cores": "2", "threads": "1", "sockets": "1"}}'''
+
+        def compareCPU(self, *args):
+            return 1
+
+        self.mox.StubOutWithMock(connection.LibvirtConnection, '_conn')
+        connection.LibvirtConnection._conn.compareCPU = compareCPU
+        self.mox.ReplayAll()
+        conn = connection.LibvirtConnection(False)
+        try:
+            conn.compare_cpu(cpu_info_json)
+        except Exception, err:
+            self.fail(err)
+
+    def test_compare_cpu_invalid_exception(self):
+        cpu_info_json = '''{"vendor": "AMD", "model": "coreduo", "arch":
+                            "x86_64", "features": ["disable"], "topology":
+                            {"cores": "2", "threads": "1", "sockets": "1"}}'''
+
+        def compareCPU(self, *args):
+                return 0
+
+        self.mox.StubOutWithMock(connection.LibvirtConnection, '_conn')
+        connection.LibvirtConnection._conn.compareCPU = compareCPU
+        self.mox.ReplayAll()
+        conn = connection.LibvirtConnection(False)
+        self.assertRaises(exception.InvalidCPUInfo, conn.compare_cpu,
+                        cpu_info_json)
+
+    def test_compare_cpu_libvirt_error(self):
+        if not self.lazy_load_library_exists():
+            return
+
+        cpu_info_json = '''{"vendor": "AMD", "model": "coreduo", "arch":
+                            "x86_64", "features": ["disable"], "topology":
+                            {"cores": "2", "threads": "1", "sockets": "1"}}'''
+
+        def compareCPU(self, *args):
+            raise libvirt.libvirtError('virDomainCompareCPU Failed', conn=self)
+
+        self.mox.StubOutWithMock(connection.LibvirtConnection, '_conn')
+        connection.LibvirtConnection._conn.compareCPU = compareCPU
+
+        self.mox.ReplayAll()
+        conn = connection.LibvirtConnection(False)
+        self.assertRaises(libvirt.libvirtError, conn.compare_cpu,
+                            cpu_info_json)
+
+    def test_init_host_running(self):
+        instance = db.instance_create(self.context, self.test_instance)
+
+        def fake_get_info(*args):
+            return {'state': 1}
+
+        def fake_db_instance_list(*args):
+            return [instance]
+
+        def fake_db_inst_set_state(*args):
+            pass
+
+        self.create_fake_libvirt_mock()
+
+        self.mox.StubOutWithMock(connection.LibvirtConnection, '_conn')
+        connection.LibvirtConnection._conn.lookupByName = self.fake_lookup
+        self.stubs.Set(connection.LibvirtConnection, 'get_info', fake_get_info)
+        self.stubs.Set(db, 'instance_get_all_by_host', fake_db_instance_list)
+        self.stubs.Set(db, 'instance_set_state', fake_db_inst_set_state)
+        self.mox.ReplayAll()
+
+        conn = connection.LibvirtConnection(False)
+        conn.firewall_driver.setattr('setup_basic_filtering', self.fake_none)
+        conn.firewall_driver.setattr('prepare_instance_filter', self.fake_none)
+        conn.firewall_driver.setattr('apply_instance_filter', self.fake_none)
+        try:
+            conn.init_host(self.test_ip)
+        except Exception, err:
+            self.fail(err)
+
+    def test_init_host_not_running(self):
+        instance = db.instance_create(self.context, self.test_instance)
+
+        def fake_get_info(*args):
+                return {'state': 3}
+
+        def fake_db_instance_list(*args):
+            return [instance]
+
+        def fake_db_inst_set_state(*args):
+            pass
+
+        self.create_fake_libvirt_mock()
+
+        self.mox.StubOutWithMock(connection.LibvirtConnection, '_conn')
+        connection.LibvirtConnection._conn.lookupByName = self.fake_lookup
+        self.stubs.Set(connection.LibvirtConnection, 'get_info', fake_get_info)
+        self.stubs.Set(db, 'instance_get_all_by_host', fake_db_instance_list)
+        self.stubs.Set(db, 'instance_set_state', fake_db_inst_set_state)
+
+        self.mox.ReplayAll()
+        conn = connection.LibvirtConnection(False)
+        try:
+            conn.init_host(self.test_ip)
+        except Exception, err:
+            self.fail(err)
+
+    def test_init_host_instance_not_found(self):
+        instance = db.instance_create(self.context, self.test_instance)
+
+        def fake_get_info(*args):
+            raise exception.NotFound
+
+        def fake_db_instance_list(*args):
+            return [instance]
+
+        def fake_db_inst_set_state(*args):
+            pass
+
+        self.create_fake_libvirt_mock()
+
+        self.mox.StubOutWithMock(connection.LibvirtConnection, '_conn')
+        connection.LibvirtConnection._conn.lookupByName = self.fake_lookup
+        self.stubs.Set(connection.LibvirtConnection, 'get_info', fake_get_info)
+        self.stubs.Set(db, 'instance_get_all_by_host', fake_db_instance_list)
+        self.stubs.Set(db, 'instance_set_state', fake_db_inst_set_state)
+        self.mox.ReplayAll()
+
+        conn = connection.LibvirtConnection(False)
+        try:
+            conn.init_host(self.test_ip)
+        except Exception, err:
+            self.fail(err)
+
+    def test_get_console_output(self):
+        instance = db.instance_create(self.context, self.test_instance)
+        instance_name = instance['name']
+
+        test_contents = "Test contents dumped to file"
+
+        def fake_get_path(*args):
+            return '/test/path/'
+
+        def fake_flush(*args):
+            pass
+
+        def fake_append_to_file(*args):
+            pass
+
+        def fake_dump_file(*args):
+            return test_contents
+
+        fake_utils.stub_out_utils_execute(self.stubs)
+        self.stubs.Set(os.path, 'join', fake_get_path)
+        FLAGS.libvirt_type = 'xen'
+        self.stubs.Set(connection.LibvirtConnection, '_flush_xen_console',
+                        fake_flush)
+        self.stubs.Set(connection.LibvirtConnection, '_append_to_file',
+                        fake_append_to_file)
+        self.stubs.Set(connection.LibvirtConnection, '_dump_file',
+                        fake_dump_file)
+        self.mox.ReplayAll()
+
+        conn = connection.LibvirtConnection(False)
+        try:
+            ret = conn.get_console_output(instance)
+        except Exception, err:
+            self.fail(err)
+
+        self.assertEquals(ret, test_contents)
+
+    def test_get_ajax_console_raises_exception(self):
+        instance = db.instance_create(self.context, self.test_instance)
+        instance_name = instance['name']
+
+        fake_utils.stub_out_utils_execute(self.stubs)
+        FLAGS.ajaxterm_portrange = '1200-45320'
+        self.mox.ReplayAll()
+
+        conn = connection.LibvirtConnection(False)
+        self.assertRaises(Exception,
+                        conn.get_ajax_console, instance)
+
+    def test_get_vnc_console(self):
+        instance = db.instance_create(self.context, self.test_instance)
+        instance_name = instance['name']
+        instance['host'] = 'test_host001'
+        test_uuid = 'abc12345-6789-0123-a1b2-a123456789z'
+        port = u'5904'
+        test_dict = {'host': instance['host'], 'token': test_uuid,
+                    'port': port}
+
+        def fake_uuid():
+            return test_uuid
+
+        self.mox.StubOutWithMock(connection.LibvirtConnection, '_conn')
+        connection.LibvirtConnection._conn.lookupByName = self.fake_lookup
+        self.stubs.Set(connection.uuid, 'uuid4', fake_uuid)
+        self.mox.ReplayAll()
+
+        conn = connection.LibvirtConnection(False)
+        ret = {}
+        try:
+            ret = conn.get_vnc_console(instance)
+        except Exception, err:
+            self.fail(err)
+
+        self.assertDictMatch(ret, test_dict)
+
+    def test_get_diagnostics_not_supported(self):
+        conn = connection.LibvirtConnection(False)
+        self.assertRaises(exception.ApiError, conn.get_diagnostics, 'test-001')
+
+    def test_get_vcpu_total_not_implemented_exception(self):
+
+        def fake_cpu_count():
+            raise NotImplementedError
+
+        self.stubs.Set(connection.multiprocessing, 'cpu_count', fake_cpu_count)
+        self.mox.ReplayAll()
+        conn = connection.LibvirtConnection(False)
+        ret = conn.get_vcpu_total()
+        self.assertEquals(ret, 0)
+
+    def test_block_stats(self):
+        instance = db.instance_create(self.context, self.test_instance)
+        instance_name = instance['name']
+        self.mox.StubOutWithMock(connection.LibvirtConnection, '_conn')
+        connection.LibvirtConnection._conn.lookupByName = self.fake_lookup
+        self.mox.ReplayAll()
+
+        conn = connection.LibvirtConnection(False)
+        try:
+            conn.block_stats(instance, 'test_disk')
+        except Exception, err:
+            self.fail(err)
+
+    def test_interface_stats(self):
+        instance = db.instance_create(self.context, self.test_instance)
+        instance_name = instance['name']
+        self.mox.StubOutWithMock(connection.LibvirtConnection, '_conn')
+        connection.LibvirtConnection._conn.lookupByName = self.fake_lookup
+        self.mox.ReplayAll()
+
+        conn = connection.LibvirtConnection(False)
+        try:
+            conn.interface_stats(instance, 'test_interface')
+        except Exception, err:
+            self.fail(err)
+
+    def test_get_console_pool_info(self):
+        match_dict = {'address': '127.0.0.1',
+                    'username': 'fakeuser',
+                    'password': 'fakepassword'}
+        conn = connection.LibvirtConnection(False)
+        try:
+            ret = conn.get_console_pool_info('test_tty')
+        except Exception, err:
+            self.fail(err)
+
+        self.assertDictMatch(ret, match_dict)
+
+    def test_refresh_security_group_rules(self):
+        self.create_fake_libvirt_mock()
+        self.mox.ReplayAll()
+        conn = connection.LibvirtConnection(False)
+        conn.firewall_driver.setattr('refresh_security_group_rules',
+                                    self.fake_none)
+        try:
+            conn.refresh_security_group_rules('test_gid')
+        except Exception, err:
+            self.fail(err)
+
+    def test_refresh_security_group_members(self):
+        self.create_fake_libvirt_mock()
+        self.mox.ReplayAll()
+        conn = connection.LibvirtConnection(False)
+        conn.firewall_driver.setattr('refresh_security_group_members',
+                                    self.fake_none)
+        try:
+            conn.refresh_security_group_members('test_gid')
+        except Exception, err:
+            self.fail(err)
+
+    def test_refresh_provider_fw_rules(self):
+        self.create_fake_libvirt_mock()
+        self.mox.ReplayAll()
+        conn = connection.LibvirtConnection(False)
+        conn.firewall_driver.setattr('refresh_provider_fw_rules',
+                                    self.fake_none)
+        try:
+            conn.refresh_provider_fw_rules()
+        except Exception, err:
+            self.fail(err)
+
+    def test_unfilter_instance(self):
+        network_info = _fake_network_info(self.stubs, 1)
+        self.create_fake_libvirt_mock()
+        self.mox.ReplayAll()
+        conn = connection.LibvirtConnection(False)
+        conn.firewall_driver.setattr('unfilter_instance', self.fake_none)
+        try:
+            conn.unfilter_instance('test_inst_ref', network_info)
+        except Exception, err:
+            self.fail(err)
+
+    def test_get_vcpu_used(self):
+
+        def listDomainsID():
+            return [1, 2, 3, 4]
+
+        def lookupByID(*args):
+
+            class Vcpu:
+                def __init__(self):
+                    pass
+
+                def vcpus(self):
+                    return [99, 'vcpu']
+
+            return Vcpu()
+
+        class FakeLibvirtConnection(object):
+            pass
+
+        self.mox.StubOutWithMock(connection.LibvirtConnection, '_conn')
+        connection.LibvirtConnection._conn = FakeLibvirtConnection()
+        connection.LibvirtConnection._conn.listDomainsID = listDomainsID
+        connection.LibvirtConnection._conn.lookupByID = lookupByID
+        self.mox.ReplayAll()
+        total = 16
+        conn = connection.LibvirtConnection(False)
+        try:
+            ret = conn.get_vcpu_used()
+        except Exception, err:
+            self.fail(err)
+
+        self.assertEquals(ret, total)
+
+    def test_cache_image_with_cow(self):
+        def fake_path_exists(*args):
+            return 0
+
+        def fake_path_join(*args):
+            return '/test/base/dir'
+
+        def fake_fn(*args, **kwargs):
+            pass
+
+        self.stubs.Set(os.path, 'exists', fake_path_exists)
+        self.stubs.Set(os.path, 'join', fake_path_join)
+        self.stubs.Set(os, 'mkdir', fake_fn)
+        self.stubs.Set(connection.utils, 'execute', fake_fn)
+
+        self.mox.ReplayAll()
+        conn = connection.LibvirtConnection(False)
+        try:
+            conn._cache_image(fake_fn, 'test_target', 'test.ami', cow=True)
+        except Exception, err:
+            self.fail(err)
+
+    def test_cache_image_no_cow(self):
+        def fake_path_exists(*args):
+            return 0
+
+        def fake_path_join(*args):
+            return '/test/base/dir'
+
+        def fake_fn(*args, **kwargs):
+            pass
+
+        self.stubs.Set(os.path, 'exists', fake_path_exists)
+        self.stubs.Set(os.path, 'join', fake_path_join)
+        self.stubs.Set(os, 'mkdir', fake_fn)
+        self.stubs.Set(connection.utils, 'execute', fake_fn)
+
+        self.mox.ReplayAll()
+        conn = connection.LibvirtConnection(False)
+        try:
+            conn._cache_image(fake_fn, 'test_target', 'test.ami', cow=False)
+        except Exception, err:
+            self.fail(err)
+
+    def test_fetch_image_with_size(self):
+        def fake_fn(*args):
+            pass
+
+        self.stubs.Set(connection.images, 'fetch', fake_fn)
+        self.stubs.Set(connection.disk, 'extend', fake_fn)
+        self.mox.ReplayAll()
+
+        conn = connection.LibvirtConnection(False)
+        try:
+            conn._fetch_image(self.context, 'test_target', 'test-001',
+                            self.user_id, self.project_id, size='2G')
+        except Exception, err:
+            self.fail(err)
+
+    def test_fetch_image_no_size(self):
+        def fake_fetch(*args):
+            pass
+
+        self.stubs.Set(connection.images, 'fetch', fake_fetch)
+        self.mox.ReplayAll()
+
+        conn = connection.LibvirtConnection(False)
+        try:
+            conn._fetch_image(self.context, 'test_target', 'test-001',
+                            self.user_id, self.project_id, size=None)
+        except Exception, err:
+            self.fail(err)
+
+    def test_create_local(self):
+        fake_utils.stub_out_utils_execute(self.stubs)
+        self.mox.ReplayAll()
+
+        conn = connection.LibvirtConnection(False)
+        try:
+            conn._create_local('test_target', 1)
+        except Exception, err:
+            self.fail(err)
+
+    def test_lookup_by_name(self):
+        if not self.lazy_load_library_exists():
+            return
+
+        instance = db.instance_create(self.context, self.test_instance)
+        instance_name = instance['name']
+
+        class FakeLibvirtConnection(object):
+            def __init__(self):
+                pass
+
+            def lookupByName(self, *args):
+                return True
+
+        fake = FakeLibvirtConnection()
+        self.stubs.Set(connection.LibvirtConnection, '_conn', fake)
+        self.mox.ReplayAll()
+
+        conn = connection.LibvirtConnection(False)
+        try:
+            ret = conn._lookup_by_name(instance_name)
+        except Exception, err:
+            self.fail(err)
+
+        self.assertTrue(ret)
+
+    def test_lookup_by_name_raises_instance_not_found_exception(self):
+        '''Test instance not found exception is raised'''
+        if not self.lazy_load_library_exists():
+            return
+
+        instance = db.instance_create(self.context, self.test_instance)
+        instance_name = instance['name']
+
+        def fake_get_last_error():
+            return [42, 13, 'fake message']
+
+        class FakeLibvirtConnection(object):
+            def __init__(self):
+                pass
+
+        def lookupByName(self, *args):
+            raise libvirt.libvirtError('ERR')
+
+        fake = FakeLibvirtConnection()
+
+        self.mox.StubOutWithMock(connection.LibvirtConnection, '_conn')
+        connection.LibvirtConnection._conn = fake
+        connection.LibvirtConnection._conn.lookupByName = lookupByName
+        self.stubs.Set(connection.libvirt, 'virGetLastError',
+                        fake_get_last_error)
+        self.mox.ReplayAll()
+
+        conn = connection.LibvirtConnection(False)
+        self.assertRaises(exception.InstanceNotFound, conn._lookup_by_name,
+                        instance_name)
+
+    def test_lookup_by_name_raises_lookup_error(self):
+        '''Test lookup error is received'''
+        if not self.lazy_load_library_exists():
+            return
+
+        instance = db.instance_create(self.context, self.test_instance)
+        instance_name = instance['name']
+        expected_msg = ('Error from libvirt while looking up %s' %
+                        instance_name)
+
+        class FakeLibvirtConnection(object):
+            def __init__(self):
+                pass
+
+        def lookupByName(self, *args):
+            raise libvirt.libvirtError('ERR')
+
+        fake = FakeLibvirtConnection()
+        self.mox.StubOutWithMock(connection.LibvirtConnection, '_conn')
+        connection.LibvirtConnection._conn = fake
+        connection.LibvirtConnection._conn.lookupByName = lookupByName
+
+        self.mox.ReplayAll()
+
+        conn = connection.LibvirtConnection(False)
+        try:
+            conn._lookup_by_name(instance_name)
+        except Exception, err:
+            self.assertTrue(str(err).find(expected_msg) != -1)
+
+    def test_get_disk_xml(self):
+        '''Test method returns xml for disk mounted at device'''
+        if not self.lazy_load_library_exists():
+            return
+
+        xml = """
+                    <domain type='kvm'>
+                        <devices>
+                            <disk type='file'>
+                                <source file='filename'/>
+                                <target dev='vdb' bus='ide'/>
+                            </disk>
+                            <interface type='bridge'>
+                                <source bridge='br0'/>
+                                <target dev='vnet'/>
+                                <mac address="00:11:22:33:44:55"/>
+                            </interface>
+                            <serial type='pty'>
+                                <source path='/dev/pts/3'/>
+                                <target port='0'/>
+                            </serial>
+                            <graphics type='vnc' port='5904'/>
+                        </devices>
+                    </domain>
+                """
+        expected_node = """<disk type="file">
+                                <source file="filename"/>
+                                <target dev="vdb" bus="ide"/>
+                            </disk>"""
+        test_device = 'vdb'
+        conn = connection.LibvirtConnection(False)
+        try:
+            node = conn._get_disk_xml(xml, test_device)
+        except Exception, err:
+            self.fail(err)
+
+        self.assertEquals(node, expected_node)
+
+    def test_get_disk_xml_returns_none(self):
+        if not self.lazy_load_library_exists():
+            return
+
+        xml = 'fake'
+        test_device = 'vdb'
+
+        def fake_parseDoc(*args):
+            raise
+
+        self.stubs.Set(connection.libxml2, 'parseDoc', fake_parseDoc)
+        self.mox.ReplayAll()
+
+        conn = connection.LibvirtConnection(False)
+        try:
+            node = conn._get_disk_xml(xml, test_device)
+        except Exception, err:
+            self.fail(err)
+
+        self.assertEquals(node, None)
+
+    def test_flush_xen_console(self):
+        test_virsh_output = ['/dev/tty0', 'test']
+
+        def fake_execute(*args, **kwatgs):
+            return 200, None
+
+        self.stubs.Set(connection.utils, 'execute', fake_execute)
+        self.mox.ReplayAll()
+        conn = connection.LibvirtConnection(False)
+        try:
+            out = conn._flush_xen_console(test_virsh_output)
+        except Exception, err:
+            self.fail(err)
+
+        self.assertEquals(out, 200)
+
+    def test_flush_xen_console_no_device(self):
+        test_virsh_output = ['test', 'test']
+
+        def fake_execute(*args, **kwatgs):
+            return 200, None
+
+        self.stubs.Set(connection.utils, 'execute', fake_execute)
+        self.mox.ReplayAll()
+        conn = connection.LibvirtConnection(False)
+        try:
+            out = conn._flush_xen_console(test_virsh_output)
+        except Exception, err:
+            self.fail(err)
+
+        self.assertEquals(out, '')
+
+    def test_append_to_file(self):
+        test_data = "Test Data"
+        test_file_path = "/test/file/path"
+
+        def fake_open(*args):
+            return StringIO.StringIO("one,two,three\n1,2,3")
+
+        import __builtin__
+        self.stubs.Set(__builtin__, 'open', fake_open)
+
+        self.mox.ReplayAll()
+        conn = connection.LibvirtConnection(False)
+        try:
+            out = conn._append_to_file(test_data, test_file_path)
+        except Exception, err:
+            self.fail(err)
+
+        self.assertEquals(out, test_file_path)
+
+    def test_dump_file(self):
+        test_contents = "Test Data"
+        test_file_path = "/test/file/path"
+        fake_contents = 'one,two,three\n1,2,3'
+
+        def fake_open(*args):
+            return StringIO.StringIO(fake_contents)
+
+        import __builtin__
+        self.stubs.Set(__builtin__, 'open', fake_open)
+        self.mox.ReplayAll()
+
+        conn = connection.LibvirtConnection(False)
+        try:
+            out = conn._dump_file(test_file_path)
+        except Exception, err:
+            self.fail(err)
+
+        self.assertEquals(out, fake_contents)
+
+    def test_create_image_lxc_no_network_info_no_v6(self):
+        '''Test private method creates image when no network info is passed'''
+        instance = db.instance_create(self.context, self.test_instance)
+        instance_name = instance['name']
+        instance['key_data'] = 'abcdef'
+        instance['image_ref'] = '123456'
+
+        network_info = []
+        import __builtin__
+
+        def fake_get_path(*args):
+            return 'fake/test/path'
+
+        def fake_method(*args, **kwargs):
+            pass
+
+        def fake_open(*args):
+            return StringIO.StringIO("one,two,three\n1,2,3")
+
+        def fake_user(*args):
+            return self.user
+
+        def fake_project(*args):
+            return self.project
+
+        def fake_mapping(*args):
+            return False
+
+        self.stubs.Set(__builtin__, 'open', fake_open)
+        self.stubs.Set(os.path, 'join', fake_get_path)
+        self.stubs.Set(connection.utils, 'execute', fake_method)
+        FLAGS.libvirt_type = 'lxc'
+        self.stubs.Set(os, 'open', fake_open)
+        self.stubs.Set(os, 'close', fake_method)
+        self.stubs.Set(connection.manager.AuthManager, 'get_user', fake_user)
+        self.stubs.Set(connection.manager.AuthManager, 'get_project',
+                        fake_project)
+        self.stubs.Set(connection.LibvirtConnection, '_volume_in_mapping',
+                        fake_mapping)
+        self.stubs.Set(connection.LibvirtConnection, '_cache_image',
+                        fake_method)
+        self.stubs.Set(connection.disk, 'inject_data', fake_method)
+        self.stubs.Set(connection.disk, 'setup_container', fake_method)
+        self.mox.ReplayAll()
+        conn = connection.LibvirtConnection(False)
+        try:
+            conn._create_image(self.context, instance, 'test',
+                                                    network_info=network_info)
+        except Exception, err:
+            self.fail(err)
+
+    def test_create_image_lxc_tiny_instance_has_kernel_ramdisk(self):
+        '''Test private method creates image with kernel and ramdisk image'''
+        test_instance = {'memory_kb': '1024000',
+                'basepath': '/some/path',
+                'bridge_name': 'br100',
+                'vcpus': 2,
+                'project_id': 'fake',
+                'bridge': 'br101',
+                'key_data': 'abcdef',
+                'image_ref': '123456',
+                'kernel_id': '123456',
+                'ramdisk_id': '123456',
+                'instance_type_id': '2'}  # m1.tiny
+
+        instance = db.instance_create(self.context, test_instance)
+        instance_name = instance['name']
+        network_info = _fake_network_info(self.stubs, 1)
+
+        import __builtin__
+
+        def fake_get_path(*args):
+            return 'fake/test/path'
+
+        def fake_method(*args, **kwargs):
+            pass
+
+        def fake_open(*args):
+            return StringIO.StringIO("one,two,three\n1,2,3")
+
+        def fake_user(*args):
+            return self.user
+
+        def fake_project(*args):
+            return self.project
+
+        def fake_mapping(*args):
+            return False
+
+        self.stubs.Set(__builtin__, 'open', fake_open)
+        self.stubs.Set(os.path, 'join', fake_get_path)
+        self.stubs.Set(connection.utils, 'execute', fake_method)
+        FLAGS.libvirt_type = 'lxc'
+        self.stubs.Set(os, 'open', fake_open)
+        self.stubs.Set(os, 'close', fake_method)
+        self.stubs.Set(connection.manager.AuthManager, 'get_user', fake_user)
+        self.stubs.Set(connection.manager.AuthManager, 'get_project',
+                        fake_project)
+        self.stubs.Set(connection.LibvirtConnection, '_volume_in_mapping',
+                        fake_mapping)
+
+        self.stubs.Set(connection.LibvirtConnection, '_cache_image',
+                        fake_method)
+        FLAGS.use_ipv6 = False
+        self.stubs.Set(connection.disk, 'inject_data', fake_method)
+        self.stubs.Set(connection.disk, 'setup_container', fake_method)
+        self.mox.ReplayAll()
+        conn = connection.LibvirtConnection(False)
+        try:
+            conn._create_image(self.context, instance, 'test',
+                                network_info=network_info)
+        except Exception, err:
+            self.fail(err)
+
+    def test_get_connection(self):
+        '''Test private method that creates the libvirt connection object'''
+
+        def fake_method(*args):
+            return 'Fake'
+
+        self.stubs.Set(connection.LibvirtConnection, '_test_connection',
+                        None)
+        self.stubs.Set(connection.LibvirtConnection, '_connect', fake_method)
+        self.mox.ReplayAll()
+        conn = connection.LibvirtConnection(False)
+        ret = conn._get_connection()
+        self.assertTrue(ret, 'Fake')
+
+    def test_test_connection(self):
+        '''Test test connection returns true of connection object is created'''
+
+        class fake_wrapped_conn:
+            def __init__(self):
+                pass
+
+            def getCapabilities(self):
+                pass
+
+        conn = connection.LibvirtConnection(False)
+        conn._wrapped_conn = fake_wrapped_conn()
+        try:
+            ret = conn._test_connection()
+        except Exception, err:
+            self.fail(err)
+
+        self.assertTrue(ret)
+
+    def test_test_connection_broken(self):
+        '''Test test connection returns false if system error is recevied'''
+        if not self.lazy_load_library_exists():
+            return
+
+        def fake_get_last_error():
+                return [38, 13, 'fake message']
+
+        class fake_wrapped_conn:
+            def __init__(self):
+                pass
+
+            def getCapabilities(self):
+                raise libvirt.libvirtError("Broken connection to libvirt")
+
+        self.stubs.Set(connection.libvirt, 'virGetLastError',
+                        fake_get_last_error)
+        self.mox.ReplayAll()
+        conn = connection.LibvirtConnection(False)
+        conn._wrapped_conn = fake_wrapped_conn()
+        try:
+            ret = conn._test_connection()
+        except Exception, err:
+            self.fail(err)
+        self.assertFalse(ret)
+
+    def test_test_connection_raises_exception_for_unknown_error(self):
+        '''Test test connection raises exception for unknown libvirt error '''
+        if not self.lazy_load_library_exists():
+            return
+
+        def fake_get_last_error():
+                return [10, 0, 'fake message']
+
+        class fake_wrapped_conn:
+            def __init__(self):
+                pass
+
+            def getCapabilities(self):
+                raise libvirt.libvirtError("Broken connection to libvirt")
+
+        self.stubs.Set(connection.libvirt, 'virGetLastError',
+                        fake_get_last_error)
+        self.mox.ReplayAll()
+        conn = connection.LibvirtConnection(False)
+        conn._wrapped_conn = fake_wrapped_conn()
+        self.assertRaises(libvirt.libvirtError, conn._test_connection)
+
+    def test_connect_read_only(self):
+        '''Test connect returns connection object for read only access'''
+        if not self.lazy_load_library_exists():
+            return
+
+        def fake_method(*args):
+            return True
+
+        self.stubs.Set(connection.libvirt, 'openReadOnly', fake_method)
+        self.mox.ReplayAll()
+        conn = connection.LibvirtConnection(False)
+        try:
+            ret = conn._connect('fake', 1)
+        except Exception, err:
+            self.fail(err)
+
+        self.assertTrue(ret)
+
+    def test_connect_with_auth(self):
+        '''Test connect returns connection object for authorized access'''
+        if not self.lazy_load_library_exists():
+            return
+
+        def fake_method(*args):
+            return True
+
+        self.stubs.Set(connection.libvirt, 'openAuth', fake_method)
+        self.mox.ReplayAll()
+        conn = connection.LibvirtConnection(False)
+        try:
+            ret = conn._connect('fake_url', 0)
+        except Exception, err:
+            self.fail(err)
+        self.assertTrue(ret)
+
+    #@test.skip_test("SKIP")
+    def test_map_to_instance_info(self):
+        '''Test method gets info from virsh domain into an InstanceInfo'''
+
+        class FakeVirtDomain(object):
+            def __init__(self):
+                pass
+
+            def info(self):
+                return (1, '20', '10', '1', '1')
+
+            def name(self):
+                return 'fake'
+
+        conn = connection.LibvirtConnection(False)
+        domain = FakeVirtDomain()
+        try:
+            ret = conn._map_to_instance_info(domain)
+            self.assertEquals(ret.name, 'fake')
+            self.assertEquals(ret.state, 1)
+        except Exception, err:
+            self.fail(err)
+
+    def test_cleanup(self):
+        '''Test instance is deleted as part of cleanup call'''
+        instance = db.instance_create(self.context, self.test_instance)
+
+        def fake_join(*args):
+            return 'fake'
+
+        def fake_exists(*args):
+            return True
+
+        def fake_method(*args, **kwargs):
+            pass
+
+        self.stubs.Set(os.path, 'join', fake_join)
+        FLAGS.libvirt_type = 'lxc'
+        self.stubs.Set(os.path, 'exists', fake_exists)
+        self.stubs.Set(connection.shutil, 'rmtree', fake_method)
+        self.stubs.Set(connection.disk, 'destroy_container', fake_method)
+        conn = connection.LibvirtConnection(False)
+        try:
+            conn._cleanup(instance)
+        except Exception, err:
+            self.fail(err)
+
     def test_volume_in_mapping(self):
+
         conn = connection.LibvirtConnection(False)
         swap = {'device_name': '/dev/sdb',
                 'swap_size': 1}
@@ -1468,5 +3175,4 @@
 
         # should undefine 2 filters: instance and instance-secgroup
         self.assertEqual(original_filter_count - len(fakefilter.filters), 2)
-
         db.instance_destroy(admin_ctxt, instance_ref['id'])