--- a
+++ b/scripts/qiita-test-install
@@ -0,0 +1,424 @@
+#!/usr/bin/env python
+from os import environ
+from os.path import join, dirname, abspath, splitext
+from sys import platform, version as python_version, exit, executable, stdout
+from unittest import TestLoader, TextTestRunner, TestCase
+from smtplib import SMTP, SMTP_SSL
+
+# -----------------------------------------------------------------------------
+# Copyright (c) 2014--, The Qiita Development Team.
+#
+# Distributed under the terms of the BSD 3-clause License.
+#
+# The full license is in the file LICENSE, distributed with this software.
+# -----------------------------------------------------------------------------
+
+core_dependency_missing_msg = (
+    '"%s" is missing and is a core requirement, for more information see the '
+    'Qiita Installation Guide: '
+    'https://github.com/biocore/qiita/blob/master/INSTALL.md')
+
+extra_info = (core_dependency_missing_msg + '. It is also possible that you '
+              'have an old version of this package, if so, please update to '
+              'the latest.')
+
+dependency_missing_msg = (
+    '"%s" is missing but this is _not_ a core requirement, for more '
+    'information see the Qiita Installation Guide: '
+    'https://github.com/biocore/qiita/blob/master/INSTALL.md')
+
+missing_deps_errors = []
+missing_deps_warnings = []
+
+try:
+    from click import __version__ as click_lib_version
+except ImportError as e:
+    missing_deps_errors.append((e, extra_info % 'click'))
+
+try:
+    from numpy import __version__ as numpy_lib_version
+except ImportError as e:
+    missing_deps_errors.append((e, core_dependency_missing_msg % 'NumPy'))
+
+try:
+    from pandas import __version__ as pandas_lib_version
+except ImportError as e:
+    missing_deps_errors.append((e, core_dependency_missing_msg % 'pandas'))
+
+try:
+    from tornado import version as tornado_lib_version
+except ImportError as e:
+    missing_deps_errors.append((e, core_dependency_missing_msg % 'tornado'))
+
+try:
+    from redis import __version__ as redis_lib_version
+except ImportError as e:
+    missing_deps_errors.append((e, core_dependency_missing_msg % 'redis'))
+
+try:
+    from toredis import Client as toredis_client
+    toredis_client()
+except ImportError as e:
+    missing_deps_errors.append((e, core_dependency_missing_msg % 'toredis'))
+
+try:
+    from redbiom import __version__ as redbiom_lib_version
+except ImportError as e:
+    missing_deps_errors.append((e, core_dependency_missing_msg % 'redbiom'))
+
+try:
+    from bcrypt import __version__ as bcrypt_lib_version
+except ImportError as e:
+    missing_deps_errors.append((e, core_dependency_missing_msg % 'bcrypt'))
+
+try:
+    from pyparsing import __version__ as pyparsing_lib_version
+except ImportError as e:
+    missing_deps_errors.append((e, core_dependency_missing_msg % 'pyparsing'))
+
+try:
+    from networkx import __version__ as networkx_lib_version
+except ImportError as e:
+    missing_deps_errors.append((e, core_dependency_missing_msg % 'networkx'))
+
+try:
+    from wtforms import __version__ as wtforms_lib_version
+except ImportError as e:
+    missing_deps_errors.append((e, core_dependency_missing_msg % 'wtforms'))
+
+try:
+    from mock import __version__ as mock_lib_version
+except ImportError as e:
+    missing_deps_warnings.append((e, dependency_missing_msg % 'mock'))
+    mock_lib_version = 'Not installed'
+
+try:
+    from psycopg2 import __version__ as psycopg2_lib_version
+except ImportError as e:
+    missing_deps_errors.append((e, core_dependency_missing_msg % 'psycopg2'))
+
+try:
+    from qiita_core import __version__ as qiita_core_lib_version
+except ImportError as e:
+    missing_deps_errors.append((e, core_dependency_missing_msg % 'qiita_core'))
+
+try:
+    from qiita_db import __version__ as qiita_db_lib_version
+except ImportError as e:
+    missing_deps_errors.append((e, core_dependency_missing_msg % 'qiita_db'))
+
+try:
+    from qiita_pet import __version__ as qiita_pet_lib_version
+except ImportError as e:
+    missing_deps_errors.append((e, core_dependency_missing_msg % 'qiita_pet'))
+
+try:
+    from qiita_ware import __version__ as qiita_ware_lib_version
+except ImportError as e:
+    missing_deps_errors.append((e, core_dependency_missing_msg % 'qiita_ware'))
+
+try:
+    from qiita_core.configuration_manager import ConfigurationManager
+    ConfigurationManager()
+except Exception as e:
+    missing_deps_errors.append((e, 'You need to add to your enviroment '
+                                'the Qiita configuration using '
+                                'QIITA_CONFIG_FP'))
+
+if missing_deps_errors:
+    for e, t in missing_deps_errors:
+        print('%s\n=============' % (t))
+    exit('Missing core dependencies, can not continue.')
+
+if missing_deps_warnings:
+    for e, t in missing_deps_errors:
+        print('%s\n=============' % (t))
+
+
+# trick flake8 to not complain about module-level imports not being at the top
+# of the file. These imports can only really happen if none of the core
+# dependencies are missing
+if True:
+    from qiita_db.sql_connection import TRN
+    from redis import StrictRedis
+
+
+class QiitaConfig(TestCase):
+
+    def setUp(self):
+        self.config = ConfigurationManager()
+        try:
+            with TRN:
+                TRN.add("SELECT version()")
+                self.psql_version = TRN.execute_fetchflatten()[0]
+        except Exception:
+            self.psql_version = None
+        try:
+            r = StrictRedis(
+                host=self.config.redis_host,
+                password=self.config.redis_password,
+                port=self.config.redis_port,
+                db=self.config.redis_db)
+            self.redis_version = r.info()['redis_version']
+        except Exception:
+            self.redis_version = None
+
+    def test_pandas_library_version(self):
+        acceptable_version = (0, 15)
+        string_acceptable_version = '.'.join(map(str, acceptable_version))
+        version = tuple(map(int, pandas_lib_version.split('.')))
+
+        self.assertTrue(acceptable_version <= version,
+                        'Unsupported pandas version. You have %s but the '
+                        'minimum required version is %s'
+                        % (pandas_lib_version, string_acceptable_version))
+
+    def test_torando_library_version(self):
+        acceptable_version = (3, 1, 1)
+        string_acceptable_version = '.'.join(map(str, acceptable_version))
+        version = tuple(map(int, tornado_lib_version.split('.')))
+
+        self.assertTrue(acceptable_version <= version,
+                        'Unsupported tornado version. You have %s but the '
+                        'minimum required version is %s'
+                        % (tornado_lib_version, string_acceptable_version))
+
+    def test_pyparsing_library_version(self):
+        acceptable_version = (2, 0, 2)
+        string_acceptable_version = '.'.join(map(str, acceptable_version))
+        version = tuple(map(int, pyparsing_lib_version.split('.')))
+
+        self.assertTrue(acceptable_version <= version,
+                        'Unsupported pyparsing version. You have %s but the '
+                        'minimum required version is %s'
+                        % (pyparsing_lib_version, string_acceptable_version))
+
+    def test_wtforms_library_version(self):
+        acceptable_version = (2, 0, 1)
+        string_acceptable_version = '.'.join(map(str, acceptable_version))
+        version = tuple(map(int, wtforms_lib_version.split('.')))
+
+        self.assertTrue(acceptable_version <= version,
+                        'Unsupported WTForms version. You have %s but the '
+                        'minimum required version is %s'
+                        % (wtforms_lib_version, string_acceptable_version))
+
+    def test_postgresql_version(self):
+        if not self.psql_version:
+            self.assertTrue(False, 'PostgreSQL not running or configured')
+
+        acceptable_version = (9, 3, 0)
+        string_acceptable_version = '.'.join(map(str, acceptable_version))
+        version = tuple(map(int, self.psql_version.split(' ')[1].split('.')))
+
+        self.assertTrue(acceptable_version <= version,
+                        'Unsupported PostgreSQL version. You have %s but the '
+                        'minimum required version is %s'
+                        % ('.'.join(map(str, version)),
+                           string_acceptable_version))
+
+    def test_redis_version(self):
+        if not self.redis_version:
+            self.assertTrue(False, 'redis not running or configured')
+
+        acceptable_version = (2, 8, 17)
+        string_acceptable_version = '.'.join(map(str, acceptable_version))
+        version = tuple(map(int, self.redis_version.split('.')))
+
+        self.assertTrue(acceptable_version <= version,
+                        'Unsupported redis version. You have %s but the '
+                        'minimum required version is %s'
+                        % ('.'.join(map(str, version)),
+                           string_acceptable_version))
+
+    def test_redbiom_version(self):
+        acceptable_version = (0, 3, 8)
+        string_acceptable_version = '.'.join(map(str, acceptable_version))
+        version = tuple(map(int, redbiom_lib_version.split('.')))
+
+        self.assertTrue(acceptable_version <= version,
+                        'Unsupported redbiom version. You have %s but the '
+                        'minimum required version is %s'
+                        % ('.'.join(map(str, version)),
+                           string_acceptable_version))
+
+
+system_info_header = """
+System information
+==================
+"""
+
+dependency_info_header = """
+Dependency versions
+===================
+"""
+
+qiita_config_header = """
+Qiita config
+============
+For definitions of these settings and to learn how to configure Qiita, visit:
+ https://github.com/biocore/qiita/blob/master/INSTALL.md#install
+"""
+
+qiita_config_tests_header = """
+Qiita version and configuration tests
+=====================================
+"""
+
+qiita_plugins_header = """
+Qiita plugins
+=============
+"""
+
+
+def main():
+    system_info = [
+        ("Platform", platform),
+        ("Python version", python_version.replace('\n', ' ')),
+        ("Python executable", executable)]
+    max_len = max([len(e[0]) for e in system_info])
+    print(system_info_header)
+    for v in system_info:
+        print("%*s:\t%s" % (max_len, v[0], v[1]))
+
+    with TRN:
+        TRN.add("SELECT current_patch FROM settings")
+        current_patch = TRN.execute_fetchflatten()[0]
+    qiita_db_patch_number = splitext(current_patch)[0]
+
+    # Getting required environment variables
+    if 'REDBIOM_HOST' in environ:
+        redbiom_host = environ['REDBIOM_HOST']
+    else:
+        redbiom_host = None
+
+    version_info = [
+        ('click library version', click_lib_version),
+        ('numpy library version', numpy_lib_version),
+        ('pandas library version', pandas_lib_version),
+        ('tornado library version', tornado_lib_version),
+        ('redis library version', redis_lib_version),
+        ('redbiom library version', '%s - host: %s' % (
+            redbiom_lib_version, redbiom_host)),
+        ('bcrypt library version', bcrypt_lib_version),
+        ('pyparsing library version', pyparsing_lib_version),
+        ('networkX library version', networkx_lib_version),
+        ('WTForms library version', wtforms_lib_version),
+        ('mock library version', mock_lib_version),
+        ('psycopg2 library version', psycopg2_lib_version),
+        ('Qiita core library version', qiita_core_lib_version),
+        ('Qiita db library version', qiita_db_lib_version),
+        ('Qiita db patch number', qiita_db_patch_number),
+        ('Qiita pet library version', qiita_pet_lib_version),
+        ('Qiita ware library version', qiita_ware_lib_version)
+    ]
+    max_len = max([len(e[0]) for e in version_info])
+    print(dependency_info_header)
+    for v in version_info:
+        print("%*s:\t%s" % (max_len, v[0], v[1]))
+
+    extra_info = None
+    qiita_config = ConfigurationManager()
+    try:
+        qiita_conf_fp = environ['QIITA_CONFIG_FP']
+    except KeyError:
+        qiita_conf_fp = join(dirname(abspath(__file__)),
+                             'support_files/config_test.cfg')
+    smtp = SMTP_SSL() if qiita_config.smtp_ssl else SMTP()
+    smtp.set_debuglevel(False)
+    try:
+        smtp.connect(qiita_config.smtp_host, qiita_config.smtp_port)
+        smtp.verify
+        send_email = True
+    except Exception:
+        send_email = False
+    ebi_credentials = (qiita_config.ebi_center_name != '' and
+                       qiita_config.ebi_dropbox_url != '' and
+                       qiita_config.ebi_organization_prefix != '' and
+                       qiita_config.ebi_seq_xfer_pass != '' and
+                       qiita_config.ebi_seq_xfer_url != '' and
+                       qiita_config.ebi_seq_xfer_user != '')
+    vamps_credentials = (qiita_config.vamps_pass != '' and
+                         qiita_config.vamps_url != '' and
+                         qiita_config.vamps_user != '')
+    try:
+        with TRN:
+            psql_running = True
+    except Exception:
+        psql_running = False
+    try:
+        StrictRedis(
+            host=qiita_config.redis_host,
+            password=qiita_config.redis_password,
+            port=qiita_config.redis_port,
+            db=qiita_config.redis_db)
+        redis_running = True
+    except Exception:
+        redis_running = False
+
+    try:
+        StrictRedis(
+             host=qiita_config.redbiom_redis_host,
+             password=qiita_config.redbiom_redis_password,
+             port=qiita_config.redbiom_redis_port,
+             db=qiita_config.redbiom_redis_db)
+        redbiom_redis_running = True
+    except Exception:
+        redbiom_redis_running = False
+
+    print(qiita_config_header)
+    qiita_config_info = [
+        ('QIITA_CONFIG_FP filepath', qiita_conf_fp),
+        ('Test environment', str(qiita_config.test_environment)),
+        ('Base URL', qiita_config.base_url),
+        ('EBI credentials exist', ebi_credentials),
+        ('VAMPS credentials exist', vamps_credentials),
+        ('Can the system send emails?', str(send_email) + '. When true, '
+         'emails could still not be going out due to your network '
+         'configuration.'),
+        ('Valid file extensions for upload', ', '.join(
+         qiita_config.valid_upload_extension)),
+        ('PostgreSQL is up and configuration can connect?', psql_running),
+        ('Redis is up and configuracion can connect?',
+            redis_running if not redis_running else '%s --port %d' % (
+                redis_running, qiita_config.redis_port)),
+        ('Redbiom redis is up and configuracion can connect?',
+            redbiom_redis_running if not redbiom_redis_running else
+            '%s --port %d' % (redbiom_redis_running,
+                              qiita_config.redbiom_redis_port)),
+        ('Extra info', extra_info)
+    ]
+    max_len = max([len(e[0]) for e in qiita_config_info])
+    for v in qiita_config_info:
+        if v != ('Extra info', None):
+            print("%*s:\t%s" % (max_len, v[0], v[1]))
+
+    print(qiita_plugins_header)
+    if not psql_running:
+        print("PostgreSQL not running, can't retrieve plugin information")
+    else:
+        try:
+            import qiita_db as qdb
+            with qdb.sql_connection.TRN:
+                sql = """SELECT name, version, client_id, client_secret
+                         FROM qiita.software
+                            JOIN qiita.oauth_software USING (software_id)
+                            JOIN qiita.oauth_identifiers USING (client_id)"""
+                qdb.sql_connection.TRN.add(sql)
+                res = qdb.sql_connection.TRN.execute_fetchindex()
+                for name, version, client_id, client_secret in res:
+                    print("Plugin name: %s" % name)
+                    print("\tVersion: %s" % version)
+                    print("\tClient id: %s" % client_id)
+                    print("\tClient secret: %s" % client_secret)
+        except Exception as e:
+            print("An error occurred while retrieving plugin information: %s"
+                  % str(e))
+
+    print(qiita_config_tests_header)
+    suite = TestLoader().loadTestsFromTestCase(QiitaConfig)
+    TextTestRunner(stream=stdout, verbosity=1).run(suite)
+
+
+if __name__ == "__main__":
+    main()