[Kimchi-devel] [PATCH][Kimchi 3/4] Update tests

8 Apr 2016

Update all tests to use source_media instead of disks and cdrom

Signed-off-by: Ramon Medeiros <ramonn@linux.vnet.ibm.com>
---
 tests/test_authorization.py |  4 +--
 tests/test_livemigration.py |  7 +++--
 tests/test_mockmodel.py     | 13 +++++----
 tests/test_model.py         | 67 +++++++++++++++++++++------------------------
 tests/test_rest.py          | 36 ++++++++++++------------
 tests/test_template.py      | 37 +++++++++++++------------
 tests/test_vmtemplate.py    |  3 +-
 7 files changed, 83 insertions(+), 84 deletions(-)

diff --git a/tests/test_authorization.py b/tests/test_authorization.py
index d88f763..7cf8da2 100644
--- a/tests/test_authorization.py
+++ b/tests/test_authorization.py
@@ -91,7 +91,7 @@ class AuthorizationTests(unittest.TestCase):
         # but he can get and create a new one
         resp = self.request('/plugins/kimchi/templates', '{}', 'GET')
         self.assertEquals(403, resp.status)
-        req = json.dumps({'name': 'test', 'cdrom': fake_iso})
+        req = json.dumps({'name': 'test', 'source_media': fake_iso})
         resp = self.request('/plugins/kimchi/templates', req, 'POST')
         self.assertEquals(403, resp.status)
         resp = self.request('/plugins/kimchi/templates/test', '{}', 'PUT')
@@ -100,7 +100,7 @@ class AuthorizationTests(unittest.TestCase):
         self.assertEquals(403, resp.status)
 
         # Non-root users can only get vms authorized to them
-        model.templates_create({'name': u'test', 'cdrom': fake_iso})
+        model.templates_create({'name': u'test', 'source_media': fake_iso})
 
         task_info = model.vms_create({
             'name': u'test-me',
diff --git a/tests/test_livemigration.py b/tests/test_livemigration.py
index aa8d1bd..34fe853 100644
--- a/tests/test_livemigration.py
+++ b/tests/test_livemigration.py
@@ -97,12 +97,13 @@ class LiveMigrationTests(unittest.TestCase):
         )
         params = {'name': u'template_test_vm_migrate',
                   'disks': [],
-                  'cdrom': UBUNTU_ISO,
-                  'memory': {'current': 2048, 'maxmemory': 4096 << 10}}
+                  'source_media': UBUNTU_ISO,
+                  'memory': {'current': 2048, 'max_memory': 4096 << 10}}
+
         self.inst.templates_create(params)
         params = {'name': u'template_test_vm_migrate_nonshared',
                   'disks': [{'name': 'test_vm_migrate.img', 'size': 1}],
-                  'cdrom': UBUNTU_ISO,
+                  'source_media': UBUNTU_ISO,
                   'memory': {'current': 2048, 'maxmemory': 4096*1024}}
         self.inst.templates_create(params)
 
diff --git a/tests/test_mockmodel.py b/tests/test_mockmodel.py
index 0668191..41156f9 100644
--- a/tests/test_mockmodel.py
+++ b/tests/test_mockmodel.py
@@ -30,6 +30,7 @@ from wok.exception import InvalidOperation
 from wok.plugins.kimchi import mockmodel
 from wok.plugins.kimchi.osinfo import get_template_default
 
+import iso_gen
 
 test_server = None
 model = None
@@ -50,7 +51,7 @@ def setUpModule():
     test_server = run_server(host, port, ssl_port, test_mode=True,
                              model=model)
     fake_iso = '/tmp/fake.iso'
-    open(fake_iso, 'w').close()
+    iso_gen.construct_fake_iso(fake_iso, True, '12.04', 'ubuntu')
 
 
 def tearDown():
@@ -65,7 +66,7 @@ class MockModelTests(unittest.TestCase):
 
     def test_screenshot_refresh(self):
         # Create a VM
-        req = json.dumps({'name': 'test', 'cdrom': fake_iso})
+        req = json.dumps({'name': 'test', 'source_media': fake_iso})
         request(host, ssl_port, '/plugins/kimchi/templates', req, 'POST')
         req = json.dumps({'name': 'test-vm',
                           'template': '/plugins/kimchi/templates/test'})
@@ -95,7 +96,7 @@ class MockModelTests(unittest.TestCase):
                           resp.getheader('last-modified'))
 
     def test_vm_list_sorted(self):
-        req = json.dumps({'name': 'test', 'cdrom': fake_iso})
+        req = json.dumps({'name': 'test', 'source_media': fake_iso})
         request(host, ssl_port, '/plugins/kimchi/templates', req, 'POST')
 
         def add_vm(name):
@@ -115,7 +116,7 @@ class MockModelTests(unittest.TestCase):
 
     def test_memory_window_changes(self):
         model.templates_create({'name': u'test',
-                                'cdrom': fake_iso})
+                                'source_media': fake_iso})
         task = model.vms_create({'name': u'test-vm',
                                  'template': '/plugins/kimchi/templates/test'})
         wait_task(model.task_lookup, task['id'])
@@ -127,7 +128,7 @@ class MockModelTests(unittest.TestCase):
 
     def test_hotplug_3D_card(self):
         model.templates_create({'name': u'test',
-                                'cdrom': fake_iso})
+                                'source_media': fake_iso})
         task = model.vms_create({'name': u'test-vm',
                                  'template': '/plugins/kimchi/templates/test'})
         wait_task(model.task_lookup, task['id'])
@@ -147,7 +148,7 @@ class MockModelTests(unittest.TestCase):
 
     def test_vm_info(self):
         model.templates_create({'name': u'test',
-                                'cdrom': fake_iso})
+                                'source_media': fake_iso})
         task = model.vms_create({'name': u'test-vm',
                                  'template': '/plugins/kimchi/templates/test'})
         wait_task(model.task_lookup, task['id'])
diff --git a/tests/test_model.py b/tests/test_model.py
index c91ba8f..90ecd40 100644
--- a/tests/test_model.py
+++ b/tests/test_model.py
@@ -135,12 +135,9 @@ class ModelTests(unittest.TestCase):
             inst.task_wait(task['id'])
             task = inst.task_lookup(task['id'])
             self.assertEquals('finished', task['status'])
-            vol = inst.storagevolume_lookup(u'default', vol_params['name'])
 
-            params = {'name': 'test', 'disks':
-                      [{'base': vol['path'], 'size': 1, 'pool': {
-                          'name': '/plugins/kimchi/storagepools/default'}}],
-                      'cdrom': UBUNTU_ISO}
+            params = {'name': 'test', 'source_media': UBUNTU_ISO}
+
             inst.templates_create(params)
             rollback.prependDefer(inst.template_delete, 'test')
 
@@ -267,16 +264,12 @@ class ModelTests(unittest.TestCase):
 
             # Create template based on IMG file
             tmpl_name = "img-tmpl"
-            pool_uri = "/plugins/kimchi/storagepools/default"
             tmpl_info = {"cpu_info": {"vcpus": 1}, "name": tmpl_name,
                          "graphics": {"type": "vnc", "listen": "127.0.0.1"},
                          "networks": ["default"], "memory": {'current': 1024},
                          "folder": [], "icon": "images/icon-vm.png",
-                         "cdrom": "", "os_distro": "unknown",
-                         "os_version": "unknown",
-                         "disks": [{"base": vol_path, "size": 10,
-                                    "format": "qcow2",
-                                    "pool": {"name": pool_uri}}]}
+                         "os_distro": "unknown", "os_version": "unknown",
+                         "source_media": vol_path}
 
             inst.templates_create(tmpl_info)
             rollback.prependDefer(inst.template_delete, tmpl_name)
@@ -299,7 +292,7 @@ class ModelTests(unittest.TestCase):
     @unittest.skipUnless(utils.running_as_root(), 'Must be run as root')
     def test_vm_graphics(self):
         inst = model.Model(objstore_loc=self.tmp_store)
-        params = {'name': 'test', 'disks': [], 'cdrom': UBUNTU_ISO}
+        params = {'name': 'test', 'source_media': UBUNTU_ISO}
         inst.templates_create(params)
         with RollbackContext() as rollback:
             params = {'name': 'kimchi-vnc',
@@ -329,7 +322,7 @@ class ModelTests(unittest.TestCase):
     @unittest.skipUnless(utils.running_as_root(), "Must be run as root")
     def test_vm_serial(self):
         inst = model.Model(objstore_loc=self.tmp_store)
-        params = {'name': 'test', 'disks': [], 'cdrom': UBUNTU_ISO}
+        params = {'name': 'test', 'source_media': UBUNTU_ISO}
         inst.templates_create(params)
         with RollbackContext() as rollback:
             params = {'name': 'kimchi-serial',
@@ -350,7 +343,7 @@ class ModelTests(unittest.TestCase):
     def test_vm_ifaces(self):
         inst = model.Model(objstore_loc=self.tmp_store)
         with RollbackContext() as rollback:
-            params = {'name': 'test', 'disks': [], 'cdrom': UBUNTU_ISO}
+            params = {'name': 'test', 'source_media': UBUNTU_ISO}
             inst.templates_create(params)
             rollback.prependDefer(inst.template_delete, 'test')
 
@@ -466,7 +459,7 @@ class ModelTests(unittest.TestCase):
             inst.task_wait(task_id)
 
             vm_name = 'kimchi-cdrom'
-            params = {'name': 'test', 'disks': [], 'cdrom': UBUNTU_ISO}
+            params = {'name': 'test', 'disks': [], 'source_media': UBUNTU_ISO}
             inst.templates_create(params)
             rollback.prependDefer(inst.template_delete, 'test')
             params = {'name': vm_name,
@@ -510,7 +503,7 @@ class ModelTests(unittest.TestCase):
 
             vm_name = 'kimchi-ide-bus-vm'
             params = {'name': 'old_distro_template', 'disks': [],
-                      'cdrom': old_distro_iso}
+                      'source_media': old_distro_iso}
             inst.templates_create(params)
             rollback.prependDefer(inst.template_delete, 'old_distro_template')
             params = {
@@ -535,7 +528,7 @@ class ModelTests(unittest.TestCase):
         inst = model.Model(objstore_loc=self.tmp_store)
         with RollbackContext() as rollback:
             vm_name = 'kimchi-cdrom'
-            params = {'name': 'test', 'disks': [], 'cdrom': UBUNTU_ISO}
+            params = {'name': 'test', 'disks': [], 'source_media': UBUNTU_ISO}
             inst.templates_create(params)
             rollback.prependDefer(inst.template_delete, 'test')
             params = {'name': vm_name,
@@ -625,8 +618,9 @@ class ModelTests(unittest.TestCase):
 
         with RollbackContext() as rollback:
             params = {'name': 'test', 'disks': [{'size': 1, 'pool': {
-                'name': '/plugins/kimchi/storagepools/default'}}],
-                'cdrom': UBUNTU_ISO}
+                      'name': '/plugins/kimchi/storagepools/default'}}], 
+                      'source_media': UBUNTU_ISO}
+
             inst.templates_create(params)
             rollback.prependDefer(inst.template_delete, 'test')
 
@@ -684,8 +678,8 @@ class ModelTests(unittest.TestCase):
             rollback.prependDefer(self._restore_template_conf_file)
 
             params = {'name': 'test', 'disks': [{'size': 1, 'pool': {
-                'name': '/plugins/kimchi/storagepools/default'}}],
-                'cdrom': UBUNTU_ISO}
+                      'name': '/plugins/kimchi/storagepools/default'}}],
+                      'source_media': UBUNTU_ISO}
             inst.templates_create(params)
             rollback.prependDefer(inst.template_delete, 'test')
 
@@ -713,7 +707,8 @@ class ModelTests(unittest.TestCase):
             params = {'name': 'test', 'disks': [{
                 'size': 1, 'format': user_vol,
                 'pool': {'name': '/plugins/kimchi/storagepools/default'}}],
-                'cdrom': UBUNTU_ISO}
+                'source_media': UBUNTU_ISO}
+
             inst.templates_create(params)
             rollback.prependDefer(inst.template_delete, 'test')
 
@@ -737,8 +732,8 @@ class ModelTests(unittest.TestCase):
             rollback.prependDefer(self._restore_template_conf_file)
 
             params = {'name': 'test', 'disks': [{'size': 1, 'pool': {
-                'name': '/plugins/kimchi/storagepools/default'}}],
-                'cdrom': UBUNTU_ISO}
+                      'name': '/plugins/kimchi/storagepools/default'}}],
+                      'source_media': UBUNTU_ISO}
             inst.templates_create(params)
             rollback.prependDefer(inst.template_delete, 'test')
 
@@ -758,7 +753,7 @@ class ModelTests(unittest.TestCase):
         inst = model.Model(None, objstore_loc=self.tmp_store)
         orig_params = {'name': 'test',
                        'memory': {'current': 1024, 'maxmemory': 3072},
-                       'cdrom': UBUNTU_ISO}
+                       'source_media': UBUNTU_ISO}
         inst.templates_create(orig_params)
 
         with RollbackContext() as rollback:
@@ -793,10 +788,10 @@ class ModelTests(unittest.TestCase):
 
         # template disk format must be qcow2 because vmsnapshot
         # only supports this format
-        orig_params = {'name': 'test', 'memory': {'current': 1024},
-                       'cpu_info': {'vcpus': 1},
-                       'cdrom': UBUNTU_ISO,
-                       'disks': [{'size': 1, 'format': 'qcow2', 'pool': {
+        orig_params = {
+            'name': 'test', 'memory': {'current': 1024},
+            'cpu_info': {'vcpus': 1}, 'source_media': UBUNTU_ISO,
+             'disks': [{'size': 1, 'format': 'qcow2', 'pool': {
                            'name': '/plugins/kimchi/storagepools/default'}}]}
         inst.templates_create(orig_params)
 
@@ -1034,11 +1029,11 @@ class ModelTests(unittest.TestCase):
         inst = model.Model(objstore_loc=self.tmp_store)
 
         with RollbackContext() as rollback:
-            params = {'name': u'test', 'disks': [], 'cdrom': UBUNTU_ISO}
+            params = {'name': u'test', 'source_media': UBUNTU_ISO}
             inst.templates_create(params)
             rollback.prependDefer(inst.template_delete, 'test')
 
-            params = {'name': u'kīмсhī-∨м',
+            params = {'name': u'kīмсhī-∨м', 'disks': [],
                       'template': u'/plugins/kimchi/templates/test'}
             task = inst.vms_create(params)
             inst.task_wait(task['id'])
@@ -1060,11 +1055,11 @@ class ModelTests(unittest.TestCase):
         inst = model.Model(objstore_loc=self.tmp_store)
 
         with RollbackContext() as rollback:
-            params = {'name': 'test', 'disks': [], 'cdrom': UBUNTU_ISO}
+            params = {'name': 'test', 'source_media': UBUNTU_ISO}
             inst.templates_create(params)
             rollback.prependDefer(inst.template_delete, 'test')
 
-            params = {'name': 'kimchi-vm',
+            params = {'name': 'kimchi-vm', 'disks': [],
                       'template': '/plugins/kimchi/templates/test'}
             task = inst.vms_create(params)
             inst.task_wait(task['id'])
@@ -1131,10 +1126,10 @@ class ModelTests(unittest.TestCase):
         with RollbackContext() as rollback:
             params = {
                 'name': 'test',
-                'disks': [],
-                'cdrom': UBUNTU_ISO,
+                'source_media': UBUNTU_ISO,
                 'domain': 'test',
-                'arch': 'i686'
+                'arch': 'i686',
+                'disks': []
             }
 
             _setDiskPoolDefaultTest()
diff --git a/tests/test_rest.py b/tests/test_rest.py
index d0d2fcf..395ee47 100644
--- a/tests/test_rest.py
+++ b/tests/test_rest.py
@@ -107,7 +107,7 @@ class RestTests(unittest.TestCase):
         self.assertEquals(1, len(vms))
 
         # Create a template as a base for our VMs
-        req = json.dumps({'name': 'test', 'cdrom': fake_iso})
+        req = json.dumps({'name': 'test', 'source_media': fake_iso})
         resp = self.request('/plugins/kimchi/templates', req, 'POST')
         self.assertEquals(201, resp.status)
 
@@ -134,7 +134,7 @@ class RestTests(unittest.TestCase):
         self.assertEquals([], vm['groups'])
 
     def test_edit_vm(self):
-        req = json.dumps({'name': 'test', 'cdrom': fake_iso})
+        req = json.dumps({'name': 'test', 'source_media': fake_iso})
         resp = self.request('/plugins/kimchi/templates', req, 'POST')
         self.assertEquals(201, resp.status)
 
@@ -291,9 +291,9 @@ class RestTests(unittest.TestCase):
 
     def test_vm_lifecycle(self):
         # Create a Template
-        req = json.dumps({'name': 'test', 'disks': DISKS,
-                          'icon': 'plugins/kimchi/images/icon-debian.png',
-                          'cdrom': fake_iso})
+        req = json.dumps({'name': 'test', 'source_media': fake_iso,
+                          'disks': DISKS, 
+                          'icon': 'plugins/kimchi/images/icon-debian.png'})
         resp = self.request('/plugins/kimchi/templates', req, 'POST')
         self.assertEquals(201, resp.status)
 
@@ -518,7 +518,7 @@ class RestTests(unittest.TestCase):
 
     def test_vm_graphics(self):
         # Create a Template
-        req = json.dumps({'name': 'test', 'cdrom': fake_iso})
+        req = json.dumps({'name': 'test', 'source_media': fake_iso})
         resp = self.request('/plugins/kimchi/templates', req, 'POST')
         self.assertEquals(201, resp.status)
 
@@ -612,7 +612,7 @@ class RestTests(unittest.TestCase):
 
         with RollbackContext() as rollback:
             # Create a template as a base for our VMs
-            req = json.dumps({'name': 'test', 'cdrom': fake_iso})
+            req = json.dumps({'name': 'test', 'source_media': fake_iso})
             resp = self.request('/plugins/kimchi/templates', req, 'POST')
             self.assertEquals(201, resp.status)
             # Delete the template
@@ -785,7 +785,7 @@ class RestTests(unittest.TestCase):
 
         with RollbackContext() as rollback:
             # Create a template as a base for our VMs
-            req = json.dumps({'name': 'test', 'cdrom': fake_iso})
+            req = json.dumps({'name': 'test', 'source_media': fake_iso})
             resp = self.request('/plugins/kimchi/templates', req, 'POST')
             self.assertEquals(201, resp.status)
             # Delete the template
@@ -891,8 +891,7 @@ class RestTests(unittest.TestCase):
 
     def test_vm_customise_storage(self):
         # Create a Template
-        req = json.dumps({'name': 'test', 'cdrom': fake_iso,
-                                          'disks': DISKS})
+        req = json.dumps({'name': 'test', 'disks': DISKS, 'source_media': fake_iso})
         resp = self.request('/plugins/kimchi/templates', req, 'POST')
         self.assertEquals(201, resp.status)
 
@@ -954,8 +953,9 @@ class RestTests(unittest.TestCase):
 
         # Create template fails because SCSI volume is missing
         tmpl_params = {
-            'name': 'test_fc_pool', 'cdrom': fake_iso, 'disks': [{'pool': {
-                'name': '/plugins/kimchi/storagepools/scsi_fc_pool'}}]}
+            'name': 'test_fc_pool', 'source_media': fake_iso, 
+            'disks': [{'pool': 
+                {'name': '/plugins/kimchi/storagepools/scsi_fc_pool'}}]}
 
         req = json.dumps(tmpl_params)
         resp = self.request('/plugins/kimchi/templates', req, 'POST')
@@ -998,7 +998,7 @@ class RestTests(unittest.TestCase):
 
     def test_unnamed_vms(self):
         # Create a Template
-        req = json.dumps({'name': 'test', 'cdrom': fake_iso})
+        req = json.dumps({'name': 'test', 'source_media': fake_iso})
         resp = self.request('/plugins/kimchi/templates', req, 'POST')
         self.assertEquals(201, resp.status)
 
@@ -1039,10 +1039,8 @@ class RestTests(unittest.TestCase):
 
         # Create a Template
         mock_base = '/tmp/mock.img'
-        open(mock_base, 'w').close()
-        disks = copy.deepcopy(DISKS)
-        disks[0]['base'] = mock_base
-        req = json.dumps({'name': 'test', 'disks': disks})
+        os.system("qemu-img create -f qcow2 %s 10M" % mock_base)
+        req = json.dumps({'name': 'test', 'source_media': mock_base})
         resp = self.request('/plugins/kimchi/templates', req, 'POST')
         self.assertEquals(201, resp.status)
 
@@ -1112,7 +1110,7 @@ class RestTests(unittest.TestCase):
         # In real model os distro/version can be omitted
         # as we will scan the iso
         req = json.dumps({'name': 'test',
-                          'cdrom': storagevolume['path'],
+                          'source_media': storagevolume['path'],
                           'os_distro': storagevolume['os_distro'],
                           'os_version': storagevolume['os_version']})
         resp = self.request('/plugins/kimchi/templates', req, 'POST')
@@ -1150,7 +1148,7 @@ class RestTests(unittest.TestCase):
 
     def test_screenshot_refresh(self):
         # Create a VM
-        req = json.dumps({'name': 'test', 'cdrom': fake_iso})
+        req = json.dumps({'name': 'test', 'source_media': fake_iso})
         resp = self.request('/plugins/kimchi/templates', req, 'POST')
         req = json.dumps({'name': 'test-vm',
                           'template': '/plugins/kimchi/templates/test'})
diff --git a/tests/test_template.py b/tests/test_template.py
index fcb2e46..6fd936c 100644
--- a/tests/test_template.py
+++ b/tests/test_template.py
@@ -18,6 +18,7 @@
 # License along with this library; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
 
+import iso_gen
 import json
 import os
 import psutil
@@ -38,7 +39,7 @@ host = None
 port = None
 ssl_port = None
 cherrypy_port = None
-
+MOCK_ISO = "/tmp/mock.iso"
 DEFAULT_POOL = u'/plugins/kimchi/storagepools/default-pool'
 
 
@@ -53,6 +54,7 @@ def setUpModule():
     cherrypy_port = get_free_port('cherrypy_port')
     test_server = run_server(host, port, ssl_port, test_mode=True,
                              cherrypy_port=cherrypy_port, model=model)
+    iso_gen.construct_fake_iso(MOCK_ISO, True, '14.04', 'ubuntu')
 
 
 def tearDownModule():
@@ -79,7 +81,7 @@ class TemplateTests(unittest.TestCase):
         self.assertEquals(400, resp.status)
 
         # Create a template
-        t = {'name': 'test', 'cdrom': '/tmp/mock.iso'}
+        t = {'name': 'test', 'source_media': MOCK_ISO}
         req = json.dumps(t)
         resp = self.request('/plugins/kimchi/templates', req, 'POST')
         self.assertEquals(201, resp.status)
@@ -117,24 +119,23 @@ class TemplateTests(unittest.TestCase):
         self.assertEquals(204, resp.status)
 
         # Create a template with same name fails with 400
-        req = json.dumps({'name': 'test', 'cdrom': '/tmp/mock.iso'})
+        req = json.dumps({'name': 'test', 'source_media': MOCK_ISO})
         resp = self.request('/plugins/kimchi/templates', req, 'POST')
         self.assertEquals(400, resp.status)
 
         # Create an image based template
-        open('/tmp/mock.img', 'w').close()
-        t = {'name': 'test_img_template', 'disks': [{
-            'base': '/tmp/mock.img', 'format': 'qcow2',
-            'pool': {'name': DEFAULT_POOL}, 'size': 1}]}
+        os.system("qemu-img create -f qcow2 %s 10G" % '/tmp/mock.img')
+        t = {'name': 'test_img_template', 'source_media': '/tmp/mock.img'}
         req = json.dumps(t)
         resp = self.request('/plugins/kimchi/templates', req, 'POST')
         self.assertEquals(201, resp.status)
         os.remove('/tmp/mock.img')
 
         # Test disk format
-        t = {'name': 'test-format', 'cdrom': '/tmp/mock.iso', 'disks': [{
-             'index': 0, 'size': 10, 'format': 'vmdk', 'pool': {
+        t = {'name': 'test-format', 'source_media': MOCK_ISO, 'disks': [{
+             'size': 10, 'format': 'vmdk', 'pool': {
                  'name': DEFAULT_POOL}}]}
+
         req = json.dumps(t)
         resp = self.request('/plugins/kimchi/templates', req, 'POST')
         self.assertEquals(201, resp.status)
@@ -149,7 +150,7 @@ class TemplateTests(unittest.TestCase):
         else:
             max_mem = (psutil.TOTAL_PHYMEM >> 10 >> 10)
         memory = max_mem + 1024
-        t = {'name': 'test-maxmem', 'cdrom': '/tmp/mock.iso',
+        t = {'name': 'test-maxmem', 'source_media': MOCK_ISO,
              'memory': {'current': memory}}
         req = json.dumps(t)
         resp = self.request('/plugins/kimchi/templates', req, 'POST')
@@ -158,7 +159,7 @@ class TemplateTests(unittest.TestCase):
 
     def test_customized_tmpl(self):
         # Create a template
-        t = {'name': 'test', 'cdrom': '/tmp/mock.iso'}
+        t = {'name': 'test', 'source_media': MOCK_ISO}
         req = json.dumps(t)
         resp = self.request('/plugins/kimchi/templates', req, 'POST')
         self.assertEquals(201, resp.status)
@@ -328,7 +329,7 @@ class TemplateTests(unittest.TestCase):
 
     def test_customized_network(self):
         # Create a template
-        t = {'name': 'test', 'cdrom': '/tmp/mock.iso'}
+        t = {'name': 'test', 'source_media': MOCK_ISO}
         req = json.dumps(t)
         resp = self.request('/plugins/kimchi/templates', req, 'POST')
         self.assertEquals(201, resp.status)
@@ -364,7 +365,7 @@ class TemplateTests(unittest.TestCase):
 
     def test_customized_storagepool(self):
         # Create a template
-        t = {'name': 'test', 'cdrom': '/tmp/mock.iso'}
+        t = {'name': 'test', 'source_media': MOCK_ISO}
         req = json.dumps(t)
         resp = self.request('/plugins/kimchi/templates', req, 'POST')
         self.assertEquals(201, resp.status)
@@ -442,6 +443,8 @@ class TemplateTests(unittest.TestCase):
                           sorted(tmpl['disks'][0].values()))
 
     def test_tmpl_integrity(self):
+        mock_iso2 = "/tmp/mock2.iso"
+        iso_gen.construct_fake_iso(mock_iso2, True, '14.04', 'ubuntu')
         # Create a network and a pool for testing template integrity
         net = {'name': u'nat-network', 'connection': 'nat'}
         self.request('/plugins/kimchi/networks', json.dumps(net), 'POST')
@@ -453,9 +456,8 @@ class TemplateTests(unittest.TestCase):
         self.request(pool_uri + '/activate', '{}', 'POST')
 
         # Create a template using the custom network and pool
-        t = {'name': 'test', 'cdrom': '/tmp/mock.iso',
-             'networks': ['nat-network'],
-             'disks': [{'pool': {
+        t = {'name': 'test', 'source_media': mock_iso2, 
+             'networks': ['nat-network'], 'disks': [{'pool': {
                  'name': '/plugins/kimchi/storagepools/dir-pool'},
                  'size': 2,
                  'format': 'qcow2'}]}
@@ -484,5 +486,6 @@ class TemplateTests(unittest.TestCase):
         self.assertEquals(400, resp.status)
 
         # Verify the template
+        os.remove(mock_iso2)
         res = json.loads(self.request('/plugins/kimchi/templates/test').read())
-        self.assertEquals(res['invalid']['cdrom'], ['/tmp/mock.iso'])
+        self.assertEquals(res['invalid']['cdrom'], [mock_iso2])
diff --git a/tests/test_vmtemplate.py b/tests/test_vmtemplate.py
index eed58b0..503d34a 100644
--- a/tests/test_vmtemplate.py
+++ b/tests/test_vmtemplate.py
@@ -17,6 +17,7 @@
 # License along with this library; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
 
+import iso_gen
 import os
 import psutil
 import unittest
@@ -36,7 +37,7 @@ DISKS = [{'size': 10, 'format': 'raw', 'index': 0, 'pool': {'name':
 class VMTemplateTests(unittest.TestCase):
     def setUp(self):
         self.iso = '/tmp/mock.iso'
-        open(self.iso, 'w').close()
+        iso_gen.construct_fake_iso(self.iso, True, '12.04', 'ubuntu')
 
     def tearDown(self):
         os.unlink(self.iso)
-- 
2.5.5

    