vagrant-salt 0.3.2 → 0.4.0

data/scripts/tests/README.rst

@@ -0,0 +1,38 @@
+Salt Bootstrap Script - Integration Testing
+===========================================
+
+Testing ``salt-bootstrap`` requires both Python and Perl.
+
+Yes, it's weird that a shell script uses either one of the above languages for testing itself, the 
+explanation though, is simple.
+
+Perl is required because we use a script, `checkbashisms`_, which does exactly what it's name says. 
+In our case, it tries it's best to find non ``POSIX`` compliant code in our bootstrap script since 
+we require the script to be able to properly execute in any ``POSIX`` compliant shell.
+
+Python is used in the integration tests. It greatly simplifies running these tests and can even 
+provide some JUnit compliant XML used to generate reports of those tests. Doing this job in shell 
+scripting would be too cumbersome and too complicated.
+
+Running the tests suite
+-----------------------
+
+.. warning:: The test suite is **destructive**. It will install/un-install packages on your system.
+ You must run the suite using ``sudo`` or most / all of the tests will be skipped.
+
+Running the tests suite is as simple as:
+
+.. code:: console
+
+  sudo python tests/runtests.py
+
+For additional information on the available options:
+
+.. code:: console
+
+  python tests/runtests.py --help
+
+
+
+.. _`checkbashisms`: http://sourceforge.net/projects/checkbaskisms/
+.. vim: fenc=utf-8 spell spl=en cc=100 tw=99 fo=want sts=2 sw=2 et

data/scripts/tests/bootstrap/__init__.py

@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+"""
+    bootstrap
+    ~~~~~~~~~
+
+    salt-bootstrap script unittesting
+
+    :codeauthor: :email:`Pedro Algarvio (pedro@algarvio.me)`
+    :copyright: © 2013 by the SaltStack Team, see AUTHORS for more details.
+    :license: Apache 2.0, see LICENSE for more details.
+"""

data/scripts/tests/bootstrap/ext/console.py

@@ -0,0 +1,100 @@
+# -*- coding: utf-8 -*-
+# vim: sw=4 ts=4 fenc=utf-8
+'''
+getTerminalSize()
+ - get width and height of console
+ - works on linux,os x,windows,cygwin(windows)
+ - taken from http://stackoverflow.com/questions/566746/how-to-get-console-window-width-in-python
+'''
+
+# Import python libs
+import os
+import platform
+import struct
+import ctypes
+import subprocess
+import fcntl
+import termios
+
+__all__ = ['getTerminalSize']
+
+
+def getTerminalSize():
+   current_os = platform.system()
+   tuple_xy=None
+   if current_os == 'Windows':
+       tuple_xy = _getTerminalSize_windows()
+       if tuple_xy is None:
+          tuple_xy = _getTerminalSize_tput()
+          # needed for window's python in cygwin's xterm!
+   if current_os == 'Linux' or current_os == 'Darwin' or current_os.startswith('CYGWIN'):
+       tuple_xy = _getTerminalSize_linux()
+   if tuple_xy is None:
+       print 'default'
+       tuple_xy = (80, 25)      # default value
+   return tuple_xy
+
+
+def _getTerminalSize_windows():
+    res=None
+    try:
+        # stdin handle is -10
+        # stdout handle is -11
+        # stderr handle is -12
+
+        h = ctypes.windll.kernel32.GetStdHandle(-12)
+        csbi = ctypes.create_string_buffer(22)
+        res = ctypes.windll.kernel32.GetConsoleScreenBufferInfo(h, csbi)
+    except Exception:
+        return None
+    if res:
+        (bufx, bufy, curx, cury, wattr,
+         left, top, right, bottom, maxx, maxy) = struct.unpack('hhhhHhhhhhh', csbi.raw)
+        sizex = right - left + 1
+        sizey = bottom - top + 1
+        return sizex, sizey
+    else:
+        return None
+
+
+def _getTerminalSize_tput():
+    # get terminal width
+    # src: http://stackoverflow.com/questions/263890/how-do-i-find-the-width-height-of-a-terminal-window
+    try:
+       proc=subprocess.Popen(['tput', 'cols'],stdin=subprocess.PIPE,stdout=subprocess.PIPE)
+       output=proc.communicate(input=None)
+       cols=int(output[0])
+       proc=subprocess.Popen(['tput', 'lines'],stdin=subprocess.PIPE,stdout=subprocess.PIPE)
+       output=proc.communicate(input=None)
+       rows=int(output[0])
+       return (cols,rows)
+    except Exception:
+       return None
+
+
+def _getTerminalSize_linux():
+    def ioctl_GWINSZ(fd):
+        try:
+            cr = struct.unpack('hh', fcntl.ioctl(fd, termios.TIOCGWINSZ,'1234'))
+        except Exception:
+            return None
+        return cr
+    cr = ioctl_GWINSZ(0) or ioctl_GWINSZ(1) or ioctl_GWINSZ(2)
+    if not cr:
+        try:
+            fd = os.open(os.ctermid(), os.O_RDONLY)
+            cr = ioctl_GWINSZ(fd)
+            os.close(fd)
+        except Exception:
+            pass
+    if not cr:
+        try:
+            cr = (os.environ['LINES'], os.environ['COLUMNS'])
+        except Exception:
+            return None
+    return int(cr[1]), int(cr[0])
+
+
+if __name__ == '__main__':
+    sizex,sizey=getTerminalSize()
+    print  'width =',sizex,'height =',sizey

data/scripts/tests/bootstrap/ext/os_data.py

@@ -0,0 +1,199 @@
+'''
+This file was copied and adapted from salt's source code
+'''
+
+import os
+import re
+import sys
+import platform
+# Extend the default list of supported distros. This will be used for the
+# /etc/DISTRO-release checking that is part of platform.linux_distribution()
+from platform import _supported_dists
+_supported_dists += ('arch', 'mageia', 'meego', 'vmware', 'bluewhite64',
+                     'slamd64', 'ovs', 'system', 'mint', 'oracle')
+
+_REPLACE_LINUX_RE = re.compile(r'linux', re.IGNORECASE)
+
+# This maps (at most) the first ten characters (no spaces, lowercased) of
+# 'osfullname' to the 'os' grain that Salt traditionally uses.
+# Please see os_data() and _supported_dists.
+# If your system is not detecting properly it likely needs an entry here.
+_OS_NAME_MAP = {
+    'redhatente': 'RedHat',
+    'gentoobase': 'Gentoo',
+    'archarm': 'Arch ARM',
+    'arch': 'Arch',
+    'debian': 'Debian',
+    'debiangnu/': 'Debian',
+    'fedoraremi': 'Fedora',
+    'amazonami': 'Amazon',
+    'alt': 'ALT',
+    'oracleserv': 'OEL',
+}
+
+# Map the 'os' grain to the 'os_family' grain
+# These should always be capitalized entries as the lookup comes
+# post-_OS_NAME_MAP. If your system is having trouble with detection, please
+# make sure that the 'os' grain is capitalized and working correctly first.
+_OS_FAMILY_MAP = {
+    'Ubuntu': 'Debian',
+    'Fedora': 'RedHat',
+    'CentOS': 'RedHat',
+    'GoOSe': 'RedHat',
+    'Scientific': 'RedHat',
+    'Amazon': 'RedHat',
+    'CloudLinux': 'RedHat',
+    'OVS': 'RedHat',
+    'OEL': 'RedHat',
+    'Mandrake': 'Mandriva',
+    'ESXi': 'VMWare',
+    'Mint': 'Debian',
+    'VMWareESX': 'VMWare',
+    'Bluewhite64': 'Bluewhite',
+    'Slamd64': 'Slackware',
+    'SLES': 'Suse',
+    'SUSE Enterprise Server': 'Suse',
+    'SUSE Enterprise Server': 'Suse',
+    'SLED': 'Suse',
+    'openSUSE': 'Suse',
+    'SUSE': 'Suse',
+    'Solaris': 'Solaris',
+    'SmartOS': 'Solaris',
+    'Arch ARM': 'Arch',
+    'ALT': 'RedHat',
+    'Trisquel': 'Debian'
+}
+
+
+def os_data():
+    '''
+    Return grains pertaining to the operating system
+    '''
+    grains = {
+        'num_gpus': 0,
+        'gpus': [],
+    }
+
+    # Windows Server 2008 64-bit
+    # ('Windows', 'MINIONNAME', '2008ServerR2', '6.1.7601', 'AMD64', 'Intel64 Fam ily 6 Model 23 Stepping 6, GenuineIntel')
+    # Ubuntu 10.04
+    # ('Linux', 'MINIONNAME', '2.6.32-38-server', '#83-Ubuntu SMP Wed Jan 4 11:26:59 UTC 2012', 'x86_64', '')
+    (grains['kernel'], grains['nodename'],
+     grains['kernelrelease'], version, grains['cpuarch'], _) = platform.uname()
+    if sys.platform.startswith('win'):
+        grains['osrelease'] = grains['kernelrelease']
+        grains['osversion'] = grains['kernelrelease'] = version
+        grains['os'] = 'Windows'
+        grains['os_family'] = 'Windows'
+        return grains
+    elif sys.platform.startswith('linux'):
+        # Add lsb grains on any distro with lsb-release
+        try:
+            import lsb_release
+            release = lsb_release.get_distro_information()
+            for key, value in release.iteritems():
+                grains['lsb_{0}'.format(key.lower())] = value  # override /etc/lsb-release
+        except ImportError:
+            # if the python library isn't available, default to regex
+            if os.path.isfile('/etc/lsb-release'):
+                with open('/etc/lsb-release') as ifile:
+                    for line in ifile:
+                        # Matches any possible format:
+                        # DISTRIB_ID="Ubuntu"
+                        # DISTRIB_ID='Mageia'
+                        # DISTRIB_ID=Fedora
+                        # DISTRIB_RELEASE='10.10'
+                        # DISTRIB_CODENAME='squeeze'
+                        # DISTRIB_DESCRIPTION='Ubuntu 10.10'
+                        regex = re.compile('^(DISTRIB_(?:ID|RELEASE|CODENAME|DESCRIPTION))=(?:\'|")?([\w\s\.-_]+)(?:\'|")?')
+                        match = regex.match(line.rstrip('\n'))
+                        if match:
+                            # Adds: lsb_distrib_{id,release,codename,description}
+                            grains['lsb_{0}'.format(match.groups()[0].lower())] = match.groups()[1].rstrip()
+            elif os.path.isfile('/etc/os-release'):
+                # Arch ARM linux
+                with open('/etc/os-release') as ifile:
+                    # Imitate lsb-release
+                    for line in ifile:
+                        # NAME="Arch Linux ARM"
+                        # ID=archarm
+                        # ID_LIKE=arch
+                        # PRETTY_NAME="Arch Linux ARM"
+                        # ANSI_COLOR="0;36"
+                        # HOME_URL="http://archlinuxarm.org/"
+                        # SUPPORT_URL="https://archlinuxarm.org/forum"
+                        # BUG_REPORT_URL="https://github.com/archlinuxarm/PKGBUILDs/issues"
+                        regex = re.compile('^([\w]+)=(?:\'|")?([\w\s\.-_]+)(?:\'|")?')
+                        match = regex.match(line.rstrip('\n'))
+                        if match:
+                            name, value = match.groups()
+                            if name.lower() == 'name':
+                                grains['lsb_distrib_id'] = value.strip()
+            elif os.path.isfile('/etc/altlinux-release'):
+                # ALT Linux
+                grains['lsb_distrib_id'] = 'altlinux'
+                with open('/etc/altlinux-release') as ifile:
+                    # This file is symlinked to from:
+                    # /etc/fedora-release
+                    # /etc/redhat-release
+                    # /etc/system-release
+                    for line in ifile:
+                        # ALT Linux Sisyphus (unstable)
+                        comps = line.split()
+                        if comps[0] == 'ALT':
+                            grains['lsb_distrib_release'] = comps[2]
+                            grains['lsb_distrib_codename'] = \
+                                comps[3].replace('(', '').replace(')', '')
+        # Use the already intelligent platform module to get distro info
+        (osname, osrelease, oscodename) = platform.linux_distribution(
+            supported_dists=_supported_dists)
+        # Try to assign these three names based on the lsb info, they tend to
+        # be more accurate than what python gets from /etc/DISTRO-release.
+        # It's worth noting that Ubuntu has patched their Python distribution
+        # so that platform.linux_distribution() does the /etc/lsb-release
+        # parsing, but we do it anyway here for the sake for full portability.
+        grains['osfullname'] = grains.get('lsb_distrib_id', osname).strip()
+        grains['osrelease'] = grains.get('lsb_distrib_release', osrelease).strip()
+        grains['oscodename'] = grains.get('lsb_distrib_codename', oscodename).strip()
+        distroname = _REPLACE_LINUX_RE.sub('', grains['osfullname']).strip()
+        # return the first ten characters with no spaces, lowercased
+        shortname = distroname.replace(' ', '').lower()[:10]
+        # this maps the long names from the /etc/DISTRO-release files to the
+        # traditional short names that Salt has used.
+        grains['os'] = _OS_NAME_MAP.get(shortname, distroname)
+    elif grains['kernel'] == 'SunOS':
+        grains['os'] = 'Solaris'
+        if os.path.isfile('/etc/release'):
+            with open('/etc/release', 'r') as fp_:
+                rel_data = fp_.read()
+                if 'SmartOS' in rel_data:
+                    grains['os'] = 'SmartOS'
+        #grains.update(_sunos_cpudata(grains))
+    elif grains['kernel'] == 'VMkernel':
+        grains['os'] = 'ESXi'
+    elif grains['kernel'] == 'Darwin':
+        grains['os'] = 'MacOS'
+    #    grains.update(_bsd_cpudata(grains))
+    else:
+        grains['os'] = grains['kernel']
+    if grains['kernel'] in ('FreeBSD', 'OpenBSD'):
+        grains['os'] = grains['kernel']
+        grains['os_family'] = grains['os']
+        grains['osfullname'] = "{0} {1}".format(grains['kernel'], grains['kernelrelease'])
+        grains['osrelease'] = grains['kernelrelease']
+    #    grains.update(_bsd_cpudata(grains))
+    if not grains['os']:
+        grains['os'] = 'Unknown {0}'.format(grains['kernel'])
+        grains['os_family'] = 'Unknown'
+    else:
+        # this assigns family names based on the os name
+        # family defaults to the os name if not found
+        grains['os_family'] = _OS_FAMILY_MAP.get(grains['os'], grains['os'])
+
+    return grains
+
+GRAINS = os_data()
+
+if __name__ == '__main__':
+    import pprint
+    pprint.pprint(GRAINS)

data/scripts/tests/bootstrap/test_install.py

@@ -0,0 +1,586 @@
+# -*- coding: utf-8 -*-
+'''
+    bootstrap.test_install
+    ~~~~~~~~~~~~~~~~~~~~~~
+
+    Run installation tests.
+
+    :codeauthor: :email:`Pedro Algarvio (pedro@algarvio.me)`
+    :copyright: © 2013 by the SaltStack Team, see AUTHORS for more details.
+    :license: Apache 2.0, see LICENSE for more details.
+'''
+
+import glob
+import shutil
+from bootstrap.unittesting import *
+
+
+CLEANUP_COMMANDS_BY_OS_FAMILY = {
+    'Arch': [
+        'pacman -Qs python2-crypto && pacman -Rsc --noconfirm python2-crypto && exit $? || exit 0',
+        'pacman -Qs python2-distribute && pacman -Rsc --noconfirm python2-distribute && exit $? || exit 0',
+        'pacman -Qs python2-jinja && pacman -Rsc --noconfirm python2-jinja && exit $? || exit 0',
+        'pacman -Qs python2-m2crypto && pacman -Rsc --noconfirm python2-m2crypto && exit $? || exit 0',
+        'pacman -Qs python2-markupsafe && pacman -Rsc --noconfirm python2-markupsafe && exit $? || exit 0',
+        'pacman -Qs python2-msgpack && pacman -Rsc --noconfirm python2-msgpack && exit $? || exit 0',
+        'pacman -Qs python2-psutil && pacman -Rsc --noconfirm python2-psutil && exit $? || exit 0',
+        'pacman -Qs python2-pyzmq && pacman -Rsc --noconfirm python2-pyzmq && exit $? || exit 0',
+        'pacman -Qs zeromq && pacman -Rsc --noconfirm zeromq && exit $? || exit 0',
+    ],
+    'Debian': [
+        'apt-get remove -y -o DPkg::Options::=--force-confold '
+        '--purge salt-master salt-minion salt-syndic python-crypto '
+        'python-jinja2 python-m2crypto python-yaml msgpack-python python-zmq',
+        'apt-get autoremove -y -o DPkg::Options::=--force-confold --purge',
+        'rm -rf /etc/apt/sources.list.d/saltstack-salt-*'
+    ],
+    'RedHat': [
+        'yum -y remove salt-minion salt-master',
+        'yum -y remove python{0}-m2crypto m2crypto python{0}-crypto '
+        'python{0}-msgpack python{0}-zmq python{0}-jinja2'.format(
+            GRAINS['osrelease'].split('.')[0] == '5' and '26' or ''
+        ),
+    ],
+    'FreeBSD': [
+        'pkg delete -y swig sysutils/py-salt',
+        'pkg autoremove -y'
+    ],
+    'Solaris': [
+        'pkgin -y rm libtool-base autoconf automake libuuid gcc-compiler '
+        'gmake py27-setuptools py27-yaml py27-crypto swig',
+        'svcs network/salt-minion >/dev/null 2>&1 && svcadm disable network/salt-minion >/dev/null 2>&1 || exit 0',
+        'svcs network/salt-minion >/dev/null 2>&1 && svccfg delete network/salt-minion >/dev/null 2>&1 || exit 0',
+        'svcs network/salt-master >/dev/null 2>&1 && svcadm disable network/salt-master >/dev/null 2>&1 || exit 0',
+        'svcs network/salt-master >/dev/null 2>&1 && svccfg delete network/salt-master >/dev/null 2>&1 || exit 0',
+        'svcs network/salt-syndic >/dev/null 2>&1 && svcadm disable network/salt-syndic >/dev/null 2>&1 || exit 0',
+        'svcs network/salt-syndic >/dev/null 2>&1 && svccfg delete network/salt-syndic >/dev/null 2>&1 || exit 0'
+    ],
+    'Suse': [
+        '(zypper --non-interactive se -i salt-master || exit 0 && zypper --non-interactive remove salt-master && exit 0) || '
+        '(rpm -q salt-master && rpm -e --noscripts salt-master || exit 0)',
+        '(zypper --non-interactive se -i salt-minion || exit 0 && zypper --non-interactive remove salt-minion && exit 0) || '
+        '(rpm -q salt-minion && rpm -e --noscripts salt-minion || exit 0)',
+        '(zypper --non-interactive se -i salt-syndic || exit 0 && zypper --non-interactive remove salt-syndic && exit 0) || '
+        '(rpm -q salt-syndic && rpm -e --noscripts salt-syndic || exit 0)',
+        '(zypper --non-interactive se -i salt || exit 0 && zypper --non-interactive remove salt && exit 0) || '
+        '(rpm -q salt && rpm -e --noscripts salt || exit 0)',
+        'pip uninstall -y salt >/dev/null 2>&1 || exit 0',
+        'pip uninstall -y PyYaml >/dev/null 2>&1 || exit 0',
+        'zypper --non-interactive remove libzmq3 python-Jinja2 '
+        'python-M2Crypto python-PyYAML python-msgpack-python '
+        'python-pycrypto python-pyzmq',
+    ]
+}
+
+OS_REQUIRES_PIP_ALLOWED = (
+    # Some distributions can only install salt or some of its dependencies
+    # passing -P to the bootstrap script.
+    # The GRAINS['os'] which are in this list, requires that extra argument.
+    'Debian',
+    'SmartOS',
+    'Suse'  # Need to revisit openSUSE and SLES for the proper OS grain.
+)
+
+# SLES grains differ from openSUSE, let do a 1:1 direct mapping
+CLEANUP_COMMANDS_BY_OS_FAMILY['SUSE  Enterprise Server'] = CLEANUP_COMMANDS_BY_OS_FAMILY['Suse']
+
+
+class InstallationTestCase(BootstrapTestCase):
+
+    def setUp(self):
+        if os.geteuid() is not 0:
+            self.skipTest('you must be root to run this test')
+
+        if GRAINS['os_family'] not in CLEANUP_COMMANDS_BY_OS_FAMILY:
+            self.skipTest(
+                'There is not `tearDown()` clean up support for {0!r} OS '
+                'family.'.format(
+                    GRAINS['os_family']
+                )
+            )
+
+    def tearDown(self):
+        for cleanup in CLEANUP_COMMANDS_BY_OS_FAMILY[GRAINS['os_family']]:
+            print 'Running cleanup command {0!r}'.format(cleanup)
+            self.assert_script_result(
+                'Failed to execute cleanup command {0!r}'.format(cleanup),
+                (
+                    0,    # Proper exit code without errors.
+
+                    4,    # ZYPPER_EXIT_ERR_ZYPP: A problem reported by ZYPP
+                          # library.
+
+                    65,   # FreeBSD throws this error code when the packages
+                          # being un-installed were not installed in the first
+                          # place.
+
+                    100,  # Same as above but on Ubuntu with a another errno
+
+                    104,  # ZYPPER_EXIT_INF_CAP_NOT_FOUND: Returned by the
+                          # install and the remove command in case any of
+                          # the arguments does not match any of the available
+                          # (or installed) package names or other capabilities.
+                ),
+                self.run_script(
+                    script=None,
+                    args=cleanup.split(),
+                    timeout=15 * 60,
+                    stream_stds=True
+                )
+            )
+
+        # As a last resort, by hand house cleaning...
+        for glob_rule in ('/tmp/git', '/usr/lib*/python*/site-packages/salt*',
+                          '/usr/bin/salt*', '/usr/lib/systemd/system/salt*',
+                          '/etc/init*/salt*', '/usr/share/doc/salt*',
+                          '/usr/share/man/man*/salt*', '/var/*/salt*',
+                          '/etc/salt'):
+            for entry in glob.glob(glob_rule):
+                if os.path.isfile(entry):
+                    print 'Removing file {0!r}'.format(entry)
+                    os.remove(entry)
+                elif os.path.isdir(entry):
+                    print 'Removing directory {0!r}'.format(entry)
+                    shutil.rmtree(entry)
+
+    def test_install_using_bash(self):
+        if not os.path.exists('/bin/bash'):
+            self.skipTest('\'/bin/bash\' was not found on this system')
+
+        args = []
+        if GRAINS['os'] in OS_REQUIRES_PIP_ALLOWED:
+            args.append('-P')
+
+        self.assert_script_result(
+            'Failed to install using bash',
+            0,
+            self.run_script(
+                args=args,
+                executable='/bin/bash',
+                timeout=15 * 60,
+                stream_stds=True
+            )
+        )
+
+        # Try to get the versions report
+        self.assert_script_result(
+            'Failed to get the versions report (\'--versions-report\')',
+            0,
+            self.run_script(
+                script=None,
+                args=('salt-minion', '--versions-report'),
+                timeout=15 * 60,
+                stream_stds=True
+            )
+        )
+
+    def test_install_using_sh(self):
+        args = []
+        if GRAINS['os'] in OS_REQUIRES_PIP_ALLOWED:
+            args.append('-P')
+
+        self.assert_script_result(
+            'Failed to install using sh',
+            0,
+            self.run_script(
+                args=args,
+                timeout=15 * 60,
+                stream_stds=True
+            )
+        )
+
+        # Try to get the versions report
+        self.assert_script_result(
+            'Failed to get the versions report (\'--versions-report\')',
+            0,
+            self.run_script(
+                script=None,
+                args=('salt-minion', '--versions-report'),
+                timeout=15 * 60,
+                stream_stds=True
+            )
+        )
+
+    def test_install_explicit_stable(self):
+        args = []
+        if GRAINS['os'] in OS_REQUIRES_PIP_ALLOWED:
+            args.append('-P')
+
+        args.append('stable')
+
+        self.assert_script_result(
+            'Failed to install explicit stable using sh',
+            0,
+            self.run_script(
+                args=args,
+                timeout=15 * 60,
+                stream_stds=True
+            )
+        )
+
+        # Try to get the versions report
+        self.assert_script_result(
+            'Failed to get the versions report (\'--versions-report\')',
+            0,
+            self.run_script(
+                script=None,
+                args=('salt-minion', '--versions-report'),
+                timeout=15 * 60,
+                stream_stds=True
+            )
+        )
+
+    def test_install_daily(self):
+        args = []
+        if GRAINS['os'] in OS_REQUIRES_PIP_ALLOWED:
+            args.append('-P')
+
+        args.append('daily')
+
+        rc, out, err = self.run_script(
+            args=args, timeout=15 * 60, stream_stds=True
+        )
+        if GRAINS['os'] in ('Ubuntu', 'Trisquel'):
+            self.assert_script_result(
+                'Failed to install daily',
+                0, (rc, out, err)
+            )
+
+            # Try to get the versions report
+            self.assert_script_result(
+                'Failed to get the versions report (\'--versions-report\')',
+                0,
+                self.run_script(
+                    script=None,
+                    args=('salt-minion', '--versions-report'),
+                    timeout=15 * 60,
+                    stream_stds=True
+                )
+            )
+        else:
+            self.assert_script_result(
+                'Although system is not Ubuntu, we managed to install',
+                1, (rc, out, err)
+            )
+
+    def test_install_stable_piped_through_sh(self):
+        args = 'cat {0} | sh '.format(BOOTSTRAP_SCRIPT_PATH).split()
+        if GRAINS['os'] in OS_REQUIRES_PIP_ALLOWED:
+            args.extend('-s -- -P'.split())
+
+        self.assert_script_result(
+            'Failed to install stable piped through sh',
+            0,
+            self.run_script(
+                script=None,
+                args=args,
+                timeout=15 * 60,
+                stream_stds=True
+            )
+        )
+
+        # Try to get the versions report
+        self.assert_script_result(
+            'Failed to get the versions report (\'--versions-report\')',
+            0,
+            self.run_script(
+                script=None,
+                args=('salt-minion', '--versions-report'),
+                timeout=15 * 60,
+                stream_stds=True
+            )
+        )
+
+    #def test_install_latest_from_git_develop(self):
+    #    args = []
+    #    if GRAINS['os'] in OS_REQUIRES_PIP_ALLOWED:
+    #        args.append('-P')
+    #
+    #    args.extend(['git', 'develop'])
+    #
+    #    self.assert_script_result(
+    #        'Failed to install using latest git develop',
+    #        0,
+    #        self.run_script(
+    #            args=args,
+    #            timeout=15 * 60,
+    #            stream_stds=True
+    #        )
+    #    )
+    #
+    #    # Try to get the versions report
+    #    self.assert_script_result(
+    #        'Failed to get the versions report (\'--versions-report\')',
+    #        0,
+    #        self.run_script(
+    #            script=None,
+    #            args=('salt', '--versions-report'),
+    #            timeout=15 * 60,
+    #            stream_stds=True
+    #        )
+    #    )
+
+    def test_install_specific_git_tag(self):
+        args = []
+        if GRAINS['os'] in OS_REQUIRES_PIP_ALLOWED:
+            args.append('-P')
+
+        args.extend(['git', 'v0.13.1'])
+
+        self.assert_script_result(
+            'Failed to install using specific git tag',
+            0,
+            self.run_script(
+                args=args,
+                timeout=15 * 60,
+                stream_stds=True
+            )
+        )
+
+        # Try to get the versions report
+        self.assert_script_result(
+            'Failed to get the versions report (\'--versions-report\')',
+            0,
+            self.run_script(
+                script=None,
+                args=('salt', '--versions-report'),
+                timeout=15 * 60,
+                stream_stds=True
+            )
+        )
+
+    def test_install_specific_git_sha(self):
+        args = []
+        if GRAINS['os'] in OS_REQUIRES_PIP_ALLOWED:
+            args.append('-P')
+
+        args.extend(['git', '2b6264de62bf2ea221bb2c0b8af36dfcfaafe7cf'])
+
+        self.assert_script_result(
+            'Failed to install using specific git sha',
+            0,
+            self.run_script(
+                args=args,
+                timeout=15 * 60,
+                stream_stds=True
+            )
+        )
+
+        # Try to get the versions report
+        self.assert_script_result(
+            'Failed to get the versions report (\'--versions-report\')',
+            0,
+            self.run_script(
+                script=None,
+                args=('salt', '--versions-report'),
+                timeout=15 * 60,
+                stream_stds=True
+            )
+        )
+
+    def test_config_only_without_config_dir_fails(self):
+        '''
+        Test running in configuration mode only without providing the necessary
+        configuration directory fails.
+        '''
+        self.assert_script_result(
+            'The script successfully executed even though no configuration '
+            'directory was provided.',
+            1,
+            self.run_script(args=('-C',))
+        )
+
+    def test_config_with_a_non_existing_configuration_dir_fails(self):
+        '''
+        Do we fail if the passed configuration directory passed does not exits?
+        '''
+        self.assert_script_result(
+            'The script successfully executed even though the configuration '
+            'directory provided does not exist.',
+            1,
+            self.run_script(
+                args=('-C', '-c', '/tmp/this-directory-must-not-exist')
+            )
+        )
+
+    def test_config_only_without_actually_configuring_anything_fails(self):
+        '''
+        Test running in configuration mode only without actually configuring
+        anything fails.
+        '''
+        rc, out, err = self.run_script(
+            args=('-C', '-n', '-c', '/tmp'),
+        )
+
+        self.assert_script_result(
+            'The script did not show a warning even though no configuration '
+            'was done.',
+            0, (rc, out, err)
+        )
+        self.assertIn(
+            'WARN: No configuration or keys were copied over. No '
+            'configuration was done!',
+            '\n'.join(out)
+        )
+
+    def test_install_salt_master(self):
+        '''
+        Test if installing a salt-master works
+        '''
+        args = []
+        if GRAINS['os'] in OS_REQUIRES_PIP_ALLOWED:
+            args.append('-P')
+
+        args.extend(['-N', '-M'])
+
+        self.assert_script_result(
+            'Failed to install salt-master',
+            0,
+            self.run_script(
+                args=args,
+                timeout=15 * 60,
+                stream_stds=True
+            )
+        )
+
+        # Try to get the versions report
+        self.assert_script_result(
+            'Failed to get the versions report from salt-master',
+            0,
+            self.run_script(
+                script=None,
+                args=('salt-master', '--versions-report'),
+                timeout=15 * 60,
+                stream_stds=True
+            )
+        )
+
+    def test_install_salt_syndic(self):
+        '''
+        Test if installing a salt-syndic works
+        '''
+        if GRAINS['os'] == 'Debian':
+            self.skipTest(
+                'Currently the debian stable package will have the syndic '
+                'waiting for a connection to a master.'
+            )
+
+        args = []
+        if GRAINS['os'] in OS_REQUIRES_PIP_ALLOWED:
+            args.append('-P')
+
+        args.extend(['-N', '-S'])
+
+        self.assert_script_result(
+            'Failed to install salt-syndic',
+            0,
+            self.run_script(
+                args=args,
+                timeout=15 * 60,
+                stream_stds=True
+            )
+        )
+
+        # Try to get the versions report
+        self.assert_script_result(
+            'Failed to get the versions report from salt-syndic',
+            0,
+            self.run_script(
+                script=None,
+                args=('salt-syndic', '--versions-report'),
+                timeout=15 * 60,
+                stream_stds=True
+            )
+        )
+
+    def test_install_pip_not_allowed(self):
+        '''
+        Check if distributions which require `-P` to allow pip to install
+        packages, fail if that flag is not passed.
+        '''
+        if GRAINS['os'] not in OS_REQUIRES_PIP_ALLOWED:
+            self.skipTest(
+                'Distribution {0} does not require the extra `-P` flag'.format(
+                    GRAINS['os']
+                )
+            )
+
+        self.assert_script_result(
+            'Even though {0} is flagged as requiring the extra `-P` flag to '
+            'allow packages to be installed by pip, it did not fail when we '
+            'did not pass it'.format(GRAINS['os']),
+            1,
+            self.run_script(
+                timeout=15 * 60,
+                stream_stds=True
+            )
+        )
+
+    def test_install_from_git_on_checked_out_repository(self):
+        '''
+        Check if the script properly updates an already checked out repository.
+        '''
+        if not os.path.isdir('/tmp/git'):
+            os.makedirs('/tmp/git')
+
+        # Clone salt from git
+        self.assert_script_result(
+            'Failed to clone salt\'s git repository',
+            0,
+            self.run_script(
+                script=None,
+                args=('git', 'clone', 'https://github.com/saltstack/salt.git'),
+                cwd='/tmp/git',
+                timeout=15 * 60,
+                stream_stds=True
+            )
+        )
+
+        # Check-out a specific revision
+        self.assert_script_result(
+            'Failed to checkout v0.12.1 from salt\'s cloned git repository',
+            0,
+            self.run_script(
+                script=None,
+                args=('git', 'checkout', 'v0.12.1'),
+                cwd='/tmp/git/salt',
+                timeout=15 * 60,
+                stream_stds=True
+            )
+        )
+
+        # Now run the bootstrap script over an existing git checkout and see
+        # if it properly updates.
+        args = []
+        if GRAINS['os'] in OS_REQUIRES_PIP_ALLOWED:
+            args.append('-P')
+
+        args.extend(['git', 'v0.13.1'])
+
+        self.assert_script_result(
+            'Failed to install using specific git tag',
+            0,
+            self.run_script(
+                args=args,
+                timeout=15 * 60,
+                stream_stds=True
+            )
+        )
+
+        # Get the version from the salt binary just installed
+        # Do it as a two step so we can check the returning output.
+        rc, out, err = self.run_script(
+            script=None,
+            args=('salt', '--version'),
+            timeout=15 * 60,
+            stream_stds=True
+        )
+
+        self.assert_script_result(
+            'Failed to get the salt version',
+            0, (rc, out, err)
+        )
+
+        # Make sure the installation updated the git repository to the proper
+        # git tag before installing.
+        self.assertIn('0.13.1', '\n'.join(out))