qontract-reconcile 0.10.1rc1201__py3-none-any.whl → 0.10.2.dev1__py3-none-any.whl

reconcile/test/test_slack_usergroups.py

@@ -1,785 +0,0 @@
-import copy
-from collections.abc import (
-    Iterable,
-    Sequence,
-)
-from datetime import (
-    datetime,
-    timedelta,
-)
-from typing import Any
-from unittest.mock import (
-    Mock,
-    call,
-    create_autospec,
-)
-
-import pytest
-from pytest_mock import MockerFixture
-
-import reconcile.slack_base as slackbase
-import reconcile.slack_usergroups as integ
-from reconcile.gql_definitions.slack_usergroups.clusters import ClusterAuthV1, ClusterV1
-from reconcile.gql_definitions.slack_usergroups.permissions import (
-    PagerDutyInstanceV1,
-    PagerDutyTargetV1,
-    PermissionSlackUsergroupV1,
-    ScheduleEntryV1,
-)
-from reconcile.gql_definitions.slack_usergroups.users import (
-    AccessV1,
-    NamespaceV1,
-    NamespaceV1_ClusterV1,
-    RoleV1,
-    UserV1,
-)
-from reconcile.gql_definitions.slack_usergroups.users import ClusterV1 as AccessCluster
-from reconcile.slack_usergroups import (
-    SlackMap,
-    SlackState,
-    State,
-    WorkspaceSpec,
-    act,
-    get_clusters,
-    get_permissions,
-    get_users,
-)
-from reconcile.utils import repo_owners
-from reconcile.utils.github_api import GithubRepositoryApi
-from reconcile.utils.pagerduty_api import PagerDutyMap
-from reconcile.utils.slack_api import SlackApi
-
-from .fixtures import Fixtures
-
-
-@pytest.fixture
-def base_state():
-    state = SlackState({
-        "slack-workspace": {
-            "usergroup-1": State(
-                workspace="slack-workspace",
-                usergroup="usergroup-1",
-                usergroup_id="USERGA",
-                user_names={"username"},
-                channel_names={"channelname"},
-                description="Some description",
-            )
-        }
-    })
-
-    return state
-
-
-@pytest.fixture
-def user() -> UserV1:
-    return UserV1(
-        org_username="org",
-        slack_username="slack",
-        github_username="github",
-        name="name",
-        pagerduty_username="pagerduty",
-        tag_on_cluster_updates=None,
-        tag_on_merge_requests=None,
-        roles=None,
-    )
-
-
-@pytest.fixture
-def fxt() -> Fixtures:
-    return Fixtures("slack_usergroups")
-
-
-@pytest.fixture
-def permissions(fxt: Fixtures) -> list[PermissionSlackUsergroupV1]:
-    def q(*args: Any, **kwargs: Any) -> dict[Any, Any]:
-        return fxt.get_anymarkup("permissions.yml")
-
-    return get_permissions(q)
-
-
-@pytest.fixture
-def slack_client_mock() -> SlackApi:
-    api = create_autospec(SlackApi)
-    api.channel = "channel"
-    return api
-
-
-@pytest.fixture
-def slack_map(slack_client_mock: Mock) -> SlackMap:
-    return {
-        "slack-workspace": WorkspaceSpec(
-            slack=slack_client_mock, managed_usergroups=[]
-        ),
-        "coreos": WorkspaceSpec(slack=slack_client_mock, managed_usergroups=[]),
-    }
-
-
-def test_get_permissions(permissions: Sequence[PermissionSlackUsergroupV1]) -> None:
-    assert len(permissions) == 2
-    p = permissions[0]
-    assert p.channels and len(p.channels) == 2
-    assert p.roles and p.roles[0].users == []
-
-    p = permissions[1]
-    assert p.roles and p.roles[0].users and p.roles[0].users[0].name == "Rafael"
-
-
-def test_get_users(fxt: Fixtures) -> None:
-    def q(*args: Any, **kwargs: Any) -> dict[Any, Any]:
-        return fxt.get_anymarkup("users.yml")
-
-    users = get_users(q)
-    assert len(users) == 2
-    assert users[0].org_username == "user1-org-username"
-    assert users[0].roles
-    assert len(users[0].roles) == 1
-    assert (
-        users[1].roles
-        and users[1].roles[0].access
-        and users[1].roles[0].access[0].namespace
-        and users[1].roles[0].access[0].namespace.cluster.name == "cluster-1"
-    )
-
-
-def test_get_clusters(fxt: Fixtures) -> None:
-    def q(*args: Any, **kwargs: Any) -> dict[Any, Any]:
-        return fxt.get_anymarkup("clusters.yml")
-
-    clusters = get_clusters(q)
-    assert len(clusters) == 2
-    assert clusters[0].name == "cluster-1"
-    assert clusters[0].disable
-
-
-def test_get_slack_usernames_from_schedule_none() -> None:
-    result = integ.get_slack_usernames_from_schedule([])
-    assert not result
-
-
-def test_get_slack_usernames_from_schedule(user: UserV1) -> None:
-    now = datetime.utcnow()
-    schedule = ScheduleEntryV1(
-        start=(now - timedelta(hours=1)).strftime(integ.DATE_FORMAT),
-        end=(now + timedelta(hours=1)).strftime(integ.DATE_FORMAT),
-        users=[user],
-    )
-    result = integ.get_slack_usernames_from_schedule([schedule])
-    assert result == [user.slack_username]
-
-
-def test_get_slack_username_org_username(user: UserV1) -> None:
-    user.slack_username = None
-    result = integ.get_slack_username(user)
-    assert result == user.org_username
-
-
-def test_get_slack_username_slack_username(user: UserV1) -> None:
-    result = integ.get_slack_username(user)
-    assert result == user.slack_username
-
-
-def test_get_pagerduty_username_org_username(user: UserV1) -> None:
-    user.pagerduty_username = None
-    result = integ.get_pagerduty_name(user)
-    assert result == user.org_username
-
-
-def test_get_pagerduty_username_slack_username(user: UserV1) -> None:
-    result = integ.get_pagerduty_name(user)
-    assert result == user.pagerduty_username
-
-
-def test_get_usernames_from_pagerduty(user: UserV1) -> None:
-    pagerduties = [
-        PagerDutyTargetV1(
-            name="app-sre-pagerduty-primary-oncall",
-            instance=PagerDutyInstanceV1(name="redhat"),
-            scheduleID="PHS3079",
-            escalationPolicyID=None,
-        )
-    ]
-    mock_pagerduty_map = create_autospec(PagerDutyMap)
-    mock_pagerduty_map.get.return_value.get_pagerduty_users.return_value = [
-        "pagerduty+foobar",
-        "nobody",
-        "nobody+foobar",
-    ]
-    result = integ.get_usernames_from_pagerduty(
-        pagerduties=pagerduties,
-        users=[user],
-        usergroup="usergroup",
-        pagerduty_map=mock_pagerduty_map,
-    )
-    assert result == [user.slack_username]
-
-
-def test_get_slack_usernames_from_owners(mocker: MockerFixture, user: UserV1) -> None:
-    mocker.patch(
-        "reconcile.slack_usergroups.get_git_api"
-    ).return_value.__enter__.return_value = create_autospec(GithubRepositoryApi)
-    mock_repo_owner = create_autospec(repo_owners.RepoOwners)
-    mock_repo_owner.return_value.get_root_owners.return_value = {
-        "approvers": ["approver1"],
-        "reviewers": ["github"],  # <- the test user
-    }
-    result = integ.get_slack_usernames_from_owners(
-        owners_from_repo=["https://github.com/owner/repo"],
-        users=[user],
-        usergroup="usergroup",
-        repo_owner_class=mock_repo_owner,
-    )
-    assert result == [user.slack_username]
-
-
-def test_include_user_to_cluster_usergroup_user_has_cluster_access(
-    mocker: MockerFixture, user: UserV1
-) -> None:
-    mocker.patch(
-        "reconcile.openshift_base.user_has_cluster_access",
-        autospec=True,
-        return_value=False,
-    )
-    cluster = ClusterV1(name="cluster", auth=[], disable={"integrations": []})
-    # user_has_cluster_access -> False
-    assert not integ.include_user_to_cluster_usergroup(user, cluster, ["user1"])
-
-
-def test_user_has_cluster_access(mocker: MockerFixture, user: UserV1) -> None:
-    cluster = ClusterV1(
-        name="cluster",
-        auth=[ClusterAuthV1(service="oidc")],
-        disable={"integrations": []},
-    )
-    assert integ.user_has_cluster_access(user, cluster, [user.org_username])
-    assert not integ.user_has_cluster_access(user, cluster, ["just-another-user"])
-
-
-def test_include_user_to_cluster_usergroup(mocker: MockerFixture, user: UserV1) -> None:
-    mocker.patch.object(
-        integ,
-        "user_has_cluster_access",
-        autospec=True,
-        return_value=True,
-    )
-    cluster = ClusterV1(name="cluster", auth=[], disable={"integrations": []})
-
-    # user.tag_on_cluster_updates
-    user.tag_on_cluster_updates = False
-    assert not integ.include_user_to_cluster_usergroup(user, cluster, ["user1"])
-    user.tag_on_cluster_updates = True
-    assert integ.include_user_to_cluster_usergroup(user, cluster, ["user1"])
-
-    # no roles
-    user.tag_on_cluster_updates = None
-    user.roles = []
-    assert not integ.include_user_to_cluster_usergroup(user, cluster, ["user1"])
-
-    # role: cluster and tag_on_cluster_updates = True & False
-    user.roles = [
-        RoleV1(
-            tag_on_cluster_updates=True,
-            access=[AccessV1(cluster=AccessCluster(name=cluster.name), namespace=None)],
-        ),
-        RoleV1(
-            tag_on_cluster_updates=False,
-            access=[AccessV1(cluster=AccessCluster(name=cluster.name), namespace=None)],
-        ),
-    ]
-    assert integ.include_user_to_cluster_usergroup(user, cluster, ["user1"])
-    # role: cluster and tag_on_cluster_updates = None & False
-    user.roles = [
-        RoleV1(
-            tag_on_cluster_updates=None,
-            access=[AccessV1(cluster=AccessCluster(name=cluster.name), namespace=None)],
-        ),
-        RoleV1(
-            tag_on_cluster_updates=False,
-            access=[AccessV1(cluster=AccessCluster(name=cluster.name), namespace=None)],
-        ),
-    ]
-    assert integ.include_user_to_cluster_usergroup(user, cluster, ["user1"])
-
-    # role: cluster and tag_on_cluster_updates = False & False
-    user.roles = [
-        RoleV1(
-            tag_on_cluster_updates=False,
-            access=[AccessV1(cluster=AccessCluster(name=cluster.name), namespace=None)],
-        ),
-        RoleV1(
-            tag_on_cluster_updates=False,
-            access=[AccessV1(cluster=AccessCluster(name=cluster.name), namespace=None)],
-        ),
-    ]
-    assert not integ.include_user_to_cluster_usergroup(user, cluster, ["user1"])
-
-    # role: namespace and tag_on_cluster_updates = True & False
-    user.roles = [
-        RoleV1(
-            tag_on_cluster_updates=True,
-            access=[
-                AccessV1(
-                    cluster=None,
-                    namespace=NamespaceV1(
-                        name="namespace",
-                        cluster=NamespaceV1_ClusterV1(name=cluster.name),
-                    ),
-                )
-            ],
-        ),
-        RoleV1(
-            tag_on_cluster_updates=False,
-            access=[
-                AccessV1(
-                    cluster=None,
-                    namespace=NamespaceV1(
-                        name="namespace",
-                        cluster=NamespaceV1_ClusterV1(name=cluster.name),
-                    ),
-                )
-            ],
-        ),
-    ]
-    assert integ.include_user_to_cluster_usergroup(user, cluster, ["user1"])
-    # role: namespace and tag_on_cluster_updates = None & False
-    user.roles = [
-        RoleV1(
-            tag_on_cluster_updates=None,
-            access=[
-                AccessV1(
-                    cluster=None,
-                    namespace=NamespaceV1(
-                        name="namespace",
-                        cluster=NamespaceV1_ClusterV1(name=cluster.name),
-                    ),
-                )
-            ],
-        ),
-        RoleV1(
-            tag_on_cluster_updates=False,
-            access=[
-                AccessV1(
-                    cluster=None,
-                    namespace=NamespaceV1(
-                        name="namespace",
-                        cluster=NamespaceV1_ClusterV1(name=cluster.name),
-                    ),
-                )
-            ],
-        ),
-    ]
-    assert integ.include_user_to_cluster_usergroup(user, cluster, ["user1"])
-
-    # role: namespace and tag_on_cluster_updates = False & False
-    user.roles = [
-        RoleV1(
-            tag_on_cluster_updates=False,
-            access=[
-                AccessV1(
-                    cluster=None,
-                    namespace=NamespaceV1(
-                        name="namespace",
-                        cluster=NamespaceV1_ClusterV1(name=cluster.name),
-                    ),
-                )
-            ],
-        ),
-        RoleV1(
-            tag_on_cluster_updates=False,
-            access=[
-                AccessV1(
-                    cluster=None,
-                    namespace=NamespaceV1(
-                        name="namespace",
-                        cluster=NamespaceV1_ClusterV1(name=cluster.name),
-                    ),
-                )
-            ],
-        ),
-    ]
-    assert not integ.include_user_to_cluster_usergroup(user, cluster, ["user1"])
-
-
-def test_get_desired_state(
-    mocker: MockerFixture,
-    permissions: Sequence[PermissionSlackUsergroupV1],
-    user: UserV1,
-) -> None:
-    mocker.patch(
-        "reconcile.slack_usergroups.get_usernames_from_pagerduty"
-    ).return_value = ["user1"]
-    mocker.patch(
-        "reconcile.slack_usergroups.get_slack_usernames_from_owners"
-    ).return_value = ["repo-user"]
-    mock_pagerduty_map = create_autospec(PagerDutyMap)
-    result = integ.get_desired_state(
-        mock_pagerduty_map,
-        permissions[1:],
-        [user],
-        desired_workspace_name=None,
-        desired_usergroup_name=None,
-    )
-
-    assert result == {
-        "coreos": {
-            "saas-osd-operators": State(
-                workspace="coreos",
-                usergroup="saas-osd-operators",
-                description="SREP managed-cluster-config owners (managed via app-interface)",
-                users=set(),
-                user_names={"repo-user", "user1", "slack_username"},
-                channels=set(),
-                channel_names={"sre-operators", "sd-sre-platform"},
-                usergroup_id="ugid",
-            )
-        }
-    }
-
-
-def test_get_desired_state_with_error(
-    mocker: MockerFixture,
-    permissions: Sequence[PermissionSlackUsergroupV1],
-    user: UserV1,
-) -> None:
-    mocker.patch(
-        "reconcile.slack_usergroups.get_usernames_from_pagerduty"
-    ).return_value = ["user1"]
-    mocker.patch(
-        "reconcile.slack_usergroups.get_slack_usernames_from_owners"
-    ).side_effect = Exception("some error")
-    mock_pagerduty_map = create_autospec(PagerDutyMap)
-    result = integ.get_desired_state(
-        mock_pagerduty_map,
-        permissions[1:],
-        [user],
-        desired_workspace_name=None,
-        desired_usergroup_name=None,
-    )
-
-    assert result == {}
-
-
-def test_get_desired_state_cluster_usergroups(
-    mocker: MockerFixture, slack_map: SlackMap, user: UserV1
-) -> None:
-    mocker.patch("reconcile.openshift_users.fetch_desired_state", autospec=True)
-    mocker.patch(
-        "reconcile.slack_usergroups.include_user_to_cluster_usergroup"
-    ).return_value = True
-
-    cluster = ClusterV1(name="cluster1", auth=[], disable={"integrations": []})
-    result = integ.get_desired_state_cluster_usergroups(
-        slack_map, [cluster], [user], None, None
-    )
-
-    assert result == {
-        "coreos": {
-            "cluster1-cluster": State(
-                workspace="coreos",
-                usergroup="cluster1-cluster",
-                description="Users with access to the cluster1 cluster",
-                users=set(),
-                user_names={"slack"},
-                channels=set(),
-                channel_names={"channel"},
-                usergroup_id="ugid",
-            )
-        },
-        "slack-workspace": {
-            "cluster1-cluster": State(
-                workspace="slack-workspace",
-                usergroup="cluster1-cluster",
-                description="Users with access to the cluster1 cluster",
-                users=set(),
-                user_names={"slack"},
-                channels=set(),
-                channel_names={"channel"},
-                usergroup_id="ugid",
-            )
-        },
-    }
-
-
-def test_get_desired_state_non_existing_usergroup(
-    mocker: MockerFixture, slack_map: SlackMap, user: UserV1
-) -> None:
-    mocker.patch("reconcile.openshift_users.fetch_desired_state", autospec=True)
-    mocker.patch(
-        "reconcile.slack_usergroups.include_user_to_cluster_usergroup"
-    ).return_value = True
-
-    cluster = ClusterV1(name="cluster1", auth=[], disable={"integrations": []})
-    result = integ.get_desired_state_cluster_usergroups(
-        slack_map, [cluster], [user], None, None
-    )
-
-    assert result == {
-        "coreos": {
-            "cluster1-cluster": State(
-                workspace="coreos",
-                usergroup="cluster1-cluster",
-                description="Users with access to the cluster1 cluster",
-                users=set(),
-                user_names={"slack"},
-                channels=set(),
-                channel_names={"channel"},
-                usergroup_id=None,
-            )
-        },
-        "slack-workspace": {
-            "cluster1-cluster": State(
-                workspace="slack-workspace",
-                usergroup="cluster1-cluster",
-                description="Users with access to the cluster1 cluster",
-                users=set(),
-                user_names={"slack"},
-                channels=set(),
-                channel_names={"channel"},
-                usergroup_id=None,
-            )
-        },
-    }
-
-
-def test_get_slack_map_return_expected(
-    mocker: MockerFixture, permissions: Iterable[PermissionSlackUsergroupV1]
-) -> None:
-    mock_slack_api = mocker.patch.object(slackbase, "SlackApi", autospec=True)
-    mock_secretreader = mocker.patch(
-        "reconcile.utils.secret_reader.SecretReader", autospec=True
-    )
-    mock_secretreader.return_value.read.return_value = "secret"
-
-    result = integ.get_slack_map(mock_secretreader, permissions)
-    mock_slack_api.assert_called_once()
-    # just one workspace in the permissions
-    assert len(result) == 1
-    assert isinstance(result["coreos"].slack, SlackApi)
-    assert result["coreos"].managed_usergroups == [
-        "app-sre-team",
-        "app-sre-ic",
-        "backplane-team",
-    ]
-
-
-def test_act_no_changes_detected(
-    base_state: SlackState, slack_map: SlackMap, slack_client_mock: Mock
-) -> None:
-    """No changes should be made when the states are identical."""
-    current_state = base_state
-    desired_state = base_state
-
-    act(current_state, desired_state, slack_map, dry_run=False)
-
-    slack_client_mock.update_usergroup.assert_not_called()
-    slack_client_mock.update_usergroup_users.assert_not_called()
-
-
-def test_act_dryrun_no_changes_made(
-    base_state: SlackState, slack_map: SlackMap, slack_client_mock: Mock
-) -> None:
-    """No changes should be made when dryrun mode is enabled."""
-
-    current_state = base_state
-    desired_state = copy.deepcopy(base_state)
-
-    desired_state["slack-workspace"]["usergroup-1"].user_names = {"foo"}
-
-    act(current_state, desired_state, slack_map, dry_run=True)
-
-    slack_client_mock.update_usergroup.assert_not_called()
-    slack_client_mock.update_usergroup_users.assert_not_called()
-
-
-def test_act_empty_current_state(
-    base_state: SlackState, slack_map: SlackMap, slack_client_mock: Mock
-) -> None:
-    """
-    An empty current state should be able to be handled properly (watching for
-    TypeErrors, etc).
-    """
-
-    current_state: SlackState = {}
-    desired_state = base_state
-
-    slack_client_mock.create_usergroup.return_value = "USERGA"
-    slack_client_mock.get_usergroup_id.return_value = "USERGA"
-    slack_client_mock.get_active_users_by_names.return_value = {"USERA": "username"}
-    slack_client_mock.get_channels_by_names.return_value = {"CHANA": "someotherchannel"}
-
-    act(current_state, desired_state, slack_map, dry_run=False)
-
-    assert slack_client_mock.create_usergroup.call_args_list == [call("usergroup-1")]
-    assert slack_client_mock.update_usergroup.call_args_list == [
-        call(id="USERGA", channels_list=["CHANA"], description="Some description")
-    ]
-    assert slack_client_mock.update_usergroup_users.call_args_list == [
-        call(id="USERGA", users_list=["USERA"])
-    ]
-
-
-def test_act_update_usergroup_users(
-    base_state: SlackState, slack_map: SlackMap, slack_client_mock: Mock
-) -> None:
-    current_state = base_state
-    desired_state = copy.deepcopy(base_state)
-
-    desired_state["slack-workspace"]["usergroup-1"].user_names = {
-        "someotherusername",
-        "anotheruser",
-    }
-
-    slack_client_mock.get_usergroup_id.return_value = "USERGA"
-    slack_client_mock.get_active_users_by_names.return_value = {
-        "USERB": "someotherusername",
-        "USERC": "anotheruser",
-    }
-    slack_client_mock.get_channels_by_names.return_value = {"CHANA": "channelname"}
-
-    act(current_state, desired_state, slack_map, dry_run=False)
-
-    slack_client_mock.update_usergroup.assert_not_called()
-    slack_client_mock.update_usergroup_users.assert_called_once()
-    assert slack_client_mock.update_usergroup_users.call_args_list == [
-        call(id="USERGA", users_list=["USERB", "USERC"])
-    ]
-
-
-def test_act_update_usergroup_channels(
-    base_state: SlackState, slack_map: SlackMap, slack_client_mock: Mock
-) -> None:
-    current_state = base_state
-    desired_state = copy.deepcopy(base_state)
-
-    desired_state["slack-workspace"]["usergroup-1"].channel_names = {"CHANB"}
-
-    slack_client_mock.get_usergroup_id.return_value = "USERGA"
-    slack_client_mock.get_active_users_by_names.return_value = {"USERA": "username"}
-    slack_client_mock.get_channels_by_names.return_value = {"CHANB": "channel"}
-
-    act(current_state, desired_state, slack_map, dry_run=False)
-
-    assert slack_client_mock.update_usergroup.call_args_list == [
-        call(id="USERGA", channels_list=["CHANB"], description="Some description")
-    ]
-    slack_client_mock.update_usergroup_users.assert_not_called()
-
-
-def test_act_update_usergroup_description(
-    base_state: SlackState, slack_map: SlackMap, slack_client_mock: Mock
-) -> None:
-    current_state = base_state
-    desired_state = copy.deepcopy(base_state)
-
-    desired_state["slack-workspace"][
-        "usergroup-1"
-    ].description = "A different description"
-
-    slack_client_mock.get_usergroup_id.return_value = "USERGA"
-    slack_client_mock.get_active_users_by_names.return_value = {"USERA": "username"}
-    slack_client_mock.get_channels_by_names.return_value = {"CHANA": "channel"}
-
-    act(current_state, desired_state, slack_map, dry_run=False)
-
-    assert slack_client_mock.update_usergroup.call_args_list == [
-        call(
-            id="USERGA", channels_list=["CHANA"], description="A different description"
-        )
-    ]
-    slack_client_mock.update_usergroup_users.assert_not_called()
-
-
-def test_act_update_usergroup_desc_and_channels(
-    base_state: SlackState, slack_map: SlackMap, slack_client_mock: Mock
-) -> None:
-    current_state = base_state
-    desired_state = copy.deepcopy(base_state)
-
-    desired_state["slack-workspace"][
-        "usergroup-1"
-    ].description = "A different description"
-
-    slack_client_mock.get_usergroup_id.return_value = "USERGA"
-    slack_client_mock.get_active_users_by_names.return_value = {"USERA": "username"}
-    slack_client_mock.get_channels_by_names.return_value = {"CHANB": "someotherchannel"}
-
-    act(current_state, desired_state, slack_map, dry_run=False)
-
-    assert slack_client_mock.update_usergroup.call_args_list == [
-        call(
-            id="USERGA", channels_list=["CHANB"], description="A different description"
-        )
-    ]
-    slack_client_mock.update_usergroup_users.assert_not_called()
-
-
-def test_act_add_new_usergroups(
-    base_state: SlackState, slack_map: SlackMap, slack_client_mock: Mock
-) -> None:
-    def get_users(users: set[str]) -> dict[str, str]:
-        if "username" in users:
-            return {"USERA": "username"}
-        if "userb" in users:
-            return {"USERB": "userb", "USERC": "userc"}
-        return {"USERF": "userf", "USERG": "userg"}
-
-    def get_channels(channels: set[str]) -> dict[str, str]:
-        if "channelname" in channels:
-            return {"CHANA": "channelname"}
-        if "channelb" in channels:
-            return {"CHANB": "channelb", "CHANC": "channelc"}
-        return {"CHANF": "channelf", "CHANG": "channelg"}
-
-    def get_ugid(usergroup: str) -> str:
-        if usergroup == "usergroup-1":
-            return "USERGA"
-        if usergroup == "usergroup-2":
-            return "USERGB"
-        return "USERGC"
-
-    current_state = base_state
-    desired_state = copy.deepcopy(base_state)
-
-    slack_client_mock.get_usergroup_id.side_effect = get_ugid
-    slack_client_mock.get_active_users_by_names.side_effect = get_users
-    slack_client_mock.get_channels_by_names.side_effect = get_channels
-
-    desired_state["slack-workspace"]["usergroup-2"] = State(
-        workspace="slack-workspace",
-        usergroup="usergroup-2",
-        usergroup_id="USERGB",
-        user_names={"userb", "userc"},
-        channel_names={"channelb", "channelc"},
-        description="A new usergroup",
-    )
-
-    desired_state["slack-workspace"]["usergroup-3"] = State(
-        workspace="slack-workspace",
-        usergroup="usergroup-3",
-        usergroup_id="USERGC",
-        user_names={"userf", "userg"},
-        channel_names={"channelf", "channelg"},
-        description="Another new usergroup",
-    )
-    slack_client_mock.create_usergroup.side_effect = ["USERGB", "USERGC"]
-
-    act(current_state, desired_state, slack_map, dry_run=False)
-
-    assert slack_client_mock.create_usergroup.call_args_list == [
-        call("usergroup-2"),
-        call("usergroup-3"),
-    ]
-
-    assert slack_client_mock.update_usergroup.call_args_list == [
-        call(
-            id="USERGB", channels_list=["CHANB", "CHANC"], description="A new usergroup"
-        ),
-        call(
-            id="USERGC",
-            channels_list=["CHANF", "CHANG"],
-            description="Another new usergroup",
-        ),
-    ]
-    assert slack_client_mock.update_usergroup_users.call_args_list == [
-        call(id="USERGB", users_list=["USERB", "USERC"]),
-        call(id="USERGC", users_list=["USERF", "USERG"]),
-    ]