From 70dcb9ca817160454e4fda2c4f0d2dec39287fc8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ren=C3=A9=20Pfeuffer?= Date: Fri, 18 Sep 2020 15:08:48 +0200 Subject: [PATCH] Fix unittests --- .../java/sonia/scm/repository/Namespace.java | 8 + .../NamespacePermissionResource.java | 5 +- .../resources/NamespaceRootResourceTest.java | 20 --- .../DefaultNamespaceManagerTest.java | 157 +++++++++++++----- 4 files changed, 121 insertions(+), 69 deletions(-) diff --git a/scm-core/src/main/java/sonia/scm/repository/Namespace.java b/scm-core/src/main/java/sonia/scm/repository/Namespace.java index d2421c102d..8ad56c3b90 100644 --- a/scm-core/src/main/java/sonia/scm/repository/Namespace.java +++ b/scm-core/src/main/java/sonia/scm/repository/Namespace.java @@ -109,6 +109,14 @@ public class Namespace implements PermissionObject, Cloneable { .toHashCode(); } + @Override + public String toString() { + return "Namespace{" + + "namespace='" + namespace + '\'' + + ", permissions=" + permissions + + '}'; + } + @Override public Namespace clone() { try { diff --git a/scm-webapp/src/main/java/sonia/scm/api/v2/resources/NamespacePermissionResource.java b/scm-webapp/src/main/java/sonia/scm/api/v2/resources/NamespacePermissionResource.java index bb65ed905b..4066c32bf0 100644 --- a/scm-webapp/src/main/java/sonia/scm/api/v2/resources/NamespacePermissionResource.java +++ b/scm-webapp/src/main/java/sonia/scm/api/v2/resources/NamespacePermissionResource.java @@ -295,9 +295,8 @@ public class NamespacePermissionResource { } private Predicate filterPermission(String name) { - return permission -> getPermissionName(name).equals(permission.getName()) - && - permission.isGroupPermission() == isGroupPermission(name); + return permission -> + getPermissionName(name).equals(permission.getName()) && permission.isGroupPermission() == isGroupPermission(name); } private String getPermissionName(String permissionName) { diff --git a/scm-webapp/src/test/java/sonia/scm/api/v2/resources/NamespaceRootResourceTest.java b/scm-webapp/src/test/java/sonia/scm/api/v2/resources/NamespaceRootResourceTest.java index d322b627bb..a7219ea02b 100644 --- a/scm-webapp/src/test/java/sonia/scm/api/v2/resources/NamespaceRootResourceTest.java +++ b/scm-webapp/src/test/java/sonia/scm/api/v2/resources/NamespaceRootResourceTest.java @@ -224,26 +224,6 @@ class NamespaceRootResourceTest { assertThat(response.getStatus()).isEqualTo(404); } - @Test - void shouldNotCreateNewPermission() throws URISyntaxException { - MockHttpRequest request = MockHttpRequest.post("/" + NamespaceRootResource.NAMESPACE_PATH_V2 + "space/permissions") - .content("{\"name\":\"dent\",\"verbs\":[],\"role\":\"WRITE\",\"groupPermission\":false}".getBytes()) - .header("Content-Type", "application/vnd.scmm-repositoryPermission+json;v=2"); - - dispatcher.invoke(request, response); - - assertThat(response.getStatus()).isEqualTo(403); - } - - @Test - void shouldNotDeletePermission() throws URISyntaxException { - MockHttpRequest request = MockHttpRequest.delete("/" + NamespaceRootResource.NAMESPACE_PATH_V2 + "hitchhiker/permissions/@humans"); - - dispatcher.invoke(request, response); - - assertThat(response.getStatus()).isEqualTo(403); - } - @Nested class WithWritePermission { diff --git a/scm-webapp/src/test/java/sonia/scm/repository/DefaultNamespaceManagerTest.java b/scm-webapp/src/test/java/sonia/scm/repository/DefaultNamespaceManagerTest.java index 80e0e26c8a..9d95dc928a 100644 --- a/scm-webapp/src/test/java/sonia/scm/repository/DefaultNamespaceManagerTest.java +++ b/scm-webapp/src/test/java/sonia/scm/repository/DefaultNamespaceManagerTest.java @@ -24,8 +24,13 @@ package sonia.scm.repository; -import com.github.legman.EventBus; +import org.apache.shiro.authz.AuthorizationException; +import org.apache.shiro.subject.Subject; +import org.apache.shiro.util.ThreadContext; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.Mock; @@ -41,6 +46,7 @@ import java.util.Optional; import static java.util.Arrays.asList; import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.ArgumentMatchers.argThat; +import static org.mockito.Mockito.lenient; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; import static sonia.scm.HandlerEventType.DELETE; @@ -54,6 +60,8 @@ class DefaultNamespaceManagerTest { RepositoryManager repositoryManager; @Mock ScmEventBus eventBus; + @Mock + Subject subject; Namespace life; @@ -64,8 +72,7 @@ class DefaultNamespaceManagerTest { @BeforeEach void mockExistingNamespaces() { - dao = new NamespaceDao(new InMemoryDataStoreFactory(new InMemoryDataStore())); - manager = new DefaultNamespaceManager(repositoryManager, dao, eventBus); + dao = new NamespaceDao(new InMemoryDataStoreFactory(new InMemoryDataStore())); when(repositoryManager.getAllNamespaces()).thenReturn(asList("life", "universe", "rest")); @@ -76,6 +83,18 @@ class DefaultNamespaceManagerTest { universe = new Namespace("universe"); rest = new Namespace("rest"); + + manager = new DefaultNamespaceManager(repositoryManager, dao, eventBus); + } + + @BeforeEach + void mockSubject() { + ThreadContext.bind(subject); + } + + @AfterEach + void unbindSubject() { + ThreadContext.unbindSubject(); } @Test @@ -85,49 +104,6 @@ class DefaultNamespaceManagerTest { assertThat(namespace).isEmpty(); } - @Test - void shouldCreateNewNamespaceObjectIfNotInStore() { - Namespace namespace = manager.get("universe").orElse(null); - - assertThat(namespace).isEqualTo(universe); - assertThat(namespace.getPermissions()).isEmpty(); - } - - @Test - void shouldEnrichExistingNamespaceWithPermissions() { - Namespace namespace = manager.get("life").orElse(null); - - assertThat(namespace.getPermissions()).containsExactly(life.getPermissions().toArray(new RepositoryPermission[0])); - } - - @Test - void shouldEnrichExistingNamespaceWithPermissionsInGetAll() { - Collection namespaces = manager.getAll(); - - assertThat(namespaces).containsExactly( - life, - universe, - rest - ); - Namespace foundLifeNamespace = namespaces.stream().filter(namespace -> namespace.getNamespace().equals("life")).findFirst().get(); - assertThat( - foundLifeNamespace.getPermissions()).containsExactly(life.getPermissions().toArray(new RepositoryPermission[0])); - } - - @Test - void shouldModifyExistingNamespaceWithPermissions() { - Namespace modifiedNamespace = manager.get("life").get(); - - modifiedNamespace.setPermissions(asList(new RepositoryPermission("Arthur Dent", "READ", false))); - manager.modify(modifiedNamespace); - - Namespace newLife = manager.get("life").get(); - - assertThat(newLife).isEqualTo(modifiedNamespace); - verify(eventBus).post(argThat(event -> ((NamespaceModificationEvent)event).getEventType() == HandlerEventType.BEFORE_MODIFY)); - verify(eventBus).post(argThat(event -> ((NamespaceModificationEvent)event).getEventType() == HandlerEventType.MODIFY)); - } - @Test void shouldCleanUpPermissionWhenLastRepositoryOfNamespaceWasDeleted() { when(repositoryManager.getAllNamespaces()).thenReturn(asList("universe", "rest")); @@ -149,4 +125,93 @@ class DefaultNamespaceManagerTest { assertThat(dao.get("life")).isEmpty(); } + + @Nested + class WithPermissionToReadPermissions { + + @BeforeEach + void grantReadPermission() { + when(subject.isPermitted("namespace:permissionRead")).thenReturn(true); + } + + @Test + void shouldCreateNewNamespaceObjectIfNotInStore() { + Namespace namespace = manager.get("universe").orElse(null); + + assertThat(namespace).isEqualTo(universe); + assertThat(namespace.getPermissions()).isEmpty(); + } + + @Test + void shouldEnrichExistingNamespaceWithPermissions() { + Namespace namespace = manager.get("life").orElse(null); + + assertThat(namespace.getPermissions()).containsExactly(life.getPermissions().toArray(new RepositoryPermission[0])); + } + + @Test + void shouldEnrichExistingNamespaceWithPermissionsInGetAll() { + Collection namespaces = manager.getAll(); + + assertThat(namespaces).containsExactly( + life, + universe, + rest + ); + Namespace foundLifeNamespace = namespaces.stream().filter(namespace -> namespace.getNamespace().equals("life")).findFirst().get(); + assertThat( + foundLifeNamespace.getPermissions()).containsExactly(life.getPermissions().toArray(new RepositoryPermission[0])); + } + + @Test + void shouldModifyExistingNamespaceWithPermissions() { + Namespace modifiedNamespace = manager.get("life").get(); + + modifiedNamespace.setPermissions(asList(new RepositoryPermission("Arthur Dent", "READ", false))); + manager.modify(modifiedNamespace); + + Namespace newLife = manager.get("life").get(); + + assertThat(newLife).isEqualTo(modifiedNamespace); + verify(eventBus).post(argThat(event -> ((NamespaceModificationEvent) event).getEventType() == HandlerEventType.BEFORE_MODIFY)); + verify(eventBus).post(argThat(event -> ((NamespaceModificationEvent) event).getEventType() == HandlerEventType.MODIFY)); + } + } + + @Nested + class WithoutPermissionToReadOrWritePermissions { + + @BeforeEach + void grantReadPermission() { + when(subject.isPermitted("namespace:permissionRead")).thenReturn(false); + lenient().doThrow(AuthorizationException.class).when(subject).checkPermission("namespace:permissionWrite"); + } + + @Test + void shouldNotEnrichExistingNamespaceWithPermissions() { + Namespace namespace = manager.get("life").orElse(null); + + assertThat(namespace.getPermissions()).isEmpty(); + } + + @Test + void shouldNotEnrichExistingNamespaceWithPermissionsInGetAll() { + Collection namespaces = manager.getAll(); + + assertThat(namespaces).containsExactly( + new Namespace("life"), + universe, + rest + ); + } + + @Test + void shouldNotModifyExistingNamespaceWithPermissions() { + Namespace modifiedNamespace = manager.get("life").get(); + + modifiedNamespace.setPermissions(asList(new RepositoryPermission("Arthur Dent", "READ", false))); + + Assertions.assertThrows(AuthorizationException.class, () -> manager.modify(modifiedNamespace)); + } + } }