def test_enabled_metrics(self):
"""Test streamlit.metrics.toggle_metrics enabled."""
config.set_option("global.metrics", True)
client = streamlit.metrics.Client.get_current()
client._metrics = {}
# yapf: disable
client._raw_metrics = [
('Counter', 'unittest_counter', 'Unittest counter', []),
('Counter', 'unittest_counter_labels', 'Unittest counter labels', ['label']),
('Gauge', 'unittest_gauge', 'Unittest gauge', []),
]
# yapf: enable
client.toggle_metrics()
client.get("unittest_counter").inc()
client.get("unittest_counter_labels").labels("some_label")
client.get("unittest_gauge").set(42)
truth = [
"unittest_counter_total 1.0",
'unittest_counter_labels_total{label="some_label"} 0.0',
"unittest_gauge 42.0",
]
lines = client.generate_latest().splitlines()
metrics = [
x.decode("utf-8") for x in lines
if x.decode("utf-8").startswith("unit")
]
metrics = [str(x) for x in metrics if "_created" not in x]
self.assertEqual(sorted(truth), sorted(metrics))
def test_get_set_and_complex_config_options(self):
"""Verify that changing one option changes another, dependent one.
This also implicitly tests simple and complex ConfigOptions as well as
get_option() and set_option().
"""
# Some useful variables.
DUMMY_VAL_1, DUMMY_VAL_2, DUMMY_VAL_3 = "Steven", "Vincent", "Buscemi"
# Set up both options.
config._create_option(
"_test.independentOption",
description="This option can change at will",
default_val=DUMMY_VAL_1,
)
@config._create_option("_test.dependentOption")
def _test_dependent_option():
"""Depend on the value of _test.independentOption."""
return config.get_option("_test.independentOption")
config.get_config_options(force_reparse=True)
# Check that the default values are good.
self.assertEqual(config.get_option("_test.independentOption"),
DUMMY_VAL_1)
self.assertEqual(config.get_option("_test.dependentOption"),
DUMMY_VAL_1)
self.assertEqual(
config.get_where_defined("_test.independentOption"),
ConfigOption.DEFAULT_DEFINITION,
)
self.assertEqual(
config.get_where_defined("_test.dependentOption"),
ConfigOption.DEFAULT_DEFINITION,
)
# Override the independent option. Both update!
config.set_option("_test.independentOption", DUMMY_VAL_2)
self.assertEqual(config.get_option("_test.independentOption"),
DUMMY_VAL_2)
self.assertEqual(config.get_option("_test.dependentOption"),
DUMMY_VAL_2)
self.assertEqual(config.get_where_defined("_test.independentOption"),
config._USER_DEFINED)
self.assertEqual(
config.get_where_defined("_test.dependentOption"),
ConfigOption.DEFAULT_DEFINITION,
)
# Override the dependent option. Only that updates!
config.set_option("_test.dependentOption", DUMMY_VAL_3)
self.assertEqual(config.get_option("_test.independentOption"),
DUMMY_VAL_2)
self.assertEqual(config.get_option("_test.dependentOption"),
DUMMY_VAL_3)
self.assertEqual(config.get_where_defined("_test.independentOption"),
config._USER_DEFINED)
self.assertEqual(config.get_where_defined("_test.dependentOption"),
config._USER_DEFINED)
def set_option(key, value):
"""Set config option.
Currently, only the following config options can be set within the script itself:
* client.caching
* client.displayEnabled
* deprecation.*
Calling with any other options will raise StreamlitAPIException.
Run `streamlit config show` in the terminal to see all available options.
Parameters
----------
key : str
The config option key of the form "section.optionName". To see all
available options, run `streamlit config show` on a terminal.
value
The new value to assign to this config option.
"""
opt = _config._config_options_template[key]
if opt.scriptable:
_config.set_option(key, value)
return
raise StreamlitAPIException(
"{key} cannot be set on the fly. Set as command line option, e.g. streamlit run script.py --{key}, or in config.toml instead.".format(
key=key
)
)
def test_auto_blacklist(self, _):
prev_blacklist = config.get_option("server.folderWatchBlacklist")
config.set_option("server.folderWatchBlacklist", [])
lso = LocalSourcesWatcher.LocalSourcesWatcher(REPORT, NOOP_CALLBACK)
def is_blacklisted(filepath):
return any(
_file_is_in_folder(filepath, blacklisted_folder)
for blacklisted_folder in lso._folder_blacklist
)
# miniconda, anaconda, and .*/ folders should be blacklisted
self.assertTrue(is_blacklisted("/foo/miniconda2/script.py"))
self.assertTrue(is_blacklisted("/foo/miniconda3/script.py"))
self.assertTrue(is_blacklisted("/foo/anaconda2/script.py"))
self.assertTrue(is_blacklisted("/foo/anaconda3/script.py"))
self.assertTrue(is_blacklisted("/foo/.virtualenv/script.py"))
self.assertTrue(is_blacklisted("/foo/.venv/script.py"))
self.assertTrue(is_blacklisted("/foo/.random_hidden_folder/script.py"))
# Ensure we're not accidentally blacklisting things we shouldn't be
self.assertFalse(is_blacklisted("/foo/not_blacklisted/script.py"))
self.assertFalse(is_blacklisted("/foo/not_blacklisted/.hidden_script.py"))
# Reset the config object.
config.set_option("server.folderWatchBlacklist", prev_blacklist)
def test_server_headless_via_atom_plugin(self):
os.environ["IS_RUNNING_IN_STREAMLIT_EDITOR_PLUGIN"] = "True"
config.set_option("server.liveSave", False)
self.assertEqual(True, config.get_option("server.headless"))
del os.environ["IS_RUNNING_IN_STREAMLIT_EDITOR_PLUGIN"]
def test_server_headless_via_atom_plugin(self):
os.environ['IS_RUNNING_IN_STREAMLIT_EDITOR_PLUGIN'] = 'True'
config.set_option('server.liveSave', False)
self.assertEqual(True, config.get_option('server.headless'))
del os.environ['IS_RUNNING_IN_STREAMLIT_EDITOR_PLUGIN']
def test_s3(self):
self.assertEqual(None, config.get_option('s3.secretAccessKey'))
self.assertEqual(None, config.get_option('s3.accessKeyId'))
self.assertEqual(None, config.get_option('s3.url'))
self.assertEqual(None, config.get_option('s3.bucket'))
with patch('streamlit.config._get_public_credentials') as p:
p.return_value = {}
config.set_option('global.sharingMode', 'streamlit-public')
self.assertEqual(None, config.get_option('s3.secretAccessKey'))
self.assertEqual(None, config.get_option('s3.accessKeyId'))
self.assertEqual(None, config.get_option('s3.url'))
self.assertEqual(None, config.get_option('s3.bucket'))
with patch('streamlit.config._get_public_credentials') as p:
p.return_value = {
'secretAccessKey': 'sekrit',
'accessKeyId': 'sekrit2',
'url': 'http://test.url',
'bucket': 'some.bucket',
}
config.set_option('global.sharingMode', 'streamlit-public')
self.assertEqual('sekrit', config.get_option('s3.secretAccessKey'))
self.assertEqual('sekrit2', config.get_option('s3.accessKeyId'))
self.assertEqual('http://test.url', config.get_option('s3.url'))
self.assertEqual('some.bucket', config.get_option('s3.bucket'))
def test_metrics(self):
config.set_option("global.metrics", False)
response = self.fetch("/metrics")
self.assertEqual(404, response.code)
config.set_option("global.metrics", True)
response = self.fetch("/metrics")
self.assertEqual(200, response.code)
def test_delete_option(self):
config.set_option("s3.bucket", "some.bucket")
config._delete_option("s3.bucket")
with pytest.raises(RuntimeError) as e:
config.get_option("s3.bucket")
self.assertEqual(str(e.value), 'Config key "s3.bucket" not defined.')
config._delete_option("s3.bucket")
def test_public_url(self, creds, static_files):
creds.return_value = {
'bucket': 'share.streamlit.io',
'url': 'https://share.streamlit.io/',
'accessKeyId': 'ACCESS_KEY_ID',
'secretAccessKey': 'SECRERT_ACCESS_KEY',
}
static_files.return_value = [('index.html', 'some data')], hashlib.md5()
set_option('global.sharingMode', 'streamlit-public')
s3 = S3Storage()
self.assertEqual(s3._url, 'https://share.streamlit.io/')
def test_enabled_metrics_no_prometheus(self):
"""Test streamlit.metrics.Client.toggle_metrics no prometheus."""
config.set_option("global.metrics", True)
client = streamlit.metrics.Client.get_current()
builtin_import = "builtins.__import__"
with pytest.raises(ImportError) as e:
with patch(builtin_import, side_effect=ImportError):
client.toggle_metrics()
msg = "prometheus-client is not installed. pip install prometheus-client"
self.assertEqual(msg, str(e.value))
def test_config_watcherType(self, _):
"""Test server.fileWatcherType"""
config.set_option("server.fileWatcherType", "none")
self.assertIsNone(local_sources_watcher.get_default_file_watcher_class())
config.set_option("server.fileWatcherType", "poll")
if local_sources_watcher.get_default_file_watcher_class() is not None:
self.assertEqual(
local_sources_watcher.get_default_file_watcher_class().__name__,
"PollingFileWatcher",
)
config.set_option("server.fileWatcherType", "watchdog")
if local_sources_watcher.get_default_file_watcher_class() is not None:
self.assertEqual(
local_sources_watcher.get_default_file_watcher_class().__name__,
"EventBasedFileWatcher",
)
config.set_option("server.fileWatcherType", "auto")
self.assertIsNotNone(local_sources_watcher.get_default_file_watcher_class())
if sys.modules["streamlit.watcher.event_based_file_watcher"] is not None:
self.assertEqual(
local_sources_watcher.get_default_file_watcher_class().__name__,
"EventBasedFileWatcher",
)
else:
self.assertEqual(
local_sources_watcher.get_default_file_watcher_class().__name__,
"PollingFileWatcher",
)
def test_enabled_metrics_no_prometheus(self):
"""Test streamlit.metrics.Client.toggle_metrics no prometheus."""
config.set_option('global.metrics', True)
client = streamlit.metrics.Client.get_current()
if sys.version_info <= (3, 0):
builtin_import = '__builtin__.__import__'
else:
builtin_import = 'builtins.__import__'
with pytest.raises(ImportError) as e:
with patch(builtin_import, side_effect=ImportError):
client.toggle_metrics()
msg = 'prometheus-client is not installed. pip install prometheus-client'
self.assertEqual(msg, str(e.value))
def test_credentials_headless_no_config(self):
"""If headless mode and no config is present,
activation should be None."""
from streamlit import config
config.set_option("server.headless", True)
with patch("validators.url", return_value=False), patch(
"streamlit.bootstrap.run"
), patch("os.path.exists", return_value=True), patch(
"streamlit.credentials._check_credential_file_exists", return_value=False
):
result = self.runner.invoke(cli, ["run", "some script.py"])
from streamlit.credentials import Credentials
credentials = Credentials.get_current()
self.assertIsNone(credentials.activation)
self.assertEqual(0, result.exit_code)
def test_private_url(self, static_files):
static_files.return_value = [("index.html", "some data")], hashlib.md5()
set_option("global.sharingMode", "s3")
set_option("s3.bucket", "buckets")
set_option("s3.accessKeyId", "ACCESS_KEY_ID")
set_option("s3.secretAccessKey", "SECRET_ACCESS_KEY")
s3 = S3Storage()
self.assertEqual(s3._url, None)
idx = s3._web_app_url.index("/", 8)
self.assertEqual(s3._web_app_url[0:idx], "https://buckets.s3.amazonaws.com")
def test_private_url(self, static_files):
static_files.return_value = [('index.html', 'some data')], hashlib.md5()
set_option('global.sharingMode', 's3')
set_option('s3.bucket', 'buckets')
set_option('s3.accessKeyId', 'ACCESS_KEY_ID')
set_option('s3.secretAccessKey', 'SECRET_ACCESS_KEY')
s3 = S3Storage()
self.assertEqual(s3._url, None)
idx = s3._web_app_url.index('/', 8)
self.assertEqual(s3._web_app_url[0:idx],
'https://buckets.s3.amazonaws.com')
def test_blacklist(self, fob):
prev_blacklist = config.get_option('server.folderWatchBlacklist')
config.set_option('server.folderWatchBlacklist',
[os.path.dirname(DUMMY_MODULE_1.__file__)])
lso = LocalSourcesWatcher.LocalSourcesWatcher(REPORT, CALLBACK)
fob.assert_called_once()
sys.modules['DUMMY_MODULE_1'] = DUMMY_MODULE_1
fob.reset_mock()
lso.update_watched_modules()
fob.assert_not_called()
# Reset the config object.
config.set_option('server.folderWatchBlacklist', prev_blacklist)
def test_unix_socket(self):
app = mock.MagicMock()
config.set_option("server.address", "unix://~/fancy-test/testasd")
some_socket = object()
mock_server = self.get_httpserver()
with patch(
"streamlit.server.server.HTTPServer",
return_value=mock_server), patch.object(
tornado.netutil,
"bind_unix_socket",
return_value=some_socket) as bind_unix_socket, patch.dict(
os.environ, {"HOME": "/home/superfakehomedir"}):
start_listening(app)
bind_unix_socket.assert_called_with(
"/home/superfakehomedir/fancy-test/testasd")
mock_server.add_socket.assert_called_with(some_socket)
def test_credentials_headless_with_config(self, headless_mode):
"""If headless, but a config file is present, activation should be
defined.
So we call `_check_activated`.
"""
from streamlit import config
config.set_option("server.headless", headless_mode)
with patch("validators.url", return_value=False), patch(
"streamlit.bootstrap.run"
), patch("os.path.exists", side_effect=[True, True]), mock.patch(
"streamlit.credentials.Credentials._check_activated"
) as mock_check, patch(
"streamlit.credentials._check_credential_file_exists", return_value=True
):
result = self.runner.invoke(cli, ["run", "some script.py"])
self.assertTrue(mock_check.called)
self.assertEqual(0, result.exit_code)
def test_disabled_metrics(self):
"""Test streamlit.metrics.Client.toggle_metrics disabled."""
config.set_option("global.metrics", False)
client = streamlit.metrics.Client.get_current()
client._metrics = {}
# yapf: disable
client._raw_metrics = [
('Counter', 'unittest_counter', 'Unittest counter', []),
('Counter', 'unittest_counter_labels', 'Unittest counter labels', ['label']),
('Gauge', 'unittest_gauge', 'Unittest gauge', []),
]
# yapf: enable
client.toggle_metrics()
client.get("unittest_counter").inc()
client.get("unittest_counter_labels").labels("some_label")
client.get("unittest_gauge").set(42)
client.get("unittest_gauge").dec()
def test_config_blacklist(self, fob, _):
"""Test server.folderWatchBlacklist"""
prev_blacklist = config.get_option("server.folderWatchBlacklist")
config.set_option("server.folderWatchBlacklist",
[os.path.dirname(DUMMY_MODULE_1.__file__)])
lso = local_sources_watcher.LocalSourcesWatcher(REPORT, NOOP_CALLBACK)
fob.assert_called_once()
sys.modules["DUMMY_MODULE_1"] = DUMMY_MODULE_1
fob.reset_mock()
lso.update_watched_modules()
fob.assert_not_called()
# Reset the config object.
config.set_option("server.folderWatchBlacklist", prev_blacklist)
def start_listening_tcp_socket(http_server):
call_count = 0
while call_count < MAX_PORT_SEARCH_RETRIES:
address = config.get_option("server.address")
port = config.get_option("server.port")
try:
http_server.listen(port, address)
break # It worked! So let's break out of the loop.
except (OSError, socket.error) as e:
if e.errno == errno.EADDRINUSE:
if server_port_is_manually_set():
LOGGER.error("Port %s is already in use", port)
sys.exit(1)
else:
LOGGER.debug(
"Port %s already in use, trying to use the next one.", port
)
port += 1
# Save port 3000 because it is used for the development
# server in the front end.
if port == 3000:
port += 1
config.set_option(
"server.port", port, ConfigOption.STREAMLIT_DEFINITION
)
call_count += 1
else:
raise
if call_count >= MAX_PORT_SEARCH_RETRIES:
raise RetriesExceeded(
"Cannot start Streamlit server. Port %s is already in use, and "
"Streamlit was unable to find a free port after %s attempts.",
port,
MAX_PORT_SEARCH_RETRIES,
)
def test_Credentials_activate(self, headless_mode):
"""Test Credentials.activate()"""
c = Credentials.get_current()
c.activation = None
config.set_option("server.headless", headless_mode)
with patch.object(
c, "load",
side_effect=RuntimeError("Some error")), patch.object(
c,
"save") as patched_save, patch(PROMPT) as patched_prompt:
patched_prompt.side_effect = ["*****@*****.**"]
c.activate()
patched_save.assert_called_once()
if headless_mode:
self.assertEqual(c.activation.email, "")
else:
self.assertEqual(c.activation.email, "*****@*****.**")
self.assertEqual(c.activation.is_valid, True)
def test_disabled_metrics_check_value(self):
"""Test streamlit.metrics.Client.toggle_metrics disabled check value."""
with patch("streamlit.metrics.MockMetric", spec=True) as mock_metric:
config.set_option("global.metrics", False)
client = streamlit.metrics.Client.get_current()
client._metrics = {}
# yapf: disable
client._raw_metrics = [
('Counter', 'unittest_counter', 'Unittest counter', []),
('Counter', 'unittest_counter_labels', 'Unittest counter labels', ['label']),
('Gauge', 'unittest_gauge', 'Unittest gauge', []),
]
# yapf: enable
client.toggle_metrics()
# Test that handler in Server.py will return nothing.
self.assertEqual(client.generate_latest(), "")
client.get("unittest_counter").inc()
client.get("unittest_counter_labels").labels("some_label")
client.get("unittest_gauge").set(42)
client.get("unittest_gauge").dec()
calls = [
call(), # Constructor
call(), # unittest_counter
call(), # unittest_counter_labels
call(), # unittest_gauge
call().inc(),
call().labels("some_label"),
call().set(42),
call().dec(),
]
self.assertEqual(calls, mock_metric.mock_calls)
def test_global_log_level(self):
config.set_option("global.developmentMode", False)
self.assertEqual("info", config.get_option("logger.level"))
def test_global_log_level_debug(self):
config.set_option("global.developmentMode", True)
self.assertEqual("debug", config.get_option("logger.level"))
def test_global_dev_mode(self):
config.set_option("global.developmentMode", True)
self.assertEqual(True, config.get_option("global.developmentMode"))
def test_server_headless_via_liveSave(self):
config.set_option("server.liveSave", True)
self.assertEqual(True, config.get_option("server.headless"))
def test_browser_server_port(self):
# developmentMode must be False for server.port to be modified
config.set_option("global.developmentMode", False)
config.set_option("server.port", 1234)
self.assertEqual(1234, config.get_option("browser.serverPort"))
def tearDown(self):
set_option("global.sharingMode", "off")
