Remove subscription attachment methods (#1377)

* Remove subscription attachment methods from ActivationKey and HostSubscription

Since Simple Content Access (SCA) is now the default and only mode for all
organizations, subscription attachment to activation keys and hosts is no
longer supported. This removes the following methods:

ActivationKey:
- add_subscriptions()
- remove_subscriptions()
- subscriptions()

HostSubscription:
- path() override for add_subscriptions and remove_subscriptions
- subscriptions()
- add_subscriptions()
- remove_subscriptions()

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

* Remove subscription attachment path references from ActivationKey and Host

This commit removes the remaining subscription attachment path references:
- ActivationKey.path(): Removed add_subscriptions, remove_subscriptions, and subscriptions from path definitions
- Host.path(): Removed bulk/add_subscriptions and bulk/remove_subscriptions from path definitions
- Host: Removed bulk_add_subscriptions() and bulk_remove_subscriptions() methods

* Remove HostSubscription entity class and all related tests

The HostSubscription entity was used to manage the relationship between hosts
and subscriptions. Since subscription attachment is no longer supported in SCA
mode, this entire entity class is obsolete and has been removed.

Changes:
- Removed HostSubscription class from entities.py
- Removed HostSubscription from entity instantiation tests
- Removed HostSubscription from required params tests
- Removed test_hostsubscription() test method
- Removed ActivationKey subscription method tests (add_subscriptions, remove_subscriptions, subscriptions)
- Removed HostSubscription method tests (add_subscriptions, remove_subscriptions)

* Remove subscription path tests for ActivationKey

Remove test cases for add_subscriptions, remove_subscriptions, and
subscriptions paths from test_id_and_which since these methods
were removed from ActivationKey.

---------

Co-authored-by: Claude <noreply@anthropic.com>

Author: jeremylenz

nailgun/entities.py

@@ -240,8 +240,6 @@ def path(self, which=None):
 
         The format of the returned path depends on the value of ``which``:
 
-        add_subscriptions
-            /activation_keys/<id>/add_subscriptions
         copy
             /activation_keys/<id>/copy
         content_override
@@ -250,23 +248,16 @@ def path(self, which=None):
             /activation_keys/<id>/product_content
         releases
             /activation_keys/<id>/releases
-        remove_subscriptions
-            /activation_keys/<id>/remove_subscriptions
-        subscriptions
-            /activation_keys/<id>/subscriptions
 
         ``super`` is called otherwise.
 
         """
         if which in (
-            'add_subscriptions',
             'content_override',
             'copy',
             'host_collections',
             'product_content',
             'releases',
-            'remove_subscriptions',
-            'subscriptions',
         ):
             return f'{super().path(which="self")}/{which}'
         return super().path(which)
@@ -297,25 +288,6 @@ def add_host_collection(self, synchronous=True, timeout=None, **kwargs):
         response = client.post(self.path('host_collections'), **kwargs)
         return _handle_response(response, self._server_config, synchronous, timeout)
 
-    def add_subscriptions(self, synchronous=True, timeout=None, **kwargs):
-        """Add subscriptions to activation key.
-
-        :param synchronous: What should happen if the server returns an HTTP
-            202 (accepted) status code? Wait for the task to complete if
-            ``True``. Immediately return the server's response otherwise.
-        :param timeout: Maximum number of seconds to wait until timing out.
-            Defaults to ``nailgun.entity_mixins.TASK_TIMEOUT``.
-        :param kwargs: Arguments to pass to requests.
-        :returns: The server's response, with all JSON decoded.
-        :raises: ``requests.exceptions.HTTPError`` If the server responds with
-            an HTTP 4XX or 5XX message.
-
-        """
-        kwargs = kwargs.copy()  # shadow the passed-in kwargs
-        kwargs.update(self._server_config.get_client_kwargs())
-        response = client.put(self.path('add_subscriptions'), **kwargs)
-        return _handle_response(response, self._server_config, synchronous, timeout)
-
     def copy(self, synchronous=True, timeout=None, **kwargs):
         """Copy provided activation key.
 
@@ -337,44 +309,6 @@ def copy(self, synchronous=True, timeout=None, **kwargs):
         response = client.post(self.path('copy'), **kwargs)
         return _handle_response(response, self._server_config, synchronous, timeout)
 
-    def remove_subscriptions(self, synchronous=True, timeout=None, **kwargs):
-        """Remove subscriptions from an activation key.
-
-        :param synchronous: What should happen if the server returns an HTTP
-            202 (accepted) status code? Wait for the task to complete if
-            ``True``. Immediately return the server's response otherwise.
-        :param timeout: Maximum number of seconds to wait until timing out.
-            Defaults to ``nailgun.entity_mixins.TASK_TIMEOUT``.
-        :param kwargs: Arguments to pass to requests.
-        :returns: The server's response, with all JSON decoded.
-        :raises: ``requests.exceptions.HTTPError`` If the server responds with
-            an HTTP 4XX or 5XX message.
-
-        """
-        kwargs = kwargs.copy()  # shadow the passed-in kwargs
-        kwargs.update(self._server_config.get_client_kwargs())
-        response = client.put(self.path('remove_subscriptions'), **kwargs)
-        return _handle_response(response, self._server_config, synchronous, timeout)
-
-    def subscriptions(self, synchronous=True, timeout=None, **kwargs):
-        """Retrieve subscriptions on an activation key.
-
-        :param synchronous: What should happen if the server returns an HTTP
-            202 (accepted) status code? Wait for the task to complete if
-            ``True``. Immediately return the server's response otherwise.
-        :param timeout: Maximum number of seconds to wait until timing out.
-            Defaults to ``nailgun.entity_mixins.TASK_TIMEOUT``.
-        :param kwargs: Arguments to pass to requests.
-        :returns: The server's response, with all JSON decoded.
-        :raises: ``requests.exceptions.HTTPError`` If the server responds with
-            an HTTP 4XX or 5XX message.
-
-        """
-        kwargs = kwargs.copy()  # shadow the passed-in kwargs
-        kwargs.update(self._server_config.get_client_kwargs())
-        response = client.get(self.path('subscriptions'), **kwargs)
-        return _handle_response(response, self._server_config, synchronous, timeout)
-
     def content_override(self, synchronous=True, timeout=None, **kwargs):
         """Override the content of an activation key.
 
@@ -4306,97 +4240,6 @@ def __init__(self, server_config=None, **kwargs):
         }
 
 
-class HostSubscription(Entity):
-    """A representation of a Host Subscription entity."""
-
-    def __init__(self, server_config=None, **kwargs):
-        _check_for_value('host', kwargs)
-        self._fields = {
-            'content_label': entity_fields.StringField(),
-            'host': entity_fields.OneToOneField(Host, required=True),
-            'subscriptions': entity_fields.DictField(),
-            'value': entity_fields.StringField(),
-        }
-        super().__init__(server_config=server_config, **kwargs)
-        self._meta = {
-            'api_path': f'{self.host.path()}/subscriptions',
-        }
-
-    def path(self, which=None):
-        """Extend ``nailgun.entity_mixins.Entity.path``.
-
-        The format of the returned path depends on the value of ``which``:
-
-        add_subscriptions
-            /hosts/<id>/add_subscriptions
-        remove_subscriptions
-            /hosts/<id>/remove_subscriptions
-
-        ``super`` is called otherwise.
-
-        """
-        if which in ('add_subscriptions', 'remove_subscriptions'):
-            return f'{super().path(which="base")}/{which}'
-        return super().path(which)
-
-    def subscriptions(self, synchronous=True, timeout=None, **kwargs):
-        """Get subscriptions from host.
-
-        :param synchronous: What should happen if the server returns an HTTP
-            202 (accepted) status code? Wait for the task to complete if
-            ``True``. Immediately return the server's response otherwise.
-        :param timeout: Maximum number of seconds to wait until timing out.
-            Defaults to ``nailgun.entity_mixins.TASK_TIMEOUT``.
-        :param kwargs: Arguments to pass to requests.
-        :returns: The server's response, with all JSON decoded.
-        :raises: ``requests.exceptions.HTTPError`` If the server responds with
-            an HTTP 4XX or 5XX message.
-
-        """
-        kwargs = kwargs.copy()  # shadow the passed-in kwargs
-        kwargs.update(self._server_config.get_client_kwargs())
-        response = client.get(self.path('base'), **kwargs)
-        return _handle_response(response, self._server_config, synchronous, timeout)
-
-    def add_subscriptions(self, synchronous=True, timeout=None, **kwargs):
-        """Add subscriptions to host.
-
-        :param synchronous: What should happen if the server returns an HTTP
-            202 (accepted) status code? Wait for the task to complete if
-            ``True``. Immediately return the server's response otherwise.
-        :param timeout: Maximum number of seconds to wait until timing out.
-            Defaults to ``nailgun.entity_mixins.TASK_TIMEOUT``.
-        :param kwargs: Arguments to pass to requests.
-        :returns: The server's response, with all JSON decoded.
-        :raises: ``requests.exceptions.HTTPError`` If the server responds with
-            an HTTP 4XX or 5XX message.
-
-        """
-        kwargs = kwargs.copy()  # shadow the passed-in kwargs
-        kwargs.update(self._server_config.get_client_kwargs())
-        response = client.put(self.path('add_subscriptions'), **kwargs)
-        return _handle_response(response, self._server_config, synchronous, timeout)
-
-    def remove_subscriptions(self, synchronous=True, timeout=None, **kwargs):
-        """Remove subscriptions from host.
-
-        :param synchronous: What should happen if the server returns an HTTP
-            202 (accepted) status code? Wait for the task to complete if
-            ``True``. Immediately return the server's response otherwise.
-        :param timeout: Maximum number of seconds to wait until timing out.
-            Defaults to ``nailgun.entity_mixins.TASK_TIMEOUT``.
-        :param kwargs: Arguments to pass to requests.
-        :returns: The server's response, with all JSON decoded.
-        :raises: ``requests.exceptions.HTTPError`` If the server responds with
-            an HTTP 4XX or 5XX message.
-
-        """
-        kwargs = kwargs.copy()  # shadow the passed-in kwargs
-        kwargs.update(self._server_config.get_client_kwargs())
-        response = client.put(self.path('remove_subscriptions'), **kwargs)
-        return _handle_response(response, self._server_config, synchronous, timeout)
-
-
 class Host(
     Entity,
     EntityCreateMixin,
@@ -4864,44 +4707,6 @@ def errata_applicability(self, synchronous=True, timeout=None, **kwargs):
         response = client.put(self.path('errata/applicability'), **kwargs)
         return _handle_response(response, self._server_config, synchronous, timeout)
 
-    def bulk_add_subscriptions(self, synchronous=True, timeout=None, **kwargs):
-        """Add subscriptions to one or more hosts.
-
-        :param synchronous: What should happen if the server returns an HTTP
-            202 (accepted) status code? Wait for the task to complete if
-            ``True``. Immediately return the server's response otherwise.
-        :param timeout: Maximum number of seconds to wait until timing out.
-            Defaults to ``nailgun.entity_mixins.TASK_TIMEOUT``.
-        :param kwargs: Arguments to pass to requests.
-        :returns: The server's response, with all content decoded.
-        :raises: ``requests.exceptions.HTTPError`` If the server responds with
-            an HTTP 4XX or 5XX message.
-
-        """
-        kwargs = kwargs.copy()  # shadow the passed-in kwargs
-        kwargs.update(self._server_config.get_client_kwargs())
-        response = client.put(self.path('bulk/add_subscriptions'), **kwargs)
-        return _handle_response(response, self._server_config, synchronous, timeout)
-
-    def bulk_remove_subscriptions(self, synchronous=True, timeout=None, **kwargs):
-        """Remove subscriptions from one or more hosts.
-
-        :param synchronous: What should happen if the server returns an HTTP
-            202 (accepted) status code? Wait for the task to complete if
-            ``True``. Immediately return the server's response otherwise.
-        :param timeout: Maximum number of seconds to wait until timing out.
-            Defaults to ``nailgun.entity_mixins.TASK_TIMEOUT``.
-        :param kwargs: Arguments to pass to requests.
-        :returns: The server's response, with all content decoded.
-        :raises: ``requests.exceptions.HTTPError`` If the server responds with
-            an HTTP 4XX or 5XX message.
-
-        """
-        kwargs = kwargs.copy()  # shadow the passed-in kwargs
-        kwargs.update(self._server_config.get_client_kwargs())
-        response = client.put(self.path('bulk/remove_subscriptions'), **kwargs)
-        return _handle_response(response, self._server_config, synchronous, timeout)
-
     def bulk_available_incremental_updates(self, synchronous=True, timeout=None, **kwargs):
         """Get available_incremental_updates for one or more hosts.
 
@@ -5119,8 +4924,6 @@ def path(self, which=None):
             return f'{super().path(which="self")}/{which}'
         elif which in (
             'bootc_images',
-            'bulk/add_subscriptions',
-            'bulk/remove_subscriptions',
             'bulk/available_incremental_updates',
             'bulk/traces',
             'bulk/resolve_traces',

tests/test_entities.py

@@ -197,7 +197,6 @@ def test_init_succeeds(self):
                 (entities.ContentViewFilterRule, {'content_view_filter': 1}),
                 (entities.ExternalUserGroup, {'usergroup': 1}),
                 (entities.HostPackage, {'host': 1}),
-                (entities.HostSubscription, {'host': 1}),
                 (entities.Interface, {'host': 1}),
                 (entities.Image, {'compute_resource': 1}),
                 (entities.OperatingSystemParameter, {'operatingsystem': 1}),
@@ -233,7 +232,6 @@ def test_required_params(self):
             entities.ContentViewFilterRule,
             entities.ExternalUserGroup,
             entities.HostPackage,
-            entities.HostSubscription,
             entities.Image,
             entities.OverrideValue,
             entities.OperatingSystemParameter,
@@ -296,13 +294,10 @@ def test_nowhich(self):
     def test_id_and_which(self):
         """Execute ``entity(id=…).path(which=…)``."""
         for entity, which in (
-            (entities.ActivationKey, 'add_subscriptions'),
             (entities.ActivationKey, 'content_override'),
             (entities.ActivationKey, 'copy'),
             (entities.ActivationKey, 'host_collections'),
             (entities.ActivationKey, 'releases'),
-            (entities.ActivationKey, 'remove_subscriptions'),
-            (entities.ActivationKey, 'subscriptions'),
             (entities.AbstractComputeResource, 'available_images'),
             (entities.AbstractComputeResource, 'available_zones'),
             (entities.AbstractComputeResource, 'available_flavors'),
@@ -595,21 +590,6 @@ def test_capsule(self):
                 self.assertIn(f'capsules/{capsule.id}/content/{which_parts[1]}', path)
                 self.assertRegex(path, fr'{which_parts[0]}/{which_parts[1]}$')
 
-    def test_hostsubscription(self):
-        """Test :meth:`nailgun.entities.HostSubscription.path`.
-
-        Assert that the following return appropriate paths:
-
-        * ``HostSubscription(host=…).path('add_subscriptions')``
-        * ``HostSubscription(host=…).path('remove_subscriptions')``
-        """
-        sub = entities.HostSubscription(self.cfg, host=gen_integer(1, 100))
-        for which in ('add_subscriptions', 'remove_subscriptions'):
-            with self.subTest(which):
-                path = sub.path(which)
-                self.assertIn(f'hosts/{sub.host.id}/subscriptions/{which}', path)
-                self.assertRegex(path, fr'{which}$')
-
 
 class CreateTestCase(TestCase):
     """Tests for :meth:`nailgun.entity_mixins.EntityCreateMixin.create`."""
@@ -2114,7 +2094,6 @@ def setUpClass(cls):
         generic = {'server_config': cfg, 'id': 1}
         external_usergroup = {'server_config': cfg, 'id': 1, 'usergroup': 2}
         sync_plan = {'server_config': cfg, 'id': 1, 'organization': 2}
-        hostsubscription = {'server_config': cfg, 'host': 1}
         cls.methods_requests = (
             (entities.AbstractComputeResource(**generic).available_flavors, 'get'),
             (entities.AbstractComputeResource(**generic).available_images, 'get'),
@@ -2123,9 +2102,6 @@ def setUpClass(cls):
             (entities.AbstractComputeResource(**generic).associate, 'put'),
             (entities.AbstractComputeResource(**generic).images, 'get'),
             (entities.ActivationKey(**generic).add_host_collection, 'post'),
-            (entities.ActivationKey(**generic).add_subscriptions, 'put'),
-            (entities.ActivationKey(**generic).remove_subscriptions, 'put'),
-            (entities.ActivationKey(**generic).subscriptions, 'get'),
             (entities.ActivationKey(**generic).content_override, 'put'),
             (entities.ActivationKey(**generic).product_content, 'get'),
             (entities.ActivationKey(**generic).remove_host_collection, 'put'),
@@ -2177,8 +2153,6 @@ def setUpClass(cls):
             (entities.HostGroup(**generic).clone, 'post'),
             (entities.HostGroup(**generic).list_ansible_roles, 'get'),
             (entities.HostGroup(**generic).list_scparams, 'get'),
-            (entities.HostSubscription(**hostsubscription).add_subscriptions, 'put'),
-            (entities.HostSubscription(**hostsubscription).remove_subscriptions, 'put'),
             (entities.Product(**generic).sync, 'post'),
             (entities.ProductBulkAction(**generic).destroy, 'put'),
             (entities.ProductBulkAction(**generic).sync, 'put'),