Merge with update plugins feature

scm-webapp/src/test/java/sonia/scm/api/v2/resources/AvailablePluginResourceTest.java

@@ -1,6 +1,7 @@
 package sonia.scm.api.v2.resources;
 
 import de.otto.edison.hal.HalRepresentation;
+import org.apache.shiro.ShiroException;
 import org.apache.shiro.subject.Subject;
 import org.apache.shiro.util.ThreadContext;
 import org.jboss.resteasy.core.Dispatcher;
@@ -18,6 +19,8 @@ import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
 import sonia.scm.plugin.AvailablePlugin;
 import sonia.scm.plugin.AvailablePluginDescriptor;
+import sonia.scm.plugin.InstalledPlugin;
+import sonia.scm.plugin.InstalledPluginDescriptor;
 import sonia.scm.plugin.PluginCondition;
 import sonia.scm.plugin.PluginInformation;
 import sonia.scm.plugin.PluginManager;
@@ -25,7 +28,6 @@ import sonia.scm.web.VndMediaType;
 
 import javax.inject.Provider;
 import javax.servlet.http.HttpServletResponse;
-
 import java.io.UnsupportedEncodingException;
 import java.net.URISyntaxException;
 import java.util.Collections;
@@ -34,6 +36,9 @@ import java.util.Optional;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.lenient;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
@@ -43,9 +48,6 @@ class AvailablePluginResourceTest {
 
   private Dispatcher dispatcher;
 
-  @Mock
-  Provider<InstalledPluginResource> installedPluginResourceProvider;
-
   @Mock
   Provider<AvailablePluginResource> availablePluginResourceProvider;
 
@@ -63,13 +65,14 @@ class AvailablePluginResourceTest {
 
   PluginRootResource pluginRootResource;
 
-  private final Subject subject = mock(Subject.class);
+  @Mock
+  Subject subject;
 
 
   @BeforeEach
   void prepareEnvironment() {
     dispatcher = MockDispatcherFactory.createDispatcher();
-    pluginRootResource = new PluginRootResource(installedPluginResourceProvider, availablePluginResourceProvider);
+    pluginRootResource = new PluginRootResource(null, availablePluginResourceProvider, null);
     when(availablePluginResourceProvider.get()).thenReturn(availablePluginResource);
     dispatcher.getRegistry().addSingletonResource(pluginRootResource);
   }
@@ -80,7 +83,7 @@ class AvailablePluginResourceTest {
     @BeforeEach
     void bindSubject() {
       ThreadContext.bind(subject);
-      when(subject.isPermitted(any(String.class))).thenReturn(true);
+      doNothing().when(subject).checkPermission(any(String.class));
     }
 
     @AfterEach
@@ -90,9 +93,10 @@ class AvailablePluginResourceTest {
 
     @Test
     void getAvailablePlugins() throws URISyntaxException, UnsupportedEncodingException {
-      AvailablePlugin plugin = createPlugin();
+      AvailablePlugin plugin = createAvailablePlugin();
 
       when(pluginManager.getAvailable()).thenReturn(Collections.singletonList(plugin));
+      when(pluginManager.getInstalled()).thenReturn(Collections.emptyList());
       when(collectionMapper.mapAvailable(Collections.singletonList(plugin))).thenReturn(new MockedResultDto());
 
       MockHttpRequest request = MockHttpRequest.get("/v2/plugins/available");
@@ -105,13 +109,32 @@ class AvailablePluginResourceTest {
       assertThat(response.getContentAsString()).contains("\"marker\":\"x\"");
     }
 
+    @Test
+    void shouldNotReturnInstalledPlugins() throws URISyntaxException, UnsupportedEncodingException {
+      AvailablePlugin availablePlugin = createAvailablePlugin();
+      InstalledPlugin installedPlugin = createInstalledPlugin();
+
+      when(pluginManager.getAvailable()).thenReturn(Collections.singletonList(availablePlugin));
+      when(pluginManager.getInstalled()).thenReturn(Collections.singletonList(installedPlugin));
+      lenient().when(collectionMapper.mapAvailable(Collections.singletonList(availablePlugin))).thenReturn(new MockedResultDto());
+
+      MockHttpRequest request = MockHttpRequest.get("/v2/plugins/available");
+      request.accept(VndMediaType.PLUGIN_COLLECTION);
+      MockHttpResponse response = new MockHttpResponse();
+
+      dispatcher.invoke(request, response);
+
+      assertThat(HttpServletResponse.SC_OK).isEqualTo(response.getStatus());
+      assertThat(response.getContentAsString()).doesNotContain("\"marker\":\"x\"");
+    }
+
     @Test
     void getAvailablePlugin() throws UnsupportedEncodingException, URISyntaxException {
       PluginInformation pluginInformation = new PluginInformation();
       pluginInformation.setName("pluginName");
       pluginInformation.setVersion("2.0.0");
 
-      AvailablePlugin plugin = createPlugin(pluginInformation);
+      AvailablePlugin plugin = createAvailablePlugin(pluginInformation);
 
       when(pluginManager.getAvailable("pluginName")).thenReturn(Optional.of(plugin));
 
@@ -139,38 +162,46 @@ class AvailablePluginResourceTest {
       verify(pluginManager).install("pluginName", false);
       assertThat(HttpServletResponse.SC_OK).isEqualTo(response.getStatus());
     }
-
-    @Test
-    void installPendingPlugin() throws URISyntaxException {
-      MockHttpRequest request = MockHttpRequest.post("/v2/plugins/available/install-pending");
-      MockHttpResponse response = new MockHttpResponse();
-
-      dispatcher.invoke(request, response);
-
-      verify(pluginManager).installPendingAndRestart();
-      assertThat(HttpServletResponse.SC_OK).isEqualTo(response.getStatus());
-    }
   }
 
-  private AvailablePlugin createPlugin() {
-    return createPlugin(new PluginInformation());
+  private AvailablePlugin createAvailablePlugin() {
+    PluginInformation pluginInformation = new PluginInformation();
+    pluginInformation.setName("scm-some-plugin");
+    return createAvailablePlugin(pluginInformation);
   }
 
-  private AvailablePlugin createPlugin(PluginInformation pluginInformation) {
+  private AvailablePlugin createAvailablePlugin(PluginInformation pluginInformation) {
     AvailablePluginDescriptor descriptor = new AvailablePluginDescriptor(
       pluginInformation, new PluginCondition(), Collections.emptySet(), "https://download.hitchhiker.com", null
     );
     return new AvailablePlugin(descriptor);
   }
 
+  private InstalledPlugin createInstalledPlugin() {
+    PluginInformation pluginInformation = new PluginInformation();
+    pluginInformation.setName("scm-some-plugin");
+    return createInstalledPlugin(pluginInformation);
+  }
+
+  private InstalledPlugin createInstalledPlugin(PluginInformation pluginInformation) {
+    InstalledPluginDescriptor descriptor = mock(InstalledPluginDescriptor.class);
+    lenient().when(descriptor.getInformation()).thenReturn(pluginInformation);
+    return new InstalledPlugin(descriptor, null, null, null, false);
+  }
+
   @Nested
   class WithoutAuthorization {
 
     @BeforeEach
-    void unbindSubject() {
-      ThreadContext.unbindSubject();
+    void bindSubject() {
+      ThreadContext.bind(subject);
+      doThrow(new ShiroException()).when(subject).checkPermission(any(String.class));
     }
 
+    @AfterEach
+    public void unbindSubject() {
+      ThreadContext.unbindSubject();
+    }
     @Test
     void shouldNotGetAvailablePluginsIfMissingPermission() throws URISyntaxException {
       MockHttpRequest request = MockHttpRequest.get("/v2/plugins/available");
@@ -178,6 +209,7 @@ class AvailablePluginResourceTest {
       MockHttpResponse response = new MockHttpResponse();
 
       assertThrows(UnhandledException.class, () -> dispatcher.invoke(request, response));
+      verify(subject).checkPermission(any(String.class));
     }
 
     @Test
@@ -187,16 +219,17 @@ class AvailablePluginResourceTest {
       MockHttpResponse response = new MockHttpResponse();
 
       assertThrows(UnhandledException.class, () -> dispatcher.invoke(request, response));
+      verify(subject).checkPermission(any(String.class));
     }
 
     @Test
     void shouldNotInstallPluginIfMissingPermission() throws URISyntaxException {
-      ThreadContext.unbindSubject();
       MockHttpRequest request = MockHttpRequest.post("/v2/plugins/available/pluginName/install");
       request.accept(VndMediaType.PLUGIN);
       MockHttpResponse response = new MockHttpResponse();
 
       assertThrows(UnhandledException.class, () -> dispatcher.invoke(request, response));
+      verify(subject).checkPermission(any(String.class));
     }
   }
 

scm-webapp/src/test/java/sonia/scm/api/v2/resources/InstalledPluginResourceTest.java

@@ -29,6 +29,7 @@ import java.net.URISyntaxException;
 import java.util.Collections;
 import java.util.Optional;
 
+import static java.util.Collections.emptyList;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.mockito.ArgumentMatchers.any;
@@ -65,7 +66,7 @@ class InstalledPluginResourceTest {
   @BeforeEach
   void prepareEnvironment() {
     dispatcher = MockDispatcherFactory.createDispatcher();
-    pluginRootResource = new PluginRootResource(installedPluginResourceProvider, availablePluginResourceProvider);
+    pluginRootResource = new PluginRootResource(installedPluginResourceProvider, null, null);
     when(installedPluginResourceProvider.get()).thenReturn(installedPluginResource);
     dispatcher.getRegistry().addSingletonResource(pluginRootResource);
   }
@@ -88,7 +89,7 @@ class InstalledPluginResourceTest {
     void getInstalledPlugins() throws URISyntaxException, UnsupportedEncodingException {
       InstalledPlugin installedPlugin = createInstalled("");
       when(pluginManager.getInstalled()).thenReturn(Collections.singletonList(installedPlugin));
-      when(collectionMapper.mapInstalled(Collections.singletonList(installedPlugin))).thenReturn(new MockedResultDto());
+      when(collectionMapper.mapInstalled(Collections.singletonList(installedPlugin), Collections.emptyList())).thenReturn(new MockedResultDto());
 
       MockHttpRequest request = MockHttpRequest.get("/v2/plugins/installed");
       request.accept(VndMediaType.PLUGIN_COLLECTION);
@@ -111,7 +112,7 @@ class InstalledPluginResourceTest {
 
       PluginDto pluginDto = new PluginDto();
       pluginDto.setName("pluginName");
-      when(mapper.mapInstalled(installedPlugin)).thenReturn(pluginDto);
+      when(mapper.mapInstalled(installedPlugin, emptyList())).thenReturn(pluginDto);
 
       MockHttpRequest request = MockHttpRequest.get("/v2/plugins/installed/pluginName");
       request.accept(VndMediaType.PLUGIN);

scm-webapp/src/test/java/sonia/scm/api/v2/resources/PendingPluginResourceTest.java

@@ -0,0 +1,227 @@
+package sonia.scm.api.v2.resources;
+
+import com.google.inject.util.Providers;
+import org.apache.shiro.ShiroException;
+import org.apache.shiro.subject.Subject;
+import org.apache.shiro.util.ThreadContext;
+import org.jboss.resteasy.core.Dispatcher;
+import org.jboss.resteasy.mock.MockDispatcherFactory;
+import org.jboss.resteasy.mock.MockHttpRequest;
+import org.jboss.resteasy.mock.MockHttpResponse;
+import org.junit.jupiter.api.AfterEach;
+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.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import sonia.scm.plugin.AvailablePlugin;
+import sonia.scm.plugin.AvailablePluginDescriptor;
+import sonia.scm.plugin.InstalledPlugin;
+import sonia.scm.plugin.InstalledPluginDescriptor;
+import sonia.scm.plugin.PluginInformation;
+import sonia.scm.plugin.PluginManager;
+
+import javax.servlet.http.HttpServletResponse;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.ext.ExceptionMapper;
+import java.io.UnsupportedEncodingException;
+import java.net.URISyntaxException;
+
+import static java.net.URI.create;
+import static java.util.Collections.singletonList;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.lenient;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+class PendingPluginResourceTest {
+
+  Dispatcher dispatcher = MockDispatcherFactory.createDispatcher();
+
+  ResourceLinks resourceLinks = ResourceLinksMock.createMock(create("/"));
+
+  @Mock
+  PluginManager pluginManager;
+  @Mock
+  PluginDtoMapper mapper;
+
+  @Mock
+  Subject subject;
+
+  @InjectMocks
+  PendingPluginResource pendingPluginResource;
+
+  MockHttpResponse response = new MockHttpResponse();
+
+  @BeforeEach
+  void prepareEnvironment() {
+    dispatcher = MockDispatcherFactory.createDispatcher();
+    dispatcher.getProviderFactory().register(new PermissionExceptionMapper());
+    PluginRootResource pluginRootResource = new PluginRootResource(null, null, Providers.of(pendingPluginResource));
+    dispatcher.getRegistry().addSingletonResource(pluginRootResource);
+  }
+
+  @BeforeEach
+  void mockMapper() {
+    lenient().when(mapper.mapAvailable(any())).thenAnswer(invocation -> {
+      PluginDto dto = new PluginDto();
+      dto.setName(((AvailablePlugin)invocation.getArgument(0)).getDescriptor().getInformation().getName());
+      return dto;
+    });
+    lenient().when(mapper.mapInstalled(any(), any())).thenAnswer(invocation -> {
+      PluginDto dto = new PluginDto();
+      dto.setName(((InstalledPlugin)invocation.getArgument(0)).getDescriptor().getInformation().getName());
+      return dto;
+    });
+  }
+
+  @Nested
+  class withAuthorization {
+
+    @BeforeEach
+    void bindSubject() {
+      ThreadContext.bind(subject);
+      doNothing().when(subject).checkPermission("plugin:manage");
+    }
+
+    @AfterEach
+    void unbindSubject() {
+      ThreadContext.unbindSubject();
+    }
+
+    @Test
+    void shouldGetEmptyPluginListsWithoutInstallLinkWhenNoPendingPluginsPresent() throws URISyntaxException, UnsupportedEncodingException {
+      AvailablePlugin availablePlugin = createAvailablePlugin("not-pending-plugin");
+      when(availablePlugin.isPending()).thenReturn(false);
+      when(pluginManager.getAvailable()).thenReturn(singletonList(availablePlugin));
+
+      MockHttpRequest request = MockHttpRequest.get("/v2/plugins/pending");
+      dispatcher.invoke(request, response);
+
+      assertThat(response.getStatus()).isEqualTo(HttpServletResponse.SC_OK);
+      assertThat(response.getContentAsString()).contains("\"_links\":{\"self\":{\"href\":\"/v2/plugins/pending\"}}");
+      assertThat(response.getContentAsString()).doesNotContain("not-pending-plugin");
+    }
+
+    @Test
+    void shouldGetPendingAvailablePluginListWithInstallLink() throws URISyntaxException, UnsupportedEncodingException {
+      AvailablePlugin availablePlugin = createAvailablePlugin("pending-available-plugin");
+      when(availablePlugin.isPending()).thenReturn(true);
+      when(pluginManager.getAvailable()).thenReturn(singletonList(availablePlugin));
+
+      MockHttpRequest request = MockHttpRequest.get("/v2/plugins/pending");
+      dispatcher.invoke(request, response);
+
+      assertThat(response.getStatus()).isEqualTo(HttpServletResponse.SC_OK);
+      assertThat(response.getContentAsString()).contains("\"new\":[{\"name\":\"pending-available-plugin\"");
+      assertThat(response.getContentAsString()).contains("\"install\":{\"href\":\"/v2/plugins/pending/install\"}");
+      System.out.println(response.getContentAsString());
+    }
+
+    @Test
+    void shouldGetPendingUpdatePluginListWithInstallLink() throws URISyntaxException, UnsupportedEncodingException {
+      AvailablePlugin availablePlugin = createAvailablePlugin("available-plugin");
+      when(availablePlugin.isPending()).thenReturn(true);
+      when(pluginManager.getAvailable()).thenReturn(singletonList(availablePlugin));
+      InstalledPlugin installedPlugin = createInstalledPlugin("available-plugin");
+      when(pluginManager.getInstalled()).thenReturn(singletonList(installedPlugin));
+
+      MockHttpRequest request = MockHttpRequest.get("/v2/plugins/pending");
+      dispatcher.invoke(request, response);
+
+      assertThat(response.getStatus()).isEqualTo(HttpServletResponse.SC_OK);
+      assertThat(response.getContentAsString()).contains("\"update\":[{\"name\":\"available-plugin\"");
+      assertThat(response.getContentAsString()).contains("\"install\":{\"href\":\"/v2/plugins/pending/install\"}");
+      System.out.println(response.getContentAsString());
+    }
+
+    @Test
+    void shouldInstallPendingPlugins() throws URISyntaxException {
+      MockHttpRequest request = MockHttpRequest.post("/v2/plugins/pending/install");
+
+      dispatcher.invoke(request, response);
+
+      assertThat(response.getStatus()).isEqualTo(HttpServletResponse.SC_OK);
+      verify(pluginManager).installPendingAndRestart();
+    }
+  }
+
+  @Nested
+  class WithoutAuthorization {
+
+    @BeforeEach
+    void bindSubject() {
+      ThreadContext.bind(subject);
+      doThrow(new ShiroException()).when(subject).checkPermission("plugin:manage");
+    }
+
+    @AfterEach
+    void unbindSubject() {
+      ThreadContext.unbindSubject();
+    }
+
+    @Test
+    void shouldNotListPendingPlugins() throws URISyntaxException {
+      MockHttpRequest request = MockHttpRequest.get("/v2/plugins/pending");
+
+      dispatcher.invoke(request, response);
+
+      assertThat(response.getStatus()).isEqualTo(HttpServletResponse.SC_UNAUTHORIZED);
+      verify(pluginManager, never()).installPendingAndRestart();
+    }
+
+    @Test
+    void shouldNotInstallPendingPlugins() throws URISyntaxException {
+      MockHttpRequest request = MockHttpRequest.post("/v2/plugins/pending/install");
+
+      dispatcher.invoke(request, response);
+
+      assertThat(response.getStatus()).isEqualTo(HttpServletResponse.SC_UNAUTHORIZED);
+      verify(pluginManager, never()).installPendingAndRestart();
+    }
+  }
+
+  static class PermissionExceptionMapper implements ExceptionMapper<ShiroException> {
+
+    @Override
+    public Response toResponse(ShiroException exception) {
+      return Response.status(401).entity(exception.getMessage()).build();
+    }
+  }
+
+  private AvailablePlugin createAvailablePlugin(String name) {
+    PluginInformation pluginInformation = new PluginInformation();
+    pluginInformation.setName(name);
+    return createAvailablePlugin(pluginInformation);
+  }
+
+  private AvailablePlugin createAvailablePlugin(PluginInformation pluginInformation) {
+    AvailablePluginDescriptor descriptor = mock(AvailablePluginDescriptor.class);
+    lenient().when(descriptor.getInformation()).thenReturn(pluginInformation);
+    AvailablePlugin availablePlugin = mock(AvailablePlugin.class);
+    lenient().when(availablePlugin.getDescriptor()).thenReturn(descriptor);
+    return availablePlugin;
+  }
+
+  private InstalledPlugin createInstalledPlugin(String name) {
+    PluginInformation pluginInformation = new PluginInformation();
+    pluginInformation.setName(name);
+    return createInstalledPlugin(pluginInformation);
+  }
+
+  private InstalledPlugin createInstalledPlugin(PluginInformation pluginInformation) {
+    InstalledPluginDescriptor descriptor = mock(InstalledPluginDescriptor.class);
+    lenient().when(descriptor.getInformation()).thenReturn(pluginInformation);
+    InstalledPlugin installedPlugin = mock(InstalledPlugin.class);
+    lenient().when(installedPlugin.getDescriptor()).thenReturn(descriptor);
+    return installedPlugin;
+  }
+}

scm-webapp/src/test/java/sonia/scm/api/v2/resources/PluginDtoCollectionMapperTest.java

@@ -0,0 +1,171 @@
+package sonia.scm.api.v2.resources;
+
+import de.otto.edison.hal.HalRepresentation;
+import org.apache.shiro.subject.Subject;
+import org.apache.shiro.subject.support.SubjectThreadState;
+import org.apache.shiro.util.ThreadContext;
+import org.apache.shiro.util.ThreadState;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.junit.jupiter.MockitoExtension;
+import sonia.scm.plugin.AvailablePlugin;
+import sonia.scm.plugin.AvailablePluginDescriptor;
+import sonia.scm.plugin.InstalledPlugin;
+import sonia.scm.plugin.InstalledPluginDescriptor;
+import sonia.scm.plugin.PluginInformation;
+
+import java.net.URI;
+import java.util.List;
+
+import static java.util.Collections.singletonList;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.lenient;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+class PluginDtoCollectionMapperTest {
+
+  ResourceLinks resourceLinks = ResourceLinksMock.createMock(URI.create("/"));
+
+  @InjectMocks
+  PluginDtoMapperImpl pluginDtoMapper;
+
+  Subject subject = mock(Subject.class);
+  ThreadState subjectThreadState = new SubjectThreadState(subject);
+
+  @BeforeEach
+  void bindSubject() {
+    subjectThreadState.bind();
+    ThreadContext.bind(subject);
+  }
+
+  @AfterEach
+  public void unbindSubject() {
+    ThreadContext.unbindSubject();
+  }
+
+
+  @Test
+  void shouldMapInstalledPluginsWithoutUpdateWhenNoNewerVersionIsAvailable() {
+    PluginDtoCollectionMapper mapper = new PluginDtoCollectionMapper(resourceLinks, pluginDtoMapper);
+
+    HalRepresentation result = mapper.mapInstalled(
+      singletonList(createInstalledPlugin("scm-some-plugin", "1")),
+      singletonList(createAvailablePlugin("scm-other-plugin", "2")));
+
+    List<HalRepresentation> plugins = result.getEmbedded().getItemsBy("plugins");
+    assertThat(plugins).hasSize(1);
+    PluginDto plugin = (PluginDto) plugins.get(0);
+    assertThat(plugin.getVersion()).isEqualTo("1");
+    assertThat(plugin.getNewVersion()).isNull();
+  }
+
+  @Test
+  void shouldSetNewVersionInInstalledPluginWhenAvailableVersionIsNewer() {
+    PluginDtoCollectionMapper mapper = new PluginDtoCollectionMapper(resourceLinks, pluginDtoMapper);
+
+    HalRepresentation result = mapper.mapInstalled(
+      singletonList(createInstalledPlugin("scm-some-plugin", "1")),
+      singletonList(createAvailablePlugin("scm-some-plugin", "2")));
+
+    PluginDto plugin = getPluginDtoFromResult(result);
+    assertThat(plugin.getVersion()).isEqualTo("1");
+    assertThat(plugin.getNewVersion()).isEqualTo("2");
+  }
+
+  @Test
+  void shouldNotAddInstallLinkForNewVersionWhenNotPermitted() {
+    when(subject.isPermitted("plugin:manage")).thenReturn(false);
+    PluginDtoCollectionMapper mapper = new PluginDtoCollectionMapper(resourceLinks, pluginDtoMapper);
+
+    HalRepresentation result = mapper.mapInstalled(
+      singletonList(createInstalledPlugin("scm-some-plugin", "1")),
+      singletonList(createAvailablePlugin("scm-some-plugin", "2")));
+
+    PluginDto plugin = getPluginDtoFromResult(result);
+    assertThat(plugin.getLinks().getLinkBy("update")).isEmpty();
+  }
+
+  @Test
+  void shouldNotAddInstallLinkForNewVersionWhenInstallationIsPending() {
+    when(subject.isPermitted("plugin:manage")).thenReturn(true);
+    PluginDtoCollectionMapper mapper = new PluginDtoCollectionMapper(resourceLinks, pluginDtoMapper);
+
+    AvailablePlugin availablePlugin = createAvailablePlugin("scm-some-plugin", "2");
+    when(availablePlugin.isPending()).thenReturn(true);
+    HalRepresentation result = mapper.mapInstalled(
+      singletonList(createInstalledPlugin("scm-some-plugin", "1")),
+      singletonList(availablePlugin));
+
+    PluginDto plugin = getPluginDtoFromResult(result);
+    assertThat(plugin.getLinks().getLinkBy("update")).isEmpty();
+  }
+
+  @Test
+  void shouldAddInstallLinkForNewVersionWhenPermitted() {
+    when(subject.isPermitted("plugin:manage")).thenReturn(true);
+    PluginDtoCollectionMapper mapper = new PluginDtoCollectionMapper(resourceLinks, pluginDtoMapper);
+
+    HalRepresentation result = mapper.mapInstalled(
+      singletonList(createInstalledPlugin("scm-some-plugin", "1")),
+      singletonList(createAvailablePlugin("scm-some-plugin", "2")));
+
+    PluginDto plugin = getPluginDtoFromResult(result);
+    assertThat(plugin.getLinks().getLinkBy("update")).isNotEmpty();
+  }
+
+  @Test
+  void shouldSetInstalledPluginPendingWhenCorrespondingAvailablePluginIsPending() {
+    when(subject.isPermitted("plugin:manage")).thenReturn(true);
+    PluginDtoCollectionMapper mapper = new PluginDtoCollectionMapper(resourceLinks, pluginDtoMapper);
+
+    AvailablePlugin availablePlugin = createAvailablePlugin("scm-some-plugin", "2");
+    when(availablePlugin.isPending()).thenReturn(true);
+    HalRepresentation result = mapper.mapInstalled(
+      singletonList(createInstalledPlugin("scm-some-plugin", "1")),
+      singletonList(availablePlugin));
+
+    PluginDto plugin = getPluginDtoFromResult(result);
+    assertThat(plugin.isPending()).isTrue();
+  }
+
+  private PluginDto getPluginDtoFromResult(HalRepresentation result) {
+    assertThat(result.getEmbedded().getItemsBy("plugins")).hasSize(1);
+    List<HalRepresentation> plugins = result.getEmbedded().getItemsBy("plugins");
+    return (PluginDto) plugins.get(0);
+  }
+
+  private InstalledPlugin createInstalledPlugin(String name, String version) {
+    PluginInformation information = new PluginInformation();
+    information.setName(name);
+    information.setVersion(version);
+    return createInstalledPlugin(information);
+  }
+
+  private InstalledPlugin createInstalledPlugin(PluginInformation information) {
+    InstalledPlugin plugin = mock(InstalledPlugin.class);
+    InstalledPluginDescriptor descriptor = mock(InstalledPluginDescriptor.class);
+    lenient().when(descriptor.getInformation()).thenReturn(information);
+    lenient().when(plugin.getDescriptor()).thenReturn(descriptor);
+    return plugin;
+  }
+
+  private AvailablePlugin createAvailablePlugin(String name, String version) {
+    PluginInformation information = new PluginInformation();
+    information.setName(name);
+    information.setVersion(version);
+    return createAvailablePlugin(information);
+  }
+
+  private AvailablePlugin createAvailablePlugin(PluginInformation information) {
+    AvailablePlugin plugin = mock(AvailablePlugin.class);
+    AvailablePluginDescriptor descriptor = mock(AvailablePluginDescriptor.class);
+    lenient().when(descriptor.getInformation()).thenReturn(information);
+    lenient().when(plugin.getDescriptor()).thenReturn(descriptor);
+    return plugin;
+  }
+}

scm-webapp/src/test/java/sonia/scm/api/v2/resources/PluginDtoMapperTest.java

@@ -17,7 +17,9 @@ import sonia.scm.plugin.InstalledPlugin;
 import sonia.scm.plugin.PluginInformation;
 
 import java.net.URI;
+import java.util.Collections;
 
+import static java.util.Collections.emptyList;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
@@ -76,7 +78,7 @@ class PluginDtoMapperTest {
   void shouldAppendInstalledSelfLink() {
     InstalledPlugin plugin = createInstalled(createPluginInformation());
 
-    PluginDto dto = mapper.mapInstalled(plugin);
+    PluginDto dto = mapper.mapInstalled(plugin, emptyList());
     assertThat(dto.getLinks().getLinkBy("self").get().getHref())
       .isEqualTo("https://hitchhiker.com/v2/plugins/installed/scm-cas-plugin");
   }

scm-webapp/src/test/java/sonia/scm/api/v2/resources/ResourceLinksMock.java

@@ -38,6 +38,7 @@ public class ResourceLinksMock {
     when(resourceLinks.repositoryTypeCollection()).thenReturn(new ResourceLinks.RepositoryTypeCollectionLinks(uriInfo));
     when(resourceLinks.installedPluginCollection()).thenReturn(new ResourceLinks.InstalledPluginCollectionLinks(uriInfo));
     when(resourceLinks.availablePluginCollection()).thenReturn(new ResourceLinks.AvailablePluginCollectionLinks(uriInfo));
+    when(resourceLinks.pendingPluginCollection()).thenReturn(new ResourceLinks.PendingPluginCollectionLinks(uriInfo));
     when(resourceLinks.installedPlugin()).thenReturn(new ResourceLinks.InstalledPluginLinks(uriInfo));
     when(resourceLinks.availablePlugin()).thenReturn(new ResourceLinks.AvailablePluginLinks(uriInfo));
     when(resourceLinks.uiPluginCollection()).thenReturn(new ResourceLinks.UIPluginCollectionLinks(uriInfo));

scm-webapp/src/test/java/sonia/scm/plugin/DefaultUberWebResourceLoaderTest.java

@@ -248,7 +248,7 @@ public class DefaultUberWebResourceLoaderTest extends WebResourceLoaderTestBase
   private InstalledPlugin createPluginWrapper(Path directory)
   {
     return new InstalledPlugin(null, null, new PathWebResourceLoader(directory),
-      directory);
+      directory, false);
   }
 
   //~--- fields ---------------------------------------------------------------

scm-webapp/src/test/java/sonia/scm/plugin/PluginTestHelper.java

@@ -10,12 +10,14 @@ public class PluginTestHelper {
   public static AvailablePlugin createAvailable(String name) {
     PluginInformation information = new PluginInformation();
     information.setName(name);
+    information.setVersion("1.0");
     return createAvailable(information);
   }
 
   public static InstalledPlugin createInstalled(String name) {
     PluginInformation information = new PluginInformation();
     information.setName(name);
+    information.setVersion("1.0");
     return createInstalled(information);
   }