800 lines
29 KiB
Python
800 lines
29 KiB
Python
# -*- coding: utf-8; -*-
|
|
|
|
import decimal
|
|
import json
|
|
import uuid as _uuid
|
|
from unittest import TestCase
|
|
from unittest.mock import patch, MagicMock
|
|
|
|
import colander
|
|
from fanstatic import Library, Resource
|
|
from pyramid import testing
|
|
|
|
from wuttjamaican.conf import WuttaConfig
|
|
from wuttjamaican.testing import ConfigTestCase, DataTestCase
|
|
from wuttjamaican.util import resource_path
|
|
|
|
from wuttaweb import util as mod
|
|
from wuttaweb.app import establish_theme
|
|
from wuttaweb.grids import Grid
|
|
from wuttaweb.testing import WebTestCase
|
|
|
|
|
|
class TestFieldList(TestCase):
|
|
|
|
def test_insert_before(self):
|
|
fields = mod.FieldList(["f1", "f2"])
|
|
self.assertEqual(fields, ["f1", "f2"])
|
|
|
|
# typical
|
|
fields.insert_before("f1", "XXX")
|
|
self.assertEqual(fields, ["XXX", "f1", "f2"])
|
|
fields.insert_before("f2", "YYY")
|
|
self.assertEqual(fields, ["XXX", "f1", "YYY", "f2"])
|
|
|
|
# appends new field if reference field is invalid
|
|
fields.insert_before("f3", "ZZZ")
|
|
self.assertEqual(fields, ["XXX", "f1", "YYY", "f2", "ZZZ"])
|
|
|
|
def test_insert_after(self):
|
|
fields = mod.FieldList(["f1", "f2"])
|
|
self.assertEqual(fields, ["f1", "f2"])
|
|
|
|
# typical
|
|
fields.insert_after("f1", "XXX")
|
|
self.assertEqual(fields, ["f1", "XXX", "f2"])
|
|
fields.insert_after("XXX", "YYY")
|
|
self.assertEqual(fields, ["f1", "XXX", "YYY", "f2"])
|
|
|
|
# appends new field if reference field is invalid
|
|
fields.insert_after("f3", "ZZZ")
|
|
self.assertEqual(fields, ["f1", "XXX", "YYY", "f2", "ZZZ"])
|
|
|
|
def test_set_sequence(self):
|
|
fields = mod.FieldList(["f5", "f1", "f3", "f4", "f2"])
|
|
|
|
# setting sequence will only "sort" for explicit fields.
|
|
# other fields remain in original order, but at the end.
|
|
fields.set_sequence(["f1", "f2", "f3"])
|
|
self.assertEqual(fields, ["f1", "f2", "f3", "f5", "f4"])
|
|
|
|
|
|
class TestGetLibVer(TestCase):
|
|
|
|
def setUp(self):
|
|
self.config = WuttaConfig()
|
|
self.request = testing.DummyRequest()
|
|
self.request.wutta_config = self.config
|
|
|
|
def test_buefy_default(self):
|
|
version = mod.get_libver(self.request, "buefy")
|
|
self.assertEqual(version, "0.9.25")
|
|
|
|
def test_buefy_custom_old(self):
|
|
self.config.setdefault("wuttaweb.buefy_version", "0.9.29")
|
|
version = mod.get_libver(self.request, "buefy")
|
|
self.assertEqual(version, "0.9.29")
|
|
|
|
def test_buefy_custom_old_tailbone(self):
|
|
self.config.setdefault("tailbone.libver.buefy", "0.9.28")
|
|
version = mod.get_libver(self.request, "buefy", prefix="tailbone")
|
|
self.assertEqual(version, "0.9.28")
|
|
|
|
def test_buefy_custom_new(self):
|
|
self.config.setdefault("wuttaweb.libver.buefy", "0.9.29")
|
|
version = mod.get_libver(self.request, "buefy")
|
|
self.assertEqual(version, "0.9.29")
|
|
|
|
def test_buefy_configured_only(self):
|
|
version = mod.get_libver(self.request, "buefy", configured_only=True)
|
|
self.assertIsNone(version)
|
|
|
|
def test_buefy_default_only(self):
|
|
self.config.setdefault("wuttaweb.libver.buefy", "0.9.29")
|
|
version = mod.get_libver(self.request, "buefy", default_only=True)
|
|
self.assertEqual(version, "0.9.25")
|
|
|
|
def test_buefy_css_default(self):
|
|
version = mod.get_libver(self.request, "buefy.css")
|
|
self.assertEqual(version, "0.9.25")
|
|
|
|
def test_buefy_css_custom_old(self):
|
|
# nb. this uses same setting as buefy (js)
|
|
self.config.setdefault("wuttaweb.buefy_version", "0.9.29")
|
|
version = mod.get_libver(self.request, "buefy.css")
|
|
self.assertEqual(version, "0.9.29")
|
|
|
|
def test_buefy_css_custom_new(self):
|
|
# nb. this uses same setting as buefy (js)
|
|
self.config.setdefault("wuttaweb.libver.buefy", "0.9.29")
|
|
version = mod.get_libver(self.request, "buefy.css")
|
|
self.assertEqual(version, "0.9.29")
|
|
|
|
def test_buefy_css_configured_only(self):
|
|
version = mod.get_libver(self.request, "buefy.css", configured_only=True)
|
|
self.assertIsNone(version)
|
|
|
|
def test_buefy_css_default_only(self):
|
|
self.config.setdefault("wuttaweb.libver.buefy", "0.9.29")
|
|
version = mod.get_libver(self.request, "buefy.css", default_only=True)
|
|
self.assertEqual(version, "0.9.25")
|
|
|
|
def test_vue_default(self):
|
|
version = mod.get_libver(self.request, "vue")
|
|
self.assertEqual(version, "2.6.14")
|
|
|
|
def test_vue_custom_old(self):
|
|
self.config.setdefault("wuttaweb.vue_version", "3.4.31")
|
|
version = mod.get_libver(self.request, "vue")
|
|
self.assertEqual(version, "3.4.31")
|
|
|
|
def test_vue_custom_new(self):
|
|
self.config.setdefault("wuttaweb.libver.vue", "3.4.31")
|
|
version = mod.get_libver(self.request, "vue")
|
|
self.assertEqual(version, "3.4.31")
|
|
|
|
def test_vue_configured_only(self):
|
|
version = mod.get_libver(self.request, "vue", configured_only=True)
|
|
self.assertIsNone(version)
|
|
|
|
def test_vue_default_only(self):
|
|
self.config.setdefault("wuttaweb.libver.vue", "3.4.31")
|
|
version = mod.get_libver(self.request, "vue", default_only=True)
|
|
self.assertEqual(version, "2.6.14")
|
|
|
|
def test_vue_resource_default(self):
|
|
version = mod.get_libver(self.request, "vue_resource")
|
|
self.assertEqual(version, "1.5.3")
|
|
|
|
def test_vue_resource_custom(self):
|
|
self.config.setdefault("wuttaweb.libver.vue_resource", "1.5.3")
|
|
version = mod.get_libver(self.request, "vue_resource")
|
|
self.assertEqual(version, "1.5.3")
|
|
|
|
def test_fontawesome_default(self):
|
|
version = mod.get_libver(self.request, "fontawesome")
|
|
self.assertEqual(version, "5.3.1")
|
|
|
|
def test_fontawesome_custom(self):
|
|
self.config.setdefault("wuttaweb.libver.fontawesome", "5.6.3")
|
|
version = mod.get_libver(self.request, "fontawesome")
|
|
self.assertEqual(version, "5.6.3")
|
|
|
|
def test_bb_vue_default(self):
|
|
version = mod.get_libver(self.request, "bb_vue")
|
|
self.assertEqual(version, "3.5.18")
|
|
|
|
def test_bb_vue_custom(self):
|
|
self.config.setdefault("wuttaweb.libver.bb_vue", "3.4.30")
|
|
version = mod.get_libver(self.request, "bb_vue")
|
|
self.assertEqual(version, "3.4.30")
|
|
|
|
def test_bb_oruga_default(self):
|
|
version = mod.get_libver(self.request, "bb_oruga")
|
|
self.assertEqual(version, "0.11.4")
|
|
|
|
def test_bb_oruga_custom(self):
|
|
self.config.setdefault("wuttaweb.libver.bb_oruga", "0.8.11")
|
|
version = mod.get_libver(self.request, "bb_oruga")
|
|
self.assertEqual(version, "0.8.11")
|
|
|
|
def test_bb_oruga_bulma_default(self):
|
|
version = mod.get_libver(self.request, "bb_oruga_bulma")
|
|
self.assertEqual(version, "0.7.3")
|
|
version = mod.get_libver(self.request, "bb_oruga_bulma_css")
|
|
self.assertEqual(version, "0.7.3")
|
|
|
|
def test_bb_oruga_bulma_custom(self):
|
|
self.config.setdefault("wuttaweb.libver.bb_oruga_bulma", "0.2.11")
|
|
version = mod.get_libver(self.request, "bb_oruga_bulma")
|
|
self.assertEqual(version, "0.2.11")
|
|
|
|
def test_bb_fontawesome_svg_core_default(self):
|
|
version = mod.get_libver(self.request, "bb_fontawesome_svg_core")
|
|
self.assertEqual(version, "7.0.0")
|
|
|
|
def test_bb_fontawesome_svg_core_custom(self):
|
|
self.config.setdefault("wuttaweb.libver.bb_fontawesome_svg_core", "6.5.1")
|
|
version = mod.get_libver(self.request, "bb_fontawesome_svg_core")
|
|
self.assertEqual(version, "6.5.1")
|
|
|
|
def test_bb_free_solid_svg_icons_default(self):
|
|
version = mod.get_libver(self.request, "bb_free_solid_svg_icons")
|
|
self.assertEqual(version, "7.0.0")
|
|
|
|
def test_bb_free_solid_svg_icons_custom(self):
|
|
self.config.setdefault("wuttaweb.libver.bb_free_solid_svg_icons", "6.5.1")
|
|
version = mod.get_libver(self.request, "bb_free_solid_svg_icons")
|
|
self.assertEqual(version, "6.5.1")
|
|
|
|
def test_bb_vue_fontawesome_default(self):
|
|
version = mod.get_libver(self.request, "bb_vue_fontawesome")
|
|
self.assertEqual(version, "3.1.1")
|
|
|
|
def test_bb_vue_fontawesome_custom(self):
|
|
self.config.setdefault("wuttaweb.libver.bb_vue_fontawesome", "3.0.8")
|
|
version = mod.get_libver(self.request, "bb_vue_fontawesome")
|
|
self.assertEqual(version, "3.0.8")
|
|
|
|
|
|
libcache = Library("testing", "libcache")
|
|
vue_js = Resource(libcache, "vue.js")
|
|
vue_resource_js = Resource(libcache, "vue_resource.js")
|
|
buefy_js = Resource(libcache, "buefy.js")
|
|
buefy_css = Resource(libcache, "buefy.css")
|
|
fontawesome_js = Resource(libcache, "fontawesome.js")
|
|
bb_vue_js = Resource(libcache, "bb_vue.js")
|
|
bb_oruga_js = Resource(libcache, "bb_oruga.js")
|
|
bb_oruga_bulma_js = Resource(libcache, "bb_oruga_bulma.js")
|
|
bb_oruga_bulma_css = Resource(libcache, "bb_oruga_bulma.css")
|
|
bb_fontawesome_svg_core_js = Resource(libcache, "bb_fontawesome_svg_core.js")
|
|
bb_free_solid_svg_icons_js = Resource(libcache, "bb_free_solid_svg_icons.js")
|
|
bb_vue_fontawesome_js = Resource(libcache, "bb_vue_fontawesome.js")
|
|
|
|
|
|
class TestGetLibUrl(TestCase):
|
|
|
|
def setUp(self):
|
|
self.config = WuttaConfig()
|
|
self.request = testing.DummyRequest(wutta_config=self.config)
|
|
self.pyramid_config = testing.setUp(request=self.request)
|
|
|
|
def tearDown(self):
|
|
testing.tearDown()
|
|
|
|
def setup_fanstatic(self, register=True):
|
|
self.pyramid_config.include("pyramid_fanstatic")
|
|
if register:
|
|
self.config.setdefault("wuttaweb.static_libcache.module", "tests.test_util")
|
|
|
|
needed = MagicMock()
|
|
needed.library_url = MagicMock(return_value="/fanstatic")
|
|
self.request.environ["fanstatic.needed"] = needed
|
|
self.request.script_name = "/wutta"
|
|
|
|
def test_unknown(self):
|
|
url = mod.get_liburl(self.request, "unknown")
|
|
self.assertIsNone(url)
|
|
|
|
def test_buefy_default(self):
|
|
url = mod.get_liburl(self.request, "buefy")
|
|
self.assertEqual(url, "https://unpkg.com/buefy@0.9.25/dist/buefy.min.js")
|
|
|
|
def test_buefy_custom(self):
|
|
self.config.setdefault("wuttaweb.liburl.buefy", "/lib/buefy.js")
|
|
url = mod.get_liburl(self.request, "buefy")
|
|
self.assertEqual(url, "/lib/buefy.js")
|
|
|
|
def test_buefy_custom_tailbone(self):
|
|
self.config.setdefault("tailbone.liburl.buefy", "/tailbone/buefy.js")
|
|
url = mod.get_liburl(self.request, "buefy", prefix="tailbone")
|
|
self.assertEqual(url, "/tailbone/buefy.js")
|
|
|
|
def test_buefy_default_only(self):
|
|
self.config.setdefault("wuttaweb.liburl.buefy", "/lib/buefy.js")
|
|
url = mod.get_liburl(self.request, "buefy", default_only=True)
|
|
self.assertEqual(url, "https://unpkg.com/buefy@0.9.25/dist/buefy.min.js")
|
|
|
|
def test_buefy_configured_only(self):
|
|
url = mod.get_liburl(self.request, "buefy", configured_only=True)
|
|
self.assertIsNone(url)
|
|
|
|
def test_buefy_fanstatic(self):
|
|
self.setup_fanstatic()
|
|
url = mod.get_liburl(self.request, "buefy")
|
|
self.assertEqual(url, "/wutta/fanstatic/buefy.js")
|
|
|
|
def test_buefy_fanstatic_tailbone(self):
|
|
self.setup_fanstatic(register=False)
|
|
self.config.setdefault("tailbone.static_libcache.module", "tests.test_util")
|
|
url = mod.get_liburl(self.request, "buefy", prefix="tailbone")
|
|
self.assertEqual(url, "/wutta/fanstatic/buefy.js")
|
|
|
|
def test_buefy_css_default(self):
|
|
url = mod.get_liburl(self.request, "buefy.css")
|
|
self.assertEqual(url, "https://unpkg.com/buefy@0.9.25/dist/buefy.min.css")
|
|
|
|
def test_buefy_css_custom(self):
|
|
self.config.setdefault("wuttaweb.liburl.buefy.css", "/lib/buefy.css")
|
|
url = mod.get_liburl(self.request, "buefy.css")
|
|
self.assertEqual(url, "/lib/buefy.css")
|
|
|
|
def test_buefy_css_fanstatic(self):
|
|
self.setup_fanstatic()
|
|
url = mod.get_liburl(self.request, "buefy.css")
|
|
self.assertEqual(url, "/wutta/fanstatic/buefy.css")
|
|
|
|
def test_vue_default(self):
|
|
url = mod.get_liburl(self.request, "vue")
|
|
self.assertEqual(url, "https://unpkg.com/vue@2.6.14/dist/vue.min.js")
|
|
|
|
def test_vue_custom(self):
|
|
self.config.setdefault("wuttaweb.liburl.vue", "/lib/vue.js")
|
|
url = mod.get_liburl(self.request, "vue")
|
|
self.assertEqual(url, "/lib/vue.js")
|
|
|
|
def test_vue_fanstatic(self):
|
|
self.setup_fanstatic()
|
|
url = mod.get_liburl(self.request, "vue")
|
|
self.assertEqual(url, "/wutta/fanstatic/vue.js")
|
|
|
|
def test_vue_resource_default(self):
|
|
url = mod.get_liburl(self.request, "vue_resource")
|
|
self.assertEqual(url, "https://cdn.jsdelivr.net/npm/vue-resource@1.5.3")
|
|
|
|
def test_vue_resource_custom(self):
|
|
self.config.setdefault("wuttaweb.liburl.vue_resource", "/lib/vue-resource.js")
|
|
url = mod.get_liburl(self.request, "vue_resource")
|
|
self.assertEqual(url, "/lib/vue-resource.js")
|
|
|
|
def test_vue_resource_fanstatic(self):
|
|
self.setup_fanstatic()
|
|
url = mod.get_liburl(self.request, "vue_resource")
|
|
self.assertEqual(url, "/wutta/fanstatic/vue_resource.js")
|
|
|
|
def test_fontawesome_default(self):
|
|
url = mod.get_liburl(self.request, "fontawesome")
|
|
self.assertEqual(url, "https://use.fontawesome.com/releases/v5.3.1/js/all.js")
|
|
|
|
def test_fontawesome_custom(self):
|
|
self.config.setdefault("wuttaweb.liburl.fontawesome", "/lib/fontawesome.js")
|
|
url = mod.get_liburl(self.request, "fontawesome")
|
|
self.assertEqual(url, "/lib/fontawesome.js")
|
|
|
|
def test_fontawesome_fanstatic(self):
|
|
self.setup_fanstatic()
|
|
url = mod.get_liburl(self.request, "fontawesome")
|
|
self.assertEqual(url, "/wutta/fanstatic/fontawesome.js")
|
|
|
|
def test_bb_vue_default(self):
|
|
url = mod.get_liburl(self.request, "bb_vue")
|
|
self.assertEqual(
|
|
url, "https://unpkg.com/vue@3.5.18/dist/vue.esm-browser.prod.js"
|
|
)
|
|
|
|
def test_bb_vue_custom(self):
|
|
self.config.setdefault("wuttaweb.liburl.bb_vue", "/lib/vue.js")
|
|
url = mod.get_liburl(self.request, "bb_vue")
|
|
self.assertEqual(url, "/lib/vue.js")
|
|
|
|
def test_bb_vue_fanstatic(self):
|
|
self.setup_fanstatic()
|
|
url = mod.get_liburl(self.request, "bb_vue")
|
|
self.assertEqual(url, "/wutta/fanstatic/bb_vue.js")
|
|
|
|
def test_bb_oruga_default(self):
|
|
url = mod.get_liburl(self.request, "bb_oruga")
|
|
self.assertEqual(
|
|
url, "https://unpkg.com/@oruga-ui/oruga-next@0.11.4/dist/oruga.mjs"
|
|
)
|
|
|
|
def test_bb_oruga_custom(self):
|
|
self.config.setdefault("wuttaweb.liburl.bb_oruga", "/lib/oruga.js")
|
|
url = mod.get_liburl(self.request, "bb_oruga")
|
|
self.assertEqual(url, "/lib/oruga.js")
|
|
|
|
def test_bb_oruga_fanstatic(self):
|
|
self.setup_fanstatic()
|
|
url = mod.get_liburl(self.request, "bb_oruga")
|
|
self.assertEqual(url, "/wutta/fanstatic/bb_oruga.js")
|
|
|
|
def test_bb_oruga_bulma_default(self):
|
|
url = mod.get_liburl(self.request, "bb_oruga_bulma")
|
|
self.assertEqual(
|
|
url, "https://unpkg.com/@oruga-ui/theme-bulma@0.7.3/dist/bulma.js"
|
|
)
|
|
|
|
def test_bb_oruga_bulma_custom(self):
|
|
self.config.setdefault("wuttaweb.liburl.bb_oruga_bulma", "/lib/oruga_bulma.js")
|
|
url = mod.get_liburl(self.request, "bb_oruga_bulma")
|
|
self.assertEqual(url, "/lib/oruga_bulma.js")
|
|
|
|
def test_bb_oruga_bulma_fanstatic(self):
|
|
self.setup_fanstatic()
|
|
url = mod.get_liburl(self.request, "bb_oruga_bulma")
|
|
self.assertEqual(url, "/wutta/fanstatic/bb_oruga_bulma.js")
|
|
|
|
def test_bb_oruga_bulma_css_default(self):
|
|
url = mod.get_liburl(self.request, "bb_oruga_bulma_css")
|
|
self.assertEqual(
|
|
url, "https://unpkg.com/@oruga-ui/theme-bulma@0.7.3/dist/bulma.css"
|
|
)
|
|
|
|
def test_bb_oruga_bulma_css_custom(self):
|
|
self.config.setdefault(
|
|
"wuttaweb.liburl.bb_oruga_bulma_css", "/lib/oruga-bulma.css"
|
|
)
|
|
url = mod.get_liburl(self.request, "bb_oruga_bulma_css")
|
|
self.assertEqual(url, "/lib/oruga-bulma.css")
|
|
|
|
def test_bb_oruga_bulma_css_fanstatic(self):
|
|
self.setup_fanstatic()
|
|
url = mod.get_liburl(self.request, "bb_oruga_bulma_css")
|
|
self.assertEqual(url, "/wutta/fanstatic/bb_oruga_bulma.css")
|
|
|
|
def test_bb_fontawesome_svg_core_default(self):
|
|
url = mod.get_liburl(self.request, "bb_fontawesome_svg_core")
|
|
self.assertEqual(
|
|
url,
|
|
"https://cdn.jsdelivr.net/npm/@fortawesome/fontawesome-svg-core@7.0.0/+esm",
|
|
)
|
|
|
|
def test_bb_fontawesome_svg_core_custom(self):
|
|
self.config.setdefault(
|
|
"wuttaweb.liburl.bb_fontawesome_svg_core", "/lib/fontawesome-svg-core.js"
|
|
)
|
|
url = mod.get_liburl(self.request, "bb_fontawesome_svg_core")
|
|
self.assertEqual(url, "/lib/fontawesome-svg-core.js")
|
|
|
|
def test_bb_fontawesome_svg_core_fanstatic(self):
|
|
self.setup_fanstatic()
|
|
url = mod.get_liburl(self.request, "bb_fontawesome_svg_core")
|
|
self.assertEqual(url, "/wutta/fanstatic/bb_fontawesome_svg_core.js")
|
|
|
|
def test_bb_free_solid_svg_icons_default(self):
|
|
url = mod.get_liburl(self.request, "bb_free_solid_svg_icons")
|
|
self.assertEqual(
|
|
url,
|
|
"https://cdn.jsdelivr.net/npm/@fortawesome/free-solid-svg-icons@7.0.0/+esm",
|
|
)
|
|
|
|
def test_bb_free_solid_svg_icons_custom(self):
|
|
self.config.setdefault(
|
|
"wuttaweb.liburl.bb_free_solid_svg_icons", "/lib/free-solid-svg-icons.js"
|
|
)
|
|
url = mod.get_liburl(self.request, "bb_free_solid_svg_icons")
|
|
self.assertEqual(url, "/lib/free-solid-svg-icons.js")
|
|
|
|
def test_bb_free_solid_svg_icons_fanstatic(self):
|
|
self.setup_fanstatic()
|
|
url = mod.get_liburl(self.request, "bb_free_solid_svg_icons")
|
|
self.assertEqual(url, "/wutta/fanstatic/bb_free_solid_svg_icons.js")
|
|
|
|
def test_bb_vue_fontawesome_default(self):
|
|
url = mod.get_liburl(self.request, "bb_vue_fontawesome")
|
|
self.assertEqual(
|
|
url, "https://cdn.jsdelivr.net/npm/@fortawesome/vue-fontawesome@3.1.1/+esm"
|
|
)
|
|
|
|
def test_bb_vue_fontawesome_custom(self):
|
|
self.config.setdefault(
|
|
"wuttaweb.liburl.bb_vue_fontawesome", "/lib/vue-fontawesome.js"
|
|
)
|
|
url = mod.get_liburl(self.request, "bb_vue_fontawesome")
|
|
self.assertEqual(url, "/lib/vue-fontawesome.js")
|
|
|
|
def test_bb_vue_fontawesome_fanstatic(self):
|
|
self.setup_fanstatic()
|
|
url = mod.get_liburl(self.request, "bb_vue_fontawesome")
|
|
self.assertEqual(url, "/wutta/fanstatic/bb_vue_fontawesome.js")
|
|
|
|
|
|
class TestGetFormData(TestCase):
|
|
|
|
def setUp(self):
|
|
self.config = WuttaConfig()
|
|
|
|
def make_request(self, **kwargs):
|
|
kwargs.setdefault("wutta_config", self.config)
|
|
kwargs.setdefault("POST", {"foo1": "bar"})
|
|
kwargs.setdefault("json_body", {"foo2": "baz"})
|
|
return testing.DummyRequest(**kwargs)
|
|
|
|
def test_default(self):
|
|
request = self.make_request()
|
|
data = mod.get_form_data(request)
|
|
self.assertEqual(data, {"foo1": "bar"})
|
|
|
|
def test_is_xhr(self):
|
|
request = self.make_request(POST=None, is_xhr=True)
|
|
data = mod.get_form_data(request)
|
|
self.assertEqual(data, {"foo2": "baz"})
|
|
|
|
def test_content_type(self):
|
|
request = self.make_request(POST=None, content_type="application/json")
|
|
data = mod.get_form_data(request)
|
|
self.assertEqual(data, {"foo2": "baz"})
|
|
|
|
|
|
class TestGetModelFields(ConfigTestCase):
|
|
|
|
def test_empty_model_class(self):
|
|
fields = mod.get_model_fields(self.config, None)
|
|
self.assertIsNone(fields)
|
|
|
|
def test_unknown_model_class(self):
|
|
fields = mod.get_model_fields(self.config, TestCase)
|
|
self.assertIsNone(fields)
|
|
|
|
def test_basic(self):
|
|
model = self.app.model
|
|
fields = mod.get_model_fields(self.config, model.Setting)
|
|
self.assertEqual(fields, ["name", "value"])
|
|
|
|
def test_include_fk(self):
|
|
model = self.app.model
|
|
|
|
# fk excluded by default
|
|
fields = mod.get_model_fields(self.config, model.User)
|
|
self.assertNotIn("person_uuid", fields)
|
|
self.assertIn("person", fields)
|
|
|
|
# fk can be included
|
|
fields = mod.get_model_fields(self.config, model.User, include_fk=True)
|
|
self.assertIn("person_uuid", fields)
|
|
self.assertIn("person", fields)
|
|
|
|
def test_avoid_versions(self):
|
|
model = self.app.model
|
|
|
|
mapper = MagicMock(
|
|
iterate_properties=[
|
|
MagicMock(key="uuid"),
|
|
MagicMock(key="full_name"),
|
|
MagicMock(key="first_name"),
|
|
MagicMock(key="middle_name"),
|
|
MagicMock(key="last_name"),
|
|
MagicMock(key="versions"),
|
|
]
|
|
)
|
|
|
|
with patch.object(mod, "sa") as sa:
|
|
sa.inspect.return_value = mapper
|
|
|
|
with patch.object(self.app, "continuum_is_enabled", return_value=True):
|
|
fields = mod.get_model_fields(self.config, model.Person)
|
|
# nb. no versions field
|
|
self.assertEqual(
|
|
set(fields),
|
|
set(
|
|
["uuid", "full_name", "first_name", "middle_name", "last_name"]
|
|
),
|
|
)
|
|
|
|
|
|
class TestGetCsrfToken(TestCase):
|
|
|
|
def setUp(self):
|
|
self.config = WuttaConfig()
|
|
self.request = testing.DummyRequest(wutta_config=self.config)
|
|
|
|
def test_same_token(self):
|
|
|
|
# same token returned for same request
|
|
# TODO: dummy request is always returning same token!
|
|
# so this isn't really testing anything.. :(
|
|
first = mod.get_csrf_token(self.request)
|
|
self.assertIsNotNone(first)
|
|
second = mod.get_csrf_token(self.request)
|
|
self.assertEqual(first, second)
|
|
|
|
# TODO: ideally would make a new request here and confirm it
|
|
# gets a different token, but see note above..
|
|
|
|
def test_new_token(self):
|
|
|
|
# nb. dummy request always returns same token, so must
|
|
# trick it into thinking it doesn't have one yet
|
|
with patch.object(self.request.session, "get_csrf_token", return_value=None):
|
|
token = mod.get_csrf_token(self.request)
|
|
self.assertIsNotNone(token)
|
|
|
|
|
|
class TestRenderCsrfToken(TestCase):
|
|
|
|
def setUp(self):
|
|
self.config = WuttaConfig()
|
|
self.request = testing.DummyRequest(wutta_config=self.config)
|
|
|
|
def test_basics(self):
|
|
html = mod.render_csrf_token(self.request)
|
|
self.assertIn('type="hidden"', html)
|
|
self.assertIn('name="_csrf"', html)
|
|
token = mod.get_csrf_token(self.request)
|
|
self.assertIn(f'value="{token}"', html)
|
|
|
|
|
|
class TestMakeJsonSafe(TestCase):
|
|
|
|
def setUp(self):
|
|
self.config = WuttaConfig()
|
|
self.app = self.config.get_app()
|
|
|
|
def test_null(self):
|
|
value = mod.make_json_safe(colander.null)
|
|
self.assertIsNone(value)
|
|
|
|
value = mod.make_json_safe(None)
|
|
self.assertIsNone(value)
|
|
|
|
def test_invalid(self):
|
|
model = self.app.model
|
|
person = model.Person(full_name="Betty Boop")
|
|
self.assertRaises(TypeError, json.dumps, person)
|
|
value = mod.make_json_safe(person, key="person")
|
|
self.assertEqual(value, "Betty Boop")
|
|
|
|
def test_uuid(self):
|
|
uuid = _uuid.uuid4()
|
|
value = mod.make_json_safe(uuid)
|
|
self.assertEqual(value, uuid.hex)
|
|
|
|
def test_decimal(self):
|
|
value = decimal.Decimal("42.42")
|
|
self.assertNotEqual(value, 42.42)
|
|
result = mod.make_json_safe(value)
|
|
self.assertEqual(result, 42.42)
|
|
|
|
def test_dict(self):
|
|
model = self.app.model
|
|
person = model.Person(full_name="Betty Boop")
|
|
|
|
data = {
|
|
"foo": "bar",
|
|
"person": person,
|
|
}
|
|
|
|
self.assertRaises(TypeError, json.dumps, data)
|
|
value = mod.make_json_safe(data)
|
|
self.assertEqual(
|
|
value,
|
|
{
|
|
"foo": "bar",
|
|
"person": "Betty Boop",
|
|
},
|
|
)
|
|
|
|
def test_list(self):
|
|
model = self.app.model
|
|
person = model.Person(full_name="Betty Boop")
|
|
|
|
data = [
|
|
"foo",
|
|
"bar",
|
|
person,
|
|
]
|
|
|
|
self.assertRaises(TypeError, json.dumps, data)
|
|
value = mod.make_json_safe(data)
|
|
self.assertEqual(
|
|
value,
|
|
[
|
|
"foo",
|
|
"bar",
|
|
"Betty Boop",
|
|
],
|
|
)
|
|
|
|
|
|
class TestRenderVueFinalize(TestCase):
|
|
|
|
def basic(self):
|
|
html = mod.render_vue_finalize("wutta-grid", "WuttaGrid")
|
|
self.assertIn("<script>", html)
|
|
self.assertIn("Vue.component('wutta-grid', WuttaGrid)", html)
|
|
|
|
|
|
class TestMakeUsersGrid(WebTestCase):
|
|
|
|
def test_make_users_grid(self):
|
|
self.pyramid_config.add_route("users.view", "/users/{uuid}/view")
|
|
self.pyramid_config.add_route("users.edit", "/users/{uuid}/edit")
|
|
model = self.app.model
|
|
person = model.Person(full_name="John Doe")
|
|
self.session.add(person)
|
|
user = model.User(username="john", person=person)
|
|
self.session.add(user)
|
|
self.session.commit()
|
|
|
|
# basic (no actions because not prvileged)
|
|
grid = mod.make_users_grid(self.request, key="blah.users", data=person.users)
|
|
self.assertIsInstance(grid, Grid)
|
|
self.assertFalse(grid.linked_columns)
|
|
self.assertFalse(grid.actions)
|
|
|
|
# key may be derived from route_prefix
|
|
grid = mod.make_users_grid(self.request, route_prefix="foo")
|
|
self.assertIsInstance(grid, Grid)
|
|
self.assertEqual(grid.key, "foo.view.users")
|
|
|
|
# view + edit actions (because root)
|
|
with patch.object(self.request, "is_root", new=True):
|
|
grid = mod.make_users_grid(
|
|
self.request, key="blah.users", data=person.users
|
|
)
|
|
self.assertIsInstance(grid, Grid)
|
|
self.assertIn("username", grid.linked_columns)
|
|
self.assertEqual(len(grid.actions), 2)
|
|
self.assertEqual(grid.actions[0].key, "view")
|
|
self.assertEqual(grid.actions[1].key, "edit")
|
|
|
|
# render grid to ensure coverage for link urls
|
|
grid.render_vue_template()
|
|
|
|
|
|
class TestGetAvailableThemes(TestCase):
|
|
|
|
def setUp(self):
|
|
self.config = WuttaConfig()
|
|
self.app = self.config.get_app()
|
|
|
|
def test_defaults(self):
|
|
themes = mod.get_available_themes(self.config)
|
|
self.assertEqual(themes, ["default", "butterfly"])
|
|
|
|
def test_sorting(self):
|
|
self.config.setdefault("wuttaweb.themes.keys", "default, foo2, foo4, foo1")
|
|
themes = mod.get_available_themes(self.config)
|
|
self.assertEqual(themes, ["default", "foo1", "foo2", "foo4"])
|
|
|
|
def test_default_omitted(self):
|
|
self.config.setdefault("wuttaweb.themes.keys", "butterfly, foo")
|
|
themes = mod.get_available_themes(self.config)
|
|
self.assertEqual(themes, ["default", "butterfly", "foo"])
|
|
|
|
def test_default_notfirst(self):
|
|
self.config.setdefault("wuttaweb.themes.keys", "butterfly, foo, default")
|
|
themes = mod.get_available_themes(self.config)
|
|
self.assertEqual(themes, ["default", "butterfly", "foo"])
|
|
|
|
|
|
class TestGetEffectiveTheme(DataTestCase):
|
|
|
|
def test_default(self):
|
|
theme = mod.get_effective_theme(self.config)
|
|
self.assertEqual(theme, "default")
|
|
|
|
def test_override_config(self):
|
|
self.app.save_setting(self.session, "wuttaweb.theme", "butterfly")
|
|
self.session.commit()
|
|
theme = mod.get_effective_theme(self.config)
|
|
self.assertEqual(theme, "butterfly")
|
|
|
|
def test_override_param(self):
|
|
theme = mod.get_effective_theme(self.config, theme="butterfly")
|
|
self.assertEqual(theme, "butterfly")
|
|
|
|
def test_invalid(self):
|
|
self.assertRaises(
|
|
ValueError, mod.get_effective_theme, self.config, theme="invalid"
|
|
)
|
|
|
|
|
|
class TestThemeTemplatePath(DataTestCase):
|
|
|
|
def test_default(self):
|
|
path = mod.get_theme_template_path(self.config, theme="default")
|
|
# nb. even though the path does not exist, we still want to
|
|
# pretend like it does, hence prev call should return this:
|
|
expected = resource_path("wuttaweb:templates/themes/default")
|
|
self.assertEqual(path, expected)
|
|
|
|
def test_default(self):
|
|
path = mod.get_theme_template_path(self.config, theme="butterfly")
|
|
expected = resource_path("wuttaweb:templates/themes/butterfly")
|
|
self.assertEqual(path, expected)
|
|
|
|
def test_custom(self):
|
|
self.config.setdefault("wuttaweb.themes.keys", "default, butterfly, poser")
|
|
self.config.setdefault("wuttaweb.theme.poser", "/tmp/poser-theme")
|
|
path = mod.get_theme_template_path(self.config, theme="poser")
|
|
self.assertEqual(path, "/tmp/poser-theme")
|
|
|
|
|
|
class TestSetAppTheme(WebTestCase):
|
|
|
|
def test_basic(self):
|
|
|
|
# establish default
|
|
settings = self.request.registry.settings
|
|
self.assertNotIn("wuttaweb.theme", settings)
|
|
establish_theme(settings)
|
|
self.assertEqual(settings["wuttaweb.theme"], "default")
|
|
|
|
# set to butterfly
|
|
mod.set_app_theme(self.request, "butterfly", session=self.session)
|
|
self.assertEqual(settings["wuttaweb.theme"], "butterfly")
|
|
|
|
# set back to default
|
|
mod.set_app_theme(self.request, "default", session=self.session)
|
|
self.assertEqual(settings["wuttaweb.theme"], "default")
|