implement simplified PluginManager API

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

@@ -0,0 +1,149 @@
+package sonia.scm.plugin;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import org.checkerframework.checker.nullness.Opt;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Answers;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+class DefaultPluginManagerTest {
+
+  @Mock
+  private PluginLoader loader;
+
+  @Mock
+  private PluginCenter center;
+
+  @InjectMocks
+  private DefaultPluginManager manager;
+
+  @Test
+  void shouldReturnInstalledPlugins() {
+    InstalledPlugin review = createInstalled("scm-review-plugin");
+    InstalledPlugin git = createInstalled("scm-git-plugin");
+
+    when(loader.getInstalledPlugins()).thenReturn(ImmutableList.of(review, git));
+
+    List<InstalledPlugin> installed = manager.getInstalled();
+    assertThat(installed).containsOnly(review, git);
+  }
+
+  @Test
+  void shouldReturnReviewPlugin() {
+    InstalledPlugin review = createInstalled("scm-review-plugin");
+    InstalledPlugin git = createInstalled("scm-git-plugin");
+
+    when(loader.getInstalledPlugins()).thenReturn(ImmutableList.of(review, git));
+
+    Optional<InstalledPlugin> plugin = manager.getInstalled("scm-review-plugin");
+    assertThat(plugin).contains(review);
+  }
+
+  @Test
+  void shouldReturnEmptyForNonInstalledPlugin() {
+    when(loader.getInstalledPlugins()).thenReturn(ImmutableList.of());
+
+    Optional<InstalledPlugin> plugin = manager.getInstalled("scm-review-plugin");
+    assertThat(plugin).isEmpty();
+  }
+
+  @Test
+  void shouldReturnAvailablePlugins() {
+    AvailablePlugin review = createAvailable("scm-review-plugin");
+    AvailablePlugin git = createAvailable("scm-git-plugin");
+
+    when(center.getAvailable()).thenReturn(ImmutableSet.of(review, git));
+
+    List<AvailablePlugin> available = manager.getAvailable();
+    assertThat(available).containsOnly(review, git);
+  }
+
+  @Test
+  void shouldFilterOutAllInstalled() {
+    InstalledPlugin installedGit = createInstalled("scm-git-plugin");
+    when(loader.getInstalledPlugins()).thenReturn(ImmutableList.of(installedGit));
+
+    AvailablePlugin review = createAvailable("scm-review-plugin");
+    AvailablePlugin git = createAvailable("scm-git-plugin");
+    when(center.getAvailable()).thenReturn(ImmutableSet.of(review, git));
+
+    List<AvailablePlugin> available = manager.getAvailable();
+    assertThat(available).containsOnly(review);
+  }
+
+  @Test
+  void shouldReturnAvailable() {
+    AvailablePlugin review = createAvailable("scm-review-plugin");
+    AvailablePlugin git = createAvailable("scm-git-plugin");
+    when(center.getAvailable()).thenReturn(ImmutableSet.of(review, git));
+
+    Optional<AvailablePlugin> available = manager.getAvailable("scm-git-plugin");
+    assertThat(available).contains(git);
+  }
+
+  @Test
+  void shouldReturnEmptyForNonExistingAvailable() {
+    AvailablePlugin review = createAvailable("scm-review-plugin");
+    when(center.getAvailable()).thenReturn(ImmutableSet.of(review));
+
+    Optional<AvailablePlugin> available = manager.getAvailable("scm-git-plugin");
+    assertThat(available).isEmpty();
+  }
+
+  @Test
+  void shouldReturnEmptyForInstalledPlugin() {
+    InstalledPlugin installedGit = createInstalled("scm-git-plugin");
+    when(loader.getInstalledPlugins()).thenReturn(ImmutableList.of(installedGit));
+
+    AvailablePlugin git = createAvailable("scm-git-plugin");
+    when(center.getAvailable()).thenReturn(ImmutableSet.of(git));
+
+    Optional<AvailablePlugin> available = manager.getAvailable("scm-git-plugin");
+    assertThat(available).isEmpty();
+  }
+
+  private AvailablePlugin createAvailable(String name) {
+    PluginInformation information = new PluginInformation();
+    information.setName(name);
+    return createAvailable(information);
+  }
+
+  private InstalledPlugin createInstalled(String name) {
+    PluginInformation information = new PluginInformation();
+    information.setName(name);
+    return createInstalled(information);
+  }
+
+  private InstalledPlugin createInstalled(PluginInformation information) {
+    InstalledPlugin plugin = mock(InstalledPlugin.class, Answers.RETURNS_DEEP_STUBS);
+    returnInformation(plugin, information);
+    return plugin;
+  }
+
+  private AvailablePlugin createAvailable(PluginInformation information) {
+    AvailablePlugin plugin = mock(AvailablePlugin.class, Answers.RETURNS_DEEP_STUBS);
+    returnInformation(plugin, information);
+    return plugin;
+  }
+
+  private void returnInformation(Plugin mockedPlugin, PluginInformation information) {
+    when(mockedPlugin.getDescriptor().getInformation()).thenReturn(information);
+  }
+
+}

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

@@ -2,6 +2,11 @@ package sonia.scm.plugin;
 
 import com.google.common.collect.ImmutableSet;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Answers;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -11,11 +16,19 @@ import java.util.List;
 import java.util.Set;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.when;
 import static sonia.scm.plugin.PluginCenterDto.Plugin;
 import static sonia.scm.plugin.PluginCenterDto.*;
 
+@ExtendWith(MockitoExtension.class)
 class PluginCenterDtoMapperTest {
 
+  @Mock(answer = Answers.RETURNS_DEEP_STUBS)
+  private PluginCenterDto dto;
+
+  @InjectMocks
+  private PluginCenterDtoMapperImpl mapper;
+
   @Test
   void shouldMapSinglePlugin() {
     Plugin plugin = new Plugin(
@@ -31,16 +44,19 @@ class PluginCenterDtoMapperTest {
       ImmutableSet.of("scm-review-plugin"),
       new HashMap<>());
 
-    PluginInformation result = PluginCenterDtoMapper.map(Collections.singletonList(plugin)).iterator().next();
+    when(dto.getEmbedded().getPlugins()).thenReturn(Collections.singletonList(plugin));
+    AvailablePluginDescriptor descriptor = mapper.map(dto).iterator().next().getDescriptor();
+    PluginInformation information = descriptor.getInformation();
+    PluginCondition condition = descriptor.getCondition();
 
-    assertThat(result.getAuthor()).isEqualTo(plugin.getAuthor());
-    assertThat(result.getCategory()).isEqualTo(plugin.getCategory());
-    assertThat(result.getVersion()).isEqualTo(plugin.getVersion());
-    assertThat(result.getCondition().getArch()).isEqualTo(plugin.getConditions().getArch());
-    assertThat(result.getCondition().getMinVersion()).isEqualTo(plugin.getConditions().getMinVersion());
-    assertThat(result.getCondition().getOs().iterator().next()).isEqualTo(plugin.getConditions().getOs().iterator().next());
-    assertThat(result.getDescription()).isEqualTo(plugin.getDescription());
-    assertThat(result.getName()).isEqualTo(plugin.getName());
+    assertThat(information.getAuthor()).isEqualTo(plugin.getAuthor());
+    assertThat(information.getCategory()).isEqualTo(plugin.getCategory());
+    assertThat(information.getVersion()).isEqualTo(plugin.getVersion());
+    assertThat(condition.getArch()).isEqualTo(plugin.getConditions().getArch());
+    assertThat(condition.getMinVersion()).isEqualTo(plugin.getConditions().getMinVersion());
+    assertThat(condition.getOs().iterator().next()).isEqualTo(plugin.getConditions().getOs().iterator().next());
+    assertThat(information.getDescription()).isEqualTo(plugin.getDescription());
+    assertThat(information.getName()).isEqualTo(plugin.getName());
   }
 
   @Test
@@ -71,12 +87,14 @@ class PluginCenterDtoMapperTest {
       ImmutableSet.of("scm-review-plugin"),
       new HashMap<>());
 
-    Set<PluginInformation> resultSet = PluginCenterDtoMapper.map(Arrays.asList(plugin1, plugin2));
+    when(dto.getEmbedded().getPlugins()).thenReturn(Arrays.asList(plugin1, plugin2));
 
-    List<PluginInformation> pluginsList = new ArrayList<>(resultSet);
+    Set<AvailablePlugin> resultSet = mapper.map(dto);
 
-    PluginInformation pluginInformation1 = pluginsList.get(1);
-    PluginInformation pluginInformation2 = pluginsList.get(0);
+    List<AvailablePlugin> pluginsList = new ArrayList<>(resultSet);
+
+    PluginInformation pluginInformation1 = pluginsList.get(1).getDescriptor().getInformation();
+    PluginInformation pluginInformation2 = pluginsList.get(0).getDescriptor().getInformation();
 
     assertThat(pluginInformation1.getAuthor()).isEqualTo(plugin1.getAuthor());
     assertThat(pluginInformation1.getVersion()).isEqualTo(plugin1.getVersion());

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

@@ -0,0 +1,50 @@
+package sonia.scm.plugin;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Answers;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import sonia.scm.net.ahc.AdvancedHttpClient;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.Set;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+class PluginCenterLoaderTest {
+
+  private static final String PLUGIN_URL = "https://plugins.hitchhiker.com";
+
+  @Mock(answer = Answers.RETURNS_DEEP_STUBS)
+  private AdvancedHttpClient client;
+
+  @Mock
+  private PluginCenterDtoMapper mapper;
+
+  @InjectMocks
+  private PluginCenterLoader loader;
+
+  @Test
+  void shouldFetch() throws IOException {
+    Set<AvailablePlugin> plugins = Collections.emptySet();
+    PluginCenterDto dto = new PluginCenterDto();
+    when(client.get(PLUGIN_URL).request().contentFromJson(PluginCenterDto.class)).thenReturn(dto);
+    when(mapper.map(dto)).thenReturn(plugins);
+
+    Set<AvailablePlugin> fetched = loader.load(PLUGIN_URL);
+    assertThat(fetched).isSameAs(plugins);
+  }
+
+  @Test
+  void shouldReturnEmptySetIfPluginCenterNotBeReached() throws IOException {
+    when(client.get(PLUGIN_URL).request()).thenThrow(new IOException("failed to fetch"));
+
+    Set<AvailablePlugin> fetch = loader.load(PLUGIN_URL);
+    assertThat(fetch).isEmpty();
+  }
+}

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

@@ -0,0 +1,73 @@
+package sonia.scm.plugin;
+
+import com.google.common.collect.ImmutableSet;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Answers;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import sonia.scm.SCMContextProvider;
+import sonia.scm.cache.CacheManager;
+import sonia.scm.cache.MapCacheManager;
+import sonia.scm.config.ScmConfiguration;
+import sonia.scm.net.ahc.AdvancedHttpClient;
+import sonia.scm.util.SystemUtil;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+class PluginCenterTest {
+
+  private static final String PLUGIN_URL_BASE = "https://plugins.hitchhiker.com/";
+  private static final String PLUGIN_URL = PLUGIN_URL_BASE + "{version}";
+
+  @Mock
+  private PluginCenterLoader loader;
+
+  @Mock
+  private SCMContextProvider contextProvider;
+
+  private ScmConfiguration configuration;
+
+  private CacheManager cacheManager;
+
+  private PluginCenter pluginCenter;
+
+  @BeforeEach
+  void setUpPluginCenter() {
+    when(contextProvider.getVersion()).thenReturn("2.0.0");
+
+    cacheManager = new MapCacheManager();
+
+    configuration = new ScmConfiguration();
+    configuration.setPluginUrl(PLUGIN_URL);
+
+    pluginCenter = new PluginCenter(contextProvider, cacheManager, configuration, loader);
+  }
+
+  @Test
+  void shouldFetchPlugins() {
+    Set<AvailablePlugin> plugins = new HashSet<>();
+    when(loader.load(PLUGIN_URL_BASE + "2.0.0")).thenReturn(plugins);
+
+    assertThat(pluginCenter.getAvailable()).isSameAs(plugins);
+  }
+
+  @Test
+  void shouldCache() {
+    Set<AvailablePlugin> first = new HashSet<>();
+    when(loader.load(anyString())).thenReturn(first, new HashSet<>());
+
+    assertThat(pluginCenter.getAvailable()).isSameAs(first);
+    assertThat(pluginCenter.getAvailable()).isSameAs(first);
+  }
+
+}