okd/utils/test/cli_installer_tests.py

# TODO: Temporarily disabled due to importing old code into openshift-ansible
# repo. We will work on these over time.
# pylint: disable=bad-continuation,missing-docstring,no-self-use,invalid-name,too-many-lines

import copy
import os
import ConfigParser

import ooinstall.cli_installer as cli

from test.fixture import OOCliFixture, SAMPLE_CONFIG, build_input, read_yaml
from mock import patch


MOCK_FACTS = {
    '10.0.0.1': {
        'common': {
            'ip': '10.0.0.1',
            'public_ip': '10.0.0.1',
            'hostname': 'master-private.example.com',
            'public_hostname': 'master.example.com'
        }
    },
    '10.0.0.2': {
        'common': {
            'ip': '10.0.0.2',
            'public_ip': '10.0.0.2',
            'hostname': 'node1-private.example.com',
            'public_hostname': 'node1.example.com'
        }
    },
    '10.0.0.3': {
        'common': {
            'ip': '10.0.0.3',
            'public_ip': '10.0.0.3',
            'hostname': 'node2-private.example.com',
            'public_hostname': 'node2.example.com'
        }
    },
    '10.1.0.1': {
        'common': {
            'ip': '10.1.0.1',
            'public_ip': '10.1.0.1',
            'hostname': 'storage-private.example.com',
            'public_hostname': 'storage.example.com'
        }
    },
}

MOCK_FACTS_QUICKHA = {
    '10.0.0.1': {
        'common': {
            'ip': '10.0.0.1',
            'public_ip': '10.0.0.1',
            'hostname': 'master-private.example.com',
            'public_hostname': 'master.example.com'
        }
    },
    '10.0.0.2': {
        'common': {
            'ip': '10.0.0.2',
            'public_ip': '10.0.0.2',
            'hostname': 'node1-private.example.com',
            'public_hostname': 'node1.example.com'
        }
    },
    '10.0.0.3': {
        'common': {
            'ip': '10.0.0.3',
            'public_ip': '10.0.0.3',
            'hostname': 'node2-private.example.com',
            'public_hostname': 'node2.example.com'
        }
    },
    '10.0.0.4': {
        'common': {
            'ip': '10.0.0.4',
            'public_ip': '10.0.0.4',
            'hostname': 'node3-private.example.com',
            'public_hostname': 'node3.example.com'
        }
    },
    '10.0.0.5': {
        'common': {
            'ip': '10.0.0.5',
            'public_ip': '10.0.0.5',
            'hostname': 'proxy-private.example.com',
            'public_hostname': 'proxy.example.com'
        }
    },
    '10.1.0.1': {
        'common': {
            'ip': '10.1.0.1',
            'public_ip': '10.1.0.1',
            'hostname': 'storage-private.example.com',
            'public_hostname': 'storage.example.com'
        }
    },
}

# Missing connect_to on some hosts:
BAD_CONFIG = """
variant: %s
deployment:
    ansible_ssh_user: root
    hosts:
      - connect_to: 10.0.0.1
        ip: 10.0.0.1
        hostname: master-private.example.com
        public_ip: 24.222.0.1
        public_hostname: master.example.com
        roles:
            - master
            - node
      - ip: 10.0.0.2
        hostname: node1-private.example.com
        public_ip: 24.222.0.2
        public_hostname: node1.example.com
        roles:
            - node
      - connect_to: 10.0.0.3
        ip: 10.0.0.3
        hostname: node2-private.example.com
        public_ip: 24.222.0.3
        public_hostname: node2.example.com
        roles:
            - node
    roles:
        master:
        node:
"""

QUICKHA_CONFIG = """
variant: %s
deployment:
    ansible_ssh_user: root
    hosts:
      - connect_to: 10.0.0.1
        ip: 10.0.0.1
        hostname: master-private.example.com
        public_ip: 24.222.0.1
        public_hostname: master.example.com
        roles:
            - master
            - node
      - connect_to: 10.0.0.2
        ip: 10.0.0.2
        hostname: node1-private.example.com
        public_ip: 24.222.0.2
        public_hostname: node1.example.com
        roles:
            - master
            - node
      - connect_to: 10.0.0.3
        ip: 10.0.0.3
        hostname: node2-private.example.com
        public_ip: 24.222.0.3
        public_hostname: node2.example.com
        roles:
            - master
            - node
      - connect_to: 10.0.0.4
        ip: 10.0.0.4
        hostname: node3-private.example.com
        public_ip: 24.222.0.4
        public_hostname: node3.example.com
        roles:
            - node
      - connect_to: 10.0.0.5
        ip: 10.0.0.5
        hostname: proxy-private.example.com
        public_ip: 24.222.0.5
        public_hostname: proxy.example.com
        roles:
            - master_lb
      - connect_to: 10.1.0.1
        ip: 10.1.0.1
        hostname: storage-private.example.com
        public_ip: 24.222.0.6
        public_hostname: storage.example.com
        roles:
            - storage
    roles:
        master:
        master_lb:
        node:
        storage:
"""

QUICKHA_2_MASTER_CONFIG = """
variant: %s
deployment:
    ansible_ssh_user: root
    hosts:
      - connect_to: 10.0.0.1
        ip: 10.0.0.1
        hostname: master-private.example.com
        public_ip: 24.222.0.1
        public_hostname: master.example.com
        roles:
            - master
            - node
      - connect_to: 10.0.0.2
        ip: 10.0.0.2
        hostname: node1-private.example.com
        public_ip: 24.222.0.2
        public_hostname: node1.example.com
        roles:
            - master
            - node
      - connect_to: 10.0.0.4
        ip: 10.0.0.4
        hostname: node3-private.example.com
        public_ip: 24.222.0.4
        public_hostname: node3.example.com
        roles:
            - node
      - connect_to: 10.0.0.5
        ip: 10.0.0.5
        hostname: proxy-private.example.com
        public_ip: 24.222.0.5
        public_hostname: proxy.example.com
        roles:
            - master_lb
      - connect_to: 10.1.0.1
        ip: 10.1.0.1
        hostname: storage-private.example.com
        public_ip: 24.222.0.6
        public_hostname: storage.example.com
        roles:
            - storage
    roles:
        master:
        master_lb:
        node:
        storage:
"""

QUICKHA_CONFIG_REUSED_LB = """
variant: %s
deployment:
    ansible_ssh_user: root
    hosts:
      - connect_to: 10.0.0.1
        ip: 10.0.0.1
        hostname: master-private.example.com
        public_ip: 24.222.0.1
        public_hostname: master.example.com
        roles:
            - master
            - node
      - connect_to: 10.0.0.2
        ip: 10.0.0.2
        hostname: node1-private.example.com
        public_ip: 24.222.0.2
        public_hostname: node1.example.com
        roles:
            - master
            - node
            - master_lb
      - connect_to: 10.0.0.3
        ip: 10.0.0.3
        hostname: node2-private.example.com
        public_ip: 24.222.0.3
        public_hostname: node2.example.com
        roles:
            - master
            - node
      - connect_to: 10.1.0.1
        ip: 10.1.0.1
        hostname: storage-private.example.com
        public_ip: 24.222.0.6
        public_hostname: storage.example.com
        roles:
            - storage
    roles:
        master:
        node:
        storage:
"""

QUICKHA_CONFIG_NO_LB = """
variant: %s
deployment:
    ansible_ssh_user: root
    hosts:
      - connect_to: 10.0.0.1
        ip: 10.0.0.1
        hostname: master-private.example.com
        public_ip: 24.222.0.1
        public_hostname: master.example.com
        roles:
            - master
            - node
      - connect_to: 10.0.0.2
        ip: 10.0.0.2
        hostname: node1-private.example.com
        public_ip: 24.222.0.2
        public_hostname: node1.example.com
        roles:
            - master
            - node
      - connect_to: 10.0.0.3
        ip: 10.0.0.3
        hostname: node2-private.example.com
        public_ip: 24.222.0.3
        public_hostname: node2.example.com
        roles:
            - master
            - node
      - connect_to: 10.1.0.1
        ip: 10.1.0.1
        hostname: storage-private.example.com
        public_ip: 24.222.0.6
        public_hostname: storage.example.com
        roles:
            - storage
    roles:
        master:
        node:
        storage:
"""

QUICKHA_CONFIG_PRECONFIGURED_LB = """
variant: %s
deployment:
    ansible_ssh_user: root
    hosts:
      - connect_to: 10.0.0.1
        ip: 10.0.0.1
        hostname: master-private.example.com
        public_ip: 24.222.0.1
        public_hostname: master.example.com
        roles:
            - master
            - node
      - connect_to: 10.0.0.2
        ip: 10.0.0.2
        hostname: node1-private.example.com
        public_ip: 24.222.0.2
        public_hostname: node1.example.com
        roles:
            - master
            - node
      - connect_to: 10.0.0.3
        ip: 10.0.0.3
        hostname: node2-private.example.com
        public_ip: 24.222.0.3
        public_hostname: node2.example.com
        roles:
            - master
            - node
      - connect_to: 10.0.0.4
        ip: 10.0.0.4
        hostname: node3-private.example.com
        public_ip: 24.222.0.4
        public_hostname: node3.example.com
        roles:
            - node
      - connect_to: proxy-private.example.com
        hostname: proxy-private.example.com
        public_hostname: proxy.example.com
        preconfigured: true
        roles:
            - master_lb
      - connect_to: 10.1.0.1
        ip: 10.1.0.1
        hostname: storage-private.example.com
        public_ip: 24.222.0.6
        public_hostname: storage.example.com
        roles:
            - storage
    roles:
        master:
        master_lb:
        node:
        storage:
"""

class UnattendedCliTests(OOCliFixture):

    def setUp(self):
        OOCliFixture.setUp(self)
        self.cli_args.append("-u")

    # unattended with config file and all installed hosts (without --force)
    @patch('ooinstall.openshift_ansible.run_main_playbook')
    @patch('ooinstall.openshift_ansible.load_system_facts')
    def test_get_hosts_to_run_on1(self, load_facts_mock, run_playbook_mock):
        mock_facts = copy.deepcopy(MOCK_FACTS)
        mock_facts['10.0.0.1']['common']['version'] = "3.0.0"
        mock_facts['10.0.0.2']['common']['version'] = "3.0.0"
        mock_facts['10.0.0.3']['common']['version'] = "3.0.0"

        load_facts_mock.return_value = (mock_facts, 0)
        run_playbook_mock.return_value = 0

        config_file = self.write_config(os.path.join(self.work_dir,
            'ooinstall.conf'), SAMPLE_CONFIG % 'openshift-enterprise')

        self.cli_args.extend(["-c", config_file, "install"])
        result = self.runner.invoke(cli.cli, self.cli_args)

        if result.exception is None or result.exit_code != 1:
            print "Exit code: %s" % result.exit_code
            self.fail("Unexpected CLI return")

    # unattended with config file and all installed hosts (with --force)
    @patch('ooinstall.openshift_ansible.run_main_playbook')
    @patch('ooinstall.openshift_ansible.load_system_facts')
    def test_get_hosts_to_run_on2(self, load_facts_mock, run_playbook_mock):
        mock_facts = copy.deepcopy(MOCK_FACTS)
        mock_facts['10.0.0.1']['common']['version'] = "3.0.0"
        mock_facts['10.0.0.2']['common']['version'] = "3.0.0"
        mock_facts['10.0.0.3']['common']['version'] = "3.0.0"
        self._verify_get_hosts_to_run_on(mock_facts, load_facts_mock, run_playbook_mock,
                                         cli_input=None,
                                         exp_hosts_len=3,
                                         exp_hosts_to_run_on_len=3,
                                         force=True)

    # unattended with config file and no installed hosts (without --force)
    @patch('ooinstall.openshift_ansible.run_main_playbook')
    @patch('ooinstall.openshift_ansible.load_system_facts')
    def test_get_hosts_to_run_on3(self, load_facts_mock, run_playbook_mock):
        load_facts_mock.return_value = (MOCK_FACTS, 0)
        run_playbook_mock.return_value = 0
        self._verify_get_hosts_to_run_on(MOCK_FACTS, load_facts_mock, run_playbook_mock,
                                         cli_input=None,
                                         exp_hosts_len=3,
                                         exp_hosts_to_run_on_len=3,
                                         force=False)

    # unattended with config file and no installed hosts (with --force)
    @patch('ooinstall.openshift_ansible.run_main_playbook')
    @patch('ooinstall.openshift_ansible.load_system_facts')
    def test_get_hosts_to_run_on4(self, load_facts_mock, run_playbook_mock):
        load_facts_mock.return_value = (MOCK_FACTS, 0)
        run_playbook_mock.return_value = 0
        self._verify_get_hosts_to_run_on(MOCK_FACTS, load_facts_mock, run_playbook_mock,
                                         cli_input=None,
                                         exp_hosts_len=3,
                                         exp_hosts_to_run_on_len=3,
                                         force=True)

    # unattended with config file and some installed some uninstalled hosts (without --force)
    @patch('ooinstall.openshift_ansible.run_main_playbook')
    @patch('ooinstall.openshift_ansible.load_system_facts')
    def test_get_hosts_to_run_on5(self, load_facts_mock, run_playbook_mock):
        mock_facts = copy.deepcopy(MOCK_FACTS)
        mock_facts['10.0.0.1']['common']['version'] = "3.0.0"
        mock_facts['10.0.0.2']['common']['version'] = "3.0.0"
        self._verify_get_hosts_to_run_on(mock_facts, load_facts_mock, run_playbook_mock,
                                         cli_input=None,
                                         exp_hosts_len=3,
                                         exp_hosts_to_run_on_len=2,
                                         force=False)

    # unattended with config file and some installed some uninstalled hosts (with --force)
    @patch('ooinstall.openshift_ansible.run_main_playbook')
    @patch('ooinstall.openshift_ansible.load_system_facts')
    def test_get_hosts_to_run_on6(self, load_facts_mock, run_playbook_mock):
        mock_facts = copy.deepcopy(MOCK_FACTS)
        mock_facts['10.0.0.1']['common']['version'] = "3.0.0"
        mock_facts['10.0.0.2']['common']['version'] = "3.0.0"
        self._verify_get_hosts_to_run_on(mock_facts, load_facts_mock, run_playbook_mock,
                                         cli_input=None,
                                         exp_hosts_len=3,
                                         exp_hosts_to_run_on_len=3,
                                         force=True)

    @patch('ooinstall.openshift_ansible.run_main_playbook')
    @patch('ooinstall.openshift_ansible.load_system_facts')
    def test_cfg_full_run(self, load_facts_mock, run_playbook_mock):
        load_facts_mock.return_value = (MOCK_FACTS, 0)
        run_playbook_mock.return_value = 0

        config_file = self.write_config(os.path.join(self.work_dir,
            'ooinstall.conf'), SAMPLE_CONFIG % 'openshift-enterprise')

        self.cli_args.extend(["-c", config_file, "install"])
        result = self.runner.invoke(cli.cli, self.cli_args)
        self.assert_result(result, 0)

        load_facts_args = load_facts_mock.call_args[0]
        self.assertEquals(os.path.join(self.work_dir, "hosts"),
            load_facts_args[0])
        self.assertEquals(os.path.join(self.work_dir,
            "playbooks/byo/openshift_facts.yml"), load_facts_args[1])
        env_vars = load_facts_args[2]
        self.assertEquals(os.path.join(self.work_dir,
            '.ansible/callback_facts.yaml'),
            env_vars['OO_INSTALL_CALLBACK_FACTS_YAML'])
        self.assertEqual('/tmp/ansible.log', env_vars['ANSIBLE_LOG_PATH'])
        # If user running test has rpm installed, this might be set to default:
        self.assertTrue('ANSIBLE_CONFIG' not in env_vars or
            env_vars['ANSIBLE_CONFIG'] == cli.DEFAULT_ANSIBLE_CONFIG)

        # Make sure we ran on the expected masters and nodes:
        hosts = run_playbook_mock.call_args[0][1]
        hosts_to_run_on = run_playbook_mock.call_args[0][2]
        self.assertEquals(3, len(hosts))
        self.assertEquals(3, len(hosts_to_run_on))

    @patch('ooinstall.openshift_ansible.run_main_playbook')
    @patch('ooinstall.openshift_ansible.load_system_facts')
    def test_inventory_write(self, load_facts_mock, run_playbook_mock):
        merged_config = SAMPLE_CONFIG % 'openshift-enterprise'
        load_facts_mock.return_value = (MOCK_FACTS, 0)
        run_playbook_mock.return_value = 0

        config_file = self.write_config(os.path.join(self.work_dir,
            'ooinstall.conf'), merged_config)

        self.cli_args.extend(["-c", config_file, "install"])
        result = self.runner.invoke(cli.cli, self.cli_args)
        self.assert_result(result, 0)

        # Check the inventory file looks as we would expect:
        inventory = ConfigParser.ConfigParser(allow_no_value=True)
        inventory.read(os.path.join(self.work_dir, 'hosts'))
        self.assertEquals('root',
            inventory.get('OSEv3:vars', 'ansible_ssh_user'))
        self.assertEquals('openshift-enterprise',
            inventory.get('OSEv3:vars', 'deployment_type'))

        # Check the masters:
        self.assertEquals(1, len(inventory.items('masters')))
        self.assertEquals(3, len(inventory.items('nodes')))

        for item in inventory.items('masters'):
            # ansible host lines do NOT parse nicely:
            master_line = item[0]
            if item[1] is not None:
                master_line = "%s=%s" % (master_line, item[1])
            self.assertTrue('openshift_ip' in master_line)
            self.assertTrue('openshift_public_ip' in master_line)
            self.assertTrue('openshift_hostname' in master_line)
            self.assertTrue('openshift_public_hostname' in master_line)

    @patch('ooinstall.openshift_ansible.run_main_playbook')
    @patch('ooinstall.openshift_ansible.load_system_facts')
    def test_variant_version_latest_assumed(self, load_facts_mock,
        run_playbook_mock):
        load_facts_mock.return_value = (MOCK_FACTS, 0)
        run_playbook_mock.return_value = 0

        config_file = self.write_config(os.path.join(self.work_dir,
            'ooinstall.conf'), SAMPLE_CONFIG % 'openshift-enterprise')

        self.cli_args.extend(["-c", config_file, "install"])
        result = self.runner.invoke(cli.cli, self.cli_args)
        self.assert_result(result, 0)

        written_config = read_yaml(config_file)

        self.assertEquals('openshift-enterprise', written_config['variant'])
        # We didn't specify a version so the latest should have been assumed,
        # and written to disk:
        self.assertEquals('3.3', written_config['variant_version'])

        # Make sure the correct value was passed to ansible:
        inventory = ConfigParser.ConfigParser(allow_no_value=True)
        inventory.read(os.path.join(self.work_dir, 'hosts'))
        self.assertEquals('openshift-enterprise',
            inventory.get('OSEv3:vars', 'deployment_type'))

    @patch('ooinstall.openshift_ansible.run_main_playbook')
    @patch('ooinstall.openshift_ansible.load_system_facts')
    def test_variant_version_preserved(self, load_facts_mock,
        run_playbook_mock):
        load_facts_mock.return_value = (MOCK_FACTS, 0)
        run_playbook_mock.return_value = 0

        config = SAMPLE_CONFIG % 'openshift-enterprise'
        config = '%s\n%s' % (config, 'variant_version: 3.3')
        config_file = self.write_config(os.path.join(self.work_dir,
            'ooinstall.conf'), config)

        self.cli_args.extend(["-c", config_file, "install"])
        result = self.runner.invoke(cli.cli, self.cli_args)
        self.assert_result(result, 0)

        written_config = read_yaml(config_file)

        self.assertEquals('openshift-enterprise', written_config['variant'])
        # Make sure our older version was preserved:
        # and written to disk:
        self.assertEquals('3.3', written_config['variant_version'])

        inventory = ConfigParser.ConfigParser(allow_no_value=True)
        inventory.read(os.path.join(self.work_dir, 'hosts'))
        self.assertEquals('openshift-enterprise',
            inventory.get('OSEv3:vars', 'deployment_type'))

    @patch('ooinstall.openshift_ansible.run_ansible')
    @patch('ooinstall.openshift_ansible.load_system_facts')
    def test_no_ansible_config_specified(self, load_facts_mock, run_ansible_mock):
        load_facts_mock.return_value = (MOCK_FACTS, 0)
        run_ansible_mock.return_value = 0

        config = SAMPLE_CONFIG % 'openshift-enterprise'

        self._ansible_config_test(load_facts_mock, run_ansible_mock,
            config, None, None)

    @patch('ooinstall.openshift_ansible.run_ansible')
    @patch('ooinstall.openshift_ansible.load_system_facts')
    def test_ansible_config_specified_cli(self, load_facts_mock, run_ansible_mock):
        load_facts_mock.return_value = (MOCK_FACTS, 0)
        run_ansible_mock.return_value = 0

        config = SAMPLE_CONFIG % 'openshift-enterprise'
        ansible_config = os.path.join(self.work_dir, 'ansible.cfg')

        self._ansible_config_test(load_facts_mock, run_ansible_mock,
            config, ansible_config, ansible_config)

    @patch('ooinstall.openshift_ansible.run_ansible')
    @patch('ooinstall.openshift_ansible.load_system_facts')
    def test_ansible_config_specified_in_installer_config(self,
        load_facts_mock, run_ansible_mock):

        load_facts_mock.return_value = (MOCK_FACTS, 0)
        run_ansible_mock.return_value = 0

        ansible_config = os.path.join(self.work_dir, 'ansible.cfg')
        config = SAMPLE_CONFIG % 'openshift-enterprise'
        config = "%s\nansible_config: %s" % (config, ansible_config)
        self._ansible_config_test(load_facts_mock, run_ansible_mock,
            config, None, ansible_config)

    #pylint: disable=too-many-arguments
    # This method allows for drastically simpler tests to write, and the args
    # are all useful.
    def _ansible_config_test(self, load_facts_mock, run_ansible_mock,
        installer_config, ansible_config_cli=None, expected_result=None):
        """
        Utility method for testing the ways you can specify the ansible config.
        """

        load_facts_mock.return_value = (MOCK_FACTS, 0)
        run_ansible_mock.return_value = 0

        config_file = self.write_config(os.path.join(self.work_dir,
            'ooinstall.conf'), installer_config)

        self.cli_args.extend(["-c", config_file])
        if ansible_config_cli:
            self.cli_args.extend(["--ansible-config", ansible_config_cli])
        self.cli_args.append("install")
        result = self.runner.invoke(cli.cli, self.cli_args)
        self.assert_result(result, 0)

        # Test the env vars for facts playbook:
        facts_env_vars = load_facts_mock.call_args[0][2]
        if expected_result:
            self.assertEquals(expected_result, facts_env_vars['ANSIBLE_CONFIG'])
        else:
            # If user running test has rpm installed, this might be set to default:
            self.assertTrue('ANSIBLE_CONFIG' not in facts_env_vars or
                facts_env_vars['ANSIBLE_CONFIG'] == cli.DEFAULT_ANSIBLE_CONFIG)

        # Test the env vars for main playbook:
        env_vars = run_ansible_mock.call_args[0][2]
        if expected_result:
            self.assertEquals(expected_result, env_vars['ANSIBLE_CONFIG'])
        else:
            # If user running test has rpm installed, this might be set to default:
            self.assertTrue('ANSIBLE_CONFIG' not in env_vars or
                env_vars['ANSIBLE_CONFIG'] == cli.DEFAULT_ANSIBLE_CONFIG)

    # unattended with bad config file and no installed hosts (without --force)
    @patch('ooinstall.openshift_ansible.run_main_playbook')
    @patch('ooinstall.openshift_ansible.load_system_facts')
    def test_bad_config(self, load_facts_mock, run_playbook_mock):
        load_facts_mock.return_value = (MOCK_FACTS, 0)
        run_playbook_mock.return_value = 0

        config_file = self.write_config(os.path.join(self.work_dir,
            'ooinstall.conf'), BAD_CONFIG % 'openshift-enterprise')

        self.cli_args.extend(["-c", config_file, "install"])
        result = self.runner.invoke(cli.cli, self.cli_args)

        self.assertEquals(1, result.exit_code)
        self.assertTrue("You must specify either an ip or hostname"
            in result.output)

    #unattended with three masters, one node, and haproxy
    @patch('ooinstall.openshift_ansible.run_main_playbook')
    @patch('ooinstall.openshift_ansible.load_system_facts')
    def test_quick_ha_full_run(self, load_facts_mock, run_playbook_mock):
        load_facts_mock.return_value = (MOCK_FACTS_QUICKHA, 0)
        run_playbook_mock.return_value = 0

        config_file = self.write_config(os.path.join(self.work_dir,
            'ooinstall.conf'), QUICKHA_CONFIG % 'openshift-enterprise')

        self.cli_args.extend(["-c", config_file, "install"])
        result = self.runner.invoke(cli.cli, self.cli_args)
        self.assert_result(result, 0)

        # Make sure we ran on the expected masters and nodes:
        hosts = run_playbook_mock.call_args[0][1]
        hosts_to_run_on = run_playbook_mock.call_args[0][2]
        self.assertEquals(6, len(hosts))
        self.assertEquals(6, len(hosts_to_run_on))

    #unattended with two masters, one node, and haproxy
    @patch('ooinstall.openshift_ansible.run_main_playbook')
    @patch('ooinstall.openshift_ansible.load_system_facts')
    def test_quick_ha_only_2_masters(self, load_facts_mock, run_playbook_mock):
        load_facts_mock.return_value = (MOCK_FACTS_QUICKHA, 0)
        run_playbook_mock.return_value = 0

        config_file = self.write_config(os.path.join(self.work_dir,
            'ooinstall.conf'), QUICKHA_2_MASTER_CONFIG % 'openshift-enterprise')

        self.cli_args.extend(["-c", config_file, "install"])
        result = self.runner.invoke(cli.cli, self.cli_args)

        # This is an invalid config:
        self.assert_result(result, 1)
        self.assertTrue("A minimum of 3 Masters are required" in result.output)

    #unattended with three masters, one node, but no load balancer specified:
    @patch('ooinstall.openshift_ansible.run_main_playbook')
    @patch('ooinstall.openshift_ansible.load_system_facts')
    def test_quick_ha_no_lb(self, load_facts_mock, run_playbook_mock):
        load_facts_mock.return_value = (MOCK_FACTS_QUICKHA, 0)
        run_playbook_mock.return_value = 0

        config_file = self.write_config(os.path.join(self.work_dir,
            'ooinstall.conf'), QUICKHA_CONFIG_NO_LB % 'openshift-enterprise')

        self.cli_args.extend(["-c", config_file, "install"])
        result = self.runner.invoke(cli.cli, self.cli_args)

        # This is not a valid input:
        self.assert_result(result, 1)
        self.assertTrue('No master load balancer specified in config' in result.output)

    #unattended with three masters, one node, and one of the masters reused as load balancer:
    @patch('ooinstall.openshift_ansible.run_main_playbook')
    @patch('ooinstall.openshift_ansible.load_system_facts')
    def test_quick_ha_reused_lb(self, load_facts_mock, run_playbook_mock):
        load_facts_mock.return_value = (MOCK_FACTS_QUICKHA, 0)
        run_playbook_mock.return_value = 0

        config_file = self.write_config(os.path.join(self.work_dir,
            'ooinstall.conf'), QUICKHA_CONFIG_REUSED_LB % 'openshift-enterprise')

        self.cli_args.extend(["-c", config_file, "install"])
        result = self.runner.invoke(cli.cli, self.cli_args)

        # This is not a valid configuration:
        self.assert_result(result, 1)

    #unattended with preconfigured lb
    @patch('ooinstall.openshift_ansible.run_main_playbook')
    @patch('ooinstall.openshift_ansible.load_system_facts')
    def test_quick_ha_preconfigured_lb(self, load_facts_mock, run_playbook_mock):
        load_facts_mock.return_value = (MOCK_FACTS_QUICKHA, 0)
        run_playbook_mock.return_value = 0

        config_file = self.write_config(os.path.join(self.work_dir,
            'ooinstall.conf'), QUICKHA_CONFIG_PRECONFIGURED_LB % 'openshift-enterprise')

        self.cli_args.extend(["-c", config_file, "install"])
        result = self.runner.invoke(cli.cli, self.cli_args)
        self.assert_result(result, 0)

        # Make sure we ran on the expected masters and nodes:
        hosts = run_playbook_mock.call_args[0][1]
        hosts_to_run_on = run_playbook_mock.call_args[0][2]
        self.assertEquals(6, len(hosts))
        self.assertEquals(6, len(hosts_to_run_on))

class AttendedCliTests(OOCliFixture):

    def setUp(self):
        OOCliFixture.setUp(self)
        # Doesn't exist but keeps us from reading the local users config:
        self.config_file = os.path.join(self.work_dir, 'config.yml')
        self.cli_args.extend(["-c", self.config_file])

    @patch('ooinstall.openshift_ansible.run_main_playbook')
    @patch('ooinstall.openshift_ansible.load_system_facts')
    def test_full_run(self, load_facts_mock, run_playbook_mock):
        load_facts_mock.return_value = (MOCK_FACTS, 0)
        run_playbook_mock.return_value = 0

        cli_input = build_input(hosts=[
            ('10.0.0.1', True, False),
            ('10.0.0.2', False, False),
            ('10.0.0.3', False, False)],
                                      ssh_user='root',
                                      variant_num=1,
                                      confirm_facts='y',
                                      storage='10.1.0.1',)
        self.cli_args.append("install")
        result = self.runner.invoke(cli.cli, self.cli_args,
            input=cli_input)
        self.assert_result(result, 0)

        self._verify_load_facts(load_facts_mock)
        self._verify_run_playbook(run_playbook_mock, 4, 4)

        written_config = read_yaml(self.config_file)
        self._verify_config_hosts(written_config, 4)

        inventory = ConfigParser.ConfigParser(allow_no_value=True)
        inventory.read(os.path.join(self.work_dir, 'hosts'))
        self.assert_inventory_host_var(inventory, 'nodes', '10.0.0.1',
                                 'openshift_schedulable=False')
        self.assert_inventory_host_var_unset(inventory, 'nodes', '10.0.0.2',
                                 'openshift_schedulable=True')
        self.assert_inventory_host_var_unset(inventory, 'nodes', '10.0.0.3',
                                 'openshift_schedulable=True')

    # interactive with config file and some installed some uninstalled hosts
    @patch('ooinstall.openshift_ansible.run_main_playbook')
    @patch('ooinstall.openshift_ansible.load_system_facts')
    def test_add_nodes(self, load_facts_mock, run_playbook_mock):

        # Modify the mock facts to return a version indicating OpenShift
        # is already installed on our master, and the first node.
        mock_facts = copy.deepcopy(MOCK_FACTS)
        mock_facts['10.0.0.1']['common']['version'] = "3.0.0"
        mock_facts['10.0.0.2']['common']['version'] = "3.0.0"

        load_facts_mock.return_value = (mock_facts, 0)
        run_playbook_mock.return_value = 0

        cli_input = build_input(hosts=[
            ('10.0.0.1', True, False),
            ('10.0.0.2', False, False),
            ],
                                      add_nodes=[('10.0.0.3', False, False)],
                                      ssh_user='root',
                                      variant_num=1,
                                      confirm_facts='y',
                                      storage='10.0.0.1',)
        self.cli_args.append("install")
        result = self.runner.invoke(cli.cli,
                                    self.cli_args,
                                    input=cli_input)
        self.assert_result(result, 0)

        self._verify_load_facts(load_facts_mock)
        self._verify_run_playbook(run_playbook_mock, 3, 2)

        written_config = read_yaml(self.config_file)
        self._verify_config_hosts(written_config, 3)

    @patch('ooinstall.openshift_ansible.run_main_playbook')
    @patch('ooinstall.openshift_ansible.load_system_facts')
    def test_fresh_install_with_config(self, load_facts_mock, run_playbook_mock):
        load_facts_mock.return_value = (MOCK_FACTS, 0)
        run_playbook_mock.return_value = 0

        config_file = self.write_config(os.path.join(self.work_dir,
                                                     'ooinstall.conf'),
                                        SAMPLE_CONFIG % 'openshift-enterprise')
        cli_input = build_input(confirm_facts='y')
        self.cli_args.extend(["-c", config_file])
        self.cli_args.append("install")
        result = self.runner.invoke(cli.cli,
                                    self.cli_args,
                                    input=cli_input)
        self.assert_result(result, 0)

        self._verify_load_facts(load_facts_mock)
        self._verify_run_playbook(run_playbook_mock, 3, 3)

        written_config = read_yaml(config_file)
        self._verify_config_hosts(written_config, 3)

    #interactive with config file and all installed hosts
    @patch('ooinstall.openshift_ansible.run_main_playbook')
    @patch('ooinstall.openshift_ansible.load_system_facts')
    def test_get_hosts_to_run_on(self, load_facts_mock, run_playbook_mock):
        mock_facts = copy.deepcopy(MOCK_FACTS)
        mock_facts['10.0.0.1']['common']['version'] = "3.0.0"
        mock_facts['10.0.0.2']['common']['version'] = "3.0.0"

        cli_input = build_input(hosts=[
            ('10.0.0.1', True, False),
            ],
                                      add_nodes=[('10.0.0.2', False, False)],
                                      ssh_user='root',
                                      variant_num=1,
                                      schedulable_masters_ok=True,
                                      confirm_facts='y',
                                      storage='10.0.0.1',)

        self._verify_get_hosts_to_run_on(mock_facts, load_facts_mock,
                                         run_playbook_mock,
                                         cli_input,
                                         exp_hosts_len=2,
                                         exp_hosts_to_run_on_len=2,
                                         force=False)

    #interactive multimaster: one more node than master
    @patch('ooinstall.openshift_ansible.run_main_playbook')
    @patch('ooinstall.openshift_ansible.load_system_facts')
    def test_ha_dedicated_node(self, load_facts_mock, run_playbook_mock):
        load_facts_mock.return_value = (MOCK_FACTS_QUICKHA, 0)
        run_playbook_mock.return_value = 0

        cli_input = build_input(hosts=[
            ('10.0.0.1', True, False),
            ('10.0.0.2', True, False),
            ('10.0.0.3', True, False),
            ('10.0.0.4', False, False)],
                                      ssh_user='root',
                                      variant_num=1,
                                      confirm_facts='y',
                                      master_lb=('10.0.0.5', False),
                                      storage='10.1.0.1',)
        self.cli_args.append("install")
        result = self.runner.invoke(cli.cli, self.cli_args,
            input=cli_input)
        self.assert_result(result, 0)

        self._verify_load_facts(load_facts_mock)
        self._verify_run_playbook(run_playbook_mock, 6, 6)

        written_config = read_yaml(self.config_file)
        self._verify_config_hosts(written_config, 6)

        inventory = ConfigParser.ConfigParser(allow_no_value=True)
        inventory.read(os.path.join(self.work_dir, 'hosts'))
        self.assert_inventory_host_var(inventory, 'nodes', '10.0.0.1',
                                       'openshift_schedulable=False')
        self.assert_inventory_host_var(inventory, 'nodes', '10.0.0.2',
                                       'openshift_schedulable=False')
        self.assert_inventory_host_var(inventory, 'nodes', '10.0.0.3',
                                       'openshift_schedulable=False')
        self.assert_inventory_host_var_unset(inventory, 'nodes', '10.0.0.4',
                                             'openshift_schedulable=True')

        self.assertTrue(inventory.has_section('etcd'))
        self.assertEquals(3, len(inventory.items('etcd')))

    #interactive multimaster: identical masters and nodes
    @patch('ooinstall.openshift_ansible.run_main_playbook')
    @patch('ooinstall.openshift_ansible.load_system_facts')
    def test_ha_no_dedicated_nodes(self, load_facts_mock, run_playbook_mock):
        load_facts_mock.return_value = (MOCK_FACTS_QUICKHA, 0)
        run_playbook_mock.return_value = 0

        cli_input = build_input(hosts=[
            ('10.0.0.1', True, False),
            ('10.0.0.2', True, False),
            ('10.0.0.3', True, False)],
                                      ssh_user='root',
                                      variant_num=1,
                                      confirm_facts='y',
                                      master_lb=('10.0.0.5', False),
                                      storage='10.1.0.1',)
        self.cli_args.append("install")
        result = self.runner.invoke(cli.cli, self.cli_args,
            input=cli_input)
        self.assert_result(result, 0)

        self._verify_load_facts(load_facts_mock)
        self._verify_run_playbook(run_playbook_mock, 5, 5)

        written_config = read_yaml(self.config_file)
        self._verify_config_hosts(written_config, 5)

        inventory = ConfigParser.ConfigParser(allow_no_value=True)
        inventory.read(os.path.join(self.work_dir, 'hosts'))
        self.assert_inventory_host_var(inventory, 'nodes', '10.0.0.1',
                                       'openshift_schedulable=True')
        self.assert_inventory_host_var(inventory, 'nodes', '10.0.0.2',
                                       'openshift_schedulable=True')
        self.assert_inventory_host_var(inventory, 'nodes', '10.0.0.3',
                                       'openshift_schedulable=True')

    # Checks the inventory (as a ConfigParser) for the given host, host
    # variable, and expected value.
    def assert_inventory_host_var(self, inventory, section, host, variable):
        # Config parser splits on the first "=", so we end up with:
        #   'hostname key1' -> 'val1 key2=val2 key3=val3'
        #
        # Convert to something easier to test:
        for (a, b) in inventory.items(section):
            full_line = "%s=%s" % (a, b)
            tokens = full_line.split()
            if tokens[0] == host:
                found = False
                for token in tokens:
                    if token == variable:
                        found = True
                        continue
                self.assertTrue("Unable to find %s in line: %s" %
                                (variable, full_line), found)
                return
        self.fail("unable to find host %s in inventory" % host)

    def assert_inventory_host_var_unset(self, inventory, section, host, variable):
        # Config parser splits on the first "=", so we end up with:
        #   'hostname key1' -> 'val1 key2=val2 key3=val3'
        #
        # Convert to something easier to test:
        for (a, b) in inventory.items(section):
            full_line = "%s=%s" % (a, b)
            tokens = full_line.split()
            if tokens[0] == host:
                self.assertFalse(("%s=" % variable) in full_line,
                                 msg='%s host variable was set: %s' %
                                 (variable, full_line))
                return
        self.fail("unable to find host %s in inventory" % host)


    #interactive multimaster: attempting to use a master as the load balancer should fail:
    @patch('ooinstall.openshift_ansible.run_main_playbook')
    @patch('ooinstall.openshift_ansible.load_system_facts')
    def test_ha_reuse_master_as_lb(self, load_facts_mock, run_playbook_mock):
        load_facts_mock.return_value = (MOCK_FACTS_QUICKHA, 0)
        run_playbook_mock.return_value = 0

        cli_input = build_input(hosts=[
                                      ('10.0.0.1', True, False),
                                      ('10.0.0.2', True, False),
                                      ('10.0.0.3', False, False),
                                      ('10.0.0.4', True, False)],
                                      ssh_user='root',
                                      variant_num=1,
                                      confirm_facts='y',
                                      master_lb=(['10.0.0.2', '10.0.0.5'], False),
                                      storage='10.1.0.1')
        self.cli_args.append("install")
        result = self.runner.invoke(cli.cli, self.cli_args,
            input=cli_input)
        self.assert_result(result, 0)

    #interactive all-in-one
    @patch('ooinstall.openshift_ansible.run_main_playbook')
    @patch('ooinstall.openshift_ansible.load_system_facts')
    def test_all_in_one(self, load_facts_mock, run_playbook_mock):
        load_facts_mock.return_value = (MOCK_FACTS, 0)
        run_playbook_mock.return_value = 0

        cli_input = build_input(hosts=[
            ('10.0.0.1', True, False)],
                                      ssh_user='root',
                                      variant_num=1,
                                      confirm_facts='y',
                                      storage='10.0.0.1')
        self.cli_args.append("install")
        result = self.runner.invoke(cli.cli, self.cli_args,
            input=cli_input)
        self.assert_result(result, 0)

        self._verify_load_facts(load_facts_mock)
        self._verify_run_playbook(run_playbook_mock, 1, 1)

        written_config = read_yaml(self.config_file)
        self._verify_config_hosts(written_config, 1)

        inventory = ConfigParser.ConfigParser(allow_no_value=True)
        inventory.read(os.path.join(self.work_dir, 'hosts'))
        self.assert_inventory_host_var(inventory, 'nodes', '10.0.0.1',
                                       'openshift_schedulable=True')


    @patch('ooinstall.openshift_ansible.run_main_playbook')
    @patch('ooinstall.openshift_ansible.load_system_facts')
    def test_gen_inventory(self, load_facts_mock, run_playbook_mock):
        load_facts_mock.return_value = (MOCK_FACTS, 0)
        run_playbook_mock.return_value = 0

        cli_input = build_input(hosts=[
            ('10.0.0.1', True, False),
            ('10.0.0.2', False, False),
            ('10.0.0.3', False, False)],
                                ssh_user='root',
                                variant_num=1,
                                confirm_facts='y',
                                storage='10.1.0.1',)
        self.cli_args.append("install")
        self.cli_args.append("--gen-inventory")
        result = self.runner.invoke(cli.cli, self.cli_args,
            input=cli_input)
        self.assert_result(result, 0)

        self._verify_load_facts(load_facts_mock)

        # Make sure run playbook wasn't called:
        self.assertEquals(0, len(run_playbook_mock.mock_calls))

        written_config = read_yaml(self.config_file)
        self._verify_config_hosts(written_config, 4)

        inventory = ConfigParser.ConfigParser(allow_no_value=True)
        inventory.read(os.path.join(self.work_dir, 'hosts'))
        self.assert_inventory_host_var(inventory, 'nodes', '10.0.0.1',
                                 'openshift_schedulable=False')
        self.assert_inventory_host_var_unset(inventory, 'nodes', '10.0.0.2',
                                 'openshift_schedulable=True')
        self.assert_inventory_host_var_unset(inventory, 'nodes', '10.0.0.3',
                                 'openshift_schedulable=True')


# TODO: test with config file, attended add node
# TODO: test with config file, attended new node already in config file
# TODO: test with config file, attended new node already in config file, plus manually added nodes
# TODO: test with config file, attended reject facts