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

"""

 (c) 2015 - Copyright Red Hat Inc

 Authors:

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

"""

from __future__ import unicode_literals

__requires__ = ['SQLAlchemy >= 0.8']

import pkg_resources

import arrow

import copy

import datetime

import unittest

import shutil

import sys

import time

import os

import flask

import json

import munch

from mock import patch, MagicMock

from sqlalchemy.exc import SQLAlchemyError

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

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

import pagure

import pagure.lib

import tests

FULL_ISSUE_LIST = [

  {

    "assignee": None,

    "blocks": [],

    "close_status": None,

    "closed_at": None,

    "comments": [],

    "content": "We should work on this",

    "custom_fields": [],

    "date_created": "1431414800",

    "depends": [],

    "id": 2,

    "last_updated": "1431414800",

    "milestone": None,

    "priority": None,

    "private": True,

    "status": "Closed",

    "tags": [],

    "title": "Test issue",

    "user": {

      "fullname": "PY C",

      "name": "pingou"

    }

  },

  {

    "assignee": {'fullname': 'foo bar', 'name': 'foo'},

    "blocks": [],

    "close_status": None,

    "closed_at": None,

    "comments": [],

    "content": "This issue needs attention",

    "custom_fields": [],

    "date_created": "1431414800",

    "depends": [],

    "id": 8,

    "last_updated": "1431414800",

    "milestone": None,

    "priority": None,

    "private": True,

    "status": "Open",

    "tags": [],

    "title": "test issue1",

    "user": {

      "fullname": "PY C",

      "name": "pingou"

    }

  },

  {

    "assignee": None,

    "blocks": [],

    "close_status": None,

    "closed_at": None,

    "comments": [],

    "content": "This issue needs attention",

    "custom_fields": [],

    "date_created": "1431414800",

    "depends": [],

    "id": 7,

    "last_updated": "1431414800",

    "milestone": None,

    "priority": None,

    "private": True,

    "status": "Open",

    "tags": [],

    "title": "test issue",

    "user": {

      "fullname": "PY C",

      "name": "pingou"

    }

  },

  {

    "assignee": None,

    "blocks": [],

    "close_status": None,

    "closed_at": None,

    "comments": [],

    "content": "This issue needs attention",

    "custom_fields": [],

    "date_created": "1431414800",

    "depends": [],

    "id": 6,

    "last_updated": "1431414800",

    "milestone": None,

    "priority": None,

    "private": False,

    "status": "Open",

    "tags": [],

    "title": "test issue",

    "user": {

      "fullname": "PY C",

      "name": "pingou"

    }

  },

  {

    "assignee": None,

    "blocks": [],

    "close_status": None,

    "closed_at": None,

    "comments": [],

    "content": "This issue needs attention",

    "custom_fields": [],

    "date_created": "1431414800",

    "depends": [],

    "id": 5,

    "last_updated": "1431414800",

    "milestone": None,

    "priority": None,

    "private": False,

    "status": "Open",

    "tags": [],

    "title": "test issue",

    "user": {

      "fullname": "PY C",

      "name": "pingou"

    }

  },

  {

    "assignee": None,

    "blocks": [],

    "close_status": None,

    "closed_at": None,

    "comments": [],

    "content": "This issue needs attention",

    "custom_fields": [],

    "date_created": "1431414800",

    "depends": [],

    "id": 4,

    "last_updated": "1431414800",

    "milestone": None,

    "priority": None,

    "private": False,

    "status": "Open",

    "tags": [],

    "title": "test issue",

    "user": {

      "fullname": "PY C",

      "name": "pingou"

    }

  },

  {

    "assignee": None,

    "blocks": [],

    "close_status": None,

    "closed_at": None,

    "comments": [],

    "content": "This issue needs attention",

    "custom_fields": [],

    "date_created": "1431414800",

    "depends": [],

    "id": 3,

    "last_updated": "1431414800",

    "milestone": None,

    "priority": None,

    "private": False,

    "status": "Open",

    "tags": [],

    "title": "test issue",

    "user": {

      "fullname": "PY C",

      "name": "pingou"

    }

  },

  {

    "assignee": None,

    "blocks": [],

    "close_status": None,

    "closed_at": None,

    "comments": [],

    "content": "This issue needs attention",

    "custom_fields": [],

    "date_created": "1431414800",

    "depends": [],

    "id": 2,

    "last_updated": "1431414800",

    "milestone": "milestone-1.0",

    "priority": None,

    "private": False,

    "status": "Open",

    "tags": [],

    "title": "test issue",

    "user": {

      "fullname": "PY C",

      "name": "pingou"

    }

  },

  {

    "assignee": None,

    "blocks": [],

    "close_status": None,

    "closed_at": None,

    "comments": [],

    "content": "This issue needs attention",

    "custom_fields": [],

    "date_created": "1431414800",

    "depends": [],

    "id": 1,

    "last_updated": "1431414800",

    "milestone": None,

    "priority": None,

    "private": False,

    "status": "Open",

    "tags": [],

    "title": "test issue",

    "user": {

      "fullname": "PY C",

      "name": "pingou"

    }

  }

]

LCL_ISSUES = [

  {

    'assignee': None,

    'blocks': [],

    'close_status': None,

    'closed_at': None,

    'comments': [],

    'content': 'Description',

    'custom_fields': [],

    'date_created': '1431414800',

    'depends': [],

    'id': 2,

    'last_updated': '1431414800',

    'milestone': None,

    'priority': None,

    'private': False,

    'status': 'Open',

    'tags': [],

    'title': 'Issue #2',

    'user': {'fullname': 'PY C', 'name': 'pingou'}

  },

  {

    'assignee': None,

    'blocks': [],

    'close_status': None,

    'closed_at': None,

    'comments': [],

    'content': 'Description',

    'custom_fields': [],

    'date_created': '1431414800',

    'depends': [],

    'id': 1,

    'last_updated': '1431414800',

    'milestone': None,

    'priority': None,

    'private': False,

    'status': 'Open',

    'tags': [],

    'title': 'Issue #1',

    'user': {'fullname': 'PY C', 'name': 'pingou'}

   }

]

class PagureFlaskApiIssuetests(tests.SimplePagureTest):

    """ Tests for the flask API of pagure for issue """

    maxDiff = None

    def setUp(self):

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

        super(PagureFlaskApiIssuetests, self).setUp()

        pagure.config.config['TICKETS_FOLDER'] = None

    def test_api_new_issue_wrong_token(self):

        """ Test the api_new_issue method of the flask api. """

        tests.create_projects(self.session)

        tests.create_projects_git(

            os.path.join(self.path, 'tickets'), bare=True)

        tests.create_tokens(self.session)

        tests.create_tokens_acl(self.session)

        headers = {'Authorization': 'token aaabbbcccddd'}

        # Valid token, wrong project

        output = self.app.post('/api/0/test2/new_issue', headers=headers)

        self.assertEqual(output.status_code, 401)

        data = json.loads(output.get_data(as_text=True))

        self.assertEqual(sorted(data.keys()), ['error', 'error_code'])

        self.assertEqual(

            pagure.api.APIERROR.EINVALIDTOK.value, data['error'])

        self.assertEqual(

            pagure.api.APIERROR.EINVALIDTOK.name, data['error_code'])

    def test_api_new_issue_no_input(self):

        """ Test the api_new_issue method of the flask api. """

        tests.create_projects(self.session)

        tests.create_projects_git(

            os.path.join(self.path, 'tickets'), bare=True)

        tests.create_tokens(self.session)

        tests.create_tokens_acl(self.session)

        headers = {'Authorization': 'token aaabbbcccddd'}

        # No input

        output = self.app.post('/api/0/test/new_issue', headers=headers)

        self.assertEqual(output.status_code, 400)

        data = json.loads(output.get_data(as_text=True))

        self.assertDictEqual(

            data,

            {

              "error": "Invalid or incomplete input submitted",

              "error_code": "EINVALIDREQ",

              "errors": {

                "issue_content": ["This field is required."],

                "title": ["This field is required."],

              }

            }

        )

    def test_api_new_issue_invalid_repo(self):

        """ Test the api_new_issue method of the flask api. """

        tests.create_projects(self.session)

        tests.create_projects_git(

            os.path.join(self.path, 'tickets'), bare=True)

        tests.create_tokens(self.session)

        tests.create_tokens_acl(self.session)

        headers = {'Authorization': 'token aaabbbcccddd'}

        data = {

            'title': 'test issue'

        }

        # Invalid repo

        output = self.app.post(

            '/api/0/foo/new_issue', data=data, headers=headers)

        self.assertEqual(output.status_code, 404)

        data = json.loads(output.get_data(as_text=True))

        self.assertDictEqual(

            data,

            {

              "error": "Project not found",

              "error_code": "ENOPROJECT",

            }

        )

    def test_api_new_issue_invalid_request(self):

        """ Test the api_new_issue method of the flask api. """

        tests.create_projects(self.session)

        tests.create_projects_git(

            os.path.join(self.path, 'tickets'), bare=True)

        tests.create_tokens(self.session)

        tests.create_tokens_acl(self.session)

        headers = {'Authorization': 'token aaabbbcccddd'}

        # Incomplete request

        output = self.app.post(

            '/api/0/test/new_issue', data={}, headers=headers)

        self.assertEqual(output.status_code, 400)

        data = json.loads(output.get_data(as_text=True))

        self.assertDictEqual(

            data,

            {

              "error": "Invalid or incomplete input submitted",

              "error_code": "EINVALIDREQ",

              "errors": {

                "issue_content": ["This field is required."],

                "title": ["This field is required."]

              }

            }

        )

    def test_api_new_issue(self):

        """ Test the api_new_issue method of the flask api. """

        tests.create_projects(self.session)

        tests.create_projects_git(

            os.path.join(self.path, 'tickets'), bare=True)

        tests.create_tokens(self.session)

        tests.create_tokens_acl(self.session)

        headers = {'Authorization': 'token aaabbbcccddd'}

        data = {

            'title': 'test issue',

            'issue_content': 'This issue needs attention',

        }

        # Valid request

        output = self.app.post(

            '/api/0/test/new_issue', data=data, headers=headers)

        self.assertEqual(output.status_code, 200)

        data = json.loads(output.get_data(as_text=True))

        data['issue']['date_created'] = '1431414800'

        data['issue']['last_updated'] = '1431414800'

        self.assertDictEqual(

            data,

            {

              "issue": FULL_ISSUE_LIST[8],

              "message": "Issue created"

            }

        )

    def test_api_new_issue_img(self):

        """ Test the api_new_issue method of the flask api. """

        tests.create_projects(self.session)

        tests.create_projects_git(

            os.path.join(self.path, 'tickets'), bare=True)

        tests.create_tokens(self.session)

        tests.create_tokens_acl(self.session)

        headers = {'Authorization': 'token aaabbbcccddd'}

        with open(os.path.join(tests.HERE, 'placebo.png'), 'rb') as stream:

            data = {

                'title': 'test issue',

                'issue_content': 'This issue needs attention ',

                'filestream': stream,

            }

            # Valid request

            output = self.app.post(

                '/api/0/test/new_issue', data=data, headers=headers)

            self.assertEqual(output.status_code, 200)

            data = json.loads(output.get_data(as_text=True))

            data['issue']['date_created'] = '1431414800'

            data['issue']['last_updated'] = '1431414800'

            issue = copy.deepcopy(FULL_ISSUE_LIST[8])

            issue['id'] = 1

            self.assertIn(

                'pagure_tests_placebo.png)](/test/issue/raw/files/'

                '8a06845923010b27bfd8e7e75acff7badc40d1021b4994e01f5e11ca'

                '40bc3abe', data['issue']['content']

            )

            data['issue']['content'] = 'This issue needs attention'

            self.assertDictEqual(

                data,

                {

                  "issue": issue,

                  "message": "Issue created"

                }

            )

    def test_api_new_issue_invalid_milestone(self):

        """ Test the api_new_issue method of the flask api. """

        tests.create_projects(self.session)

        tests.create_projects_git(

            os.path.join(self.path, 'tickets'), bare=True)

        tests.create_tokens(self.session)

        tests.create_tokens_acl(self.session)

        headers = {'Authorization': 'token aaabbbcccddd'}

        # Valid request but invalid milestone

        data = {

            'title': 'test issue',

            'issue_content': 'This issue needs attention',

            'milestone': ['milestone-1.0'],

        }

        output = self.app.post(

            '/api/0/test/new_issue', data=data, headers=headers)

        self.assertEqual(output.status_code, 400)

        data = json.loads(output.get_data(as_text=True))

        self.assertDictEqual(

            data,

            {

              "error": "Invalid or incomplete input submitted",

              "error_code": "EINVALIDREQ",

              "errors": {

                "milestone": [

                  "Not a valid choice"

                ]

              }

            }

        )

    def test_api_new_issue_milestone(self):

        """ Test the api_new_issue method of the flask api. """

        tests.create_projects(self.session)

        tests.create_projects_git(

            os.path.join(self.path, 'tickets'), bare=True)

        tests.create_tokens(self.session)

        tests.create_tokens_acl(self.session)

        headers = {'Authorization': 'token aaabbbcccddd'}

        # Set some milestones

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

        repo.milestones = {'milestone-1.0': '', 'milestone-2.0': 'Tomorrow!'}

        self.session.add(repo)

        self.session.commit()

        # Valid request with milestone

        data = {

            'title': 'test issue',

            'issue_content': 'This issue needs attention',

            'milestone': ['milestone-1.0'],

        }

        output = self.app.post(

            '/api/0/test/new_issue', data=data, headers=headers)

        self.assertEqual(output.status_code, 200)

        data = json.loads(output.get_data(as_text=True))

        data['issue']['date_created'] = '1431414800'

        data['issue']['last_updated'] = '1431414800'

        issue = copy.deepcopy(FULL_ISSUE_LIST[7])

        issue['id'] = 1

        self.assertDictEqual(

            data,

            {

              "issue": issue,

              "message": "Issue created"

            }

        )

    def test_api_new_issue_public(self):

        """ Test the api_new_issue method of the flask api. """

        tests.create_projects(self.session)

        tests.create_projects_git(

            os.path.join(self.path, 'tickets'), bare=True)

        tests.create_tokens(self.session)

        tests.create_tokens_acl(self.session)

        headers = {'Authorization': 'token aaabbbcccddd'}

        # Valid request, with private='false'

        data = {

            'title': 'test issue',

            'issue_content': 'This issue needs attention',

            'private': 'false',

        }

        output = self.app.post(

            '/api/0/test/new_issue', data=data, headers=headers)

        self.assertEqual(output.status_code, 200)

        data = json.loads(output.get_data(as_text=True))

        data['issue']['date_created'] = '1431414800'

        data['issue']['last_updated'] = '1431414800'

        issue = copy.deepcopy(FULL_ISSUE_LIST[6])

        issue['id'] = 1

        self.assertDictEqual(

            data,

            {

              "issue": issue,

              "message": "Issue created"

            }

        )

        # Valid request, with private=False

        data = {

            'title': 'test issue',

            'issue_content': 'This issue needs attention',

            'private': False

        }

        output = self.app.post(

            '/api/0/test/new_issue', data=data, headers=headers)

        self.assertEqual(output.status_code, 200)

        data = json.loads(output.get_data(as_text=True))

        data['issue']['date_created'] = '1431414800'

        data['issue']['last_updated'] = '1431414800'

        issue = copy.deepcopy(FULL_ISSUE_LIST[5])

        issue['id'] = 2

        self.assertDictEqual(

            data,

            {

              "issue": issue,

              "message": "Issue created"

            }

        )

        # Valid request, with private='False'

        data = {

            'title': 'test issue',

            'issue_content': 'This issue needs attention',

            'private': 'False'

        }

        output = self.app.post(

            '/api/0/test/new_issue', data=data, headers=headers)

        self.assertEqual(output.status_code, 200)

        data = json.loads(output.get_data(as_text=True))

        data['issue']['date_created'] = '1431414800'

        data['issue']['last_updated'] = '1431414800'

        issue = copy.deepcopy(FULL_ISSUE_LIST[4])

        issue['id'] = 3

        self.assertDictEqual(

            data,

            {

              "issue": issue,

              "message": "Issue created"

            }

        )

        # Valid request, with private=0

        data = {

            'title': 'test issue',

            'issue_content': 'This issue needs attention',

            'private': 0

        }

        output = self.app.post(

            '/api/0/test/new_issue', data=data, headers=headers)

        self.assertEqual(output.status_code, 200)

        data = json.loads(output.get_data(as_text=True))

        data['issue']['date_created'] = '1431414800'

        data['issue']['last_updated'] = '1431414800'

        issue = copy.deepcopy(FULL_ISSUE_LIST[3])

        issue['id'] = 4

        self.assertDictEqual(

            data,

            {

              "issue": issue,

              "message": "Issue created"

            }

        )

    def test_api_new_issue_private(self):

        """ Test the api_new_issue method of the flask api. """

        tests.create_projects(self.session)

        tests.create_projects_git(

            os.path.join(self.path, 'tickets'), bare=True)

        tests.create_tokens(self.session)

        tests.create_tokens_acl(self.session)

        headers = {'Authorization': 'token aaabbbcccddd'}

        # Private issue: True

        data = {

            'title': 'test issue',

            'issue_content': 'This issue needs attention',

            'private': True,

        }

        output = self.app.post(

            '/api/0/test/new_issue', data=data, headers=headers)

        self.assertEqual(output.status_code, 200)

        data = json.loads(output.get_data(as_text=True))

        data['issue']['date_created'] = '1431414800'

        data['issue']['last_updated'] = '1431414800'

        issue = copy.deepcopy(FULL_ISSUE_LIST[2])

        issue['id'] = 1

        self.assertDictEqual(

            data,

            {

              "issue": issue,

              "message": "Issue created"

            }

        )

        # Private issue: 1

        data = {

            'title': 'test issue1',

            'issue_content': 'This issue needs attention',

            'private': 1,

            'assignee': 'foo'

        }

        output = self.app.post(

            '/api/0/test/new_issue', data=data, headers=headers)

        self.assertEqual(output.status_code, 200)

        data = json.loads(output.get_data(as_text=True))

        data['issue']['date_created'] = '1431414800'

        data['issue']['last_updated'] = '1431414800'

        exp = copy.deepcopy(FULL_ISSUE_LIST[1])

        exp['id'] = 2

        self.assertDictEqual(

            data,

            {

              "issue": exp,

              "message": "Issue created"

            }

        )

    @patch('pagure.api.check_api_acls', MagicMock(return_value=None))

    def test_api_new_issue_raise_db_error(self):

        """ Test the api_new_issue method of the flask api. """

        tests.create_projects(self.session)

        tests.create_projects_git(

            os.path.join(self.path, 'tickets'), bare=True)

        tests.create_tokens(self.session)

        tests.create_tokens_acl(self.session)

        headers = {'Authorization': 'token aaabbbcccddd'}

        data = {

            'title': 'test issue',

            'issue_content': 'This issue needs attention',

        }

        with self._app.test_request_context('/') as ctx:

            flask.g.session = self.session

            flask.g.fas_user = tests.FakeUser(username='foo')

            with patch(

                    'flask.g.session.commit',

                    MagicMock(side_effect=SQLAlchemyError('DB error'))):

                output = self.app.post(

                    '/api/0/test/new_issue', data=data, headers=headers)

                self.assertEqual(output.status_code, 400)

                data = json.loads(output.get_data(as_text=True))

                self.assertDictEqual(

                    data,

                    {

                        u'error': u'An error occurred at the database '

                        'level and prevent the action from reaching '

                        'completion',

                        u'error_code': u'EDBERROR'

                    }

                )

    def test_api_new_issue_user_token_no_input(self):

        """ Test the api_new_issue method of the flask api. """

        tests.create_projects(self.session)

        tests.create_projects_git(

            os.path.join(self.path, 'tickets'), bare=True)

        tests.create_tokens(self.session, project_id=None)

        tests.create_tokens_acl(self.session)

        headers = {'Authorization': 'token aaabbbcccddd'}

        # Valid token, invalid request - No input

        output = self.app.post('/api/0/test2/new_issue', headers=headers)

        self.assertEqual(output.status_code, 400)

        data = json.loads(output.get_data(as_text=True))

        self.assertDictEqual(

            data,

            {

              "error": "Invalid or incomplete input submitted",

              "error_code": "EINVALIDREQ",

              "errors": {

                "issue_content": ["This field is required."],

                "title": ["This field is required."],

              }

            }

        )

    def test_api_new_issue_user_token_invalid_user(self):

        """ Test the api_new_issue method of the flask api. """

        tests.create_projects(self.session)

        tests.create_projects_git(

            os.path.join(self.path, 'tickets'), bare=True)

        tests.create_tokens(self.session, project_id=None)

        tests.create_tokens_acl(self.session)

        headers = {'Authorization': 'token aaabbbcccddd'}

        # Another project, still an invalid request - No input

        output = self.app.post('/api/0/test/new_issue', headers=headers)

        self.assertEqual(output.status_code, 400)

        data = json.loads(output.get_data(as_text=True))

        self.assertDictEqual(

            data,

            {

              "error": "Invalid or incomplete input submitted",

              "error_code": "EINVALIDREQ",

              "errors": {

                "issue_content": ["This field is required."],

                "title": ["This field is required."],

              }

            }

        )

    def test_api_new_issue_user_token_invalid_repo(self):

        """ Test the api_new_issue method of the flask api. """

        tests.create_projects(self.session)

        tests.create_projects_git(

            os.path.join(self.path, 'tickets'), bare=True)

        tests.create_tokens(self.session, project_id=None)

        tests.create_tokens_acl(self.session)

        headers = {'Authorization': 'token aaabbbcccddd'}

        data = {

            'title': 'test issue'

        }

        # Invalid repo

        output = self.app.post(

            '/api/0/foo/new_issue', data=data, headers=headers)

        self.assertEqual(output.status_code, 404)

        data = json.loads(output.get_data(as_text=True))

        self.assertDictEqual(

            data,

            {

              "error": "Project not found",

              "error_code": "ENOPROJECT",

            }

        )

    def test_api_new_issue_user_token_invalid_request(self):

        """ Test the api_new_issue method of the flask api. """

        tests.create_projects(self.session)

        tests.create_projects_git(

            os.path.join(self.path, 'tickets'), bare=True)

        tests.create_tokens(self.session, project_id=None)

        tests.create_tokens_acl(self.session)

        headers = {'Authorization': 'token aaabbbcccddd'}

        # Incomplete request

        output = self.app.post(

            '/api/0/test/new_issue', data={}, headers=headers)

        self.assertEqual(output.status_code, 400)

        data = json.loads(output.get_data(as_text=True))

        self.assertDictEqual(

            data,

            {

              "error": "Invalid or incomplete input submitted",

              "error_code": "EINVALIDREQ",

              "errors": {

                "issue_content": ["This field is required."],

                "title": ["This field is required."]

              }

            }

        )

    def test_api_new_issue_user_token(self):

        """ Test the api_new_issue method of the flask api. """

        tests.create_projects(self.session)

        tests.create_projects_git(

            os.path.join(self.path, 'tickets'), bare=True)

        tests.create_tokens(self.session, project_id=None)

        tests.create_tokens_acl(self.session)

        headers = {'Authorization': 'token aaabbbcccddd'}

        data = {

            'title': 'test issue',

            'issue_content': 'This issue needs attention',

        }

        # Valid request

        output = self.app.post(

            '/api/0/test/new_issue', data=data, headers=headers)

        self.assertEqual(output.status_code, 200)

        data = json.loads(output.get_data(as_text=True))

        data['issue']['date_created'] = '1431414800'

        data['issue']['last_updated'] = '1431414800'