peshay / tpm

            # number of passwords as from original json file.

            self.assertEqual(data, response)

    def test_function_list_subprojects_action_new_pwd(self):

        """Test function list_subprojects_action_new_pwd."""

        action = 'new_pwd'

        for project in Projects:

            project_id = project.get('id')

            log.debug("Testing with Project ID: {}".format(project_id))

            path_to_mock = 'projects/{}/subprojects/{}.json'.format(project_id, action)

            request_url = api_url + path_to_mock

            request_path = local_path + path_to_mock

            resource_file = os.path.normpath(request_path)

            data_file = open(resource_file)

            data = json.load(data_file)

            with requests_mock.Mocker() as m:

                fake_data(request_url, m)

                response = self.client.list_subprojects_action(project_id, action)

            # number of passwords as from original json file.

            self.assertEqual(data, response)

class ClientPasswordTestCase(unittest.TestCase):

    """Test cases for all password related queries."""

    def setUp(self):

        self.client = tpm.TpmApiv4('https://tpm.example.com', username='USER', password='PASS')

    def test_paging(self):

        """Test paging, if number of items is same as from original data source."""

        path_to_mock = 'passwords.json'

        request_url = api_url + path_to_mock

        request_path = local_path + path_to_mock

        resource_file = os.path.normpath(request_path)

        data_file = open(resource_file)

        data = json.load(data_file)

        with requests_mock.Mocker() as m:

            fake_data(request_url, m)

            response = self.client.list_passwords()

        # number of passwords as from original json file.

        source_items = len(data)

        response_items = len(response)

        log.debug("Source Items: {}; Response Items: {}".format(source_items, response_items))

        self.assertEqual(source_items, response_items)

    def test_provide_unlock_reason(self):

        """Test providing an unlock reason."""

            # number of passwords as from original json file.

            self.assertEqual(data, response)

    def test_function_show_mypassword(self):

        """Test function show_mypassword."""

        for password in MyPasswords:

            password_id = password.get('id')

            log.debug("Testing with Password ID: {}".format(password_id))

            path_to_mock = 'my_passwords/{}.json'.format(password_id)

            request_url = api_url + path_to_mock

            request_path = local_path + path_to_mock

            resource_file = os.path.normpath(request_path)

            data_file = open(resource_file)

            data = json.load(data_file)

            with requests_mock.Mocker() as m:

                fake_data(request_url, m)

                response = self.client.show_mypassword(password_id)

            # number of passwords as from original json file.

            self.assertEqual(data, response)

    def test_function_create_mypassword(self):

        """Test function create_mypassword."""

            # number of passwords as from original json file.

            self.assertEqual(data, response)

    def test_function_list_user_access_on_password(self):

        """Test function list_user_access_on_password."""

        for password in Passwords:

            password_id = password.get('id')

            log.debug("Testing with Password ID: {}".format(password_id))

            path_to_mock = 'passwords/{}/security.json'.format(password_id)

            request_url = api_url + path_to_mock

            request_path = local_path + path_to_mock

            resource_file = os.path.normpath(request_path)

            data_file = open(resource_file)

            data = json.load(data_file)

            with requests_mock.Mocker() as m:

                fake_data(request_url, m)

                response = self.client.list_user_access_on_password(password_id)

            # number of passwords as from original json file.

            self.assertEqual(data, response)

    def test_function_create_password(self):

        """Test function create_password."""

            # number of passwords as from original json file.

            self.assertEqual(data, response)

    def test_function_show_password(self):

        """Test function show_password."""

        for password in Passwords:

            password_id = password.get('id')

            log.debug("Testing with Password ID: {}".format(password_id))

            path_to_mock = 'passwords/{}.json'.format(password_id)

            request_url = api_url + path_to_mock

            request_path = local_path + path_to_mock

            resource_file = os.path.normpath(request_path)

            data_file = open(resource_file)

            data = json.load(data_file)

            with requests_mock.Mocker() as m:

                fake_data(request_url, m)

                response = self.client.show_password(password_id)

            # number of passwords as from original json file.

            self.assertEqual(data, response)

    def test_function_list_user_access_on_password(self):

        """Test function list_user_access_on_password."""

            response = self.client.unarchive_project('4')

        self.assertEqual(response, None)

    def test_function_list_subprojects(self):

        """Test function list_subprojects."""

        for project in Projects:

            project_id = project.get('id')

            log.debug("Testing with Project ID: {}".format(project_id))

            path_to_mock = 'projects/{}/subprojects.json'.format(project_id)

            request_url = api_url + path_to_mock

            request_path = local_path + path_to_mock

            resource_file = os.path.normpath(request_path)

            data_file = open(resource_file)

            data = json.load(data_file)

            with requests_mock.Mocker() as m:

                fake_data(request_url, m)

                response = self.client.list_subprojects(project_id)

            # number of passwords as from original json file.

            self.assertEqual(data, response)

    def test_function_list_subprojects_action_new_pwd(self):

        """Test function list_subprojects_action_new_pwd."""

            # number of passwords as from original json file.

            self.assertEqual(data, response)

    def test_function_list_user_access_on_project(self):

        """Test function list_user_access_on_project."""

        for project in Projects:

            project_id = project.get('id')

            log.debug("Testing with Project ID: {}".format(project_id))

            path_to_mock = 'projects/{}/security.json'.format(project_id)

            request_url = api_url + path_to_mock

            request_path = local_path + path_to_mock

            resource_file = os.path.normpath(request_path)

            data_file = open(resource_file)

            data = json.load(data_file)

            with requests_mock.Mocker() as m:

                fake_data(request_url, m)

                response = self.client.list_user_access_on_project(project_id)

            # number of passwords as from original json file.

            self.assertEqual(data, response)

    def test_function_create_project(self):

        """Test function create_project."""

            # number of passwords as from original json file.

            self.assertEqual(data, response)

    def test_function_list_passwords_of_project(self):

        """Test function list_passwords_of_project."""

        for project in Projects:

            project_id = project.get('id')

            log.debug("Testing with Project ID: {}".format(project_id))

            path_to_mock = 'projects/{}/passwords.json'.format(project_id)

            request_url = api_url + path_to_mock

            request_path = local_path + path_to_mock

            resource_file = os.path.normpath(request_path)

            data_file = open(resource_file)

            data = json.load(data_file)

            with requests_mock.Mocker() as m:

                fake_data(request_url, m)

                response = self.client.list_passwords_of_project(project_id)

            # number of passwords as from original json file.

            self.assertEqual(data, response)

    def test_function_list_user_access_on_project(self):

        """Test function list_user_access_on_project."""

            # number of passwords as from original json file.

            self.assertEqual(data, response)

    def test_function_show_project(self):

        """Test function show_project."""

        for project in Projects:

            project_id = project.get('id')

            log.debug("Testing with Project ID: {}".format(project_id))

            path_to_mock = 'projects/{}.json'.format(project_id)

            request_url = api_url + path_to_mock

            request_path = local_path + path_to_mock

            resource_file = os.path.normpath(request_path)

            data_file = open(resource_file)

            data = json.load(data_file)

            with requests_mock.Mocker() as m:

                fake_data(request_url, m)

                response = self.client.show_project(project_id)

            # number of passwords as from original json file.

            self.assertEqual(data, response)

    def test_function_list_passwords_of_project(self):

        """Test function list_passwords_of_project."""

            response = self.client.list_groups()

        self.assertEqual(data, response)

    def test_function_show_group(self):

        """Test function show_group."""

        for group in Groups:

            group_id = group.get('id')

            log.debug("Testing with Project ID: {}".format(group_id))

            path_to_mock = 'groups/{}.json'.format(group_id)

            request_url = api_url + path_to_mock

            request_path = local_path + path_to_mock

            resource_file = os.path.normpath(request_path)

            data_file = open(resource_file)

            data = json.load(data_file)

            with requests_mock.Mocker() as m:

                fake_data(request_url, m)

                response = self.client.show_group(group_id)

            self.assertEqual(data, response)

    def test_function_create_group(self):

        """Test function create_group."""

            response = self.client.list_users()

        self.assertEqual(data, response)

    def test_function_show_user(self):

        """Test function show_user."""

        for user in Users:

            user_id = user.get('id')

            log.debug("Testing with Project ID: {}".format(user_id))

            path_to_mock = 'users/{}.json'.format(user_id)

            request_url = api_url + path_to_mock

            request_path = local_path + path_to_mock

            resource_file = os.path.normpath(request_path)

            data_file = open(resource_file)

            data = json.load(data_file)

            with requests_mock.Mocker() as m:

                fake_data(request_url, m)

                response = self.client.show_user(user_id)

            self.assertEqual(data, response)

    def test_function_show_me(self):

        """Test function show_me."""

        # number of passwords as from original json file.

        self.assertEqual(data, response)

    def test_function_list_mypasswords_search(self):

        """Test function list_mypasswords_search."""

        searches = ['amazon', 'backup', 'facebook', 'john', 'jonny']

        for search in searches:

            path_to_mock = 'my_passwords/search/{}.json'.format(search)

            request_url = api_url + path_to_mock

            request_path = local_path + path_to_mock

            resource_file = os.path.normpath(request_path)

            data_file = open(resource_file)

            data = json.load(data_file)

            with requests_mock.Mocker() as m:

                fake_data(request_url, m)

                response = self.client.list_mypasswords_search(search)

            # number of passwords as from original json file.

            self.assertEqual(data, response)

    def test_function_show_mypassword(self):

        """Test function show_mypassword."""

            response = sorted(self.client.list_passwords_favorite(), key=lambda k: k['id'])

        self.assertEqual(data, response)

    def test_function_list_passwords_search(self):

        """Test function list_passwords_search."""

        searches = ['backup', 'dns', 'facebook', 'firewall', 'reddit', 'test']

        for search in searches:

            path_to_mock = 'passwords/search/{}.json'.format(search)

            request_url = api_url + path_to_mock

            request_path = local_path + path_to_mock

            resource_file = os.path.normpath(request_path)

            data_file = open(resource_file)

            data = json.load(data_file)

            with requests_mock.Mocker() as m:

                fake_data(request_url, m)

                response = self.client.list_passwords_search(search)

            # number of passwords as from original json file.

            self.assertEqual(data, response)

    def test_function_show_password(self):

        """Test function show_password."""

        # number of passwords as from original json file.

        self.assertEqual(data, response)

    def test_function_list_projects_search(self):

        """Test function list_projects_search."""

        searches = ['company', 'internal', 'website']

        for search in searches:

            path_to_mock = 'projects/search/{}.json'.format(search)

            request_url = api_url + path_to_mock

            request_path = local_path + path_to_mock

            resource_file = os.path.normpath(request_path)

            data_file = open(resource_file)

            data = json.load(data_file)

            with requests_mock.Mocker() as m:

                fake_data(request_url, m)

                response = self.client.list_projects_search(search)

            # number of passwords as from original json file.

            self.assertEqual(data, response)

    def test_function_show_project(self):

        """Test function show_project."""

                response = self.client.show_user(user_id)

            self.assertEqual(data, response)

    def test_function_show_me(self):

        """Test function show_me."""

        path_to_mock = 'users/me.json'

        request_url = api_url + path_to_mock

        request_path = local_path + path_to_mock

        resource_file = os.path.normpath(request_path)

        data_file = open(resource_file)

        data = json.load(data_file)

        with requests_mock.Mocker() as m:

            fake_data(request_url, m)

            response = self.client.show_me()

            response2 = self.client.who_am_i()

        self.assertEqual(data, response)

        self.assertEqual(response2, response)

    def test_function_create_user(self):

        """Test function create_user."""

class ExceptionOnRequestsTestCases(unittest.TestCase):

    """Test case for Request based Exceptions."""

    def setUp(self):

        self.client = tpm.TpmApiv4('https://tpm.example.com', username='USER', password='PASS')

    def test_connection_exception(self):

        """Exception if connection fails."""

        exception_error = "Connection error for HTTPSConnectionPool(host='tpm.example.com', port=443)"

        with self.assertRaises(tpm.TPMException) as context:

            self.client.list_passwords()

        log.debug("context exception: {}".format(context.exception))

        self.assertTrue(exception_error in str(context.exception))

    def test_value_error_exception(self):

        """Exception if value is not json format."""

        path_to_mock = 'passwords/value_error.json'

        request_url = api_url + path_to_mock

        exception_error = "No JSON object could be decoded: "

        exception_error3 = "Expecting value: line 1 column 1 (char 0): "

        resource_file = os.path.normpath('tests/resources/{}'.format(path_to_mock))