Add a new example test that will patch utils and os

functions so that they can be 'retargeted' to a temporary
directory, which allows us the ability to run a full set
of cloud-init stages.

Neat things:

1. All cloud-init code is unchanged (as long as it goes
   through the utils functions for most functionality)
2. Allows for a natural way to setup a temporary directory
   then patch the new directory as the new 'root' and then
   run cloud-init stages and then check the contents of 
   what was placed as desired.

1 files changed, 89 insertions, 0 deletions

diff --git a/tests/unittests/test_runs/test_simple_run.py b/tests/unittests/test_runs/test_simple_run.py
new file mode 100644
index 00000000..33dd3ca2
--- /dev/null
+++ b/tests/unittests/test_runs/test_simple_run.py
@@ -0,0 +1,89 @@
+from mocker import MockerTestCase
+
+import mocker
+import sys
+import os
+
+# Allow running this test individually
+top_dir = os.path.join(os.path.dirname(__file__), os.pardir, "helpers.py")
+top_dir = os.path.abspath(top_dir)
+if os.path.exists(top_dir):
+    sys.path.insert(0, os.path.dirname(top_dir))
+
+
+import helpers
+
+from cloudinit import util
+from cloudinit import stages
+
+from cloudinit.settings import (PER_INSTANCE)
+
+
+class TestSimpleRunDistro(helpers.FilesystemMockingTestCase):
+    def _patchIn(self, root):
+        self.restore()
+        self.patchOS(root)
+        self.patchUtils(root)
+
+    def _pp_root(self, root, repatch=True):
+        self.restore()
+        for (dirpath, dirnames, filenames) in os.walk(root):
+            print(dirpath)
+            for f in filenames:
+                joined = os.path.join(dirpath, f)
+                if os.path.islink(joined):
+                    print("f %s - (symlink)" % (f))
+                else:
+                    print("f %s" % (f))
+            for d in dirnames:
+                joined = os.path.join(dirpath, d)
+                if os.path.islink(joined):
+                    print("d %s - (symlink)" % (d))
+                else:
+                    print("d %s" % (d))
+        if repatch:
+            self._patchIn(root)
+
+    def test_none_ds(self):
+        new_root = self.makeDir()
+        self.replicateTestRoot('simple_ubuntu', new_root)
+        cfg = {
+            'datasource_list': ['None'],
+            'write_files': [{
+                    'path': '/etc/blah.ini',
+                    'content': 'blah',
+                    'permissions': 0755,
+            }],
+            'cloud_init_modules': ['write-files'],
+        }
+        cloud_cfg = util.yaml_dumps(cfg)
+        util.ensure_dir(os.path.join(new_root, 'etc', 'cloud'))
+        util.write_file(os.path.join(new_root, 'etc',
+                                     'cloud', 'cloud.cfg'), cloud_cfg)
+        self._patchIn(new_root)
+
+        # Now start verifying whats created
+        initer = stages.Init()
+        initer.read_cfg()
+        initer.initialize()
+        self.assertTrue(os.path.exists("/var/lib/cloud"))
+        for d in ['scripts', 'seed', 'instances', 'handlers', 'sem', 'data']:
+            self.assertTrue(os.path.isdir(os.path.join("/var/lib/cloud", d)))
+
+        initer.fetch()
+        iid = initer.instancify()
+        self.assertEquals(iid, 'iid-datasource-none')
+        initer.update()
+        self.assertTrue(os.path.islink("var/lib/cloud/instance"))
+
+        (ran, results) = initer.cloudify().run('consume_userdata',
+                                               initer.consume_userdata,
+                                               args=[PER_INSTANCE],
+                                               freq=PER_INSTANCE)
+
+        mods = stages.Modules(initer)
+        (which_ran, failures) = mods.run_section('cloud_init_modules')
+        self.assertTrue(os.path.exists('/etc/blah.ini'))
+        self.assertIn('write-files', which_ran)
+        contents = util.load_file('/etc/blah.ini')
+        self.assertEquals(contents, 'blah')