Merge pull request #496 from MongoEngine/independency_tests

Added: Tests to check correct work without extra install options, or part of them

Author: insspb

.github/workflows/coverage.yml

@@ -37,7 +37,7 @@ jobs:
       with:
         mongodb-version: ${{ matrix.mongodb-version }}
     - name: Test build
-      run: "nox -s latest --python ${{ matrix.python }} -- --cov-report=xml --cov-report=html"
+      run: "nox -s 'latest-${{ matrix.python }}(wtf=True, toolbar=True)' -- --cov-report=xml --cov-report=html"
     - name: Send coverage report to codecov
       uses: codecov/codecov-action@v3
       with:

noxfile.py

@@ -11,25 +11,33 @@
 db_version = "5.0"
 
 
-def base_install(session, flask, mongoengine):
+def base_install(session, flask, mongoengine, toolbar, wtf):
     """Create basic environment setup for tests and linting."""
+    session.run("python", "-m", "pip", "install", "--upgrade", "pip")
+    session.run("python", "-m", "pip", "install", "setuptools_scm[toml]>=6.3.1")
+
+    if toolbar and wtf:
+        extra = "wtf,toolbar,"
+    elif toolbar:
+        extra = "toolbar,"
+    elif wtf:
+        extra = "wtf,"
+    else:
+        extra = ""
+
     if flask == "==1.1.4":
-        session.run("python", "-m", "pip", "install", "--upgrade", "pip")
-        session.run("python", "-m", "pip", "install", "setuptools_scm[toml]>=6.3.1")
         session.install(
             f"Flask{flask}",
             f"mongoengine{mongoengine}",
             "-e",
-            ".[wtf,toolbar,legacy,legacy-dev]",
+            f".[{extra}legacy,legacy-dev]",
         )
     else:
-        session.run("python", "-m", "pip", "install", "--upgrade", "pip")
-        session.run("python", "-m", "pip", "install", "setuptools_scm[toml]>=6.3.1")
         session.install(
             f"Flask{flask}",
             f"mongoengine{mongoengine}",
             "-e",
-            ".[wtf,toolbar,dev]",
+            f".[{extra}dev]",
         )
     return session
 
@@ -44,9 +52,11 @@ def lint(session):
 @nox.session(python=["3.7", "3.8", "3.9", "3.10", "pypy3.7"])
 @nox.parametrize("flask", ["==1.1.4", "==2.0.3", ">=2.1.2"])
 @nox.parametrize("mongoengine", ["==0.21.0", "==0.22.1", "==0.23.1", ">=0.24.1"])
-def ci_cd_tests(session, flask, mongoengine):
+@nox.parametrize("toolbar", [True, False])
+@nox.parametrize("wtf", [True, False])
+def ci_cd_tests(session, flask, mongoengine, toolbar, wtf):
     """Run test suite with pytest into ci_cd (no docker)."""
-    session = base_install(session, flask, mongoengine)
+    session = base_install(session, flask, mongoengine, toolbar, wtf)
     session.run("pytest", *session.posargs)
 
 
@@ -71,18 +81,22 @@ def _run_in_docker(session):
 @nox.session(python=["3.7", "3.8", "3.9", "3.10", "pypy3.7"])
 @nox.parametrize("flask", ["==1.1.4", "==2.0.3", ">=2.1.2"])
 @nox.parametrize("mongoengine", ["==0.21.0", "==0.22.1", "==0.23.1", ">=0.24.1"])
-def full_tests(session, flask, mongoengine):
+@nox.parametrize("toolbar", [True, False])
+@nox.parametrize("wtf", [True, False])
+def full_tests(session, flask, mongoengine, toolbar, wtf):
     """Run tests locally with docker and complete support matrix."""
-    session = base_install(session, flask, mongoengine)
+    session = base_install(session, flask, mongoengine, toolbar, wtf)
     _run_in_docker(session)
 
 
 @nox.session(python=["3.7", "3.8", "3.9", "3.10", "pypy3.7"])
-def latest(session):
+@nox.parametrize("toolbar", [True, False])
+@nox.parametrize("wtf", [True, False])
+def latest(session, toolbar, wtf):
     """Run minimum tests for checking minimum code quality."""
     flask = ">=2.1.2"
     mongoengine = ">=0.24.1"
-    session = base_install(session, flask, mongoengine)
+    session = base_install(session, flask, mongoengine, toolbar, wtf)
     if session.interactive:
         _run_in_docker(session)
     else:

tests/test_db_fields.py

@@ -5,10 +5,17 @@
 import pytest
 from mongoengine import fields as base_fields
 from pytest_mock import MockerFixture
-from wtforms import validators as wtf_validators_
 
 from flask_mongoengine import db_fields, documents
 
+try:
+    from wtforms import validators as wtf_validators_
+
+    wtforms_not_installed = False
+except ImportError:
+    wtf_validators_ = None
+    wtforms_not_installed = True
+
 
 @pytest.fixture
 def local_app(app):
@@ -44,6 +51,7 @@ class Model(request.param):
 
         return Model
 
+    @pytest.mark.skipif(condition=wtforms_not_installed, reason="No WTF CI/CD chain")
     def test__get_fields_names__is_called_by_to_wtf_form_call(
         self, TempDocument, mocker: MockerFixture
     ):
@@ -79,6 +87,7 @@ def test__to_wtf_form__is_called_by_mixin_child_model(
         TempDocument.to_wtf_form()
         to_wtf_spy.assert_called_once()
 
+    @pytest.mark.skipif(condition=wtforms_not_installed, reason="No WTF CI/CD chain")
     def test__to_wtf_form__logs_error(self, caplog, TempDocument):
         TempDocument.to_wtf_form()
 
@@ -225,6 +234,7 @@ def test__wtf_field_class__return__user_provided_value__if_set(self):
 
         assert issubclass(field.wtf_field_class, str)
 
+    @pytest.mark.skipif(condition=wtforms_not_installed, reason="No WTF CI/CD chain")
     @pytest.mark.parametrize(
         ["user_dict", "expected_result"],
         [
@@ -245,6 +255,7 @@ def test__wtf_field_options__overwrite_generated_options_with_user_provided(
         field = db_fields.WtfFieldMixin(wtf_options=user_dict)
         assert field.wtf_field_options == expected_result
 
+    @pytest.mark.skipif(condition=wtforms_not_installed, reason="No WTF CI/CD chain")
     def test__wtf_generated_options__correctly_retrieve_label_from_parent_class(self):
         """Test based on base class for all fields."""
         default_call = self.WTFieldBaseMRO()
@@ -254,6 +265,7 @@ def test__wtf_generated_options__correctly_retrieve_label_from_parent_class(self
         assert default_call.wtf_generated_options["label"] == "set not by init"
         assert with_option_call.wtf_generated_options["label"] == "fake"
 
+    @pytest.mark.skipif(condition=wtforms_not_installed, reason="No WTF CI/CD chain")
     def test__wtf_generated_options__correctly_retrieve_description_from_parent_class(
         self,
     ):
@@ -263,13 +275,15 @@ def test__wtf_generated_options__correctly_retrieve_description_from_parent_clas
         assert default_call.wtf_generated_options["description"] == ""
         assert with_option_call.wtf_generated_options["description"] == "fake"
 
+    @pytest.mark.skipif(condition=wtforms_not_installed, reason="No WTF CI/CD chain")
     def test__wtf_generated_options__correctly_retrieve_default_from_parent_class(self):
         default_call = self.WTFieldBaseMRO()
         with_option_call = self.WTFieldBaseMRO(default="fake")
 
         assert default_call.wtf_generated_options["default"] is None
         assert with_option_call.wtf_generated_options["default"] == "fake"
 
+    @pytest.mark.skipif(condition=wtforms_not_installed, reason="No WTF CI/CD chain")
     def test__wtf_generated_options__correctly_retrieve_validators_from_parent_class__and__add_optional_validator__if_field_not_required(
         self,
     ):
@@ -286,6 +300,7 @@ def test__wtf_generated_options__correctly_retrieve_validators_from_parent_class
             wtf_validators_.Optional,
         )
 
+    @pytest.mark.skipif(condition=wtforms_not_installed, reason="No WTF CI/CD chain")
     def test__wtf_generated_options__correctly_retrieve_validators_from_parent_class__and__add_required__if_field_required(
         self,
     ):
@@ -302,13 +317,15 @@ def test__wtf_generated_options__correctly_retrieve_validators_from_parent_class
             wtf_validators_.InputRequired,
         )
 
+    @pytest.mark.skipif(condition=wtforms_not_installed, reason="No WTF CI/CD chain")
     def test__wtf_generated_options__correctly_retrieve_filters_from_parent_class(self):
         default_call = self.WTFieldBaseMRO()
         with_option_call = self.WTFieldBaseMRO(wtf_filters=[str, list])
 
         assert default_call.wtf_generated_options["filters"] == []
         assert with_option_call.wtf_generated_options["filters"] == [str, list]
 
+    @pytest.mark.skipif(condition=wtforms_not_installed, reason="No WTF CI/CD chain")
     def test__wtf_generated_options__correctly_handle_choices_settings(self):
         default_call = self.WTFieldBaseMRO(choices=[1, 2])
         with_option_call = self.WTFieldBaseMRO(choices=[1, 2], wtf_choices_coerce=list)
@@ -318,6 +335,7 @@ def test__wtf_generated_options__correctly_handle_choices_settings(self):
         assert with_option_call.wtf_generated_options["choices"] == [1, 2]
         assert with_option_call.wtf_generated_options["coerce"] is list
 
+    @pytest.mark.skipif(condition=wtforms_not_installed, reason="No WTF CI/CD chain")
     def test__to_wtf_field__does_not_modify_anything_if_options_not_provided(self):
         # Setting base validators to exclude patching of .wtf_generated_options()
         field = self.WTFieldBaseMRO(wtf_options={"validators": ["ignore"]})
@@ -328,6 +346,7 @@ def test__to_wtf_field__does_not_modify_anything_if_options_not_provided(self):
 
         field.DEFAULT_WTF_FIELD.assert_called_with(**field_options)
 
+    @pytest.mark.skipif(condition=wtforms_not_installed, reason="No WTF CI/CD chain")
     def test__to_wtf_field__update_field_class_if_related_option_provided(self):
         # Setting base validators to exclude patching of .wtf_generated_options()
         will_be_called = Mock()
@@ -340,6 +359,7 @@ def test__to_wtf_field__update_field_class_if_related_option_provided(self):
         will_not_be_called.assert_not_called()
         will_be_called.assert_called_with(**field_options)
 
+    @pytest.mark.skipif(condition=wtforms_not_installed, reason="No WTF CI/CD chain")
     def test__to_wtf_field__update_field_kwargs_if_related_option_provided(self):
         # Setting base validators to exclude patching of .wtf_generated_options()
         will_be_called = Mock()

tests/test_db_fields_import_protection.py

@@ -1,20 +1,28 @@
 """Testing independency from WTForms."""
+import pytest
+
+try:
+    import wtforms
+
+    wtforms_not_installed = False
+except ImportError:
+    wtforms = None
+    wtforms_not_installed = True
 
 
 class TestImportProtection:
     def test__when_wtforms_available__import_use_its_data(self):
         from flask_mongoengine import db_fields
 
-        assert db_fields.wtf_fields is not None
-        assert db_fields.wtf_validators_ is not None
+        assert db_fields is not None
 
-    def test__core_class_imported_without_error(self, monkeypatch):
-        monkeypatch.setattr("flask_mongoengine.decorators.wtf_installed", False)
+    def test__core_class_imported_without_error(self):
         from flask_mongoengine import MongoEngine
 
         db = MongoEngine()
         assert db is not None
 
+    @pytest.mark.skipif(condition=wtforms_not_installed, reason="No WTF CI/CD chain")
     def test__wtf_required_decorator__when_wtf_installed(self):
         from flask_mongoengine.decorators import wtf_required
 

tests/test_debug_panel.py

@@ -9,14 +9,17 @@
 import pymongo
 import pytest
 from flask import Flask
-from flask_debugtoolbar import DebugToolbarExtension
-from flask_debugtoolbar.panels import DebugPanel
-from jinja2 import ChoiceLoader, DictLoader
-from pymongo import monitoring
-from pymongo.errors import OperationFailure
-from pytest_mock import MockerFixture
-
-from flask_mongoengine.panels import (
+
+flask_debugtoolbar = pytest.importorskip("flask_debugtoolbar")
+
+from flask_debugtoolbar import DebugToolbarExtension  # noqa
+from flask_debugtoolbar.panels import DebugPanel  # noqa
+from jinja2 import ChoiceLoader, DictLoader  # noqa
+from pymongo import monitoring  # noqa
+from pymongo.errors import OperationFailure  # noqa
+from pytest_mock import MockerFixture  # noqa
+
+from flask_mongoengine.panels import (  # noqa
     MongoCommandLogger,
     MongoDebugPanel,
     _maybe_patch_jinja_loader,

tests/test_forms.py

@@ -4,11 +4,14 @@
 import bson
 import flask
 import pytest
-import wtforms
 from mongoengine import NotUniqueError, queryset_manager
 from werkzeug.datastructures import MultiDict
 
-from flask_mongoengine.wtf.orm import model_form
+try:
+    from flask_mongoengine.wtf.orm import model_form
+except ImportError:
+    model_form = None
+wtforms = pytest.importorskip("wtforms")
 
 
 def test_binaryfield(app, db):