QT/superset2
1
0
Fork 0
mirror of https://github.com/apache/superset.git synced 2026-04-08 02:45:22 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
2c9f0c1c2a8ae99d4bae93e2cf3cd15e7c4eef5a
superset2/tests/unit_tests/utils/test_core.py

1691 lines
54 KiB
Python
Raw Blame History

# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
import os
from dataclasses import dataclass
from typing import Any, Optional
from unittest.mock import MagicMock, patch
import numpy as np
import pandas as pd
import pytest
from flask import current_app
from pandas.api.types import is_datetime64_dtype
from pytest_mock import MockerFixture
from superset.exceptions import SupersetException
from superset.utils.core import (
cast_to_boolean,
check_is_safe_zip,
DateColumn,
FilterOperator,
generic_find_constraint_name,
generic_find_fk_constraint_name,
get_datasource_full_name,
get_query_source_from_request,
get_stacktrace,
get_user_agent,
is_test,
merge_extra_filters,
merge_extra_form_data,
merge_request_params,
normalize_dttm_col,
parse_boolean_string,
parse_js_uri_path_item,
QueryObjectFilterClause,
QuerySource,
remove_extra_adhoc_filters,
sanitize_svg_content,
sanitize_url,
)
from tests.conftest import with_config
ADHOC_FILTER: QueryObjectFilterClause = {
"col": "foo",
"op": "==",
"val": "bar",
}
EXTRA_FILTER: QueryObjectFilterClause = {
"col": "foo",
"op": "==",
"val": "bar",
"isExtra": True,
}
@dataclass
class MockZipInfo:
file_size: int
compress_size: int
@pytest.mark.parametrize(
"original,expected",
[
({"foo": "bar"}, {"foo": "bar"}),
(
{"foo": "bar", "adhoc_filters": [ADHOC_FILTER]},
{"foo": "bar", "adhoc_filters": [ADHOC_FILTER]},
),
(
{"foo": "bar", "adhoc_filters": [EXTRA_FILTER]},
{"foo": "bar", "adhoc_filters": []},
),
(
{
"foo": "bar",
"adhoc_filters": [ADHOC_FILTER, EXTRA_FILTER],
},
{"foo": "bar", "adhoc_filters": [ADHOC_FILTER]},
),
(
{
"foo": "bar",
"adhoc_filters_b": [ADHOC_FILTER, EXTRA_FILTER],
},
{"foo": "bar", "adhoc_filters_b": [ADHOC_FILTER]},
),
(
{
"foo": "bar",
"custom_adhoc_filters": [
ADHOC_FILTER,
EXTRA_FILTER,
],
},
{
"foo": "bar",
"custom_adhoc_filters": [
ADHOC_FILTER,
EXTRA_FILTER,
],
},
),
],
)
def test_remove_extra_adhoc_filters(
original: dict[str, Any], expected: dict[str, Any]
) -> None:
remove_extra_adhoc_filters(original)
assert expected == original
def test_is_test():
orig_value = os.getenv("SUPERSET_TESTENV")
os.environ["SUPERSET_TESTENV"] = "true"
assert is_test()
os.environ["SUPERSET_TESTENV"] = "false"
assert not is_test()
os.environ["SUPERSET_TESTENV"] = ""
assert not is_test()
if orig_value is not None:
os.environ["SUPERSET_TESTENV"] = orig_value
@pytest.mark.parametrize(
"test_input,expected",
[
("y", True),
("Y", True),
("yes", True),
("True", True),
("t", True),
("true", True),
("On", True),
("on", True),
("1", True),
("n", False),
("N", False),
("no", False),
("False", False),
("f", False),
("false", False),
("Off", False),
("off", False),
("0", False),
("foo", False),
(None, False),
],
)
def test_parse_boolean_string(test_input: Optional[str], expected: bool):
assert parse_boolean_string(test_input) == expected
def test_int_values():
assert cast_to_boolean(1) is True
assert cast_to_boolean(0) is False
assert cast_to_boolean(-1) is True
assert cast_to_boolean(42) is True
assert cast_to_boolean(0) is False
def test_float_values():
assert cast_to_boolean(0.5) is True
assert cast_to_boolean(3.14) is True
assert cast_to_boolean(-2.71) is True
assert cast_to_boolean(0.0) is False
def test_string_values():
assert cast_to_boolean("true") is True
assert cast_to_boolean("TruE") is True
assert cast_to_boolean("false") is False
assert cast_to_boolean("FaLsE") is False
assert cast_to_boolean("") is False
def test_none_value():
assert cast_to_boolean(None) is None
def test_boolean_values():
assert cast_to_boolean(True) is True
assert cast_to_boolean(False) is False
def test_other_values():
assert cast_to_boolean([]) is False
assert cast_to_boolean({}) is False
assert cast_to_boolean(object()) is False
def test_normalize_dttm_col() -> None:
"""
Tests for the ``normalize_dttm_col`` function.
In particular, this covers a regression when Pandas was upgraded from 1.5.3 to
2.0.3 and the behavior of ``pd.to_datetime`` changed.
"""
df = pd.DataFrame({"__time": ["2017-07-01T00:00:00.000Z"]})
assert (
df.to_markdown()
== """
| | __time |
|---:|:-------------------------|
| 0 | 2017-07-01T00:00:00.000Z |
""".strip()
)
# in 1.5.3 this would return a datetime64[ns] dtype, but in 2.0.3 we had to
# add ``exact=False`` since there is a leftover after parsing the format
dttm_cols = (DateColumn("__time", "%Y-%m-%d"),)
# the function modifies the dataframe in place
normalize_dttm_col(df, dttm_cols)
assert df["__time"].astype(str).tolist() == ["2017-07-01"]
def test_normalize_dttm_col_epoch_seconds() -> None:
"""Test conversion of epoch seconds."""
df = pd.DataFrame(
{
"epoch_col": [
1577836800,
1609459200,
1640995200,
] # 2020-01-01, 2021-01-01, 2022-01-01
}
)
dttm_cols = (DateColumn(col_label="epoch_col", timestamp_format="epoch_s"),)
normalize_dttm_col(df, dttm_cols)
assert is_datetime64_dtype(df["epoch_col"])
assert df["epoch_col"][0].strftime("%Y-%m-%d") == "2020-01-01"
assert df["epoch_col"][1].strftime("%Y-%m-%d") == "2021-01-01"
assert df["epoch_col"][2].strftime("%Y-%m-%d") == "2022-01-01"
def test_normalize_dttm_col_epoch_milliseconds() -> None:
"""Test conversion of epoch milliseconds."""
df = pd.DataFrame(
{
"epoch_ms_col": [
1577836800000,
1609459200000,
1640995200000,
] # 2020-01-01, 2021-01-01, 2022-01-01
}
)
dttm_cols = (DateColumn(col_label="epoch_ms_col", timestamp_format="epoch_ms"),)
normalize_dttm_col(df, dttm_cols)
assert is_datetime64_dtype(df["epoch_ms_col"])
assert df["epoch_ms_col"][0].strftime("%Y-%m-%d") == "2020-01-01"
assert df["epoch_ms_col"][1].strftime("%Y-%m-%d") == "2021-01-01"
assert df["epoch_ms_col"][2].strftime("%Y-%m-%d") == "2022-01-01"
def test_normalize_dttm_col_formatted_date() -> None:
"""Test conversion of formatted date strings."""
df = pd.DataFrame({"date_col": ["2020-01-01", "2021-01-01", "2022-01-01"]})
dttm_cols = (DateColumn(col_label="date_col", timestamp_format="%Y-%m-%d"),)
normalize_dttm_col(df, dttm_cols)
assert is_datetime64_dtype(df["date_col"])
assert df["date_col"][0].strftime("%Y-%m-%d") == "2020-01-01"
assert df["date_col"][1].strftime("%Y-%m-%d") == "2021-01-01"
assert df["date_col"][2].strftime("%Y-%m-%d") == "2022-01-01"
def test_normalize_dttm_col_with_offset() -> None:
"""Test with hour offset."""
df = pd.DataFrame({"date_col": ["2020-01-01", "2021-01-01", "2022-01-01"]})
dttm_cols = (
DateColumn(col_label="date_col", timestamp_format="%Y-%m-%d", offset=3),
)
normalize_dttm_col(df, dttm_cols)
assert is_datetime64_dtype(df["date_col"])
assert df["date_col"][0].strftime("%Y-%m-%d %H:%M:%S") == "2020-01-01 03:00:00"
assert df["date_col"][1].strftime("%Y-%m-%d %H:%M:%S") == "2021-01-01 03:00:00"
assert df["date_col"][2].strftime("%Y-%m-%d %H:%M:%S") == "2022-01-01 03:00:00"
def test_normalize_dttm_col_with_time_shift() -> None:
"""Test with time shift."""
df = pd.DataFrame({"date_col": ["2020-01-01", "2021-01-01", "2022-01-01"]})
dttm_cols = (
DateColumn(
col_label="date_col", timestamp_format="%Y-%m-%d", time_shift="1 day"
),
)
normalize_dttm_col(df, dttm_cols)
assert is_datetime64_dtype(df["date_col"])
assert df["date_col"][0].strftime("%Y-%m-%d") == "2020-01-02"
assert df["date_col"][1].strftime("%Y-%m-%d") == "2021-01-02"
assert df["date_col"][2].strftime("%Y-%m-%d") == "2022-01-02"
def test_normalize_dttm_col_with_offset_and_time_shift() -> None:
"""Test with both offset and time shift."""
df = pd.DataFrame({"date_col": ["2020-01-01", "2021-01-01", "2022-01-01"]})
dttm_cols = (
DateColumn(
col_label="date_col",
timestamp_format="%Y-%m-%d",
offset=3,
time_shift="1 hour",
),
)
normalize_dttm_col(df, dttm_cols)
assert is_datetime64_dtype(df["date_col"])
assert df["date_col"][0].strftime("%Y-%m-%d %H:%M:%S") == "2020-01-01 04:00:00"
assert df["date_col"][1].strftime("%Y-%m-%d %H:%M:%S") == "2021-01-01 04:00:00"
assert df["date_col"][2].strftime("%Y-%m-%d %H:%M:%S") == "2022-01-01 04:00:00"
def test_normalize_dttm_col_invalid_date_coerced() -> None:
"""Test that invalid dates are coerced to NaT."""
df = pd.DataFrame({"date_col": ["2020-01-01", "invalid_date", "2022-01-01"]})
dttm_cols = (DateColumn(col_label="date_col", timestamp_format="%Y-%m-%d"),)
normalize_dttm_col(df, dttm_cols)
assert is_datetime64_dtype(df["date_col"])
assert df["date_col"][0].strftime("%Y-%m-%d") == "2020-01-01"
assert pd.isna(df["date_col"][1])
assert df["date_col"][2].strftime("%Y-%m-%d") == "2022-01-01"
def test_normalize_dttm_col_invalid_epoch_coerced() -> None:
"""Test that invalid epoch values are coerced to NaT."""
df = pd.DataFrame(
{"epoch_col": [1577836800, np.nan, 1640995200]} # 2020-01-01, NaN, 2022-01-01
)
dttm_cols = (DateColumn(col_label="epoch_col", timestamp_format="epoch_s"),)
normalize_dttm_col(df, dttm_cols)
assert is_datetime64_dtype(df["epoch_col"])
assert df["epoch_col"][0].strftime("%Y-%m-%d") == "2020-01-01"
assert pd.isna(df["epoch_col"][1])
assert df["epoch_col"][2].strftime("%Y-%m-%d") == "2022-01-01"
def test_normalize_dttm_col_non_existing_column() -> None:
"""Test handling of non-existing columns."""
df = pd.DataFrame({"existing_col": [1, 2, 3]})
dttm_cols = (DateColumn(col_label="non_existing_col", timestamp_format="%Y-%m-%d"),)
# Should not raise any exception
normalize_dttm_col(df, dttm_cols)
# DataFrame should remain unchanged
assert list(df.columns) == ["existing_col"]
assert df["existing_col"].tolist() == [1, 2, 3]
def test_normalize_dttm_col_multiple_columns() -> None:
"""Test normalizing multiple datetime columns."""
df = pd.DataFrame(
{
"date_col1": ["2020-01-01", "2021-01-01", "2022-01-01"],
"date_col2": ["01/01/2020", "01/01/2021", "01/01/2022"],
}
)
dttm_cols = (
DateColumn(col_label="date_col1", timestamp_format="%Y-%m-%d"),
DateColumn(col_label="date_col2", timestamp_format="%m/%d/%Y"),
)
normalize_dttm_col(df, dttm_cols)
assert is_datetime64_dtype(df["date_col1"])
assert is_datetime64_dtype(df["date_col2"])
assert df["date_col1"][0].strftime("%Y-%m-%d") == "2020-01-01"
assert df["date_col2"][0].strftime("%Y-%m-%d") == "2020-01-01"
def test_normalize_dttm_col_already_datetime_series() -> None:
"""Test handling of already datetime series with epoch format."""
# Create a DataFrame with timestamp strings
df = pd.DataFrame(
{
"ts_col": [
"2020-01-01 00:00:00",
"2021-01-01 00:00:00",
"2022-01-01 00:00:00",
]
}
)
dttm_cols = (DateColumn(col_label="ts_col", timestamp_format="epoch_s"),)
normalize_dttm_col(df, dttm_cols)
assert is_datetime64_dtype(df["ts_col"])
assert df["ts_col"][0].strftime("%Y-%m-%d") == "2020-01-01"
assert df["ts_col"][1].strftime("%Y-%m-%d") == "2021-01-01"
assert df["ts_col"][2].strftime("%Y-%m-%d") == "2022-01-01"
def test_check_if_safe_zip_success(app_context: None) -> None:
"""
Test if ZIP files are safe
"""
ZipFile = MagicMock() # noqa: N806
ZipFile.infolist.return_value = [
MockZipInfo(file_size=1000, compress_size=10),
MockZipInfo(file_size=1000, compress_size=10),
MockZipInfo(file_size=1000, compress_size=10),
MockZipInfo(file_size=1000, compress_size=10),
MockZipInfo(file_size=1000, compress_size=10),
]
check_is_safe_zip(ZipFile)
def test_check_if_safe_zip_high_rate(app_context: None) -> None:
"""
Test if ZIP files is not highly compressed
"""
ZipFile = MagicMock() # noqa: N806
ZipFile.infolist.return_value = [
MockZipInfo(file_size=1000, compress_size=1),
MockZipInfo(file_size=1000, compress_size=1),
MockZipInfo(file_size=1000, compress_size=1),
MockZipInfo(file_size=1000, compress_size=1),
MockZipInfo(file_size=1000, compress_size=1),
]
with pytest.raises(SupersetException):
check_is_safe_zip(ZipFile)
def test_check_if_safe_zip_hidden_bomb(app_context: None) -> None:
"""
Test if ZIP file does not contain a big file highly compressed
"""
ZipFile = MagicMock() # noqa: N806
ZipFile.infolist.return_value = [
MockZipInfo(file_size=1000, compress_size=100),
MockZipInfo(file_size=1000, compress_size=100),
MockZipInfo(file_size=1000, compress_size=100),
MockZipInfo(file_size=1000, compress_size=100),
MockZipInfo(file_size=1000 * (1024 * 1024), compress_size=100),
]
with pytest.raises(SupersetException):
check_is_safe_zip(ZipFile)
def test_generic_constraint_name_exists():
# Create a mock SQLAlchemy database object
database_mock = MagicMock()
# Define the table name and constraint details
table_name = "my_table"
columns = {"column1", "column2"}
referenced_table_name = "other_table"
constraint_name = "my_constraint"
# Create a mock table object with the same structure
table_mock = MagicMock()
table_mock.name = table_name
table_mock.columns = [MagicMock(name=col) for col in columns]
# Create a mock for the referred_table with a name attribute
referred_table_mock = MagicMock()
referred_table_mock.name = referenced_table_name
# Create a mock for the foreign key constraint with a name attribute
foreign_key_constraint_mock = MagicMock()
foreign_key_constraint_mock.name = constraint_name
foreign_key_constraint_mock.referred_table = referred_table_mock
foreign_key_constraint_mock.column_keys = list(columns)
# Set the foreign key constraint mock as part of the table's constraints
table_mock.foreign_key_constraints = [foreign_key_constraint_mock]
# Configure the autoload behavior for the database mock
database_mock.metadata = MagicMock()
database_mock.metadata.tables = {table_name: table_mock}
# Mock the sa.Table creation with autoload
with patch("superset.utils.core.sa.Table") as table_creation_mock:
table_creation_mock.return_value = table_mock
result = generic_find_constraint_name(
table_name, columns, referenced_table_name, database_mock
)
assert result == constraint_name
def test_generic_constraint_name_not_found():
# Create a mock SQLAlchemy database object
database_mock = MagicMock()
# Define the table name and constraint details
table_name = "my_table"
columns = {"column1", "column2"}
referenced_table_name = "other_table"
# Create a mock table object with the same structure but no matching constraint
table_mock = MagicMock()
table_mock.name = table_name
table_mock.columns = [MagicMock(name=col) for col in columns]
table_mock.foreign_key_constraints = []
# Configure the autoload behavior for the database mock
database_mock.metadata = MagicMock()
database_mock.metadata.tables = {table_name: table_mock}
result = generic_find_constraint_name(
table_name, columns, referenced_table_name, database_mock
)
assert result is None
def test_generic_find_fk_constraint_exists():
insp_mock = MagicMock()
table_name = "my_table"
columns = {"column1", "column2"}
referenced_table_name = "other_table"
constraint_name = "my_constraint"
# Create a mock for the foreign key constraint as a dictionary
constraint_mock = {
"name": constraint_name,
"referred_table": referenced_table_name,
"referred_columns": list(columns),
}
# Configure the Inspector mock to return the list of foreign key constraints
insp_mock.get_foreign_keys.return_value = [constraint_mock]
result = generic_find_fk_constraint_name(
table_name, columns, referenced_table_name, insp_mock
)
assert result == constraint_name
def test_generic_find_fk_constraint_none_exist():
insp_mock = MagicMock()
table_name = "my_table"
columns = {"column1", "column2"}
referenced_table_name = "other_table"
# Configure the Inspector mock to return the list of foreign key constraints
insp_mock.get_foreign_keys.return_value = []
result = generic_find_fk_constraint_name(
table_name, columns, referenced_table_name, insp_mock
)
assert result is None
def test_get_datasource_full_name():
"""
Test the `get_datasource_full_name` function.
This is used to build permissions, so it doesn't really return the datasource full
name. Instead, it returns a fully qualified table name that includes the database
name and schema, with each part wrapped in square brackets.
"""
assert (
get_datasource_full_name("db", "table", "catalog", "schema")
== "[db].[catalog].[schema].[table]"
)
assert get_datasource_full_name("db", "table", None, None) == "[db].[table]"
assert (
get_datasource_full_name("db", "table", None, "schema")
== "[db].[schema].[table]"
)
assert (
get_datasource_full_name("db", "table", "catalog", None)
== "[db].[catalog].[table]"
)
@pytest.mark.parametrize(
"referrer,expected",
[
(None, None),
("https://mysuperset.com/abc", None),
("https://mysuperset.com/superset/dashboard/", QuerySource.DASHBOARD),
("https://mysuperset.com/explore/", QuerySource.CHART),
("https://mysuperset.com/sqllab/", QuerySource.SQL_LAB),
],
)
def test_get_query_source_from_request(
referrer: str | None,
expected: QuerySource | None,
mocker: MockerFixture,
app_context: None,
) -> None:
if referrer:
# Use has_request_context to mock request when not in a request context
with mocker.patch("flask.has_request_context", return_value=True):
request_mock = mocker.MagicMock()
request_mock.referrer = referrer
mocker.patch("superset.utils.core.request", request_mock)
assert get_query_source_from_request() == expected
else:
# When no referrer, test without request context
with mocker.patch("flask.has_request_context", return_value=False):
assert get_query_source_from_request() == expected
@with_config({"USER_AGENT_FUNC": None})
def test_get_user_agent(mocker: MockerFixture, app_context: None) -> None:
database_mock = mocker.MagicMock()
database_mock.database_name = "mydb"
assert get_user_agent(database_mock, QuerySource.DASHBOARD) == "Apache Superset", (
"The default user agent should be returned"
)
@with_config(
{
"USER_AGENT_FUNC": lambda database,
source: f"{database.database_name} {source.name}"
}
)
def test_get_user_agent_custom(mocker: MockerFixture, app_context: None) -> None:
database_mock = mocker.MagicMock()
database_mock.database_name = "mydb"
assert get_user_agent(database_mock, QuerySource.DASHBOARD) == "mydb DASHBOARD", (
"the custom user agent function result should have been returned"
)
def test_merge_extra_filters():
# does nothing if no extra filters
form_data = {"A": 1, "B": 2, "c": "test"}
expected = {**form_data, "adhoc_filters": [], "applied_time_extras": {}}
merge_extra_filters(form_data)
assert form_data == expected
# empty extra_filters
form_data = {"A": 1, "B": 2, "c": "test", "extra_filters": []}
expected = {
"A": 1,
"B": 2,
"c": "test",
"adhoc_filters": [],
"applied_time_extras": {},
}
merge_extra_filters(form_data)
assert form_data == expected
# copy over extra filters into empty filters
form_data = {
"extra_filters": [
{"col": "a", "op": "in", "val": "someval"},
{"col": "B", "op": "==", "val": ["c1", "c2"]},
]
}
expected = {
"adhoc_filters": [
{
"clause": "WHERE",
"comparator": "someval",
"expressionType": "SIMPLE",
"filterOptionName": (
"eb77ff8188437d8722af8c932727da1e83ec37e88aaf800a3859ed352d87119f"
),
"isExtra": True,
"operator": "in",
"subject": "a",
},
{
"clause": "WHERE",
"comparator": ["c1", "c2"],
"expressionType": "SIMPLE",
"filterOptionName": (
"48dd60c7ecb8699b51e36ce956ba481aa5382548811aecec71af7e550c59762c"
),
"isExtra": True,
"operator": "==",
"subject": "B",
},
],
"applied_time_extras": {},
}
merge_extra_filters(form_data)
assert form_data == expected
# adds extra filters to existing filters
form_data = {
"extra_filters": [
{"col": "a", "op": "in", "val": "someval"},
{"col": "B", "op": "==", "val": ["c1", "c2"]},
],
"adhoc_filters": [
{
"clause": "WHERE",
"comparator": ["G1", "g2"],
"expressionType": "SIMPLE",
"operator": "!=",
"subject": "D",
}
],
}
expected = {
"adhoc_filters": [
{
"clause": "WHERE",
"comparator": ["G1", "g2"],
"expressionType": "SIMPLE",
"operator": "!=",
"subject": "D",
},
{
"clause": "WHERE",
"comparator": "someval",
"expressionType": "SIMPLE",
"filterOptionName": (
"eb77ff8188437d8722af8c932727da1e83ec37e88aaf800a3859ed352d87119f"
),
"isExtra": True,
"operator": "in",
"subject": "a",
},
{
"clause": "WHERE",
"comparator": ["c1", "c2"],
"expressionType": "SIMPLE",
"filterOptionName": (
"48dd60c7ecb8699b51e36ce956ba481aa5382548811aecec71af7e550c59762c"
),
"isExtra": True,
"operator": "==",
"subject": "B",
},
],
"applied_time_extras": {},
}
merge_extra_filters(form_data)
assert form_data == expected
# adds extra filters to existing filters and sets time options
form_data = {
"extra_filters": [
{"col": "__time_range", "op": "in", "val": "1 year ago :"},
{"col": "__time_col", "op": "in", "val": "birth_year"},
{"col": "__time_grain", "op": "in", "val": "years"},
{"col": "A", "op": "like", "val": "hello"},
]
}
expected = {
"adhoc_filters": [
{
"clause": "WHERE",
"comparator": "hello",
"expressionType": "SIMPLE",
"filterOptionName": (
"2ca91524f5ab8e39d6aa5373d1f11301ad2c5b95f5aa77eb30d92f572f5b9157"
),
"isExtra": True,
"operator": "like",
"subject": "A",
}
],
"time_range": "1 year ago :",
"granularity_sqla": "birth_year",
"time_grain_sqla": "years",
"applied_time_extras": {
"__time_range": "1 year ago :",
"__time_col": "birth_year",
"__time_grain": "years",
},
}
merge_extra_filters(form_data)
assert form_data == expected
def test_merge_extra_filters_ignores_empty_filters():
form_data = {
"extra_filters": [
{"col": "a", "op": "in", "val": ""},
{"col": "B", "op": "==", "val": []},
]
}
expected = {"adhoc_filters": [], "applied_time_extras": {}}
merge_extra_filters(form_data)
assert form_data == expected
def test_merge_extra_filters_ignores_nones():
form_data = {
"adhoc_filters": [
{
"clause": "WHERE",
"comparator": "",
"expressionType": "SIMPLE",
"operator": "in",
"subject": None,
}
],
"extra_filters": [{"col": "B", "op": "==", "val": []}],
}
expected = {
"adhoc_filters": [
{
"clause": "WHERE",
"comparator": "",
"expressionType": "SIMPLE",
"operator": "in",
"subject": None,
}
],
"applied_time_extras": {},
}
merge_extra_filters(form_data)
assert form_data == expected
def test_merge_extra_filters_ignores_equal_filters():
form_data = {
"extra_filters": [
{"col": "a", "op": "in", "val": "someval"},
{"col": "B", "op": "==", "val": ["c1", "c2"]},
{"col": "c", "op": "in", "val": ["c1", 1, None]},
],
"adhoc_filters": [
{
"clause": "WHERE",
"comparator": "someval",
"expressionType": "SIMPLE",
"operator": "in",
"subject": "a",
},
{
"clause": "WHERE",
"comparator": ["c1", "c2"],
"expressionType": "SIMPLE",
"operator": "==",
"subject": "B",
},
{
"clause": "WHERE",
"comparator": ["c1", 1, None],
"expressionType": "SIMPLE",
"operator": "in",
"subject": "c",
},
],
}
expected = {
"adhoc_filters": [
{
"clause": "WHERE",
"comparator": "someval",
"expressionType": "SIMPLE",
"operator": "in",
"subject": "a",
},
{
"clause": "WHERE",
"comparator": ["c1", "c2"],
"expressionType": "SIMPLE",
"operator": "==",
"subject": "B",
},
{
"clause": "WHERE",
"comparator": ["c1", 1, None],
"expressionType": "SIMPLE",
"operator": "in",
"subject": "c",
},
],
"applied_time_extras": {},
}
merge_extra_filters(form_data)
assert form_data == expected
def test_merge_extra_filters_merges_different_val_types():
form_data = {
"extra_filters": [
{"col": "a", "op": "in", "val": ["g1", "g2"]},
{"col": "B", "op": "==", "val": ["c1", "c2"]},
],
"adhoc_filters": [
{
"clause": "WHERE",
"comparator": "someval",
"expressionType": "SIMPLE",
"operator": "in",
"subject": "a",
},
{
"clause": "WHERE",
"comparator": ["c1", "c2"],
"expressionType": "SIMPLE",
"operator": "==",
"subject": "B",
},
],
}
expected = {
"adhoc_filters": [
{
"clause": "WHERE",
"comparator": "someval",
"expressionType": "SIMPLE",
"operator": "in",
"subject": "a",
},
{
"clause": "WHERE",
"comparator": ["c1", "c2"],
"expressionType": "SIMPLE",
"operator": "==",
"subject": "B",
},
{
"clause": "WHERE",
"comparator": ["g1", "g2"],
"expressionType": "SIMPLE",
"filterOptionName": (
"e2f7d6304169124258364916403b2d9208fce39dd7771797726111b7498bbd52"
),
"isExtra": True,
"operator": "in",
"subject": "a",
},
],
"applied_time_extras": {},
}
merge_extra_filters(form_data)
assert form_data == expected
form_data = {
"extra_filters": [
{"col": "a", "op": "in", "val": "someval"},
{"col": "B", "op": "==", "val": ["c1", "c2"]},
],
"adhoc_filters": [
{
"clause": "WHERE",
"comparator": ["g1", "g2"],
"expressionType": "SIMPLE",
"operator": "in",
"subject": "a",
},
{
"clause": "WHERE",
"comparator": ["c1", "c2"],
"expressionType": "SIMPLE",
"operator": "==",
"subject": "B",
},
],
}
expected = {
"adhoc_filters": [
{
"clause": "WHERE",
"comparator": ["g1", "g2"],
"expressionType": "SIMPLE",
"operator": "in",
"subject": "a",
},
{
"clause": "WHERE",
"comparator": ["c1", "c2"],
"expressionType": "SIMPLE",
"operator": "==",
"subject": "B",
},
{
"clause": "WHERE",
"comparator": "someval",
"expressionType": "SIMPLE",
"filterOptionName": (
"eb77ff8188437d8722af8c932727da1e83ec37e88aaf800a3859ed352d87119f"
),
"isExtra": True,
"operator": "in",
"subject": "a",
},
],
"applied_time_extras": {},
}
merge_extra_filters(form_data)
assert form_data == expected
def test_merge_extra_filters_adds_unequal_lists():
form_data = {
"extra_filters": [
{"col": "a", "op": "in", "val": ["g1", "g2", "g3"]},
{"col": "B", "op": "==", "val": ["c1", "c2", "c3"]},
],
"adhoc_filters": [
{
"clause": "WHERE",
"comparator": ["g1", "g2"],
"expressionType": "SIMPLE",
"operator": "in",
"subject": "a",
},
{
"clause": "WHERE",
"comparator": ["c1", "c2"],
"expressionType": "SIMPLE",
"operator": "==",
"subject": "B",
},
],
}
expected = {
"adhoc_filters": [
{
"clause": "WHERE",
"comparator": ["g1", "g2"],
"expressionType": "SIMPLE",
"operator": "in",
"subject": "a",
},
{
"clause": "WHERE",
"comparator": ["c1", "c2"],
"expressionType": "SIMPLE",
"operator": "==",
"subject": "B",
},
{
"clause": "WHERE",
"comparator": ["g1", "g2", "g3"],
"expressionType": "SIMPLE",
"filterOptionName": (
"b3f17391546e130560efd1e841742bc5f154d09a7d534b8c0ec33fc1c8a146cd"
),
"isExtra": True,
"operator": "in",
"subject": "a",
},
{
"clause": "WHERE",
"comparator": ["c1", "c2", "c3"],
"expressionType": "SIMPLE",
"filterOptionName": (
"41ef70f6edada46006253189b27778088da2cf27ccc69f703634493d7396708a"
),
"isExtra": True,
"operator": "==",
"subject": "B",
},
],
"applied_time_extras": {},
}
merge_extra_filters(form_data)
assert form_data == expected
def test_merge_extra_filters_when_applied_time_extras_predefined():
form_data = {"applied_time_extras": {"__time_range": "Last week"}}
merge_extra_filters(form_data)
assert form_data == {
"applied_time_extras": {"__time_range": "Last week"},
"adhoc_filters": [],
}
def test_merge_extra_form_data_updates_temporal_range_subject():
"""
Test that when extra_form_data contains granularity_sqla, it should update
the subject of any TEMPORAL_RANGE adhoc filter to use the new time column.
"""
form_data = {
"adhoc_filters": [
{
"clause": "WHERE",
"comparator": "No filter",
"expressionType": "SIMPLE",
"operator": "TEMPORAL_RANGE",
"subject": "created_at",
}
],
"extra_form_data": {
"granularity_sqla": "event_date",
"time_range": "Last week",
},
}
merge_extra_form_data(form_data)
assert form_data["adhoc_filters"][0]["subject"] == "event_date"
assert form_data["time_range"] == "Last week"
assert form_data["granularity"] == "event_date"
assert "extra_form_data" not in form_data
def test_time_column_filter_with_multiple_temporal_range_filters():
"""
Test that Time Column native filter updates ALL TEMPORAL_RANGE filters
in the adhoc_filters list, but leaves non-TEMPORAL_RANGE filters unchanged.
"""
form_data = {
"adhoc_filters": [
{
"clause": "WHERE",
"comparator": "Last week",
"expressionType": "SIMPLE",
"operator": "TEMPORAL_RANGE",
"subject": "default_time_col",
},
{
"clause": "WHERE",
"comparator": "foo",
"expressionType": "SIMPLE",
"operator": "==",
"subject": "some_column",
},
{
"clause": "WHERE",
"comparator": "Last month",
"expressionType": "SIMPLE",
"operator": "TEMPORAL_RANGE",
"subject": "another_time_col",
},
],
"extra_form_data": {
"granularity_sqla": "selected_time_col",
},
}
merge_extra_form_data(form_data)
assert form_data["adhoc_filters"][0]["subject"] == "selected_time_col"
assert form_data["adhoc_filters"][2]["subject"] == "selected_time_col"
assert form_data["adhoc_filters"][1]["subject"] == "some_column"
assert "extra_form_data" not in form_data
def test_merge_extra_form_data_skips_sql_expression_filters():
"""
Test that SQL expression type filters are not modified when granularity_sqla
is provided. Only SIMPLE expression type filters should have their subject updated.
"""
form_data = {
"adhoc_filters": [
{
"clause": "WHERE",
"expressionType": "SQL",
"operator": "TEMPORAL_RANGE",
"sqlExpression": "created_at > '2020-01-01'",
},
{
"clause": "WHERE",
"comparator": "Last week",
"expressionType": "SIMPLE",
"operator": "TEMPORAL_RANGE",
"subject": "created_at",
},
],
"extra_form_data": {
"granularity_sqla": "event_date",
},
}
merge_extra_form_data(form_data)
assert "subject" not in form_data["adhoc_filters"][0]
assert form_data["adhoc_filters"][1]["subject"] == "event_date"
assert "extra_form_data" not in form_data
def test_merge_extra_form_data_time_range_without_granularity_sqla():
"""
Test that when form_data has time_range but no granularity_sqla,
the TEMPORAL_RANGE filter comparator is updated to match time_range.
"""
form_data = {
"time_range": "Last month",
"adhoc_filters": [
{
"clause": "WHERE",
"comparator": "No filter",
"expressionType": "SIMPLE",
"operator": "TEMPORAL_RANGE",
"subject": "created_at",
}
],
"extra_form_data": {},
}
merge_extra_form_data(form_data)
assert form_data["adhoc_filters"][0]["comparator"] == "Last month"
assert form_data["adhoc_filters"][0]["subject"] == "created_at"
assert "extra_form_data" not in form_data
def test_merge_extra_form_data_no_subject_update_when_granularity_override_none():
"""
Test that when granularity_sqla_override is None, the TEMPORAL_RANGE filter
subject should NOT be updated, even if expressionType is SIMPLE.
"""
original_subject = "original_time_col"
form_data = {
"adhoc_filters": [
{
"clause": "WHERE",
"comparator": "Last week",
"expressionType": "SIMPLE",
"operator": "TEMPORAL_RANGE",
"subject": original_subject,
}
],
"extra_form_data": {},
}
merge_extra_form_data(form_data)
assert form_data["adhoc_filters"][0]["subject"] == original_subject
assert "extra_form_data" not in form_data
def test_merge_extra_form_data_does_not_update_comparator_when_time_range_is_falsy():
"""
Test that when time_range is falsy (None, empty string, or False),
the TEMPORAL_RANGE filter comparator should NOT be updated.
"""
original_comparator = "Original time range"
form_data = {
"time_range": None,
"adhoc_filters": [
{
"clause": "WHERE",
"comparator": original_comparator,
"expressionType": "SIMPLE",
"operator": "TEMPORAL_RANGE",
"subject": "created_at",
}
],
"extra_form_data": {},
}
merge_extra_form_data(form_data)
assert form_data["adhoc_filters"][0]["comparator"] == original_comparator
assert "extra_form_data" not in form_data
def test_merge_extra_form_data_no_comparator_update_when_time_range_empty():
"""
Test that when time_range is an empty string (falsy), the TEMPORAL_RANGE
filter comparator should NOT be updated.
"""
original_comparator = "Original time range"
form_data = {
"time_range": "",
"adhoc_filters": [
{
"clause": "WHERE",
"comparator": original_comparator,
"expressionType": "SIMPLE",
"operator": "TEMPORAL_RANGE",
"subject": "created_at",
}
],
"extra_form_data": {},
}
merge_extra_form_data(form_data)
assert form_data["adhoc_filters"][0]["comparator"] == original_comparator
assert "extra_form_data" not in form_data
def test_merge_extra_form_data_does_not_update_comparator_when_has_granularity_sqla():
"""
Test that when form_data has granularity_sqla (truthy), the TEMPORAL_RANGE
filter comparator should NOT be updated, even if time_range exists.
When granularity_sqla is present in form_data, it indicates a legacy chart
where granularity_sqla and time_range are separate form_data attributes.
"""
original_comparator = "Original time range"
form_data = {
"time_range": "Last month",
"granularity_sqla": "event_date",
"adhoc_filters": [
{
"clause": "WHERE",
"comparator": original_comparator,
"expressionType": "SIMPLE",
"operator": "TEMPORAL_RANGE",
"subject": "created_at",
}
],
"extra_form_data": {},
}
merge_extra_form_data(form_data)
assert form_data["adhoc_filters"][0]["comparator"] == original_comparator
assert "extra_form_data" not in form_data
def test_merge_extra_form_data_removes_extra_form_data():
"""
Test that merge_extra_form_data removes extra_form_data from form_data
after processing (it calls form_data.pop("extra_form_data", {})).
"""
form_data = {
"adhoc_filters": [],
"extra_form_data": {
"granularity_sqla": "event_date",
"time_range": "Last week",
},
}
merge_extra_form_data(form_data)
assert "extra_form_data" not in form_data
assert form_data["granularity"] == "event_date"
assert form_data["time_range"] == "Last week"
def test_merge_extra_form_data_creates_temporal_filter_when_none_exists():
"""
Test that when granularity_sqla_override and time_range are provided
but no TEMPORAL_RANGE filter exists, a new temporal filter is created.
"""
form_data = {
"time_range": "2022-01-22 : 2025-01-22",
"adhoc_filters": [
{
"clause": "WHERE",
"comparator": "foo",
"expressionType": "SIMPLE",
"operator": "==",
"subject": "some_column",
}
],
"extra_form_data": {
"granularity_sqla": "updated_at",
},
}
merge_extra_form_data(form_data)
temporal_filters = [
f
for f in form_data["adhoc_filters"]
if f.get("operator") == FilterOperator.TEMPORAL_RANGE
]
assert len(temporal_filters) == 1
assert temporal_filters[0]["subject"] == "updated_at"
assert temporal_filters[0]["comparator"] == "2022-01-22 : 2025-01-22"
assert temporal_filters[0]["expressionType"] == "SIMPLE"
assert temporal_filters[0]["clause"] == "WHERE"
assert temporal_filters[0]["isExtra"] is True
assert "filterOptionName" in temporal_filters[0]
assert "extra_form_data" not in form_data
def test_merge_extra_form_data_creates_temporal_filter_with_empty_adhoc_filters():
"""
Test that a temporal filter is created when adhoc_filters is empty
and granularity_sqla_override and time_range are provided.
"""
form_data = {
"time_range": "Last month",
"adhoc_filters": [],
"extra_form_data": {
"granularity_sqla": "created_at",
},
}
merge_extra_form_data(form_data)
assert len(form_data["adhoc_filters"]) == 1
assert form_data["adhoc_filters"][0]["operator"] == FilterOperator.TEMPORAL_RANGE
assert form_data["adhoc_filters"][0]["subject"] == "created_at"
assert form_data["adhoc_filters"][0]["comparator"] == "Last month"
assert "extra_form_data" not in form_data
def test_merge_extra_form_data_creates_temporal_filter_with_missing_adhoc_filters():
"""
Test that a temporal filter is created when adhoc_filters key doesn't exist
and granularity_sqla_override and time_range are provided.
"""
form_data = {
"time_range": "2024-01-01 : 2024-03-01",
"extra_form_data": {
"granularity_sqla": "event_date",
},
}
merge_extra_form_data(form_data)
assert "adhoc_filters" in form_data
assert len(form_data["adhoc_filters"]) == 1
assert form_data["adhoc_filters"][0]["operator"] == FilterOperator.TEMPORAL_RANGE
assert form_data["adhoc_filters"][0]["subject"] == "event_date"
assert form_data["adhoc_filters"][0]["comparator"] == "2024-01-01 : 2024-03-01"
assert "extra_form_data" not in form_data
def test_merge_extra_form_data_does_not_create_filter_when_granularity_missing():
"""
Test that no temporal filter is created when granularity_sqla_override
is missing, even if time_range is provided.
"""
form_data = {
"time_range": "Last week",
"adhoc_filters": [],
"extra_form_data": {},
}
original_filters_count = len(form_data["adhoc_filters"])
merge_extra_form_data(form_data)
assert len(form_data["adhoc_filters"]) == original_filters_count
assert "extra_form_data" not in form_data
def test_merge_extra_form_data_does_not_create_filter_when_time_range_missing():
"""
Test that no temporal filter is created when time_range is missing,
even if granularity_sqla_override is provided.
"""
form_data = {
"adhoc_filters": [],
"extra_form_data": {
"granularity_sqla": "updated_at",
},
}
original_filters_count = len(form_data["adhoc_filters"])
merge_extra_form_data(form_data)
assert len(form_data["adhoc_filters"]) == original_filters_count
assert "extra_form_data" not in form_data
def test_merge_extra_form_data_does_not_create_filter_when_time_range_none():
"""
Test that no temporal filter is created when time_range is None,
even if granularity_sqla_override is provided.
"""
form_data = {
"time_range": None,
"adhoc_filters": [],
"extra_form_data": {
"granularity_sqla": "created_at",
},
}
original_filters_count = len(form_data["adhoc_filters"])
merge_extra_form_data(form_data)
assert len(form_data["adhoc_filters"]) == original_filters_count
assert "extra_form_data" not in form_data
def test_merge_extra_form_data_does_not_create_filter_when_granularity_none():
"""
Test that no temporal filter is created when granularity_sqla_override
is None, even if time_range is provided.
"""
form_data = {
"time_range": "Last month",
"adhoc_filters": [],
"extra_form_data": {
"granularity_sqla": None,
},
}
original_filters_count = len(form_data["adhoc_filters"])
merge_extra_form_data(form_data)
assert len(form_data["adhoc_filters"]) == original_filters_count
assert "extra_form_data" not in form_data
def test_merge_extra_form_data_creates_filter_with_different_temporal_columns():
"""
Test creating temporal filters for different temporal columns
(event_date, created_at, updated_at) to ensure the fix works
across multiple column types.
"""
temporal_columns = ["event_date", "created_at", "updated_at"]
time_range = "2022-01-22 : 2025-01-22"
for column in temporal_columns:
form_data = {
"time_range": time_range,
"adhoc_filters": [],
"extra_form_data": {
"granularity_sqla": column,
},
}
merge_extra_form_data(form_data)
assert len(form_data["adhoc_filters"]) == 1
assert form_data["adhoc_filters"][0]["subject"] == column
assert form_data["adhoc_filters"][0]["comparator"] == time_range
assert (
form_data["adhoc_filters"][0]["operator"] == FilterOperator.TEMPORAL_RANGE
)
def test_merge_extra_form_data_does_not_create_duplicate_when_filter_exists():
"""
Test that when a TEMPORAL_RANGE filter already exists, a new one
is NOT created. Instead, the existing filter is updated.
"""
form_data = {
"time_range": "Last week",
"adhoc_filters": [
{
"clause": "WHERE",
"comparator": "No filter",
"expressionType": "SIMPLE",
"operator": FilterOperator.TEMPORAL_RANGE,
"subject": "original_column",
}
],
"extra_form_data": {
"granularity_sqla": "new_column",
},
}
merge_extra_form_data(form_data)
temporal_filters = [
f
for f in form_data["adhoc_filters"]
if f.get("operator") == FilterOperator.TEMPORAL_RANGE
]
assert len(temporal_filters) == 1
assert temporal_filters[0]["subject"] == "new_column"
assert temporal_filters[0]["comparator"] == "Last week"
assert "extra_form_data" not in form_data
def test_merge_extra_form_data_date_format_with_timestamp_column():
"""
Test that date format time_range (YYYY-MM-DD) works correctly
when applied to a timestamp column.
"""
form_data = {
"time_range": "2022-01-22 : 2025-01-22",
"adhoc_filters": [],
"extra_form_data": {
"granularity_sqla": "created_at",
},
}
merge_extra_form_data(form_data)
assert len(form_data["adhoc_filters"]) == 1
temporal_filter = form_data["adhoc_filters"][0]
assert temporal_filter["operator"] == FilterOperator.TEMPORAL_RANGE
assert temporal_filter["subject"] == "created_at"
assert temporal_filter["comparator"] == "2022-01-22 : 2025-01-22"
assert temporal_filter["expressionType"] == "SIMPLE"
assert "extra_form_data" not in form_data
def test_merge_extra_form_data_timestamp_format_with_date_column():
"""
Test that timestamp format time_range (YYYY-MM-DDTHH:MM:SS) works correctly
when applied to a date column.
"""
form_data = {
"time_range": "2022-01-22T00:00:00 : 2025-01-22T23:59:59",
"adhoc_filters": [],
"extra_form_data": {
"granularity_sqla": "event_date",
},
}
merge_extra_form_data(form_data)
assert len(form_data["adhoc_filters"]) == 1
temporal_filter = form_data["adhoc_filters"][0]
assert temporal_filter["operator"] == FilterOperator.TEMPORAL_RANGE
assert temporal_filter["subject"] == "event_date"
assert temporal_filter["comparator"] == "2022-01-22T00:00:00 : 2025-01-22T23:59:59"
assert temporal_filter["expressionType"] == "SIMPLE"
assert "extra_form_data" not in form_data
def test_merge_request_params_when_url_params_undefined():
form_data = {"since": "2000", "until": "now"}
url_params = {"form_data": form_data, "dashboard_ids": "(1,2,3,4,5)"}
merge_request_params(form_data, url_params)
assert "url_params" in form_data.keys()
assert "dashboard_ids" in form_data["url_params"]
assert "form_data" not in form_data.keys()
def test_merge_request_params_when_url_params_predefined():
form_data = {
"since": "2000",
"until": "now",
"url_params": {"abc": "123", "dashboard_ids": "(1,2,3)"},
}
url_params = {"form_data": form_data, "dashboard_ids": "(1,2,3,4,5)"}
merge_request_params(form_data, url_params)
assert "url_params" in form_data.keys()
assert "abc" in form_data["url_params"]
assert url_params["dashboard_ids"] == form_data["url_params"]["dashboard_ids"]
def test_parse_js_uri_path_items_eval_undefined():
assert parse_js_uri_path_item("undefined", eval_undefined=True) is None
assert parse_js_uri_path_item("null", eval_undefined=True) is None
assert "undefined" == parse_js_uri_path_item("undefined")
assert "null" == parse_js_uri_path_item("null")
def test_parse_js_uri_path_items_unquote():
assert "slashed/name" == parse_js_uri_path_item("slashed%2fname")
assert "slashed%2fname" == parse_js_uri_path_item("slashed%2fname", unquote=False)
def test_parse_js_uri_path_items_item_optional():
assert parse_js_uri_path_item(None) is None
assert parse_js_uri_path_item("item") is not None
def test_get_stacktrace():
current_app.config["SHOW_STACKTRACE"] = True
try:
raise Exception("NONONO!")
except Exception:
stacktrace = get_stacktrace()
assert "NONONO" in stacktrace
current_app.config["SHOW_STACKTRACE"] = False
try:
raise Exception("NONONO!")
except Exception:
stacktrace = get_stacktrace()
assert stacktrace is None
def test_sanitize_svg_content_safe():
"""Test that safe SVG content is preserved."""
safe_svg = '<svg><rect width="10" height="10"/></svg>'
result = sanitize_svg_content(safe_svg)
assert "svg" in result
assert "rect" in result
def test_sanitize_svg_content_removes_scripts():
"""Test that nh3 removes dangerous script content."""
malicious_svg = '<svg><script>alert("xss")</script><rect/></svg>'
result = sanitize_svg_content(malicious_svg)
assert "script" not in result.lower()
assert "alert" not in result
def test_sanitize_url_relative():
"""Test that relative URLs are allowed."""
assert sanitize_url("/static/spinner.gif") == "/static/spinner.gif"
def test_sanitize_url_safe_absolute():
"""Test that safe absolute URLs are allowed."""
assert (
sanitize_url("https://example.com/spinner.gif")
== "https://example.com/spinner.gif"
)
assert (
sanitize_url("http://localhost/spinner.png") == "http://localhost/spinner.png"
)
def test_sanitize_url_blocks_dangerous():
"""Test that dangerous URL schemes are blocked."""
assert sanitize_url("javascript:alert('xss')") == ""
assert sanitize_url("data:text/html,<script>alert(1)</script>") == ""
Reference in New Issue View Git Blame Copy Permalink