Repository: datasciencecampus/synthgauge (language: python)

Issue:
Can't change colour of crosstab
Hi there, 

I recently used synthgauge as part of a gov hackathon, and thought it was fantastic - really useful package! Came across one small bug, where I couldn't change the colour of a crosstab plot, because the colorbar didn't reflect the update. I was passing in eg. `cmap='Blues'` to the `plot_crosstab` method, and as per the docs it passed through to `sns.heatmap`, but not to the colorbar alongside the plot. I think the key lines are these, where the `fig.colorbar` call can't be modified:

https://github.com/datasciencecampus/synthgauge/blob/28badf14f8537cab7f3c9fb7c83dd8039d4dc06b/src/synthgauge/plot.py#L445-L455

Simplest solution would probably be to just have `cmap` exposed as an argument with a default setting, but I guess you could also check if `cmap` is passed as part of `kwargs` and add it into the `fig.colorbar` call if so?

Thanks again for the great package!


Discussion / hints:
@cwthom - Many thanks for flagging this, and for the kind words about the package. We'll take a look.

Fix patch:
diff --git a/examples/demo_notebook.ipynb b/examples/demo_notebook.ipynb
index af5934a..02dc456 100644
--- a/examples/demo_notebook.ipynb
+++ b/examples/demo_notebook.ipynb
@@ -392,7 +392,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 576x288 with 3 Axes>"
       ]
@@ -898,9 +898,9 @@
    "hash": "e7c37ba80a6e54a3d63188245ab5de6a3e0d381993bcb1990a7020536fc2299e"
   },
   "kernelspec": {
-   "display_name": "synthgauge-dev",
+   "display_name": "sg-dev",
    "language": "python",
-   "name": "synthgauge-dev"
+   "name": "sg-dev"
   },
   "language_info": {
    "codemirror_mode": {
@@ -912,7 +912,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.3"
+   "version": "3.8.13"
   }
  },
  "nbformat": 4,
diff --git a/src/synthgauge/plot.py b/src/synthgauge/plot.py
index abcc443..7497f57 100644
--- a/src/synthgauge/plot.py
+++ b/src/synthgauge/plot.py
@@ -6,7 +6,7 @@
 import matplotlib.pyplot as plt
 import numpy as np
 import seaborn as sns
-from pandas import DataFrame, Index, concat, crosstab, cut
+from pandas import DataFrame, concat, crosstab, cut
 from pandas.core.dtypes.common import (
     is_categorical_dtype,
     is_numeric_dtype,
@@ -78,12 +78,12 @@ def plot_histograms(df, feats=None, groupby=None, figcols=2, figsize=None):
 
     """
 
-    if isinstance(feats, Index):
-        feats = feats
+    if feats is None:
+        feats = list(df.columns)
     elif isinstance(feats, str):
         feats = [feats]
     else:
-        feats = feats or df.columns
+        feats = feats
 
     n_rows = int(np.ceil(len(feats) / figcols))
     fig, axes = plt.subplots(n_rows, figcols, figsize=figsize)
@@ -446,9 +446,9 @@ def plot_crosstab(
     synth: pandas.DataFrame
         DataFrame containing the sythetic data.
     x: str
-        Feature to plot on x axis. Must be column in `df`.
+        Feature to plot on x axis. Must be in `real` and `synth`.
     y: str
-        Feature to plot on y axis. Must be column in `df`.
+        Feature to plot on y axis. Must be in `real` and `synth`.
     x_bins, y_bins: array_like or int or str, default='auto'
         If ``array_like`` must be sequence of bin edges. If ``int``, specifies
         the number of bins to use. If ``str``, specifies the method used to
@@ -507,7 +507,13 @@ def plot_crosstab(
         (freq_real, freq_synth), axes, ("REAL", "SYNTH")
     ):
         sns.heatmap(
-            freq, vmin=vmin, vmax=vmax, cmap=cmap, cbar=False, ax=ax, **kwargs
+            freq.T,
+            vmin=vmin,
+            vmax=vmax,
+            cmap=cmap,
+            cbar=False,
+            ax=ax,
+            **kwargs,
         )
         ax.set_title(title)
 
@@ -539,7 +545,8 @@ def plot_qq(real, synth, feature, n_quantiles=None, figsize=None):
     synth: pandas.DataFrame
         DataFrame containing the sythetic data.
     feature: str
-        Feature to plot.
+        Feature to plot. This feature must be a numeric attribute
+        present in `real` and `synth`.
     n_quantiles: int, optional
         Number of quantiles to calculate. If ``None`` (the default) and
         ``real[feature]`` has the same length as ``synth[feature]`` then
@@ -553,6 +560,13 @@ def plot_qq(real, synth, feature, n_quantiles=None, figsize=None):
     -------
     matplotlib.figure.Figure
     """
+
+    dtype = real[feature].dtype
+    if not is_numeric_dtype(dtype):
+        raise ValueError(
+            f"The feature to plot must be numeric not of type: {dtype}"
+        )
+
     if n_quantiles is None:
         if len(real[feature]) == len(synth[feature]):
             # Matching lengths do not require computing quantiles
@@ -629,12 +643,13 @@ def plot_feat_density_diff(
     matplotlib.axes._subplots.AxesSubplot
         The matplotlib axes containing the plot.
     """
-    if isinstance(feats, Index):
-        feats = feats
+
+    if feats is None:
+        feats = list(set(real.columns).intersection(synth.columns))
     elif isinstance(feats, str):
         feats = [feats]
     else:
-        feats = feats or real.columns
+        feats = feats
 
     if len(feats) == 1:
         diff_hist, diff_edges = feature_density_diff(
@@ -668,7 +683,7 @@ def plot_feat_density_diff(
     ax.set_ylabel(ylabel)
     ax.set_title(title)
 
-    return ax
+    return fig
 
 
 if __name__ == "__main__":


Test patch:
diff --git a/tests/test_plot.py b/tests/test_plot.py
index 3b28bfe..a0d893b 100644
--- a/tests/test_plot.py
+++ b/tests/test_plot.py
@@ -1,146 +1,475 @@
-""" Tests for plotting. """
+"""Property-based tests for plotting functions."""
 
+import matplotlib as mpl
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
 import pytest
-from matplotlib.figure import Figure
+from hypothesis import HealthCheck, given, settings
+from hypothesis import strategies as st
 from seaborn.axisgrid import JointGrid
 
+from synthgauge import plot
 from synthgauge.datasets import make_blood_types_df
-from synthgauge.plot import (
-    plot_correlation,
-    plot_crosstab,
-    plot_histogram3d,
-    plot_histograms,
-    plot_joint,
+
+from .utils import resolve_features
+
+available_columns = (
+    "age",
+    "height",
+    "weight",
+    "hair_colour",
+    "eye_colour",
+    "blood_type",
+)
+
+blood_type_feats = st.one_of(
+    st.none(),
+    st.sampled_from(available_columns),
+    st.lists(
+        st.sampled_from(available_columns), min_size=1, max_size=4, unique=True
+    ),
 )
 
+plot_settings = settings(
+    suppress_health_check=[HealthCheck.function_scoped_fixture],
+    max_examples=15,
+    deadline=None,
+)
+
+
+@st.composite
+def joint_params(draw):
+    """Get a valid set of joint-plot parameters. Recycled by the 3D
+    histogram and crosstab plot tests."""
+
+    x, y = draw(
+        st.lists(
+            st.sampled_from(available_columns),
+            min_size=2,
+            max_size=2,
+            unique=True,
+        )
+    )
+
+    remaining_columns = list(set(available_columns).difference({x, y}))
+    groupby = draw(st.one_of(st.none(), st.sampled_from(remaining_columns)))
+
+    return x, y, groupby
+
 
 @pytest.fixture
-def make_real():
-    """Real data."""
+def real():
+    """Make some real (noiseless) data."""
+
     return make_blood_types_df(0, 0)
 
 
 @pytest.fixture
-def make_synth():
-    """Synthetic data that differs from the real data."""
+def synth():
+    """Make some synthetic (noisy) data."""
+
     return make_blood_types_df(1, 0)
 
 
-def test_plot_hist(make_real):
-    """Check correct figure type returned with number of
-    axes matching number of columns in the DataFrame.
-    """
-    fig = plot_histograms(make_real)
-    assert isinstance(fig, Figure)
-    assert len(fig.axes) == len(make_real.columns)
+@given(
+    st.lists(st.text(min_size=1), min_size=1),
+    st.sampled_from(("x", "y")),
+    st.integers(1, 10),
+)
+@plot_settings
+def test_suggest_label_rotation(labels, axis, limit):
+    """Check that axis tick label rotation can be flagged correctly."""
 
+    _, ax = plt.subplots()
+    getattr(ax, f"set_{axis}ticks")(range(len(labels)))
+    getattr(ax, f"set_{axis}ticklabels")(labels)
 
-@pytest.mark.parametrize(
-    "x, y",
-    [("age", "height"), ("age", "eye_colour"), ("eye_colour", "hair_colour")],
-)
-def test_plot_joint(make_real, x, y):
-    """Check correct figure type returned with expected axes"""
-    fig = plot_joint(make_real, x, y)
+    rotate = plot.suggest_label_rotation(ax, axis, limit)
+    assert rotate is any(len(label) > limit for label in labels)
+
+
+@given(feats=blood_type_feats)
+@plot_settings
+def test_plot_histograms(real, feats):
+    """Check that a histogram (or set thereof) can be created from a dataset
+    regardless of its data types."""
+
+    columns = resolve_features(feats, real)
+    num_columns = len(columns)
+
+    fig = plot.plot_histograms(real, feats)
+    axes = fig.axes
+    num_axes = len(axes)
+
+    assert isinstance(fig, plt.Figure)
+
+    if num_columns % 2 == 0:
+        assert num_axes == num_columns
+    else:
+        assert num_axes == num_columns + 1
+        assert not axes[-1].has_data()
+
+    for col, ax in zip(columns, axes):
+
+        assert isinstance(ax, plt.Subplot)
+        assert ax.get_xlabel() == col
+        assert ax.get_ylabel().lower() == "count"
+
+        column = real[col]
+        xmin, xmax = ax.get_xlim()
+
+        if pd.api.types.is_numeric_dtype(column):
+            assert xmin < min(column) and xmax > max(column)
+        else:
+            assert (xmin, xmax) == (-0.5, column.nunique() - 0.5)
+
+
+@given(joint_params())
+@plot_settings
+def test_plot_joint(real, params):
+    """Check that a joint plot can be created from two columns of a
+    dataset."""
+
+    x, y, groupby = params
+
+    fig = plot.plot_joint(real, x, y, groupby=groupby)
+    ax, axx, axy = fig.ax_joint, fig.ax_marg_x, fig.ax_marg_y
 
-    # Check figure type
     assert isinstance(fig, JointGrid)
 
-    # # Check axes labels are as expected
-    assert fig.ax_joint.get_xlabel() == x
-    assert fig.ax_joint.get_ylabel() == y
+    assert isinstance(ax, plt.Subplot)
+    assert ax.get_xlabel() == x
+    assert ax.get_ylabel() == y
+    if groupby is None:
+        assert ax.get_legend() is None
+    else:
+        assert ax.get_legend().get_title().get_text() == groupby
 
+    for name, col in zip(("x", "y"), (x, y)):
+        column = real[col]
+        vmin, vmax = sorted(getattr(ax, f"get_{name}lim")())
 
-@pytest.mark.parametrize(
-    "x, y",
-    [("age", "height"), ("age", "eye_colour"), ("eye_colour", "hair_colour")],
-)
-def test_plot_hist3d_numeric(make_real, x, y):
-    """Check correct figure type returned with expected axes"""
-    fig = plot_histogram3d(make_real, x, y)
-
-    # Check figure type
-    assert isinstance(fig, Figure)
-
-    # Check axes labels are as expected
-    assert fig.axes[0].get_xlabel() == x
-    assert fig.axes[0].get_ylabel() == y
-
-
-@pytest.mark.parametrize(
-    "feats, method, plot_diff",
-    [
-        (None, "pearson", False),
-        (None, "pearson", True),
-        (["age", "height"], "spearman", False),
-        (["eye_colour", "hair_colour"], "cramers_v", False),
-    ],
-)
-def test_plot_correlation(make_real, make_synth, feats, method, plot_diff):
-    """Check correct figure type returned with correct number of axes."""
-    fig = plot_correlation(
-        make_real, make_synth, feats=feats, method=method, plot_diff=plot_diff
+        if pd.api.types.is_numeric_dtype(column):
+            assert vmin < min(column) and vmax > max(column)
+        else:
+            assert vmin, vmax == (-0.5, column.nunique() - 0.5)
+
+    assert isinstance(axx, plt.Subplot)
+    assert axx.get_xlabel() == x
+    assert axx.get_ylabel().lower() == "count"
+    assert axx.get_legend() is None
+
+    assert isinstance(axy, plt.Subplot)
+    assert axy.get_xlabel().lower() == "count"
+    assert axy.get_ylabel() == y
+    assert axy.get_legend() is None
+
+
+@given(joint_params())
+@plot_settings
+def test_plot_histogram3d(real, params):
+    """Check that a 3D histogram can be created from two columns of a
+    dataset."""
+
+    x, y, _ = params
+
+    fig = plot.plot_histogram3d(real, x, y)
+    ax = fig.axes[0]
+
+    assert isinstance(fig, plt.Figure)
+
+    assert (
+        str(ax.__class__)
+        == "<class 'matplotlib.axes._subplots.Axes3DSubplot'>"
     )
+    assert ax.get_title() == "3D Histogram"
+    assert ax.get_xlabel() == x
+    assert ax.get_ylabel() == y
+    assert ax.get_zlabel() == "$count$"
 
-    assert isinstance(fig, Figure)
-    assert len(fig.axes) == 4 if not plot_diff else 6
+    for name, col in zip(("x", "y"), (x, y)):
+        column = real[col]
+        vmin, vmax = sorted(getattr(ax, f"get_{name}lim")())
 
-    # Get features from first axis
-    ax0 = fig.axes[0]
-    x_labels = [label.get_text() for label in ax0.get_xticklabels()]
-    y_labels = [label.get_text() for label in ax0.get_xticklabels()]
+        if pd.api.types.is_numeric_dtype(column):
+            assert vmin < min(column) and vmax > max(column)
+        else:
+            assert vmin, vmax == (-0.5, column.nunique() - 0.5)
 
-    # Check feature lables match
-    assert x_labels == y_labels
 
-    # Check correct features used
-    if feats is None:
-        feats = make_real.columns
-    if method in ["pearson", "spearman"]:
-        expected_feats = (
-            make_real[feats].select_dtypes(include="number").columns
-        )
-    elif method == "cramers_v":
-        expected_feats = (
-            make_real[feats].select_dtypes(exclude="number").columns
+@given(method=st.sampled_from(("pearson", "spearman", "cramers_v")))
+@plot_settings
+def test_plot_correlation_methods(real, method):
+    """Check that a correlation heatmap can be created for a single
+    dataset with any of the implemented methods."""
+
+    fig = plot.plot_correlation(real, method=method)
+    ax, cbar = fig.axes
+
+    assert isinstance(fig, plt.Figure)
+    assert isinstance(ax, plt.Subplot)
+    assert isinstance(cbar, plt.Subplot)
+
+    assert ax.get_title() == "DataFrame 1 Correlation"
+    assert cbar.get_label() == "<colorbar>"
+
+    if method == "cramers_v":
+        columns = list(real.select_dtypes(exclude="number").columns)
+    else:
+        columns = list(real.select_dtypes(include="number").columns)
+
+    for col, xlab, ylab in zip(
+        columns, ax.get_xticklabels(), ax.get_yticklabels()
+    ):
+        assert {col, xlab.get_text(), ylab.get_text()} == {col}
+
+
+@given(method=st.sampled_from(("pearson", "spearman", "cramers_v")))
+@plot_settings
+def test_plot_correlation_method_errors(real, method):
+    """Check that a ValueError is raised if only categorical columns are
+    passed with a numeric correlation method or only numeric columns
+    with `cramers_v`. Also catches the `if` statement for when `feats`
+    is a single column."""
+
+    if method == "cramers_v":
+        column, match = "age", "^No categorical columns"
+    else:
+        column, match = "blood_type", "^No numeric columns"
+
+    with pytest.raises(ValueError, match=match):
+        _ = plot.plot_correlation(real, feats=column, method=method)
+
+
+@given(method=st.sampled_from(("pearson", "spearman", "cramers_v")))
+@plot_settings
+def test_plot_correlation_two_datasets(real, synth, method):
+    """Check that an array of correlation heatmaps can be produced when
+    two dataframes are passed."""
+
+    fig = plot.plot_correlation(real, synth, method=method)
+    rax, sax, rbar, sbar = fig.axes
+
+    assert isinstance(fig, plt.Figure)
+    assert all(isinstance(ax, plt.Subplot) for ax in fig.axes)
+    assert all(bar.get_label() == "<colorbar>" for bar in (rbar, sbar))
+
+    if method == "cramers_v":
+        columns = list(real.select_dtypes(exclude="number").columns)
+    else:
+        columns = list(real.select_dtypes(include="number").columns)
+
+    for i, ax in enumerate((rax, sax)):
+        assert ax.get_title() == f"DataFrame {i + 1} Correlation"
+        for col, xlab, ylab in zip(
+            columns, ax.get_xticklabels(), ax.get_yticklabels()
+        ):
+            assert {col, xlab.get_text(), ylab.get_text()} == {col}
+
+
+@given(method=st.sampled_from(("pearson", "spearman", "cramers_v")))
+@plot_settings
+def test_plot_correlation_difference(real, synth, method):
+    """Check that an additional heatmap can be produced for the
+    absolute difference between two correlation matrices."""
+
+    fig = plot.plot_correlation(real, synth, plot_diff=True, method=method)
+    rax, sax, dax, empty, rbar, sbar, dbar = fig.axes
+
+    assert isinstance(fig, plt.Figure)
+    assert all(isinstance(ax, plt.Subplot) for ax in fig.axes)
+    assert not empty.has_data()
+    assert all(bar.get_label() == "<colorbar>" for bar in (rbar, sbar, dbar))
+
+    dmin, dmax = dbar.get_ylim()
+    assert dmin == 0 and dmax <= abs(
+        max(rbar.get_ylim()) - min(sbar.get_ylim())
+    )
+
+    if method == "cramers_v":
+        columns = list(real.select_dtypes(exclude="number").columns)
+    else:
+        columns = list(real.select_dtypes(include="number").columns)
+
+    for i, ax in enumerate((rax, sax, dax)):
+        if ax is dax:
+            assert ax.get_title() == "Correlation Difference"
+        else:
+            assert ax.get_title() == f"DataFrame {i + 1} Correlation"
+
+        for col, xlab, ylab in zip(
+            columns, ax.get_xticklabels(), ax.get_yticklabels()
+        ):
+            assert {col, xlab.get_text(), ylab.get_text()} == {col}
+
+
+@given(params=joint_params())
+@plot_settings
+def test_plot_crosstab(real, synth, params):
+    """Check that an array of heatmaps can be produced correctly."""
+
+    x, y, _ = params
+    fig = plot.plot_crosstab(real, synth, x, y)
+    rax, sax, cbar = fig.axes
+
+    assert isinstance(fig, plt.Figure)
+    assert isinstance(cbar, plt.Axes)
+    assert rax.get_title() == "REAL" and sax.get_title() == "SYNTH"
+    assert cbar.get_label() == "<colorbar>"
+
+    for ax, data in zip((rax, sax), (real, synth)):
+        assert isinstance(ax, plt.Subplot)
+        assert ax.get_xlabel() == x
+        assert ax.get_ylabel() == y
+
+        total_count = sum(ax.collections[0]._A)
+        binning_error = sum(
+            pd.api.types.is_numeric_dtype(data[col]) for col in (x, y)
         )
-    assert expected_feats.to_list() == x_labels
+        nrows = len(data)
+        assert total_count in range(nrows - binning_error, nrows + 1)
 
 
-@pytest.mark.parametrize(
-    "feats, method,",
-    [
-        (["age", "height"], "cramers_v"),
-        (["eye_colour", "hair_colour"], "pearson"),
-    ],
+@given(
+    columns=st.lists(
+        st.sampled_from(("age", "height", "weight")),
+        unique=True,
+        min_size=2,
+        max_size=2,
+    )
+)
+@plot_settings
+def test_plot_crosstab_error(real, synth, columns):
+    """Check that a TypeError is thrown when neither binning method is
+    specified for a crosstab plot of two numeric columns."""
+
+    with pytest.raises(
+        TypeError, match="^`x_bins` and `y_bins` must not be None$"
+    ):
+        x, y = columns
+        _ = plot.plot_crosstab(real, synth, x, y, x_bins=None, y_bins=None)
+
+
+@given(
+    params=joint_params(),
+    cmap=st.sampled_from(("viridis", "ch:s=.25,rot=-.25", "light:coral")),
 )
-def test_plot_correlation_method(make_real, make_synth, feats, method):
-    """Check a ``ValueError`` is raised if an inappropriate correlation method
-    is used, e.g. Pearson with categorical variables."""
-    with pytest.raises(ValueError):
-        plot_correlation(make_real, make_synth, feats=feats, method=method)
-
-
-@pytest.mark.parametrize(
-    "x, y, x_bins, y_bins",
-    [
-        ("age", "height", "auto", "auto"),
-        ("eye_colour", "hair_colour", 5, 5),
-        ("height", "eye_colour", 10, "auto"),
-    ],
+@plot_settings
+def test_plot_crosstab_colour_palette(real, synth, params, cmap):
+    """Check that a colour palette (map) can be passed to a crosstab
+    plot correctly, following through to each heatmap and the colour
+    bar.
+
+    This test serves to cover this issue (#1) in the repository:
+        https://github.com/datasciencecampus/synthgauge/issues/1
+    """
+
+    x, y, _ = params
+    fig = plot.plot_crosstab(real, synth, x, y, cmap=cmap)
+    rax, sax, cbar = fig.axes
+
+    assert rax.collections[0].cmap is sax.collections[0].cmap
+    assert rax.collections[0].cmap is cbar.collections[-1].cmap
+
+
+@given(
+    feature=st.sampled_from(("age", "height", "weight")),
+    n_quantiles=st.one_of(st.none(), st.integers(2, 100)),
 )
-def test_plot_crosstab(make_real, make_synth, x, y, x_bins, y_bins):
-    """Check that ``plot_crosstab`` produces a ``Figure`` instance."""
-    fig = plot_crosstab(make_real, make_synth, x, y, x_bins, y_bins)
-    assert isinstance(fig, Figure)
+@plot_settings
+def test_plot_qq(real, synth, feature, n_quantiles):
+    """Check that a quantile-quantile plot can be created correctly for
+    two numeric columns."""
+
+    fig = plot.plot_qq(real, synth, feature, n_quantiles)
+    ax = fig.axes[0]
+
+    assert isinstance(fig, plt.Figure)
+    assert fig.axes == [ax]
+    assert isinstance(ax, plt.Subplot)
+
+    assert ax.get_xlabel() == "real data quantiles"
+    assert ax.get_ylabel() == "synth data quantiles"
+    assert ax.get_title() == f'Q-Q Plot for "{feature}"'
+
+    scatter = ax.collections[0]._offsets.data
+    line = ax.lines[0]._xy
+
+    assert (
+        len(scatter) == n_quantiles
+        if isinstance(n_quantiles, int)
+        else len(real)
+    )
+    for j, data in enumerate((real, synth)):
+
+        points = scatter[:, j]
+        assert np.min(points) == data[feature].min()
+        assert np.max(points) == data[feature].max()
+
+        if n_quantiles is None or n_quantiles == len(data):
+            assert np.array_equal(points, data[feature].sort_values())
 
+    expected_line_ends = [
+        min(real[feature].min(), synth[feature].min()),
+        max(real[feature].max(), synth[feature].max()),
+    ]
 
-@pytest.mark.parametrize(
-    "x, y, x_bins, y_bins",
-    [("age", "height", None, None), ("height", "eye_colour", None, "auto")],
+    assert np.array_equal(line[:, 0], line[:, 1])
+    assert np.array_equal(line[:, 0], expected_line_ends)
+
+
+@given(feature=st.sampled_from(("age", "height", "weight")))
+@plot_settings
+def test_plot_qq_unequal_lengths(real, synth, feature):
+    """Check that the "real" data length is preserved when the datasets
+    do not have the same number of rows and a number of quantiles is not
+    specified."""
+
+    synth = synth.iloc[:-1, :]
+    fig = plot.plot_qq(real, synth, feature)
+
+    assert len(fig.axes[0].collections[0]._offsets.data) == len(real)
+
+
+@given(feature=st.sampled_from(("blood_type", "eye_colour", "hair_colour")))
+@plot_settings
+def test_plot_qq_error_with_categorical_feature(real, synth, feature):
+    """Check that a ValueError is raised when `plot_qq()` is passed a
+    non-numeric feature."""
+
+    with pytest.raises(
+        ValueError,
+        match="^The feature to plot must be numeric not of type: category$",
+    ):
+        _ = plot.plot_qq(real, synth, feature)
+
+
+@given(
+    feats=blood_type_feats, fbins=st.integers(1, 10), dbins=st.integers(1, 10)
 )
-def test_plot_crosstab_bins(make_real, make_synth, x, y, x_bins, y_bins):
-    """Check that a ``TypeError`` is raised if a binning strategy is not
-    specified for a continuous variable."""
-    with pytest.raises(TypeError):
-        plot_crosstab(make_real, make_synth, x, y, x_bins, y_bins)
+@plot_settings
+def test_plot_feat_density_diff(real, synth, feats, fbins, dbins):
+    """Check that a feature density plot can be created correctly."""
+
+    columns = resolve_features(feats, real)
+    fig = plot.plot_feat_density_diff(real, synth, feats, fbins, dbins)
+    ax = fig.axes[0]
+    bars = ax.containers[0]
+
+    assert isinstance(fig, plt.Figure)
+    assert isinstance(ax, plt.Subplot)
+    assert isinstance(bars, mpl.container.BarContainer)
+
+    if len(columns) == 1:
+        column = columns[0]
+        assert ax.get_xlabel() == f"{column} Binned"
+        assert ax.get_ylabel() == "Density Difference"
+        assert ax.get_title() == f"Feature Density Difference for {column}"
+        assert len(bars) == fbins
+
+    else:
+        assert ax.get_xlabel() == "Difference Bins"
+        assert ax.get_ylabel() == "Count"
+        assert ax.get_title() == "Histogram of Density Differences"
+        assert len(bars) == dbins
diff --git a/tests/test_utils.py b/tests/test_utils.py
index 55316a0..c2761c6 100644
--- a/tests/test_utils.py
+++ b/tests/test_utils.py
@@ -8,7 +8,7 @@
 
 from synthgauge import utils
 
-from .utils import datasets
+from .utils import datasets, resolve_features
 
 
 @given(datasets(), st.one_of(st.none(), st.sampled_from(("a", ["a"]))))
@@ -19,12 +19,7 @@ def test_df_combine(datasets, feats):
     real, synth = datasets
     assume(not (real.empty or synth.empty))
 
-    if isinstance(feats, str):
-        columns = list([feats])
-    elif isinstance(feats, list):
-        columns = list(feats)
-    else:
-        columns = list(real.columns)
+    columns = resolve_features(feats, real)
 
     combined = utils.df_combine(real, synth, feats)
 
@@ -109,12 +104,7 @@ def test_cat_encode_categorical(datasets, feats):
     data, _ = datasets
     assume(not data.empty)
 
-    if isinstance(feats, str):
-        columns = [feats]
-    elif feats is None:
-        columns = list(data.columns)
-    else:
-        columns = list(feats)
+    columns = resolve_features(feats, data)
 
     out, cats = utils.cat_encode(data, feats)
 
@@ -215,6 +205,7 @@ def test_cat_encode_convert_only(datasets):
 
 
 @given(datasets(available_dtypes=("object",)), st.integers(1, 10))
+@settings(deadline=None)
 def test_feature_density_diff(datasets, bins):
     """Check that histogram-based density differences can be computed
     correctly. For the ease of testing, we only look at object (str)
diff --git a/tests/utils.py b/tests/utils.py
index c3dfd71..07842f1 100644
--- a/tests/utils.py
+++ b/tests/utils.py
@@ -8,6 +8,19 @@
 import synthgauge as sg
 
 
+def resolve_features(feats, data):
+    """Resolve the specified features so they are always a list."""
+
+    if isinstance(feats, str):
+        columns = list([feats])
+    elif isinstance(feats, list):
+        columns = list(feats)
+    else:
+        columns = list(data.columns)
+
+    return columns
+
+
 @st.composite
 def datasets(
     draw,