ripgrep

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

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 (

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:

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:

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 

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

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

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

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

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

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>'

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

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

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

40          }

41      )

42      response = await datasette.client.get("/-/actor.json", cookies=cookies)

43      assert response.json() == {"actor": ACTOR}

44      request = httpx_mock.get_request()

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

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

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

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

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

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 

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