#!/usr/bin/python

from os import path
from pprint import pprint

import os
import unittest
import yaml
import sys
import subprocess
class KSclient(object):
    def setUp(self):
        try:
            self.keystone_OS_USERNAME = os.environ['OS_USERNAME']
            self.keystone_OS_PASSWORD = os.environ['OS_PASSWORD']
            self.keystone_OS_AUTH_URL = os.environ['OS_AUTH_URL']
            self.keystone_OS_TENANT_NAME = os.environ['OS_TENANT_NAME']
        except Exception as e:
            _e_msg = 'Unable to find all required environment variables: '\
                ' OS_USERNAME OS_PASSWORD OS_AUTH_URL OS_TENANT_NAME'
            raise type(e)(_e_msg)

    def keystone_connect(self):
        self.setUp()
        from keystoneclient.v2_0 import client
        _c = client.Client(
            auth_url=self.keystone_OS_AUTH_URL,
            username=self.keystone_OS_USERNAME,
            password=self.keystone_OS_PASSWORD,
            tenant_name=self.keystone_OS_TENANT_NAME)
        return _c

    def get_srvc_catalog(self):
        ks = self.keystone_connect()
        sc = ks.service_catalog.get_endpoints()
        return sc

class SSLTestSet(unittest.TestCase):
    """SSL related unit tests"""

    def setUp(self):
        """This method runs before every test"""
        self.config_in = '/home/stack/user_config.yaml'
        self.config_out = '/home/stack/templates/user_config.yaml'
        with open(self.config_in) as f_config_in:
            self.yaml_config_in = yaml.safe_load(f_config_in)
        with open(self.config_out) as f_config_out:
            self.yaml_config_out = yaml.safe_load(f_config_out)

    def tearDown(self):
        """No need to cleanup after test execution"""
        pass

    def test_config_in(self):
        """Does /home/stack/user_config.yaml exists"""
        self.assertTrue(path.exists(self.config_in))
        self.assertTrue(path.isfile(self.config_in))

    def test_config_out(self):
        """Does /home/stack/templates/user_config.yaml exists"""
        self.assertTrue(path.exists(self.config_out))
        self.assertTrue(path.isfile(self.config_out))

    def test_config_in_data(self):
        self.assertTrue(self.yaml_config_in,
                        "No data in {}".format(self.config_in))
        self.assertIsInstance(self.yaml_config_in, dict,
                              "Data from {} not a dict".format(self.config_in))

    def test_config_out_data(self):
        self.assertTrue(self.yaml_config_out,
                        "No data in {}".format(self.config_out))
        self.assertIsInstance(self.yaml_config_out, dict,
                              "Data from {} not a dict".format(self.config_out))

    def test_tls_enable_presence_in(self):
        self.assertTrue(self.yaml_config_in['CBIS']['common']['enable_tls'])

    def test_tls_enable_presence_out(self):
        self.assertTrue(self.yaml_config_out['CBIS']['common']['enable_tls'])

    def test_ssl_public(self):
        with open('/home/stack/overcloudrc') as data:
           lines = data.readlines()
        for line in lines:
           var = line.split(' ')[1].split('=')[0].strip()
           val = line.split(' ')[1].split('=')[1].strip()
           os.environ[var] = val
        ksc = KSclient()
        self.sc = ksc.get_srvc_catalog()
        for service in self.sc.keys():
            self.assertTrue(self.sc[service][0]['publicURL'].startswith('https://'),
                "Found a non-https endpoint for {}".format(service))


if __name__ == '__main__':
    config_in = '/home/stack/user_config.yaml'
    with open(config_in) as f_config_in:
        yaml_config_in = yaml.safe_load(f_config_in)
    if not yaml_config_in['CBIS']['common']['enable_tls']:
        sys.exit(0)
    unittest.main()