ripgrep
datasette-upload-dbs/tests/test_upload_dbs.py
14 if auth:
15 cookies = {"ds_actor": ds.sign({"a": {"id": "root"}}, "actor")}
16 response = await ds.client.get("/", cookies=cookies)
17 assert response.status_code == 200
18 if auth:
77 if authed:
78 cookies = {"ds_actor": ds.sign({"a": {"id": "root"}}, "actor")}
79 response = await ds.client.get("/-/upload-dbs", cookies=cookies)
80 assert response.status_code == 403
81 assert expected_error in response.text
datasette-upload-csvs/tests/test_datasette_upload_csvs.py
43 if auth:
44 cookies = {"ds_actor": ds.sign({"a": {"id": "root"}}, "actor")}
45 response = await client.get("http://localhost/", cookies=cookies)
46 assert response.status_code == 200
47 should_allow = False
54 assert (
55 (
56 await client.get("http://localhost/-/upload-csvs", cookies=cookies)
57 ).status_code
58 == 200
138 # First test the upload page exists
139 async with httpx.AsyncClient(app=datasette.app()) as client:
140 response = await client.get("http://localhost/-/upload-csvs", cookies=cookies)
141 assert 200 == response.status_code
142 assert (
datasette-tiddlywiki/tests/test_tiddlywiki.py
93 @pytest.mark.asyncio
94 async def test_status_root(ds):
95 response = await ds.client.get("/-/tiddlywiki/status", cookies=root_cookies(ds))
96 assert response.json() == {
97 "username": "root",
198 ):
199 # Root should be able to see it
200 root_response = await ds.client.get(path, cookies=root_cookies(ds))
201 assert root_response.status_code == 200
202 # Anonymous should not
218 cookies = root_cookies(ds)
219
220 response = await ds.client.get("/", cookies=cookies)
221 fragment = '<li><a href="/-/tiddlywiki">TiddlyWiki</a></li>'
222 if can_view:
datasette-socrata/tests/test_socrata.py
391 if auth:
392 cookies = {"ds_actor": ds.sign({"a": {"id": "root"}}, "actor")}
393 response = await ds.client.get("/", cookies=cookies)
394 assert response.status_code == 200
395 if auth:
datasette-ripgrep/tests/test_ripgrep.py
250 if authenticated:
251 cookies["ds_actor"] = datasette.sign({"a": {"id": "user"}}, "actor")
252 response = await datasette.client.get(path, cookies=cookies)
253 assert response.status_code == expected_status
254
datasette-public/tests/test_public.py
114 '<li><a href="/-/public-table/data/t1">Make {} public</a></li>'.format(noun)
115 )
116 response = await ds.client.get("/data/t1", cookies=cookies)
117 if user_is_root:
118 assert menu_fragment in response.text
121
122 # Check permissions on /-/public-table/data/t1 page
123 response2 = await ds.client.get("/-/public-table/data/t1", cookies=cookies)
124 if user_is_root:
125 assert response2.status_code == 200
146 assert _get_public_tables(db_path) == ["t1"]
147 # And toggle it private again
148 response4 = await ds.client.get("/-/public-table/data/t1", cookies=cookies)
149 html2 = response4.text
150 assert "{} is currently <strong>public</strong>".format(noun.title()) in html2
datasette-indieauth/tests/test_indieauth.py
53 }
54 for path in paths:
55 response2 = await ds.client.get(path, cookies=cookies)
56 assert response2.status_code == 200
57 assert "simonwillison.net" in response2.text
datasette-import-table/tests/test_import_table.py
38 ds = Datasette([db_path])
39 cookies = {"ds_actor": ds.sign({"a": {"id": "root"}}, "actor")}
40 response = await ds.client.get("/-/import-table", cookies=cookies)
41 assert response.status_code == 200
42 csrftoken = response.cookies["ds_csrftoken"]
60 ds = Datasette([db_path1, db_path2])
61 cookies = {"ds_actor": ds.sign({"a": {"id": "root"}}, "actor")}
62 response = await ds.client.get("/-/import-table", cookies=cookies)
63 assert response.status_code == 200
64 assert '<select name="database">' in response.text
65 assert "<option>test</option>" in response.text
66 assert "<option>test2</option>" in response.text
67 response2 = await ds.client.get("/-/import-table?database=test2", cookies=cookies)
68 assert response2.status_code == 200
69 assert '<option selected="selected">test2</option>' in response2.text
datasette-edit-templates/tests/test_edit_templates.py
129 assert ds._edit_templates == {}
130 actor = ds.sign({"a": {"id": "root"}}, "actor")
131 response1 = await ds.client.get("/-/edit-templates", cookies={"ds_actor": actor})
132 assert ' action="/-/edit-templates/" method="get">' in response1.text
133 assert (await ds.client.get("/foo")).status_code == 404
datasette-edit-schema/tests/test_edit_schema.py
61 if actor_id:
62 cookies = {"ds_actor": ds.sign({"a": {"id": actor_id}}, "actor")}
63 response = await ds.client.get("/data/creatures", cookies=cookies)
64 assert response.status_code == 200
65 fragment = '<li><a href="/-/edit-schema/data/creatures">Edit table schema</a></li>'
77 # Get a csrftoken
78 csrftoken = (
79 await ds.client.get("/-/edit-schema/data/creatures", cookies=cookies)
80 ).cookies["ds_csrftoken"]
81 cookies["ds_csrftoken"] = csrftoken
178 # Get a csrftoken
179 csrftoken = (
180 await ds.client.get("/-/edit-schema/data/creatures", cookies=cookies)
181 ).cookies["ds_csrftoken"]
182 response = await ds.client.post(
218 cookies = {"ds_actor": ds.sign({"a": {"id": "root"}}, "actor")}
219 csrftoken = (
220 await ds.client.get("/-/edit-schema/data/creatures", cookies=cookies)
221 ).cookies["ds_csrftoken"]
222 response = await ds.client.post(
348 assert table.columns_dict == {"name": str, "description": str}
349 csrftoken = (
350 await ds.client.get("/-/edit-schema/data/creatures", cookies=cookies)
351 ).cookies["ds_csrftoken"]
352 post_data["csrftoken"] = csrftoken
376 assert table.columns_dict == {"name": str, "description": str}
377 csrftoken = (
378 await ds.client.get("/-/edit-schema/data/creatures", cookies=cookies)
379 ).cookies["ds_csrftoken"]
380 post_data = {
418 assert response.status_code == 403
419 # Should deny with someuser cookie
420 response2 = await ds.client.get("" + path, cookies=someuser_cookies)
421 assert response2.status_code == 403
422 # Should allow with root cookies
423 response3 = await ds.client.get("" + path, cookies=root_cookies)
424 assert response3.status_code in (200, 302)
425
478 ds._rules_allow = rules_allow
479 cookies = {"ds_actor": ds.sign({"a": {"id": "user"}}, "actor")}
480 csrftoken_r = await ds.client.get("/-/edit-schema/data/-/create", cookies=cookies)
481 if not should_work:
482 assert csrftoken_r.status_code == 403
552 ds._rules_allow = rules_allow
553 cookies = {"ds_actor": ds.sign({"a": {"id": "user"}}, "actor")}
554 csrftoken_r = await ds.client.get("/-/edit-schema/data/museums", cookies=cookies)
555 if not should_work:
556 assert csrftoken_r.status_code == 403
587 cookies = {"ds_actor": ds.sign({"a": {"id": "root"}}, "actor")}
588 csrftoken = (
589 await ds.client.get("/-/edit-schema/data/creatures", cookies=cookies)
590 ).cookies["ds_csrftoken"]
591 response = await ds.client.post(
627 ds = Datasette([db_path])
628 cookies = {"ds_actor": ds.sign({"a": {"id": "root"}}, "actor")}
629 response = await ds.client.get(path, cookies=cookies)
630 assert response.status_code == 200
631 breadcrumbs = response.text.split('<p class="crumbs">')[1].split("</p>")[0]
649 ds = Datasette([db_path])
650 cookies = {"ds_actor": ds.sign({"a": {"id": "root"}}, "actor")}
651 response = await ds.client.get("/-/edit-schema/data/museums", cookies=cookies)
652 assert response.status_code == 200
653 # Should suggest two of the three columns as primary keys
704 ds = Datasette([db_path])
705 cookies = {"ds_actor": ds.sign({"a": {"id": "root"}}, "actor")}
706 response = await ds.client.get("/-/edit-schema/data/empty_table", cookies=cookies)
707 assert response.status_code == 200
708
862 ds = Datasette([db_path])
863 cookies = {"ds_actor": ds.sign({"a": {"id": "root"}}, "actor")}
864 csrftoken_r = await ds.client.get("/-/edit-schema/data/-/create", cookies=cookies)
865 csrftoken = csrftoken_r.cookies["ds_csrftoken"]
866 cookies["ds_csrftoken"] = csrftoken
988 cookies = {"ds_actor": ds.sign({"a": {"id": "root"}}, "actor")}
989 csrftoken = (
990 await ds.client.get("/-/edit-schema/data/{}".format(table), cookies=cookies)
991 ).cookies["ds_csrftoken"]
992 cookies["ds_csrftoken"] = csrftoken
datasette-configure-fts/tests/test_configure_fts.py
210 if authenticate:
211 cookies = {"ds_actor": ds.sign({"a": {"id": "root"}}, "actor")}
212 response = await ds.client.get("/data/creatures", cookies=cookies)
213 assert response.status_code == 200
214 fragment = '<li><a href="/-/configure-fts/data?table=creatures">Configure full-text search</a></li>'
datasette-auth-passwords/tests/test_auth_passwords.py
103 assert ds_actor["id"] == expected_username
104 # Now that user is logged in, menu should show 'Log out' option
105 html = (await ds.client.get("/", cookies={"ds_actor": ds_actor_cookie})).text
106 assert LOG_IN not in html
107 assert LOG_OUT in html
datasette-auth-github/tests/test_datasette_auth_github.py
187 )
188 cookies = {"ds_actor": auth_response.cookies["ds_actor"]}
189 databases = await ds.client.get("/.json", cookies=cookies)
190 assert set(databases.json().keys()) == expected_databases
datasette-auth-tokens/tests/test_managed_tokens.py
244 cookies = {"ds_actor": ds_managed_is_member.client.actor_cookie(actor)}
245 # tokens/create link should only show for users with permission to create tokens
246 list_page = await ds_managed_is_member.client.get("/-/api/tokens", cookies=cookies)
247 if is_member:
248 assert 'href="tokens/create"' in list_page.text
251 # We always get CSRF token from /-/permissions
252 csrftoken = (
253 await ds_managed_is_member.client.get("/-/permissions", cookies=cookies)
254 ).cookies["ds_csrftoken"]
255 cookies["ds_csrftoken"] = csrftoken
384 if next_:
385 path += "?next={}".format(next_)
386 response = await ds_managed.client.get(path, cookies=cookies)
387 pages += 1
388 assert response.status_code == 200
datasette-auth-existing-cookies/test_datasette_auth_existing_cookies.py
40 }
41 )
42 response = await datasette.client.get("/-/actor.json", cookies=cookies)
43 assert response.json() == {"actor": ACTOR}
44 request = httpx_mock.get_request()
datasette/tests/test_plugins.py
786 with make_app_client(template_dir=templates) as client:
787 response1 = client.get("/add-message/")
788 response2 = client.get("/render-message/", cookies=response1.cookies)
789 assert 200 == response2.status
790 assert "Hello from messages" in response2.text
datasette/tests/test_permissions.py
279 # But for logged in user all of these should work:
280 cookies = {"ds_actor": client.actor_cookie({"id": "root"})}
281 response_text = client.get("/fixtures", cookies=cookies).text
282 # Extract the schema= portion of the JavaScript
283 schema_json = schema_re.search(response_text).group(1)
286 assert schema["paginated_view"] == []
287 assert form_fragment in response_text
288 query_response = client.get("/fixtures?sql=select+1", cookies=cookies)
289 assert query_response.status == 200
290 schema2 = json.loads(schema_re.search(query_response.text).group(1))
291 assert set(schema2["attraction_characteristic"]) == {"name", "pk"}
292 assert (
293 client.get("/fixtures/facet_cities?_where=id=3", cookies=cookies).status
294 == 200
295 )
373 # With the cookie it should work
374 cookie = ds_client.actor_cookie({"id": "root"})
375 response = await ds_client.get("/-/permissions", cookies={"ds_actor": cookie})
376 assert response.status_code == 200
377 # Should show one failure and one success
641 perms_ds.pdb = True
642 cookies = {"ds_actor": perms_ds.sign({"a": {"id": "root"}}, "actor")}
643 csrftoken = (await perms_ds.client.get("/-/permissions", cookies=cookies)).cookies[
644 "ds_csrftoken"
645 ]
1011 if is_logged_in:
1012 cookies = {"ds_actor": perms_ds.client.actor_cookie({"id": "user"})}
1013 response = await perms_ds.client.get("/-/api", cookies=cookies)
1014 if expected_visible_tables:
1015 assert response.status_code == 200
1035 }
1036 cookies = {"ds_actor": perms_ds.client.actor_cookie(actor)}
1037 response = await perms_ds.client.get("/perms_ds_two/t1.json", cookies=cookies)
1038 assert response.status_code == 200
1039
datasette/tests/test_messages.py
26 )
27 # Now access a page that displays messages
28 response = await ds_client.get("/", cookies=set_msg_response.cookies)
29 # Messages should be in that HTML
30 assert "xmessagex" in response.text
datasette/tests/test_html.py
937 if actor_id:
938 cookies = {"ds_actor": ds_client.actor_cookie({"id": actor_id})}
939 html = (await ds_client.get("/", cookies=cookies)).text
940 soup = Soup(html, "html.parser")
941 details = soup.find("nav").find("details")
datasette/tests/test_docs.py
131 ds = Datasette(memory=True)
132 cookies = {"ds_actor": ds.client.actor_cookie({"id": "root"})}
133 response = await ds.client.get("/-/actor.json", cookies=cookies)
134 assert response.json() == {"actor": {"id": "root"}}
135 # -- end test_signed_cookie_actor --
datasette/tests/test_canned_queries.py
309 assert 200 == canned_write_client.get("/data/update_name").status
310 cookies = {"ds_actor": canned_write_client.actor_cookie({"id": "root"})}
311 assert 200 == canned_write_client.get("/data/delete_name", cookies=cookies).status
312 assert 200 == canned_write_client.get("/data/update_name", cookies=cookies).status
313
314
datasette/tests/test_auth.py
29 """A valid actor cookie sets request.scope['actor']"""
30 cookie = ds_client.actor_cookie({"id": "test"})
31 await ds_client.get("/", cookies={"ds_actor": cookie})
32 assert ds_client.ds._last_request.scope["actor"] == {"id": "test"}
33
37 cookie = ds_client.actor_cookie({"id": "test"})
38 # Break the signature
39 await ds_client.get("/", cookies={"ds_actor": cookie[:-1] + "."})
40 assert ds_client.ds._last_request.scope["actor"] is None
41 # Break the cookie format
42 cookie = ds_client.ds.sign({"b": {"id": "test"}}, "actor")
43 await ds_client.get("/", cookies={"ds_actor": cookie})
44 assert ds_client.ds._last_request.scope["actor"] is None
45
58 {"a": {"id": "test"}, "e": baseconv.base62.encode(expires_at)}, "actor"
59 )
60 response = await ds_client.get("/", cookies={"ds_actor": cookie})
61 assert ds_client.ds._last_request.scope["actor"] == expected
62
160 assert app_client.get("/-/create-token").status == 403
161 ds_actor = app_client.actor_cookie({"id": "test"})
162 response = app_client.get("/-/create-token", cookies={"ds_actor": ds_actor})
163 assert response.status == 200
164 assert ">Create an API token<" in response.text