')[0]
747 | assert equal_no_whitespace(
748 | urllib.parse.unquote(example_query),
749 | textwrap.dedent(
750 | """
751 | {
752 | TABLE {
753 | totalCount
754 | pageInfo {
755 | hasNextPage
756 | endCursor
757 | }
758 | nodes {
759 | COLUMNS
760 | }
761 | }
762 | }
763 | """.replace(
764 | "TABLE", graphql_table
765 | ).replace(
766 | "COLUMNS", columns
767 | )
768 | ),
769 | )
770 |
771 |
772 | @pytest.mark.asyncio
773 | async def test_graphql_reserved_column_names(ds):
774 | response = await ds.client.post(
775 | "/graphql",
776 | json={
777 | "query": """{
778 | table_with_reserved_columns {
779 | nodes {
780 | id
781 | if_
782 | description_
783 | }
784 | }
785 | }"""
786 | },
787 | )
788 | assert response.status_code == 200
789 | assert response.json() == {
790 | "data": {
791 | "table_with_reserved_columns": {
792 | "nodes": [
793 | {"id": 1, "if_": "keyword if", "description_": "a description"}
794 | ]
795 | }
796 | }
797 | }
798 |
799 |
800 | @pytest.mark.asyncio
801 | async def test_graphql_dangerous_column_names(ds):
802 | response = await ds.client.post(
803 | "/graphql",
804 | json={
805 | "query": """{
806 | table_with_dangerous_columns {
807 | nodes {
808 | _0_Starts_With_Hash
809 | _0_double_underscore
810 | }
811 | }
812 | }"""
813 | },
814 | )
815 | assert response.status_code == 200
816 | assert response.json() == {
817 | "data": {
818 | "table_with_dangerous_columns": {
819 | "nodes": [{"_0_Starts_With_Hash": 2, "_0_double_underscore": 3}]
820 | }
821 | }
822 | }
823 |
824 |
825 | @pytest.mark.asyncio
826 | async def test_bad_foreign_keys(ds):
827 | # https://github.com/simonw/datasette-graphql/issues/79
828 | response = await ds.client.post(
829 | "/graphql",
830 | json={
831 | "query": """{
832 | bad_foreign_key {
833 | nodes {
834 | fk
835 | }
836 | }
837 | }"""
838 | },
839 | )
840 | assert response.status_code == 200
841 | assert response.json() == {"data": {"bad_foreign_key": {"nodes": [{"fk": 1}]}}}
842 |
843 |
844 | @pytest.mark.asyncio
845 | async def test_alternative_graphql():
846 | graphql_path = "/-/graphql"
847 | ds = Datasette(
848 | [],
849 | memory=True,
850 | metadata={
851 | "plugins": {
852 | "datasette-graphql": {
853 | "path": graphql_path,
854 | }
855 | }
856 | },
857 | )
858 | # First check for menu
859 | response = await ds.client.get("/")
860 | if graphql_path is None:
861 | assert "GraphQL API" not in response.text
862 | else:
863 | assert (
864 | 'GraphQL API'.format(graphql_path)
865 | in response.text
866 | )
867 | # Now check for direct access
868 | if graphql_path is None:
869 | response = await ds.client.get("/graphql")
870 | assert response.status_code == 404
871 | else:
872 | response = await ds.client.get(graphql_path, headers={"Accept": "text/html"})
873 | assert response.status_code == 200
874 | assert "GraphiQL" in response.text
875 |
--------------------------------------------------------------------------------
/tests/test_plugin_hook.py:
--------------------------------------------------------------------------------
1 | from datasette import hookimpl
2 | from datasette.plugins import pm
3 | from datasette.app import Datasette
4 | import graphene
5 | import pytest
6 |
7 |
8 | @pytest.mark.asyncio
9 | async def test_graphql_extra_fields_hook():
10 | class InfoPlugin:
11 | __name__ = "InfoPlugin"
12 |
13 | @hookimpl
14 | def graphql_extra_fields(self, datasette, database):
15 | class Info(graphene.ObjectType):
16 | "Extra information"
17 | key = graphene.String()
18 | value = graphene.String()
19 |
20 | async def info_resolver(root, info):
21 | db = datasette.get_database(database)
22 | result = await db.execute("select 1 + 1")
23 | return [
24 | {
25 | "key": "static",
26 | "value": "static",
27 | },
28 | {
29 | "key": "database",
30 | "value": database,
31 | },
32 | {"key": "1+1", "value": result.single_value()},
33 | ]
34 |
35 | return [
36 | (
37 | "info",
38 | graphene.Field(
39 | graphene.List(Info),
40 | description="List of extra info",
41 | resolver=info_resolver,
42 | ),
43 | ),
44 | ]
45 |
46 | pm.register(InfoPlugin(), name="undo")
47 | try:
48 | ds = Datasette([], memory=True)
49 | response = await ds.client.post(
50 | "/graphql",
51 | json={
52 | "query": """{
53 | info {
54 | key
55 | value
56 | }
57 | }"""
58 | },
59 | )
60 | assert response.status_code == 200
61 | assert response.json() == {
62 | "data": {
63 | "info": [
64 | {"key": "static", "value": "static"},
65 | {"key": "database", "value": "_memory"},
66 | {"key": "1+1", "value": "2"},
67 | ]
68 | }
69 | }
70 | finally:
71 | pm.unregister(name="undo")
72 |
--------------------------------------------------------------------------------
/tests/test_schema_caching.py:
--------------------------------------------------------------------------------
1 | from datasette.app import Datasette
2 | from datasette_graphql.utils import schema_for_database, _schema_cache
3 | import sqlite_utils
4 | import pytest
5 | from unittest import mock
6 | import sys
7 | from .fixtures import build_database
8 |
9 |
10 | @pytest.mark.skipif(
11 | sys.version_info < (3, 8),
12 | reason="async mocks from patch() require 3.8 or higher - #52",
13 | )
14 | @pytest.mark.asyncio
15 | @mock.patch("datasette_graphql.utils.schema_for_database")
16 | async def test_schema_caching(mock_schema_for_database, tmp_path_factory):
17 | mock_schema_for_database.side_effect = schema_for_database
18 | db_directory = tmp_path_factory.mktemp("dbs")
19 | db_path = db_directory / "schema.db"
20 | db = sqlite_utils.Database(db_path)
21 | build_database(db)
22 |
23 | # Previous tests will have populated the cache
24 | _schema_cache.clear()
25 |
26 | assert len(_schema_cache) == 0
27 |
28 | # The first hit should call schema_for_database
29 | assert not mock_schema_for_database.called
30 | ds = Datasette([str(db_path)])
31 | response = await ds.client.get("/graphql/schema.graphql")
32 | assert response.status_code == 200
33 | assert "view_on_table_with_pkSort" in response.text
34 |
35 | assert mock_schema_for_database.called
36 |
37 | assert len(_schema_cache) == 1
38 |
39 | mock_schema_for_database.reset_mock()
40 |
41 | # The secod hit should NOT call it
42 | assert not mock_schema_for_database.called
43 | response = await ds.client.get("/graphql/schema.graphql")
44 | assert response.status_code == 200
45 | assert "view_on_table_with_pkSort" in response.text
46 | assert "new_table" not in response.text
47 |
48 | assert not mock_schema_for_database.called
49 |
50 | current_keys = set(_schema_cache.keys())
51 | assert len(current_keys) == 1
52 |
53 | # We change the schema and it should be called again
54 | db["new_table"].insert({"new_column": 1})
55 |
56 | response = await ds.client.get("/graphql/schema.graphql")
57 | assert response.status_code == 200
58 | assert "view_on_table_with_pkSort" in response.text
59 | assert "new_table" in response.text
60 |
61 | assert mock_schema_for_database.called
62 |
63 | assert len(_schema_cache) == 1
64 | assert set(_schema_cache.keys()) != current_keys
65 |
--------------------------------------------------------------------------------
/tests/test_schema_for_database.py:
--------------------------------------------------------------------------------
1 | from datasette_graphql.utils import schema_for_database
2 | from graphql import graphql
3 | import pytest
4 | from .fixtures import ds, db_path
5 |
6 |
7 | @pytest.mark.asyncio
8 | async def test_schema(ds):
9 | schema = (await schema_for_database(ds)).schema
10 |
11 | query = """{
12 | users {
13 | totalCount
14 | nodes {
15 | name
16 | points
17 | score
18 | }
19 | }
20 | }"""
21 |
22 | result = await schema.execute_async(query)
23 | assert result.data == {
24 | "users": {
25 | "totalCount": 2,
26 | "nodes": [
27 | {"name": "cleopaws", "points": 5, "score": 51.5},
28 | {"name": "simonw", "points": 3, "score": 35.2},
29 | ],
30 | }
31 | }, result.errors
32 |
--------------------------------------------------------------------------------
/tests/test_template_tag.py:
--------------------------------------------------------------------------------
1 | from datasette.app import Datasette
2 | import pytest
3 | from .fixtures import db_path
4 |
5 | TEMPLATE = r'''
6 | {% set users = graphql("""
7 | {
8 | users {
9 | nodes {
10 | name
11 | points
12 | score
13 | }
14 | }
15 | }
16 | """)["users"] %}
17 | {% for user in users.nodes %}
18 | {{ user.name }} - points: {{ user.points }}, score = {{ user.score }}
19 | {% endfor %}
20 | '''
21 |
22 | TEMPLATE_WITH_VARS = r'''
23 | {% set user = graphql("""
24 | query ($id: Int) {
25 | users_row(id: $id) {
26 | id
27 | name
28 | }
29 | }
30 | """, variables={"id": 2})["users_row"] %}
31 | {{ user.id }}: {{ user.name }}
32 | '''
33 |
34 |
35 | @pytest.mark.asyncio
36 | @pytest.mark.parametrize(
37 | "template,expected",
38 | [
39 | (
40 | TEMPLATE,
41 | "cleopaws - points: 5, score = 51.5
\n\n"
42 | " simonw - points: 3, score = 35.2
",
43 | ),
44 | (TEMPLATE_WITH_VARS, "2: simonw
"),
45 | ],
46 | )
47 | async def test_schema_caching(tmp_path_factory, db_path, template, expected):
48 | template_dir = tmp_path_factory.mktemp("templates")
49 | pages_dir = template_dir / "pages"
50 | pages_dir.mkdir()
51 | (pages_dir / "about.html").write_text(template)
52 |
53 | ds = Datasette([str(db_path)], template_dir=template_dir)
54 | response = await ds.client.get("/about")
55 | assert response.status_code == 200
56 | assert response.text.strip() == expected
57 |
--------------------------------------------------------------------------------
/tests/test_utils.py:
--------------------------------------------------------------------------------
1 | from datasette_graphql import utils
2 |
3 |
4 | def test_namer():
5 | n = utils.Namer()
6 | for input, expected in (
7 | ("foo", "foo"),
8 | ("foo", "foo_2"),
9 | ("foo", "foo_3"),
10 | ("bar", "bar"),
11 | ("bar", "bar_2"),
12 | ("74_thang", "_74_thang"),
13 | ("74_thang", "_74_thang_2"),
14 | ("this has spaces", "this_has_spaces"),
15 | ("this$and&that", "this_and_that"),
16 | ):
17 | assert n.name(input) == expected
18 |
--------------------------------------------------------------------------------