wuttaweb/tests/views/test_master.py

# -*- 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

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,
        ):
            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)

    ##############################
    # 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")
        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)
            grid = view.make_model_grid()
            self.assertIsNone(grid.model_class)

        # explicit model class
        with patch.multiple(mod.MasterView, create=True, model_class=model.Setting):
            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):
            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,
        ):
            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):
            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,
        ):

            # 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):
            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
        ):
            with patch.object(self.request, "is_root", new=True):
                grid = view.make_model_grid(session=self.session)
                self.assertIn("delete-results", grid.tools)

    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.assertIs(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")

    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,
            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
                self.request.method = "POST"
                self.request.POST = {
                    "name": "foo.bar",
                    "value": "froogle",
                }
                with patch.object(view, "persist", new=persist):
                    response = view.edit()
                # nb. should get redirect back to view page
                self.assertEqual(response.status_code, 302)
                # setting should be updated in DB
                self.assertEqual(
                    self.app.get_setting(self.session, "foo.bar"), "froogle"
                )

                # 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.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"
                )

    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.session.commit()
        self.assertEqual(self.session.query(model.Setting).count(), 1)

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

        # sanity/coverage check using /settings/XXX/delete
        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/"),
            form_fields=["name", "value"],
        ):
            view = mod.MasterView(self.request)
            with patch.object(view, "get_instance", new=get_instance):

                # get the form page
                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"])

                self.request.method = "POST"
                self.request.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(), 1)

                    # 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(), 0)

    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_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")
        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"] = []
                        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_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_get_rows_title(self):
        view = self.make_view()

        # no default
        self.assertIsNone(view.get_rows_title())

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


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"],
            )

            # 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_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)

        user = model.User(username="fred")
        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()
                versions = view.get_relevant_versions(txn, user)
                self.assertEqual(len(versions), 1)
                version = versions[0]
                self.assertIsInstance(version, vercls)

    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,
                    )