+++ /dev/null
-/*
- * SonarQube
- * Copyright (C) 2009-2023 SonarSource SA
- * mailto:info AT sonarsource DOT com
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 3 of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-package org.sonar.server.management;
-
-import com.google.common.collect.MoreCollectors;
-import java.util.Map;
-import java.util.Optional;
-import java.util.Set;
-import javax.annotation.Priority;
-import org.sonar.api.server.ServerSide;
-import org.sonar.db.DbSession;
-
-import static java.util.function.Function.identity;
-import static java.util.stream.Collectors.toMap;
-import static java.util.stream.Collectors.toSet;
-import static org.sonar.api.utils.Preconditions.checkState;
-
-@ServerSide
-@Priority(ManagedInstanceService.DELEGATING_INSTANCE_PRIORITY)
-public class DelegatingManagedInstanceService implements ManagedInstanceService, ManagedProjectService {
-
- private static final IllegalStateException NOT_MANAGED_INSTANCE_EXCEPTION = new IllegalStateException("This instance is not managed.");
- private final Set<ManagedInstanceService> delegates;
-
- public DelegatingManagedInstanceService(Set<ManagedInstanceService> delegates) {
- this.delegates = delegates;
- }
-
- public final boolean isInstanceExternallyManaged() {
- return delegates.stream().anyMatch(ManagedInstanceService::isInstanceExternallyManaged);
- }
-
- @Override
- public String getProviderName() {
- return findManagedInstanceService()
- .map(ManagedInstanceService::getProviderName)
- .orElseThrow(() -> NOT_MANAGED_INSTANCE_EXCEPTION);
- }
-
- @Override
- public Map<String, Boolean> getUserUuidToManaged(DbSession dbSession, Set<String> userUuids) {
- return findManagedInstanceService()
- .map(managedInstanceService -> managedInstanceService.getUserUuidToManaged(dbSession, userUuids))
- .orElse(returnNonManagedForAll(userUuids));
- }
-
- @Override
- public Map<String, Boolean> getGroupUuidToManaged(DbSession dbSession, Set<String> groupUuids) {
- return findManagedInstanceService()
- .map(managedInstanceService -> managedInstanceService.getGroupUuidToManaged(dbSession, groupUuids))
- .orElse(returnNonManagedForAll(groupUuids));
- }
-
- @Override
- public String getManagedUsersSqlFilter(boolean filterByManaged) {
- return findManagedInstanceService()
- .map(managedInstanceService -> managedInstanceService.getManagedUsersSqlFilter(filterByManaged))
- .orElseThrow(() -> NOT_MANAGED_INSTANCE_EXCEPTION);
- }
-
- @Override
- public String getManagedGroupsSqlFilter(boolean filterByManaged) {
- return findManagedInstanceService()
- .map(managedInstanceService -> managedInstanceService.getManagedGroupsSqlFilter(filterByManaged))
- .orElseThrow(() -> NOT_MANAGED_INSTANCE_EXCEPTION);
- }
-
- @Override
- public boolean isUserManaged(DbSession dbSession, String login) {
- return findManagedInstanceService()
- .map(managedInstanceService -> managedInstanceService.isUserManaged(dbSession, login))
- .orElse(false);
- }
-
- private Optional<ManagedInstanceService> findManagedInstanceService() {
- Set<ManagedInstanceService> managedInstanceServices = delegates.stream()
- .filter(ManagedInstanceService::isInstanceExternallyManaged)
- .collect(toSet());
-
- checkState(managedInstanceServices.size() < 2,
- "The instance can't be managed by more than one identity provider and %s were found.", managedInstanceServices.size());
- return managedInstanceServices.stream().collect(MoreCollectors.toOptional());
- }
-
- private static Map<String, Boolean> returnNonManagedForAll(Set<String> resourcesUuid) {
- return resourcesUuid.stream().collect(toMap(identity(), any -> false));
- }
-
- @Override
- public boolean isProjectManaged(DbSession dbSession, String projectKey) {
- return findManagedProjectService()
- .map(managedProjectService -> managedProjectService.isProjectManaged(dbSession, projectKey))
- .orElse(false);
- }
-
- private Optional<ManagedProjectService> findManagedProjectService() {
- return findManagedInstanceService()
- .filter(ManagedProjectService.class::isInstance)
- .map(ManagedProjectService.class::cast);
- }
-}
--- /dev/null
+/*
+ * SonarQube
+ * Copyright (C) 2009-2023 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+package org.sonar.server.management;
+
+import com.google.common.collect.MoreCollectors;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import javax.annotation.Priority;
+import org.sonar.api.server.ServerSide;
+import org.sonar.db.DbSession;
+
+import static java.util.function.Function.identity;
+import static java.util.stream.Collectors.toMap;
+import static java.util.stream.Collectors.toSet;
+import static org.sonar.api.utils.Preconditions.checkState;
+
+@ServerSide
+@Priority(ManagedInstanceService.DELEGATING_INSTANCE_PRIORITY)
+public class DelegatingManagedServices implements ManagedInstanceService, ManagedProjectService {
+
+ private static final IllegalStateException NOT_MANAGED_INSTANCE_EXCEPTION = new IllegalStateException("This instance is not managed.");
+ private final Set<ManagedInstanceService> delegates;
+
+ public DelegatingManagedServices(Set<ManagedInstanceService> delegates) {
+ this.delegates = delegates;
+ }
+
+ public final boolean isInstanceExternallyManaged() {
+ return delegates.stream().anyMatch(ManagedInstanceService::isInstanceExternallyManaged);
+ }
+
+ @Override
+ public String getProviderName() {
+ return findManagedInstanceService()
+ .map(ManagedInstanceService::getProviderName)
+ .orElseThrow(() -> NOT_MANAGED_INSTANCE_EXCEPTION);
+ }
+
+ @Override
+ public Map<String, Boolean> getUserUuidToManaged(DbSession dbSession, Set<String> userUuids) {
+ return findManagedInstanceService()
+ .map(managedInstanceService -> managedInstanceService.getUserUuidToManaged(dbSession, userUuids))
+ .orElse(returnNonManagedForAll(userUuids));
+ }
+
+ @Override
+ public Map<String, Boolean> getGroupUuidToManaged(DbSession dbSession, Set<String> groupUuids) {
+ return findManagedInstanceService()
+ .map(managedInstanceService -> managedInstanceService.getGroupUuidToManaged(dbSession, groupUuids))
+ .orElse(returnNonManagedForAll(groupUuids));
+ }
+
+ @Override
+ public String getManagedUsersSqlFilter(boolean filterByManaged) {
+ return findManagedInstanceService()
+ .map(managedInstanceService -> managedInstanceService.getManagedUsersSqlFilter(filterByManaged))
+ .orElseThrow(() -> NOT_MANAGED_INSTANCE_EXCEPTION);
+ }
+
+ @Override
+ public String getManagedGroupsSqlFilter(boolean filterByManaged) {
+ return findManagedInstanceService()
+ .map(managedInstanceService -> managedInstanceService.getManagedGroupsSqlFilter(filterByManaged))
+ .orElseThrow(() -> NOT_MANAGED_INSTANCE_EXCEPTION);
+ }
+
+ @Override
+ public boolean isUserManaged(DbSession dbSession, String login) {
+ return findManagedInstanceService()
+ .map(managedInstanceService -> managedInstanceService.isUserManaged(dbSession, login))
+ .orElse(false);
+ }
+
+ private Optional<ManagedInstanceService> findManagedInstanceService() {
+ Set<ManagedInstanceService> managedInstanceServices = delegates.stream()
+ .filter(ManagedInstanceService::isInstanceExternallyManaged)
+ .collect(toSet());
+
+ checkState(managedInstanceServices.size() < 2,
+ "The instance can't be managed by more than one identity provider and %s were found.", managedInstanceServices.size());
+ return managedInstanceServices.stream().collect(MoreCollectors.toOptional());
+ }
+
+ private static Map<String, Boolean> returnNonManagedForAll(Set<String> resourcesUuid) {
+ return resourcesUuid.stream().collect(toMap(identity(), any -> false));
+ }
+
+ @Override
+ public boolean isProjectManaged(DbSession dbSession, String projectKey) {
+ return findManagedProjectService()
+ .map(managedProjectService -> managedProjectService.isProjectManaged(dbSession, projectKey))
+ .orElse(false);
+ }
+
+ private Optional<ManagedProjectService> findManagedProjectService() {
+ return findManagedInstanceService()
+ .filter(ManagedProjectService.class::isInstance)
+ .map(ManagedProjectService.class::cast);
+ }
+}
+++ /dev/null
-/*
- * SonarQube
- * Copyright (C) 2009-2023 SonarSource SA
- * mailto:info AT sonarsource DOT com
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 3 of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-package org.sonar.server.management;
-
-import java.util.Map;
-import java.util.Set;
-import org.jetbrains.annotations.NotNull;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-import org.sonar.db.DbSession;
-
-import static java.util.Collections.emptySet;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
-@RunWith(MockitoJUnitRunner.class)
-public class DelegatingManagedInstanceServiceTest {
-
- @Mock
- private DbSession dbSession;
-
- @Test
- public void getProviderName_whenNotManaged_shouldThrow() {
- DelegatingManagedInstanceService managedInstanceService = noManagedInstanceService();
-
- assertThatThrownBy(managedInstanceService::getProviderName)
- .isInstanceOf(IllegalStateException.class)
- .hasMessage("This instance is not managed.");
- }
-
- @Test
- public void getProviderName_whenManaged_shouldReturnName() {
- DelegatingManagedInstanceService managedInstanceService = new DelegatingManagedInstanceService(Set.of(new AlwaysManagedInstanceService()));
-
- assertThat(managedInstanceService.getProviderName()).isEqualTo("Always");
- }
-
- @Test
- public void isInstanceExternallyManaged_whenNoManagedInstanceService_returnsFalse() {
- DelegatingManagedInstanceService managedInstanceService = noManagedInstanceService();
- assertThat(managedInstanceService.isInstanceExternallyManaged()).isFalse();
- }
-
- @Test
- public void isInstanceExternallyManaged_whenAllManagedInstanceServiceReturnsFalse_returnsFalse() {
- Set<ManagedInstanceService> delegates = Set.of(new NeverManagedInstanceService(), new NeverManagedInstanceService());
- DelegatingManagedInstanceService managedInstanceService = new DelegatingManagedInstanceService(delegates);
-
- assertThat(managedInstanceService.isInstanceExternallyManaged()).isFalse();
- }
-
- @Test
- public void isInstanceExternallyManaged_whenOneManagedInstanceServiceReturnsTrue_returnsTrue() {
- Set<ManagedInstanceService> delegates = Set.of(new NeverManagedInstanceService(), new AlwaysManagedInstanceService());
- DelegatingManagedInstanceService managedInstanceService = new DelegatingManagedInstanceService(delegates);
-
- assertThat(managedInstanceService.isInstanceExternallyManaged()).isTrue();
- }
-
- @Test
- public void getUserUuidToManaged_whenNoDelegates_setAllUsersAsNonManaged() {
- Set<String> userUuids = Set.of("a", "b");
- DelegatingManagedInstanceService managedInstanceService = noManagedInstanceService();
-
- Map<String, Boolean> userUuidToManaged = managedInstanceService.getUserUuidToManaged(dbSession, userUuids);
-
- assertThat(userUuidToManaged).containsExactlyInAnyOrderEntriesOf(Map.of("a", false, "b", false));
- }
-
- @Test
- public void getUserUuidToManaged_delegatesToRightService_andPropagateAnswer() {
- Set<String> userUuids = Set.of("a", "b");
- Map<String, Boolean> serviceResponse = Map.of("a", false, "b", true);
-
- ManagedInstanceService anotherManagedInstanceService = getManagedInstanceService(userUuids, serviceResponse);
- DelegatingManagedInstanceService managedInstanceService = new DelegatingManagedInstanceService(Set.of(new NeverManagedInstanceService(), anotherManagedInstanceService));
-
- Map<String, Boolean> userUuidToManaged = managedInstanceService.getUserUuidToManaged(dbSession, userUuids);
-
- assertThat(userUuidToManaged).containsExactlyInAnyOrderEntriesOf(serviceResponse);
- }
-
- @Test
- public void getGroupUuidToManaged_whenNoDelegates_setAllUsersAsNonManaged() {
- Set<String> groupUuids = Set.of("a", "b");
- DelegatingManagedInstanceService managedInstanceService = noManagedInstanceService();
-
- Map<String, Boolean> groupUuidToManaged = managedInstanceService.getGroupUuidToManaged(dbSession, groupUuids);
-
- assertThat(groupUuidToManaged).containsExactlyInAnyOrderEntriesOf(Map.of("a", false, "b", false));
- }
-
- @Test
- public void isUserManaged_delegatesToRightService_andPropagateAnswer() {
- DelegatingManagedInstanceService managedInstanceService = new DelegatingManagedInstanceService(Set.of(new NeverManagedInstanceService(), new AlwaysManagedInstanceService()));
-
- assertThat(managedInstanceService.isUserManaged(dbSession, "login")).isTrue();
- }
-
- @Test
- public void isUserManaged_whenNoDelegates_returnsFalse() {
- DelegatingManagedInstanceService managedInstanceService = new DelegatingManagedInstanceService(Set.of());
-
- assertThat(managedInstanceService.isUserManaged(dbSession, "login")).isFalse();
- }
-
- @Test
- public void getGroupUuidToManaged_delegatesToRightService_andPropagateAnswer() {
- Set<String> groupUuids = Set.of("a", "b");
- Map<String, Boolean> serviceResponse = Map.of("a", false, "b", true);
-
- ManagedInstanceService anotherManagedInstanceService = getManagedInstanceService(groupUuids, serviceResponse);
- DelegatingManagedInstanceService managedInstanceService = new DelegatingManagedInstanceService(Set.of(new NeverManagedInstanceService(), anotherManagedInstanceService));
-
- Map<String, Boolean> groupUuidToManaged = managedInstanceService.getGroupUuidToManaged(dbSession, groupUuids);
-
- assertThat(groupUuidToManaged).containsExactlyInAnyOrderEntriesOf(serviceResponse);
- }
-
- @Test
- public void getGroupUuidToManaged_ifMoreThanOneDelegatesActivated_throws() {
- Set<ManagedInstanceService> managedInstanceServices = Set.of(new AlwaysManagedInstanceService(), new AlwaysManagedInstanceService());
- DelegatingManagedInstanceService delegatingManagedInstanceService = new DelegatingManagedInstanceService(managedInstanceServices);
- assertThatIllegalStateException()
- .isThrownBy(() -> delegatingManagedInstanceService.getGroupUuidToManaged(dbSession, Set.of("a")))
- .withMessage("The instance can't be managed by more than one identity provider and 2 were found.");
- }
-
- @Test
- public void getUserUuidToManaged_ifMoreThanOneDelegatesActivated_throws() {
- Set<ManagedInstanceService> managedInstanceServices = Set.of(new AlwaysManagedInstanceService(), new AlwaysManagedInstanceService());
- DelegatingManagedInstanceService delegatingManagedInstanceService = new DelegatingManagedInstanceService(managedInstanceServices);
- assertThatIllegalStateException()
- .isThrownBy(() -> delegatingManagedInstanceService.getUserUuidToManaged(dbSession, Set.of("a")))
- .withMessage("The instance can't be managed by more than one identity provider and 2 were found.");
- }
-
- @Test
- public void getManagedUsersSqlFilter_whenNoDelegates_throws() {
- Set<ManagedInstanceService> managedInstanceServices = emptySet();
- DelegatingManagedInstanceService delegatingManagedInstanceService = new DelegatingManagedInstanceService(managedInstanceServices);
- assertThatIllegalStateException()
- .isThrownBy(() -> delegatingManagedInstanceService.getManagedUsersSqlFilter(true))
- .withMessage("This instance is not managed.");
- }
-
- @Test
- public void getManagedUsersSqlFilter_delegatesToRightService_andPropagateAnswer() {
- AlwaysManagedInstanceService alwaysManagedInstanceService = new AlwaysManagedInstanceService();
- DelegatingManagedInstanceService managedInstanceService = new DelegatingManagedInstanceService(Set.of(new NeverManagedInstanceService(), alwaysManagedInstanceService));
-
- assertThat(managedInstanceService.getManagedUsersSqlFilter(true)).isNotNull().isEqualTo(alwaysManagedInstanceService.getManagedUsersSqlFilter(
- true));
- }
-
- @Test
- public void getManagedGroupsSqlFilter_whenNoDelegates_throws() {
- Set<ManagedInstanceService> managedInstanceServices = emptySet();
- DelegatingManagedInstanceService delegatingManagedInstanceService = new DelegatingManagedInstanceService(managedInstanceServices);
- assertThatIllegalStateException()
- .isThrownBy(() -> delegatingManagedInstanceService.getManagedGroupsSqlFilter(true))
- .withMessage("This instance is not managed.");
- }
-
- @Test
- public void getManagedGroupsSqlFilter_delegatesToRightService_andPropagateAnswer() {
- AlwaysManagedInstanceService alwaysManagedInstanceService = new AlwaysManagedInstanceService();
- DelegatingManagedInstanceService managedInstanceService = new DelegatingManagedInstanceService(Set.of(new NeverManagedInstanceService(), alwaysManagedInstanceService));
-
- assertThat(managedInstanceService.getManagedGroupsSqlFilter(true)).isNotNull().isEqualTo(alwaysManagedInstanceService.getManagedGroupsSqlFilter(
- true));
- }
-
- private ManagedInstanceService getManagedInstanceService(Set<String> userUuids, Map<String, Boolean> uuidToManaged) {
- ManagedInstanceService anotherManagedInstanceService = mock(ManagedInstanceService.class);
- when(anotherManagedInstanceService.isInstanceExternallyManaged()).thenReturn(true);
- when(anotherManagedInstanceService.getGroupUuidToManaged(dbSession, userUuids)).thenReturn(uuidToManaged);
- when(anotherManagedInstanceService.getUserUuidToManaged(dbSession, userUuids)).thenReturn(uuidToManaged);
- return anotherManagedInstanceService;
- }
-
- @Test
- public void isProjectManaged_whenManagedInstanceServices_shouldDelegatesToRightService() {
- DelegatingManagedInstanceService managedInstanceService = new DelegatingManagedInstanceService(Set.of(new NeverManagedInstanceService(), new AlwaysManagedInstanceService()));
-
- assertThat(managedInstanceService.isProjectManaged(dbSession, "project_key")).isTrue();
- }
-
- @Test
- public void isProjectManaged_whenManagedNoInstanceServices_returnsFalse() {
- DelegatingManagedInstanceService managedInstanceService = noManagedInstanceService();
-
- assertThat(managedInstanceService.isProjectManaged(dbSession, "project_key")).isFalse();
- }
-
- @NotNull
- private static DelegatingManagedInstanceService noManagedInstanceService() {
- return new DelegatingManagedInstanceService(emptySet());
- }
-
- private static class NeverManagedInstanceService implements ManagedInstanceService, ManagedProjectService {
-
- @Override
- public boolean isInstanceExternallyManaged() {
- return false;
- }
-
- @Override
- public String getProviderName() {
- return "Never";
- }
-
- @Override
- public Map<String, Boolean> getUserUuidToManaged(DbSession dbSession, Set<String> userUuids) {
- return null;
- }
-
- @Override
- public Map<String, Boolean> getGroupUuidToManaged(DbSession dbSession, Set<String> groupUuids) {
- return null;
- }
-
- @Override
- public String getManagedUsersSqlFilter(boolean filterByManaged) {
- return null;
- }
-
- @Override
- public String getManagedGroupsSqlFilter(boolean filterByManaged) {
- return null;
- }
-
- @Override
- public boolean isUserManaged(DbSession dbSession, String login) {
- return false;
- }
-
- @Override
- public boolean isProjectManaged(DbSession dbSession, String projectKey) {
- return false;
- }
- }
-
- private static class AlwaysManagedInstanceService implements ManagedInstanceService, ManagedProjectService {
-
- @Override
- public boolean isInstanceExternallyManaged() {
- return true;
- }
-
- @Override
- public String getProviderName() {
- return "Always";
- }
-
- @Override
- public Map<String, Boolean> getUserUuidToManaged(DbSession dbSession, Set<String> userUuids) {
- return null;
- }
-
- @Override
- public Map<String, Boolean> getGroupUuidToManaged(DbSession dbSession, Set<String> groupUuids) {
- return null;
- }
-
- @Override
- public String getManagedUsersSqlFilter(boolean filterByManaged) {
- return "any filter";
- }
-
- @Override
- public String getManagedGroupsSqlFilter(boolean filterByManaged) {
- return "any filter";
- }
-
- @Override
- public boolean isUserManaged(DbSession dbSession, String login) {
- return true;
- }
-
- @Override
- public boolean isProjectManaged(DbSession dbSession, String projectKey) {
- return true;
- }
- }
-
-}
--- /dev/null
+/*
+ * SonarQube
+ * Copyright (C) 2009-2023 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+package org.sonar.server.management;
+
+import java.util.Map;
+import java.util.Set;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.sonar.db.DbSession;
+
+import static java.util.Collections.emptySet;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+@RunWith(MockitoJUnitRunner.class)
+public class DelegatingManagedServicesTest {
+
+ private static final DelegatingManagedServices NO_MANAGED_SERVICES = new DelegatingManagedServices(emptySet());
+
+ @Mock
+ private DbSession dbSession;
+
+ @Test
+ public void getProviderName_whenNotManaged_shouldThrow() {
+ DelegatingManagedServices managedInstanceService = NO_MANAGED_SERVICES;
+
+ assertThatThrownBy(managedInstanceService::getProviderName)
+ .isInstanceOf(IllegalStateException.class)
+ .hasMessage("This instance is not managed.");
+ }
+
+ @Test
+ public void getProviderName_whenManaged_shouldReturnName() {
+ DelegatingManagedServices managedInstanceService = new DelegatingManagedServices(Set.of(new AlwaysManagedInstanceService()));
+
+ assertThat(managedInstanceService.getProviderName()).isEqualTo("Always");
+ }
+
+ @Test
+ public void isInstanceExternallyManaged_whenNoManagedInstanceService_returnsFalse() {
+ DelegatingManagedServices managedInstanceService = NO_MANAGED_SERVICES;
+ assertThat(managedInstanceService.isInstanceExternallyManaged()).isFalse();
+ }
+
+ @Test
+ public void isInstanceExternallyManaged_whenAllManagedInstanceServiceReturnsFalse_returnsFalse() {
+ Set<ManagedInstanceService> delegates = Set.of(new NeverManagedInstanceService(), new NeverManagedInstanceService());
+ DelegatingManagedServices managedInstanceService = new DelegatingManagedServices(delegates);
+
+ assertThat(managedInstanceService.isInstanceExternallyManaged()).isFalse();
+ }
+
+ @Test
+ public void isInstanceExternallyManaged_whenOneManagedInstanceServiceReturnsTrue_returnsTrue() {
+ Set<ManagedInstanceService> delegates = Set.of(new NeverManagedInstanceService(), new AlwaysManagedInstanceService());
+ DelegatingManagedServices managedInstanceService = new DelegatingManagedServices(delegates);
+
+ assertThat(managedInstanceService.isInstanceExternallyManaged()).isTrue();
+ }
+
+ @Test
+ public void getUserUuidToManaged_whenNoDelegates_setAllUsersAsNonManaged() {
+ Set<String> userUuids = Set.of("a", "b");
+ DelegatingManagedServices managedInstanceService = NO_MANAGED_SERVICES;
+
+ Map<String, Boolean> userUuidToManaged = managedInstanceService.getUserUuidToManaged(dbSession, userUuids);
+
+ assertThat(userUuidToManaged).containsExactlyInAnyOrderEntriesOf(Map.of("a", false, "b", false));
+ }
+
+ @Test
+ public void getUserUuidToManaged_delegatesToRightService_andPropagateAnswer() {
+ Set<String> userUuids = Set.of("a", "b");
+ Map<String, Boolean> serviceResponse = Map.of("a", false, "b", true);
+
+ ManagedInstanceService anotherManagedInstanceService = getManagedInstanceService(userUuids, serviceResponse);
+ DelegatingManagedServices managedInstanceService = new DelegatingManagedServices(Set.of(new NeverManagedInstanceService(), anotherManagedInstanceService));
+
+ Map<String, Boolean> userUuidToManaged = managedInstanceService.getUserUuidToManaged(dbSession, userUuids);
+
+ assertThat(userUuidToManaged).containsExactlyInAnyOrderEntriesOf(serviceResponse);
+ }
+
+ @Test
+ public void getGroupUuidToManaged_whenNoDelegates_setAllUsersAsNonManaged() {
+ Set<String> groupUuids = Set.of("a", "b");
+ DelegatingManagedServices managedInstanceService = NO_MANAGED_SERVICES;
+
+ Map<String, Boolean> groupUuidToManaged = managedInstanceService.getGroupUuidToManaged(dbSession, groupUuids);
+
+ assertThat(groupUuidToManaged).containsExactlyInAnyOrderEntriesOf(Map.of("a", false, "b", false));
+ }
+
+ @Test
+ public void isUserManaged_delegatesToRightService_andPropagateAnswer() {
+ DelegatingManagedServices managedInstanceService = new DelegatingManagedServices(Set.of(new NeverManagedInstanceService(), new AlwaysManagedInstanceService()));
+
+ assertThat(managedInstanceService.isUserManaged(dbSession, "login")).isTrue();
+ }
+
+ @Test
+ public void isUserManaged_whenNoDelegates_returnsFalse() {
+ DelegatingManagedServices managedInstanceService = new DelegatingManagedServices(Set.of());
+
+ assertThat(managedInstanceService.isUserManaged(dbSession, "login")).isFalse();
+ }
+
+ @Test
+ public void getGroupUuidToManaged_delegatesToRightService_andPropagateAnswer() {
+ Set<String> groupUuids = Set.of("a", "b");
+ Map<String, Boolean> serviceResponse = Map.of("a", false, "b", true);
+
+ ManagedInstanceService anotherManagedInstanceService = getManagedInstanceService(groupUuids, serviceResponse);
+ DelegatingManagedServices managedInstanceService = new DelegatingManagedServices(Set.of(new NeverManagedInstanceService(), anotherManagedInstanceService));
+
+ Map<String, Boolean> groupUuidToManaged = managedInstanceService.getGroupUuidToManaged(dbSession, groupUuids);
+
+ assertThat(groupUuidToManaged).containsExactlyInAnyOrderEntriesOf(serviceResponse);
+ }
+
+ @Test
+ public void getGroupUuidToManaged_ifMoreThanOneDelegatesActivated_throws() {
+ Set<ManagedInstanceService> managedInstanceServices = Set.of(new AlwaysManagedInstanceService(), new AlwaysManagedInstanceService());
+ DelegatingManagedServices delegatingManagedServices = new DelegatingManagedServices(managedInstanceServices);
+ assertThatIllegalStateException()
+ .isThrownBy(() -> delegatingManagedServices.getGroupUuidToManaged(dbSession, Set.of("a")))
+ .withMessage("The instance can't be managed by more than one identity provider and 2 were found.");
+ }
+
+ @Test
+ public void getUserUuidToManaged_ifMoreThanOneDelegatesActivated_throws() {
+ Set<ManagedInstanceService> managedInstanceServices = Set.of(new AlwaysManagedInstanceService(), new AlwaysManagedInstanceService());
+ DelegatingManagedServices delegatingManagedServices = new DelegatingManagedServices(managedInstanceServices);
+ assertThatIllegalStateException()
+ .isThrownBy(() -> delegatingManagedServices.getUserUuidToManaged(dbSession, Set.of("a")))
+ .withMessage("The instance can't be managed by more than one identity provider and 2 were found.");
+ }
+
+ @Test
+ public void getManagedUsersSqlFilter_whenNoDelegates_throws() {
+ Set<ManagedInstanceService> managedInstanceServices = emptySet();
+ DelegatingManagedServices delegatingManagedServices = new DelegatingManagedServices(managedInstanceServices);
+ assertThatIllegalStateException()
+ .isThrownBy(() -> delegatingManagedServices.getManagedUsersSqlFilter(true))
+ .withMessage("This instance is not managed.");
+ }
+
+ @Test
+ public void getManagedUsersSqlFilter_delegatesToRightService_andPropagateAnswer() {
+ AlwaysManagedInstanceService alwaysManagedInstanceService = new AlwaysManagedInstanceService();
+ DelegatingManagedServices managedInstanceService = new DelegatingManagedServices(Set.of(new NeverManagedInstanceService(), alwaysManagedInstanceService));
+
+ assertThat(managedInstanceService.getManagedUsersSqlFilter(true)).isNotNull().isEqualTo(alwaysManagedInstanceService.getManagedUsersSqlFilter(
+ true));
+ }
+
+ @Test
+ public void getManagedGroupsSqlFilter_whenNoDelegates_throws() {
+ Set<ManagedInstanceService> managedInstanceServices = emptySet();
+ DelegatingManagedServices delegatingManagedServices = new DelegatingManagedServices(managedInstanceServices);
+ assertThatIllegalStateException()
+ .isThrownBy(() -> delegatingManagedServices.getManagedGroupsSqlFilter(true))
+ .withMessage("This instance is not managed.");
+ }
+
+ @Test
+ public void getManagedGroupsSqlFilter_delegatesToRightService_andPropagateAnswer() {
+ AlwaysManagedInstanceService alwaysManagedInstanceService = new AlwaysManagedInstanceService();
+ DelegatingManagedServices managedInstanceService = new DelegatingManagedServices(Set.of(new NeverManagedInstanceService(), alwaysManagedInstanceService));
+
+ assertThat(managedInstanceService.getManagedGroupsSqlFilter(true)).isNotNull().isEqualTo(alwaysManagedInstanceService.getManagedGroupsSqlFilter(
+ true));
+ }
+
+ private ManagedInstanceService getManagedInstanceService(Set<String> userUuids, Map<String, Boolean> uuidToManaged) {
+ ManagedInstanceService anotherManagedInstanceService = mock(ManagedInstanceService.class);
+ when(anotherManagedInstanceService.isInstanceExternallyManaged()).thenReturn(true);
+ when(anotherManagedInstanceService.getGroupUuidToManaged(dbSession, userUuids)).thenReturn(uuidToManaged);
+ when(anotherManagedInstanceService.getUserUuidToManaged(dbSession, userUuids)).thenReturn(uuidToManaged);
+ return anotherManagedInstanceService;
+ }
+
+ @Test
+ public void isProjectManaged_whenManagedInstanceServices_shouldDelegatesToRightService() {
+ DelegatingManagedServices managedInstanceService = new DelegatingManagedServices(Set.of(new NeverManagedInstanceService(), new AlwaysManagedInstanceService()));
+
+ assertThat(managedInstanceService.isProjectManaged(dbSession, "project_key")).isTrue();
+ }
+
+ @Test
+ public void isProjectManaged_whenManagedNoInstanceServices_returnsFalse() {
+ DelegatingManagedServices managedInstanceService = NO_MANAGED_SERVICES;
+
+ assertThat(managedInstanceService.isProjectManaged(dbSession, "project_key")).isFalse();
+ }
+
+ private static class NeverManagedInstanceService implements ManagedInstanceService, ManagedProjectService {
+
+ @Override
+ public boolean isInstanceExternallyManaged() {
+ return false;
+ }
+
+ @Override
+ public String getProviderName() {
+ return "Never";
+ }
+
+ @Override
+ public Map<String, Boolean> getUserUuidToManaged(DbSession dbSession, Set<String> userUuids) {
+ return null;
+ }
+
+ @Override
+ public Map<String, Boolean> getGroupUuidToManaged(DbSession dbSession, Set<String> groupUuids) {
+ return null;
+ }
+
+ @Override
+ public String getManagedUsersSqlFilter(boolean filterByManaged) {
+ return null;
+ }
+
+ @Override
+ public String getManagedGroupsSqlFilter(boolean filterByManaged) {
+ return null;
+ }
+
+ @Override
+ public boolean isUserManaged(DbSession dbSession, String login) {
+ return false;
+ }
+
+ @Override
+ public boolean isProjectManaged(DbSession dbSession, String projectKey) {
+ return false;
+ }
+ }
+
+ private static class AlwaysManagedInstanceService implements ManagedInstanceService, ManagedProjectService {
+
+ @Override
+ public boolean isInstanceExternallyManaged() {
+ return true;
+ }
+
+ @Override
+ public String getProviderName() {
+ return "Always";
+ }
+
+ @Override
+ public Map<String, Boolean> getUserUuidToManaged(DbSession dbSession, Set<String> userUuids) {
+ return null;
+ }
+
+ @Override
+ public Map<String, Boolean> getGroupUuidToManaged(DbSession dbSession, Set<String> groupUuids) {
+ return null;
+ }
+
+ @Override
+ public String getManagedUsersSqlFilter(boolean filterByManaged) {
+ return "any filter";
+ }
+
+ @Override
+ public String getManagedGroupsSqlFilter(boolean filterByManaged) {
+ return "any filter";
+ }
+
+ @Override
+ public boolean isUserManaged(DbSession dbSession, String login) {
+ return true;
+ }
+
+ @Override
+ public boolean isProjectManaged(DbSession dbSession, String projectKey) {
+ return true;
+ }
+ }
+
+}
package org.sonar.server.project.ws;
import java.util.Arrays;
-import java.util.Map;
import java.util.Random;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;
-import org.apache.commons.lang.NotImplementedException;
import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.config.Configuration;
import org.sonar.server.exceptions.BadRequestException;
import org.sonar.server.exceptions.ForbiddenException;
import org.sonar.server.exceptions.UnauthorizedException;
-import org.sonar.server.management.DelegatingManagedInstanceService;
-import org.sonar.server.management.ManagedInstanceService;
-import org.sonar.server.management.ManagedProjectService;
+import org.sonar.server.management.DelegatingManagedServices;
import org.sonar.server.permission.PermissionService;
import org.sonar.server.permission.PermissionServiceImpl;
import org.sonar.server.permission.index.FooIndexDefinition;
+import org.sonar.server.project.Visibility;
import org.sonar.server.project.VisibilityService;
import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.TestRequest;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.assertj.core.api.Assertions.fail;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import static org.sonar.api.CoreProperties.CORE_ALLOW_PERMISSION_MANAGEMENT_FOR_PROJECT_ADMINS_PROPERTY;
private final DbSession dbSession = dbTester.getSession();
private final TestIndexers projectIndexers = new TestIndexers();
private final Configuration configuration = mock(Configuration.class);
- private final DelegatingManagedInstanceService delegatingManagedInstanceService = new DelegatingManagedInstanceService(Set.of(new ControllableManagedProjectService()));
+ private final DelegatingManagedServices delegatingManagedServices = mock(DelegatingManagedServices.class);
private final VisibilityService visibilityService = new VisibilityService(dbClient, projectIndexers, new SequenceUuidFactory());
- private final UpdateVisibilityAction underTest = new UpdateVisibilityAction(dbClient, userSessionRule, configuration, visibilityService, delegatingManagedInstanceService);
+ private final UpdateVisibilityAction underTest = new UpdateVisibilityAction(dbClient, userSessionRule, configuration, visibilityService, delegatingManagedServices);
private final WsActionTester ws = new WsActionTester(underTest);
private final Random random = new Random();
@Test
public void execute_throws_BadRequestException_if_entity_is_project_and_managed() {
+ when(delegatingManagedServices.isProjectManaged(any(), eq(MANAGED_PROJECT_KEY))).thenReturn(true);
ProjectDto project = dbTester.components().insertPublicProject(p -> p.setKey(MANAGED_PROJECT_KEY)).getProjectDto();
request.setParam(PARAM_PROJECT, project.getKey())
- .setParam(PARAM_VISIBILITY, randomVisibility);
+ .setParam(PARAM_VISIBILITY, Visibility.PUBLIC.getLabel());
userSessionRule.addProjectPermission(UserRole.ADMIN, project);
assertThatThrownBy(request::execute)
return random.nextBoolean() ? dbTester.components().insertPublicProject() : dbTester.components().insertPrivateProject();
}
- private static class ControllableManagedProjectService implements ManagedInstanceService, ManagedProjectService {
-
- @Override
- public boolean isInstanceExternallyManaged() {
- return true;
- }
-
- @Override
- public String getProviderName() {
- throw new NotImplementedException();
- }
-
- @Override
- public Map<String, Boolean> getUserUuidToManaged(DbSession dbSession, Set<String> userUuids) {
- throw new NotImplementedException();
- }
-
- @Override
- public Map<String, Boolean> getGroupUuidToManaged(DbSession dbSession, Set<String> groupUuids) {
- throw new NotImplementedException();
- }
-
- @Override
- public String getManagedUsersSqlFilter(boolean filterByManaged) {
- throw new NotImplementedException();
- }
-
- @Override
- public String getManagedGroupsSqlFilter(boolean filterByManaged) {
- throw new NotImplementedException();
- }
-
- @Override
- public boolean isUserManaged(DbSession dbSession, String login) {
- throw new NotImplementedException();
- }
-
- @Override
- public boolean isProjectManaged(DbSession dbSession, String projectKey) {
- if (projectKey.equals(MANAGED_PROJECT_KEY)) {
- return true;
- }
- return false;
- }
- }
-
}
import org.sonar.db.DbSession;
import org.sonar.db.entity.EntityDto;
import org.sonar.server.exceptions.BadRequestException;
-import org.sonar.server.management.DelegatingManagedInstanceService;
+import org.sonar.server.management.DelegatingManagedServices;
import org.sonar.server.project.Visibility;
import org.sonar.server.project.VisibilityService;
import org.sonar.server.user.UserSession;
private final UserSession userSession;
private final Configuration configuration;
private final VisibilityService visibilityService;
- private final DelegatingManagedInstanceService delegatingManagedInstanceService;
+ private final DelegatingManagedServices delegatingInstanceService;
public UpdateVisibilityAction(DbClient dbClient, UserSession userSession, Configuration configuration,
- VisibilityService visibilityService, DelegatingManagedInstanceService delegatingManagedInstanceService) {
+ VisibilityService visibilityService, DelegatingManagedServices delegatingInstanceService) {
this.dbClient = dbClient;
this.userSession = userSession;
this.configuration = configuration;
- this.delegatingManagedInstanceService = delegatingManagedInstanceService;
this.visibilityService = visibilityService;
+ this.delegatingInstanceService = delegatingInstanceService;
}
public void define(WebService.NewController context) {
if (!isProjectAdmin || (!isGlobalAdmin && !allowChangingPermissionsByProjectAdmins)) {
throw insufficientPrivilegesException();
}
- checkRequest(notManagedProject(dbSession, entityDto), "Cannot change visibility of a managed project");
+ checkRequest(!isManagedProject(dbSession, entityDto), "Cannot change visibility of a managed project");
}
- private boolean notManagedProject(DbSession dbSession, EntityDto entityDto) {
- return !entityDto.isProject() || !delegatingManagedInstanceService.isProjectManaged(dbSession, entityDto.getKey());
+ private boolean isManagedProject(DbSession dbSession, EntityDto entityDto) {
+ return entityDto.isProject() && delegatingInstanceService.isProjectManaged(dbSession, entityDto.getKey());
}
}
import org.sonar.server.language.ws.LanguageWs;
import org.sonar.server.log.ServerLogging;
import org.sonar.server.loginmessage.LoginMessageFeature;
-import org.sonar.server.management.DelegatingManagedInstanceService;
+import org.sonar.server.management.DelegatingManagedServices;
import org.sonar.server.measure.index.ProjectsEsModule;
import org.sonar.server.measure.live.LiveMeasureModule;
import org.sonar.server.measure.ws.MeasuresWsModule;
new MonitoringWsModule(),
DefaultBranchNameResolver.class,
DefaultDocumentationLinkGenerator.class,
- DelegatingManagedInstanceService.class,
+ DelegatingManagedServices.class,
// batch
new BatchWsModule(),
projects / sonarqube.git / commitdiff