test_graphql.py

from graphqlclient import GraphQLClient
import unittest
from os import environ
from app import app
from flask_testing import LiveServerTestCase
from json import loads
from database.database import db_session
from database.models import User, Role, Application
import logging

class GraphQlTests(LiveServerTestCase):

    def create_app(self):
        app.config["TESTING"] = True
        # Disable flask console log and output
        environ['WERKZEUG_RUN_MAIN'] = 'true'
        app.logger.disabled = True
        log = logging.getLogger('werkzeug')
        log.disabled = True
        return app

    def setUp(self):
        self.client = GraphQLClient(self.get_server_url()+"/graphql")

    def tearDown(self):
        # clean up tables
        for username in ["graphqluser", "graphqluser2", "graphqluser3"]:
            user = db_session.query(User).filter_by(username=username).first()
            if user is not None:
                user.roles = []
                user.applications = []
                db_session.delete(user)
                db_session.commit()
        role = db_session.query(Role).filter_by(name="testusers").first()
        if role is not None:
            role.users = []
            db_session.delete(role)
            db_session.commit()
        application = db_session.query(Application).filter_by(name="testapp").first()
        if application is not None:
            application.users = []
            db_session.delete(application)
            db_session.commit()

    def test_query_create_and_get_user(self):
        username = "graphqluser"
        password = "randompassword"
        email = "user@example.com"
        result = self._create_user(username, password, email)
        self.assertNotIn("error", result, "Creating user failed due to an error")
        self.assertIn("data", result)
        self.assertIn("createUser", result["data"])
        self.assertIn("user", result["data"]["createUser"])
        user = result["data"]["createUser"]["user"]
        self.assertEqual(user["username"], username)
        self.assertEqual(user["email"], email)
        querystring = '''
        {{
          getUser(username: "{0}"){{
            username,
            email
         }}
        }}
        '''.format(username).strip()
        result = loads(self.client.execute(querystring))
        self.assertIn("data", result)
        self.assertIn("getUser", result["data"])
        user = result["data"]["getUser"]
        self.assertEqual(user["username"], username)
        self.assertEqual(user["email"], email)

    def test_verify_user_password(self):
        username = "graphqluser"
        password = "randompassword"
        email = "user@example.com"
        self._create_user(username, password, email)
        querystring = '''
        query{{
          verifyPassword(
            username: "{0}",
            password: "{1}")
            }}
        '''.format(username, password).strip()
        result = loads(self.client.execute(querystring))
        self.assertIn("data", result)
        self.assertTrue(result["data"]["verifyPassword"])

    def _create_user(self, username, password, email):
        querystring = '''
        mutation{{
          createUser(
            username: "{0}",
              password: "{1}",
              email: "{2}"){{
              user{{
                username,
                email}}}}}}
        '''.format(username, password, email).strip()
        return loads(self.client.execute(querystring))

    def test_create_and_assign_role(self):
        role_name = "testusers"
        role_description = "A role assigned to users during unittests"
        result = self._create_role(role_name, role_description)
        self.assertIn("data", result)
        self.assertIn("createRole", result["data"])
        self.assertIn("role", result["data"]["createRole"])
        role = result["data"]["createRole"]["role"]
        self.assertEqual(role["name"], role_name)
        self.assertEqual(role["description"], role_description)
        username = "graphqluser2"
        password = "randompassword"
        email = "user2@example.com"
        self._create_user(username, password, email)
        querystring = '''
        mutation{{
          addRoleToUser(
            username: "{0}",
            role: "{1}"){{
              user{{
                username,
                roles{{
                  edges{{
                    node{{
                      name
                    }}
                  }}
                }}
              }}
              role{{
                name,
                description
                users{{
                  edges{{
                    node{{
                      username
                    }}
                  }}
                }}
              }}
           }}
        }}
        '''.format(username, role_name).strip()
        result = loads(self.client.execute(querystring))
        self.assertIn("data", result)
        self.assertIn("addRoleToUser", result["data"])
        user = result["data"]["addRoleToUser"]["user"]
        self.assertEqual(username, user["username"])
        self.assertIn("edges", user["roles"])
        roles = user["roles"]["edges"]
        self.assertEqual(role_name, roles[0]["node"]["name"])
        role = result["data"]["addRoleToUser"]["role"]
        self.assertEqual(role_name, role["name"])
        self.assertIn("edges", role["users"])
        users = role["users"]["edges"]
        self.assertEqual(username, users[0]["node"]["username"])

    def test_remove_role_from_user(self):
        role_name = "testusers"
        role_description = "A role assigned to users during unittests"
        username = "graphqluser2"
        password = "randompassword"
        email = "user2@example.com"
        self._create_role(role_name, role_description)
        self._create_user(username, password, email)
        querystring = '''
        mutation{{
          addRoleToUser(
            username: "{0}",
            role: "{1}"){{
              user{{username}},
              role{{name}}
            }}}}'''.format(username, role_name)
        self.client.execute(querystring)
        get_user_querystring = '''
        {{
          getUser(username: "{0}"){{
            roles{{
                edges{{ node {{ name }}}}
                }}
            }}
        }}
        '''.format(username).strip()
        result = loads(self.client.execute(get_user_querystring))
        self.assertEqual(1, len(result["data"]["getUser"]["roles"]["edges"]))
        querystring = '''
        mutation{{
          removeRoleFromUser(
            username: "{0}",
            role: "{1}"){{ ok }}
            }}'''.format(username, role_name)
        result = loads(self.client.execute(querystring))
        self.assertTrue(result["data"]["removeRoleFromUser"]["ok"])
        result = loads(self.client.execute(get_user_querystring))
        self.assertEqual(0, len(result["data"]["getUser"]["roles"]["edges"]))


    def test_remove_application_from_user(self):
        application_name = "testapp"
        username = "graphqluser2"
        password = "randompassword"
        email = "user2@example.com"
        self._create_application(application_name)
        self._create_user(username, password, email)
        querystring = '''
        mutation{{
          addApplicationToUser(
            username: "{0}",
            application: "{1}"){{
              user{{username}},
              application{{name}}
            }}}}'''.format(username, application_name)
        self.client.execute(querystring)
        querystring = '''
        mutation{{
          removeApplicationFromUser(
            username: "{0}",
            application: "{1}"){{ ok }}
            }}'''.format(username, application_name)
        result = loads(self.client.execute(querystring))
        self.assertTrue(result["data"]["removeApplicationFromUser"]["ok"])
        querystring = '''
        {{
          getUser(username: "{0}"){{
            applications{{
                edges{{ node {{ name }}}}
                }}
            }}
        }}
        '''.format(username).strip()
        result = loads(self.client.execute(querystring))
        self.assertEqual(0, len(result["data"]["getUser"]["applications"]["edges"]))


    def _create_role(self, name, description):
        querystring = '''
        mutation{{
          createRole(
            name: "{0}",
            description: "{1}"){{
              role{{
                name,
                description}}}}}}
        '''.format(name, description).strip()
        return loads(self.client.execute(querystring))

    def test_create_and_assign_application(self):
        application_name = "testapp"
        result = self._create_application(application_name)
        self.assertIn("data", result)
        self.assertIn("createApplication", result["data"])
        self.assertIn("application", result["data"]["createApplication"])
        application = result["data"]["createApplication"]["application"]
        self.assertEqual(application["name"], application_name)
        username = "graphqluser3"
        password = "randompassword"
        email = "user3@example.com"
        self._create_user(username, password, email)
        querystring = '''
        mutation{{
          addApplicationToUser(
            username: "{0}",
            application: "{1}"){{
              user{{
                username,
                applications{{
                  edges{{
                    node{{
                      name
                    }}
                  }}
                }}
              }}
              application{{
                name,
                users{{
                  edges{{
                    node{{
                      username
                    }}
                  }}
                }}
              }}
           }}
        }}
        '''.format(username, application_name).strip()
        result = loads(self.client.execute(querystring))
        self.assertIn("data", result)
        self.assertIn("addApplicationToUser", result["data"])
        user = result["data"]["addApplicationToUser"]["user"]
        self.assertEqual(username, user["username"])
        self.assertIn("edges", user["applications"])
        applications = user["applications"]["edges"]
        self.assertEqual(application_name, applications[0]["node"]["name"])
        application = result["data"]["addApplicationToUser"]["application"]
        self.assertEqual(application_name, application["name"])
        self.assertIn("edges", application["users"])
        users = application["users"]["edges"]
        self.assertEqual(username, users[0]["node"]["username"])

    def _create_application(self, name):
        querystring = '''
        mutation{{
          createApplication(
            name: "{0}"){{
              application{{
                name}}}}}}
        '''.format(name).strip()
        return loads(self.client.execute(querystring))

    def test_delete_user(self):
        username = "graphqluser"
        password = "randompassword"
        email = "user@example.com"
        self._create_user(username, password, email)
        querystring = '''
        mutation{{
          deleteUser(username: "{0}"){{
            ok
            }}
        }}
        '''.format(username).strip()
        result = loads(self.client.execute(querystring))
        self.assertIn("data", result)
        self.assertTrue(result["data"]["deleteUser"]["ok"])
        querystring = '''
        {{
          getUser(username: "{0}"){{
            username,
            email
         }}
        }}
        '''.format(username).strip()
        result = loads(self.client.execute(querystring))
        self.assertIs(None, result["data"]["getUser"])

    def test_bulk_queries(self):
        username = "graphqluser"
        password = "randompassword"
        email = "user@example.com"
        role_name = "testusers"
        role_description = "A role assigned to users during unittests"
        application_name = "testapp"
        self._create_user(username, password, email)
        result = self._create_role(role_name, role_description)
        result = self._create_application(application_name)
        querystring = '''
        query{ allUsers{ edges { node { username, email }}},
               allRoles{ edges { node { name, description }}},
               allApplications{ edges { node { name }}}}
        '''
        result = loads(self.client.execute(querystring))
        self.assertIn("allUsers", result["data"] )
        users = result["data"]["allUsers"]["edges"]
        self.assertEqual(users[0]["node"]["username"], username)
        self.assertEqual(users[0]["node"]["email"], email)
        self.assertIn("allRoles", result["data"] )
        roles = result["data"]["allRoles"]["edges"]
        self.assertEqual(roles[0]["node"]["name"], role_name)
        self.assertEqual(roles[0]["node"]["description"], role_description)
        applications = result["data"]["allApplications"]["edges"]
        self.assertEqual(applications[0]["node"]["name"], application_name)

    def test_edit_user(self):
        username = "graphqluser"
        password = "randompassword"
        email = "user@example.com"
        new_password = "new_randompassword"
        new_email = "new_user@example.com"
        self._create_user(username, password, email)
        querystring = '''
        mutation{{
          editUser(username: "{0}", password: "{1}"){{
            ok
            }}
        }}
        '''.format(username, new_password).strip()
        result = loads(self.client.execute(querystring))
        self.assertIn("data", result)
        self.assertTrue(result["data"]["editUser"]["ok"])
        querystring = '''
        query{{
          verifyPassword(
            username: "{0}",
            password: "{1}")
            }}
        '''.format(username, new_password).strip()
        result = loads(self.client.execute(querystring))
        self.assertIn("data", result)
        self.assertTrue(result["data"]["verifyPassword"])
        querystring = '''
        mutation{{
          editUser(username: "{0}", email: "{1}"){{
            ok
            }}
        }}
        '''.format(username, new_email).strip()
        result = loads(self.client.execute(querystring))
        self.assertIn("data", result)
        self.assertTrue(result["data"]["editUser"]["ok"])
        querystring = '''
        {{
          getUser(username: "{0}"){{
            email
         }}
        }}
        '''.format(username).strip()
        result = loads(self.client.execute(querystring))
        self.assertEqual(new_email, result["data"]["getUser"]["email"])