123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707 |
- # 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
- """Unit tests for Superset"""
- import json
- import unittest
- from flask import g
- from sqlalchemy.orm.session import make_transient
- from tests.test_app import app
- from superset.utils.dashboard_import_export import decode_dashboards
- from superset import db, security_manager
- from superset.connectors.druid.models import (
- DruidColumn,
- DruidDatasource,
- DruidMetric,
- DruidCluster,
- )
- from superset.connectors.sqla.models import SqlaTable, SqlMetric, TableColumn
- from superset.models.dashboard import Dashboard
- from superset.models.slice import Slice
- from .base_tests import SupersetTestCase
- class ImportExportTests(SupersetTestCase):
- """Testing export import functionality for dashboards"""
- @classmethod
- def delete_imports(cls):
- with app.app_context():
- # Imported data clean up
- session = db.session
- for slc in session.query(Slice):
- if "remote_id" in slc.params_dict:
- session.delete(slc)
- for dash in session.query(Dashboard):
- if "remote_id" in dash.params_dict:
- session.delete(dash)
- for table in session.query(SqlaTable):
- if "remote_id" in table.params_dict:
- session.delete(table)
- for datasource in session.query(DruidDatasource):
- if "remote_id" in datasource.params_dict:
- session.delete(datasource)
- session.commit()
- @classmethod
- def setUpClass(cls):
- cls.delete_imports()
- cls.create_druid_test_objects()
- @classmethod
- def tearDownClass(cls):
- cls.delete_imports()
- def create_slice(
- self,
- name,
- ds_id=None,
- id=None,
- db_name="examples",
- table_name="wb_health_population",
- ):
- params = {
- "num_period_compare": "10",
- "remote_id": id,
- "datasource_name": table_name,
- "database_name": db_name,
- "schema": "",
- # Test for trailing commas
- "metrics": ["sum__signup_attempt_email", "sum__signup_attempt_facebook"],
- }
- if table_name and not ds_id:
- table = self.get_table_by_name(table_name)
- if table:
- ds_id = table.id
- return Slice(
- slice_name=name,
- datasource_type="table",
- viz_type="bubble",
- params=json.dumps(params),
- datasource_id=ds_id,
- id=id,
- )
- def create_dashboard(self, title, id=0, slcs=[]):
- json_metadata = {"remote_id": id}
- return Dashboard(
- id=id,
- dashboard_title=title,
- slices=slcs,
- position_json='{"size_y": 2, "size_x": 2}',
- slug="{}_imported".format(title.lower()),
- json_metadata=json.dumps(json_metadata),
- )
- def create_table(self, name, schema="", id=0, cols_names=[], metric_names=[]):
- params = {"remote_id": id, "database_name": "examples"}
- table = SqlaTable(
- id=id, schema=schema, table_name=name, params=json.dumps(params)
- )
- for col_name in cols_names:
- table.columns.append(TableColumn(column_name=col_name))
- for metric_name in metric_names:
- table.metrics.append(SqlMetric(metric_name=metric_name, expression=""))
- return table
- def create_druid_datasource(self, name, id=0, cols_names=[], metric_names=[]):
- cluster_name = "druid_test"
- cluster = self.get_or_create(
- DruidCluster, {"cluster_name": cluster_name}, db.session
- )
- params = {"remote_id": id, "database_name": cluster_name}
- datasource = DruidDatasource(
- id=id,
- datasource_name=name,
- cluster_id=cluster.id,
- params=json.dumps(params),
- )
- for col_name in cols_names:
- datasource.columns.append(DruidColumn(column_name=col_name))
- for metric_name in metric_names:
- datasource.metrics.append(DruidMetric(metric_name=metric_name, json="{}"))
- return datasource
- def get_slice(self, slc_id):
- return db.session.query(Slice).filter_by(id=slc_id).first()
- def get_slice_by_name(self, name):
- return db.session.query(Slice).filter_by(slice_name=name).first()
- def get_dash(self, dash_id):
- return db.session.query(Dashboard).filter_by(id=dash_id).first()
- def get_datasource(self, datasource_id):
- return db.session.query(DruidDatasource).filter_by(id=datasource_id).first()
- def get_table_by_name(self, name):
- return db.session.query(SqlaTable).filter_by(table_name=name).first()
- def assert_dash_equals(self, expected_dash, actual_dash, check_position=True):
- self.assertEqual(expected_dash.slug, actual_dash.slug)
- self.assertEqual(expected_dash.dashboard_title, actual_dash.dashboard_title)
- self.assertEqual(len(expected_dash.slices), len(actual_dash.slices))
- expected_slices = sorted(expected_dash.slices, key=lambda s: s.slice_name or "")
- actual_slices = sorted(actual_dash.slices, key=lambda s: s.slice_name or "")
- for e_slc, a_slc in zip(expected_slices, actual_slices):
- self.assert_slice_equals(e_slc, a_slc)
- if check_position:
- self.assertEqual(expected_dash.position_json, actual_dash.position_json)
- def assert_table_equals(self, expected_ds, actual_ds):
- self.assertEqual(expected_ds.table_name, actual_ds.table_name)
- self.assertEqual(expected_ds.main_dttm_col, actual_ds.main_dttm_col)
- self.assertEqual(expected_ds.schema, actual_ds.schema)
- self.assertEqual(len(expected_ds.metrics), len(actual_ds.metrics))
- self.assertEqual(len(expected_ds.columns), len(actual_ds.columns))
- self.assertEqual(
- set([c.column_name for c in expected_ds.columns]),
- set([c.column_name for c in actual_ds.columns]),
- )
- self.assertEqual(
- set([m.metric_name for m in expected_ds.metrics]),
- set([m.metric_name for m in actual_ds.metrics]),
- )
- def assert_datasource_equals(self, expected_ds, actual_ds):
- self.assertEqual(expected_ds.datasource_name, actual_ds.datasource_name)
- self.assertEqual(expected_ds.main_dttm_col, actual_ds.main_dttm_col)
- self.assertEqual(len(expected_ds.metrics), len(actual_ds.metrics))
- self.assertEqual(len(expected_ds.columns), len(actual_ds.columns))
- self.assertEqual(
- set([c.column_name for c in expected_ds.columns]),
- set([c.column_name for c in actual_ds.columns]),
- )
- self.assertEqual(
- set([m.metric_name for m in expected_ds.metrics]),
- set([m.metric_name for m in actual_ds.metrics]),
- )
- def assert_slice_equals(self, expected_slc, actual_slc):
- # to avoid bad slice data (no slice_name)
- expected_slc_name = expected_slc.slice_name or ""
- actual_slc_name = actual_slc.slice_name or ""
- self.assertEqual(expected_slc_name, actual_slc_name)
- self.assertEqual(expected_slc.datasource_type, actual_slc.datasource_type)
- self.assertEqual(expected_slc.viz_type, actual_slc.viz_type)
- exp_params = json.loads(expected_slc.params)
- actual_params = json.loads(actual_slc.params)
- diff_params_keys = (
- "schema",
- "database_name",
- "datasource_name",
- "remote_id",
- "import_time",
- )
- for k in diff_params_keys:
- if k in actual_params:
- actual_params.pop(k)
- if k in exp_params:
- exp_params.pop(k)
- self.assertEqual(exp_params, actual_params)
- def assert_only_exported_slc_fields(self, expected_dash, actual_dash):
- """ only exported json has this params
- imported/created dashboard has relationships to other models instead
- """
- expected_slices = sorted(expected_dash.slices, key=lambda s: s.slice_name or "")
- actual_slices = sorted(actual_dash.slices, key=lambda s: s.slice_name or "")
- for e_slc, a_slc in zip(expected_slices, actual_slices):
- params = a_slc.params_dict
- self.assertEqual(e_slc.datasource.name, params["datasource_name"])
- self.assertEqual(e_slc.datasource.schema, params["schema"])
- self.assertEqual(e_slc.datasource.database.name, params["database_name"])
- def test_export_1_dashboard(self):
- self.login("admin")
- birth_dash = self.get_dash_by_slug("births")
- id_ = birth_dash.id
- export_dash_url = f"/dashboard/export_dashboards_form?id={id_}&action=go"
- resp = self.client.get(export_dash_url)
- exported_dashboards = json.loads(
- resp.data.decode("utf-8"), object_hook=decode_dashboards
- )["dashboards"]
- birth_dash = self.get_dash_by_slug("births")
- self.assert_only_exported_slc_fields(birth_dash, exported_dashboards[0])
- self.assert_dash_equals(birth_dash, exported_dashboards[0])
- self.assertEqual(
- id_,
- json.loads(
- exported_dashboards[0].json_metadata, object_hook=decode_dashboards
- )["remote_id"],
- )
- exported_tables = json.loads(
- resp.data.decode("utf-8"), object_hook=decode_dashboards
- )["datasources"]
- self.assertEqual(1, len(exported_tables))
- self.assert_table_equals(
- self.get_table_by_name("birth_names"), exported_tables[0]
- )
- def test_export_2_dashboards(self):
- self.login("admin")
- birth_dash = self.get_dash_by_slug("births")
- world_health_dash = self.get_dash_by_slug("world_health")
- export_dash_url = "/dashboard/export_dashboards_form?id={}&id={}&action=go".format(
- birth_dash.id, world_health_dash.id
- )
- resp = self.client.get(export_dash_url)
- resp_data = json.loads(resp.data.decode("utf-8"), object_hook=decode_dashboards)
- exported_dashboards = sorted(
- resp_data.get("dashboards"), key=lambda d: d.dashboard_title
- )
- self.assertEqual(2, len(exported_dashboards))
- birth_dash = self.get_dash_by_slug("births")
- self.assert_only_exported_slc_fields(birth_dash, exported_dashboards[0])
- self.assert_dash_equals(birth_dash, exported_dashboards[0])
- self.assertEqual(
- birth_dash.id, json.loads(exported_dashboards[0].json_metadata)["remote_id"]
- )
- world_health_dash = self.get_dash_by_slug("world_health")
- self.assert_only_exported_slc_fields(world_health_dash, exported_dashboards[1])
- self.assert_dash_equals(world_health_dash, exported_dashboards[1])
- self.assertEqual(
- world_health_dash.id,
- json.loads(exported_dashboards[1].json_metadata)["remote_id"],
- )
- exported_tables = sorted(
- resp_data.get("datasources"), key=lambda t: t.table_name
- )
- self.assertEqual(2, len(exported_tables))
- self.assert_table_equals(
- self.get_table_by_name("birth_names"), exported_tables[0]
- )
- self.assert_table_equals(
- self.get_table_by_name("wb_health_population"), exported_tables[1]
- )
- def test_import_1_slice(self):
- expected_slice = self.create_slice("Import Me", id=10001)
- slc_id = Slice.import_obj(expected_slice, None, import_time=1989)
- slc = self.get_slice(slc_id)
- self.assertEqual(slc.datasource.perm, slc.perm)
- self.assert_slice_equals(expected_slice, slc)
- table_id = self.get_table_by_name("wb_health_population").id
- self.assertEqual(table_id, self.get_slice(slc_id).datasource_id)
- def test_import_2_slices_for_same_table(self):
- table_id = self.get_table_by_name("wb_health_population").id
- # table_id != 666, import func will have to find the table
- slc_1 = self.create_slice("Import Me 1", ds_id=666, id=10002)
- slc_id_1 = Slice.import_obj(slc_1, None)
- slc_2 = self.create_slice("Import Me 2", ds_id=666, id=10003)
- slc_id_2 = Slice.import_obj(slc_2, None)
- imported_slc_1 = self.get_slice(slc_id_1)
- imported_slc_2 = self.get_slice(slc_id_2)
- self.assertEqual(table_id, imported_slc_1.datasource_id)
- self.assert_slice_equals(slc_1, imported_slc_1)
- self.assertEqual(imported_slc_1.datasource.perm, imported_slc_1.perm)
- self.assertEqual(table_id, imported_slc_2.datasource_id)
- self.assert_slice_equals(slc_2, imported_slc_2)
- self.assertEqual(imported_slc_2.datasource.perm, imported_slc_2.perm)
- def test_import_slices_for_non_existent_table(self):
- with self.assertRaises(AttributeError):
- Slice.import_obj(
- self.create_slice("Import Me 3", id=10004, table_name="non_existent"),
- None,
- )
- def test_import_slices_override(self):
- slc = self.create_slice("Import Me New", id=10005)
- slc_1_id = Slice.import_obj(slc, None, import_time=1990)
- slc.slice_name = "Import Me New"
- imported_slc_1 = self.get_slice(slc_1_id)
- slc_2 = self.create_slice("Import Me New", id=10005)
- slc_2_id = Slice.import_obj(slc_2, imported_slc_1, import_time=1990)
- self.assertEqual(slc_1_id, slc_2_id)
- imported_slc_2 = self.get_slice(slc_2_id)
- self.assert_slice_equals(slc, imported_slc_2)
- def test_import_empty_dashboard(self):
- empty_dash = self.create_dashboard("empty_dashboard", id=10001)
- imported_dash_id = Dashboard.import_obj(empty_dash, import_time=1989)
- imported_dash = self.get_dash(imported_dash_id)
- self.assert_dash_equals(empty_dash, imported_dash, check_position=False)
- def test_import_dashboard_1_slice(self):
- slc = self.create_slice("health_slc", id=10006)
- dash_with_1_slice = self.create_dashboard(
- "dash_with_1_slice", slcs=[slc], id=10002
- )
- dash_with_1_slice.position_json = """
- {{"DASHBOARD_VERSION_KEY": "v2",
- "DASHBOARD_CHART_TYPE-{0}": {{
- "type": "DASHBOARD_CHART_TYPE",
- "id": {0},
- "children": [],
- "meta": {{
- "width": 4,
- "height": 50,
- "chartId": {0}
- }}
- }}
- }}
- """.format(
- slc.id
- )
- imported_dash_id = Dashboard.import_obj(dash_with_1_slice, import_time=1990)
- imported_dash = self.get_dash(imported_dash_id)
- expected_dash = self.create_dashboard("dash_with_1_slice", slcs=[slc], id=10002)
- make_transient(expected_dash)
- self.assert_dash_equals(expected_dash, imported_dash, check_position=False)
- self.assertEqual(
- {"remote_id": 10002, "import_time": 1990},
- json.loads(imported_dash.json_metadata),
- )
- expected_position = dash_with_1_slice.position
- # new slice id (auto-incremental) assigned on insert
- # id from json is used only for updating position with new id
- meta = expected_position["DASHBOARD_CHART_TYPE-10006"]["meta"]
- meta["chartId"] = imported_dash.slices[0].id
- self.assertEqual(expected_position, imported_dash.position)
- def test_import_dashboard_2_slices(self):
- e_slc = self.create_slice("e_slc", id=10007, table_name="energy_usage")
- b_slc = self.create_slice("b_slc", id=10008, table_name="birth_names")
- dash_with_2_slices = self.create_dashboard(
- "dash_with_2_slices", slcs=[e_slc, b_slc], id=10003
- )
- dash_with_2_slices.json_metadata = json.dumps(
- {
- "remote_id": 10003,
- "expanded_slices": {
- "{}".format(e_slc.id): True,
- "{}".format(b_slc.id): False,
- },
- # mocked filter_scope metadata
- "filter_scopes": {
- str(e_slc.id): {
- "region": {"scope": ["ROOT_ID"], "immune": [b_slc.id]}
- }
- },
- }
- )
- imported_dash_id = Dashboard.import_obj(dash_with_2_slices, import_time=1991)
- imported_dash = self.get_dash(imported_dash_id)
- expected_dash = self.create_dashboard(
- "dash_with_2_slices", slcs=[e_slc, b_slc], id=10003
- )
- make_transient(expected_dash)
- self.assert_dash_equals(imported_dash, expected_dash, check_position=False)
- i_e_slc = self.get_slice_by_name("e_slc")
- i_b_slc = self.get_slice_by_name("b_slc")
- expected_json_metadata = {
- "remote_id": 10003,
- "import_time": 1991,
- "filter_scopes": {
- str(i_e_slc.id): {
- "region": {"scope": ["ROOT_ID"], "immune": [i_b_slc.id]}
- }
- },
- "expanded_slices": {
- "{}".format(i_e_slc.id): True,
- "{}".format(i_b_slc.id): False,
- },
- }
- self.assertEqual(
- expected_json_metadata, json.loads(imported_dash.json_metadata)
- )
- def test_import_override_dashboard_2_slices(self):
- e_slc = self.create_slice("e_slc", id=10009, table_name="energy_usage")
- b_slc = self.create_slice("b_slc", id=10010, table_name="birth_names")
- dash_to_import = self.create_dashboard(
- "override_dashboard", slcs=[e_slc, b_slc], id=10004
- )
- imported_dash_id_1 = Dashboard.import_obj(dash_to_import, import_time=1992)
- # create new instances of the slices
- e_slc = self.create_slice("e_slc", id=10009, table_name="energy_usage")
- b_slc = self.create_slice("b_slc", id=10010, table_name="birth_names")
- c_slc = self.create_slice("c_slc", id=10011, table_name="birth_names")
- dash_to_import_override = self.create_dashboard(
- "override_dashboard_new", slcs=[e_slc, b_slc, c_slc], id=10004
- )
- imported_dash_id_2 = Dashboard.import_obj(
- dash_to_import_override, import_time=1992
- )
- # override doesn't change the id
- self.assertEqual(imported_dash_id_1, imported_dash_id_2)
- expected_dash = self.create_dashboard(
- "override_dashboard_new", slcs=[e_slc, b_slc, c_slc], id=10004
- )
- make_transient(expected_dash)
- imported_dash = self.get_dash(imported_dash_id_2)
- self.assert_dash_equals(expected_dash, imported_dash, check_position=False)
- self.assertEqual(
- {"remote_id": 10004, "import_time": 1992},
- json.loads(imported_dash.json_metadata),
- )
- def test_import_new_dashboard_slice_reset_ownership(self):
- admin_user = security_manager.find_user(username="admin")
- self.assertTrue(admin_user)
- gamma_user = security_manager.find_user(username="gamma")
- self.assertTrue(gamma_user)
- g.user = gamma_user
- dash_with_1_slice = self._create_dashboard_for_import(id_=10200)
- # set another user as an owner of importing dashboard
- dash_with_1_slice.created_by = admin_user
- dash_with_1_slice.changed_by = admin_user
- dash_with_1_slice.owners = [admin_user]
- imported_dash_id = Dashboard.import_obj(dash_with_1_slice)
- imported_dash = self.get_dash(imported_dash_id)
- self.assertEqual(imported_dash.created_by, gamma_user)
- self.assertEqual(imported_dash.changed_by, gamma_user)
- self.assertEqual(imported_dash.owners, [gamma_user])
- imported_slc = imported_dash.slices[0]
- self.assertEqual(imported_slc.created_by, gamma_user)
- self.assertEqual(imported_slc.changed_by, gamma_user)
- self.assertEqual(imported_slc.owners, [gamma_user])
- def test_import_override_dashboard_slice_reset_ownership(self):
- admin_user = security_manager.find_user(username="admin")
- self.assertTrue(admin_user)
- gamma_user = security_manager.find_user(username="gamma")
- self.assertTrue(gamma_user)
- g.user = gamma_user
- dash_with_1_slice = self._create_dashboard_for_import(id_=10300)
- imported_dash_id = Dashboard.import_obj(dash_with_1_slice)
- imported_dash = self.get_dash(imported_dash_id)
- self.assertEqual(imported_dash.created_by, gamma_user)
- self.assertEqual(imported_dash.changed_by, gamma_user)
- self.assertEqual(imported_dash.owners, [gamma_user])
- imported_slc = imported_dash.slices[0]
- self.assertEqual(imported_slc.created_by, gamma_user)
- self.assertEqual(imported_slc.changed_by, gamma_user)
- self.assertEqual(imported_slc.owners, [gamma_user])
- # re-import with another user shouldn't change the permissions
- g.user = admin_user
- dash_with_1_slice = self._create_dashboard_for_import(id_=10300)
- imported_dash_id = Dashboard.import_obj(dash_with_1_slice)
- imported_dash = self.get_dash(imported_dash_id)
- self.assertEqual(imported_dash.created_by, gamma_user)
- self.assertEqual(imported_dash.changed_by, gamma_user)
- self.assertEqual(imported_dash.owners, [gamma_user])
- imported_slc = imported_dash.slices[0]
- self.assertEqual(imported_slc.created_by, gamma_user)
- self.assertEqual(imported_slc.changed_by, gamma_user)
- self.assertEqual(imported_slc.owners, [gamma_user])
- def _create_dashboard_for_import(self, id_=10100):
- slc = self.create_slice("health_slc" + str(id_), id=id_ + 1)
- dash_with_1_slice = self.create_dashboard(
- "dash_with_1_slice" + str(id_), slcs=[slc], id=id_ + 2
- )
- dash_with_1_slice.position_json = """
- {{"DASHBOARD_VERSION_KEY": "v2",
- "DASHBOARD_CHART_TYPE-{0}": {{
- "type": "DASHBOARD_CHART_TYPE",
- "id": {0},
- "children": [],
- "meta": {{
- "width": 4,
- "height": 50,
- "chartId": {0}
- }}
- }}
- }}
- """.format(
- slc.id
- )
- return dash_with_1_slice
- def test_import_table_no_metadata(self):
- table = self.create_table("pure_table", id=10001)
- imported_id = SqlaTable.import_obj(table, import_time=1989)
- imported = self.get_table(imported_id)
- self.assert_table_equals(table, imported)
- def test_import_table_1_col_1_met(self):
- table = self.create_table(
- "table_1_col_1_met", id=10002, cols_names=["col1"], metric_names=["metric1"]
- )
- imported_id = SqlaTable.import_obj(table, import_time=1990)
- imported = self.get_table(imported_id)
- self.assert_table_equals(table, imported)
- self.assertEqual(
- {"remote_id": 10002, "import_time": 1990, "database_name": "examples"},
- json.loads(imported.params),
- )
- def test_import_table_2_col_2_met(self):
- table = self.create_table(
- "table_2_col_2_met",
- id=10003,
- cols_names=["c1", "c2"],
- metric_names=["m1", "m2"],
- )
- imported_id = SqlaTable.import_obj(table, import_time=1991)
- imported = self.get_table(imported_id)
- self.assert_table_equals(table, imported)
- def test_import_table_override(self):
- table = self.create_table(
- "table_override", id=10003, cols_names=["col1"], metric_names=["m1"]
- )
- imported_id = SqlaTable.import_obj(table, import_time=1991)
- table_over = self.create_table(
- "table_override",
- id=10003,
- cols_names=["new_col1", "col2", "col3"],
- metric_names=["new_metric1"],
- )
- imported_over_id = SqlaTable.import_obj(table_over, import_time=1992)
- imported_over = self.get_table(imported_over_id)
- self.assertEqual(imported_id, imported_over.id)
- expected_table = self.create_table(
- "table_override",
- id=10003,
- metric_names=["new_metric1", "m1"],
- cols_names=["col1", "new_col1", "col2", "col3"],
- )
- self.assert_table_equals(expected_table, imported_over)
- def test_import_table_override_identical(self):
- table = self.create_table(
- "copy_cat",
- id=10004,
- cols_names=["new_col1", "col2", "col3"],
- metric_names=["new_metric1"],
- )
- imported_id = SqlaTable.import_obj(table, import_time=1993)
- copy_table = self.create_table(
- "copy_cat",
- id=10004,
- cols_names=["new_col1", "col2", "col3"],
- metric_names=["new_metric1"],
- )
- imported_id_copy = SqlaTable.import_obj(copy_table, import_time=1994)
- self.assertEqual(imported_id, imported_id_copy)
- self.assert_table_equals(copy_table, self.get_table(imported_id))
- def test_import_druid_no_metadata(self):
- datasource = self.create_druid_datasource("pure_druid", id=10001)
- imported_id = DruidDatasource.import_obj(datasource, import_time=1989)
- imported = self.get_datasource(imported_id)
- self.assert_datasource_equals(datasource, imported)
- def test_import_druid_1_col_1_met(self):
- datasource = self.create_druid_datasource(
- "druid_1_col_1_met", id=10002, cols_names=["col1"], metric_names=["metric1"]
- )
- imported_id = DruidDatasource.import_obj(datasource, import_time=1990)
- imported = self.get_datasource(imported_id)
- self.assert_datasource_equals(datasource, imported)
- self.assertEqual(
- {"remote_id": 10002, "import_time": 1990, "database_name": "druid_test"},
- json.loads(imported.params),
- )
- def test_import_druid_2_col_2_met(self):
- datasource = self.create_druid_datasource(
- "druid_2_col_2_met",
- id=10003,
- cols_names=["c1", "c2"],
- metric_names=["m1", "m2"],
- )
- imported_id = DruidDatasource.import_obj(datasource, import_time=1991)
- imported = self.get_datasource(imported_id)
- self.assert_datasource_equals(datasource, imported)
- def test_import_druid_override(self):
- datasource = self.create_druid_datasource(
- "druid_override", id=10004, cols_names=["col1"], metric_names=["m1"]
- )
- imported_id = DruidDatasource.import_obj(datasource, import_time=1991)
- table_over = self.create_druid_datasource(
- "druid_override",
- id=10004,
- cols_names=["new_col1", "col2", "col3"],
- metric_names=["new_metric1"],
- )
- imported_over_id = DruidDatasource.import_obj(table_over, import_time=1992)
- imported_over = self.get_datasource(imported_over_id)
- self.assertEqual(imported_id, imported_over.id)
- expected_datasource = self.create_druid_datasource(
- "druid_override",
- id=10004,
- metric_names=["new_metric1", "m1"],
- cols_names=["col1", "new_col1", "col2", "col3"],
- )
- self.assert_datasource_equals(expected_datasource, imported_over)
- def test_import_druid_override_identical(self):
- datasource = self.create_druid_datasource(
- "copy_cat",
- id=10005,
- cols_names=["new_col1", "col2", "col3"],
- metric_names=["new_metric1"],
- )
- imported_id = DruidDatasource.import_obj(datasource, import_time=1993)
- copy_datasource = self.create_druid_datasource(
- "copy_cat",
- id=10005,
- cols_names=["new_col1", "col2", "col3"],
- metric_names=["new_metric1"],
- )
- imported_id_copy = DruidDatasource.import_obj(copy_datasource, import_time=1994)
- self.assertEqual(imported_id, imported_id_copy)
- self.assert_datasource_equals(copy_datasource, self.get_datasource(imported_id))
- if __name__ == "__main__":
- unittest.main()
|