#!/usr/bin/env python2
import unittest
import httplib

from zdesk import ZendeskError

from zendesk_sync import ZendeskSync
from zendesk_sync.zendesk_sync import format_name
from clean_users_test import CleanUsersTest


class TestUsers(CleanUsersTest):
    """
    Make sure user related actions work
    """

    def test_create_user(self):
        # we make sure that create_user can create a user
        self.zs.create_user(
            self.user_uuid,
            self.primary_email,
            self.emails,
            self.fullname,
            self.username)
        user = self.zs.get_user(self.user_uuid)
        self.assertEqual(user['external_id'], self.user_uuid)

    def test_duplicate_uuid(self):
        # create two users with the same uuid and see the error
        self.zs.create_user(
            self.user_uuid,
            self.primary_email,
            self.emails,
            self.fullname,
            self.username)
        with self.assertRaises(ZendeskError) as context:
            self.zs.create_user(
                self.user_uuid,
                self.primary_email2,
                self.emails2,
                self.fullname,
                self.username)
        self.assertEqual(context.exception.error_code, httplib.UNPROCESSABLE_ENTITY)

    def test_user_suspend(self):
        # we make sure that create_user can create a user
        self.test_create_user()
        self.assertTrue(self.zs.safe_suspend_user(self.user_uuid))
        user = self.zs.get_user(self.user_uuid)
        self.assertTrue(user['suspended'])

    def test_user_suspend_fail(self):
        self.assertFalse(self.zs.safe_suspend_user(self.user_uuid))

    def test_user_merging(self):
        self.zs.safe_delete_user_by_email(self.primary_email)
        # create a user with no uuid
        old_user_id = self.zs.create_user_no_merge(
            "",
            self.primary_email,
            self.emails,
            self.fullname,
            self.username)
        self.assertEqual(int(old_user_id), int(self.zs.get_user_by_email(self.primary_email)['id']))
        # check if the two users were merged when a user with a uuid was
        # created
        new_user_id = self.zs.create_user(
            self.user_uuid,
            self.primary_email,
            self.emails,
            self.fullname,
            self.username)
        idents = self.zs.list_identities(self.user_uuid)
        self.assertEqual(len(idents), 1)
        self.assertEqual(idents[0]['value'], self.primary_email.lower())
        # The old user is destroyed by being merged into the new one
        self.assertNotEqual(old_user_id, new_user_id)
        self.assertEqual(int(new_user_id), int(self.zs.get_user_by_email(self.primary_email)['id']))

    def test_user_merging_existing_uuid(self):
        self.zs.safe_delete_user_by_email(self.primary_email)
        # create a user with a uuid
        old_user_id = self.zs.create_user_no_merge(
            self.user_uuid,
            self.primary_email,
            self.emails,
            self.fullname,
            self.username)
        self.assertEqual(int(old_user_id), int(self.zs.get_user_by_email(self.primary_email)['id']))
        # check if the two users were merged when a user with a uuid was
        # created
        new_user_id = self.zs.create_user(
            self.user_uuid2,
            self.primary_email,
            self.emails,
            self.fullname,
            self.username)
        idents = self.zs.list_identities(self.user_uuid2)
        self.assertEqual(len(idents), 1)
        self.assertEqual(idents[0]['value'], self.primary_email.lower())
        # The old user is destroyed by being merged into the new one
        self.assertNotEqual(old_user_id, new_user_id)
        self.assertEqual(int(new_user_id), int(self.zs.get_user_by_email(self.primary_email)['id']))

    def test_safe_create_user(self):
        self.zs.safe_create_user(
            self.user_uuid,
            self.primary_email,
            self.emails,
            self.fullname,
            self.username)
        # we make sure that the first user creation attempt worked
        user = self.zs.get_user(self.user_uuid)
        self.assertEqual(user['name'], self.fullname + ' (' + self.username + ')')
        # we make sure that an attempt to create a user that exists does not
        # cause an error
        self.assertIsNone(self.zs.safe_create_user(
            self.user_uuid,
            self.primary_email,
            self.emails,
            self.fullname,
            self.username))

    def test_update_existing_user(self):
        self.zs.create_user(
            self.user_uuid,
            self.primary_email,
            self.emails,
            self.fullname,
            self.username)
        user = self.zs.get_user(self.user_uuid)
        self.assertEqual(user['name'], format_name(self.username, self.fullname))
        # we make sure that we can change the user's self.username and full
        # name
        self.zs.safe_create_update_user(
            self.user_uuid,
            self.primary_email,
            self.emails,
            self.fullname2,
            self.username2)
        user = self.zs.get_user(self.user_uuid)
        self.assertEqual(user['name'], format_name(self.username2, self.fullname2))
        # and again with unicode!
        unicode_name = u'{0}{1}'.format(self.fullname2, u'\u1234')
        self.zs.safe_create_update_user(
            self.user_uuid,
            self.primary_email,
            self.emails,
            unicode_name,
            self.username2)
        user = self.zs.get_user(self.user_uuid)
        self.assertEqual(user['name'], format_name(self.username2, unicode_name))

    def test_update_create_user(self):
        # we make sure that safe_create_update_user can create a user
        self.zs.safe_create_update_user(
            self.user_uuid,
            self.primary_email,
            self.emails,
            self.fullname2,
            self.username2)
        user = self.zs.get_user(self.user_uuid)
        self.assertEqual(user['name'], format_name(self.username2, self.fullname2))

    def test_create_update_user_no_primary(self):
        # we make sure that we don't need a primary email
        self.zs.safe_create_update_user(
            self.user_uuid,
            None,
            self.emails,
            self.fullname2,
            self.username2)
        user = self.zs.get_user(self.user_uuid)
        self.assertEqual(user['name'], format_name(self.username2, self.fullname2))


if __name__ == '__main__':
    unittest.main()