123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953 |
- # 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.
- # isort:skip_file
- import unittest
- import uuid
- from datetime import date, datetime, time, timedelta
- from decimal import Decimal
- from unittest.mock import Mock, patch
- import numpy
- from flask import Flask
- from flask_caching import Cache
- from sqlalchemy.exc import ArgumentError
- import tests.test_app
- from superset import app, db, security_manager
- from superset.exceptions import SupersetException
- from superset.models.core import Database
- from superset.utils.cache_manager import CacheManager
- from superset.utils.core import (
- base_json_conv,
- convert_legacy_filters_into_adhoc,
- datetime_f,
- format_timedelta,
- get_or_create_db,
- get_since_until,
- get_stacktrace,
- json_int_dttm_ser,
- json_iso_dttm_ser,
- JSONEncodedDict,
- memoized,
- merge_extra_filters,
- merge_request_params,
- parse_human_timedelta,
- parse_js_uri_path_item,
- parse_past_timedelta,
- split,
- TimeRangeEndpoint,
- validate_json,
- zlib_compress,
- zlib_decompress,
- )
- from superset.views.utils import get_time_range_endpoints
- from tests.base_tests import SupersetTestCase
- def mock_parse_human_datetime(s):
- if s == "now":
- return datetime(2016, 11, 7, 9, 30, 10)
- elif s == "today":
- return datetime(2016, 11, 7)
- elif s == "yesterday":
- return datetime(2016, 11, 6)
- elif s == "tomorrow":
- return datetime(2016, 11, 8)
- elif s == "Last year":
- return datetime(2015, 11, 7)
- elif s == "Last week":
- return datetime(2015, 10, 31)
- elif s == "Last 5 months":
- return datetime(2016, 6, 7)
- elif s == "Next 5 months":
- return datetime(2017, 4, 7)
- elif s in ["5 days", "5 days ago"]:
- return datetime(2016, 11, 2)
- elif s == "2018-01-01T00:00:00":
- return datetime(2018, 1, 1)
- elif s == "2018-12-31T23:59:59":
- return datetime(2018, 12, 31, 23, 59, 59)
- def mock_to_adhoc(filt, expressionType="SIMPLE", clause="where"):
- result = {"clause": clause.upper(), "expressionType": expressionType}
- if expressionType == "SIMPLE":
- result.update(
- {"comparator": filt["val"], "operator": filt["op"], "subject": filt["col"]}
- )
- elif expressionType == "SQL":
- result.update({"sqlExpression": filt[clause]})
- return result
- class UtilsTestCase(SupersetTestCase):
- def test_json_int_dttm_ser(self):
- dttm = datetime(2020, 1, 1)
- ts = 1577836800000.0
- assert json_int_dttm_ser(dttm) == ts
- assert json_int_dttm_ser(date(2020, 1, 1)) == ts
- assert json_int_dttm_ser(datetime(1970, 1, 1)) == 0
- assert json_int_dttm_ser(date(1970, 1, 1)) == 0
- assert json_int_dttm_ser(dttm + timedelta(milliseconds=1)) == (ts + 1)
- with self.assertRaises(TypeError):
- json_int_dttm_ser("this is not a date")
- def test_json_iso_dttm_ser(self):
- dttm = datetime(2020, 1, 1)
- dt = date(2020, 1, 1)
- t = time()
- assert json_iso_dttm_ser(dttm) == dttm.isoformat()
- assert json_iso_dttm_ser(dt) == dt.isoformat()
- assert json_iso_dttm_ser(t) == t.isoformat()
- with self.assertRaises(TypeError):
- json_iso_dttm_ser("this is not a date")
- def test_base_json_conv(self):
- assert isinstance(base_json_conv(numpy.bool_(1)), bool) is True
- assert isinstance(base_json_conv(numpy.int64(1)), int) is True
- assert isinstance(base_json_conv(numpy.array([1, 2, 3])), list) is True
- assert isinstance(base_json_conv(set([1])), list) is True
- assert isinstance(base_json_conv(Decimal("1.0")), float) is True
- assert isinstance(base_json_conv(uuid.uuid4()), str) is True
- assert isinstance(base_json_conv(timedelta(0)), str) is True
- @patch("superset.utils.core.datetime")
- def test_parse_human_timedelta(self, mock_datetime):
- mock_datetime.now.return_value = datetime(2019, 4, 1)
- mock_datetime.side_effect = lambda *args, **kw: datetime(*args, **kw)
- self.assertEqual(parse_human_timedelta("now"), timedelta(0))
- self.assertEqual(parse_human_timedelta("1 year"), timedelta(366))
- self.assertEqual(parse_human_timedelta("-1 year"), timedelta(-365))
- self.assertEqual(parse_human_timedelta(None), timedelta(0))
- @patch("superset.utils.core.datetime")
- def test_parse_past_timedelta(self, mock_datetime):
- mock_datetime.now.return_value = datetime(2019, 4, 1)
- mock_datetime.side_effect = lambda *args, **kw: datetime(*args, **kw)
- self.assertEqual(parse_past_timedelta("1 year"), timedelta(365))
- self.assertEqual(parse_past_timedelta("-1 year"), timedelta(365))
- self.assertEqual(parse_past_timedelta("52 weeks"), timedelta(364))
- self.assertEqual(parse_past_timedelta("1 month"), timedelta(31))
- def test_zlib_compression(self):
- json_str = '{"test": 1}'
- blob = zlib_compress(json_str)
- got_str = zlib_decompress(blob)
- self.assertEqual(json_str, got_str)
- @patch("superset.utils.core.to_adhoc", mock_to_adhoc)
- def test_merge_extra_filters(self):
- # does nothing if no extra filters
- form_data = {"A": 1, "B": 2, "c": "test"}
- expected = {"A": 1, "B": 2, "c": "test"}
- merge_extra_filters(form_data)
- self.assertEqual(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": []}
- merge_extra_filters(form_data)
- self.assertEqual(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",
- "operator": "in",
- "subject": "a",
- },
- {
- "clause": "WHERE",
- "comparator": ["c1", "c2"],
- "expressionType": "SIMPLE",
- "operator": "==",
- "subject": "B",
- },
- ]
- }
- merge_extra_filters(form_data)
- self.assertEqual(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",
- "operator": "in",
- "subject": "a",
- },
- {
- "clause": "WHERE",
- "comparator": ["c1", "c2"],
- "expressionType": "SIMPLE",
- "operator": "==",
- "subject": "B",
- },
- ]
- }
- merge_extra_filters(form_data)
- self.assertEqual(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"},
- {"col": "__time_origin", "op": "in", "val": "now"},
- {"col": "__granularity", "op": "in", "val": "90 seconds"},
- ]
- }
- expected = {
- "adhoc_filters": [
- {
- "clause": "WHERE",
- "comparator": "hello",
- "expressionType": "SIMPLE",
- "operator": "like",
- "subject": "A",
- }
- ],
- "time_range": "1 year ago :",
- "granularity_sqla": "birth_year",
- "time_grain_sqla": "years",
- "granularity": "90 seconds",
- "druid_time_origin": "now",
- }
- merge_extra_filters(form_data)
- self.assertEqual(form_data, expected)
- @patch("superset.utils.core.to_adhoc", mock_to_adhoc)
- def test_merge_extra_filters_ignores_empty_filters(self):
- form_data = {
- "extra_filters": [
- {"col": "a", "op": "in", "val": ""},
- {"col": "B", "op": "==", "val": []},
- ]
- }
- expected = {"adhoc_filters": []}
- merge_extra_filters(form_data)
- self.assertEqual(form_data, expected)
- @patch("superset.utils.core.to_adhoc", mock_to_adhoc)
- def test_merge_extra_filters_ignores_nones(self):
- 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,
- }
- ]
- }
- merge_extra_filters(form_data)
- self.assertEqual(form_data, expected)
- @patch("superset.utils.core.to_adhoc", mock_to_adhoc)
- def test_merge_extra_filters_ignores_equal_filters(self):
- 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",
- },
- ]
- }
- merge_extra_filters(form_data)
- self.assertEqual(form_data, expected)
- @patch("superset.utils.core.to_adhoc", mock_to_adhoc)
- def test_merge_extra_filters_merges_different_val_types(self):
- 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",
- "operator": "in",
- "subject": "a",
- },
- ]
- }
- merge_extra_filters(form_data)
- self.assertEqual(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",
- "operator": "in",
- "subject": "a",
- },
- ]
- }
- merge_extra_filters(form_data)
- self.assertEqual(form_data, expected)
- @patch("superset.utils.core.to_adhoc", mock_to_adhoc)
- def test_merge_extra_filters_adds_unequal_lists(self):
- 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",
- "operator": "in",
- "subject": "a",
- },
- {
- "clause": "WHERE",
- "comparator": ["c1", "c2", "c3"],
- "expressionType": "SIMPLE",
- "operator": "==",
- "subject": "B",
- },
- ]
- }
- merge_extra_filters(form_data)
- self.assertEqual(form_data, expected)
- def test_merge_request_params_when_url_params_undefined(self):
- 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)
- self.assertIn("url_params", form_data.keys())
- self.assertIn("dashboard_ids", form_data["url_params"])
- self.assertNotIn("form_data", form_data.keys())
- def test_merge_request_params_when_url_params_predefined(self):
- 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)
- self.assertIn("url_params", form_data.keys())
- self.assertIn("abc", form_data["url_params"])
- self.assertEquals(
- url_params["dashboard_ids"], form_data["url_params"]["dashboard_ids"]
- )
- def test_datetime_f(self):
- self.assertEqual(
- datetime_f(datetime(1990, 9, 21, 19, 11, 19, 626096)),
- "<nobr>1990-09-21T19:11:19.626096</nobr>",
- )
- self.assertEqual(len(datetime_f(datetime.now())), 28)
- self.assertEqual(datetime_f(None), "<nobr>None</nobr>")
- iso = datetime.now().isoformat()[:10].split("-")
- [a, b, c] = [int(v) for v in iso]
- self.assertEqual(datetime_f(datetime(a, b, c)), "<nobr>00:00:00</nobr>")
- def test_format_timedelta(self):
- self.assertEqual(format_timedelta(timedelta(0)), "0:00:00")
- self.assertEqual(format_timedelta(timedelta(days=1)), "1 day, 0:00:00")
- self.assertEqual(format_timedelta(timedelta(minutes=-6)), "-0:06:00")
- self.assertEqual(
- format_timedelta(timedelta(0) - timedelta(days=1, hours=5, minutes=6)),
- "-1 day, 5:06:00",
- )
- self.assertEqual(
- format_timedelta(timedelta(0) - timedelta(days=16, hours=4, minutes=3)),
- "-16 days, 4:03:00",
- )
- def test_json_encoded_obj(self):
- obj = {"a": 5, "b": ["a", "g", 5]}
- val = '{"a": 5, "b": ["a", "g", 5]}'
- jsonObj = JSONEncodedDict()
- resp = jsonObj.process_bind_param(obj, "dialect")
- self.assertIn('"a": 5', resp)
- self.assertIn('"b": ["a", "g", 5]', resp)
- self.assertEqual(jsonObj.process_result_value(val, "dialect"), obj)
- def test_validate_json(self):
- invalid = '{"a": 5, "b": [1, 5, ["g", "h]]}'
- with self.assertRaises(SupersetException):
- validate_json(invalid)
- def test_memoized_on_functions(self):
- watcher = {"val": 0}
- @memoized
- def test_function(a, b, c):
- watcher["val"] += 1
- return a * b * c
- result1 = test_function(1, 2, 3)
- result2 = test_function(1, 2, 3)
- self.assertEqual(result1, result2)
- self.assertEqual(watcher["val"], 1)
- def test_memoized_on_methods(self):
- class test_class:
- def __init__(self, num):
- self.num = num
- self.watcher = 0
- @memoized
- def test_method(self, a, b, c):
- self.watcher += 1
- return a * b * c * self.num
- instance = test_class(5)
- result1 = instance.test_method(1, 2, 3)
- result2 = instance.test_method(1, 2, 3)
- self.assertEqual(result1, result2)
- self.assertEqual(instance.watcher, 1)
- instance.num = 10
- self.assertEqual(result2, instance.test_method(1, 2, 3))
- def test_memoized_on_methods_with_watches(self):
- class test_class:
- def __init__(self, x, y):
- self.x = x
- self.y = y
- self.watcher = 0
- @memoized(watch=("x", "y"))
- def test_method(self, a, b, c):
- self.watcher += 1
- return a * b * c * self.x * self.y
- instance = test_class(3, 12)
- result1 = instance.test_method(1, 2, 3)
- result2 = instance.test_method(1, 2, 3)
- self.assertEqual(result1, result2)
- self.assertEqual(instance.watcher, 1)
- result3 = instance.test_method(2, 3, 4)
- self.assertEqual(instance.watcher, 2)
- result4 = instance.test_method(2, 3, 4)
- self.assertEqual(instance.watcher, 2)
- self.assertEqual(result3, result4)
- self.assertNotEqual(result3, result1)
- instance.x = 1
- result5 = instance.test_method(2, 3, 4)
- self.assertEqual(instance.watcher, 3)
- self.assertNotEqual(result5, result4)
- result6 = instance.test_method(2, 3, 4)
- self.assertEqual(instance.watcher, 3)
- self.assertEqual(result6, result5)
- instance.x = 10
- instance.y = 10
- result7 = instance.test_method(2, 3, 4)
- self.assertEqual(instance.watcher, 4)
- self.assertNotEqual(result7, result6)
- instance.x = 3
- instance.y = 12
- result8 = instance.test_method(1, 2, 3)
- self.assertEqual(instance.watcher, 4)
- self.assertEqual(result1, result8)
- @patch("superset.utils.core.parse_human_datetime", mock_parse_human_datetime)
- def test_get_since_until(self):
- result = get_since_until()
- expected = None, datetime(2016, 11, 7)
- self.assertEqual(result, expected)
- result = get_since_until(" : now")
- expected = None, datetime(2016, 11, 7, 9, 30, 10)
- self.assertEqual(result, expected)
- result = get_since_until("yesterday : tomorrow")
- expected = datetime(2016, 11, 6), datetime(2016, 11, 8)
- self.assertEqual(result, expected)
- result = get_since_until("2018-01-01T00:00:00 : 2018-12-31T23:59:59")
- expected = datetime(2018, 1, 1), datetime(2018, 12, 31, 23, 59, 59)
- self.assertEqual(result, expected)
- result = get_since_until("Last year")
- expected = datetime(2015, 11, 7), datetime(2016, 11, 7)
- self.assertEqual(result, expected)
- result = get_since_until("Last 5 months")
- expected = datetime(2016, 6, 7), datetime(2016, 11, 7)
- self.assertEqual(result, expected)
- result = get_since_until("Next 5 months")
- expected = datetime(2016, 11, 7), datetime(2017, 4, 7)
- self.assertEqual(result, expected)
- result = get_since_until(since="5 days")
- expected = datetime(2016, 11, 2), datetime(2016, 11, 7)
- self.assertEqual(result, expected)
- result = get_since_until(since="5 days ago", until="tomorrow")
- expected = datetime(2016, 11, 2), datetime(2016, 11, 8)
- self.assertEqual(result, expected)
- result = get_since_until(time_range="yesterday : tomorrow", time_shift="1 day")
- expected = datetime(2016, 11, 5), datetime(2016, 11, 7)
- self.assertEqual(result, expected)
- result = get_since_until(time_range="5 days : now")
- expected = datetime(2016, 11, 2), datetime(2016, 11, 7, 9, 30, 10)
- self.assertEqual(result, expected)
- result = get_since_until("Last week", relative_end="now")
- expected = datetime(2016, 10, 31), datetime(2016, 11, 7, 9, 30, 10)
- self.assertEqual(result, expected)
- result = get_since_until("Last week", relative_start="now")
- expected = datetime(2016, 10, 31, 9, 30, 10), datetime(2016, 11, 7)
- self.assertEqual(result, expected)
- result = get_since_until("Last week", relative_start="now", relative_end="now")
- expected = datetime(2016, 10, 31, 9, 30, 10), datetime(2016, 11, 7, 9, 30, 10)
- self.assertEqual(result, expected)
- with self.assertRaises(ValueError):
- get_since_until(time_range="tomorrow : yesterday")
- @patch("superset.utils.core.to_adhoc", mock_to_adhoc)
- def test_convert_legacy_filters_into_adhoc_where(self):
- form_data = {"where": "a = 1"}
- expected = {
- "adhoc_filters": [
- {"clause": "WHERE", "expressionType": "SQL", "sqlExpression": "a = 1"}
- ]
- }
- convert_legacy_filters_into_adhoc(form_data)
- self.assertEqual(form_data, expected)
- @patch("superset.utils.core.to_adhoc", mock_to_adhoc)
- def test_convert_legacy_filters_into_adhoc_filters(self):
- form_data = {"filters": [{"col": "a", "op": "in", "val": "someval"}]}
- expected = {
- "adhoc_filters": [
- {
- "clause": "WHERE",
- "comparator": "someval",
- "expressionType": "SIMPLE",
- "operator": "in",
- "subject": "a",
- }
- ]
- }
- convert_legacy_filters_into_adhoc(form_data)
- self.assertEqual(form_data, expected)
- @patch("superset.utils.core.to_adhoc", mock_to_adhoc)
- def test_convert_legacy_filters_into_adhoc_having(self):
- form_data = {"having": "COUNT(1) = 1"}
- expected = {
- "adhoc_filters": [
- {
- "clause": "HAVING",
- "expressionType": "SQL",
- "sqlExpression": "COUNT(1) = 1",
- }
- ]
- }
- convert_legacy_filters_into_adhoc(form_data)
- self.assertEqual(form_data, expected)
- @patch("superset.utils.core.to_adhoc", mock_to_adhoc)
- def test_convert_legacy_filters_into_adhoc_having_filters(self):
- form_data = {"having_filters": [{"col": "COUNT(1)", "op": "==", "val": 1}]}
- expected = {
- "adhoc_filters": [
- {
- "clause": "HAVING",
- "comparator": 1,
- "expressionType": "SIMPLE",
- "operator": "==",
- "subject": "COUNT(1)",
- }
- ]
- }
- convert_legacy_filters_into_adhoc(form_data)
- self.assertEqual(form_data, expected)
- @patch("superset.utils.core.to_adhoc", mock_to_adhoc)
- def test_convert_legacy_filters_into_adhoc_present_and_empty(self):
- form_data = {"adhoc_filters": [], "where": "a = 1"}
- expected = {
- "adhoc_filters": [
- {"clause": "WHERE", "expressionType": "SQL", "sqlExpression": "a = 1"}
- ]
- }
- convert_legacy_filters_into_adhoc(form_data)
- self.assertEqual(form_data, expected)
- @patch("superset.utils.core.to_adhoc", mock_to_adhoc)
- def test_convert_legacy_filters_into_adhoc_present_and_nonempty(self):
- form_data = {
- "adhoc_filters": [
- {"clause": "WHERE", "expressionType": "SQL", "sqlExpression": "a = 1"}
- ],
- "filters": [{"col": "a", "op": "in", "val": "someval"}],
- "having": "COUNT(1) = 1",
- "having_filters": [{"col": "COUNT(1)", "op": "==", "val": 1}],
- }
- expected = {
- "adhoc_filters": [
- {"clause": "WHERE", "expressionType": "SQL", "sqlExpression": "a = 1"}
- ]
- }
- convert_legacy_filters_into_adhoc(form_data)
- self.assertEqual(form_data, expected)
- def test_parse_js_uri_path_items_eval_undefined(self):
- self.assertIsNone(parse_js_uri_path_item("undefined", eval_undefined=True))
- self.assertIsNone(parse_js_uri_path_item("null", eval_undefined=True))
- self.assertEqual("undefined", parse_js_uri_path_item("undefined"))
- self.assertEqual("null", parse_js_uri_path_item("null"))
- def test_parse_js_uri_path_items_unquote(self):
- self.assertEqual("slashed/name", parse_js_uri_path_item("slashed%2fname"))
- self.assertEqual(
- "slashed%2fname", parse_js_uri_path_item("slashed%2fname", unquote=False)
- )
- def test_parse_js_uri_path_items_item_optional(self):
- self.assertIsNone(parse_js_uri_path_item(None))
- self.assertIsNotNone(parse_js_uri_path_item("item"))
- def test_setup_cache_null_config(self):
- app = Flask(__name__)
- cache_config = {"CACHE_TYPE": "null"}
- assert isinstance(CacheManager._setup_cache(app, cache_config), Cache)
- def test_setup_cache_standard_config(self):
- app = Flask(__name__)
- cache_config = {
- "CACHE_TYPE": "redis",
- "CACHE_DEFAULT_TIMEOUT": 60,
- "CACHE_KEY_PREFIX": "superset_results",
- "CACHE_REDIS_URL": "redis://localhost:6379/0",
- }
- assert isinstance(CacheManager._setup_cache(app, cache_config), Cache) is True
- def test_setup_cache_custom_function(self):
- app = Flask(__name__)
- CustomCache = type("CustomCache", (object,), {"__init__": lambda *args: None})
- def init_cache(app):
- return CustomCache(app, {})
- assert (
- isinstance(CacheManager._setup_cache(app, init_cache), CustomCache) is True
- )
- def test_get_stacktrace(self):
- with app.app_context():
- app.config["SHOW_STACKTRACE"] = True
- try:
- raise Exception("NONONO!")
- except Exception:
- stacktrace = get_stacktrace()
- self.assertIn("NONONO", stacktrace)
- app.config["SHOW_STACKTRACE"] = False
- try:
- raise Exception("NONONO!")
- except Exception:
- stacktrace = get_stacktrace()
- assert stacktrace is None
- def test_split(self):
- self.assertEqual(list(split("a b")), ["a", "b"])
- self.assertEqual(list(split("a,b", delimiter=",")), ["a", "b"])
- self.assertEqual(list(split("a,(b,a)", delimiter=",")), ["a", "(b,a)"])
- self.assertEqual(
- list(split('a,(b,a),"foo , bar"', delimiter=",")),
- ["a", "(b,a)", '"foo , bar"'],
- )
- self.assertEqual(
- list(split("a,'b,c'", delimiter=",", quote="'")), ["a", "'b,c'"]
- )
- self.assertEqual(list(split('a "b c"')), ["a", '"b c"'])
- self.assertEqual(list(split(r'a "b \" c"')), ["a", r'"b \" c"'])
- def test_get_or_create_db(self):
- get_or_create_db("test_db", "sqlite:///superset.db")
- database = db.session.query(Database).filter_by(database_name="test_db").one()
- self.assertIsNotNone(database)
- self.assertEqual(database.sqlalchemy_uri, "sqlite:///superset.db")
- self.assertIsNotNone(
- security_manager.find_permission_view_menu("database_access", database.perm)
- )
- # Test change URI
- get_or_create_db("test_db", "sqlite:///changed.db")
- database = db.session.query(Database).filter_by(database_name="test_db").one()
- self.assertEqual(database.sqlalchemy_uri, "sqlite:///changed.db")
- db.session.delete(database)
- db.session.commit()
- def test_get_or_create_db_invalid_uri(self):
- with self.assertRaises(ArgumentError):
- get_or_create_db("test_db", "yoursql:superset.db/()")
- def test_get_time_range_endpoints(self):
- self.assertEqual(
- get_time_range_endpoints(form_data={}),
- (TimeRangeEndpoint.INCLUSIVE, TimeRangeEndpoint.EXCLUSIVE),
- )
- self.assertEqual(
- get_time_range_endpoints(
- form_data={"time_range_endpoints": ["inclusive", "inclusive"]}
- ),
- (TimeRangeEndpoint.INCLUSIVE, TimeRangeEndpoint.INCLUSIVE),
- )
- self.assertEqual(
- get_time_range_endpoints(form_data={"datasource": "1_druid"}),
- (TimeRangeEndpoint.INCLUSIVE, TimeRangeEndpoint.EXCLUSIVE),
- )
- slc = Mock()
- slc.datasource.database.get_extra.return_value = {}
- self.assertEqual(
- get_time_range_endpoints(form_data={"datasource": "1__table"}, slc=slc),
- (TimeRangeEndpoint.UNKNOWN, TimeRangeEndpoint.INCLUSIVE),
- )
- slc.datasource.database.get_extra.return_value = {
- "time_range_endpoints": ["inclusive", "inclusive"]
- }
- self.assertEqual(
- get_time_range_endpoints(form_data={"datasource": "1__table"}, slc=slc),
- (TimeRangeEndpoint.INCLUSIVE, TimeRangeEndpoint.INCLUSIVE),
- )
- self.assertIsNone(get_time_range_endpoints(form_data={}, slc=slc))
- with app.app_context():
- app.config["SIP_15_GRACE_PERIOD_END"] = date.today() + timedelta(days=1)
- self.assertEqual(
- get_time_range_endpoints(form_data={"datasource": "1__table"}, slc=slc),
- (TimeRangeEndpoint.INCLUSIVE, TimeRangeEndpoint.INCLUSIVE),
- )
- app.config["SIP_15_GRACE_PERIOD_END"] = date.today()
- self.assertEqual(
- get_time_range_endpoints(form_data={"datasource": "1__table"}, slc=slc),
- (TimeRangeEndpoint.INCLUSIVE, TimeRangeEndpoint.EXCLUSIVE),
- )
|