# -*- coding: utf-8; -*-

import datetime
import decimal
import functools
from unittest import TestCase
from unittest.mock import MagicMock, patch

from sqlalchemy import orm
from pyramid import testing
from pyramid.response import Response
from pyramid.httpexceptions import HTTPNotFound, HTTPFound
from webhelpers2.html import HTML

from wuttjamaican.conf import WuttaConfig
from wuttaweb.views import master as mod
from wuttaweb.views import View
from wuttaweb.progress import SessionProgress
from wuttaweb.subscribers import new_request_set_user
from wuttaweb.testing import WebTestCase, VersionWebTestCase
from wuttaweb.grids import Grid


class TestMasterView(WebTestCase):

    def make_view(self):
        return mod.MasterView(self.request)

    def test_defaults(self):
        with patch.multiple(
            mod.MasterView,
            create=True,
            model_name="Widget",
            model_key="uuid",
            deletable_bulk=True,
            has_autocomplete=True,
            downloadable=True,
            executable=True,
            configurable=True,
            mergeable=True,
            has_rows=True,
            rows_creatable=True,
        ):
            mod.MasterView.defaults(self.pyramid_config)

    ##############################
    # class methods
    ##############################

    def test_get_model_class(self):

        # no model class by default
        self.assertIsNone(mod.MasterView.get_model_class())

        # subclass may specify
        MyModel = MagicMock()
        with patch.multiple(mod.MasterView, create=True, model_class=MyModel):
            self.assertIs(mod.MasterView.get_model_class(), MyModel)

    def test_get_model_name(self):

        # error by default (since no model class)
        self.assertRaises(AttributeError, mod.MasterView.get_model_name)

        # subclass may specify model name
        with patch.multiple(mod.MasterView, create=True, model_name="Widget"):
            self.assertEqual(mod.MasterView.get_model_name(), "Widget")

        # or it may specify model class
        MyModel = MagicMock(__name__="Blaster")
        with patch.multiple(mod.MasterView, create=True, model_class=MyModel):
            self.assertEqual(mod.MasterView.get_model_name(), "Blaster")

    def test_get_model_name_normalized(self):

        # error by default (since no model class)
        self.assertRaises(AttributeError, mod.MasterView.get_model_name_normalized)

        # subclass may specify *normalized* model name
        with patch.multiple(
            mod.MasterView, create=True, model_name_normalized="widget"
        ):
            self.assertEqual(mod.MasterView.get_model_name_normalized(), "widget")

        # or it may specify *standard* model name
        with patch.multiple(mod.MasterView, create=True, model_name="Blaster"):
            self.assertEqual(mod.MasterView.get_model_name_normalized(), "blaster")

        # or it may specify model class
        MyModel = MagicMock(__name__="Dinosaur")
        with patch.multiple(mod.MasterView, create=True, model_class=MyModel):
            self.assertEqual(mod.MasterView.get_model_name_normalized(), "dinosaur")

    def test_get_model_title(self):

        # error by default (since no model class)
        self.assertRaises(AttributeError, mod.MasterView.get_model_title)

        # subclass may specify  model title
        with patch.multiple(mod.MasterView, create=True, model_title="Wutta Widget"):
            self.assertEqual(mod.MasterView.get_model_title(), "Wutta Widget")

        # or it may specify model name
        with patch.multiple(mod.MasterView, create=True, model_name="Blaster"):
            self.assertEqual(mod.MasterView.get_model_title(), "Blaster")

        # or it may specify model class
        MyModel = MagicMock(__name__="Dinosaur")
        with patch.multiple(mod.MasterView, create=True, model_class=MyModel):
            self.assertEqual(mod.MasterView.get_model_title(), "Dinosaur")

    def test_get_model_title_plural(self):

        # error by default (since no model class)
        self.assertRaises(AttributeError, mod.MasterView.get_model_title_plural)

        # subclass may specify *plural* model title
        with patch.multiple(mod.MasterView, create=True, model_title_plural="People"):
            self.assertEqual(mod.MasterView.get_model_title_plural(), "People")

        # or it may specify *singular* model title
        with patch.multiple(mod.MasterView, create=True, model_title="Wutta Widget"):
            self.assertEqual(mod.MasterView.get_model_title_plural(), "Wutta Widgets")

        # or it may specify model name
        with patch.multiple(mod.MasterView, create=True, model_name="Blaster"):
            self.assertEqual(mod.MasterView.get_model_title_plural(), "Blasters")

        # or it may specify model class
        MyModel = MagicMock(__name__="Dinosaur")
        with patch.multiple(mod.MasterView, create=True, model_class=MyModel):
            self.assertEqual(mod.MasterView.get_model_title_plural(), "Dinosaurs")

    def test_get_model_key(self):

        # error by default (since no model class)
        self.assertRaises(AttributeError, mod.MasterView.get_model_key)

        # subclass may specify model key
        with patch.multiple(mod.MasterView, create=True, model_key="uuid"):
            self.assertEqual(mod.MasterView.get_model_key(), ("uuid",))

    def test_get_route_prefix(self):

        # error by default (since no model class)
        self.assertRaises(AttributeError, mod.MasterView.get_route_prefix)

        # subclass may specify route prefix
        with patch.multiple(mod.MasterView, create=True, route_prefix="widgets"):
            self.assertEqual(mod.MasterView.get_route_prefix(), "widgets")

        # subclass may specify *normalized* model name
        with patch.multiple(
            mod.MasterView, create=True, model_name_normalized="blaster"
        ):
            self.assertEqual(mod.MasterView.get_route_prefix(), "blasters")

        # or it may specify *standard* model name
        with patch.multiple(mod.MasterView, create=True, model_name="Dinosaur"):
            self.assertEqual(mod.MasterView.get_route_prefix(), "dinosaurs")

        # or it may specify model class
        MyModel = MagicMock(__name__="Truck")
        with patch.multiple(mod.MasterView, create=True, model_class=MyModel):
            self.assertEqual(mod.MasterView.get_route_prefix(), "trucks")

    def test_get_permission_prefix(self):

        # error by default (since no model class)
        self.assertRaises(AttributeError, mod.MasterView.get_permission_prefix)

        # subclass may specify permission prefix
        with patch.object(
            mod.MasterView, "permission_prefix", new="widgets", create=True
        ):
            self.assertEqual(mod.MasterView.get_permission_prefix(), "widgets")

        # subclass may specify route prefix
        with patch.object(mod.MasterView, "route_prefix", new="widgets", create=True):
            self.assertEqual(mod.MasterView.get_permission_prefix(), "widgets")

        # or it may specify model class
        Truck = MagicMock(__name__="Truck")
        with patch.object(mod.MasterView, "model_class", new=Truck, create=True):
            self.assertEqual(mod.MasterView.get_permission_prefix(), "trucks")

    def test_get_url_prefix(self):

        # error by default (since no model class)
        self.assertRaises(AttributeError, mod.MasterView.get_url_prefix)

        # subclass may specify url prefix
        with patch.multiple(mod.MasterView, create=True, url_prefix="/widgets"):
            self.assertEqual(mod.MasterView.get_url_prefix(), "/widgets")

        # or it may specify route prefix
        with patch.multiple(mod.MasterView, create=True, route_prefix="trucks"):
            self.assertEqual(mod.MasterView.get_url_prefix(), "/trucks")

        # or it may specify *normalized* model name
        with patch.multiple(
            mod.MasterView, create=True, model_name_normalized="blaster"
        ):
            self.assertEqual(mod.MasterView.get_url_prefix(), "/blasters")

        # or it may specify *standard* model name
        with patch.multiple(mod.MasterView, create=True, model_name="Dinosaur"):
            self.assertEqual(mod.MasterView.get_url_prefix(), "/dinosaurs")

        # or it may specify model class
        MyModel = MagicMock(__name__="Machine")
        with patch.multiple(mod.MasterView, create=True, model_class=MyModel):
            self.assertEqual(mod.MasterView.get_url_prefix(), "/machines")

    def test_get_instance_url_prefix(self):

        # error by default (since no model class)
        self.assertRaises(AttributeError, mod.MasterView.get_instance_url_prefix)

        # typical example with url_prefix and simple key
        with patch.multiple(
            mod.MasterView, create=True, url_prefix="/widgets", model_key="uuid"
        ):
            self.assertEqual(
                mod.MasterView.get_instance_url_prefix(), "/widgets/{uuid}"
            )

        # typical example with composite key
        with patch.multiple(
            mod.MasterView, create=True, url_prefix="/widgets", model_key=("foo", "bar")
        ):
            self.assertEqual(
                mod.MasterView.get_instance_url_prefix(), "/widgets/{foo}|{bar}"
            )

    def test_get_template_prefix(self):

        # error by default (since no model class)
        self.assertRaises(AttributeError, mod.MasterView.get_template_prefix)

        # subclass may specify template prefix
        with patch.multiple(mod.MasterView, create=True, template_prefix="/widgets"):
            self.assertEqual(mod.MasterView.get_template_prefix(), "/widgets")

        # or it may specify url prefix
        with patch.multiple(mod.MasterView, create=True, url_prefix="/trees"):
            self.assertEqual(mod.MasterView.get_template_prefix(), "/trees")

        # or it may specify route prefix
        with patch.multiple(mod.MasterView, create=True, route_prefix="trucks"):
            self.assertEqual(mod.MasterView.get_template_prefix(), "/trucks")

        # or it may specify *normalized* model name
        with patch.multiple(
            mod.MasterView, create=True, model_name_normalized="blaster"
        ):
            self.assertEqual(mod.MasterView.get_template_prefix(), "/blasters")

        # or it may specify *standard* model name
        with patch.multiple(mod.MasterView, create=True, model_name="Dinosaur"):
            self.assertEqual(mod.MasterView.get_template_prefix(), "/dinosaurs")

        # or it may specify model class
        MyModel = MagicMock(__name__="Machine")
        with patch.multiple(mod.MasterView, create=True, model_class=MyModel):
            self.assertEqual(mod.MasterView.get_template_prefix(), "/machines")

    def test_get_grid_key(self):

        # error by default (since no model class)
        self.assertRaises(AttributeError, mod.MasterView.get_grid_key)

        # subclass may specify grid key
        with patch.multiple(mod.MasterView, create=True, grid_key="widgets"):
            self.assertEqual(mod.MasterView.get_grid_key(), "widgets")

        # or it may specify route prefix
        with patch.multiple(mod.MasterView, create=True, route_prefix="trucks"):
            self.assertEqual(mod.MasterView.get_grid_key(), "trucks")

        # or it may specify *normalized* model name
        with patch.multiple(
            mod.MasterView, create=True, model_name_normalized="blaster"
        ):
            self.assertEqual(mod.MasterView.get_grid_key(), "blasters")

        # or it may specify *standard* model name
        with patch.multiple(mod.MasterView, create=True, model_name="Dinosaur"):
            self.assertEqual(mod.MasterView.get_grid_key(), "dinosaurs")

        # or it may specify model class
        MyModel = MagicMock(__name__="Machine")
        with patch.multiple(mod.MasterView, create=True, model_class=MyModel):
            self.assertEqual(mod.MasterView.get_grid_key(), "machines")

    def test_get_config_title(self):

        # error by default (since no model class)
        self.assertRaises(AttributeError, mod.MasterView.get_config_title)

        # subclass may specify config title
        with patch.multiple(mod.MasterView, create=True, config_title="Widgets"):
            self.assertEqual(mod.MasterView.get_config_title(), "Widgets")

        # subclass may specify *plural* model title
        with patch.multiple(mod.MasterView, create=True, model_title_plural="People"):
            self.assertEqual(mod.MasterView.get_config_title(), "People")

        # or it may specify *singular* model title
        with patch.multiple(mod.MasterView, create=True, model_title="Wutta Widget"):
            self.assertEqual(mod.MasterView.get_config_title(), "Wutta Widgets")

        # or it may specify model name
        with patch.multiple(mod.MasterView, create=True, model_name="Blaster"):
            self.assertEqual(mod.MasterView.get_config_title(), "Blasters")

        # or it may specify model class
        MyModel = MagicMock(__name__="Dinosaur")
        with patch.multiple(mod.MasterView, create=True, model_class=MyModel):
            self.assertEqual(mod.MasterView.get_config_title(), "Dinosaurs")

    def test_get_row_model_class(self):
        model = self.app.model

        # no default
        self.assertIsNone(mod.MasterView.get_row_model_class())

        # class may specify
        with patch.object(
            mod.MasterView, "row_model_class", create=True, new=model.User
        ):
            self.assertIs(mod.MasterView.get_row_model_class(), model.User)

    def test_get_row_model_name(self):

        # error by default (since no model class)
        self.assertRaises(AttributeError, mod.MasterView.get_row_model_name)

        # may specify model name directly
        with patch.object(mod.MasterView, "row_model_name", new="Widget", create=True):
            self.assertEqual(mod.MasterView.get_row_model_name(), "Widget")

        # or indirectly via model class
        MyModel = MagicMock(__name__="Blaster")
        with patch.object(mod.MasterView, "row_model_class", new=MyModel):
            self.assertEqual(mod.MasterView.get_row_model_name(), "Blaster")

    def test_get_row_model_title(self):

        # error by default (since no model class)
        self.assertRaises(AttributeError, mod.MasterView.get_row_model_title)

        # may specify model title directly
        with patch.object(
            mod.MasterView, "row_model_title", new="Wutta Widget", create=True
        ):
            self.assertEqual(mod.MasterView.get_row_model_title(), "Wutta Widget")

        # or may specify model name
        with patch.object(mod.MasterView, "row_model_name", new="Blaster", create=True):
            self.assertEqual(mod.MasterView.get_row_model_title(), "Blaster")

        # or may specify model class
        MyModel = MagicMock(__name__="Dinosaur")
        with patch.object(mod.MasterView, "row_model_class", new=MyModel):
            self.assertEqual(mod.MasterView.get_row_model_title(), "Dinosaur")

        # model class may have wutta hint
        MyModel.__wutta_hint__ = {"model_title": "T-Rex"}
        with patch.object(mod.MasterView, "row_model_class", new=MyModel):
            self.assertEqual(mod.MasterView.get_row_model_title(), "T-Rex")

    def test_get_row_model_title_plural(self):

        # error by default (since no model class)
        self.assertRaises(AttributeError, mod.MasterView.get_row_model_title_plural)

        # subclass may specify *plural* model title
        with patch.object(
            mod.MasterView, "row_model_title_plural", new="People", create=True
        ):
            self.assertEqual(mod.MasterView.get_row_model_title_plural(), "People")

        # or it may specify *singular* model title
        with patch.object(
            mod.MasterView, "row_model_title", new="Wutta Widget", create=True
        ):
            self.assertEqual(
                mod.MasterView.get_row_model_title_plural(), "Wutta Widgets"
            )

        # or it may specify model name
        with patch.object(mod.MasterView, "row_model_name", new="Blaster", create=True):
            self.assertEqual(mod.MasterView.get_row_model_title_plural(), "Blasters")

        # or it may specify model class
        MyModel = MagicMock(__name__="Dinosaur")
        with patch.object(mod.MasterView, "row_model_class", new=MyModel, create=True):
            self.assertEqual(mod.MasterView.get_row_model_title_plural(), "Dinosaurs")

        # model class may have wutta hint
        MyModel.__wutta_hint__ = {"model_title_plural": "T-Rexes"}
        with patch.object(mod.MasterView, "row_model_class", new=MyModel):
            self.assertEqual(mod.MasterView.get_row_model_title_plural(), "T-Rexes")

    ##############################
    # support methods
    ##############################

    def test_get_class_hierarchy(self):
        class MyView(mod.MasterView):
            pass

        view = MyView(self.request)
        classes = view.get_class_hierarchy()
        self.assertEqual(classes, [View, mod.MasterView, MyView])

    def test_has_perm(self):
        model = self.app.model
        auth = self.app.get_auth_handler()

        with patch.multiple(mod.MasterView, create=True, model_name="Setting"):
            view = self.make_view()

            # anonymous user
            self.assertFalse(view.has_perm("list"))
            self.assertFalse(self.request.has_perm("list"))

            # reset
            del self.request.user_permissions

            # make user with perms
            barney = model.User(username="barney")
            self.session.add(barney)
            blokes = model.Role(name="Blokes")
            self.session.add(blokes)
            barney.roles.append(blokes)
            auth.grant_permission(blokes, "settings.list")
            self.session.commit()

            # this user has perms
            self.request.user = barney
            self.assertTrue(view.has_perm("list"))
            self.assertTrue(self.request.has_perm("settings.list"))

    def test_has_any_perm(self):
        model = self.app.model
        auth = self.app.get_auth_handler()

        with patch.multiple(mod.MasterView, create=True, model_name="Setting"):
            view = self.make_view()

            # anonymous user
            self.assertFalse(view.has_any_perm("list", "view"))
            self.assertFalse(
                self.request.has_any_perm("settings.list", "settings.view")
            )

            # reset
            del self.request.user_permissions

            # make user with perms
            barney = model.User(username="barney")
            self.session.add(barney)
            blokes = model.Role(name="Blokes")
            self.session.add(blokes)
            barney.roles.append(blokes)
            auth.grant_permission(blokes, "settings.view")
            self.session.commit()

            # this user has perms
            self.request.user = barney
            self.assertTrue(view.has_any_perm("list", "view"))
            self.assertTrue(self.request.has_any_perm("settings.list", "settings.view"))

    def test_make_button(self):
        view = self.make_view()

        # normal
        html = view.make_button("click me")
        self.assertIn("<b-button ", html)
        self.assertIn("click me", html)
        self.assertNotIn("is-primary", html)

        # primary as primary
        html = view.make_button("click me", primary=True)
        self.assertIn("<b-button ", html)
        self.assertIn("click me", html)
        self.assertIn("is-primary", html)

        # primary as variant
        html = view.make_button("click me", variant="is-primary")
        self.assertIn("<b-button ", html)
        self.assertIn("click me", html)
        self.assertIn("is-primary", html)

        # primary as type
        html = view.make_button("click me", type="is-primary")
        self.assertIn("<b-button ", html)
        self.assertIn("click me", html)
        self.assertIn("is-primary", html)

        # with url
        html = view.make_button("click me", url="http://example.com")
        self.assertIn('<b-button tag="a"', html)
        self.assertIn("click me", html)
        self.assertIn('href="http://example.com"', html)

    def test_make_progress(self):

        # basic
        view = self.make_view()
        self.request.session.id = "mockid"
        progress = view.make_progress("foo")
        self.assertIsInstance(progress, SessionProgress)

    def test_render_progress(self):
        self.pyramid_config.add_route("progress", "/progress/{key}")

        # sanity / coverage check
        view = self.make_view()
        progress = MagicMock()
        response = view.render_progress(progress)

    def test_render_to_response(self):
        self.pyramid_config.include("wuttaweb.views.common")
        self.pyramid_config.include("wuttaweb.views.auth")
        self.pyramid_config.add_route("appinfo", "/appinfo/")

        def widgets(request):
            return {}

        self.pyramid_config.add_route("widgets", "/widgets/")
        self.pyramid_config.add_view(widgets, route_name="widgets")

        # basic sanity check using /master/index.mako
        # (nb. it skips /widgets/index.mako since that doesn't exist)
        with patch.multiple(
            mod.MasterView, create=True, model_name="Widget", creatable=False
        ):
            view = mod.MasterView(self.request)
            response = view.render_to_response("index", {})
            self.assertIsInstance(response, Response)

        # basic sanity check using /appinfo/index.mako
        with patch.multiple(
            mod.MasterView,
            create=True,
            model_name="AppInfo",
            route_prefix="appinfo",
            url_prefix="/appinfo",
            creatable=False,
        ):
            view = mod.MasterView(self.request)
            response = view.render_to_response(
                "index",
                {
                    # nb. grid is required for this template
                    "grid": MagicMock(),
                },
            )
            self.assertIsInstance(response, Response)

        # bad template name causes error
        with patch.multiple(mod.MasterView, create=True, model_name="Widget"):
            self.assertRaises(IOError, view.render_to_response, "nonexistent", {})

    def test_get_index_title(self):
        with patch.multiple(
            mod.MasterView, create=True, model_title_plural="Wutta Widgets"
        ):
            view = mod.MasterView(self.request)
            self.assertEqual(view.get_index_title(), "Wutta Widgets")

    def test_get_index_url(self):
        self.pyramid_config.add_route("widgets", "/widgets")
        with patch.multiple(mod.MasterView, create=True, model_name="Widget"):

            # normal
            view = self.make_view()
            self.assertEqual(view.get_index_url(), "http://example.com/widgets")

            # list/index not supported
            view = self.make_view()
            view.listable = False
            self.assertIsNone(view.get_index_url())

    def test_collect_labels(self):

        # no labels by default
        view = self.make_view()
        labels = view.collect_labels()
        self.assertEqual(labels, {})

        # labels come from all classes; subclass wins
        with patch.object(
            View, "labels", new={"foo": "Foo", "bar": "Bar"}, create=True
        ):
            with patch.object(
                mod.MasterView, "labels", new={"foo": "FOO FIGHTERS"}, create=True
            ):
                view = self.make_view()
                labels = view.collect_labels()
                self.assertEqual(labels, {"foo": "FOO FIGHTERS", "bar": "Bar"})

    def test_set_labels(self):
        model = self.app.model
        with patch.object(
            mod.MasterView, "model_class", new=model.Setting, create=True
        ):

            # no labels by default
            view = self.make_view()
            grid = view.make_model_grid(session=self.session)
            view.set_labels(grid)
            self.assertEqual(grid.labels, {})

            # labels come from all classes; subclass wins
            with patch.object(
                mod.MasterView, "labels", new={"name": "SETTING NAME"}, create=True
            ):
                view = self.make_view()
                view.set_labels(grid)
                self.assertEqual(grid.labels, {"name": "SETTING NAME"})

    def test_make_model_grid(self):
        self.pyramid_config.add_route("settings.delete_bulk", "/settings/delete-bulk")
        self.pyramid_config.add_route("people.merge", "/people/merge")
        model = self.app.model

        with patch.object(mod.MasterView, "Session", return_value=self.session):

            # no model class
            with patch.multiple(
                mod.MasterView, create=True, model_name="Widget", model_key="uuid"
            ):
                view = self.make_view()
                grid = view.make_model_grid()
                self.assertIsNone(grid.model_class)

            # explicit model class
            with patch.multiple(mod.MasterView, create=True, model_class=model.Setting):
                view = self.make_view()
                grid = view.make_model_grid(session=self.session)
                self.assertIs(grid.model_class, model.Setting)

            # no row class by default
            with patch.multiple(mod.MasterView, create=True, model_class=model.Setting):
                view = self.make_view()
                grid = view.make_model_grid(session=self.session)
                self.assertIsNone(grid.row_class)

            # can specify row class
            get_row_class = MagicMock()
            with patch.multiple(
                mod.MasterView,
                create=True,
                model_class=model.Setting,
                grid_row_class=get_row_class,
            ):
                view = self.make_view()
                grid = view.make_model_grid(session=self.session)
                self.assertIs(grid.row_class, get_row_class)

            # no actions by default
            with patch.multiple(mod.MasterView, create=True, model_class=model.Setting):
                view = self.make_view()
                grid = view.make_model_grid(session=self.session)
                self.assertEqual(grid.actions, [])

            # now let's test some more actions logic
            with patch.multiple(
                mod.MasterView,
                create=True,
                model_class=model.Setting,
                viewable=True,
                editable=True,
                deletable=True,
            ):
                view = self.make_view()

                # should have 3 actions now, but for lack of perms
                grid = view.make_model_grid(session=self.session)
                self.assertEqual(len(grid.actions), 0)

                # but root user has perms, so gets 3 actions
                with patch.object(self.request, "is_root", new=True):
                    grid = view.make_model_grid(session=self.session)
                self.assertEqual(len(grid.actions), 3)

            # no tools by default
            with patch.multiple(mod.MasterView, create=True, model_class=model.Setting):
                view = self.make_view()
                grid = view.make_model_grid(session=self.session)
                self.assertEqual(grid.tools, {})

            # delete-results tool added if master/perms allow
            with patch.multiple(
                mod.MasterView,
                create=True,
                model_class=model.Setting,
                deletable_bulk=True,
            ):
                view = self.make_view()
                with patch.object(self.request, "is_root", new=True):
                    grid = view.make_model_grid(session=self.session)
                    self.assertIn("delete-results", grid.tools)

            # merge tool added if master/perms allow
            with patch.multiple(
                mod.MasterView,
                model_class=model.Person,
                route_prefix="people",
                mergeable=True,
                create=True,
            ):
                view = self.make_view()
                with patch.object(self.request, "is_root", new=True):
                    grid = view.make_model_grid()
                    self.assertIn("merge", grid.tools)

            # test checkable flag
            with patch.multiple(
                mod.MasterView,
                model_class=model.Person,
                route_prefix="people",
                create=True,
            ):
                view = self.make_view()

                # not checkable by default
                grid = view.make_model_grid()
                self.assertFalse(grid.checkable)

                # but can override
                grid = view.make_model_grid(checkable=True)
                self.assertTrue(grid.checkable)

                # checkable is true if merge allowed
                with patch.object(mod.MasterView, "mergeable", new=True):
                    with patch.object(self.request, "is_root", new=True):
                        grid = view.make_model_grid()
                        self.assertTrue(grid.checkable)

    def test_get_grid_data(self):
        model = self.app.model
        self.app.save_setting(self.session, "foo", "bar")
        self.session.commit()
        setting = self.session.query(model.Setting).one()
        view = self.make_view()

        # empty by default
        self.assertIsNone(mod.MasterView.model_class)
        data = view.get_grid_data(session=self.session)
        self.assertEqual(data, [])

        # grid with model class will produce data query
        with patch.multiple(mod.MasterView, create=True, model_class=model.Setting):
            view = mod.MasterView(self.request)
            query = view.get_grid_data(session=self.session)
            self.assertIsInstance(query, orm.Query)
            data = query.all()
            self.assertEqual(len(data), 1)
            self.assertIs(data[0], setting)

    def test_configure_grid(self):
        model = self.app.model

        # uuid field is pruned
        with patch.multiple(mod.MasterView, create=True, model_class=model.Setting):
            view = mod.MasterView(self.request)
            grid = view.make_grid(
                model_class=model.Setting, columns=["uuid", "name", "value"]
            )
            self.assertIn("uuid", grid.columns)
            view.configure_grid(grid)
            self.assertNotIn("uuid", grid.columns)

    def test_grid_render_bool(self):
        model = self.app.model
        view = self.make_view()
        user = model.User(username="barney", active=None)

        # null
        value = view.grid_render_bool(user, "active", None)
        self.assertIsNone(value)

        # true
        user.active = True
        value = view.grid_render_bool(user, "active", True)
        self.assertEqual(value, "Yes")

        # false
        user.active = False
        value = view.grid_render_bool(user, "active", False)
        self.assertEqual(value, "No")

    def test_grid_render_currency(self):
        view = self.make_view()
        obj = {"amount": None}

        # null
        value = view.grid_render_currency(obj, "amount", None)
        self.assertIsNone(value)

        # normal amount
        obj["amount"] = decimal.Decimal("100.42")
        value = view.grid_render_currency(obj, "amount", "100.42")
        self.assertEqual(value, "$100.42")

        # negative amount
        obj["amount"] = decimal.Decimal("-100.42")
        value = view.grid_render_currency(obj, "amount", "-100.42")
        self.assertEqual(value, "($100.42)")

    def test_grid_render_datetime(self):
        view = self.make_view()
        obj = {"dt": None}

        # null
        value = view.grid_render_datetime(obj, "dt", None)
        self.assertIsNone(value)

        # normal
        obj["dt"] = datetime.datetime(2024, 8, 24, 11)
        value = view.grid_render_datetime(obj, "dt", "2024-08-24T11:00:00")
        self.assertEqual(value, "2024-08-24 11:00:00 AM")

    def test_grid_render_enum(self):
        enum = self.app.enum
        view = self.make_view()
        obj = {"status": None}

        # null
        value = view.grid_render_enum(obj, "status", None, enum=enum.UpgradeStatus)
        self.assertIsNone(value)

        # normal
        obj["status"] = enum.UpgradeStatus.SUCCESS
        value = view.grid_render_enum(obj, "status", "SUCCESS", enum=enum.UpgradeStatus)
        self.assertEqual(value, "SUCCESS")

    def test_grid_render_notes(self):
        model = self.app.model
        view = self.make_view()

        # null
        text = None
        role = model.Role(name="Foo", notes=text)
        value = view.grid_render_notes(role, "notes", text)
        self.assertIsNone(value)

        # short string
        text = "hello world"
        role = model.Role(name="Foo", notes=text)
        value = view.grid_render_notes(role, "notes", text)
        self.assertEqual(value, text)

        # long string
        text = "hello world " * 20
        role = model.Role(name="Foo", notes=text)
        value = view.grid_render_notes(role, "notes", text)
        self.assertIn("<span ", value)

    def test_get_instance(self):
        model = self.app.model
        self.app.save_setting(self.session, "foo", "bar")
        self.session.commit()
        self.assertEqual(self.session.query(model.Setting).count(), 1)

        # default not implemented
        view = mod.MasterView(self.request)
        self.assertRaises(NotImplementedError, view.get_instance)

        # fetch from DB if model class is known
        with patch.multiple(mod.MasterView, create=True, model_class=model.Setting):
            view = mod.MasterView(self.request)

            # existing setting is returned
            self.request.matchdict = {"name": "foo"}
            setting = view.get_instance(session=self.session)
            self.assertIsInstance(setting, model.Setting)
            self.assertEqual(setting.name, "foo")
            self.assertEqual(setting.value, "bar")

            # missing setting not found
            self.request.matchdict = {"name": "blarg"}
            self.assertRaises(HTTPNotFound, view.get_instance, session=self.session)

    def test_get_action_route_kwargs(self):
        model = self.app.model
        with patch.object(
            mod.MasterView, "model_class", new=model.Setting, create=True
        ):
            view = self.make_view()

            # dict object
            setting = {"name": "foo", "value": "bar"}
            kw = view.get_action_route_kwargs(setting)
            self.assertEqual(kw, {"name": "foo"})

            # mapped object
            setting = model.Setting(name="foo", value="bar")
            kw = view.get_action_route_kwargs(setting)
            self.assertEqual(kw, {"name": "foo"})

            # non-standard object
            class MySetting:
                def __init__(self, **kw):
                    self.__dict__.update(kw)

            setting = MySetting(name="foo", value="bar")
            kw = view.get_action_route_kwargs(setting)
            self.assertEqual(kw, {"name": "foo"})

    def test_get_action_url_for_dict(self):
        model = self.app.model
        setting = {"name": "foo", "value": "bar"}
        with patch.multiple(mod.MasterView, create=True, model_class=model.Setting):
            mod.MasterView.defaults(self.pyramid_config)
            view = self.make_view()
            url = view.get_action_url_view(setting, 0)
            self.assertEqual(url, self.request.route_url("settings.view", name="foo"))

    def test_get_action_url_for_orm_object(self):
        model = self.app.model
        setting = model.Setting(name="foo", value="bar")
        self.session.add(setting)
        self.session.commit()
        with patch.multiple(mod.MasterView, create=True, model_class=model.Setting):
            mod.MasterView.defaults(self.pyramid_config)
            view = self.make_view()
            url = view.get_action_url_view(setting, 0)
            self.assertEqual(url, self.request.route_url("settings.view", name="foo"))

    def test_get_action_url_for_adhoc_object(self):
        model = self.app.model

        class MockSetting:
            def __init__(self, **kw):
                self.__dict__.update(kw)

        setting = MockSetting(name="foo", value="bar")
        with patch.multiple(mod.MasterView, create=True, model_class=model.Setting):
            mod.MasterView.defaults(self.pyramid_config)
            view = self.make_view()
            url = view.get_action_url_view(setting, 0)
            self.assertEqual(url, self.request.route_url("settings.view", name="foo"))

    def test_get_action_url_view(self):
        model = self.app.model
        setting = model.Setting(name="foo", value="bar")
        self.session.add(setting)
        self.session.commit()

        with patch.multiple(mod.MasterView, create=True, model_class=model.Setting):
            mod.MasterView.defaults(self.pyramid_config)
            view = self.make_view()
            url = view.get_action_url_view(setting, 0)
            self.assertEqual(url, self.request.route_url("settings.view", name="foo"))

    def test_get_action_url_edit(self):
        model = self.app.model
        setting = model.Setting(name="foo", value="bar")
        self.session.add(setting)
        self.session.commit()
        with patch.multiple(mod.MasterView, create=True, model_class=model.Setting):
            mod.MasterView.defaults(self.pyramid_config)
            view = self.make_view()

            # typical
            url = view.get_action_url_edit(setting, 0)
            self.assertEqual(url, self.request.route_url("settings.edit", name="foo"))

            # but null if instance not editable
            with patch.object(view, "is_editable", return_value=False):
                url = view.get_action_url_edit(setting, 0)
                self.assertIsNone(url)

    def test_get_action_url_delete(self):
        model = self.app.model
        setting = model.Setting(name="foo", value="bar")
        self.session.add(setting)
        self.session.commit()
        with patch.multiple(mod.MasterView, create=True, model_class=model.Setting):
            mod.MasterView.defaults(self.pyramid_config)
            view = self.make_view()

            # typical
            url = view.get_action_url_delete(setting, 0)
            self.assertEqual(url, self.request.route_url("settings.delete", name="foo"))

            # but null if instance not deletable
            with patch.object(view, "is_deletable", return_value=False):
                url = view.get_action_url_delete(setting, 0)
                self.assertIsNone(url)

    def test_make_model_form(self):
        model = self.app.model

        # no model class
        with patch.multiple(
            mod.MasterView, create=True, model_name="Widget", model_key="uuid"
        ):
            view = mod.MasterView(self.request)
            form = view.make_model_form()
            self.assertIsNone(form.model_class)

        # explicit model class
        with patch.multiple(mod.MasterView, create=True, model_class=model.Setting):
            form = view.make_model_form()
            self.assertIs(form.model_class, model.Setting)

    def test_configure_form(self):
        model = self.app.model

        # uuid field is pruned
        with patch.multiple(mod.MasterView, create=True, model_class=model.Setting):
            view = mod.MasterView(self.request)
            form = view.make_form(
                model_class=model.Setting, fields=["uuid", "name", "value"]
            )
            self.assertIn("uuid", form.fields)
            view.configure_form(form)
            self.assertNotIn("uuid", form.fields)

    def test_objectify(self):
        model = self.app.model
        self.app.save_setting(self.session, "foo", "bar")
        self.session.commit()
        self.assertEqual(self.session.query(model.Setting).count(), 1)

        # no model class
        with patch.multiple(
            mod.MasterView, create=True, model_name="Widget", model_key="uuid"
        ):
            view = mod.MasterView(self.request)
            form = view.make_model_form(fields=["name", "description"])
            form.validated = {"name": "first"}
            obj = view.objectify(form)
            self.assertEqual(obj, form.validated)

        # explicit model class (editing)
        with patch.multiple(
            mod.MasterView, create=True, model_class=model.Setting, editing=True
        ):
            form = view.make_model_form()
            form.validated = {"name": "foo", "value": "blarg"}
            form.model_instance = self.session.query(model.Setting).one()
            obj = view.objectify(form)
            self.assertIsInstance(obj, model.Setting)
            self.assertEqual(obj.name, "foo")
            self.assertEqual(obj.value, "blarg")

        # explicit model class (creating)
        with patch.multiple(
            mod.MasterView, create=True, model_class=model.Setting, creating=True
        ):
            form = view.make_model_form()
            form.validated = {"name": "another", "value": "whatever"}
            obj = view.objectify(form)
            self.assertIsInstance(obj, model.Setting)
            self.assertEqual(obj.name, "another")
            self.assertEqual(obj.value, "whatever")

    def test_persist(self):
        model = self.app.model
        with patch.multiple(mod.MasterView, create=True, model_class=model.Setting):
            view = mod.MasterView(self.request)

            # new instance is persisted
            setting = model.Setting(name="foo", value="bar")
            self.assertEqual(self.session.query(model.Setting).count(), 0)
            view.persist(setting, session=self.session)
            self.session.commit()
            setting = self.session.query(model.Setting).one()
            self.assertEqual(setting.name, "foo")
            self.assertEqual(setting.value, "bar")

    ##############################
    # view methods
    ##############################

    def test_index(self):
        self.pyramid_config.include("wuttaweb.views.common")
        self.pyramid_config.include("wuttaweb.views.auth")
        self.pyramid_config.add_route("settings.create", "/settings/new")
        self.pyramid_config.add_route("settings.view", "/settings/{name}")
        self.pyramid_config.add_route("settings.edit", "/settings/{name}/edit")
        self.pyramid_config.add_route("settings.delete", "/settings/{name}/delete")

        # sanity/coverage check using /settings/
        with patch.multiple(
            mod.MasterView,
            create=True,
            model_name="Setting",
            model_key="name",
            get_index_url=MagicMock(return_value="/settings/"),
            grid_columns=["name", "value"],
        ):
            view = mod.MasterView(self.request)
            response = view.index()

            # then again with data, to include view action url
            data = [{"name": "foo", "value": "bar"}]
            with patch.object(view, "get_grid_data", return_value=data):
                response = view.index()
                self.assertEqual(response.status_code, 200)
                self.assertEqual(response.content_type, "text/html")

                # then once more as 'partial' - aka. data only
                self.request.GET = {"partial": "1"}
                response = view.index()
                self.assertEqual(response.status_code, 200)
                self.assertEqual(response.content_type, "application/json")

                # redirects when view is reset
                self.request.GET = {"reset-view": "1", "hash": "foo"}
                with patch.object(self.request, "current_route_url"):
                    response = view.index()
                self.assertEqual(response.status_code, 302)

    def test_create(self):
        self.pyramid_config.include("wuttaweb.views.common")
        self.pyramid_config.include("wuttaweb.views.auth")
        self.pyramid_config.add_route("settings.view", "/settings/{name}")
        model = self.app.model

        # sanity/coverage check using /settings/new
        with patch.multiple(
            mod.MasterView,
            create=True,
            model_name="Setting",
            model_key="name",
            get_index_url=MagicMock(return_value="/settings/"),
            form_fields=["name", "value"],
        ):
            view = mod.MasterView(self.request)

            # no setting yet
            self.assertIsNone(self.app.get_setting(self.session, "foo.bar"))

            # get the form page
            response = view.create()
            self.assertIsInstance(response, Response)
            self.assertEqual(response.status_code, 200)
            # self.assertIn('frazzle', response.text)
            # nb. no error
            self.assertNotIn("Required", response.text)

            def persist(setting):
                self.app.save_setting(self.session, setting["name"], setting["value"])
                self.session.commit()

            # post request to save setting
            self.request.method = "POST"
            self.request.POST = {
                "name": "foo.bar",
                "value": "fraggle",
            }
            with patch.object(view, "persist", new=persist):
                response = view.create()
            # nb. should get redirect back to view page
            self.assertEqual(response.status_code, 302)
            # setting should now be in DB
            self.assertEqual(self.app.get_setting(self.session, "foo.bar"), "fraggle")

            # try another post with invalid data (value is required)
            self.request.method = "POST"
            self.request.POST = {}
            with patch.object(view, "persist", new=persist):
                response = view.create()
            # nb. should get a form with errors
            self.assertEqual(response.status_code, 200)
            self.assertIn("Required", response.text)
            # setting did not change in DB
            self.assertEqual(self.app.get_setting(self.session, "foo.bar"), "fraggle")

            # post again to save setting
            with patch.multiple(
                self.request,
                method="POST",
                POST={
                    "name": "foo.bar",
                    "value": "friggle",
                },
            ):
                with patch.object(view, "persist", new=persist):
                    response = view.create()
                    self.assertIsInstance(response, HTTPFound)
                    self.assertFalse(self.request.session.peek_flash("error"))
                    self.assertEqual(
                        self.app.get_setting(self.session, "foo.bar"), "friggle"
                    )

            # and this time force an error on save
            with patch.multiple(
                self.request,
                method="POST",
                POST={"name": "foo.bar", "value": "froooooggle"},
            ):
                with patch.object(
                    view, "save_create_form", side_effect=RuntimeError("testing")
                ):
                    response = view.create()
                    self.assertEqual(response.status_code, 200)
                    # nb. flash error is already gone, b/c template is rendered
                    self.assertFalse(self.request.session.peek_flash("error"))
                    self.assertEqual(
                        self.app.get_setting(self.session, "foo.bar"), "friggle"
                    )

    def test_view(self):
        self.pyramid_config.include("wuttaweb.views.common")
        self.pyramid_config.include("wuttaweb.views.auth")
        self.pyramid_config.add_route("settings.create", "/settings/new")
        self.pyramid_config.add_route("settings.edit", "/settings/{name}/edit")
        self.pyramid_config.add_route("settings.delete", "/settings/{name}/delete")

        # sanity/coverage check using /settings/XXX
        setting = {"name": "foo.bar", "value": "baz"}
        self.request.matchdict = {"name": "foo.bar"}
        with patch.multiple(
            mod.MasterView,
            create=True,
            model_name="Setting",
            model_key="name",
            get_index_url=MagicMock(return_value="/settings/"),
            grid_columns=["name", "value"],
            form_fields=["name", "value"],
        ):
            view = mod.MasterView(self.request)
            with patch.object(view, "get_instance", return_value=setting):
                response = view.view()

    def test_view_with_rows(self):
        self.pyramid_config.include("wuttaweb.views.common")
        self.pyramid_config.include("wuttaweb.views.auth")
        self.pyramid_config.add_route("people", "/people/")
        model = self.app.model
        person = model.Person(full_name="Whitney Houston")
        self.session.add(person)
        user = model.User(username="whitney", person=person)
        self.session.add(user)
        self.session.commit()

        get_row_grid_data = MagicMock()
        with patch.multiple(
            mod.MasterView,
            create=True,
            Session=MagicMock(return_value=self.session),
            model_class=model.Person,
            route_prefix="people",
            has_rows=True,
            row_model_class=model.User,
            get_row_grid_data=get_row_grid_data,
        ):
            with patch.object(self.request, "matchdict", new={"uuid": person.uuid}):
                view = self.make_view()

                # just for coverage
                get_row_grid_data.return_value = []
                response = view.view()
                self.assertEqual(response.status_code, 200)
                self.assertEqual(response.content_type, "text/html")

                # now with data...
                get_row_grid_data.return_value = [user]
                response = view.view()
                self.assertEqual(response.status_code, 200)
                self.assertEqual(response.content_type, "text/html")

                # then once more as 'partial' - aka. data only
                with patch.dict(self.request.GET, {"partial": 1}):
                    response = view.view()
                    self.assertEqual(response.status_code, 200)
                    self.assertEqual(response.content_type, "application/json")

                # redirects when view is reset
                with patch.dict(self.request.GET, {"reset-view": "1", "hash": "foo"}):
                    # nb. mock current route
                    with patch.object(self.request, "current_route_url"):
                        response = view.view()
                        self.assertEqual(response.status_code, 302)

    def test_edit(self):
        self.pyramid_config.include("wuttaweb.views.common")
        self.pyramid_config.include("wuttaweb.views.auth")
        self.pyramid_config.add_route("settings.create", "/settings/new")
        self.pyramid_config.add_route("settings.view", "/settings/{name}")
        self.pyramid_config.add_route("settings.delete", "/settings/{name}/delete")
        model = self.app.model
        self.app.save_setting(self.session, "foo.bar", "frazzle")
        self.session.commit()

        def get_instance():
            setting = self.session.get(model.Setting, "foo.bar")
            return {
                "name": setting.name,
                "value": setting.value,
            }

        # sanity/coverage check using /settings/XXX/edit
        self.request.matchdict = {"name": "foo.bar"}
        with patch.multiple(
            mod.MasterView,
            create=True,
            # nb. not actually using the model_class here
            model_name="Setting",
            model_key="name",
            get_index_url=MagicMock(return_value="/settings/"),
            form_fields=["name", "value"],
        ):
            view = mod.MasterView(self.request)
            with patch.object(view, "get_instance", new=get_instance):

                # get the form page
                response = view.edit()
                self.assertIsInstance(response, Response)
                self.assertEqual(response.status_code, 200)
                self.assertIn("frazzle", response.text)
                # nb. no error
                self.assertNotIn("Required", response.text)

                def persist(setting):
                    self.app.save_setting(self.session, "foo.bar", setting["value"])
                    self.session.commit()

                # post request to save settings
                with patch.multiple(
                    self.request,
                    method="POST",
                    POST={"name": "foo.bar", "value": "froogle"},
                ):
                    with patch.object(view, "persist", new=persist):
                        response = view.edit()
                        self.assertIsInstance(response, HTTPFound)
                        self.assertEqual(
                            response.location, "http://example.com/settings/foo.bar"
                        )
                        # setting is saved in DB
                        self.assertEqual(
                            self.app.get_setting(self.session, "foo.bar"), "froogle"
                        )

                # try another post with invalid data (value is required)
                with patch.multiple(self.request, method="POST", POST={}):
                    with patch.object(view, "persist", new=persist):
                        response = view.edit()
                    # nb. should get a form with errors
                    self.assertEqual(response.status_code, 200)
                    self.assertIn("Required", response.text)
                    # setting did not change in DB
                    self.assertEqual(
                        self.app.get_setting(self.session, "foo.bar"), "froogle"
                    )

                # once more with forced error
                with patch.multiple(
                    self.request,
                    method="POST",
                    POST={
                        "name": "foo.bar",
                        "value": "froooooggle",
                    },
                ):
                    with patch.object(
                        view, "save_edit_form", side_effect=RuntimeError("testing")
                    ):
                        response = view.edit()
                        self.assertEqual(response.status_code, 200)
                        # nb. flash error is already gone, b/c template is rendered
                        self.assertFalse(self.request.session.peek_flash("error"))
                        # setting did not change in DB
                        self.assertEqual(
                            self.app.get_setting(self.session, "foo.bar"), "froogle"
                        )

    def test_delete(self):
        self.pyramid_config.include("wuttaweb.views.common")
        self.pyramid_config.include("wuttaweb.views.auth")
        self.pyramid_config.add_route("settings.create", "/settings/new")
        self.pyramid_config.add_route("settings.view", "/settings/{name}")
        self.pyramid_config.add_route("settings.edit", "/settings/{name}/edit")
        model = self.app.model
        self.app.save_setting(self.session, "foo.bar", "frazzle")
        self.app.save_setting(self.session, "another", "fun-value")
        self.session.commit()
        self.assertEqual(self.session.query(model.Setting).count(), 2)

        def get_instance():
            name = self.request.matchdict["name"]
            setting = self.session.get(model.Setting, name)
            if not setting:
                raise view.notfound()
            return {
                "name": setting.name,
                "value": setting.value,
            }

        # sanity/coverage check using /settings/XXX/delete
        with patch.multiple(
            mod.MasterView,
            create=True,
            model_name="Setting",
            model_key="name",
            get_index_url=MagicMock(return_value="/settings/"),
            form_fields=["name", "value"],
        ):
            view = mod.MasterView(self.request)
            with patch.object(view, "get_instance", new=get_instance):

                # get the form page
                with patch.object(self.request, "matchdict", new={"name": "foo.bar"}):
                    response = view.delete()
                    self.assertIsInstance(response, Response)
                    self.assertEqual(response.status_code, 200)
                    self.assertIn("frazzle", response.text)

                def delete_instance(setting):
                    self.app.delete_setting(self.session, setting["name"])

                with patch.multiple(
                    self.request, matchdict={"name": "foo.bar"}, method="POST", POST={}
                ):
                    with patch.object(view, "delete_instance", new=delete_instance):

                        # enforces "instance not deletable" rules
                        with patch.object(view, "is_deletable", return_value=False):
                            response = view.delete()
                        # nb. should get redirect back to view page
                        self.assertEqual(response.status_code, 302)
                        # setting remains in DB
                        self.assertEqual(self.session.query(model.Setting).count(), 2)

                        # post request to delete setting
                        response = view.delete()
                        # nb. should get redirect back to view page
                        self.assertEqual(response.status_code, 302)
                        # setting should be gone from DB
                        self.assertEqual(self.session.query(model.Setting).count(), 1)

                # try to delete 2nd setting, but force an error
                with patch.multiple(
                    self.request, matchdict={"name": "another"}, method="POST", POST={}
                ):
                    with patch.object(
                        view, "save_delete_form", side_effect=RuntimeError("testing")
                    ):
                        response = view.delete()
                        self.assertEqual(response.status_code, 200)
                        # nb. flash error is already gone, b/c template is rendered
                        self.assertFalse(self.request.session.peek_flash("error"))
                        # setting is still in DB
                        self.assertEqual(self.session.query(model.Setting).count(), 1)
                        self.assertEqual(
                            self.app.get_setting(self.session, "another"), "fun-value"
                        )

    def test_delete_instance(self):
        model = self.app.model
        self.app.save_setting(self.session, "foo.bar", "frazzle")
        self.session.commit()
        setting = self.session.query(model.Setting).one()

        with patch.multiple(
            mod.MasterView,
            create=True,
            model_class=model.Setting,
            form_fields=["name", "value"],
        ):
            view = mod.MasterView(self.request)
            view.delete_instance(setting)
            self.session.commit()
            self.assertEqual(self.session.query(model.Setting).count(), 0)

    def test_delete_bulk(self):
        self.pyramid_config.add_route("settings", "/settings/")
        self.pyramid_config.add_route("progress", "/progress/{key}")
        model = self.app.model
        sample_data = [
            {"name": "foo1", "value": "ONE"},
            {"name": "foo2", "value": "two"},
            {"name": "foo3", "value": "three"},
            {"name": "foo4", "value": "four"},
            {"name": "foo5", "value": "five"},
            {"name": "foo6", "value": "six"},
            {"name": "foo7", "value": "seven"},
            {"name": "foo8", "value": "eight"},
            {"name": "foo9", "value": "nine"},
        ]
        for setting in sample_data:
            self.app.save_setting(self.session, setting["name"], setting["value"])
        self.session.commit()
        sample_query = self.session.query(model.Setting)

        with patch.multiple(mod.MasterView, create=True, model_class=model.Setting):
            view = self.make_view()

            # sanity check on sample data
            grid = view.make_model_grid(session=self.session)
            data = grid.get_visible_data()
            self.assertEqual(len(data), 9)

            # and then let's filter it a little
            self.request.GET = {"value": "s", "value.verb": "contains"}
            grid = view.make_model_grid(session=self.session)
            self.assertEqual(len(grid.filters), 2)
            self.assertEqual(len(grid.active_filters), 1)
            data = grid.get_visible_data()
            self.assertEqual(len(data), 2)

            # okay now let's delete those via quick method
            # (user should be redirected back to index)
            with patch.multiple(
                view,
                deletable_bulk_quick=True,
                make_model_grid=MagicMock(return_value=grid),
            ):
                response = view.delete_bulk()
            self.assertEqual(response.status_code, 302)
            self.assertEqual(self.session.query(model.Setting).count(), 7)

            # now use another filter since those records are gone
            self.request.GET = {"name": "foo2", "name.verb": "equal"}
            grid = view.make_model_grid(session=self.session)
            self.assertEqual(len(grid.filters), 2)
            self.assertEqual(len(grid.active_filters), 1)
            data = grid.get_visible_data()
            self.assertEqual(len(data), 1)

            # this time we delete "slowly" with progress
            self.request.session.id = "ignorethis"
            with patch.multiple(
                view,
                deletable_bulk_quick=False,
                make_model_grid=MagicMock(return_value=grid),
            ):
                with patch.object(mod, "threading") as threading:
                    response = view.delete_bulk()
                    threading.Thread.return_value.start.assert_called_once_with()
            # nb. user is shown progress page
            self.assertEqual(response.status_code, 200)

    def test_delete_bulk_action(self):
        self.pyramid_config.add_route("settings", "/settings/")
        model = self.app.model
        sample_data = [
            {"name": "foo1", "value": "ONE"},
            {"name": "foo2", "value": "two"},
            {"name": "foo3", "value": "three"},
            {"name": "foo4", "value": "four"},
            {"name": "foo5", "value": "five"},
            {"name": "foo6", "value": "six"},
            {"name": "foo7", "value": "seven"},
            {"name": "foo8", "value": "eight"},
            {"name": "foo9", "value": "nine"},
        ]
        for setting in sample_data:
            self.app.save_setting(self.session, setting["name"], setting["value"])
        self.session.commit()
        sample_query = self.session.query(model.Setting)

        with patch.multiple(mod.MasterView, create=True, model_class=model.Setting):
            view = self.make_view()

            # basic bulk delete
            self.assertEqual(self.session.query(model.Setting).count(), 9)
            settings = (
                self.session.query(model.Setting)
                .filter(model.Setting.value.ilike("%s%"))
                .all()
            )
            self.assertEqual(len(settings), 2)
            view.delete_bulk_action(settings)
            self.session.commit()
            self.assertEqual(self.session.query(model.Setting).count(), 7)

    def test_do_thread_body(self):
        view = self.make_view()

        # nb. so far this is just proving coverage, in case caller
        # does not specify an error handler

        def func():
            raise RuntimeError

        # with error handler
        onerror = MagicMock()
        view.do_thread_body(func, (), {}, onerror)
        onerror.assert_called_once_with()

        # without error handler
        onerror.reset_mock()
        view.do_thread_body(func, (), {})
        onerror.assert_not_called()

    def test_delete_bulk_thread(self):
        self.pyramid_config.add_route("settings", "/settings/")
        model = self.app.model
        sample_data = [
            {"name": "foo1", "value": "ONE"},
            {"name": "foo2", "value": "two"},
            {"name": "foo3", "value": "three"},
            {"name": "foo4", "value": "four"},
            {"name": "foo5", "value": "five"},
            {"name": "foo6", "value": "six"},
            {"name": "foo7", "value": "seven"},
            {"name": "foo8", "value": "eight"},
            {"name": "foo9", "value": "nine"},
        ]
        for setting in sample_data:
            self.app.save_setting(self.session, setting["name"], setting["value"])
        self.session.commit()
        sample_query = self.session.query(model.Setting)

        with patch.multiple(mod.MasterView, create=True, model_class=model.Setting):
            view = self.make_view()

            # basic delete, no progress
            self.assertEqual(self.session.query(model.Setting).count(), 9)
            settings = self.session.query(model.Setting).filter(
                model.Setting.value.ilike("%s%")
            )
            self.assertEqual(settings.count(), 2)
            with patch.object(self.app, "make_session", return_value=self.session):
                view.delete_bulk_thread(settings)
            self.assertEqual(self.session.query(model.Setting).count(), 7)

            # basic delete, with progress
            settings = self.session.query(model.Setting).filter(
                model.Setting.name == "foo1"
            )
            self.assertEqual(settings.count(), 1)
            with patch.object(self.app, "make_session", return_value=self.session):
                view.delete_bulk_thread(settings, progress=MagicMock())
            self.assertEqual(self.session.query(model.Setting).count(), 6)

            # error, no progress
            settings = self.session.query(model.Setting).filter(
                model.Setting.name == "foo2"
            )
            self.assertEqual(settings.count(), 1)
            with patch.object(self.app, "make_session", return_value=self.session):
                with patch.object(view, "delete_bulk_action", side_effect=RuntimeError):
                    view.delete_bulk_thread(settings)
            # nb. nothing was deleted
            self.assertEqual(self.session.query(model.Setting).count(), 6)

            # error, with progress
            self.assertEqual(settings.count(), 1)
            with patch.object(self.app, "make_session", return_value=self.session):
                with patch.object(view, "delete_bulk_action", side_effect=RuntimeError):
                    view.delete_bulk_thread(settings, progress=MagicMock())
            # nb. nothing was deleted
            self.assertEqual(self.session.query(model.Setting).count(), 6)

    def test_merge_get_simple_fields(self):
        model = self.app.model
        with patch.object(mod.MasterView, "model_class", new=model.Person):
            view = self.make_view()

            # fields include table columns by default
            fields = view.merge_get_simple_fields()
            self.assertEqual(
                fields,
                ["uuid", "full_name", "first_name", "middle_name", "last_name"],
            )

            # but class can specify fields
            view.merge_simple_fields = ["first_name", "last_name"]
            fields = view.merge_get_simple_fields()
            self.assertEqual(
                fields,
                ["first_name", "last_name"],
            )

    def test_merge_get_additive_fields(self):
        model = self.app.model
        with patch.object(mod.MasterView, "model_class", new=model.Person):
            view = self.make_view()

            # no additive fields by default
            fields = view.merge_get_additive_fields()
            self.assertEqual(fields, [])

            # but class can specify fields
            view.merge_additive_fields = ["usernames"]
            fields = view.merge_get_additive_fields()
            self.assertEqual(fields, ["usernames"])

    def test_merge_get_coalesce_fields(self):
        model = self.app.model
        with patch.object(mod.MasterView, "model_class", new=model.Person):
            view = self.make_view()

            # no coalesce fields by default
            fields = view.merge_get_coalesce_fields()
            self.assertEqual(fields, [])

            # but class can specify fields
            view.merge_coalesce_fields = ["active"]
            fields = view.merge_get_coalesce_fields()
            self.assertEqual(fields, ["active"])

    def test_merge_get_all_fields(self):
        model = self.app.model
        with patch.object(mod.MasterView, "model_class", new=model.Person):
            view = self.make_view()

            # nb. "all" fields will be a sorted list

            # only column (simple) fields by default
            fields = view.merge_get_all_fields()
            self.assertEqual(
                fields,
                ["first_name", "full_name", "last_name", "middle_name", "uuid"],
            )

            # but class can specify fields
            view.merge_simple_fields = ["first_name", "last_name"]
            view.merge_additive_fields = ["usernames"]
            view.merge_coalesce_fields = ["active"]
            fields = view.merge_get_all_fields()
            self.assertEqual(
                fields,
                ["active", "first_name", "last_name", "usernames"],
            )

    def test_merge_get_data(self):
        model = self.app.model
        person = model.Person(first_name="Fred", last_name="Flintstone")
        with patch.object(mod.MasterView, "model_class", new=model.Person):
            view = self.make_view()

            # data will include "all" fields
            view.merge_simple_fields = ["first_name", "last_name", "usernames"]
            data = view.merge_get_data(person)
            self.assertEqual(
                data,
                {
                    "first_name": "Fred",
                    "last_name": "Flintstone",
                    # nb. person has no such attr, so null value
                    "usernames": None,
                },
            )

    def test_merge_get_final_data(self):
        model = self.app.model

        removing = {
            "first_name": "Freddie",
            "last_name": "Flintstone",
            "user_count": 1,
            "usernames": ["freddie"],
            "some_value": 42,
            "active": True,
        }

        keeping = {
            "first_name": "Fred",
            "last_name": "Flintstone",
            "user_count": 1,
            "usernames": ["fred"],
            "some_value": None,
            "active": False,
        }

        with patch.object(mod.MasterView, "model_class", new=model.Person):
            view = self.make_view()
            view.merge_simple_fields = ["first_name", "last_name"]
            view.merge_additive_fields = ["user_count", "usernames"]
            view.merge_coalesce_fields = ["some_value", "active"]

            final = view.merge_get_final_data(removing, keeping)
            self.assertEqual(
                final,
                {
                    "first_name": "Fred",
                    "last_name": "Flintstone",
                    "user_count": 2,
                    "usernames": ["fred", "freddie"],
                    "some_value": 42,
                    "active": True,
                },
            )

    def test_merge_execute(self):
        model = self.app.model

        person1 = model.Person(
            first_name="Freddie", last_name="Flintstone", full_name="Freddie Flintstone"
        )
        self.session.add(person1)
        person2 = model.Person(
            first_name="Fred", last_name="Flintstone", full_name="Fred Flintstone"
        )
        self.session.add(person2)
        self.session.commit()
        self.assertEqual(self.session.query(model.Person).count(), 2)

        with patch.object(mod.MasterView, "Session", return_value=self.session):
            view = self.make_view()

            # default merge logic just deletes 'removing' person1
            view.merge_execute(person1, person2)
            self.assertEqual(self.session.query(model.Person).count(), 1)
            person = self.session.query(model.Person).one()
            self.assertIs(person, person2)
            self.assertEqual(person.first_name, "Fred")
            self.assertEqual(person.full_name, "Fred Flintstone")

    def test_merge_validate_and_execute(self):
        model = self.app.model

        person1 = model.Person(
            first_name="Freddie", last_name="Flintstone", full_name="Freddie Flintstone"
        )
        self.session.add(person1)
        person2 = model.Person(
            first_name="Fred", last_name="Flintstone", full_name="Fred Flintstone"
        )
        self.session.add(person2)
        self.session.commit()
        self.assertEqual(self.session.query(model.Person).count(), 2)
        self.assertIn(person1, self.session)

        with patch.object(mod.MasterView, "Session", return_value=self.session):
            view = self.make_view()

            # default merge logic just deletes 'removing' person1
            result = view.merge_validate_and_execute(person1, person2)
            self.assertTrue(result)
            self.assertEqual(self.session.query(model.Person).count(), 1)
            person = self.session.query(model.Person).one()
            self.assertIs(person, person2)
            self.assertEqual(person.first_name, "Fred")
            self.assertEqual(person.full_name, "Fred Flintstone")
            self.assertFalse(self.request.session.peek_flash("warning"))
            self.assertFalse(self.request.session.peek_flash("error"))
            self.assertEqual(
                self.request.session.pop_flash(),
                ["Freddie Flintstone has been merged into Fred Flintstone"],
            )

            # restore Freddie
            self.assertNotIn(person1, self.session)
            person1 = self.session.merge(person1)
            self.session.commit()
            self.assertEqual(self.session.query(model.Person).count(), 2)

            # merge does not validate
            with patch.object(view, "merge_why_not", return_value="because i said so"):
                result = view.merge_validate_and_execute(person1, person2)
                self.assertFalse(result)
                self.assertEqual(self.session.query(model.Person).count(), 2)
                self.assertFalse(self.request.session.peek_flash())
                self.assertFalse(self.request.session.peek_flash("error"))
                self.assertEqual(
                    self.request.session.pop_flash("warning"),
                    [
                        HTML.literal(
                            '<p class="block">Merge cannot proceed:</p>'
                            '<p class="block">because i said so</p>'
                        ),
                    ],
                )

            # error executing merge
            with patch.object(view, "merge_execute", side_effect=RuntimeError):
                result = view.merge_validate_and_execute(person1, person2)
                self.assertFalse(result)
                self.assertEqual(self.session.query(model.Person).count(), 2)
                self.assertFalse(self.request.session.peek_flash())
                self.assertFalse(self.request.session.peek_flash("warning"))
                self.assertEqual(
                    self.request.session.pop_flash("error"),
                    [
                        HTML.literal(
                            '<p class="block">Merge failed:</p>'
                            '<p class="block">RuntimeError</p>'
                        ),
                    ],
                )

    def test_merge(self):
        self.pyramid_config.add_route("home", "/")
        self.pyramid_config.add_route("login", "/auth/login")
        self.pyramid_config.add_route("people", "/people/")
        self.pyramid_config.add_route("people.merge", "/people/merge")
        self.pyramid_config.add_route("people.view", "/people/{uuid}")
        model = self.app.model

        class MergeRoute:
            name = "people.merge"

        person1 = model.Person(
            first_name="Freddie", last_name="Flintstone", full_name="Freddie Flintstone"
        )
        self.session.add(person1)
        person2 = model.Person(
            first_name="Fred", last_name="Flintstone", full_name="Fred Flintstone"
        )
        self.session.add(person2)
        self.session.commit()
        self.assertEqual(self.session.query(model.Person).count(), 2)
        self.assertIn(person1, self.session)

        with patch.multiple(
            mod.MasterView,
            Session=MagicMock(return_value=self.session),
            model_class=model.Person,
            route_prefix="people",
            create=True,
        ):
            view = self.make_view()

            # GET request will redirect to index
            result = view.merge()
            self.assertIsInstance(result, HTTPFound)
            self.assertEqual(result.location, "http://example.com/people/")
            self.assertEqual(self.session.query(model.Person).count(), 2)

            # assume POST from now on
            with patch.multiple(
                self.request, matched_route=MergeRoute, method="POST", create=True
            ):

                # POST without 'execute-merge' flag shows user the diff
                with patch.object(
                    self.request,
                    "POST",
                    new={"uuids": f"{person1.uuid},{person2.uuid}"},
                ):
                    response = view.merge()
                    self.assertIsInstance(response, Response)
                    self.assertEqual(response.status_code, 200)
                    self.assertEqual(self.session.query(model.Person).count(), 2)
                    self.assertFalse(self.request.session.peek_flash())
                    self.assertFalse(self.request.session.peek_flash("warning"))
                    self.assertFalse(self.request.session.peek_flash("error"))

                # default merge logic deletes person1, then redirects
                with patch.object(
                    self.request,
                    "POST",
                    new={
                        "uuids": f"{person1.uuid},{person2.uuid}",
                        "execute-merge": "true",
                    },
                ):
                    result = view.merge()
                    self.assertIsInstance(result, HTTPFound)
                    self.assertEqual(
                        result.location, f"http://example.com/people/{person2.uuid}"
                    )
                    self.assertEqual(self.session.query(model.Person).count(), 1)
                    self.assertNotIn(person1, self.session)
                    self.assertIn(person2, self.session)
                    person = self.session.query(model.Person).one()
                    self.assertIs(person, person2)
                    self.assertEqual(person.first_name, "Fred")
                    self.assertEqual(person.full_name, "Fred Flintstone")
                    self.assertFalse(self.request.session.peek_flash("warning"))
                    self.assertFalse(self.request.session.peek_flash("error"))
                    self.assertEqual(
                        self.request.session.pop_flash(),
                        ["Freddie Flintstone has been merged into Fred Flintstone"],
                    )

                # restore Freddie
                self.assertNotIn(person1, self.session)
                person1 = self.session.merge(person1)
                self.session.commit()
                self.assertEqual(self.session.query(model.Person).count(), 2)

                # simple redirect if invalid uuids specified
                with patch.object(
                    self.request,
                    "POST",
                    new={
                        "uuids": "bogus1,bogus2",
                        "execute-merge": "true",
                    },
                ):
                    with self.assertRaises(HTTPFound) as cm:
                        view.merge()
                    self.assertEqual(
                        cm.exception.location, "http://example.com/people/"
                    )
                    self.assertEqual(self.session.query(model.Person).count(), 2)
                    self.assertFalse(self.request.session.peek_flash())
                    self.assertFalse(self.request.session.peek_flash("warning"))
                    self.assertFalse(self.request.session.peek_flash("error"))

                # simple redirect if unknown uuids specified
                fake1 = self.app.make_true_uuid()
                fake2 = self.app.make_true_uuid()
                with patch.object(
                    self.request,
                    "POST",
                    new={
                        "uuids": f"{fake1},{fake2}",
                        "execute-merge": "true",
                    },
                ):
                    with self.assertRaises(HTTPFound) as cm:
                        view.merge()
                    self.assertEqual(
                        cm.exception.location, "http://example.com/people/"
                    )
                    self.assertEqual(self.session.query(model.Person).count(), 2)
                    self.assertFalse(self.request.session.peek_flash())
                    self.assertFalse(self.request.session.peek_flash("warning"))
                    self.assertFalse(self.request.session.peek_flash("error"))

                # warning redirect if merge does not validate
                with patch.object(
                    self.request,
                    "POST",
                    new={
                        "uuids": f"{person1.uuid},{person2.uuid}",
                        "execute-merge": "true",
                    },
                ):
                    with patch.object(
                        view, "merge_why_not", return_value="because i said so"
                    ):
                        response = view.merge()
                        self.assertIsInstance(response, Response)
                        self.assertEqual(self.session.query(model.Person).count(), 2)
                        self.assertFalse(self.request.session.peek_flash())
                        self.assertFalse(self.request.session.peek_flash("error"))
                        # TODO: since response is already rendered, the warning flash
                        # msg has already been popped off the stack..will have to
                        # avoid render_to_response() to properly test that..
                        self.assertFalse(self.request.session.peek_flash("warning"))
                        # self.assertEqual(
                        #     self.request.session.pop_flash("warning"),
                        #     [
                        #         HTML.literal(
                        #             '<p class="block">Merge cannot proceed:</p>'
                        #             '<p class="block">because i said so</p>'
                        #         ),
                        #     ],
                        # )

                # error redirect if merge execution fails
                with patch.object(
                    self.request,
                    "POST",
                    new={
                        "uuids": f"{person1.uuid},{person2.uuid}",
                        "execute-merge": "true",
                    },
                ):
                    with patch.object(view, "merge_execute", side_effect=RuntimeError):
                        response = view.merge()
                        self.assertIsInstance(response, Response)
                        self.assertEqual(self.session.query(model.Person).count(), 2)
                        self.assertFalse(self.request.session.peek_flash())
                        self.assertFalse(self.request.session.peek_flash("warning"))
                        # TODO: since response is already rendered, the error flash
                        # msg has already been popped off the stack..will have to
                        # avoid render_to_response() to properly test that..
                        self.assertFalse(self.request.session.peek_flash("error"))
                        # self.assertEqual(
                        #     self.request.session.pop_flash("error"),
                        #     [
                        #         HTML.literal(
                        #             '<p class="block">Merge failed:</p>'
                        #             '<p class="block">RuntimeError</p>'
                        #         ),
                        #     ],
                        # )

    def test_autocomplete(self):
        model = self.app.model

        person1 = model.Person(full_name="George Jones")
        self.session.add(person1)
        person2 = model.Person(full_name="George Strait")
        self.session.add(person2)
        self.session.commit()

        # no results for empty term
        self.request.GET = {}
        view = self.make_view()
        results = view.autocomplete()
        self.assertEqual(len(results), 0)

        # search yields no results
        self.request.GET = {"term": "sally"}
        view = self.make_view()
        with patch.object(view, "autocomplete_data", return_value=[]):
            view = self.make_view()
            results = view.autocomplete()
            self.assertEqual(len(results), 0)

        # search yields 2 results
        self.request.GET = {"term": "george"}
        view = self.make_view()
        with patch.object(view, "autocomplete_data", return_value=[person1, person2]):
            results = view.autocomplete()
            self.assertEqual(len(results), 2)
            self.assertEqual(
                [res["value"] for res in results], [p.uuid for p in [person1, person2]]
            )

    def test_autocomplete_normalize(self):
        model = self.app.model
        view = self.make_view()

        person = model.Person(full_name="Betty Boop", uuid="bogus")
        normal = view.autocomplete_normalize(person)
        self.assertEqual(normal, {"value": "bogus", "label": "Betty Boop"})

    def test_download(self):
        model = self.app.model
        self.app.save_setting(self.session, "foo", "bar")
        self.session.commit()

        with patch.multiple(
            mod.MasterView,
            create=True,
            model_class=model.Setting,
            model_key="name",
            Session=MagicMock(return_value=self.session),
        ):
            view = self.make_view()
            self.request.matchdict = {"name": "foo"}

            # 404 if no filename
            response = view.download()
            self.assertEqual(response.status_code, 404)

            # 404 if bad filename
            self.request.GET = {"filename": "doesnotexist"}
            response = view.download()
            self.assertEqual(response.status_code, 404)

            # 200 if good filename
            foofile = self.write_file("foo.txt", "foo")
            with patch.object(view, "download_path", return_value=foofile):
                response = view.download()
                self.assertEqual(response.status_code, 200)
                self.assertEqual(
                    response.content_disposition, 'attachment; filename="foo.txt"'
                )

    def test_execute(self):
        self.pyramid_config.add_route("settings.view", "/settings/{name}")
        self.pyramid_config.add_route("progress", "/progress/{key}")
        model = self.app.model
        self.app.save_setting(self.session, "foo", "bar")
        user = model.User(username="barney")
        self.session.add(user)
        self.session.commit()

        with patch.multiple(
            mod.MasterView,
            create=True,
            model_class=model.Setting,
            model_key="name",
            Session=MagicMock(return_value=self.session),
        ):
            view = self.make_view()
            self.request.matchdict = {"name": "foo"}
            self.request.session.id = "mockid"
            self.request.user = user

            # basic usage; user is shown progress page
            with patch.object(mod, "threading") as threading:
                response = view.execute()
                threading.Thread.return_value.start.assert_called_once_with()
                self.assertEqual(response.status_code, 200)

    def test_execute_thread(self):
        model = self.app.model
        enum = self.app.enum
        user = model.User(username="barney")
        self.session.add(user)
        upgrade = model.Upgrade(
            description="test", created_by=user, status=enum.UpgradeStatus.PENDING
        )
        self.session.add(upgrade)
        self.session.commit()

        with patch.multiple(mod.MasterView, create=True, model_class=model.Upgrade):
            view = self.make_view()

            # basic execute, no progress
            with patch.object(view, "execute_instance") as execute_instance:
                view.execute_thread({"uuid": upgrade.uuid}, user.uuid)
                execute_instance.assert_called_once()

            # basic execute, with progress
            with patch.object(view, "execute_instance") as execute_instance:
                progress = MagicMock()
                view.execute_thread(
                    {"uuid": upgrade.uuid}, user.uuid, progress=progress
                )
                execute_instance.assert_called_once()
                progress.handle_success.assert_called_once_with()

            # error, no progress
            with patch.object(view, "execute_instance") as execute_instance:
                execute_instance.side_effect = RuntimeError
                view.execute_thread({"uuid": upgrade.uuid}, user.uuid)
                execute_instance.assert_called_once()

            # error, with progress
            with patch.object(view, "execute_instance") as execute_instance:
                progress = MagicMock()
                execute_instance.side_effect = RuntimeError
                view.execute_thread(
                    {"uuid": upgrade.uuid}, user.uuid, progress=progress
                )
                execute_instance.assert_called_once()
                progress.handle_error.assert_called_once()

    def test_configure(self):
        self.pyramid_config.include("wuttaweb.views.common")
        self.pyramid_config.include("wuttaweb.views.auth")
        self.pyramid_config.add_route(
            "appinfo.check_timezone", "/appinfo/check-timezone"
        )
        model = self.app.model

        # mock settings
        settings = [
            {"name": "wutta.app_title"},
            {"name": "wutta.foo", "value": "bar"},
            {"name": "wutta.flag", "type": bool},
            {"name": "wutta.number", "type": int, "default": 42},
            {"name": "wutta.value1", "save_if_empty": True},
            {"name": "wutta.value2", "save_if_empty": False},
        ]

        view = mod.MasterView(self.request)
        with patch.object(
            self.request, "current_route_url", return_value="/appinfo/configure"
        ):
            with patch.object(mod, "Session", return_value=self.session):
                with patch.multiple(
                    mod.MasterView,
                    create=True,
                    model_name="AppInfo",
                    route_prefix="appinfo",
                    template_prefix="/appinfo",
                    creatable=False,
                    get_index_url=MagicMock(return_value="/appinfo/"),
                    configure_get_simple_settings=MagicMock(return_value=settings),
                ):

                    # nb. appinfo/configure template requires menu_handlers
                    original_context = view.configure_get_context

                    def get_context(**kw):
                        kw = original_context(**kw)
                        kw["menu_handlers"] = []
                        kw["default_timezone"] = "UTC"
                        kw["grid_pagesize_options"] = [10, 20, 50]
                        kw["grid_pagesize_default"] = 20
                        return kw

                    with patch.object(view, "configure_get_context", new=get_context):

                        # get the form page
                        response = view.configure(session=self.session)
                        self.assertIsInstance(response, Response)

                        # post request to save settings
                        self.request.method = "POST"
                        self.request.POST = {
                            "wutta.app_title": "Wutta",
                            "wutta.foo": "bar",
                            "wutta.flag": "true",
                        }
                        response = view.configure(session=self.session)
                        # nb. should get redirect back to configure page
                        self.assertEqual(response.status_code, 302)

                        # should now have 5 settings
                        count = self.session.query(model.Setting).count()
                        self.assertEqual(count, 5)
                        get_setting = functools.partial(
                            self.app.get_setting, self.session
                        )
                        self.assertEqual(get_setting("wutta.app_title"), "Wutta")
                        self.assertEqual(get_setting("wutta.foo"), "bar")
                        self.assertEqual(get_setting("wutta.flag"), "true")
                        self.assertEqual(get_setting("wutta.number"), "42")
                        self.assertEqual(get_setting("wutta.value1"), "")
                        self.assertEqual(get_setting("wutta.value2"), None)

                        # post request to remove settings
                        self.request.method = "POST"
                        self.request.POST = {"remove_settings": "1"}
                        response = view.configure(session=self.session)
                        # nb. should get redirect back to configure page
                        self.assertEqual(response.status_code, 302)

                        # should now have 0 settings
                        count = self.session.query(model.Setting).count()
                        self.assertEqual(count, 0)

    def test_configure_get_simple_settings(self):
        view = self.make_view()
        settings = view.configure_get_simple_settings()
        self.assertEqual(settings, [])

    def test_configure_gather_settings(self):
        view = self.make_view()

        simple_settings = [
            {"name": "wutta.app_title"},
            {"name": "wutta.foo"},
            {"name": "wutta.flag", "type": bool, "default": True},
            {"name": "wutta.number", "type": int, "default": 42},
            {"name": "wutta.value1", "save_if_empty": True},
            {"name": "wutta.value2", "save_if_empty": False},
            {"name": "wutta.value3", "save_if_empty": False, "default": "baz"},
        ]

        data = {
            "wutta.app_title": "Poser",
            "wutta.foo": "bar",
            "wutta.number": 44,
            "wutta.value1": None,
        }

        with patch.object(
            view, "configure_get_simple_settings", return_value=simple_settings
        ):
            settings = view.configure_gather_settings(data)
            self.assertEqual(len(settings), 6)
            self.assertEqual(
                settings,
                [
                    {"name": "wutta.app_title", "value": "Poser"},
                    {"name": "wutta.foo", "value": "bar"},
                    {"name": "wutta.flag", "value": "false"},
                    {"name": "wutta.number", "value": "44"},
                    {"name": "wutta.value1", "value": ""},
                    {"name": "wutta.value3", "value": "baz"},
                ],
            )

    ##############################
    # row methods
    ##############################

    def test_get_rows_title(self):
        model = self.app.model

        with patch.object(mod.MasterView, "row_model_class", new=model.User):
            view = self.make_view()

            # default based on row model class
            self.assertEqual(view.get_rows_title(), "Users")

            # explicit override
            with patch.object(view, "rows_title", create=True, new="Mock Rows"):
                self.assertEqual(view.get_rows_title(), "Mock Rows")

    def test_get_row_parent(self):
        model = self.app.model
        view = self.make_view()

        person = model.Person(full_name="Fred Flintstone")
        self.session.add(person)
        user = model.User(username="fred", person=person)
        self.session.add(user)
        self.session.commit()

        with patch.multiple(
            mod.MasterView, model_class=model.Person, row_model_class=model.User
        ):
            self.assertRaises(NotImplementedError, view.get_row_parent, user)

    def test_collect_row_labels(self):

        # default labels
        view = self.make_view()
        labels = view.collect_row_labels()
        self.assertEqual(labels, {})

        # labels come from all classes; subclass wins
        with patch.object(
            View, "row_labels", create=True, new={"foo": "Foo", "bar": "Bar"}
        ):
            with patch.object(
                mod.MasterView, "row_labels", create=True, new={"foo": "FOO FIGHTERS"}
            ):
                view = self.make_view()
                labels = view.collect_row_labels()
                self.assertEqual(labels, {"foo": "FOO FIGHTERS", "bar": "Bar"})

    def test_set_row_labels(self):
        model = self.app.model
        person = model.Person(full_name="Fred Flintstone")
        self.session.add(person)

        with patch.multiple(
            mod.MasterView,
            create=True,
            model_class=model.Person,
            has_rows=True,
            row_model_class=model.User,
        ):

            # no labels by default
            view = self.make_view()
            grid = view.make_row_model_grid(person, key="person.users", data=[])
            view.set_row_labels(grid)
            self.assertEqual(grid.labels, {})

            # labels come from all classes; subclass wins
            with patch.object(
                View, "row_labels", create=True, new={"username": "USERNAME"}
            ):
                with patch.object(
                    mod.MasterView,
                    "row_labels",
                    create=True,
                    new={"username": "UserName"},
                ):
                    view = self.make_view()
                    grid = view.make_row_model_grid(person, key="person.users", data=[])
                    view.set_row_labels(grid)
                    self.assertEqual(grid.labels, {"username": "UserName"})

    def test_get_row_grid_data(self):
        model = self.app.model
        person = model.Person(full_name="Fred Flintstone")
        self.session.add(person)
        view = self.make_view()
        self.assertRaises(NotImplementedError, view.get_row_grid_data, person)

    def test_get_row_grid_columns(self):

        # no default
        view = self.make_view()
        self.assertIsNone(view.get_row_grid_columns())

        # class may specify
        with patch.object(view, "row_grid_columns", create=True, new=["foo", "bar"]):
            self.assertEqual(view.get_row_grid_columns(), ["foo", "bar"])

    def test_get_row_grid_key(self):
        view = self.make_view()
        with patch.multiple(
            mod.MasterView, create=True, model_key="id", grid_key="widgets"
        ):

            self.request.matchdict = {"id": 42}
            self.assertEqual(view.get_row_grid_key(), "widgets.42")

    def test_make_row_model_grid(self):
        model = self.app.model
        person = model.Person(full_name="Barney Rubble")
        self.session.add(person)
        self.session.commit()

        self.request.matchdict = {"uuid": person.uuid}
        with patch.multiple(mod.MasterView, create=True, model_class=model.Person):
            view = self.make_view()

            # specify data
            grid = view.make_row_model_grid(person, data=[])
            self.assertIsNone(grid.model_class)
            self.assertEqual(grid.data, [])

            # fetch data
            with patch.object(view, "get_row_grid_data", return_value=[]):
                grid = view.make_row_model_grid(person)
                self.assertIsNone(grid.model_class)
                self.assertEqual(grid.data, [])

            # view action
            with patch.object(view, "rows_viewable", new=True):
                with patch.object(view, "get_row_action_url_view", return_value="#"):
                    grid = view.make_row_model_grid(person, data=[])
                    self.assertEqual(len(grid.actions), 1)
                    self.assertEqual(grid.actions[0].key, "view")

    def test_get_row_action_url_view(self):
        view = self.make_view()
        row = MagicMock()
        self.assertRaises(NotImplementedError, view.get_row_action_url_view, row, 0)

    def test_make_row_model_form(self):
        model = self.app.model
        view = self.make_view()

        # no model class
        form = view.make_row_model_form()
        self.assertIsNone(form.model_class)

        # explicit model class + fields
        form = view.make_row_model_form(
            model_class=model.User, fields=["username", "active"]
        )
        self.assertIs(form.model_class, model.User)
        self.assertEqual(form.fields, ["username", "active"])

        # implicit model + fields
        with patch.multiple(
            mod.MasterView,
            create=True,
            row_model_class=model.User,
            row_form_fields=["username", "person"],
        ):
            form = view.make_row_model_form()
            self.assertIs(form.model_class, model.User)
            self.assertEqual(form.fields, ["username", "person"])

    def test_configure_row_form(self):
        model = self.app.model
        view = self.make_view()

        # uuid field is pruned
        with patch.object(mod.MasterView, "row_model_class", new=model.User):
            form = view.make_form(model_class=model.User, fields=["uuid", "username"])
            self.assertIn("uuid", form.fields)
            view.configure_row_form(form)
            self.assertNotIn("uuid", form.fields)

    def test_create_row(self):
        self.pyramid_config.add_route("home", "/")
        self.pyramid_config.add_route("login", "/auth/login")
        self.pyramid_config.add_route("people", "/people/")
        self.pyramid_config.add_route("people.view", "/people/{uuid}")
        model = self.app.model

        person = model.Person(
            first_name="Fred", last_name="Flintstone", full_name="Fred Flintstone"
        )
        self.session.add(person)
        user = model.User(username="fred", person=person)
        self.session.add(user)
        self.session.commit()

        with patch.multiple(
            mod.MasterView,
            create=True,
            model_class=model.Person,
            row_model_class=model.User,
            row_form_fields=["person_uuid", "username"],
            route_prefix="people",
        ):
            with patch.object(mod.MasterView, "Session", return_value=self.session):
                with patch.object(self.request, "matchdict", {"uuid": person.uuid}):
                    with patch.object(
                        mod.MasterView, "get_row_parent", return_value=person
                    ):
                        view = self.make_view()

                        # get the form page
                        response = view.create_row()
                        self.assertIsInstance(response, Response)
                        self.assertEqual(response.status_code, 200)
                        # nb. no error
                        self.assertNotIn("Required", response.text)

                        self.assertEqual(len(person.users), 1)

                        # post request to add user
                        with patch.multiple(
                            self.request,
                            method="POST",
                            POST={
                                "person_uuid": person.uuid.hex,
                                "username": "freddie2",
                            },
                        ):
                            response = view.create_row()
                            # nb. should get redirect back to view page
                            self.assertEqual(response.status_code, 302)
                            # user should now be in DB
                            self.session.refresh(person)
                            self.assertEqual(len(person.users), 2)

                        # try another post with invalid data (username is required)
                        with patch.multiple(
                            self.request,
                            method="POST",
                            POST={"person_uuid": person.uuid.hex, "username": ""},
                        ):
                            response = view.create_row()
                            # nb. should get a form with errors
                            self.assertEqual(response.status_code, 200)
                            self.assertIn("Required", response.text)
                            self.session.refresh(person)
                            self.assertEqual(len(person.users), 2)


class TestVersionedMasterView(VersionWebTestCase):

    def make_view(self):
        return mod.MasterView(self.request)

    def test_is_versioned(self):
        model = self.app.model

        with patch.object(mod.MasterView, "model_class", new=model.User):

            # User is versioned by default
            self.assertTrue(mod.MasterView.is_versioned())

            # but view can override w/ attr
            with patch.object(
                mod.MasterView, "model_is_versioned", new=False, create=True
            ):
                self.assertFalse(mod.MasterView.is_versioned())

    def test_defaults(self):
        model = self.app.model

        with patch.object(mod.MasterView, "model_class", new=model.User):
            mod.MasterView.defaults(self.pyramid_config)

    def test_get_model_version_class(self):
        model = self.app.model
        with patch.object(mod.MasterView, "model_class", new=model.User):
            view = self.make_view()
            vercls = view.get_model_version_class()
            self.assertEqual(vercls.__name__, "UserVersion")

    def test_should_expose_versions(self):
        model = self.app.model
        with patch.object(mod.MasterView, "model_class", new=model.User):

            # fully enabled for root user
            with patch.object(self.request, "is_root", new=True):
                view = self.make_view()
                self.assertTrue(view.should_expose_versions())

            # but not if user has no access
            view = self.make_view()
            self.assertFalse(view.should_expose_versions())

            # again, works for root user
            with patch.object(self.request, "is_root", new=True):
                view = self.make_view()
                self.assertTrue(view.should_expose_versions())

                # but not if config disables versioning
                with patch.object(view.app, "continuum_is_enabled", return_value=False):
                    self.assertFalse(view.should_expose_versions())

    def test_get_version_grid_key(self):
        model = self.app.model
        with patch.object(mod.MasterView, "model_class", new=model.User):

            # default
            view = self.make_view()
            self.assertEqual(view.get_version_grid_key(), "users.history")

            # custom
            with patch.object(
                mod.MasterView,
                "version_grid_key",
                new="users_custom_history",
                create=True,
            ):
                view = self.make_view()
                self.assertEqual(view.get_version_grid_key(), "users_custom_history")

    def test_get_version_grid_columns(self):
        model = self.app.model
        with patch.object(mod.MasterView, "model_class", new=model.User):

            # default
            view = self.make_view()
            self.assertEqual(
                view.get_version_grid_columns(),
                ["id", "issued_at", "user", "remote_addr", "comment"],
            )

            # custom
            with patch.object(
                mod.MasterView,
                "version_grid_columns",
                new=["issued_at", "user"],
                create=True,
            ):
                view = self.make_view()
                self.assertEqual(view.get_version_grid_columns(), ["issued_at", "user"])

    def test_get_version_joins(self):
        view = self.make_view()
        self.assertEqual(view.get_version_joins(), [])

    def test_normalize_version_joins(self):
        model = self.app.model
        view = self.make_view()

        joins = [(model.Person, "uuid", "person_uuid")]
        with patch.object(view, "get_version_joins", return_value=joins):
            normal = view.normalize_version_joins()
            self.assertEqual(normal, joins)
            self.assertEqual(normal, [(model.Person, "uuid", "person_uuid")])

        joins = [model.Person]
        with patch.object(view, "get_version_joins", return_value=joins):
            normal = view.normalize_version_joins()
            self.assertNotEqual(normal, joins)
            self.assertEqual(normal, [(model.Person, "uuid", "uuid")])

    def test_get_version_grid_data(self):
        model = self.app.model

        user = model.User(username="fred")
        self.session.add(user)
        self.session.commit()
        user.username = "freddie"
        self.session.commit()

        with patch.object(mod.MasterView, "model_class", new=model.User):
            view = self.make_view()
            query = view.get_version_grid_data(user)
            self.assertIsInstance(query, orm.Query)
            transactions = query.all()
            self.assertEqual(len(transactions), 2)

    def test_configure_version_grid(self):
        import sqlalchemy_continuum as continuum

        model = self.app.model
        txncls = continuum.transaction_class(model.User)

        with patch.object(mod.MasterView, "model_class", new=model.User):
            view = self.make_view()

            # this is mostly just for coverage, but we at least can
            # confirm something does change
            grid = view.make_grid(model_class=txncls)
            self.assertNotIn("issued_at", grid.linked_columns)
            view.configure_version_grid(grid)
            self.assertIn("issued_at", grid.linked_columns)

    def test_make_version_grid(self):
        model = self.app.model

        user = model.User(username="fred")
        self.session.add(user)
        self.session.commit()
        user.username = "freddie"
        self.session.commit()

        with patch.object(mod.MasterView, "model_class", new=model.User):
            with patch.object(mod.MasterView, "Session", return_value=self.session):
                with patch.dict(self.request.matchdict, uuid=user.uuid):
                    view = self.make_view()
                    grid = view.make_version_grid()
                    self.assertIsInstance(grid, Grid)
                    self.assertIsInstance(grid.data, orm.Query)
                    self.assertEqual(len(grid.data.all()), 2)

    def test_view_versions(self):
        self.pyramid_config.add_route("home", "/")
        self.pyramid_config.add_route("login", "/auth/login")
        self.pyramid_config.add_route("users", "/users/")
        self.pyramid_config.add_route("users.view", "/users/{uuid}")
        self.pyramid_config.add_route("users.version", "/users/{uuid}/versions/{txnid}")
        model = self.app.model

        user = model.User(username="fred")
        self.session.add(user)
        self.session.commit()
        user.username = "freddie"
        self.session.commit()

        with patch.object(mod.MasterView, "model_class", new=model.User):
            with patch.object(mod.MasterView, "Session", return_value=self.session):
                with patch.dict(self.request.matchdict, uuid=user.uuid):
                    view = self.make_view()

                    # normal, full page
                    response = view.view_versions()
                    self.assertEqual(response.content_type, "text/html")
                    self.assertIn("<b-table", response.text)

                    # partial page
                    with patch.dict(self.request.params, partial="1"):
                        response = view.view_versions()
                        self.assertEqual(response.content_type, "application/json")
                        self.assertIn("data", response.json)
                        self.assertEqual(len(response.json["data"]), 2)

    def test_get_relevant_versions(self):
        import sqlalchemy_continuum as continuum

        model = self.app.model
        txncls = continuum.transaction_class(model.User)
        vercls = continuum.version_class(model.User)

        person = model.Person(full_name="Fred Flintstone")
        self.session.add(person)
        user = model.User(username="fred", person=person)
        self.session.add(user)
        self.session.commit()

        txn = (
            self.session.query(txncls)
            .join(vercls, vercls.transaction_id == txncls.id)
            .order_by(txncls.id)
            .first()
        )

        with patch.object(mod.MasterView, "model_class", new=model.User):
            with patch.object(mod.MasterView, "Session", return_value=self.session):
                view = self.make_view()

                # just one version if no joins are specified
                versions = view.get_relevant_versions(txn, user)
                self.assertEqual(len(versions), 1)
                version = versions[0]
                self.assertIsInstance(version, vercls)

                # but two versions if we specify join
                joins = [(model.Person, "uuid", "person_uuid")]
                with patch.object(view, "get_version_joins", return_value=joins):
                    versions = view.get_relevant_versions(txn, user)
                    self.assertEqual(len(versions), 2)
                    types = sorted([v.__class__.__name__ for v in versions])
                    self.assertEqual(types, ["PersonVersion", "UserVersion"])

    def test_view_version(self):
        import sqlalchemy_continuum as continuum

        self.pyramid_config.add_route("home", "/")
        self.pyramid_config.add_route("login", "/auth/login")
        self.pyramid_config.add_route("users", "/users/")
        self.pyramid_config.add_route("users.view", "/users/{uuid}")
        self.pyramid_config.add_route("users.versions", "/users/{uuid}/versions/")
        self.pyramid_config.add_route("users.version", "/users/{uuid}/versions/{txnid}")
        model = self.app.model
        txncls = continuum.transaction_class(model.User)
        vercls = continuum.version_class(model.User)

        user = model.User(username="fred")
        self.session.add(user)
        self.session.commit()
        user.username = "freddie"
        self.session.commit()

        transactions = (
            self.session.query(txncls)
            .join(vercls, vercls.transaction_id == txncls.id)
            .order_by(txncls.id)
            .all()
        )
        self.assertEqual(len(transactions), 2)

        with patch.object(mod.MasterView, "model_class", new=model.User):
            with patch.object(mod.MasterView, "Session", return_value=self.session):

                # invalid txnid
                with patch.dict(self.request.matchdict, uuid=user.uuid, txnid=999999):
                    view = self.make_view()
                    self.assertRaises(HTTPNotFound, view.view_version)

                # first txn
                first = transactions[0]
                with patch.dict(self.request.matchdict, uuid=user.uuid, txnid=first.id):
                    view = self.make_view()
                    response = view.view_version()
                    self.assertIn(
                        '<table class="table is-fullwidth is-bordered is-narrow">',
                        response.text,
                    )

                # second txn
                second = transactions[1]
                with patch.dict(
                    self.request.matchdict, uuid=user.uuid, txnid=second.id
                ):
                    view = self.make_view()
                    response = view.view_version()
                    self.assertIn(
                        '<table class="table is-fullwidth is-bordered is-narrow">',
                        response.text,
                    )