ipatests: add remove automember condition tests

Related: https://pagure.io/freeipa/issue/9332

Signed-off-by: mbhalodi <mbhalodi@redhat.com>
Reviewed-By: Florence Blanc-Renaud <flo@redhat.com>

ipatests/test_xmlrpc/test_automember_plugin.py

@@ -195,6 +195,8 @@ def automember_hostgroup4(request, hostgroup4):
 
 @pytest.mark.tier1
 class TestAutomemberAddNegative(XMLRPC_test):
+    """Test the ipa automember-add command."""
+
     def test_create_with_nonexistent_group(self, automember_group, group1):
         """ Try to add a rule with non-existent group """
         group1.ensure_missing()
@@ -247,6 +249,7 @@ class TestAutomemberAddNegative(XMLRPC_test):
 
 
 class TestAutomemberFindNegative(XMLRPC_test):
+    """Test the ipa automember-find command."""
 
     @pytest.mark.parametrize(
         "automember_grp", [
@@ -287,6 +290,7 @@ class TestAutomemberFindNegative(XMLRPC_test):
 
 
 class TestAutomemberShowNegative(XMLRPC_test):
+    """Test the ipa automember-show command."""
 
     @pytest.mark.parametrize(
         "automember_grp", [
@@ -499,6 +503,7 @@ class TestAutomemberRebuildHostMembership(XMLRPC_test):
 
 
 class TestAutomemberModifyNegative(XMLRPC_test):
+    """Test the ipa automember-mod command."""
 
     @pytest.mark.parametrize(
         "automember_grp, grp", [
@@ -693,6 +698,7 @@ class TestAutomemberRebuildMembershipIncorrectly(XMLRPC_test):
 
 
 class TestAutomemberAddConditionNegative(XMLRPC_test):
+    """Test the ipa automember-add-condition command."""
 
     @pytest.mark.parametrize(
         "automember_grp", [
@@ -851,6 +857,277 @@ class TestAutomemberAddConditionNegative(XMLRPC_test):
             command()
 
 
+class TestAutomemberRemoveCondition(XMLRPC_test):
+    """Test the ipa automember-remove-condition command."""
+
+    @pytest.mark.parametrize(
+        "automember_grp", [
+            "automember_group",
+            "automember_hostgroup"
+        ])
+    def test_remove_inclusive_with_nonexistent_automember(
+            self, automember_grp, request):
+        """Test automember-remove-condition RULE when RULE does not exist."""
+        automember_grp = request.getfixturevalue(automember_grp)
+        automember_grp.ensure_missing()
+        command = automember_grp.make_remove_condition_command(
+            key=u'manager', type=automember_grp.membertype,
+            automemberinclusiveregex="eng[0-9]+.example.com")
+        with pytest.raises(errors.NotFound,
+                           match=r'Auto member rule: %s not found'
+                                 % automember_grp.cn):
+            command()
+
+    @pytest.mark.parametrize(
+        "automember_grp, grp", [
+            ("automember_group", "group1"),
+            ("automember_hostgroup", "hostgroup1")
+        ])
+    def test_remove_inclusive_with_group_invalidtype(self, automember_grp,
+                                                     grp, request):
+        """Test automember-remove-condition RULE --type TYPE with invalid
+        TYPE."""
+        grp = request.getfixturevalue(grp)
+        automember_grp = request.getfixturevalue(automember_grp)
+        grp.ensure_exists()
+        automember_grp.ensure_exists()
+        command = automember_grp.make_remove_condition_command(
+            key=u'manager', type='badtype',
+            automemberinclusiveregex=[u'mjohn'])
+        with pytest.raises(errors.ValidationError,
+                           match=r'invalid \'type\': must be one '
+                                 r'of \'group\', \'hostgroup\''):
+            command()
+
+    @pytest.mark.parametrize(
+        "automember_grp, grp", [
+            ("automember_group", "group1"),
+            ("automember_hostgroup", "hostgroup1")
+        ])
+    def test_remove_inclusive_with_group_badregextype(
+            self, automember_grp, grp, request):
+        """Test automember-remove-condition RULE with invalid regextype."""
+        grp = request.getfixturevalue(grp)
+        automember_grp = request.getfixturevalue(automember_grp)
+        grp.ensure_exists()
+        automember_grp.ensure_exists()
+        command = automember_grp.make_remove_condition_command(
+            key='manager', type=automember_grp.membertype,
+            badregextype_regex=[group_include_regex])
+        with raises_exact(errors.OptionError(
+                ('Unknown option: %(option)s'), option='badregextype_regex')):
+            command()
+
+    @pytest.mark.parametrize(
+        "automember_grp, grp", [
+            ("automember_group", "group1"),
+            ("automember_hostgroup", "hostgroup1")
+        ])
+    def test_remove_inclusive_with_group_invalidkey(
+            self, automember_grp, grp, request):
+        """Test automember-remove-condition RULE --key KEY with invalid KEY."""
+        grp = request.getfixturevalue(grp)
+        automember_grp = request.getfixturevalue(automember_grp)
+        grp.ensure_exists()
+        automember_grp.ensure_exists()
+        automember_grp.add_condition(key=u'manager',
+                                     type=automember_grp.membertype,
+                                     inclusiveregex=[group_include_regex])
+        command = automember_grp.make_remove_condition_command(
+            key='badkey', type=automember_grp.membertype,
+            automemberinclusiveregex=[group_include_regex])
+        result = command()
+
+        expected = dict(
+            value=automember_grp.cn,
+            summary=u'Removed condition(s) from "%s"' % automember_grp.cn,
+            completed=0,
+            failed=dict(
+                failed=dict(
+                    automemberexclusiveregex=tuple(),
+                    automemberinclusiveregex=(u'badkey=%s' %
+                                              group_include_regex,),
+                )
+            ),
+            result=dict(
+                automemberinclusiveregex=[u'manager=%s' %
+                                          group_include_regex],
+            ),
+        )
+        assert_deepequal(expected, result)
+
+    @pytest.mark.parametrize(
+        "automember_grp, grp", [
+            ("automember_group", "group1"),
+            ("automember_hostgroup", "hostgroup1")
+        ])
+    def test_remove_inclusive_with_group_badregex(
+            self, automember_grp, grp, request):
+        """Test automember-remove-condition RULE with invalid regex."""
+        grp = request.getfixturevalue(grp)
+        automember_grp = request.getfixturevalue(automember_grp)
+        grp.ensure_exists()
+        automember_grp.ensure_exists()
+        command = automember_grp.make_remove_condition_command(
+            key='manager', type=automember_grp.membertype,
+            automemberinclusiveregex=[u'badmscott'])
+        result = command()
+
+        expected = dict(
+            value=automember_grp.cn,
+            summary=u'Removed condition(s) from "%s"' % automember_grp.cn,
+            completed=0,
+            failed=dict(
+                failed=dict(
+                    automemberexclusiveregex=tuple(),
+                    automemberinclusiveregex=(u'manager=badmscott',),
+                )
+            ),
+            result=dict(
+                automemberinclusiveregex=[u'manager=%s' %
+                                          group_include_regex],
+            ),
+        )
+        assert_deepequal(expected, result)
+
+    @pytest.mark.parametrize(
+        "automember_grp, grp", [
+            ("automember_group", "group1"),
+            ("automember_hostgroup", "hostgroup1")
+        ])
+    def test_positive_remove_inclusive(
+            self, automember_grp, grp, request):
+        grp = request.getfixturevalue(grp)
+        automember_grp = request.getfixturevalue(automember_grp)
+        grp.ensure_exists()
+        automember_grp.ensure_exists()
+        command = automember_grp.make_remove_condition_command(
+            key='manager', type=automember_grp.membertype,
+            automemberinclusiveregex=[u'mjohn'])
+        command()
+
+    @pytest.mark.parametrize(
+        "automember_grp, grp", [
+            ("automember_group", "group1"),
+            ("automember_hostgroup", "hostgroup1")
+        ])
+    def test_remove_exclusive_with_group_invalidtype(self, automember_grp,
+                                                     grp, request):
+        grp = request.getfixturevalue(grp)
+        automember_grp = request.getfixturevalue(automember_grp)
+        grp.ensure_exists()
+        automember_grp.ensure_exists()
+        command = automember_grp.make_remove_condition_command(
+            key=u'fqdn', type='badtype',
+            automemberexclusiveregex="eng[0-9]+.example.com")
+        with pytest.raises(errors.ValidationError,
+                           match=r'invalid \'type\': must be one '
+                                 r'of \'group\', \'hostgroup\''):
+            command()
+
+    @pytest.mark.parametrize(
+        "automember_grp", [
+            "automember_group",
+            "automember_hostgroup"
+        ])
+    def test_remove_exclusive_with_nonexistent_automember(
+            self, automember_grp, request):
+        automember_grp = request.getfixturevalue(automember_grp)
+        automember_grp.ensure_missing()
+        command = automember_grp.make_remove_condition_command(
+            key=u'manager', type=automember_grp.membertype,
+            automemberexclusiveregex="qa[0-9]+.example.com")
+        with pytest.raises(errors.NotFound,
+                           match=r'Auto member rule: %s not found'
+                                 % automember_grp.cn):
+            command()
+
+    @pytest.mark.parametrize(
+        "automember_grp, grp", [
+            ("automember_group", "group1"),
+            ("automember_hostgroup", "hostgroup1")
+        ])
+    def test_remove_exclusive_with_group_badregextype(
+            self, automember_grp, grp, request):
+        grp = request.getfixturevalue(grp)
+        automember_grp = request.getfixturevalue(automember_grp)
+        grp.ensure_exists()
+        automember_grp.ensure_exists()
+        command = automember_grp.make_remove_condition_command(
+            key='manager', type=automember_grp.membertype,
+            badregextype_regex="qa[0-9]+.example.com")
+        with raises_exact(errors.OptionError(
+                ('Unknown option: %(option)s'), option='badregextype_regex')):
+            command()
+
+    @pytest.mark.parametrize(
+        "automember_grp, grp", [
+            ("automember_group", "group1"),
+            ("automember_hostgroup", "hostgroup1")
+        ])
+    def test_remove_exclusive_with_group_invalidkey(
+            self, automember_grp, grp, request):
+        grp = request.getfixturevalue(grp)
+        automember_grp = request.getfixturevalue(automember_grp)
+        grp.ensure_exists()
+        automember_grp.ensure_exists()
+        automember_grp.add_condition_exclusive(key=u'manager',
+                                               type=automember_grp.membertype,
+                                               exclusiveregex=[u'mjohn'])
+        command = automember_grp.make_remove_condition_command(
+            key='badkey', type=automember_grp.membertype,
+            automemberexclusiveregex=[u'mjohn'])
+        result = command()
+
+        expected = dict(
+            value=automember_grp.cn,
+            summary=u'Removed condition(s) from "%s"' % automember_grp.cn,
+            completed=0,
+            failed=dict(
+                failed=dict(
+                    automemberexclusiveregex=(u'badkey=mjohn',),
+                    automemberinclusiveregex=tuple(),
+                )
+            ),
+            result=dict(
+                automemberexclusiveregex=[u'manager=mjohn'],
+            ),
+        )
+        assert_deepequal(expected, result)
+
+    @pytest.mark.parametrize(
+        "automember_grp, grp", [
+            ("automember_group", "group1"),
+            ("automember_hostgroup", "hostgroup1")
+        ])
+    def test_remove_exclusive_with_group_badregex(
+            self, automember_grp, grp, request):
+        grp = request.getfixturevalue(grp)
+        automember_grp = request.getfixturevalue(automember_grp)
+        grp.ensure_exists()
+        automember_grp.ensure_exists()
+        command = automember_grp.make_remove_condition_command(
+            key='manager', type=automember_grp.membertype,
+            automemberexclusiveregex=[u'badmjohn'])
+        result = command()
+
+        expected = dict(
+            value=automember_grp.cn,
+            summary=u'Removed condition(s) from "%s"' % automember_grp.cn,
+            completed=0,
+            failed=dict(
+                failed=dict(
+                    automemberinclusiveregex=tuple(),
+                    automemberexclusiveregex=(u'manager=badmjohn',),
+                )
+            ),
+            result=dict(
+                automemberexclusiveregex=[u'manager=mjohn'],
+            ),
+        )
+        assert_deepequal(expected, result)
+
+
 @pytest.mark.tier1
 class TestMultipleAutomemberConditions(XMLRPC_test):
     def test_create_deps_for_multiple_conditions(

ipatests/test_xmlrpc/tracker/automember_plugin.py

@@ -87,6 +87,11 @@ class AutomemberTracker(Tracker):
         return self.make_command('automember_add_condition', self.cn,
                                  *args, **kwargs)
 
+    def make_remove_condition_command(self, *args, **kwargs):
+        """ Make function that issues automember_remove_condition """
+        return self.make_command('automember_remove_condition', self.cn,
+                                 *args, **kwargs)
+
     def track_create(self):
         """ Updates expected state for automember creation"""
         self.attrs = dict(