peshay / tpm

            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."""

        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)

            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."""

        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)

            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."""

        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)

            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."""

        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)

        """Test function unarchive_project."""

        path_to_mock = 'projects/4/unarchive.json'

        request_url = api_url + path_to_mock

        with requests_mock.Mocker() as m:

            m.put(request_url, status_code=204)

            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)

            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."""

        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)

            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."""

        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)

            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."""

        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)

        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_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)

        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_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)

        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()

        # 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)

        resource_file = os.path.normpath(request_path)

        data_file = open(resource_file)

        data = sorted(json.load(data_file), key=lambda k: k['id'])

        with requests_mock.Mocker() as m:

            fake_data(request_url, m)

            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)

        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_favorite()

        # 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)

            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."""

        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()

    def test_wrong_url_exception(self):

        """Exception if URL does not match REGEXurl."""

        wrong_url = 'ftp://tpm.example.com'

        with self.assertRaises(tpm.TpmApiv4.ConfigError) as context:

            tpm.TpmApiv4(wrong_url, username='USER', password='PASS')

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

        self.assertEqual("'Invalid URL: {}'".format(wrong_url), str(context.exception))

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 "

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

            self.client.list_passwords()

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