#-*- coding: utf-8 -*-

"""

 (c) 2015 - Copyright Red Hat Inc

 Authors:

   Pierre-Yves Chibon <pingou@pingoured.fr></pingou@pingoured.fr>

"""

__requires__ = ['SQLAlchemy >= 0.7']

import pkg_resources

import unittest

import sys

import os

from datetime import date

from datetime import timedelta

from functools import wraps

from contextlib import contextmanager

from sqlalchemy import create_engine

from sqlalchemy.orm import sessionmaker

from sqlalchemy.orm import scoped_session

sys.path.insert(0, os.path.join(os.path.dirname(

    os.path.abspath(__file__)), '..'))

import progit.lib

import progit.lib.model

DB_PATH = 'sqlite:///:memory:'

FAITOUT_URL = 'http://209.132.184.152/faitout/'

if os.environ.get('BUILD_ID'):

    try:

        import requests

        req = requests.get('%s/new' % FAITOUT_URL)

        if req.status_code == 200:

            DB_PATH = req.text

            print 'Using faitout at: %s' % DB_PATH

    except:

        pass

@contextmanager

def user_set(APP, user):

    """ Set the provided user as fas_user in the provided application."""

    # Hack used to remove the before_request function set by

    # flask.ext.fas_openid.FAS which otherwise kills our effort to set a

    # flask.g.fas_user.

    from flask import appcontext_pushed, g

    APP.before_request_funcs[None] = []

    def handler(sender, **kwargs):

        g.fas_user = user

    with appcontext_pushed.connected_to(handler, APP):

        yield

class Modeltests(unittest.TestCase):

    """ Model tests. """

    def __init__(self, method_name='runTest'):

        """ Constructor. """

        unittest.TestCase.__init__(self, method_name)

        self.session = None

    # pylint: disable=C0103

    def setUp(self):

        """ Set up the environnment, ran before every tests. """

        self.session = progit.lib.model.create_tables(DB_PATH)

        # Create a couple of users

        item = progit.lib.model.User(

            user='pingou',

            fullname='PY C',

            password='foo',

        )

        self.session.add(item)

        item = progit.lib.model.User(

            user='foo',

            fullname='foo bar',

            password='foo',

        )

        self.session.add(item)

        self.session.commit()

    # pylint: disable=C0103

    def tearDown(self):

        """ Remove the test.db database if there is one. """

        self.session.close()

        if os.path.exists(DB_PATH):

            os.unlink(DB_PATH)

        if DB_PATH.startswith('postgres'):

            if 'localhost' in DB_PATH:

                progit.lib.model.drop_tables(DB_PATH, self.session.bind)

            else:

                db_name = DB_PATH.rsplit('/', 1)[1]

                requests.get('%s/clean/%s' % (FAITOUT_URL, db_name))

class FakeGroup(object):

    """ Fake object used to make the FakeUser object closer to the

    expectations.

    """

    def __init__(self, name):

        """ Constructor.

        :arg name: the name given to the name attribute of this object.

        """

        self.name = name

        self.group_type = 'cla'

# pylint: disable=R0903

class FakeUser(object):

    """ Fake user used to test the fedocallib library. """

    def __init__(self, groups=[], username='username', cla_done=True):

        """ Constructor.

        :arg groups: list of the groups in which this fake user is

            supposed to be.

        """

        if isinstance(groups, basestring):

            groups = [groups]

        self.groups = groups

        self.username = username

        self.name = username

        self.approved_memberships = [

            FakeGroup('packager'),

            FakeGroup('design-team')

        ]

        self.dic = {}

        self.dic['timezone'] = 'Europe/Paris'

        self.cla_done = cla_done

    def __getitem__(self, key):

        return self.dic[key]

def create_projects(session):

    """ Create some projects in the database. """

    item = progit.lib.model.Project(

        user_id=1,  # pingou

        name='test',

        description='test project #1',

    )

    session.add(item)

    item = progit.lib.model.Project(

        user_id=1,  # pingou

        name='test2',

        description='test project #2',

    )

    session.add(item)

    session.commit()

if __name__ == '__main__':

    SUITE = unittest.TestLoader().loadTestsFromTestCase(Modeltests)

    unittest.TextTestRunner(verbosity=2).run(SUITE)