Merge pull request #26 from NyanKiyoshi/feature/backup-results

Implement the backup command

Author: NyanKiyoshi

.gitignore

@@ -2,6 +2,7 @@
 venv/
 *.pyc
 *.egg-info/
+*wheel*
 .pytest*
 .coverage
 *cov/

README.md

@@ -61,6 +61,8 @@ You will find the [full documentation here](https://pytest-django-queries.readth
 
 ## Integrating with GitHub
 
+TBA.
+
 ## Testing locally
 Simply install `pytest-django-queries` through pip and run your
 tests using `pytest`. A report should have been generated in your
@@ -106,6 +108,13 @@ django-queries html > results.html
 
 ## Comparing results
 
+When running pytest, pass the `--django-backup-queries` (can take a path, optionally)
+then you can run `django-queries diff` to generate results looking like this:
+
+<a href='./docs/_static/diff_results.png'>
+ <img src='./docs/_static/diff_results.png' alt='screenshot' width='500px' />
+</a>
+
 ## Development
 First of all, clone the project locally. Then, install it using the below command.
 

docs/diff.rst

@@ -2,3 +2,11 @@
 
 The Diff Command
 ----------------
+
+The plugin can backup the test results for you if you pass the ``--django-backup-queries [BACKUP_PATH]`` parameter to it. It will create a backup to ``.pytest-query.old`` by default if previous results were found.
+
+.. warning::
+
+ Bear in mind that it will override any existing backup file in the provided or default path.
+
+After running ``pytest --django-backup-queries``, you can run ``django-queries diff`` to show the changes. Make sure you actually had previous results, otherwise it will have nothing to compare.

docs/index.rst

@@ -29,7 +29,8 @@ Quick Start
  def test_another_query_performances(count_queries):
  Model.objects.all()
 
-3. Then use ``django-queries show`` to show the results directly into your console:
+3. Run ``pytest``;
+4. Then use ``django-queries show`` to show the results directly into your console:
 
  .. code-block:: text
 
@@ -53,13 +54,13 @@ Quick Start
  | module3 | |
  +---------+-------------------------+
 
-4. Or for a nicer presentation, use ``django-queries html > results.html`` to export the results as HTML. See `this example <./html_export_results.html>`_ for a demo!
+5. Or for a nicer presentation, use ``django-queries html > results.html`` to export the results as HTML. See `this example <./html_export_results.html>`_ for a demo!
 
  .. image:: _static/html_export_results.png
  :width: 500 px
  :align: center
 
-5. By running it twice with the option described :ref:`here <diff_usage>` and by running ``django-queries diff`` you will get something like this:
+6. By running it twice with the option described :ref:`here <diff_usage>` and by running ``django-queries diff`` you will get something like this:
 
  .. image:: _static/diff_results.png
  :width: 500 px

docs/usage.rst

@@ -1,3 +1,30 @@
+Plugin Usage
+============
+
+The plugin supports some optional parameters that are defined below.
+
+Customizing the Save Path
++++++++++++++++++++++++++
+
+.. code-block:: text
+
+ --django-db-bench=PATH
+ Output file for storing the results. Default: .pytest-queries
+
+
+Backing Up Results
+++++++++++++++++++
+
+You can pass the ``--django-backup-queries`` parameter to backup previous results to `.pytest-django.old``.
+
+Or pass a custom path.
+
+.. code-block:: text
+
+ --django-backup-queries=[PATH]
+ Whether the old results should be backed up or not before overriding.
+
+
 CLI Usage
 =========
 

pytest_django_queries/plugin.py

@@ -1,4 +1,6 @@
 import json
+import shutil
+from os.path import isfile
 
 import pytest
 from django.test.utils import CaptureQueriesContext
@@ -17,16 +19,31 @@ def _get_session(request):
  return request.config.pytest_django_queries_session
 
 
+def _create_backup(save_path, backup_path):
+ shutil.copy(save_path, backup_path)
+
+
 class _Session(object):
- def __init__(self, save_path):
+ def __init__(self, save_path, backup_path):
+ """
+ :param save_path:
+ :type save_path: str
+
+ :param backup_path:
+ :type backup_path: bool
+ """
  self.save_path = save_path
+ self.backup_path = backup_path
  self._data = {}
 
  def add_entry(self, module_name, test_name, query_count):
  module_data = self._data.setdefault(module_name, {})
  module_data[test_name] = {"query-count": query_count}
 
  def save_json(self):
+ if self.backup_path and isfile(self.save_path):
+ _create_backup(self.save_path, self.backup_path)
+
  with open(self.save_path, "w") as fp:
  json.dump(self._data, fp, indent=2)
 
@@ -49,6 +66,15 @@ def pytest_addoption(parser):
  metavar="PATH",
  help="Output file for storing the results. Default: .pytest-queries",
  )
+ group.addoption(
+ "--django-backup-queries",
+ dest="queries_backup_results",
+ action="store",
+ default=None,
+ metavar="PATH",
+ help="Whether the old results should be backed up or not before overriding",
+ nargs="?",
+ )
 
 
 @pytest.mark.tryfirst
@@ -63,10 +89,21 @@ def pytest_configure(config):
 
 @pytest.mark.tryfirst
 def pytest_load_initial_conftests(early_config, parser, args):
- _set_session(
- early_config,
- _Session(early_config.known_args_namespace.queries_results_save_path),
- )
+ """
+ :param early_config:
+ :param parser:
+ :param args:
+ :type args: tuple|list
+ :return:
+ """
+ save_path = early_config.known_args_namespace.queries_results_save_path
+ backup_path = early_config.known_args_namespace.queries_backup_results
+
+ # Set default value if the flag was provided without value in arguments
+ if backup_path is None and "--django-backup-queries" in args:
+ backup_path = DEFAULT_OLD_RESULT_FILENAME
+
+ _set_session(early_config, _Session(save_path, backup_path))
 
 
 @pytest.hookimpl(hookwrapper=True)

requirements_dev.txt

@@ -3,3 +3,4 @@ lxml
 sphinx
 sphinx_rtd_theme
 pre-commit
+mock

setup.cfg

@@ -58,4 +58,4 @@ include_trailing_comma: True
 
 line_length = 88
 known_first_party = pytest_django_queries
-known_third_party =beautifultable,bs4,click,django,jinja2,pytest,setuptools
+known_third_party =beautifultable,bs4,click,django,jinja2,mock,pytest,setuptools

tests/test_plugin.py

@@ -1,5 +1,7 @@
 import json
 
+import mock
+
 DUMMY_TEST_QUERY = """
  import pytest
 
@@ -25,7 +27,7 @@ def test_fixture_is_invoked_when_marked(testdir):
 
  # Run a dummy test that performs queries
  # and triggers a counting of the query number
- testdir.makepyfile(DUMMY_TEST_QUERY)
+ testdir.makepyfile(test_file=DUMMY_TEST_QUERY)
  results = testdir.runpytest("--django-db-bench", results_path)
 
  # Ensure the tests have passed
@@ -34,9 +36,7 @@ def test_fixture_is_invoked_when_marked(testdir):
  # Ensure the results file was created
  assert results_path.check()
  assert json.load(results_path) == {
- "test_fixture_is_invoked_when_marked": {
- "test_count_db_query_number": {"query-count": 2}
- }
+ "test_file": {"test_count_db_query_number": {"query-count": 2}}
  }
 
 
@@ -94,6 +94,94 @@ def test_failure():
  }
 
 
+def test_fixture_is_backing_up_old_results(testdir):
+ """Ensure marking a test is backing up old results if asked to."""
+ results_path = testdir.tmpdir.join("results.json")
+ old_results_path = testdir.tmpdir.join("results.old.json")
+
+ # Run a dummy test that performs queries
+ # and triggers a counting of the query number
+ testdir.makepyfile(test_file=DUMMY_TEST_QUERY)
+
+ results = testdir.runpytest(
+ "--django-db-bench", results_path, "--django-backup-queries", old_results_path
+ )
+
+ # Ensure the tests have passed
+ results.assert_outcomes(1, 0, 0)
+
+ # Ensure the results file was created
+ assert results_path.check()
+ assert (
+ not old_results_path.check()
+ ), "Nothing should have been backed up--there was nothing to back up"
+
+ # Create another test to generate more results,
+ # to ensure the backup results were actually the previous ones
+ testdir.makepyfile(test_otherfile=DUMMY_TEST_QUERY)
+
+ # Run again the tests
+ results = testdir.runpytest(
+ "--django-db-bench", results_path, "--django-backup-queries", old_results_path
+ )
+
+ # Ensure the tests have passed
+ results.assert_outcomes(2, 0, 0)
+
+ # Ensure the results file was created
+ assert results_path.check()
+ assert old_results_path.check(), "The backup file should have been created"
+
+ # Check contents
+ assert json.load(results_path) == {
+ "test_file": {"test_count_db_query_number": {"query-count": 2}},
+ "test_otherfile": {"test_count_db_query_number": {"query-count": 2}},
+ }
+ assert json.load(old_results_path) == {
+ "test_file": {"test_count_db_query_number": {"query-count": 2}}
+ }
+
+
+def test_fixture_is_not_backing_up_if_not_asked_to(testdir):
+ """Ensure marking a test is backing up old results if asked to."""
+ results_path = testdir.tmpdir.join("results.json")
+ results_path.ensure(file=True) # 'touch' the file
+
+ # Run a dummy test that performs queries
+ # and triggers a counting of the query number
+ testdir.makepyfile(test_file=DUMMY_TEST_QUERY)
+
+ with mock.patch("pytest_django_queries.plugin._create_backup") as mocked_backup:
+ results = testdir.runpytest("--django-db-bench", results_path)
+ assert mocked_backup.call_count == 0
+
+ # Ensure the tests have passed
+ results.assert_outcomes(1, 0, 0)
+ assert results_path.check()
+
+
+def test_fixture_is_backing_up_old_results_to_default_path_if_no_path_provided(testdir):
+ """Ensure marking a test is backing up old results if asked to."""
+ results_path = testdir.tmpdir.join("results.json")
+ results_path.ensure(file=True) # 'touch' the file
+
+ # Run a dummy test that performs queries
+ # and triggers a counting of the query number
+ testdir.makepyfile(test_file=DUMMY_TEST_QUERY)
+
+ with mock.patch("pytest_django_queries.plugin._create_backup") as mocked_backup:
+ from pytest_django_queries.plugin import DEFAULT_OLD_RESULT_FILENAME
+
+ results = testdir.runpytest(
+ "--django-db-bench", results_path, "--django-backup-queries"
+ )
+ mocked_backup.assert_called_with(str(results_path), DEFAULT_OLD_RESULT_FILENAME)
+
+ # Ensure the tests have passed
+ results.assert_outcomes(1, 0, 0)
+ assert results_path.check()
+
+
 def test_marker_message(testdir):
  """Ensure the custom markers configuration is added to pytest."""
  result = testdir.runpytest("--markers")
@@ -114,5 +202,8 @@ def test_implements_custom_options(testdir):
  "*--django-db-bench=PATH",
  "*Output file for storing the results. Default: .pytest-",
  "*queries",
+ "*--django-backup-queries=[[]PATH[]]",
+ "*Whether the old results should be backed up or not",
+ "*before overriding",
  ]
  )