rcdb 2.3.1__tar.gz → 2.4.0__tar.gz

{rcdb-2.3.1/rcdb.egg-info → rcdb-2.4.0}/PKG-INFO

@@ -1,9 +1,12 @@
 Metadata-Version: 2.4
 Name: rcdb
-Version: 2.3.1
+Version: 2.4.0
 Summary: RCDB - Run Conditions DataBase
 Author-email: Dmitry Romanov <romanov@jlab.org>
 License-Expression: MIT
+Project-URL: Homepage, https://github.com/JeffersonLab/rcdb
+Project-URL: Documentation, https://jeffersonlab.github.io/rcdb
+Project-URL: Repository, https://github.com/JeffersonLab/rcdb.git
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9

{rcdb-2.3.1 → rcdb-2.4.0}/pyproject.toml

@@ -50,8 +50,11 @@ dependencies = [
 examples = ["jsonpickle", "pandas"]
 dev = ["pyflakes>=3"]
 
+[project.urls]
+Homepage = "https://github.com/JeffersonLab/rcdb"
+Documentation = "https://jeffersonlab.github.io/rcdb"
+Repository = "https://github.com/JeffersonLab/rcdb.git"
 
-# If you want a console script, define it in [project.scripts]
 [project.scripts]
 rcdb = "rcdb.cli.app:rcdb_cli"
 

{rcdb-2.3.1 → rcdb-2.4.0}/rcdb/app_context.py

@@ -19,6 +19,18 @@ class RcdbApplicationContext(object):
             self._db_instance = RCDBProvider(self.connection_str)
         return self._db_instance
 
+    def close(self):
+        """Disconnect the database if one was opened.
+
+        Safe to call when no connection was ever made. The CLI registers this on
+        the Click context so the engine is disposed deterministically when the
+        command finishes, instead of waiting for garbage collection (which on
+        Python 3.13+ leaks a ``ResourceWarning: unclosed database``).
+        """
+        if self._db_instance is not None:
+            self._db_instance.close()
+            self._db_instance = None
+
     def require_connected_db(self) -> RCDBProvider:
         """Return the RCDBProvider, or fail with a clear CLI error if no connection was given.
 

{rcdb-2.3.1 → rcdb-2.4.0}/rcdb/cli/app.py

@@ -60,6 +60,12 @@ def rcdb_cli(ctx, user_config, connection, config, verbose):
     for key, value in config:
         ctx.obj.set_config(key, value)
 
+    # Dispose the DB engine deterministically when the command finishes, rather
+    # than leaving it to garbage collection. On Python 3.13+ a lingering, GC'd
+    # SQLite connection emits "ResourceWarning: unclosed database" at an
+    # unpredictable time, which can leak into command output captured by tests.
+    ctx.call_on_close(ctx.obj.close)
+
     # Bo commands given
     if ctx.invoked_subcommand is None:
         # There is a connection but no subcommand

{rcdb-2.3.1 → rcdb-2.4.0}/rcdb/cli/db.py

@@ -24,6 +24,7 @@ def db_command(ctx):
             print("ERROR connection string is missing.")
             exit(1)
         provider.connect(connection_str, check_version=False)
+        ctx.call_on_close(provider.close)
         query = select(SchemaVersion).order_by(SchemaVersion.version.desc())
         schema_version, = provider.session.execute(query).first()
         print("Schema version: {} - '{}'".format(schema_version.version, schema_version.comment))
@@ -88,6 +89,7 @@ def _print_sqlite_table_sizes(engine):
 @pass_rcdb_context
 def update(context):
     provider = RCDBProvider(context.connection_str, check_version=False)
+    click.get_current_context().call_on_close(provider.close)
 
     # Check something exists
     if not sqlalchemy.inspect(provider.engine).has_table(SchemaVersion.__tablename__):
@@ -117,6 +119,7 @@ def update(context):
         return
 
     provider = RCDBProvider(context.connection_str, check_version=False)
+    click.get_current_context().call_on_close(provider.close)
 
     # Create alias table
     Alias.__table__.create(provider.engine)
@@ -181,6 +184,7 @@ def init(context, drop_all, no_defaults, confirm, add_tests, add_cpp_tests):
     # That we will need for DB
     metadata = rcdb.model.Base.metadata
     provider = RCDBProvider(context.connection_str, check_version=False)
+    click.get_current_context().call_on_close(provider.close)
 
     # Drop all if needed
     if drop_all:

{rcdb-2.3.1 → rcdb-2.4.0}/rcdb/cli/rp.py

@@ -55,6 +55,7 @@ def add(context, name, description, run_min, run_max, start_date, end_date):
 
     provider = RCDBProvider()
     provider.connect(connection_str, check_version=False)
+    click.get_current_context().call_on_close(provider.close)
     session = provider.session
 
     # Convert date strings to Date objects if provided
@@ -104,6 +105,7 @@ def rm(context, period_id, yes):
 
     provider = RCDBProvider()
     provider.connect(connection_str, check_version=False)
+    click.get_current_context().call_on_close(provider.close)
     session = provider.session
 
     rp_item = session.query(RunPeriod).filter(RunPeriod.id == period_id).one_or_none()
@@ -142,6 +144,7 @@ def update(context, period_id, name, description, run_min, run_max, start_date,
 
     provider = RCDBProvider()
     provider.connect(connection_str, check_version=False)
+    click.get_current_context().call_on_close(provider.close)
     session = provider.session
 
     rp_item = session.query(RunPeriod).filter(RunPeriod.id == period_id).one_or_none()

{rcdb-2.3.1 → rcdb-2.4.0}/rcdb/provider.py

@@ -133,26 +133,51 @@ class RCDBProvider(object):
         self._connection_string = connection_string
 
         if check_version:
-            db_version = self.get_schema_version()
-            if db_version != rcdb.SQL_SCHEMA_VERSION:
-                message = "SQL schema version doesn't match. " \
-                          "Retrieved DB version is {0}, required version is {1}. " \
-                    .format(db_version, rcdb.SQL_SCHEMA_VERSION)
-                if db_version is not None and db_version < rcdb.SQL_SCHEMA_VERSION:
-                    message += "The database schema is older than this RCDB version. " \
-                               "Run 'rcdb db update' to migrate the database to the current schema."
-                else:
-                    message += "The database schema is newer than this RCDB version. " \
-                               "Update your RCDB installation to match the database."
-                raise rcdb.errors.SqlSchemaVersionError(message)
+            # This version query is the first statement that actually opens a
+            # DB connection. If it fails (unreachable host, access denied, wrong
+            # schema, ...) the engine/session we just built must be disposed
+            # here: the exception propagates out of connect()/__init__, so the
+            # caller never receives this provider to disconnect() it themselves,
+            # and the engine's open connection would otherwise leak until GC.
+            try:
+                db_version = self.get_schema_version()
+                if db_version != rcdb.SQL_SCHEMA_VERSION:
+                    message = "SQL schema version doesn't match. " \
+                              "Retrieved DB version is {0}, required version is {1}. " \
+                        .format(db_version, rcdb.SQL_SCHEMA_VERSION)
+                    if db_version is not None and db_version < rcdb.SQL_SCHEMA_VERSION:
+                        message += "The database schema is older than this RCDB version. " \
+                                   "Run 'rcdb db update' to migrate the database to the current schema."
+                    else:
+                        message += "The database schema is newer than this RCDB version. " \
+                                   "Update your RCDB installation to match the database."
+                    raise rcdb.errors.SqlSchemaVersionError(message)
+            except Exception:
+                self.close()
+                raise
 
     # ------------------------------------------------
     # Closes connection to data
     # ------------------------------------------------
-    def disconnect(self):
-        """Closes connection to database"""
+    def close(self):
+        """Closes connection to database.
+
+        Closes the ORM session and disposes the SQLAlchemy engine so the
+        underlying connection pool releases its DBAPI connections. Without the
+        ``engine.dispose()`` the pooled SQLite/MySQL connection stays open until
+        the engine is garbage collected, which on Python 3.13+ surfaces as a
+        ``ResourceWarning: unclosed database`` at an unpredictable time.
+        """
         self._is_connected = False
-        self.session.close()
+        if self.session is not None:
+            self.session.close()
+        if self.engine is not None:
+            self.engine.dispose()
+
+    # ``disconnect`` is the historical name for ``close``; kept as an alias so
+    # existing RCDB code and users keep working while new code standardizes on
+    # ``close()`` (the conventional name other resource-holding objects use).
+    disconnect = close
 
     # -------------------------------------------------
     # indicates ether the connection is open or not

{rcdb-2.3.1 → rcdb-2.4.0}/rcdb/version.py

@@ -1,5 +1,5 @@
 # String version. Used both for setup.py and for internal code
-version = '2.3.1'
+version = '2.4.0'
 
 # version as the tuple of ints
 version_tuple = tuple(int(val) for val in version.split('.'))

{rcdb-2.3.1 → rcdb-2.4.0}/rcdb/web/__init__.py

@@ -4,6 +4,7 @@ from datetime import datetime
 from urllib.parse import urlparse
 
 from flask import Flask, render_template, g, request, url_for
+from sqlalchemy.exc import SQLAlchemyError
 from sqlalchemy.orm import subqueryload
 
 import rcdb
@@ -60,8 +61,13 @@ app = Flask(__name__, template_folder=template_folder)
 
 app.config.from_object(__name__)
 
-@app.before_request
-def before_request():
+def _resolve_active_database():
+    """Pick the connection string for this request and expose selector state.
+
+    Sets ``g.active_db_name`` / ``g.available_databases`` (used by the navbar DB
+    selector) and returns the connection string to connect to. Does not touch
+    the database -- only reads config and the ``rcdb_database`` cookie.
+    """
     available_dbs = app.config.get("AVAILABLE_DATABASES", {})
 
     if available_dbs:
@@ -90,24 +96,93 @@ def before_request():
             # No default set, use first available
             active_name = next(iter(available_dbs))
 
-        connection_string = available_dbs[active_name]
         g.active_db_name = active_name
         g.available_databases = available_dbs
-    else:
-        # Original single-database behavior
-        connection_string = app.config["SQL_CONNECTION_STRING"]
-        g.active_db_name = None
-        g.available_databases = {}
-
-    g.tdb = rcdb.ConfigurationProvider()
-    g.tdb.connect(connection_string)
+        return available_dbs[active_name]
+
+    # Original single-database behavior
+    g.active_db_name = None
+    g.available_databases = {}
+    return app.config["SQL_CONNECTION_STRING"]
+
+
+@app.before_request
+def before_request():
+    # Never gate static assets on the database -- the graceful DB-error page
+    # below still needs its CSS/JS to load when the DB is unreachable.
+    if request.endpoint == "static":
+        return None
+
     app.jinja_env.globals['datetime_now'] = datetime.now
 
+    # Resolve the selector state first so the navbar (and the DB-error page)
+    # can render even if the connection below fails.
+    connection_string = _resolve_active_database()
+
+    # Connect fresh, per request. A DB access/connection failure (access
+    # denied, too many connections, timeout, host down, ...) must degrade
+    # gracefully instead of surfacing a raw 500 -- and must not poison any
+    # cookie or cached engine, so a later reload recovers once the DB is back.
+    try:
+        g.tdb = rcdb.ConfigurationProvider()
+        g.tdb.connect(connection_string)
+    except SQLAlchemyError:
+        return _render_db_error(connection_string)
+
+    return None
+
+
+def _render_db_error(connection_string):
+    """Log the full failure detail and render the sanitized DB-error page.
+
+    The *log* gets everything an admin needs (which database, the underlying
+    pymysql/SQLAlchemy error code + message, and the stack trace). The *page*
+    gets none of it -- no connection string, host, user, or exception text --
+    only a red "DB connection failure" strip with the top menu (and the DB
+    selector) intact so the visitor can switch to a working database.
+    """
+    logger.exception(
+        "DB connection/access failure for database '%s' (%s); serving graceful "
+        "error page instead of a 500.",
+        getattr(g, "active_db_name", None) or "<default>",
+        _connection_hint(connection_string),
+    )
+
+    # Drop the half-built provider so its engine/pool is released now rather
+    # than lingering as a broken cached connection -- the teardown below only
+    # disposes fully-connected providers.
+    broken = getattr(g, "tdb", None)
+    if broken is not None:
+        try:
+            broken.close()
+        except Exception:
+            logger.debug("Ignoring error while disposing failed DB engine.",
+                         exc_info=True)
+        g.tdb = None
+
+    # 503 Service Unavailable: the failure is transient-friendly (e.g. "too
+    # many connections" recovers), so signal a retryable condition rather than
+    # a 200 or a permanent error. A plain reload after recovery renders fine.
+    return render_template("db_error.html"), 503
+
+
+@app.errorhandler(SQLAlchemyError)
+def handle_db_error(error):
+    """Catch DB errors raised while a view runs (not just at connect time).
+
+    ``before_request`` already handles the common case (``connect()`` exercises
+    the connection via the schema-version check), but a lazily-issued query in
+    a view can still raise. Route those through the same graceful page instead
+    of a 500. ``g.active_db_name`` / ``g.available_databases`` were set by
+    ``before_request`` before the failure, so the selector still renders.
+    """
+    return _render_db_error(getattr(g.get("tdb", None), "connection_string", ""))
+
 
 @app.teardown_request
 def teardown_request(exception):
-    tdb = getattr(g, 'db', None)
-    if tdb:
+    tdb = getattr(g, 'tdb', None)
+    if tdb is not None:
         tdb.close()
 
 

{rcdb-2.3.1 → rcdb-2.4.0}/rcdb/web/modules/runs.py

@@ -157,8 +157,11 @@ def elog(run_number):
         from urllib.request import urlopen
         from urllib.error import HTTPError
     try:
-        elog_json = urlopen('https://logbooks.jlab.org/api/elog/entries?book=hdrun&title=Run_{}&limit=1'
-                            .format(run_number)).read()
+        # Context-manage the response so the underlying socket is closed
+        # deterministically instead of leaking until GC.
+        with urlopen('https://logbooks.jlab.org/api/elog/entries?book=hdrun&title=Run_{}&limit=1'
+                     .format(run_number)) as response:
+            elog_json = response.read()
     except HTTPError as e:
         return jsonify(stat=str(e.code))
 

{rcdb-2.3.1 → rcdb-2.4.0}/rcdb/web/modules/select_values.py

@@ -1,3 +1,5 @@
+import sys
+
 from flask import Blueprint, request, render_template, flash, g, redirect, url_for
 from sqlalchemy import desc
 
@@ -22,16 +24,21 @@ def index():
         # Handle search request
         search_query = request.args.get('q', '')
         run_range = request.args.get('rr', '')
-        req_conditions_values = req_conditions_str.split(',')
+        # Drop blanks so an empty field or trailing comma doesn't become a bogus condition name
+        req_conditions_values = [name.strip() for name in req_conditions_str.split(',') if name.strip()]
 
         if run_from_str or run_to_str:
             run_range = run_from_str + "-" + run_to_str
 
         run_from, run_to = _parse_run_range(run_range)
 
+        # An empty field means "no bound" - map it to the full run range the API expects
+        run_min = run_from if run_from is not None else 0
+        run_max = run_to if run_to is not None else sys.maxsize
+
         try:
-            table = g.tdb.select_values(val_names=req_conditions_values, search_str=search_query, run_min=run_from,
-                                        run_max=run_to, sort_desc=True)
+            table = g.tdb.select_values(val_names=req_conditions_values, search_str=search_query, run_min=run_min,
+                                        run_max=run_max, sort_desc=True)
         except Exception as err:
             flash("Error in performing request: {}".format(err), 'danger')
             return redirect(url_for('select_values.index'))

rcdb-2.4.0/rcdb/web/templates/db_error.html

@@ -0,0 +1,20 @@
+{% extends "layouts/base.html" %}
+
+{% block title %}Database unavailable{% endblock %}
+
+{#
+    Graceful page shown when the selected database cannot be reached or used
+    (access denied, too many connections, timeout, host down, ...). The top
+    menu -- including the database selector -- is inherited from base.html so
+    the visitor can switch to a working database and reload. No connection
+    string, host, user, or exception text is exposed here; the full detail is
+    written to the application log instead.
+#}
+
+{% block body %}
+    <div class="alert alert-danger"
+         role="alert"
+         style="text-align: center; font-weight: bold; margin-top: 20px;">
+        DB connection failure
+    </div>
+{% endblock %}

{rcdb-2.3.1 → rcdb-2.4.0}/rcdb/web/templates/select_values/index.html

@@ -10,7 +10,7 @@
 <div class="container">
 
     <div class="blog-header"><h3 class="blog-title">Custom table</h3></div>
-    <div class="hidden-table">
+    <div class="hidden-table hidden">
         <form id="condition-form">
             <table class="table condition-table">
                 <tr>
@@ -33,7 +33,12 @@
     </div>
     <div class="row">
         <div class="col-md-4">
-            <table class="table">
+            {% if table %}
+            <button id="export-csv-btn" type="button" class="btn btn-default btn-sm" style="margin-bottom: 10px;">
+                <span class="glyphicon glyphicon-download-alt" aria-hidden="true"></span> Export to CSV
+            </button>
+            {% endif %}
+            <table id="results-table" class="table">
                 <thead>
                     <tr>
                         <th>Run</th>
@@ -113,7 +118,50 @@
             });
         });
 
-        
+        // Wrap a CSV field in quotes when it contains a comma, quote or newline
+        function csvEscape(value) {
+            value = (value === null || value === undefined) ? '' : String(value);
+            if (/[",\n\r]/.test(value)) {
+                value = '"' + value.replace(/"/g, '""') + '"';
+            }
+            return value;
+        }
+
+        function tableToCsv(table) {
+            var lines = [];
+            var rows = table.querySelectorAll('tr');
+            for (var i = 0; i < rows.length; i++) {
+                var cells = rows[i].querySelectorAll('th, td');
+                var fields = [];
+                for (var j = 0; j < cells.length; j++) {
+                    fields.push(csvEscape(cells[j].textContent.trim()));
+                }
+                lines.push(fields.join(','));
+            }
+            return lines.join('\r\n');
+        }
+
+        function exportCsv() {
+            var table = document.getElementById('results-table');
+            if (!table) return;
+
+            var csv = tableToCsv(table);
+            var blob = new Blob([csv], {type: 'text/csv;charset=utf-8;'});
+            var url = URL.createObjectURL(blob);
+
+            var link = document.createElement('a');
+            link.href = url;
+            link.download = 'rcdb_select_values.csv';
+            document.body.appendChild(link);
+            link.click();
+            document.body.removeChild(link);
+            URL.revokeObjectURL(url);
+        }
+
+        var exportBtn = document.getElementById('export-csv-btn');
+        if (exportBtn) {
+            exportBtn.addEventListener('click', exportCsv);
+        }
 
     </script>
     {{ search_box.run_search_box_scripts(condition_types, run_periods) }}

{rcdb-2.3.1 → rcdb-2.4.0/rcdb.egg-info}/PKG-INFO

@@ -1,9 +1,12 @@
 Metadata-Version: 2.4
 Name: rcdb
-Version: 2.3.1
+Version: 2.4.0
 Summary: RCDB - Run Conditions DataBase
 Author-email: Dmitry Romanov <romanov@jlab.org>
 License-Expression: MIT
+Project-URL: Homepage, https://github.com/JeffersonLab/rcdb
+Project-URL: Documentation, https://jeffersonlab.github.io/rcdb
+Project-URL: Repository, https://github.com/JeffersonLab/rcdb.git
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9

{rcdb-2.3.1 → rcdb-2.4.0}/rcdb.egg-info/SOURCES.txt

@@ -155,6 +155,7 @@ rcdb/web/static/js/webintellisense-textbox.js
 rcdb/web/static/js/webintellisense.js
 rcdb/web/templates/404.html
 rcdb/web/templates/custom_column_run_table.html
+rcdb/web/templates/db_error.html
 rcdb/web/templates/default_run_table.html
 rcdb/web/templates/index.html
 rcdb/web/templates/layout.html
@@ -217,4 +218,5 @@ tests/test_save_files.py
 tests/test_select_runs.py
 tests/test_select_values.py
 tests/test_sql_schema_version.py
-tests/test_value_comparison.py
+tests/test_value_comparison.py
+tests/test_web_db_failure.py

rcdb-2.4.0/tests/test_web_db_failure.py

@@ -0,0 +1,119 @@
+"""Web DB-failure handling.
+
+A database selected in the navbar (stored in the ``rcdb_database`` cookie) may
+be unreachable or access-denied server-side (e.g. the MariaDB ``rcdb`` user has
+no GRANT on ``xem2``/``pionct`` -> pymysql ``(1044, "Access denied ...")``).
+
+These tests pin the required behaviour:
+
+* such a failure renders a graceful page (top menu + DB selector + a red
+  "DB connection failure" strip), never a raw 500;
+* no sensitive detail (connection string, host, user, error code/text) leaks
+  into the page, while the full exception is written to the application log;
+* the failure is not sticky -- reloading after the DB recovers, or switching to
+  a working DB, renders normally with no poisoned cookie or cached engine.
+"""
+
+import unittest
+
+from sqlalchemy.exc import OperationalError
+
+import rcdb
+import rcdb.provider
+import rcdb.web
+
+
+class TestWebDbFailure(unittest.TestCase):
+    def setUp(self):
+        self.app = rcdb.web.app
+        self.app.testing = True
+
+        # Save config we mutate so other tests see the app untouched.
+        self._saved = {k: self.app.config.get(k) for k in
+                       ("AVAILABLE_DATABASES", "DEFAULT_DATABASE")}
+        self.app.config["AVAILABLE_DATABASES"] = {
+            "good": "sqlite:///good",
+            "bad": "sqlite:///bad",
+        }
+        self.app.config["DEFAULT_DATABASE"] = "sqlite:///good"
+
+        self.client = self.app.test_client()
+
+        # Replace connect(): raise an access-denied-style OperationalError for the
+        # "bad" DB (while it is "down"); connect a fresh in-memory schema for the
+        # "good" one. ``bad_down`` flips to False to simulate recovery.
+        self.bad_down = True
+        self._orig_connect = rcdb.ConfigurationProvider.connect
+        test = self
+
+        def fake_connect(provider, connection_string="", check_version=True):
+            if "bad" in connection_string and test.bad_down:
+                raise OperationalError(
+                    "SELECT 1", {},
+                    Exception("(1044, \"Access denied for user 'rcdb'@'%' "
+                              "to database 'bad'\")"))
+            test._orig_connect(provider, "sqlite://", check_version=False)
+            rcdb.provider.destroy_all_create_schema(provider)
+
+        rcdb.ConfigurationProvider.connect = fake_connect
+
+    def tearDown(self):
+        rcdb.ConfigurationProvider.connect = self._orig_connect
+        for k, v in self._saved.items():
+            if v is None:
+                self.app.config.pop(k, None)
+            else:
+                self.app.config[k] = v
+
+    def _get(self, path="/", db=None):
+        # Fresh client per call so the cookie jar carries only what we set here
+        # (the Werkzeug test client ignores a raw Cookie header, hence set_cookie).
+        client = self.app.test_client()
+        if db:
+            client.set_cookie("rcdb_database", db)
+        return client.get(path)
+
+    def test_failure_renders_graceful_page_not_500(self):
+        with self.assertLogs("rcdb.web", level="ERROR") as cm:
+            resp = self._get("/", db="bad")
+
+        # Graceful, retryable status -- never a raw 500.
+        self.assertEqual(resp.status_code, 503)
+        self.assertNotEqual(resp.status_code, 500)
+
+        body = resp.get_data(as_text=True)
+        # Red strip + intact top menu incl. the DB selector to switch away.
+        self.assertIn("DB connection failure", body)
+        self.assertIn('id="dbSelector"', body)
+        self.assertIn(">bad<", body)
+        self.assertIn(">good<", body)
+
+        # No sensitive detail leaks into the page ...
+        for secret in ("1044", "Access denied", "sqlite:///bad", "rcdb@",
+                       "OperationalError", "Traceback"):
+            self.assertNotIn(secret, body)
+
+        # ... but the log has the full picture (db name + underlying error).
+        logtext = "\n".join(cm.output)
+        self.assertIn("bad", logtext)
+        self.assertIn("1044", logtext)
+
+    def test_reload_recovers_after_db_comes_back(self):
+        # Same cookie, DB down -> graceful 503.
+        self.assertEqual(self._get("/", db="bad").status_code, 503)
+
+        # DB recovers; a plain reload (identical cookie) must render normally.
+        self.bad_down = False
+        resp = self._get("/", db="bad")
+        self.assertEqual(resp.status_code, 200)
+        self.assertNotIn("DB connection failure", resp.get_data(as_text=True))
+
+    def test_switching_to_working_db_recovers(self):
+        self.assertEqual(self._get("/", db="bad").status_code, 503)
+        resp = self._get("/", db="good")
+        self.assertEqual(resp.status_code, 200)
+        self.assertNotIn("DB connection failure", resp.get_data(as_text=True))
+
+
+if __name__ == "__main__":
+    unittest.main()