Automation rules: add delete version action

Currently we automatically delete inactive versions
when they are deleted from the repository.

If the version is active we keep it,
and users must deactivate it manually.

With this rule users can automate that.
Default versions can't deactivate it,
users must change the default version first.

This is the only rule that is run when a version is deleted.

Closes #7637

Author: stsewd

docs/automation-rules.rst

@@ -61,6 +61,9 @@ Currently, the following actions are available:
   i.e. the version of your project that `/` redirects to.
   See more in :ref:`automatic-redirects:Root URL`.
   It also activates and builds the version.
+- **Delete version**: When a branch or tag is deleted from your repository,
+  Read the Docs will delete it *only if isn't active*.
+  This action allows you to delete *active* versions when a branch or tag is deleted from your repository.
 
 .. note::
 
@@ -69,6 +72,12 @@ Currently, the following actions are available:
    The stable version is also automatically updated at the same time.
    See more in :doc:`versions`.
 
+.. note::
+
+   Default versions aren't deleted even if they match a rule.
+   You can use the ``Set version as default`` action to change the default version
+   before deleting the current one.
+
 Order
 -----
 
@@ -99,6 +108,13 @@ Activate only new branches that belong to the ``1.x`` release
 - Version type: ``Branch``
 - Action: ``Activate version``
 
+Automatically delete an active version of a deleted branch
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+- Match: ``Any version``
+- Version type: ``Branch``
+- Action: ``Delete version``
+
 Set as default new tags that have the ``-stable`` or ``-release`` suffix
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 

readthedocs/api/v2/utils.py

@@ -14,7 +14,7 @@
     STABLE_VERBOSE_NAME,
     TAG,
 )
-from readthedocs.builds.models import Version
+from readthedocs.builds.models import RegexAutomationRule, Version
 
 log = logging.getLogger(__name__)
 
@@ -140,7 +140,12 @@ def _set_or_create_version(project, slug, version_id, verbose_name, type_):
 
 
 def delete_versions_from_db(project, version_data):
-    """Delete all versions not in the current repo."""
+    """
+    Delete all versions not in the current repo.
+
+    :returns: The slug of the deleted versions from the database,
+    and the slug of active versions that where deleted from the repository.
+    """
     # We use verbose_name for tags
     # because several tags can point to the same identifier.
     versions_tags = [
@@ -153,7 +158,6 @@ def delete_versions_from_db(project, version_data):
     to_delete_qs = (
         project.versions
         .exclude(uploaded=True)
-        .exclude(active=True)
         .exclude(slug__in=NON_REPOSITORY_VERSIONS)
     )
 
@@ -166,18 +170,23 @@ def delete_versions_from_db(project, version_data):
         identifier__in=versions_branches,
     )
 
-    ret_val = set(to_delete_qs.values_list('slug', flat=True))
-    if ret_val:
+    deleted_active_versions = set(
+        to_delete_qs.filter(active=True).values_list('slug', flat=True)
+    )
+
+    to_delete_qs = to_delete_qs.exclude(active=True)
+    deleted_versions = set(to_delete_qs.values_list('slug', flat=True))
+    if deleted_versions:
         log.info(
             '(Sync Versions) Deleted Versions: project=%s, versions=[%s]',
-            project.slug, ' '.join(ret_val),
+            project.slug, ' '.join(deleted_versions),
         )
         to_delete_qs.delete()
 
-    return ret_val
+    return deleted_versions, deleted_active_versions
 
 
-def run_automation_rules(project, versions_slug):
+def run_automation_rules(project, added_versions, deleted_active_versions):
     """
     Runs the automation rules on each version.
 
@@ -188,10 +197,16 @@ def run_automation_rules(project, versions_slug):
        Currently the versions aren't sorted in any way,
        the same order is keeped.
     """
-    versions = project.versions.filter(slug__in=versions_slug)
-    rules = project.automation_rules.all()
-    for version, rule in itertools.product(versions, rules):
-        rule.run(version)
+    class_ = RegexAutomationRule
+    actions = [
+        (added_versions, class_.allowed_actions_on_create),
+        (deleted_active_versions, class_.allowed_actions_on_delete),
+    ]
+    for versions_slug, allowed_actions in actions:
+        versions = project.versions.filter(slug__in=versions_slug)
+        rules = project.automation_rules.filter(action__in=allowed_actions)
+        for version, rule in itertools.product(versions, rules):
+            rule.run(version)
 
 
 class RemoteOrganizationPagination(PageNumberPagination):

readthedocs/api/v2/views/model_views.py

@@ -219,7 +219,7 @@ def sync_versions(self, request, **kwargs):  # noqa: D205
                     type=BRANCH,
                 )
                 added_versions.update(ret_set)
-            deleted_versions = delete_versions_from_db(project, data)
+            deleted_versions, deleted_active_versions = delete_versions_from_db(project, data)
         except Exception as e:
             log.exception('Sync Versions Error')
             return Response(
@@ -233,7 +233,7 @@ def sync_versions(self, request, **kwargs):  # noqa: D205
             # The order of added_versions isn't deterministic.
             # We don't track the commit time or any other metadata.
             # We usually have one version added per webhook.
-            run_automation_rules(project, added_versions)
+            run_automation_rules(project, added_versions, deleted_active_versions)
         except Exception:
             # Don't interrupt the request if something goes wrong
             # in the automation rules.

readthedocs/builds/automation_actions.py

@@ -62,3 +62,10 @@ def set_private_privacy_level(version, match_result, action_arg, *args, **kwargs
     """Sets the privacy_level of the version to private."""
     version.privacy_level = PRIVATE
     version.save()
+
+
+def delete_version(version, match_result, action_arg, *args, **kwargs):
+    """Delete a version if isn't marked as the default version."""
+    if version.project.default_version == version.slug:
+        return
+    version.delete()

readthedocs/builds/models.py

@@ -947,6 +947,7 @@ class VersionAutomationRule(PolymorphicModel, TimeStampedModel):
     """Versions automation rules for projects."""
 
     ACTIVATE_VERSION_ACTION = 'activate-version'
+    DELETE_VERSION_ACTION = 'delete-version'
     HIDE_VERSION_ACTION = 'hide-version'
     MAKE_VERSION_PUBLIC_ACTION = 'make-version-public'
     MAKE_VERSION_PRIVATE_ACTION = 'make-version-private'
@@ -958,8 +959,12 @@ class VersionAutomationRule(PolymorphicModel, TimeStampedModel):
         (MAKE_VERSION_PUBLIC_ACTION, _('Make version public')),
         (MAKE_VERSION_PRIVATE_ACTION, _('Make version private')),
         (SET_DEFAULT_VERSION_ACTION, _('Set version as default')),
+        (DELETE_VERSION_ACTION, _('Delete version (on deletion)')),
     )
 
+    allowed_actions_on_create = {}
+    allowed_actions_on_delete = {}
+
     project = models.ForeignKey(
         Project,
         related_name='automation_rules',
@@ -1052,14 +1057,17 @@ def match(self, version, match_arg):
 
     def apply_action(self, version, match_result):
         """
-        Apply the action from allowed_actions.
+        Apply the action from allowed_actions_on_*.
 
         :type version: readthedocs.builds.models.Version
         :param any match_result: Additional context from the match operation
         :raises: NotImplementedError if the action
                  isn't implemented or supported for this rule.
         """
-        action = self.allowed_actions.get(self.action)
+        action = (
+            self.allowed_actions_on_create.get(self.action)
+            or self.allowed_actions_on_delete.get(self.action)
+        )
         if action is None:
             raise NotImplementedError
         action(version, match_result, self.action_arg)
@@ -1166,14 +1174,18 @@ class RegexAutomationRule(VersionAutomationRule):
 
     TIMEOUT = 1  # timeout in seconds
 
-    allowed_actions = {
+    allowed_actions_on_create = {
         VersionAutomationRule.ACTIVATE_VERSION_ACTION: actions.activate_version,
         VersionAutomationRule.HIDE_VERSION_ACTION: actions.hide_version,
         VersionAutomationRule.MAKE_VERSION_PUBLIC_ACTION: actions.set_public_privacy_level,
         VersionAutomationRule.MAKE_VERSION_PRIVATE_ACTION: actions.set_private_privacy_level,
         VersionAutomationRule.SET_DEFAULT_VERSION_ACTION: actions.set_default_version,
     }
 
+    allowed_actions_on_delete = {
+        VersionAutomationRule.DELETE_VERSION_ACTION: actions.delete_version,
+    }
+
     class Meta:
         proxy = True
 

readthedocs/rtd_tests/tests/test_automation_rules.py

@@ -1,4 +1,5 @@
 from unittest import mock
+
 import pytest
 from django_dynamic_fixture import get
 
@@ -9,12 +10,12 @@
     SEMVER_VERSIONS,
     TAG,
 )
-from readthedocs.projects.constants import PUBLIC, PRIVATE
 from readthedocs.builds.models import (
     RegexAutomationRule,
     Version,
     VersionAutomationRule,
 )
+from readthedocs.projects.constants import PRIVATE, PUBLIC
 from readthedocs.projects.models import Project
 
 
@@ -183,6 +184,53 @@ def test_action_activation(self, trigger_build):
         assert version.active is True
         trigger_build.assert_called_once()
 
+    @pytest.mark.parametrize('version_type', [BRANCH, TAG])
+    def test_action_delete_version(self, version_type):
+        slug = 'delete-me'
+        version = get(
+            Version,
+            slug=slug,
+            verbose_name=slug,
+            project=self.project,
+            active=True,
+            type=version_type,
+        )
+        rule = get(
+            RegexAutomationRule,
+            project=self.project,
+            priority=0,
+            match_arg='.*',
+            action=VersionAutomationRule.DELETE_VERSION_ACTION,
+            version_type=version_type,
+        )
+        assert rule.run(version) is True
+        assert not self.project.versions.filter(slug=slug).exists()
+
+    @pytest.mark.parametrize('version_type', [BRANCH, TAG])
+    def test_action_delete_version_on_default_version(self, version_type):
+        slug = 'delete-me'
+        version = get(
+            Version,
+            slug=slug,
+            verbose_name=slug,
+            project=self.project,
+            active=True,
+            type=version_type,
+        )
+        self.project.default_version = slug
+        self.project.save()
+
+        rule = get(
+            RegexAutomationRule,
+            project=self.project,
+            priority=0,
+            match_arg='.*',
+            action=VersionAutomationRule.DELETE_VERSION_ACTION,
+            version_type=version_type,
+        )
+        assert rule.run(version) is True
+        assert self.project.versions.filter(slug=slug).exists()
+
     def test_action_set_default_version(self):
         version = get(
             Version,

readthedocs/rtd_tests/tests/test_sync_versions.py

@@ -1,12 +1,10 @@
-# -*- coding: utf-8 -*-
-
 import json
 from unittest import mock
 
 from django.test import TestCase
 from django.urls import reverse
 
-from readthedocs.builds.constants import BRANCH, STABLE, TAG, LATEST
+from readthedocs.builds.constants import BRANCH, LATEST, STABLE, TAG
 from readthedocs.builds.models import (
     RegexAutomationRule,
     Version,
@@ -774,7 +772,9 @@ def test_automation_rules_are_triggered_for_new_versions(self, run_automation_ru
             content_type='application/json',
         )
         run_automation_rules.assert_called_with(
-            self.pip, {'new_branch', 'new_tag'}
+            self.pip,
+            {'new_branch', 'new_tag'},
+            {'0.8', '0.8.1'},
         )
 
     def test_automation_rule_activate_version(self):
@@ -837,6 +837,70 @@ def test_automation_rule_set_default_version(self):
         self.pip.refresh_from_db()
         self.assertEqual(self.pip.get_default_version(), 'new_tag')
 
+    def test_automation_rule_delete_version(self):
+        version_post_data = {
+            'tags': [
+                {
+                    'identifier': 'new_tag',
+                    'verbose_name': 'new_tag',
+                },
+                {
+                    'identifier': '0.8.3',
+                    'verbose_name': '0.8.3',
+                },
+            ],
+        }
+        version_slug = '0.8'
+        RegexAutomationRule.objects.create(
+            project=self.pip,
+            priority=0,
+            match_arg=r'^0\.8$',
+            action=VersionAutomationRule.DELETE_VERSION_ACTION,
+            version_type=TAG,
+        )
+        version = self.pip.versions.get(slug=version_slug)
+        self.assertTrue(version.active)
+
+        self.client.post(
+            reverse('project-sync-versions', args=[self.pip.pk]),
+            data=json.dumps(version_post_data),
+            content_type='application/json',
+        )
+        self.assertFalse(self.pip.versions.filter(slug=version_slug).exists())
+
+    def test_automation_rule_dont_delete_default_version(self):
+        version_post_data = {
+            'tags': [
+                {
+                    'identifier': 'new_tag',
+                    'verbose_name': 'new_tag',
+                },
+                {
+                    'identifier': '0.8.3',
+                    'verbose_name': '0.8.3',
+                },
+            ],
+        }
+        version_slug = '0.8'
+        RegexAutomationRule.objects.create(
+            project=self.pip,
+            priority=0,
+            match_arg=r'^0\.8$',
+            action=VersionAutomationRule.DELETE_VERSION_ACTION,
+            version_type=TAG,
+        )
+        version = self.pip.versions.get(slug=version_slug)
+        self.assertTrue(version.active)
+
+        self.pip.default_version = version_slug
+        self.pip.save()
+
+        self.client.post(
+            reverse('project-sync-versions', args=[self.pip.pk]),
+            data=json.dumps(version_post_data),
+            content_type='application/json',
+        )
+        self.assertTrue(self.pip.versions.filter(slug=version_slug).exists())
 
 class TestStableVersion(TestCase):
     fixtures = ['eric', 'test_data']