#!/usr/bin/env python

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

"""

 (c) 2016 - Copyright Red Hat Inc

 Authors:

   Adam Williamson <awilliam@redhat.com></awilliam@redhat.com>

Tests for the Pagure streaming server.

"""

# obviously this is fine for testing.

# pylint: disable=locally-disabled, protected-access

from __future__ import unicode_literals

import logging

import os

import sys

import unittest

import mock

import six

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

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

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

    os.path.abspath(__file__)), '../pagure-ev'))

if six.PY3:

    raise unittest.case.SkipTest('Skipping on python3')

import pagure.lib.query                             # pylint: disable=wrong-import-position

from pagure.exceptions import PagureException, PagureEvException     # pylint: disable=wrong-import-position

import tests                                        # pylint: disable=wrong-import-position

# comes from ev-server/

import pagure_stream_server as pss                  # pylint: disable=wrong-import-position, import-error

logging.basicConfig(stream=sys.stderr)

class StreamingServerTests(tests.Modeltests):

    """Tests for the streaming server."""

    def setUp(self):

        """Set up the environnment, run before every test."""

        super(StreamingServerTests, self).setUp()

        # Make sure the server uses the existing session

        pss.SESSION = self.session

        # Mock send_email, we never want to send or see emails here.

        self.mailpatcher = mock.patch('pagure.lib.notify.send_email')

        self.mailpatcher.start()

        # Setup projects

        tests.create_projects(self.session)

        self.repo = pagure.lib.query._get_project(self.session, 'test')

        self.repo2 = pagure.lib.query._get_project(self.session, 'test2')

        # Disable repo 2's issue tracker and PR tracker

        pagure.lib.query.update_project_settings(

            session=self.session,

            repo=self.repo2,

            user='pingou',

            settings={

                'issue_tracker': False,

                'pull_requests': False,

            }

        )

        # Create a public issue

        pagure.lib.query.new_issue(

            session=self.session,

            repo=self.repo,

            title='Test issue',

            content='We should work on this',

            user='pingou',

        )

        # Create a private issue

        pagure.lib.query.new_issue(

            session=self.session,

            repo=self.repo,

            title='Private issue #2',

            content='The world can see my porn folder',

            user='pingou',

            private=True,

        )

        # Create a PR

        pagure.lib.query.new_pull_request(

            session=self.session,

            repo_from=self.repo,

            repo_to=self.repo,

            branch_from='feature',

            branch_to='master',

            title='Test PR',

            user='pingou',

        )

    def tearDown(self):

        "Stop the patchers, as well as calling super."""

        super(StreamingServerTests, self).tearDown()

        self.mailpatcher.stop()

    def test_parse_path(self):

        """Tests for _parse_path."""

        # Result format is: (username, namespace, repo, objtype, objid)

        # Simple case: issue for non-namespaced, non-forked repo.

        result = pagure.utils.parse_path('/pagure/issue/1')

        self.assertEqual(result, (None, None, 'pagure', 'issue', '1'))

        # Pull request for namespaced repo.

        result = pagure.utils.parse_path('/fedora-qa/fedfind/pull-request/2')

        self.assertEqual(result, (None, 'fedora-qa', 'fedfind', 'pull-request', '2'))

        # Issue for forked repo.

        result = pagure.utils.parse_path('/fork/adamwill/pagure/issue/3')

        self.assertEqual(result, ('adamwill', None, 'pagure', 'issue', '3'))

        # Issue for forked, namespaced repo.

        result = pagure.utils.parse_path('/fork/pingou/fedora-qa/fedfind/issue/4')

        self.assertEqual(result, ('pingou', 'fedora-qa', 'fedfind', 'issue', '4'))

        # Issue for repo named 'pull-request' (yeah, now we're getting tricksy).

        result = pagure.utils.parse_path('/pull-request/issue/5')

        self.assertEqual(result, (None, None, 'pull-request', 'issue', '5'))

        # Unknown object type.

        six.assertRaisesRegex(

            self,

            PagureException,

            r"No known object",

            pagure.utils.parse_path,

            '/pagure/unexpected/1'

        )

        # No object ID.

        six.assertRaisesRegex(

            self,

            PagureException,

            r"No project or object ID",

            pagure.utils.parse_path,

            '/pagure/issue'

        )

        # No repo name. Note: we cannot catch 'namespace but no repo name',

        # but that should fail later in pagure.lib.query.get_project

        six.assertRaisesRegex(

            self,

            PagureException,

            r"No project or object ID",

            pagure.utils.parse_path,

            '/issue/1'

        )

        # /fork but no user name.

        six.assertRaisesRegex(

            self,

            PagureException,

            r"no user found!",

            pagure.utils.parse_path,

            '/fork/pagure/issue/1'

        )

        # Too many path components before object type.

        six.assertRaisesRegex(

            self,

            PagureException,

            r"More path components",

            pagure.utils.parse_path,

            '/fork/adamwill/fedora-qa/fedfind/unexpected/issue/1'

        )

        six.assertRaisesRegex(

            self,

            PagureException,

            r"More path components",

            pagure.utils.parse_path,

            '/fedora-qa/fedfind/unexpected/issue/1'

        )

    def test_get_issue(self):

        """Tests for _get_issue."""

        # Simple case: get the existing issue from the existing repo.

        result = pss._get_issue(self.repo, '1')

        self.assertEqual(result.id, 1)

        # Issue that doesn't exist.

        six.assertRaisesRegex(

            self,

            PagureEvException,

            r"Issue '3' not found",

            pss._get_issue, self.repo, '3'

        )

        # Private issue (for now we don't handle auth).

        six.assertRaisesRegex(

            self,

            PagureEvException,

            r"issue is private",

            pss._get_issue, self.repo, '2'

        )

        # Issue from a project with no issue tracker.

        six.assertRaisesRegex(

            self,

            PagureEvException,

            r"No issue tracker found",

            pss._get_issue, self.repo2, '1'

        )

    def test_get_pull_request(self):

        """Tests for _get_pull_request."""

        # Simple case: get the existing PR from the existing repo.

        result = pss._get_pull_request(self.repo, '3')

        self.assertEqual(result.id, 3)

        # PR that doesn't exist.

        six.assertRaisesRegex(

            self,

            PagureEvException,

            r"Pull-Request '2' not found",

            pss._get_pull_request, self.repo, '2'

        )

        # PR from a project with no PR tracker.

        six.assertRaisesRegex(

            self,

            PagureEvException,

            r"No pull-request tracker found",

            pss._get_pull_request, self.repo2, '1'

        )

    def test_get_obj_from_path(self):

        """Tests for get_obj_from_path."""

        # Simple issue case.

        result = pss.get_obj_from_path('/test/issue/1')

        self.assertEqual(result.id, 1)

        # Simple PR case.

        result = pss.get_obj_from_path('/test/pull-request/3')

        self.assertEqual(result.id, 3)

        # Non-existent repo.

        six.assertRaisesRegex(

            self,

            PagureEvException,

            r"Project 'foo' not found",

            pss.get_obj_from_path, '/foo/issue/1'

        )

        # NOTE: we cannot test the 'Invalid object provided' exception

        # as it's a backup (current code will never hit it)

if __name__ == '__main__':

    unittest.main(verbosity=2)