HgPlugin Config: Adds v2 endpoint

scm-plugins/scm-hg-plugin/src/test/java/sonia/scm/api/v2/resources/HgConfigDtoToHgConfigMapperTest.java

@@ -0,0 +1,49 @@
+package sonia.scm.api.v2.resources;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.runners.MockitoJUnitRunner;
+import sonia.scm.repository.HgConfig;
+
+import java.io.File;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+@RunWith(MockitoJUnitRunner.class)
+public class HgConfigDtoToHgConfigMapperTest {
+
+  @InjectMocks
+  private HgConfigDtoToHgConfigMapperImpl mapper;
+
+  @Test
+  public void shouldMapFields() {
+    HgConfigDto dto = createDefaultDto();
+    HgConfig config = mapper.map(dto);
+
+    assertTrue(config.isDisabled());
+    assertEquals("repository/directory", config.getRepositoryDirectory().getPath());
+
+    assertEquals("ABC", config.getEncoding());
+    assertEquals("/etc/hg", config.getHgBinary());
+    assertEquals("/py", config.getPythonBinary());
+    assertEquals("/etc/", config.getPythonPath());
+    assertTrue(config.isShowRevisionInId());
+    assertTrue(config.isUseOptimizedBytecode());
+  }
+
+  private HgConfigDto createDefaultDto() {
+    HgConfigDto configDto = new HgConfigDto();
+    configDto.setDisabled(true);
+    configDto.setRepositoryDirectory(new File("repository/directory"));
+    configDto.setEncoding("ABC");
+    configDto.setHgBinary("/etc/hg");
+    configDto.setPythonBinary("/py");
+    configDto.setPythonPath("/etc/");
+    configDto.setShowRevisionInId(true);
+    configDto.setUseOptimizedBytecode(true);
+
+    return configDto;
+  }
+}

scm-plugins/scm-hg-plugin/src/test/java/sonia/scm/api/v2/resources/HgConfigResourceTest.java

@@ -0,0 +1,158 @@
+package sonia.scm.api.v2.resources;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import com.github.sdorra.shiro.ShiroRule;
+import com.github.sdorra.shiro.SubjectAware;
+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.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.junit.runner.RunWith;
+import org.mockito.Answers;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+import sonia.scm.repository.HgConfig;
+import sonia.scm.repository.HgRepositoryHandler;
+import sonia.scm.repository.HgVndMediaType;
+
+import javax.servlet.http.HttpServletResponse;
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+import java.net.URISyntaxException;
+
+import static junit.framework.TestCase.assertTrue;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.mockito.Mockito.when;
+
+@SubjectAware(
+  configuration = "classpath:sonia/scm/configuration/shiro.ini",
+  password = "secret"
+)
+@RunWith(MockitoJUnitRunner.class)
+public class HgConfigResourceTest {
+
+  @Rule
+  public ShiroRule shiro = new ShiroRule();
+
+  @Rule
+  public ExpectedException thrown = ExpectedException.none();
+
+  private Dispatcher dispatcher = MockDispatcherFactory.createDispatcher();
+
+  private final URI baseUri = URI.create("/");
+
+  @InjectMocks
+  private HgConfigDtoToHgConfigMapperImpl dtoToConfigMapper;
+
+  @Mock(answer = Answers.RETURNS_DEEP_STUBS)
+  private UriInfoStore uriInfoStore;
+
+  @InjectMocks
+  private HgConfigToHgConfigDtoMapperImpl configToDtoMapper;
+
+  @Mock
+  private HgRepositoryHandler repositoryHandler;
+
+  @Before
+  public void prepareEnvironment() {
+    HgConfig gitConfig = createConfiguration();
+    when(repositoryHandler.getConfig()).thenReturn(gitConfig);
+    HgConfigResource gitConfigResource = new HgConfigResource(dtoToConfigMapper, configToDtoMapper, repositoryHandler);
+    dispatcher.getRegistry().addSingletonResource(gitConfigResource);
+    when(uriInfoStore.get().getBaseUri()).thenReturn(baseUri);
+  }
+
+  @Test
+  @SubjectAware(username = "readWrite")
+  public void shouldGetHgConfig() throws URISyntaxException, IOException {
+    MockHttpResponse response = get();
+
+    assertEquals(HttpServletResponse.SC_OK, response.getStatus());
+
+    String responseString = response.getContentAsString();
+    ObjectNode responseJson = new ObjectMapper().readValue(responseString, ObjectNode.class);
+
+    assertTrue(responseString.contains("\"disabled\":false"));
+    assertTrue(responseJson.get("repositoryDirectory").asText().endsWith("repository/directory"));
+    assertTrue(responseString.contains("\"self\":{\"href\":\"/v2/config/hg"));
+    assertTrue(responseString.contains("\"update\":{\"href\":\"/v2/config/hg"));
+  }
+
+  @Test
+  @SubjectAware(username = "readWrite")
+  public void shouldGetHgConfigEvenWhenItsEmpty() throws URISyntaxException, IOException {
+    when(repositoryHandler.getConfig()).thenReturn(null);
+
+    MockHttpResponse response = get();
+    String responseString = response.getContentAsString();
+
+    assertTrue(responseString.contains("\"disabled\":false"));
+  }
+
+  @Test
+  @SubjectAware(username = "readOnly")
+  public void shouldGetHgConfigWithoutUpdateLink() throws URISyntaxException {
+    MockHttpResponse response = get();
+
+    assertEquals(HttpServletResponse.SC_OK, response.getStatus());
+
+    assertFalse(response.getContentAsString().contains("\"update\":{\"href\":\"/v2/config/hg"));
+  }
+
+  @Test
+  @SubjectAware(username = "writeOnly")
+  public void shouldGetConfigOnlyWhenAuthorized() throws URISyntaxException {
+    thrown.expectMessage("Subject does not have permission [configuration:read:hg]");
+
+    get();
+  }
+
+  @Test
+  @SubjectAware(username = "writeOnly")
+  public void shouldUpdateConfig() throws URISyntaxException {
+    MockHttpResponse response = put();
+    assertEquals(HttpServletResponse.SC_NO_CONTENT, response.getStatus());
+  }
+
+  @Test
+  @SubjectAware(username = "readOnly")
+  public void shouldUpdateConfigOnlyWhenAuthorized() throws URISyntaxException, IOException {
+    thrown.expectMessage("Subject does not have permission [configuration:write:hg]");
+
+    put();
+  }
+
+  private MockHttpResponse get() throws URISyntaxException {
+    MockHttpRequest request = MockHttpRequest.get("/" + HgConfigResource.GIT_CONFIG_PATH_V2);
+    MockHttpResponse response = new MockHttpResponse();
+    dispatcher.invoke(request, response);
+    return response;
+  }
+
+  private MockHttpResponse put() throws URISyntaxException {
+    MockHttpRequest request = MockHttpRequest.put("/" + HgConfigResource.GIT_CONFIG_PATH_V2)
+                                             .contentType(HgVndMediaType.HG_CONFIG)
+                                             .content("{\"disabled\":true}".getBytes());
+
+    MockHttpResponse response = new MockHttpResponse();
+    dispatcher.invoke(request, response);
+    return response;
+  }
+
+  private HgConfig createConfiguration() {
+    HgConfig config = new HgConfig();
+    config.setDisabled(false);
+    config.setRepositoryDirectory(new File("repository/directory"));
+    return config;
+  }
+
+}
+

scm-plugins/scm-hg-plugin/src/test/java/sonia/scm/api/v2/resources/HgConfigToHgConfigDtoMapperTest.java

@@ -0,0 +1,102 @@
+package sonia.scm.api.v2.resources;
+
+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.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Answers;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+import sonia.scm.repository.HgConfig;
+
+import java.io.File;
+import java.net.URI;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+@RunWith(MockitoJUnitRunner.class)
+public class HgConfigToHgConfigDtoMapperTest {
+
+  private URI baseUri = URI.create("http://example.com/base/");
+
+  @Mock(answer = Answers.RETURNS_DEEP_STUBS)
+  private UriInfoStore uriInfoStore;
+
+  @InjectMocks
+  private HgConfigToHgConfigDtoMapperImpl mapper;
+
+  private final Subject subject = mock(Subject.class);
+  private final ThreadState subjectThreadState = new SubjectThreadState(subject);
+
+  private URI expectedBaseUri;
+
+  @Before
+  public void init() {
+    when(uriInfoStore.get().getBaseUri()).thenReturn(baseUri);
+    expectedBaseUri = baseUri.resolve(HgConfigResource.GIT_CONFIG_PATH_V2);
+    subjectThreadState.bind();
+    ThreadContext.bind(subject);
+  }
+
+  @After
+  public void unbindSubject() {
+    ThreadContext.unbindSubject();
+  }
+
+  @Test
+  public void shouldMapFields() {
+    HgConfig config = createConfiguration();
+
+    when(subject.isPermitted("configuration:write:hg")).thenReturn(true);
+    HgConfigDto dto = mapper.map(config);
+
+    assertTrue(dto.isDisabled());
+    assertEquals("repository/directory", dto.getRepositoryDirectory().getPath());
+
+    assertEquals("ABC", dto.getEncoding());
+    assertEquals("/etc/hg", dto.getHgBinary());
+    assertEquals("/py", dto.getPythonBinary());
+    assertEquals("/etc/", dto.getPythonPath());
+    assertTrue(dto.isShowRevisionInId());
+    assertTrue(dto.isUseOptimizedBytecode());
+
+    assertEquals(expectedBaseUri.toString(), dto.getLinks().getLinkBy("self").get().getHref());
+    assertEquals(expectedBaseUri.toString(), dto.getLinks().getLinkBy("update").get().getHref());
+  }
+
+  @Test
+  public void shouldMapFieldsWithoutUpdate() {
+    HgConfig config = createConfiguration();
+
+    when(subject.isPermitted("configuration:write:hg")).thenReturn(false);
+    HgConfigDto dto = mapper.map(config);
+
+    assertEquals(expectedBaseUri.toString(), dto.getLinks().getLinkBy("self").get().getHref());
+    assertFalse(dto.getLinks().hasLink("update"));
+  }
+
+  private HgConfig createConfiguration() {
+    HgConfig config = new HgConfig();
+    config.setDisabled(true);
+    config.setRepositoryDirectory(new File("repository/directory"));
+
+    config.setEncoding("ABC");
+    config.setHgBinary("/etc/hg");
+    config.setPythonBinary("/py");
+    config.setPythonPath("/etc/");
+    config.setShowRevisionInId(true);
+    config.setUseOptimizedBytecode(true);
+    
+    return config;
+  }
+
+}