blob: d242bd9b2ee448094215d67fb594b1aabf00f516 [file]
################################################################################
# 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 unittest
from typing import get_type_hints, Optional
import pyflink.dataframe as pf
from pyflink.dataframe.dataframe_config import _DataFrameConfig
from pyflink.testing.test_case_utils import PyFlinkUTTestCase
class DataFrameConfigValidationTests(unittest.TestCase):
def setUp(self):
previous_environment = pf.get_table_environment()
self.addCleanup(pf.set_table_environment, previous_environment)
self.addCleanup(pf.config._buffered.clear)
pf.set_table_environment(None)
pf.config._buffered.clear()
def test_config_is_a_dataframe_config_singleton(self):
self.assertIsInstance(pf.config, _DataFrameConfig)
self.assertNotIn("DataFrameConfig", pf.__all__)
self.assertNotIn("_DataFrameConfig", pf.__all__)
def test_public_type_hints_are_resolvable(self):
self.assertEqual(
get_type_hints(_DataFrameConfig.set),
{
"key": str,
"value": str,
"return": _DataFrameConfig,
},
)
self.assertEqual(
get_type_hints(_DataFrameConfig.get),
{
"key": str,
"default": Optional[str],
"return": Optional[str],
},
)
def test_set_rejects_non_string_key_without_buffering(self):
with self.assertRaisesRegex(TypeError, "key must be a string"):
pf.config.set(1, "value")
self.assertEqual(pf.config._buffered, {})
def test_set_rejects_non_string_value_without_buffering(self):
with self.assertRaisesRegex(TypeError, "value must be a string"):
pf.config.set("pipeline.name", 1)
self.assertEqual(pf.config._buffered, {})
def test_get_rejects_non_string_key(self):
with self.assertRaisesRegex(TypeError, "key must be a string"):
pf.config.get(1)
def test_get_rejects_non_string_default(self):
with self.assertRaisesRegex(TypeError, "default must be a string or None"):
pf.config.get("pipeline.name", 1)
def test_set_returns_the_config_for_chaining(self):
result = pf.config.set("pipeline.name", "a").set("parallelism.default", "4")
self.assertIs(result, pf.config)
def test_buffered_value_is_returned_before_an_environment_exists(self):
pf.config.set("pipeline.name", "buffered")
self.assertEqual(pf.config.get("pipeline.name"), "buffered")
def test_default_is_returned_when_not_buffered(self):
self.assertIsNone(pf.config.get("pipeline.name"))
self.assertEqual(pf.config.get("pipeline.name", "fallback"), "fallback")
class DataFrameConfigTests(PyFlinkUTTestCase):
def setUp(self):
super().setUp()
previous_environment = pf.get_table_environment()
self.addCleanup(pf.set_table_environment, previous_environment)
self.addCleanup(pf.config._buffered.clear)
pf.set_table_environment(None)
pf.config._buffered.clear()
def test_buffered_values_are_applied_to_the_lazily_created_environment(self):
pf.config.set("pipeline.name", "lazy-name")
created_environment = pf.get_or_create_table_environment()
self.assertEqual(
created_environment.get_config().get("pipeline.name", None), "lazy-name"
)
def test_table_creation_time_option_takes_effect(self):
# The built-in catalog is chosen when the TableEnvironment is instantiated, so the
# buffered value has to reach EnvironmentSettings rather than TableConfig afterwards.
pf.config.set("table.builtin-catalog-name", "my_catalog")
created_environment = pf.get_or_create_table_environment()
self.assertEqual(created_environment.get_current_catalog(), "my_catalog")
def test_set_is_rejected_while_an_environment_is_active(self):
pf.set_table_environment(self.t_env)
with self.assertRaisesRegex(RuntimeError, "before the table environment exists"):
pf.config.set("pipeline.name", "too-late")
self.assertEqual(pf.config._buffered, {})
self.assertIsNone(self.t_env.get_config().get("pipeline.name", None))
def test_set_is_allowed_again_after_the_environment_is_cleared(self):
pf.set_table_environment(self.t_env)
pf.set_table_environment(None)
pf.config.set("pipeline.name", "after-clear")
self.assertEqual(pf.config.get("pipeline.name"), "after-clear")
def test_injecting_an_environment_is_rejected_when_values_are_buffered(self):
pf.config.set("pipeline.name", "buffered-name")
with self.assertRaisesRegex(RuntimeError, "buffered values"):
pf.set_table_environment(self.t_env)
self.assertIsNone(pf.get_table_environment())
self.assertIsNone(self.t_env.get_config().get("pipeline.name", None))
def test_injected_environment_is_not_modified(self):
self.t_env.get_config().set("pipeline.name", "explicit")
pf.set_table_environment(self.t_env)
self.assertIs(pf.get_table_environment(), self.t_env)
self.assertEqual(self.t_env.get_config().get("pipeline.name", None), "explicit")
def test_clearing_the_environment_keeps_buffered_values(self):
pf.config.set("pipeline.name", "kept")
pf.get_or_create_table_environment()
pf.set_table_environment(None)
self.assertEqual(pf.config.get("pipeline.name"), "kept")
created_environment = pf.get_or_create_table_environment()
self.assertEqual(created_environment.get_config().get("pipeline.name", None), "kept")
def test_get_reads_from_the_active_environment(self):
pf.set_table_environment(self.t_env)
self.t_env.get_config().set("pipeline.name", "from-environment")
self.assertEqual(pf.config.get("pipeline.name"), "from-environment")
def test_get_returns_default_when_missing_from_the_active_environment(self):
pf.set_table_environment(self.t_env)
self.assertEqual(pf.config.get("pipeline.name", "fallback"), "fallback")
def test_runtime_mode_buffered_before_creation_takes_effect(self):
# The planner is chosen when the environment is instantiated, so a buffered
# runtime mode must be visible at creation time rather than applied afterwards.
pf.config.set("execution.runtime-mode", "batch")
created_environment = pf.get_or_create_table_environment()
table = created_environment.from_elements([(1, "a"), (2, "b")], ["id", "name"])
with table.execute().collect() as rows:
self.assertEqual(len(list(rows)), 2)
if __name__ == "__main__":
unittest.main()