mirror
/
datasette
kopia lustrzana https://github.com/simonw/datasette
1
0
Forkuj 0
Kod Zgłoszenia Packages Projekty Wydania Wiki Aktywność
datasette/tests/test_api.py

1696 wiersze
56 KiB
Python
Czysty Zwykły widok Historia

New ?tags__arraycontains=tag lookup against JSON fields Part one of supporting facet-by-JSON-array, refs #359
2019-04-10 15:17:19 +00:00
from datasette.utils import detect_json1
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
from .fixtures import ( # noqa
Compound primary key _next= now plays well with extra filters Closes #190
2018-03-30 06:26:22 +00:00
app_client,
Support for :memory: databases If you start Datasette with no files, it will connect to :memory: instead. When starting it with files you can add --memory to also get a :memory: database.
2019-03-14 23:42:38 +00:00
app_client_no_files,
URL hashing is now off by default - closes #418 Prior to this commit Datasette would calculate the content hash of every database and redirect to a URL containing that hash, like so: https://v0-27.datasette.io/fixtures => https://v0-27.datasette.io/fixtures-dd88475 This assumed that all databases were opened in immutable mode and were not expected to change. This will be changing as a result of #419 - so this commit takes the first step in implementing that change by changing this default behaviour. Datasette will now only redirect hash-free URLs under two circumstances: * The new `hash_urls` config option is set to true (it defaults to false). * The user passes `?_hash=1` in the URL
2019-03-17 22:55:04 +00:00
app_client_with_hash,
Default tests to using a longer timelimit Every now and then a test will fail in Travis CI on Python 3.5 because it hit the default 20ms SQL time limit. Test fixtures now default to a 200ms time limit, and we only use the 20ms time limit for the specific test that tests query interruption. This should make our tests on Python 3.5 in Travis much more stable.
2018-05-05 22:41:37 +00:00
app_client_shorter_time_limit,
New cache_size_kb config for SQLite, closes #304
2018-06-04 16:02:07 +00:00
app_client_larger_cache_size,
Upgrade pytest to 3.6.0 https://github.com/pytest-dev/pytest/issues/1875 made it impossible to declare a function as a fixture multiple times, which we were doing across different modules. The fix was to move our @pytest.fixture calls into decorators in the tests/fixtures.py module.
2018-05-31 13:40:30 +00:00
app_client_returned_rows_matches_page_size,
New introspection endpoint: /-/databases - closes #470 Refs #419 and #465
2019-05-16 14:49:34 +00:00
app_client_two_attached_databases_one_immutable,
Fix for /foo v.s. /foo-bar issue, closes #597 Pull request #599
2019-10-18 22:51:07 +00:00
app_client_conflicting_database_names,
Respect --cors for error pages, closes #453
2019-05-05 11:59:45 +00:00
app_client_with_cors,
Allow "." in database filenames, closes #302
2018-06-21 15:21:09 +00:00
app_client_with_dot,
Compound primary key _next= now plays well with extra filters Closes #190
2018-03-30 06:26:22 +00:00
generate_compound_rows,
_sort and _sort_desc parameters for table views Allows for paginated sorted results based on a specified column. Refs #189
2018-04-09 00:06:10 +00:00
generate_sortable_rows,
New make_app_client() pattern Because next version of pytest discourages calling fixture factories as functions
2018-11-20 17:16:31 +00:00
make_app_client,
Added /-/metadata /-/plugins /-/inspect, closes #225
2018-04-19 05:24:48 +00:00
METADATA,
Compound primary key _next= now plays well with extra filters Closes #190
2018-03-30 06:26:22 +00:00
)
Export option: _shape=array&_nl=on for newline-delimited JSON
2019-01-28 01:40:23 +00:00
import json
Broke up test_app into test_api and test_html
2017-12-15 12:04:17 +00:00
import pytest
Faceting no longer breaks pagination, fixes #282
2018-05-23 13:41:14 +00:00
import urllib
Broke up test_app into test_api and test_html
2017-12-15 12:04:17 +00:00
def test_homepage(app_client):
Index page no longer uses inspect data - refs #420 Also introduced a mechanism whereby table counts are calculated against a time limit but immutable databases have their table counts calculated on server startup.
2019-05-02 00:39:39 +00:00
response = app_client.get("/.json")
Broke up test_app into test_api and test_html
2017-12-15 12:04:17 +00:00
assert response.status == 200
Port Datasette from Sanic to ASGI + Uvicorn (#518) Datasette now uses ASGI internally, and no longer depends on Sanic. It now uses Uvicorn as the underlying HTTP server. This was thirteen months in the making... for full details see the issue: https://github.com/simonw/datasette/issues/272 And for a full sequence of commits plus commentary, see the pull request: https://github.com/simonw/datasette/pull/518
2019-06-24 03:13:09 +00:00
assert "application/json; charset=utf-8" == response.headers["content-type"]
Index page no longer uses inspect data - refs #420 Also introduced a mechanism whereby table counts are calculated against a time limit but immutable databases have their table counts calculated on server startup.
2019-05-02 00:39:39 +00:00
assert response.json.keys() == {"fixtures": 0}.keys()
d = response.json["fixtures"]
assert d["name"] == "fixtures"
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
assert d["tables_count"] == 24
Include views on homepage, fix table counts If we have less than 5 tables we now also show one or more views in the summary on the homepage. Also corrected the logic for the row counts - we now count hidden and visible tables separately. Closes #373, Refs #460
2019-05-16 00:28:07 +00:00
assert len(d["tables_and_views_truncated"]) == 5
assert d["tables_and_views_more"] is True
Fixed bug where metadata.json hidden tables were ignored
2019-05-02 00:54:48 +00:00
# 4 hidden FTS tables + no_primary_key (hidden in metadata)
assert d["hidden_tables_count"] == 5
# 201 in no_primary_key, plus 5 in other hidden tables:
assert d["hidden_table_rows_sum"] == 206
Index page no longer uses inspect data - refs #420 Also introduced a mechanism whereby table counts are calculated against a time limit but immutable databases have their table counts calculated on server startup.
2019-05-02 00:39:39 +00:00
assert d["views_count"] == 4
Broke up test_app into test_api and test_html
2017-12-15 12:04:17 +00:00
Sometimes sort tables by number of relationships, closes #460
2019-05-16 03:23:33 +00:00
def test_homepage_sort_by_relationships(app_client):
response = app_client.get("/.json?_sort=relationships")
assert response.status == 200
tables = [
t["name"] for t in response.json["fixtures"]["tables_and_views_truncated"]
]
assert [
"simple_primary_key",
"complex_foreign_keys",
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"roadside_attraction_characteristics",
Sometimes sort tables by number of relationships, closes #460
2019-05-16 03:23:33 +00:00
"searchable_tags",
"foreign_key_references",
] == tables
Broke up test_app into test_api and test_html
2017-12-15 12:04:17 +00:00
def test_database_page(app_client):
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
response = app_client.get("/fixtures.json")
Broke up test_app into test_api and test_html
2017-12-15 12:04:17 +00:00
data = response.json
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
assert "fixtures" == data["database"]
assert [
{
"name": "123_starts_with_digits",
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"columns": ["content"],
"primary_keys": [],
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"count": 0,
"hidden": False,
"fts_table": None,
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"foreign_keys": {"incoming": [], "outgoing": []},
Broke up test_app into test_api and test_html
2017-12-15 12:04:17 +00:00
},
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
{
"name": "Table With Space In Name",
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"columns": ["pk", "content"],
"primary_keys": ["pk"],
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"count": 0,
"hidden": False,
"fts_table": None,
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"foreign_keys": {"incoming": [], "outgoing": []},
},
{
"name": "attraction_characteristic",
"columns": ["pk", "name"],
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"primary_keys": ["pk"],
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"count": 2,
"hidden": False,
"fts_table": None,
"foreign_keys": {
"incoming": [
{
"other_table": "roadside_attraction_characteristics",
"column": "pk",
"other_column": "characteristic_id",
}
],
"outgoing": [],
},
label_column option in metadata.json - closes #234
2018-04-22 17:51:43 +00:00
},
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
{
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"name": "binary_data",
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"columns": ["data"],
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"primary_keys": [],
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"count": 1,
"hidden": False,
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"fts_table": None,
"foreign_keys": {"incoming": [], "outgoing": []},
Foreign key facets are now expanded to labels, refs #255
2018-05-15 15:52:02 +00:00
},
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
{
"name": "complex_foreign_keys",
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"columns": ["pk", "f1", "f2", "f3"],
"primary_keys": ["pk"],
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"count": 1,
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"hidden": False,
"fts_table": None,
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"foreign_keys": {
"incoming": [],
"outgoing": [
{
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"other_table": "simple_primary_key",
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"column": "f3",
"other_column": "id",
},
{
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"other_table": "simple_primary_key",
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"column": "f2",
"other_column": "id",
},
{
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"other_table": "simple_primary_key",
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"column": "f1",
"other_column": "id",
},
],
},
Foreign key facets are now expanded to labels, refs #255
2018-05-15 15:52:02 +00:00
},
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
{
"name": "compound_primary_key",
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"columns": ["pk1", "pk2", "content"],
"primary_keys": ["pk1", "pk2"],
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"count": 1,
"hidden": False,
"fts_table": None,
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"foreign_keys": {"incoming": [], "outgoing": []},
Added unit test for foreign key links in HTML Needed to add a further unit test for #207
2018-04-14 14:55:27 +00:00
},
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
{
"name": "compound_three_primary_keys",
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"columns": ["pk1", "pk2", "pk3", "content"],
"primary_keys": ["pk1", "pk2", "pk3"],
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"count": 1001,
"hidden": False,
"fts_table": None,
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"foreign_keys": {"incoming": [], "outgoing": []},
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
},
{
"name": "custom_foreign_key_label",
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"columns": ["pk", "foreign_key_with_custom_label"],
"primary_keys": ["pk"],
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"count": 1,
"hidden": False,
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"fts_table": None,
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"foreign_keys": {
"incoming": [],
"outgoing": [
{
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"other_table": "primary_key_multiple_columns_explicit_label",
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"column": "foreign_key_with_custom_label",
"other_column": "id",
}
],
},
label_column now defined on the table-being-linked-to, fixes #234
2018-04-22 20:46:18 +00:00
},
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
{
"name": "facet_cities",
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"columns": ["id", "name"],
"primary_keys": ["id"],
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"count": 4,
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"hidden": False,
"fts_table": None,
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"foreign_keys": {
"incoming": [
{
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"other_table": "facetable",
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"column": "id",
"other_column": "city_id",
}
],
"outgoing": [],
},
Added unit test for foreign key links in HTML Needed to add a further unit test for #207
2018-04-14 14:55:27 +00:00
},
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
{
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"name": "facetable",
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"columns": [
"pk",
Facet by date, closes #481
2019-05-21 06:09:22 +00:00
"created",
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"planet_int",
"on_earth",
"state",
"city_id",
"neighborhood",
"tags",
Only suggest array facet for arrays of strings - closes #562
2019-11-01 19:37:46 +00:00
"complex_array",
Fixed incorrect display of compound primary keys with foreign key references Closes #319
2018-06-21 14:56:28 +00:00
],
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"primary_keys": ["pk"],
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"count": 15,
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"hidden": False,
"fts_table": None,
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"foreign_keys": {
"incoming": [],
"outgoing": [
{
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"other_table": "facet_cities",
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"column": "city_id",
"other_column": "id",
}
],
},
},
{
"name": "foreign_key_references",
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"columns": ["pk", "foreign_key_with_label", "foreign_key_with_no_label"],
"primary_keys": ["pk"],
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"count": 1,
"hidden": False,
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"fts_table": None,
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"foreign_keys": {
"incoming": [],
"outgoing": [
{
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"other_table": "primary_key_multiple_columns",
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"column": "foreign_key_with_no_label",
"other_column": "id",
},
{
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"other_table": "simple_primary_key",
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"column": "foreign_key_with_label",
"other_column": "id",
},
],
},
Fixed incorrect display of compound primary keys with foreign key references Closes #319
2018-06-21 14:56:28 +00:00
},
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
{
"name": "infinity",
"columns": ["value"],
"primary_keys": [],
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"count": 3,
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"hidden": False,
"fts_table": None,
"foreign_keys": {"incoming": [], "outgoing": []},
Broke up test_app into test_api and test_html
2017-12-15 12:04:17 +00:00
},
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
{
"name": "primary_key_multiple_columns",
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"columns": ["id", "content", "content2"],
"primary_keys": ["id"],
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"count": 1,
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"hidden": False,
"fts_table": None,
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"foreign_keys": {
"incoming": [
{
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"other_table": "foreign_key_references",
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"column": "id",
"other_column": "foreign_key_with_no_label",
}
],
"outgoing": [],
},
},
{
"name": "primary_key_multiple_columns_explicit_label",
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"columns": ["id", "content", "content2"],
"primary_keys": ["id"],
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"count": 1,
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"hidden": False,
"fts_table": None,
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"foreign_keys": {
"incoming": [
{
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"other_table": "custom_foreign_key_label",
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"column": "id",
"other_column": "foreign_key_with_custom_label",
}
],
"outgoing": [],
},
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
},
{
"name": "roadside_attraction_characteristics",
"columns": ["attraction_id", "characteristic_id"],
"primary_keys": [],
"count": 5,
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"hidden": False,
"fts_table": None,
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"foreign_keys": {
"incoming": [],
"outgoing": [
{
"other_table": "attraction_characteristic",
"column": "characteristic_id",
"other_column": "pk",
},
{
"other_table": "roadside_attractions",
"column": "attraction_id",
"other_column": "pk",
},
],
},
},
{
"name": "roadside_attractions",
"columns": ["pk", "name", "address", "latitude", "longitude"],
"primary_keys": ["pk"],
"count": 4,
"hidden": False,
"fts_table": None,
"foreign_keys": {
"incoming": [
{
"other_table": "roadside_attraction_characteristics",
"column": "pk",
"other_column": "attraction_id",
}
],
"outgoing": [],
},
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
},
{
"name": "searchable",
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"columns": ["pk", "text1", "text2", "name with . and spaces"],
"primary_keys": ["pk"],
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"count": 2,
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"hidden": False,
"fts_table": "searchable_fts",
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"foreign_keys": {
"incoming": [
{
"other_table": "searchable_tags",
"column": "pk",
"other_column": "searchable_id",
}
],
"outgoing": [],
},
},
{
"name": "searchable_tags",
"columns": ["searchable_id", "tag"],
"primary_keys": ["searchable_id", "tag"],
"count": 2,
"hidden": False,
"fts_table": None,
"foreign_keys": {
"incoming": [],
"outgoing": [
{"other_table": "tags", "column": "tag", "other_column": "tag"},
{
"other_table": "searchable",
"column": "searchable_id",
"other_column": "pk",
},
],
},
},
{
"name": "select",
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"columns": ["group", "having", "and", "json"],
"primary_keys": [],
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"count": 1,
"hidden": False,
"fts_table": None,
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"foreign_keys": {"incoming": [], "outgoing": []},
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
},
{
"name": "simple_primary_key",
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"columns": ["id", "content"],
"primary_keys": ["id"],
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"count": 4,
"hidden": False,
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"fts_table": None,
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"foreign_keys": {
"incoming": [
{
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"other_table": "foreign_key_references",
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"column": "id",
"other_column": "foreign_key_with_label",
},
{
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"other_table": "complex_foreign_keys",
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"column": "id",
"other_column": "f3",
},
{
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"other_table": "complex_foreign_keys",
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"column": "id",
"other_column": "f2",
},
{
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"other_table": "complex_foreign_keys",
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"column": "id",
"other_column": "f1",
},
],
"outgoing": [],
},
},
{
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"name": "sortable",
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"columns": [
"pk1",
"pk2",
"content",
"sortable",
"sortable_with_nulls",
"sortable_with_nulls_2",
"text",
],
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"primary_keys": ["pk1", "pk2"],
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"count": 201,
"hidden": False,
"fts_table": None,
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"foreign_keys": {"incoming": [], "outgoing": []},
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
},
{
"name": "table/with/slashes.csv",
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"columns": ["pk", "content"],
"primary_keys": ["pk"],
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"count": 1,
"hidden": False,
"fts_table": None,
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"foreign_keys": {"incoming": [], "outgoing": []},
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
},
{
"name": "tags",
"columns": ["tag"],
"primary_keys": ["tag"],
"count": 2,
"hidden": False,
"fts_table": None,
"foreign_keys": {
"incoming": [
{
"other_table": "searchable_tags",
"column": "tag",
"other_column": "tag",
}
],
"outgoing": [],
},
},
{
"name": "units",
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"columns": ["pk", "distance", "frequency"],
"primary_keys": ["pk"],
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"count": 3,
"hidden": False,
"fts_table": None,
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"foreign_keys": {"incoming": [], "outgoing": []},
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
},
{
"name": "no_primary_key",
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"columns": ["content", "a", "b", "c"],
"primary_keys": [],
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"count": 201,
"hidden": True,
"fts_table": None,
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"foreign_keys": {"incoming": [], "outgoing": []},
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
},
{
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"name": "searchable_fts",
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"columns": ["text1", "text2", "name with . and spaces", "content"],
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"primary_keys": [],
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"count": 2,
"hidden": True,
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"fts_table": "searchable_fts",
"foreign_keys": {"incoming": [], "outgoing": []},
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
},
{
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"name": "searchable_fts_content",
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"columns": [
"docid",
"c0text1",
"c1text2",
"c2name with . and spaces",
"c3content",
Fixed incorrect display of compound primary keys with foreign key references Closes #319
2018-06-21 14:56:28 +00:00
],
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"primary_keys": ["docid"],
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"count": 2,
"hidden": True,
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"fts_table": None,
"foreign_keys": {"incoming": [], "outgoing": []},
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
},
{
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"name": "searchable_fts_segdir",
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"columns": [
"level",
"idx",
"start_block",
"leaves_end_block",
"end_block",
"root",
],
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"primary_keys": ["level", "idx"],
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"count": 1,
"hidden": True,
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"fts_table": None,
"foreign_keys": {"incoming": [], "outgoing": []},
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
},
{
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"name": "searchable_fts_segments",
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"columns": ["blockid", "block"],
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"primary_keys": ["blockid"],
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"count": 0,
"hidden": True,
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
"fts_table": None,
"foreign_keys": {"incoming": [], "outgoing": []},
Fixed incorrect display of compound primary keys with foreign key references Closes #319
2018-06-21 14:56:28 +00:00
},
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
] == data["tables"]
Broke up test_app into test_api and test_html
2017-12-15 12:04:17 +00:00
Support for :memory: databases If you start Datasette with no files, it will connect to :memory: instead. When starting it with files you can add --memory to also get a :memory: database.
2019-03-14 23:42:38 +00:00
def test_no_files_uses_memory_database(app_client_no_files):
response = app_client_no_files.get("/.json")
assert response.status == 200
assert {
":memory:": {
Index page no longer uses inspect data - refs #420 Also introduced a mechanism whereby table counts are calculated against a time limit but immutable databases have their table counts calculated on server startup.
2019-05-02 00:39:39 +00:00
"hash": None,
"color": "f7935d",
Support for :memory: databases If you start Datasette with no files, it will connect to :memory: instead. When starting it with files you can add --memory to also get a :memory: database.
2019-03-14 23:42:38 +00:00
"hidden_table_rows_sum": 0,
"hidden_tables_count": 0,
"name": ":memory:",
Index page only shows row counts for smaller databases The index page now only shows row counts for immutable databases OR for databases with less than 30 tables provided it could get a count for each of those tables in less than 10ms. Closes #467, Refs #460
2019-05-16 03:02:33 +00:00
"show_table_row_counts": False,
URL hashing is now off by default - closes #418 Prior to this commit Datasette would calculate the content hash of every database and redirect to a URL containing that hash, like so: https://v0-27.datasette.io/fixtures => https://v0-27.datasette.io/fixtures-dd88475 This assumed that all databases were opened in immutable mode and were not expected to change. This will be changing as a result of #419 - so this commit takes the first step in implementing that change by changing this default behaviour. Datasette will now only redirect hash-free URLs under two circumstances: * The new `hash_urls` config option is set to true (it defaults to false). * The user passes `?_hash=1` in the URL
2019-03-17 22:55:04 +00:00
"path": "/:memory:",
Support for :memory: databases If you start Datasette with no files, it will connect to :memory: instead. When starting it with files you can add --memory to also get a :memory: database.
2019-03-14 23:42:38 +00:00
"table_rows_sum": 0,
"tables_count": 0,
Include views on homepage, fix table counts If we have less than 5 tables we now also show one or more views in the summary on the homepage. Also corrected the logic for the row counts - we now count hidden and visible tables separately. Closes #373, Refs #460
2019-05-16 00:28:07 +00:00
"tables_and_views_more": False,
"tables_and_views_truncated": [],
Support for :memory: databases If you start Datasette with no files, it will connect to :memory: instead. When starting it with files you can add --memory to also get a :memory: database.
2019-03-14 23:42:38 +00:00
"views_count": 0,
}
} == response.json
# Try that SQL query
response = app_client_no_files.get(
URL hashing is now off by default - closes #418 Prior to this commit Datasette would calculate the content hash of every database and redirect to a URL containing that hash, like so: https://v0-27.datasette.io/fixtures => https://v0-27.datasette.io/fixtures-dd88475 This assumed that all databases were opened in immutable mode and were not expected to change. This will be changing as a result of #419 - so this commit takes the first step in implementing that change by changing this default behaviour. Datasette will now only redirect hash-free URLs under two circumstances: * The new `hash_urls` config option is set to true (it defaults to false). * The user passes `?_hash=1` in the URL
2019-03-17 22:55:04 +00:00
"/:memory:.json?sql=select+sqlite_version()&_shape=array"
Support for :memory: databases If you start Datasette with no files, it will connect to :memory: instead. When starting it with files you can add --memory to also get a :memory: database.
2019-03-14 23:42:38 +00:00
)
assert 1 == len(response.json)
assert ["sqlite_version()"] == list(response.json[0].keys())
Allow "." in database filenames, closes #302
2018-06-21 15:21:09 +00:00
def test_database_page_for_database_with_dot_in_name(app_client_with_dot):
response = app_client_with_dot.get("/fixtures.dot.json")
assert 200 == response.status
Broke up test_app into test_api and test_html
2017-12-15 12:04:17 +00:00
def test_custom_sql(app_client):
response = app_client.get(
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"/fixtures.json?sql=select+content+from+simple_primary_key&_shape=objects"
Broke up test_app into test_api and test_html
2017-12-15 12:04:17 +00:00
)
data = response.json
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
assert {"sql": "select content from simple_primary_key", "params": {}} == data[
"query"
]
Broke up test_app into test_api and test_html
2017-12-15 12:04:17 +00:00
assert [
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
{"content": "hello"},
{"content": "world"},
{"content": ""},
{"content": "RENDER_CELL_DEMO"},
] == data["rows"]
assert ["content"] == data["columns"]
assert "fixtures" == data["database"]
assert not data["truncated"]
Broke up test_app into test_api and test_html
2017-12-15 12:04:17 +00:00
Docs + example of canned SQL query using || concatenation Closes #321
2018-06-21 04:54:36 +00:00
def test_canned_query_with_named_parameter(app_client):
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
response = app_client.get("/fixtures/neighborhood_search.json?text=town")
Docs + example of canned SQL query using || concatenation Closes #321
2018-06-21 04:54:36 +00:00
assert [
["Corktown", "Detroit", "MI"],
["Downtown", "Los Angeles", "CA"],
["Downtown", "Detroit", "MI"],
["Greektown", "Detroit", "MI"],
["Koreatown", "Los Angeles", "CA"],
["Mexicantown", "Detroit", "MI"],
] == response.json["rows"]
Default tests to using a longer timelimit Every now and then a test will fail in Travis CI on Python 3.5 because it hit the default 20ms SQL time limit. Test fixtures now default to a 200ms time limit, and we only use the 20ms time limit for the specific test that tests query interruption. This should make our tests on Python 3.5 in Travis much more stable.
2018-05-05 22:41:37 +00:00
def test_sql_time_limit(app_client_shorter_time_limit):
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
response = app_client_shorter_time_limit.get("/fixtures.json?sql=select+sleep(0.5)")
Broke up test_app into test_api and test_html
2017-12-15 12:04:17 +00:00
assert 400 == response.status
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
assert "SQL Interrupted" == response.json["title"]
Broke up test_app into test_api and test_html
2017-12-15 12:04:17 +00:00
def test_custom_sql_time_limit(app_client):
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
response = app_client.get("/fixtures.json?sql=select+sleep(0.01)")
Broke up test_app into test_api and test_html
2017-12-15 12:04:17 +00:00
assert 200 == response.status
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
response = app_client.get("/fixtures.json?sql=select+sleep(0.01)&_timelimit=5")
Broke up test_app into test_api and test_html
2017-12-15 12:04:17 +00:00
assert 400 == response.status
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
assert "SQL Interrupted" == response.json["title"]
Broke up test_app into test_api and test_html
2017-12-15 12:04:17 +00:00
def test_invalid_custom_sql(app_client):
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
response = app_client.get("/fixtures.json?sql=.schema")
Broke up test_app into test_api and test_html
2017-12-15 12:04:17 +00:00
assert response.status == 400
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
assert response.json["ok"] is False
assert "Statement must be a SELECT" == response.json["error"]
Broke up test_app into test_api and test_html
2017-12-15 12:04:17 +00:00
allow_sql config option to disable custom SQL, closes #284
2018-05-25 05:50:50 +00:00
def test_allow_sql_off():
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
for client in make_app_client(config={"allow_sql": False}):
response = client.get("/fixtures.json?sql=select+sleep(0.01)")
?_where= parameter on table views, closes #429 From pull request #430
2019-04-13 01:37:22 +00:00
assert 400 == response.status
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
assert "sql= is not allowed" == response.json["error"]
allow_sql config option to disable custom SQL, closes #284
2018-05-25 05:50:50 +00:00
Broke up test_app into test_api and test_html
2017-12-15 12:04:17 +00:00
def test_table_json(app_client):
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
response = app_client.get("/fixtures/simple_primary_key.json?_shape=objects")
Broke up test_app into test_api and test_html
2017-12-15 12:04:17 +00:00
assert response.status == 200
data = response.json
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
assert (
data["query"]["sql"] == "select * from simple_primary_key order by id limit 51"
)
assert data["query"]["params"] == {}
assert data["rows"] == [
{"id": "1", "content": "hello"},
{"id": "2", "content": "world"},
{"id": "3", "content": ""},
{"id": "4", "content": "RENDER_CELL_DEMO"},
]
Broke up test_app into test_api and test_html
2017-12-15 12:04:17 +00:00
Better mechanism for handling errors; 404s for missing table/database New error mechanism closes #193 404s for missing tables/databesse closes #184 Makes pull request #202 unnecessary.
2018-04-13 18:17:22 +00:00
def test_table_not_exists_json(app_client):
assert {
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"ok": False,
"error": "Table not found: blah",
"status": 404,
"title": None,
} == app_client.get("/fixtures/blah.json").json
Better mechanism for handling errors; 404s for missing table/database New error mechanism closes #193 404s for missing tables/databesse closes #184 Makes pull request #202 unnecessary.
2018-04-13 18:17:22 +00:00
URL hashing is now off by default - closes #418 Prior to this commit Datasette would calculate the content hash of every database and redirect to a URL containing that hash, like so: https://v0-27.datasette.io/fixtures => https://v0-27.datasette.io/fixtures-dd88475 This assumed that all databases were opened in immutable mode and were not expected to change. This will be changing as a result of #419 - so this commit takes the first step in implementing that change by changing this default behaviour. Datasette will now only redirect hash-free URLs under two circumstances: * The new `hash_urls` config option is set to true (it defaults to false). * The user passes `?_hash=1` in the URL
2019-03-17 22:55:04 +00:00
def test_jsono_redirects_to_shape_objects(app_client_with_hash):
response_1 = app_client_with_hash.get(
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"/fixtures/simple_primary_key.jsono", allow_redirects=False
New ?_shape=objects/object/lists param for JSON API (#192) New _shape= parameter replacing old .jsono extension Now instead of this: /database/table.jsono We use the _shape parameter like this: /database/table.json?_shape=objects Also introduced a new _shape called 'object' which looks like this: /database/table.json?_shape=object Returning an object for the rows key: ... "rows": { "pk1": { ... }, "pk2": { ... } } Refs #122
2018-04-03 14:52:54 +00:00
)
URL hashing is now off by default - closes #418 Prior to this commit Datasette would calculate the content hash of every database and redirect to a URL containing that hash, like so: https://v0-27.datasette.io/fixtures => https://v0-27.datasette.io/fixtures-dd88475 This assumed that all databases were opened in immutable mode and were not expected to change. This will be changing as a result of #419 - so this commit takes the first step in implementing that change by changing this default behaviour. Datasette will now only redirect hash-free URLs under two circumstances: * The new `hash_urls` config option is set to true (it defaults to false). * The user passes `?_hash=1` in the URL
2019-03-17 22:55:04 +00:00
response = app_client_with_hash.get(
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
response_1.headers["Location"], allow_redirects=False
New ?_shape=objects/object/lists param for JSON API (#192) New _shape= parameter replacing old .jsono extension Now instead of this: /database/table.jsono We use the _shape parameter like this: /database/table.json?_shape=objects Also introduced a new _shape called 'object' which looks like this: /database/table.json?_shape=object Returning an object for the rows key: ... "rows": { "pk1": { ... }, "pk2": { ... } } Refs #122
2018-04-03 14:52:54 +00:00
)
assert response.status == 302
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
assert response.headers["Location"].endswith("?_shape=objects")
New ?_shape=objects/object/lists param for JSON API (#192) New _shape= parameter replacing old .jsono extension Now instead of this: /database/table.jsono We use the _shape parameter like this: /database/table.json?_shape=objects Also introduced a new _shape called 'object' which looks like this: /database/table.json?_shape=object Returning an object for the rows key: ... "rows": { "pk1": { ... }, "pk2": { ... } } Refs #122
2018-04-03 14:52:54 +00:00
New ?_shape=array option + tweaks to _shape, closes #245 * Default is now ?_shape=arrays (renamed from lists) * New ?_shape=array returns an array of objects as the root object * Changed ?_shape=object to return the object as the root * Updated docs
2018-05-02 00:08:16 +00:00
def test_table_shape_arrays(app_client):
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
response = app_client.get("/fixtures/simple_primary_key.json?_shape=arrays")
New ?_shape=objects/object/lists param for JSON API (#192) New _shape= parameter replacing old .jsono extension Now instead of this: /database/table.jsono We use the _shape parameter like this: /database/table.json?_shape=objects Also introduced a new _shape called 'object' which looks like this: /database/table.json?_shape=object Returning an object for the rows key: ... "rows": { "pk1": { ... }, "pk2": { ... } } Refs #122
2018-04-03 14:52:54 +00:00
assert [
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
["1", "hello"],
["2", "world"],
["3", ""],
["4", "RENDER_CELL_DEMO"],
] == response.json["rows"]
New ?_shape=objects/object/lists param for JSON API (#192) New _shape= parameter replacing old .jsono extension Now instead of this: /database/table.jsono We use the _shape parameter like this: /database/table.json?_shape=objects Also introduced a new _shape called 'object' which looks like this: /database/table.json?_shape=object Returning an object for the rows key: ... "rows": { "pk1": { ... }, "pk2": { ... } } Refs #122
2018-04-03 14:52:54 +00:00
?_shape=arrayfirst, closes #287
2018-05-27 00:32:15 +00:00
def test_table_shape_arrayfirst(app_client):
response = app_client.get(
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"/fixtures.json?"
+ urllib.parse.urlencode(
{
"sql": "select content from simple_primary_key order by id",
"_shape": "arrayfirst",
}
)
?_shape=arrayfirst, closes #287
2018-05-27 00:32:15 +00:00
)
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
assert ["hello", "world", "", "RENDER_CELL_DEMO"] == response.json
?_shape=arrayfirst, closes #287
2018-05-27 00:32:15 +00:00
New ?_shape=objects/object/lists param for JSON API (#192) New _shape= parameter replacing old .jsono extension Now instead of this: /database/table.jsono We use the _shape parameter like this: /database/table.json?_shape=objects Also introduced a new _shape called 'object' which looks like this: /database/table.json?_shape=object Returning an object for the rows key: ... "rows": { "pk1": { ... }, "pk2": { ... } } Refs #122
2018-04-03 14:52:54 +00:00
def test_table_shape_objects(app_client):
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
response = app_client.get("/fixtures/simple_primary_key.json?_shape=objects")
assert [
{"id": "1", "content": "hello"},
{"id": "2", "content": "world"},
{"id": "3", "content": ""},
{"id": "4", "content": "RENDER_CELL_DEMO"},
] == response.json["rows"]
New ?_shape=objects/object/lists param for JSON API (#192) New _shape= parameter replacing old .jsono extension Now instead of this: /database/table.jsono We use the _shape parameter like this: /database/table.json?_shape=objects Also introduced a new _shape called 'object' which looks like this: /database/table.json?_shape=object Returning an object for the rows key: ... "rows": { "pk1": { ... }, "pk2": { ... } } Refs #122
2018-04-03 14:52:54 +00:00
New ?_shape=array option + tweaks to _shape, closes #245 * Default is now ?_shape=arrays (renamed from lists) * New ?_shape=array returns an array of objects as the root object * Changed ?_shape=object to return the object as the root * Updated docs
2018-05-02 00:08:16 +00:00
def test_table_shape_array(app_client):
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
response = app_client.get("/fixtures/simple_primary_key.json?_shape=array")
assert [
{"id": "1", "content": "hello"},
{"id": "2", "content": "world"},
{"id": "3", "content": ""},
{"id": "4", "content": "RENDER_CELL_DEMO"},
] == response.json
New ?_shape=array option + tweaks to _shape, closes #245 * Default is now ?_shape=arrays (renamed from lists) * New ?_shape=array returns an array of objects as the root object * Changed ?_shape=object to return the object as the root * Updated docs
2018-05-02 00:08:16 +00:00
Export option: _shape=array&_nl=on for newline-delimited JSON
2019-01-28 01:40:23 +00:00
def test_table_shape_array_nl(app_client):
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
response = app_client.get("/fixtures/simple_primary_key.json?_shape=array&_nl=on")
Export option: _shape=array&_nl=on for newline-delimited JSON
2019-01-28 01:40:23 +00:00
lines = response.text.split("\n")
results = [json.loads(line) for line in lines]
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
assert [
{"id": "1", "content": "hello"},
{"id": "2", "content": "world"},
{"id": "3", "content": ""},
{"id": "4", "content": "RENDER_CELL_DEMO"},
] == results
Export option: _shape=array&_nl=on for newline-delimited JSON
2019-01-28 01:40:23 +00:00
New ?_shape=array option + tweaks to _shape, closes #245 * Default is now ?_shape=arrays (renamed from lists) * New ?_shape=array returns an array of objects as the root object * Changed ?_shape=object to return the object as the root * Updated docs
2018-05-02 00:08:16 +00:00
def test_table_shape_invalid(app_client):
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
response = app_client.get("/fixtures/simple_primary_key.json?_shape=invalid")
New ?_shape=array option + tweaks to _shape, closes #245 * Default is now ?_shape=arrays (renamed from lists) * New ?_shape=array returns an array of objects as the root object * Changed ?_shape=object to return the object as the root * Updated docs
2018-05-02 00:08:16 +00:00
assert {
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"ok": False,
"error": "Invalid _shape: invalid",
"status": 400,
"title": None,
New ?_shape=array option + tweaks to _shape, closes #245 * Default is now ?_shape=arrays (renamed from lists) * New ?_shape=array returns an array of objects as the root object * Changed ?_shape=object to return the object as the root * Updated docs
2018-05-02 00:08:16 +00:00
} == response.json
New ?_shape=objects/object/lists param for JSON API (#192) New _shape= parameter replacing old .jsono extension Now instead of this: /database/table.jsono We use the _shape parameter like this: /database/table.json?_shape=objects Also introduced a new _shape called 'object' which looks like this: /database/table.json?_shape=object Returning an object for the rows key: ... "rows": { "pk1": { ... }, "pk2": { ... } } Refs #122
2018-04-03 14:52:54 +00:00
def test_table_shape_object(app_client):
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
response = app_client.get("/fixtures/simple_primary_key.json?_shape=object")
New ?_shape=objects/object/lists param for JSON API (#192) New _shape= parameter replacing old .jsono extension Now instead of this: /database/table.jsono We use the _shape parameter like this: /database/table.json?_shape=objects Also introduced a new _shape called 'object' which looks like this: /database/table.json?_shape=object Returning an object for the rows key: ... "rows": { "pk1": { ... }, "pk2": { ... } } Refs #122
2018-04-03 14:52:54 +00:00
assert {
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"1": {"id": "1", "content": "hello"},
"2": {"id": "2", "content": "world"},
"3": {"id": "3", "content": ""},
"4": {"id": "4", "content": "RENDER_CELL_DEMO"},
New ?_shape=array option + tweaks to _shape, closes #245 * Default is now ?_shape=arrays (renamed from lists) * New ?_shape=array returns an array of objects as the root object * Changed ?_shape=object to return the object as the root * Updated docs
2018-05-02 00:08:16 +00:00
} == response.json
New ?_shape=objects/object/lists param for JSON API (#192) New _shape= parameter replacing old .jsono extension Now instead of this: /database/table.jsono We use the _shape parameter like this: /database/table.json?_shape=objects Also introduced a new _shape called 'object' which looks like this: /database/table.json?_shape=object Returning an object for the rows key: ... "rows": { "pk1": { ... }, "pk2": { ... } } Refs #122
2018-04-03 14:52:54 +00:00
def test_table_shape_object_compound_primary_Key(app_client):
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
response = app_client.get("/fixtures/compound_primary_key.json?_shape=object")
assert {"a,b": {"pk1": "a", "pk2": "b", "content": "c"}} == response.json
New ?_shape=objects/object/lists param for JSON API (#192) New _shape= parameter replacing old .jsono extension Now instead of this: /database/table.jsono We use the _shape parameter like this: /database/table.json?_shape=objects Also introduced a new _shape called 'object' which looks like this: /database/table.json?_shape=object Returning an object for the rows key: ... "rows": { "pk1": { ... }, "pk2": { ... } } Refs #122
2018-04-03 14:52:54 +00:00
Broke up test_app into test_api and test_html
2017-12-15 12:04:17 +00:00
def test_table_with_slashes_in_name(app_client):
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
response = app_client.get(
"/fixtures/table%2Fwith%2Fslashes.csv?_shape=objects&_format=json"
)
Broke up test_app into test_api and test_html
2017-12-15 12:04:17 +00:00
assert response.status == 200
data = response.json
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
assert data["rows"] == [{"pk": "3", "content": "hey"}]
Broke up test_app into test_api and test_html
2017-12-15 12:04:17 +00:00
escape_sqlite_table_name => escape_sqlite, handles reserved words It can be used for column names as well as table names. Reserved word list from https://www.sqlite.org/lang_keywords.html
2018-04-03 13:39:50 +00:00
def test_table_with_reserved_word_name(app_client):
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
response = app_client.get("/fixtures/select.json?_shape=objects")
escape_sqlite_table_name => escape_sqlite, handles reserved words It can be used for column names as well as table names. Reserved word list from https://www.sqlite.org/lang_keywords.html
2018-04-03 13:39:50 +00:00
assert response.status == 200
data = response.json
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
assert data["rows"] == [
{
"rowid": 1,
"group": "group",
"having": "having",
"and": "and",
"json": '{"href": "http://example.com/", "label":"Example"}',
}
]
@pytest.mark.parametrize(
"path,expected_rows,expected_pages",
[
("/fixtures/no_primary_key.json", 201, 5),
("/fixtures/paginated_view.json", 201, 5),
("/fixtures/no_primary_key.json?_size=25", 201, 9),
("/fixtures/paginated_view.json?_size=25", 201, 9),
("/fixtures/paginated_view.json?_size=max", 201, 3),
("/fixtures/123_starts_with_digits.json", 0, 1),
# Ensure faceting doesn't break pagination:
("/fixtures/compound_three_primary_keys.json?_facet=pk1", 1001, 21),
Fix pagination when sorted by expanded foreign key Closes #489
2019-05-28 02:23:18 +00:00
# Paginating while sorted by an expanded foreign key should work
Tidy up with Black
2019-05-28 02:28:47 +00:00
(
"/fixtures/roadside_attraction_characteristics.json?_size=2&_sort=attraction_id&_labels=on",
5,
3,
),
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
],
)
Default tests to using a longer timelimit Every now and then a test will fail in Travis CI on Python 3.5 because it hit the default 20ms SQL time limit. Test fixtures now default to a 200ms time limit, and we only use the 20ms time limit for the specific test that tests query interruption. This should make our tests on Python 3.5 in Travis much more stable.
2018-05-05 22:41:37 +00:00
def test_paginate_tables_and_views(app_client, path, expected_rows, expected_pages):
Broke up test_app into test_api and test_html
2017-12-15 12:04:17 +00:00
fetched = []
count = 0
while path:
Test client wrapper removing need for gather_request - refs #272 As part of decoupling from Sanic, this will make it easier to run tests against ASGI instead.
2018-06-05 03:53:12 +00:00
response = app_client.get(path)
?_size=max option, closes #249
2018-05-04 18:03:40 +00:00
assert 200 == response.status
Broke up test_app into test_api and test_html
2017-12-15 12:04:17 +00:00
count += 1
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
fetched.extend(response.json["rows"])
path = response.json["next_url"]
Broke up test_app into test_api and test_html
2017-12-15 12:04:17 +00:00
if path:
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
assert urllib.parse.urlencode({"_next": response.json["next"]}) in path
Port Datasette from Sanic to ASGI + Uvicorn (#518) Datasette now uses ASGI internally, and no longer depends on Sanic. It now uses Uvicorn as the underlying HTTP server. This was thirteen months in the making... for full details see the issue: https://github.com/simonw/datasette/issues/272 And for a full sequence of commits plus commentary, see the pull request: https://github.com/simonw/datasette/pull/518
2019-06-24 03:13:09 +00:00
path = path.replace("http://localhost", "")
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
assert count < 30, "Possible infinite loop detected"
Broke up test_app into test_api and test_html
2017-12-15 12:04:17 +00:00
assert expected_rows == len(fetched)
assert expected_pages == count
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
@pytest.mark.parametrize(
"path,expected_error",
[
("/fixtures/no_primary_key.json?_size=-4", "_size must be a positive integer"),
("/fixtures/no_primary_key.json?_size=dog", "_size must be a positive integer"),
("/fixtures/no_primary_key.json?_size=1001", "_size must be <= 100"),
],
)
New ?_size=XXX querystring parameter for table view, closes #229 Also added documentation for all of the _special arguments. Plus deleted some duplicate logic implementing _group_count.
2018-04-26 04:47:12 +00:00
def test_validate_page_size(app_client, path, expected_error):
Test client wrapper removing need for gather_request - refs #272 As part of decoupling from Sanic, this will make it easier to run tests against ASGI instead.
2018-06-05 03:53:12 +00:00
response = app_client.get(path)
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
assert expected_error == response.json["error"]
New ?_size=XXX querystring parameter for table view, closes #229 Also added documentation for all of the _special arguments. Plus deleted some duplicate logic implementing _group_count.
2018-04-26 04:47:12 +00:00
assert 400 == response.status
def test_page_size_zero(app_client):
"For _size=0 we return the counts, empty rows and no continuation token"
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
response = app_client.get("/fixtures/no_primary_key.json?_size=0")
New ?_size=XXX querystring parameter for table view, closes #229 Also added documentation for all of the _special arguments. Plus deleted some duplicate logic implementing _group_count.
2018-04-26 04:47:12 +00:00
assert 200 == response.status
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
assert [] == response.json["rows"]
assert 201 == response.json["filtered_table_rows_count"]
assert None is response.json["next"]
assert None is response.json["next_url"]
New ?_size=XXX querystring parameter for table view, closes #229 Also added documentation for all of the _special arguments. Plus deleted some duplicate logic implementing _group_count.
2018-04-26 04:47:12 +00:00
Default tests to using a longer timelimit Every now and then a test will fail in Travis CI on Python 3.5 because it hit the default 20ms SQL time limit. Test fixtures now default to a 200ms time limit, and we only use the 20ms time limit for the specific test that tests query interruption. This should make our tests on Python 3.5 in Travis much more stable.
2018-05-05 22:41:37 +00:00
def test_paginate_compound_keys(app_client):
Fixed bug with keyset pagination over compound primary keys Closes #190
2018-03-30 05:10:09 +00:00
fetched = []
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
path = "/fixtures/compound_three_primary_keys.json?_shape=objects"
Compound primary key _next= now plays well with extra filters Closes #190
2018-03-30 06:26:22 +00:00
page = 0
Fixed bug with keyset pagination over compound primary keys Closes #190
2018-03-30 05:10:09 +00:00
while path:
Compound primary key _next= now plays well with extra filters Closes #190
2018-03-30 06:26:22 +00:00
page += 1
Test client wrapper removing need for gather_request - refs #272 As part of decoupling from Sanic, this will make it easier to run tests against ASGI instead.
2018-06-05 03:53:12 +00:00
response = app_client.get(path)
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
fetched.extend(response.json["rows"])
path = response.json["next_url"]
Port Datasette from Sanic to ASGI + Uvicorn (#518) Datasette now uses ASGI internally, and no longer depends on Sanic. It now uses Uvicorn as the underlying HTTP server. This was thirteen months in the making... for full details see the issue: https://github.com/simonw/datasette/issues/272 And for a full sequence of commits plus commentary, see the pull request: https://github.com/simonw/datasette/pull/518
2019-06-24 03:13:09 +00:00
if path:
path = path.replace("http://localhost", "")
Compound primary key _next= now plays well with extra filters Closes #190
2018-03-30 06:26:22 +00:00
assert page < 100
assert 1001 == len(fetched)
assert 21 == page
Fixed bug with keyset pagination over compound primary keys Closes #190
2018-03-30 05:10:09 +00:00
# Should be correctly ordered
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
contents = [f["content"] for f in fetched]
Compound primary key _next= now plays well with extra filters Closes #190
2018-03-30 06:26:22 +00:00
expected = [r[3] for r in generate_compound_rows(1001)]
assert expected == contents
def test_paginate_compound_keys_with_extra_filters(app_client):
fetched = []
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
path = (
"/fixtures/compound_three_primary_keys.json?content__contains=d&_shape=objects"
)
Compound primary key _next= now plays well with extra filters Closes #190
2018-03-30 06:26:22 +00:00
page = 0
while path:
page += 1
assert page < 100
Test client wrapper removing need for gather_request - refs #272 As part of decoupling from Sanic, this will make it easier to run tests against ASGI instead.
2018-06-05 03:53:12 +00:00
response = app_client.get(path)
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
fetched.extend(response.json["rows"])
path = response.json["next_url"]
Port Datasette from Sanic to ASGI + Uvicorn (#518) Datasette now uses ASGI internally, and no longer depends on Sanic. It now uses Uvicorn as the underlying HTTP server. This was thirteen months in the making... for full details see the issue: https://github.com/simonw/datasette/issues/272 And for a full sequence of commits plus commentary, see the pull request: https://github.com/simonw/datasette/pull/518
2019-06-24 03:13:09 +00:00
if path:
path = path.replace("http://localhost", "")
Compound primary key _next= now plays well with extra filters Closes #190
2018-03-30 06:26:22 +00:00
assert 2 == page
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
expected = [r[3] for r in generate_compound_rows(1001) if "d" in r[3]]
assert expected == [f["content"] for f in fetched]
@pytest.mark.parametrize(
"query_string,sort_key,human_description_en",
[
("_sort=sortable", lambda row: row["sortable"], "sorted by sortable"),
(
"_sort_desc=sortable",
lambda row: -row["sortable"],
"sorted by sortable descending",
),
(
"_sort=sortable_with_nulls",
lambda row: (
1 if row["sortable_with_nulls"] is not None else 0,
row["sortable_with_nulls"],
),
"sorted by sortable_with_nulls",
Working implementation of #216 which passes the tests Reverted commit 5364fa7f3357f2de24fd45c85832205377642f19 (where I removed the code that didn't work). Added primary keys to order-by clause for sorting to get tests to pass
2018-04-17 01:41:17 +00:00
),
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
(
"_sort_desc=sortable_with_nulls",
lambda row: (
1 if row["sortable_with_nulls"] is None else 0,
-row["sortable_with_nulls"]
if row["sortable_with_nulls"] is not None
else 0,
row["content"],
),
"sorted by sortable_with_nulls descending",
Working implementation of #216 which passes the tests Reverted commit 5364fa7f3357f2de24fd45c85832205377642f19 (where I removed the code that didn't work). Added primary keys to order-by clause for sorting to get tests to pass
2018-04-17 01:41:17 +00:00
),
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
# text column contains '$null' - ensure it doesn't confuse pagination:
("_sort=text", lambda row: row["text"], "sorted by text"),
],
)
Current sort order now reflected in human filter description Plus renamed human_description to human_description_en Refs #189
2018-04-09 01:01:23 +00:00
def test_sortable(app_client, query_string, sort_key, human_description_en):
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
path = "/fixtures/sortable.json?_shape=objects&{}".format(query_string)
_sort and _sort_desc parameters for table views Allows for paginated sorted results based on a specified column. Refs #189
2018-04-09 00:06:10 +00:00
fetched = []
page = 0
while path:
page += 1
assert page < 100
Test client wrapper removing need for gather_request - refs #272 As part of decoupling from Sanic, this will make it easier to run tests against ASGI instead.
2018-06-05 03:53:12 +00:00
response = app_client.get(path)
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
assert human_description_en == response.json["human_description_en"]
fetched.extend(response.json["rows"])
path = response.json["next_url"]
Port Datasette from Sanic to ASGI + Uvicorn (#518) Datasette now uses ASGI internally, and no longer depends on Sanic. It now uses Uvicorn as the underlying HTTP server. This was thirteen months in the making... for full details see the issue: https://github.com/simonw/datasette/issues/272 And for a full sequence of commits plus commentary, see the pull request: https://github.com/simonw/datasette/pull/518
2019-06-24 03:13:09 +00:00
if path:
path = path.replace("http://localhost", "")
_sort and _sort_desc parameters for table views Allows for paginated sorted results based on a specified column. Refs #189
2018-04-09 00:06:10 +00:00
assert 5 == page
expected = list(generate_sortable_rows(201))
expected.sort(key=sort_key)
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
assert [r["content"] for r in expected] == [r["content"] for r in fetched]
_sort and _sort_desc parameters for table views Allows for paginated sorted results based on a specified column. Refs #189
2018-04-09 00:06:10 +00:00
Current sort order now reflected in human filter description Plus renamed human_description to human_description_en Refs #189
2018-04-09 01:01:23 +00:00
def test_sortable_and_filtered(app_client):
path = (
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"/fixtures/sortable.json"
"?content__contains=d&_sort_desc=sortable&_shape=objects"
Current sort order now reflected in human filter description Plus renamed human_description to human_description_en Refs #189
2018-04-09 01:01:23 +00:00
)
Test client wrapper removing need for gather_request - refs #272 As part of decoupling from Sanic, this will make it easier to run tests against ASGI instead.
2018-06-05 03:53:12 +00:00
response = app_client.get(path)
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
fetched = response.json["rows"]
assert (
'where content contains "d" sorted by sortable descending'
== response.json["human_description_en"]
)
expected = [row for row in generate_sortable_rows(201) if "d" in row["content"]]
assert len(expected) == response.json["filtered_table_rows_count"]
expected.sort(key=lambda row: -row["sortable"])
assert [r["content"] for r in expected] == [r["content"] for r in fetched]
Current sort order now reflected in human filter description Plus renamed human_description to human_description_en Refs #189
2018-04-09 01:01:23 +00:00
Error handling for ?_sort and ?_sort_desc Verifies that they match an existing column, and only one or the other option is provided - refs #189 Eses a new DatasetteError exception that closes #193
2018-04-09 04:07:31 +00:00
def test_sortable_argument_errors(app_client):
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
response = app_client.get("/fixtures/sortable.json?_sort=badcolumn")
assert "Cannot sort table by badcolumn" == response.json["error"]
response = app_client.get("/fixtures/sortable.json?_sort_desc=badcolumn2")
assert "Cannot sort table by badcolumn2" == response.json["error"]
Error handling for ?_sort and ?_sort_desc Verifies that they match an existing column, and only one or the other option is provided - refs #189 Eses a new DatasetteError exception that closes #193
2018-04-09 04:07:31 +00:00
response = app_client.get(
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"/fixtures/sortable.json?_sort=sortable_with_nulls&_sort_desc=sortable"
Error handling for ?_sort and ?_sort_desc Verifies that they match an existing column, and only one or the other option is provided - refs #189 Eses a new DatasetteError exception that closes #193
2018-04-09 04:07:31 +00:00
)
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
assert "Cannot use _sort and _sort_desc at the same time" == response.json["error"]
Error handling for ?_sort and ?_sort_desc Verifies that they match an existing column, and only one or the other option is provided - refs #189 Eses a new DatasetteError exception that closes #193
2018-04-09 04:07:31 +00:00
New sortable_columns option in metadata.json to control sort options You can now explicitly set which columns in a table can be used for sorting using the _sort and _sort_desc arguments using metadata.json: { "databases": { "database1": { "tables": { "example_table": { "sortable_columns": [ "height", "weight" ] } } } } } Refs #189
2018-04-09 04:58:25 +00:00
def test_sortable_columns_metadata(app_client):
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
response = app_client.get("/fixtures/sortable.json?_sort=content")
assert "Cannot sort table by content" == response.json["error"]
New sortable_columns option in metadata.json to control sort options You can now explicitly set which columns in a table can be used for sorting using the _sort and _sort_desc arguments using metadata.json: { "databases": { "database1": { "tables": { "example_table": { "sortable_columns": [ "height", "weight" ] } } } } } Refs #189
2018-04-09 04:58:25 +00:00
# no_primary_key has ALL sort options disabled
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
for column in ("content", "a", "b", "c"):
response = app_client.get("/fixtures/sortable.json?_sort={}".format(column))
assert "Cannot sort table by {}".format(column) == response.json["error"]
@pytest.mark.parametrize(
"path,expected_rows",
[
(
"/fixtures/searchable.json?_search=dog",
[
[1, "barry cat", "terry dog", "panther"],
[2, "terry dog", "sara weasel", "puma"],
],
),
(
"/fixtures/searchable.json?_search=weasel",
[[2, "terry dog", "sara weasel", "puma"]],
),
(
"/fixtures/searchable.json?_search_text2=dog",
[[1, "barry cat", "terry dog", "panther"]],
),
(
"/fixtures/searchable.json?_search_name%20with%20.%20and%20spaces=panther",
[[1, "barry cat", "terry dog", "panther"]],
),
],
)
Unit tests for _search= feature, refs #237
2018-05-05 22:01:14 +00:00
def test_searchable(app_client, path, expected_rows):
Test client wrapper removing need for gather_request - refs #272 As part of decoupling from Sanic, this will make it easier to run tests against ASGI instead.
2018-06-05 03:53:12 +00:00
response = app_client.get(path)
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
assert expected_rows == response.json["rows"]
@pytest.mark.parametrize(
"path,expected_rows",
[
(
"/fixtures/searchable_view_configured_by_metadata.json?_search=weasel",
[[2, "terry dog", "sara weasel", "puma"]],
),
# This should return all results because search is not configured:
(
"/fixtures/searchable_view.json?_search=weasel",
[
[1, "barry cat", "terry dog", "panther"],
[2, "terry dog", "sara weasel", "puma"],
],
),
(
"/fixtures/searchable_view.json?_search=weasel&_fts_table=searchable_fts&_fts_pk=pk",
[[2, "terry dog", "sara weasel", "puma"]],
),
],
)
?_fts_table= and ?_fts_pk= arguments, closes #428
2019-04-12 04:21:17 +00:00
def test_searchable_views(app_client, path, expected_rows):
response = app_client.get(path)
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
assert expected_rows == response.json["rows"]
?_fts_table= and ?_fts_pk= arguments, closes #428
2019-04-12 04:21:17 +00:00
Support _search_COLUMN=text searches, closes #237
2018-05-05 22:33:08 +00:00
def test_searchable_invalid_column(app_client):
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
response = app_client.get("/fixtures/searchable.json?_search_invalid=x")
Support _search_COLUMN=text searches, closes #237
2018-05-05 22:33:08 +00:00
assert 400 == response.status
assert {
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"ok": False,
"error": "Cannot search by that column",
"status": 400,
"title": None,
Support _search_COLUMN=text searches, closes #237
2018-05-05 22:33:08 +00:00
} == response.json
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
@pytest.mark.parametrize(
"path,expected_rows",
[
("/fixtures/simple_primary_key.json?content=hello", [["1", "hello"]]),
(
"/fixtures/simple_primary_key.json?content__contains=o",
[["1", "hello"], ["2", "world"], ["4", "RENDER_CELL_DEMO"]],
),
("/fixtures/simple_primary_key.json?content__exact=", [["3", ""]]),
(
"/fixtures/simple_primary_key.json?content__not=world",
[["1", "hello"], ["3", ""], ["4", "RENDER_CELL_DEMO"]],
),
],
)
Broke up test_app into test_api and test_html
2017-12-15 12:04:17 +00:00
def test_table_filter_queries(app_client, path, expected_rows):
Test client wrapper removing need for gather_request - refs #272 As part of decoupling from Sanic, this will make it easier to run tests against ASGI instead.
2018-06-05 03:53:12 +00:00
response = app_client.get(path)
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
assert expected_rows == response.json["rows"]
Broke up test_app into test_api and test_html
2017-12-15 12:04:17 +00:00
Support multiple filters of the same type Closes #288
2019-04-15 23:44:17 +00:00
def test_table_filter_queries_multiple_of_same_type(app_client):
response = app_client.get(
"/fixtures/simple_primary_key.json?content__not=world&content__not=hello"
)
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
assert [["3", ""], ["4", "RENDER_CELL_DEMO"]] == response.json["rows"]
Support multiple filters of the same type Closes #288
2019-04-15 23:44:17 +00:00
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
@pytest.mark.skipif(not detect_json1(), reason="Requires the SQLite json1 module")
New ?tags__arraycontains=tag lookup against JSON fields Part one of supporting facet-by-JSON-array, refs #359
2019-04-10 15:17:19 +00:00
def test_table_filter_json_arraycontains(app_client):
response = app_client.get("/fixtures/facetable.json?tags__arraycontains=tag1")
assert [
Only suggest array facet for arrays of strings - closes #562
2019-11-01 19:37:46 +00:00
[
1,
"2019-01-14 08:00:00",
1,
1,
"CA",
1,
"Mission",
'["tag1", "tag2"]',
'[{"foo": "bar"}]',
],
[2, "2019-01-14 08:00:00", 1, 1, "CA", 1, "Dogpatch", '["tag1", "tag3"]', "[]"],
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
] == response.json["rows"]
New ?tags__arraycontains=tag lookup against JSON fields Part one of supporting facet-by-JSON-array, refs #359
2019-04-10 15:17:19 +00:00
?_where= parameter on table views, closes #429 From pull request #430
2019-04-13 01:37:22 +00:00
def test_table_filter_extra_where(app_client):
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
response = app_client.get("/fixtures/facetable.json?_where=neighborhood='Dogpatch'")
Facet by date, closes #481
2019-05-21 06:09:22 +00:00
assert [
Only suggest array facet for arrays of strings - closes #562
2019-11-01 19:37:46 +00:00
[2, "2019-01-14 08:00:00", 1, 1, "CA", 1, "Dogpatch", '["tag1", "tag3"]', "[]"]
Facet by date, closes #481
2019-05-21 06:09:22 +00:00
] == response.json["rows"]
?_where= parameter on table views, closes #429 From pull request #430
2019-04-13 01:37:22 +00:00
def test_table_filter_extra_where_invalid(app_client):
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
response = app_client.get("/fixtures/facetable.json?_where=neighborhood=Dogpatch'")
?_where= parameter on table views, closes #429 From pull request #430
2019-04-13 01:37:22 +00:00
assert 400 == response.status
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
assert "Invalid SQL" == response.json["title"]
?_where= parameter on table views, closes #429 From pull request #430
2019-04-13 01:37:22 +00:00
def test_table_filter_extra_where_disabled_if_no_sql_allowed():
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
for client in make_app_client(config={"allow_sql": False}):
response = client.get("/fixtures/facetable.json?_where=neighborhood='Dogpatch'")
?_where= parameter on table views, closes #429 From pull request #430
2019-04-13 01:37:22 +00:00
assert 400 == response.status
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
assert "_where= is not allowed" == response.json["error"]
?_where= parameter on table views, closes #429 From pull request #430
2019-04-13 01:37:22 +00:00
Added ?_through= table argument, closes #355 Also added much more interesting many-to-many fixtures - roadside attractions!
2019-05-23 05:44:34 +00:00
def test_table_through(app_client):
# Just the museums:
response = app_client.get(
'/fixtures/roadside_attractions.json?_through={"table":"roadside_attraction_characteristics","column":"characteristic_id","value":"1"}'
)
assert [
[
3,
"Burlingame Museum of PEZ Memorabilia",
"214 California Drive, Burlingame, CA 94010",
37.5793,
-122.3442,
],
[
4,
"Bigfoot Discovery Museum",
"5497 Highway 9, Felton, CA 95018",
37.0414,
-122.0725,
],
] == response.json["rows"]
assert (
'where roadside_attraction_characteristics.characteristic_id = "1"'
== response.json["human_description_en"]
)
Broke up test_app into test_api and test_html
2017-12-15 12:04:17 +00:00
def test_max_returned_rows(app_client):
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
response = app_client.get("/fixtures.json?sql=select+content+from+no_primary_key")
Broke up test_app into test_api and test_html
2017-12-15 12:04:17 +00:00
data = response.json
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
assert {"sql": "select content from no_primary_key", "params": {}} == data["query"]
assert data["truncated"]
assert 100 == len(data["rows"])
Broke up test_app into test_api and test_html
2017-12-15 12:04:17 +00:00
def test_view(app_client):
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
response = app_client.get("/fixtures/simple_view.json?_shape=objects")
Broke up test_app into test_api and test_html
2017-12-15 12:04:17 +00:00
assert response.status == 200
data = response.json
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
assert data["rows"] == [
{"upper_content": "HELLO", "content": "hello"},
{"upper_content": "WORLD", "content": "world"},
{"upper_content": "", "content": ""},
{"upper_content": "RENDER_CELL_DEMO", "content": "RENDER_CELL_DEMO"},
]
Broke up test_app into test_api and test_html
2017-12-15 12:04:17 +00:00
def test_row(app_client):
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
response = app_client.get("/fixtures/simple_primary_key/1.json?_shape=objects")
Broke up test_app into test_api and test_html
2017-12-15 12:04:17 +00:00
assert response.status == 200
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
assert [{"id": "1", "content": "hello"}] == response.json["rows"]
Fix for row pages for tables with / in, closes #325
2018-07-08 05:21:51 +00:00
Always pop as_format off args dict (#603) Closes #563. Thanks, @chris48s
2019-10-21 02:03:08 +00:00
def test_row_format_in_querystring(app_client):
# regression test for https://github.com/simonw/datasette/issues/563
response = app_client.get(
"/fixtures/simple_primary_key/1?_format=json&_shape=objects"
)
assert response.status == 200
assert [{"id": "1", "content": "hello"}] == response.json["rows"]
Fix for row pages for tables with / in, closes #325
2018-07-08 05:21:51 +00:00
def test_row_strange_table_name(app_client):
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
response = app_client.get(
"/fixtures/table%2Fwith%2Fslashes.csv/3.json?_shape=objects"
)
Fix for row pages for tables with / in, closes #325
2018-07-08 05:21:51 +00:00
assert response.status == 200
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
assert [{"pk": "3", "content": "hey"}] == response.json["rows"]
Broke up test_app into test_api and test_html
2017-12-15 12:04:17 +00:00
def test_row_foreign_key_tables(app_client):
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
response = app_client.get(
"/fixtures/simple_primary_key/1.json?_extras=foreign_key_tables"
)
Broke up test_app into test_api and test_html
2017-12-15 12:04:17 +00:00
assert response.status == 200
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
assert [
{
"column": "id",
"count": 1,
"other_column": "foreign_key_with_label",
"other_table": "foreign_key_references",
},
{
"column": "id",
"count": 1,
"other_column": "f3",
"other_table": "complex_foreign_keys",
},
{
"column": "id",
"count": 0,
"other_column": "f2",
"other_table": "complex_foreign_keys",
},
{
"column": "id",
"count": 1,
"other_column": "f1",
"other_table": "complex_foreign_keys",
},
] == response.json["foreign_key_tables"]
Tests for unit filtering
2018-04-14 14:06:52 +00:00
def test_unit_filters(app_client):
New --plugins-dir=plugins/ option (#212) * New --plugins-dir=plugins/ option New option causing Datasette to load and evaluate all of the Python files in the specified directory and register any plugins that are defined in those files. This new option is available for the following commands: datasette serve mydb.db --plugins-dir=plugins/ datasette publish now/heroku mydb.db --plugins-dir=plugins/ datasette package mydb.db --plugins-dir=plugins/ * Unit tests for --plugins-dir=plugins/ Closes #211
2018-04-16 05:22:01 +00:00
response = app_client.get(
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"/fixtures/units.json?distance__lt=75km&frequency__gt=1kHz"
New --plugins-dir=plugins/ option (#212) * New --plugins-dir=plugins/ option New option causing Datasette to load and evaluate all of the Python files in the specified directory and register any plugins that are defined in those files. This new option is available for the following commands: datasette serve mydb.db --plugins-dir=plugins/ datasette publish now/heroku mydb.db --plugins-dir=plugins/ datasette package mydb.db --plugins-dir=plugins/ * Unit tests for --plugins-dir=plugins/ Closes #211
2018-04-16 05:22:01 +00:00
)
Tests for unit filtering
2018-04-14 14:06:52 +00:00
assert response.status == 200
data = response.json
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
assert data["units"]["distance"] == "m"
assert data["units"]["frequency"] == "Hz"
Tests for unit filtering
2018-04-14 14:06:52 +00:00
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
assert len(data["rows"]) == 1
assert data["rows"][0][0] == 2
New --plugins-dir=plugins/ option (#212) * New --plugins-dir=plugins/ option New option causing Datasette to load and evaluate all of the Python files in the specified directory and register any plugins that are defined in those files. This new option is available for the following commands: datasette serve mydb.db --plugins-dir=plugins/ datasette publish now/heroku mydb.db --plugins-dir=plugins/ datasette package mydb.db --plugins-dir=plugins/ * Unit tests for --plugins-dir=plugins/ Closes #211
2018-04-16 05:22:01 +00:00
New introspection endpoint: /-/databases - closes #470 Refs #419 and #465
2019-05-16 14:49:34 +00:00
def test_databases_json(app_client_two_attached_databases_one_immutable):
response = app_client_two_attached_databases_one_immutable.get("/-/databases.json")
databases = response.json
assert 2 == len(databases)
extra_database, fixtures_database = databases
assert "extra_database" == extra_database["name"]
assert None == extra_database["hash"]
assert True == extra_database["is_mutable"]
assert False == extra_database["is_memory"]
assert "fixtures" == fixtures_database["name"]
assert fixtures_database["hash"] is not None
assert False == fixtures_database["is_mutable"]
assert False == fixtures_database["is_memory"]
Added /-/metadata /-/plugins /-/inspect, closes #225
2018-04-19 05:24:48 +00:00
def test_metadata_json(app_client):
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
response = app_client.get("/-/metadata.json")
Added /-/metadata /-/plugins /-/inspect, closes #225
2018-04-19 05:24:48 +00:00
assert METADATA == response.json
def test_plugins_json(app_client):
Don't load setuptools plugins during test runs Uses pattern from https://docs.pytest.org/en/latest/example/simple.html#detect-if-running-from-within-a-pytest-run Closes #438
2019-05-02 05:09:03 +00:00
response = app_client.get("/-/plugins.json")
assert [
{"name": "my_plugin.py", "static": False, "templates": False, "version": None},
{
"name": "my_plugin_2.py",
"static": False,
"templates": False,
"version": None,
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
},
Don't load setuptools plugins during test runs Uses pattern from https://docs.pytest.org/en/latest/example/simple.html#detect-if-running-from-within-a-pytest-run Closes #438
2019-05-02 05:09:03 +00:00
] == sorted(response.json, key=lambda p: p["name"])
If max_returned_rows==page_size, increment max_returned_rows Fixes #230, where if the two were equal pagination didn't work correctly.
2018-04-26 04:04:12 +00:00
Added /-/versions and /-/versions.json, closes #244 Sample output: { "python": { "version": "3.6.3", "full": "3.6.3 (default, Oct 4 2017, 06:09:38) \n[GCC 4.2.1 Compatible Apple LLVM 9.0.0 (clang-900.0.37)]" }, "datasette": { "version": "0.20" }, "sqlite": { "version": "3.23.1", "extensions": { "json1": null, "spatialite": "4.3.0a" } } }
2018-05-02 08:46:54 +00:00
def test_versions_json(app_client):
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
response = app_client.get("/-/versions.json")
assert "python" in response.json
Port Datasette from Sanic to ASGI + Uvicorn (#518) Datasette now uses ASGI internally, and no longer depends on Sanic. It now uses Uvicorn as the underlying HTTP server. This was thirteen months in the making... for full details see the issue: https://github.com/simonw/datasette/issues/272 And for a full sequence of commits plus commentary, see the pull request: https://github.com/simonw/datasette/pull/518
2019-06-24 03:13:09 +00:00
assert "3.0" == response.json.get("asgi")
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
assert "version" in response.json["python"]
assert "full" in response.json["python"]
assert "datasette" in response.json
assert "version" in response.json["datasette"]
assert "sqlite" in response.json
assert "version" in response.json["sqlite"]
assert "fts_versions" in response.json["sqlite"]
assert "compile_options" in response.json["sqlite"]
Added /-/versions and /-/versions.json, closes #244 Sample output: { "python": { "version": "3.6.3", "full": "3.6.3 (default, Oct 4 2017, 06:09:38) \n[GCC 4.2.1 Compatible Apple LLVM 9.0.0 (clang-900.0.37)]" }, "datasette": { "version": "0.20" }, "sqlite": { "version": "3.23.1", "extensions": { "json1": null, "spatialite": "4.3.0a" } } }
2018-05-02 08:46:54 +00:00
Renamed --limit to --config, added --help-config, closes #274 Removed the --page_size= argument to datasette serve in favour of: datasette serve --config default_page_size:50 mydb.db Added new help section: $ datasette --help-config Config options: default_page_size Default page size for the table view (default=100) max_returned_rows Maximum rows that can be returned from a table or custom query (default=1000) sql_time_limit_ms Time limit for a SQL query in milliseconds (default=1000) default_facet_size Number of values to return for requested facets (default=30) facet_time_limit_ms Time limit for calculating a requested facet (default=200) facet_suggest_time_limit_ms Time limit for calculating a suggested facet (default=50)
2018-05-20 17:01:49 +00:00
def test_config_json(app_client):
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
response = app_client.get("/-/config.json")
Added /-/limits and /-/limits.json, closes #270
2018-05-18 06:16:28 +00:00
assert {
Renamed --limit to --config, added --help-config, closes #274 Removed the --page_size= argument to datasette serve in favour of: datasette serve --config default_page_size:50 mydb.db Added new help section: $ datasette --help-config Config options: default_page_size Default page size for the table view (default=100) max_returned_rows Maximum rows that can be returned from a table or custom query (default=1000) sql_time_limit_ms Time limit for a SQL query in milliseconds (default=1000) default_facet_size Number of values to return for requested facets (default=30) facet_time_limit_ms Time limit for calculating a requested facet (default=200) facet_suggest_time_limit_ms Time limit for calculating a suggested facet (default=50)
2018-05-20 17:01:49 +00:00
"default_page_size": 50,
Added /-/limits and /-/limits.json, closes #270
2018-05-18 06:16:28 +00:00
"default_facet_size": 30,
"facet_suggest_time_limit_ms": 50,
"facet_time_limit_ms": 200,
"max_returned_rows": 100,
"sql_time_limit_ms": 200,
allow_facet, allow_download, suggest_facets boolean --config Refs #284
2018-05-25 01:12:27 +00:00
"allow_download": True,
"allow_facet": True,
allow_sql config option to disable custom SQL, closes #284
2018-05-25 05:50:50 +00:00
"suggest_facets": True,
"allow_sql": True,
URL hashing is now off by default - closes #418 Prior to this commit Datasette would calculate the content hash of every database and redirect to a URL containing that hash, like so: https://v0-27.datasette.io/fixtures => https://v0-27.datasette.io/fixtures-dd88475 This assumed that all databases were opened in immutable mode and were not expected to change. This will be changing as a result of #419 - so this commit takes the first step in implementing that change by changing this default behaviour. Datasette will now only redirect hash-free URLs under two circumstances: * The new `hash_urls` config option is set to true (it defaults to false). * The user passes `?_hash=1` in the URL
2019-03-17 22:55:04 +00:00
"default_cache_ttl": 5,
"default_cache_ttl_hashed": 365 * 24 * 60 * 60,
Added num_sql_threads config option, closes #285
2018-05-27 00:43:22 +00:00
"num_sql_threads": 3,
New cache_size_kb config for SQLite, closes #304
2018-06-04 16:02:07 +00:00
"cache_size_kb": 0,
Streaming mode for downloading all rows as a CSV (#315) * table.csv?_stream=1 to download all rows - refs #266 This option causes Datasette to serve ALL rows in the table, by internally following the _next= pagination links and serving everything out as a stream. Also added new config option, allow_csv_stream, which can be used to disable this feature. * New config option max_csv_mb limiting size of CSV export
2018-06-18 03:21:02 +00:00
"allow_csv_stream": True,
"max_csv_mb": 100,
New truncate_cells_html config for truncating cells, closes #330
2018-07-10 16:20:41 +00:00
"truncate_cells_html": 2048,
New force_https_urls option, refs #333
2018-07-23 15:58:29 +00:00
"force_https_urls": False,
URL hashing is now off by default - closes #418 Prior to this commit Datasette would calculate the content hash of every database and redirect to a URL containing that hash, like so: https://v0-27.datasette.io/fixtures => https://v0-27.datasette.io/fixtures-dd88475 This assumed that all databases were opened in immutable mode and were not expected to change. This will be changing as a result of #419 - so this commit takes the first step in implementing that change by changing this default behaviour. Datasette will now only redirect hash-free URLs under two circumstances: * The new `hash_urls` config option is set to true (it defaults to false). * The user passes `?_hash=1` in the URL
2019-03-17 22:55:04 +00:00
"hash_urls": False,
Added /-/limits and /-/limits.json, closes #270
2018-05-18 06:16:28 +00:00
} == response.json
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
def test_page_size_matching_max_returned_rows(
Update to latest black (#609)
2019-10-30 18:49:01 +00:00
app_client_returned_rows_matches_page_size,
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
):
If max_returned_rows==page_size, increment max_returned_rows Fixes #230, where if the two were equal pagination didn't work correctly.
2018-04-26 04:04:12 +00:00
fetched = []
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
path = "/fixtures/no_primary_key.json"
If max_returned_rows==page_size, increment max_returned_rows Fixes #230, where if the two were equal pagination didn't work correctly.
2018-04-26 04:04:12 +00:00
while path:
Test client wrapper removing need for gather_request - refs #272 As part of decoupling from Sanic, this will make it easier to run tests against ASGI instead.
2018-06-05 03:53:12 +00:00
response = app_client_returned_rows_matches_page_size.get(path)
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
fetched.extend(response.json["rows"])
assert len(response.json["rows"]) in (1, 50)
path = response.json["next_url"]
Port Datasette from Sanic to ASGI + Uvicorn (#518) Datasette now uses ASGI internally, and no longer depends on Sanic. It now uses Uvicorn as the underlying HTTP server. This was thirteen months in the making... for full details see the issue: https://github.com/simonw/datasette/issues/272 And for a full sequence of commits plus commentary, see the pull request: https://github.com/simonw/datasette/pull/518
2019-06-24 03:13:09 +00:00
if path:
path = path.replace("http://localhost", "")
If max_returned_rows==page_size, increment max_returned_rows Fixes #230, where if the two were equal pagination didn't work correctly.
2018-04-26 04:04:12 +00:00
assert 201 == len(fetched)
Initial implementation of facets, plus tests and docs Refs #255
2018-05-12 22:29:06 +00:00
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
@pytest.mark.parametrize(
"path,expected_facet_results",
[
(
"/fixtures/facetable.json?_facet=state&_facet=city_id",
{
"state": {
"name": "state",
"hideable": True,
"type": "column",
"toggle_url": "/fixtures/facetable.json?_facet=city_id",
"results": [
{
"value": "CA",
"label": "CA",
"count": 10,
"toggle_url": "_facet=state&_facet=city_id&state=CA",
"selected": False,
},
{
"value": "MI",
"label": "MI",
"count": 4,
"toggle_url": "_facet=state&_facet=city_id&state=MI",
"selected": False,
},
{
"value": "MC",
"label": "MC",
"count": 1,
"toggle_url": "_facet=state&_facet=city_id&state=MC",
"selected": False,
},
],
"truncated": False,
},
"city_id": {
"name": "city_id",
"hideable": True,
"type": "column",
"toggle_url": "/fixtures/facetable.json?_facet=state",
"results": [
{
"value": 1,
"label": "San Francisco",
"count": 6,
"toggle_url": "_facet=state&_facet=city_id&city_id=1",
"selected": False,
},
{
"value": 2,
"label": "Los Angeles",
"count": 4,
"toggle_url": "_facet=state&_facet=city_id&city_id=2",
"selected": False,
},
{
"value": 3,
"label": "Detroit",
"count": 4,
"toggle_url": "_facet=state&_facet=city_id&city_id=3",
"selected": False,
},
{
"value": 4,
"label": "Memnonia",
"count": 1,
"toggle_url": "_facet=state&_facet=city_id&city_id=4",
"selected": False,
},
],
"truncated": False,
},
Facet results now have "truncated" field To indicate if there was more than 20 distinct values. Refs #255
2018-05-15 09:50:27 +00:00
},
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
),
(
"/fixtures/facetable.json?_facet=state&_facet=city_id&state=MI",
{
"state": {
"name": "state",
"hideable": True,
"type": "column",
"toggle_url": "/fixtures/facetable.json?_facet=city_id&state=MI",
"results": [
{
"value": "MI",
"label": "MI",
"count": 4,
"selected": True,
"toggle_url": "_facet=state&_facet=city_id",
}
],
"truncated": False,
},
"city_id": {
"name": "city_id",
"hideable": True,
"type": "column",
"toggle_url": "/fixtures/facetable.json?_facet=state&state=MI",
"results": [
{
"value": 3,
"label": "Detroit",
"count": 4,
"selected": False,
"toggle_url": "_facet=state&_facet=city_id&state=MI&city_id=3",
}
],
"truncated": False,
},
Facet results now have "truncated" field To indicate if there was more than 20 distinct values. Refs #255
2018-05-15 09:50:27 +00:00
},
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
),
(
"/fixtures/facetable.json?_facet=planet_int",
{
"planet_int": {
"name": "planet_int",
"hideable": True,
"type": "column",
"toggle_url": "/fixtures/facetable.json",
"results": [
{
"value": 1,
"label": 1,
"count": 14,
"selected": False,
"toggle_url": "_facet=planet_int&planet_int=1",
},
{
"value": 2,
"label": 2,
"count": 1,
"selected": False,
"toggle_url": "_facet=planet_int&planet_int=2",
},
],
"truncated": False,
}
Facet results now have "truncated" field To indicate if there was more than 20 distinct values. Refs #255
2018-05-15 09:50:27 +00:00
},
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
),
(
# planet_int is an integer field:
"/fixtures/facetable.json?_facet=planet_int&planet_int=1",
{
"planet_int": {
"name": "planet_int",
"hideable": True,
"type": "column",
"toggle_url": "/fixtures/facetable.json?planet_int=1",
"results": [
{
"value": 1,
"label": 1,
"count": 14,
"selected": True,
"toggle_url": "_facet=planet_int",
}
],
"truncated": False,
}
Facet results now have "truncated" field To indicate if there was more than 20 distinct values. Refs #255
2018-05-15 09:50:27 +00:00
},
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
),
],
)
Initial implementation of facets, plus tests and docs Refs #255
2018-05-12 22:29:06 +00:00
def test_facets(app_client, path, expected_facet_results):
Test client wrapper removing need for gather_request - refs #272 As part of decoupling from Sanic, this will make it easier to run tests against ASGI instead.
2018-06-05 03:53:12 +00:00
response = app_client.get(path)
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
facet_results = response.json["facet_results"]
Initial implementation of facets, plus tests and docs Refs #255
2018-05-12 22:29:06 +00:00
# We only compare the querystring portion of the taggle_url
Facet results now have "truncated" field To indicate if there was more than 20 distinct values. Refs #255
2018-05-15 09:50:27 +00:00
for facet_name, facet_info in facet_results.items():
assert facet_name == facet_info["name"]
assert False is facet_info["truncated"]
for facet_value in facet_info["results"]:
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
facet_value["toggle_url"] = facet_value["toggle_url"].split("?")[1]
Initial implementation of facets, plus tests and docs Refs #255
2018-05-12 22:29:06 +00:00
assert expected_facet_results == facet_results
allow_facet, allow_download, suggest_facets boolean --config Refs #284
2018-05-25 01:12:27 +00:00
def test_suggested_facets(app_client):
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
suggestions = [
{
"name": suggestion["name"],
"querystring": suggestion["toggle_url"].split("?")[-1],
}
for suggestion in app_client.get("/fixtures/facetable.json").json[
"suggested_facets"
]
]
Implemented ArrayFacet, closes #359
2019-05-03 00:21:27 +00:00
expected = [
Facet by date, closes #481
2019-05-21 06:09:22 +00:00
{"name": "created", "querystring": "_facet=created"},
Extract facet code out into a new plugin hook, closes #427 (#445) Datasette previously only supported one type of faceting: exact column value counting. With this change, faceting logic is extracted out into one or more separate classes which can implement other patterns of faceting - this is discussed in #427, but potential upcoming facet types include facet-by-date, facet-by-JSON-array, facet-by-many-2-many and more. A new plugin hook, register_facet_classes, can be used by plugins to add in additional facet classes. Each class must implement two methods: suggest(), which scans columns in the table to decide if they might be worth suggesting for faceting, and facet_results(), which executes the facet operation and returns results ready to be displayed in the UI.
2019-05-03 00:11:26 +00:00
{"name": "planet_int", "querystring": "_facet=planet_int"},
{"name": "on_earth", "querystring": "_facet=on_earth"},
{"name": "state", "querystring": "_facet=state"},
{"name": "city_id", "querystring": "_facet=city_id"},
{"name": "neighborhood", "querystring": "_facet=neighborhood"},
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
{"name": "tags", "querystring": "_facet=tags"},
Only suggest array facet for arrays of strings - closes #562
2019-11-01 19:37:46 +00:00
{"name": "complex_array", "querystring": "_facet=complex_array"},
Facet by date, closes #481
2019-05-21 06:09:22 +00:00
{"name": "created", "querystring": "_facet_date=created"},
Implemented ArrayFacet, closes #359
2019-05-03 00:21:27 +00:00
]
if detect_json1():
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
expected.append({"name": "tags", "querystring": "_facet_array=tags"})
Implemented ArrayFacet, closes #359
2019-05-03 00:21:27 +00:00
assert expected == suggestions
allow_facet, allow_download, suggest_facets boolean --config Refs #284
2018-05-25 01:12:27 +00:00
def test_allow_facet_off():
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
for client in make_app_client(config={"allow_facet": False}):
assert 400 == client.get("/fixtures/facetable.json?_facet=planet_int").status
allow_facet, allow_download, suggest_facets boolean --config Refs #284
2018-05-25 01:12:27 +00:00
# Should not suggest any facets either:
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
assert [] == client.get("/fixtures/facetable.json").json["suggested_facets"]
allow_facet, allow_download, suggest_facets boolean --config Refs #284
2018-05-25 01:12:27 +00:00
def test_suggest_facets_off():
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
for client in make_app_client(config={"suggest_facets": False}):
allow_facet, allow_download, suggest_facets boolean --config Refs #284
2018-05-25 01:12:27 +00:00
# Now suggested_facets should be []
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
assert [] == client.get("/fixtures/facetable.json").json["suggested_facets"]
?_ttl= parameter and default_cache_ttl config Refs #285, Closes #289
2018-05-26 22:17:33 +00:00
?_labels= and ?_label=COL to expand foreign keys in JSON/CSV These new querystring arguments can be used to request expanded foreign keys in both JSON and CSV formats. ?_labels=on turns on expansions for ALL foreign key columns ?_label=COLUMN1&_label=COLUMN2 can be used to pick specific columns to expand e.g. `Street_Tree_List.json?_label=qSpecies&_label=qLegalStatus` { "rowid": 233, "TreeID": 121240, "qLegalStatus": { "value" 2, "label": "Private" } "qSpecies": { "value": 16, "label": "Sycamore" } "qAddress": "91 Commonwealth Ave", ... } The labels option also works for the HTML and CSV views. HTML defaults to `?_labels=on`, so if you pass `?_labels=off` you can disable foreign key expansion entirely - or you can use `?_label=COLUMN` to request just specific columns. If you expand labels on CSV you get additional columns in the output: `/Street_Tree_List.csv?_label=qLegalStatus` rowid,TreeID,qLegalStatus,qLegalStatus_label... 1,141565,1,Permitted Site... 2,232565,2,Undocumented... I also refactored the existing foreign key expansion code. Closes #233. Refs #266.
2018-06-16 22:18:57 +00:00
def test_expand_labels(app_client):
response = app_client.get(
Renamed test_tables.db to fixtures.db in unit tests
2018-06-17 18:34:16 +00:00
"/fixtures/facetable.json?_shape=object&_labels=1&_size=2"
?_labels= and ?_label=COL to expand foreign keys in JSON/CSV These new querystring arguments can be used to request expanded foreign keys in both JSON and CSV formats. ?_labels=on turns on expansions for ALL foreign key columns ?_label=COLUMN1&_label=COLUMN2 can be used to pick specific columns to expand e.g. `Street_Tree_List.json?_label=qSpecies&_label=qLegalStatus` { "rowid": 233, "TreeID": 121240, "qLegalStatus": { "value" 2, "label": "Private" } "qSpecies": { "value": 16, "label": "Sycamore" } "qAddress": "91 Commonwealth Ave", ... } The labels option also works for the HTML and CSV views. HTML defaults to `?_labels=on`, so if you pass `?_labels=off` you can disable foreign key expansion entirely - or you can use `?_label=COLUMN` to request just specific columns. If you expand labels on CSV you get additional columns in the output: `/Street_Tree_List.csv?_label=qLegalStatus` rowid,TreeID,qLegalStatus,qLegalStatus_label... 1,141565,1,Permitted Site... 2,232565,2,Undocumented... I also refactored the existing foreign key expansion code. Closes #233. Refs #266.
2018-06-16 22:18:57 +00:00
"&neighborhood__contains=c"
)
assert {
"2": {
"pk": 2,
Facet by date, closes #481
2019-05-21 06:09:22 +00:00
"created": "2019-01-14 08:00:00",
?_labels= and ?_label=COL to expand foreign keys in JSON/CSV These new querystring arguments can be used to request expanded foreign keys in both JSON and CSV formats. ?_labels=on turns on expansions for ALL foreign key columns ?_label=COLUMN1&_label=COLUMN2 can be used to pick specific columns to expand e.g. `Street_Tree_List.json?_label=qSpecies&_label=qLegalStatus` { "rowid": 233, "TreeID": 121240, "qLegalStatus": { "value" 2, "label": "Private" } "qSpecies": { "value": 16, "label": "Sycamore" } "qAddress": "91 Commonwealth Ave", ... } The labels option also works for the HTML and CSV views. HTML defaults to `?_labels=on`, so if you pass `?_labels=off` you can disable foreign key expansion entirely - or you can use `?_label=COLUMN` to request just specific columns. If you expand labels on CSV you get additional columns in the output: `/Street_Tree_List.csv?_label=qLegalStatus` rowid,TreeID,qLegalStatus,qLegalStatus_label... 1,141565,1,Permitted Site... 2,232565,2,Undocumented... I also refactored the existing foreign key expansion code. Closes #233. Refs #266.
2018-06-16 22:18:57 +00:00
"planet_int": 1,
Correctly display facets with value of 0 - fixes #318 Also added comprehensive unit test for facet display HTML.
2018-06-21 04:30:13 +00:00
"on_earth": 1,
?_labels= and ?_label=COL to expand foreign keys in JSON/CSV These new querystring arguments can be used to request expanded foreign keys in both JSON and CSV formats. ?_labels=on turns on expansions for ALL foreign key columns ?_label=COLUMN1&_label=COLUMN2 can be used to pick specific columns to expand e.g. `Street_Tree_List.json?_label=qSpecies&_label=qLegalStatus` { "rowid": 233, "TreeID": 121240, "qLegalStatus": { "value" 2, "label": "Private" } "qSpecies": { "value": 16, "label": "Sycamore" } "qAddress": "91 Commonwealth Ave", ... } The labels option also works for the HTML and CSV views. HTML defaults to `?_labels=on`, so if you pass `?_labels=off` you can disable foreign key expansion entirely - or you can use `?_label=COLUMN` to request just specific columns. If you expand labels on CSV you get additional columns in the output: `/Street_Tree_List.csv?_label=qLegalStatus` rowid,TreeID,qLegalStatus,qLegalStatus_label... 1,141565,1,Permitted Site... 2,232565,2,Undocumented... I also refactored the existing foreign key expansion code. Closes #233. Refs #266.
2018-06-16 22:18:57 +00:00
"state": "CA",
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"city_id": {"value": 1, "label": "San Francisco"},
New ?tags__arraycontains=tag lookup against JSON fields Part one of supporting facet-by-JSON-array, refs #359
2019-04-10 15:17:19 +00:00
"neighborhood": "Dogpatch",
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"tags": '["tag1", "tag3"]',
Only suggest array facet for arrays of strings - closes #562
2019-11-01 19:37:46 +00:00
"complex_array": "[]",
?_labels= and ?_label=COL to expand foreign keys in JSON/CSV These new querystring arguments can be used to request expanded foreign keys in both JSON and CSV formats. ?_labels=on turns on expansions for ALL foreign key columns ?_label=COLUMN1&_label=COLUMN2 can be used to pick specific columns to expand e.g. `Street_Tree_List.json?_label=qSpecies&_label=qLegalStatus` { "rowid": 233, "TreeID": 121240, "qLegalStatus": { "value" 2, "label": "Private" } "qSpecies": { "value": 16, "label": "Sycamore" } "qAddress": "91 Commonwealth Ave", ... } The labels option also works for the HTML and CSV views. HTML defaults to `?_labels=on`, so if you pass `?_labels=off` you can disable foreign key expansion entirely - or you can use `?_label=COLUMN` to request just specific columns. If you expand labels on CSV you get additional columns in the output: `/Street_Tree_List.csv?_label=qLegalStatus` rowid,TreeID,qLegalStatus,qLegalStatus_label... 1,141565,1,Permitted Site... 2,232565,2,Undocumented... I also refactored the existing foreign key expansion code. Closes #233. Refs #266.
2018-06-16 22:18:57 +00:00
},
"13": {
"pk": 13,
Facet by date, closes #481
2019-05-21 06:09:22 +00:00
"created": "2019-01-17 08:00:00",
?_labels= and ?_label=COL to expand foreign keys in JSON/CSV These new querystring arguments can be used to request expanded foreign keys in both JSON and CSV formats. ?_labels=on turns on expansions for ALL foreign key columns ?_label=COLUMN1&_label=COLUMN2 can be used to pick specific columns to expand e.g. `Street_Tree_List.json?_label=qSpecies&_label=qLegalStatus` { "rowid": 233, "TreeID": 121240, "qLegalStatus": { "value" 2, "label": "Private" } "qSpecies": { "value": 16, "label": "Sycamore" } "qAddress": "91 Commonwealth Ave", ... } The labels option also works for the HTML and CSV views. HTML defaults to `?_labels=on`, so if you pass `?_labels=off` you can disable foreign key expansion entirely - or you can use `?_label=COLUMN` to request just specific columns. If you expand labels on CSV you get additional columns in the output: `/Street_Tree_List.csv?_label=qLegalStatus` rowid,TreeID,qLegalStatus,qLegalStatus_label... 1,141565,1,Permitted Site... 2,232565,2,Undocumented... I also refactored the existing foreign key expansion code. Closes #233. Refs #266.
2018-06-16 22:18:57 +00:00
"planet_int": 1,
Correctly display facets with value of 0 - fixes #318 Also added comprehensive unit test for facet display HTML.
2018-06-21 04:30:13 +00:00
"on_earth": 1,
?_labels= and ?_label=COL to expand foreign keys in JSON/CSV These new querystring arguments can be used to request expanded foreign keys in both JSON and CSV formats. ?_labels=on turns on expansions for ALL foreign key columns ?_label=COLUMN1&_label=COLUMN2 can be used to pick specific columns to expand e.g. `Street_Tree_List.json?_label=qSpecies&_label=qLegalStatus` { "rowid": 233, "TreeID": 121240, "qLegalStatus": { "value" 2, "label": "Private" } "qSpecies": { "value": 16, "label": "Sycamore" } "qAddress": "91 Commonwealth Ave", ... } The labels option also works for the HTML and CSV views. HTML defaults to `?_labels=on`, so if you pass `?_labels=off` you can disable foreign key expansion entirely - or you can use `?_label=COLUMN` to request just specific columns. If you expand labels on CSV you get additional columns in the output: `/Street_Tree_List.csv?_label=qLegalStatus` rowid,TreeID,qLegalStatus,qLegalStatus_label... 1,141565,1,Permitted Site... 2,232565,2,Undocumented... I also refactored the existing foreign key expansion code. Closes #233. Refs #266.
2018-06-16 22:18:57 +00:00
"state": "MI",
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"city_id": {"value": 3, "label": "Detroit"},
New ?tags__arraycontains=tag lookup against JSON fields Part one of supporting facet-by-JSON-array, refs #359
2019-04-10 15:17:19 +00:00
"neighborhood": "Corktown",
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"tags": "[]",
Only suggest array facet for arrays of strings - closes #562
2019-11-01 19:37:46 +00:00
"complex_array": "[]",
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
},
?_labels= and ?_label=COL to expand foreign keys in JSON/CSV These new querystring arguments can be used to request expanded foreign keys in both JSON and CSV formats. ?_labels=on turns on expansions for ALL foreign key columns ?_label=COLUMN1&_label=COLUMN2 can be used to pick specific columns to expand e.g. `Street_Tree_List.json?_label=qSpecies&_label=qLegalStatus` { "rowid": 233, "TreeID": 121240, "qLegalStatus": { "value" 2, "label": "Private" } "qSpecies": { "value": 16, "label": "Sycamore" } "qAddress": "91 Commonwealth Ave", ... } The labels option also works for the HTML and CSV views. HTML defaults to `?_labels=on`, so if you pass `?_labels=off` you can disable foreign key expansion entirely - or you can use `?_label=COLUMN` to request just specific columns. If you expand labels on CSV you get additional columns in the output: `/Street_Tree_List.csv?_label=qLegalStatus` rowid,TreeID,qLegalStatus,qLegalStatus_label... 1,141565,1,Permitted Site... 2,232565,2,Undocumented... I also refactored the existing foreign key expansion code. Closes #233. Refs #266.
2018-06-16 22:18:57 +00:00
} == response.json
def test_expand_label(app_client):
response = app_client.get(
Renamed test_tables.db to fixtures.db in unit tests
2018-06-17 18:34:16 +00:00
"/fixtures/foreign_key_references.json?_shape=object"
?_labels= and ?_label=COL to expand foreign keys in JSON/CSV These new querystring arguments can be used to request expanded foreign keys in both JSON and CSV formats. ?_labels=on turns on expansions for ALL foreign key columns ?_label=COLUMN1&_label=COLUMN2 can be used to pick specific columns to expand e.g. `Street_Tree_List.json?_label=qSpecies&_label=qLegalStatus` { "rowid": 233, "TreeID": 121240, "qLegalStatus": { "value" 2, "label": "Private" } "qSpecies": { "value": 16, "label": "Sycamore" } "qAddress": "91 Commonwealth Ave", ... } The labels option also works for the HTML and CSV views. HTML defaults to `?_labels=on`, so if you pass `?_labels=off` you can disable foreign key expansion entirely - or you can use `?_label=COLUMN` to request just specific columns. If you expand labels on CSV you get additional columns in the output: `/Street_Tree_List.csv?_label=qLegalStatus` rowid,TreeID,qLegalStatus,qLegalStatus_label... 1,141565,1,Permitted Site... 2,232565,2,Undocumented... I also refactored the existing foreign key expansion code. Closes #233. Refs #266.
2018-06-16 22:18:57 +00:00
"&_label=foreign_key_with_label"
)
assert {
"1": {
"pk": "1",
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"foreign_key_with_label": {"value": "1", "label": "hello"},
"foreign_key_with_no_label": "1",
?_labels= and ?_label=COL to expand foreign keys in JSON/CSV These new querystring arguments can be used to request expanded foreign keys in both JSON and CSV formats. ?_labels=on turns on expansions for ALL foreign key columns ?_label=COLUMN1&_label=COLUMN2 can be used to pick specific columns to expand e.g. `Street_Tree_List.json?_label=qSpecies&_label=qLegalStatus` { "rowid": 233, "TreeID": 121240, "qLegalStatus": { "value" 2, "label": "Private" } "qSpecies": { "value": 16, "label": "Sycamore" } "qAddress": "91 Commonwealth Ave", ... } The labels option also works for the HTML and CSV views. HTML defaults to `?_labels=on`, so if you pass `?_labels=off` you can disable foreign key expansion entirely - or you can use `?_label=COLUMN` to request just specific columns. If you expand labels on CSV you get additional columns in the output: `/Street_Tree_List.csv?_label=qLegalStatus` rowid,TreeID,qLegalStatus,qLegalStatus_label... 1,141565,1,Permitted Site... 2,232565,2,Undocumented... I also refactored the existing foreign key expansion code. Closes #233. Refs #266.
2018-06-16 22:18:57 +00:00
}
} == response.json
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
@pytest.mark.parametrize(
"path,expected_cache_control",
[
("/fixtures/facetable.json", "max-age=5"),
("/fixtures/facetable.json?_ttl=invalid", "max-age=5"),
("/fixtures/facetable.json?_ttl=10", "max-age=10"),
("/fixtures/facetable.json?_ttl=0", "no-cache"),
],
)
?_ttl= parameter and default_cache_ttl config Refs #285, Closes #289
2018-05-26 22:17:33 +00:00
def test_ttl_parameter(app_client, path, expected_cache_control):
Test client wrapper removing need for gather_request - refs #272 As part of decoupling from Sanic, this will make it easier to run tests against ASGI instead.
2018-06-05 03:53:12 +00:00
response = app_client.get(path)
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
assert expected_cache_control == response.headers["Cache-Control"]
New ?_json=colname argument for returning unescaped JSON Also extracted docs for special JSON arguments into a new section. Closes #31
2018-05-28 18:08:39 +00:00
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
@pytest.mark.parametrize(
"path,expected_redirect",
[
("/fixtures/facetable.json?_hash=1", "/fixtures-HASH/facetable.json"),
(
"/fixtures/facetable.json?city_id=1&_hash=1",
"/fixtures-HASH/facetable.json?city_id=1",
),
],
)
?_hash=1 no longer respected for mutable databases Closes #471, refs #419
2019-05-16 15:10:25 +00:00
def test_hash_parameter(
app_client_two_attached_databases_one_immutable, path, expected_redirect
):
URL hashing is now off by default - closes #418 Prior to this commit Datasette would calculate the content hash of every database and redirect to a URL containing that hash, like so: https://v0-27.datasette.io/fixtures => https://v0-27.datasette.io/fixtures-dd88475 This assumed that all databases were opened in immutable mode and were not expected to change. This will be changing as a result of #419 - so this commit takes the first step in implementing that change by changing this default behaviour. Datasette will now only redirect hash-free URLs under two circumstances: * The new `hash_urls` config option is set to true (it defaults to false). * The user passes `?_hash=1` in the URL
2019-03-17 22:55:04 +00:00
# First get the current hash for the fixtures database
?_hash=1 no longer respected for mutable databases Closes #471, refs #419
2019-05-16 15:10:25 +00:00
current_hash = app_client_two_attached_databases_one_immutable.ds.databases[
"fixtures"
].hash[:7]
response = app_client_two_attached_databases_one_immutable.get(
path, allow_redirects=False
)
URL hashing is now off by default - closes #418 Prior to this commit Datasette would calculate the content hash of every database and redirect to a URL containing that hash, like so: https://v0-27.datasette.io/fixtures => https://v0-27.datasette.io/fixtures-dd88475 This assumed that all databases were opened in immutable mode and were not expected to change. This will be changing as a result of #419 - so this commit takes the first step in implementing that change by changing this default behaviour. Datasette will now only redirect hash-free URLs under two circumstances: * The new `hash_urls` config option is set to true (it defaults to false). * The user passes `?_hash=1` in the URL
2019-03-17 22:55:04 +00:00
assert response.status == 302
location = response.headers["Location"]
assert expected_redirect.replace("HASH", current_hash) == location
?_hash=1 no longer respected for mutable databases Closes #471, refs #419
2019-05-16 15:10:25 +00:00
def test_hash_parameter_ignored_for_mutable_databases(app_client):
path = "/fixtures/facetable.json?_hash=1"
response = app_client.get(path, allow_redirects=False)
assert response.status == 200
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
test_json_columns_default_expected = [
{"intval": 1, "strval": "s", "floatval": 0.5, "jsonval": '{"foo": "bar"}'}
]
@pytest.mark.parametrize(
"extra_args,expected",
[
("", test_json_columns_default_expected),
("&_json=intval", test_json_columns_default_expected),
("&_json=strval", test_json_columns_default_expected),
("&_json=floatval", test_json_columns_default_expected),
(
"&_json=jsonval",
[{"intval": 1, "strval": "s", "floatval": 0.5, "jsonval": {"foo": "bar"}}],
),
],
)
New ?_json=colname argument for returning unescaped JSON Also extracted docs for special JSON arguments into a new section. Closes #31
2018-05-28 18:08:39 +00:00
def test_json_columns(app_client, extra_args, expected):
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
sql = """
New ?_json=colname argument for returning unescaped JSON Also extracted docs for special JSON arguments into a new section. Closes #31
2018-05-28 18:08:39 +00:00
select 1 as intval, "s" as strval, 0.5 as floatval,
'{"foo": "bar"}' as jsonval
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
"""
path = "/fixtures.json?" + urllib.parse.urlencode({"sql": sql, "_shape": "array"})
New ?_json=colname argument for returning unescaped JSON Also extracted docs for special JSON arguments into a new section. Closes #31
2018-05-28 18:08:39 +00:00
path += extra_args
Test client wrapper removing need for gather_request - refs #272 As part of decoupling from Sanic, this will make it easier to run tests against ASGI instead.
2018-06-05 03:53:12 +00:00
response = app_client.get(path)
New ?_json=colname argument for returning unescaped JSON Also extracted docs for special JSON arguments into a new section. Closes #31
2018-05-28 18:08:39 +00:00
assert expected == response.json
New cache_size_kb config for SQLite, closes #304
2018-06-04 16:02:07 +00:00
def test_config_cache_size(app_client_larger_cache_size):
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
response = app_client_larger_cache_size.get("/fixtures/pragma_cache_size.json")
assert [[-2500]] == response.json["rows"]
New force_https_urls option, refs #333
2018-07-23 15:58:29 +00:00
def test_config_force_https_urls():
New make_app_client() pattern Because next version of pytest discourages calling fixture factories as functions
2018-11-20 17:16:31 +00:00
for client in make_app_client(config={"force_https_urls": True}):
New force_https_urls option, refs #333
2018-07-23 15:58:29 +00:00
response = client.get("/fixtures/facetable.json?_size=3&_facet=state")
assert response.json["next_url"].startswith("https://")
assert response.json["facet_results"]["state"]["results"][0][
"toggle_url"
].startswith("https://")
assert response.json["suggested_facets"][0]["toggle_url"].startswith("https://")
?_json_infinity=1 for handling Infinity/-Infinity - fixes #332
2018-07-24 03:07:57 +00:00
def test_infinity_returned_as_null(app_client):
response = app_client.get("/fixtures/infinity.json?_shape=array")
assert [
{"rowid": 1, "value": None},
{"rowid": 2, "value": None},
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
{"rowid": 3, "value": 1.5},
?_json_infinity=1 for handling Infinity/-Infinity - fixes #332
2018-07-24 03:07:57 +00:00
] == response.json
def test_infinity_returned_as_invalid_json_if_requested(app_client):
response = app_client.get("/fixtures/infinity.json?_shape=array&_json_infinity=1")
assert [
{"rowid": 1, "value": float("inf")},
{"rowid": 2, "value": float("-inf")},
Apply black to everything, enforce via unit tests (#449) I've run the black code formatting tool against everything: black tests datasette setup.py I also added a new unit test, in tests/test_black.py, which will fail if the code does not conform to black's exacting standards. This unit test only runs on Python 3.6 or higher, because black itself doesn't run on 3.5.
2019-05-04 02:15:14 +00:00
{"rowid": 3, "value": 1.5},
?_json_infinity=1 for handling Infinity/-Infinity - fixes #332
2018-07-24 03:07:57 +00:00
] == response.json
Test for ?_trace=1, refs #435
2019-04-21 17:46:56 +00:00
Fix plus test for unicode characters in custom query name, closes #558
2019-07-14 02:49:24 +00:00
def test_custom_query_with_unicode_characters(app_client):
response = app_client.get("/fixtures/𝐜𝐢𝐭𝐢𝐞𝐬.json?_shape=array")
assert [{"id": 1, "name": "San Francisco"}] == response.json
Test for ?_trace=1, refs #435
2019-04-21 17:46:56 +00:00
def test_trace(app_client):
response = app_client.get("/fixtures/simple_primary_key.json?_trace=1")
data = response.json
Finished implementation of ?_trace=1 debug tool I redesigned the JSON output and added a handy "traceback" key showing three relevant lines of the current traceback for each logged query. Closes #435
2019-05-11 19:06:22 +00:00
assert "_trace" in data
trace_info = data["_trace"]
assert isinstance(trace_info["request_duration_ms"], float)
assert isinstance(trace_info["sum_trace_duration_ms"], float)
assert isinstance(trace_info["num_traces"], int)
assert isinstance(trace_info["traces"], list)
assert len(trace_info["traces"]) == trace_info["num_traces"]
for trace in trace_info["traces"]:
assert isinstance(trace["type"], str)
assert isinstance(trace["start"], float)
assert isinstance(trace["end"], float)
assert trace["duration_ms"] == (trace["end"] - trace["start"]) * 1000
assert isinstance(trace["traceback"], list)
assert isinstance(trace["database"], str)
assert isinstance(trace["sql"], str)
assert isinstance(trace["params"], (list, dict))
Respect --cors for error pages, closes #453
2019-05-05 11:59:45 +00:00
@pytest.mark.parametrize(
"path,status_code",
[
("/fixtures.json", 200),
("/fixtures/no_primary_key.json", 200),
# A 400 invalid SQL query should still have the header:
("/fixtures.json?sql=select+blah", 400),
],
)
def test_cors(app_client_with_cors, path, status_code):
response = app_client_with_cors.get(path)
assert response.status == status_code
assert "*" == response.headers["Access-Control-Allow-Origin"]
Fix for /foo v.s. /foo-bar issue, closes #597 Pull request #599
2019-10-18 22:51:07 +00:00
def test_common_prefix_database_names(app_client_conflicting_database_names):
# https://github.com/simonw/datasette/issues/597
assert ["fixtures", "foo", "foo-bar"] == [
d["name"]
for d in json.loads(
app_client_conflicting_database_names.get("/-/databases.json").body.decode(
"utf8"
)
)
]
for db_name, path in (("foo", "/foo.json"), ("foo-bar", "/foo-bar.json")):
data = json.loads(
app_client_conflicting_database_names.get(path).body.decode("utf8")
)
assert db_name == data["database"]