Merge branch 'master' into pr/704

# Conflicts:
#	src/main/java/org/gitlab4j/api/ProjectApi.java
#	src/main/java/org/gitlab4j/api/models/ProjectHook.java

src/main/java/org/gitlab4j/api/models/MarkdownRequest.java

+package org.gitlab4j.api.models;
+
+public class MarkdownRequest {
+    private String text;
+    private boolean gfm;
+
+    public MarkdownRequest(String text, boolean gfm) {
+        this.text = text;
+        this.gfm = gfm;
+    }
+
+    public String getText() {
+        return text;
+    }
+
+    public void setText(String text) {
+        this.text = text;
+    }
+
+    public boolean isGfm() {
+        return gfm;
+    }
+
+    public void setGfm(boolean gfm) {
+        this.gfm = gfm;
+    }
+}

src/main/java/org/gitlab4j/api/models/Membership.java

+package org.gitlab4j.api.models;
+
+import org.gitlab4j.api.utils.JacksonJson;
+
+public class Membership {
+
+    private Integer sourceId;
+    private String sourceName;
+    private MembershipSourceType sourceType;
+    private AccessLevel accessLevel;
+
+    public Integer getSourceId() {
+        return sourceId;
+    }
+
+    public void setSourceId(Integer sourceId) {
+        this.sourceId = sourceId;
+    }
+
+    public String getSourceName() {
+        return sourceName;
+    }
+
+    public void setSourceName(String sourceName) {
+        this.sourceName = sourceName;
+    }
+
+    public MembershipSourceType getSourceType() {
+        return sourceType;
+    }
+
+    public void setSourceType(MembershipSourceType sourceType) {
+        this.sourceType = sourceType;
+    }
+
+    public AccessLevel getAccessLevel() {
+        return accessLevel;
+    }
+
+    public void setAccessLevel(AccessLevel accessLevel) {
+        this.accessLevel = accessLevel;
+    }
+
+    @Override
+    public String toString() {
+        return (JacksonJson.toJsonString(this));
+    }
+}

src/main/java/org/gitlab4j/api/models/MembershipSourceType.java

+package org.gitlab4j.api.models;
+
+import org.gitlab4j.api.utils.JacksonJsonEnumHelper;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonValue;
+
+public enum MembershipSourceType {
+
+    PROJECT,
+
+    /** Representing a group */
+    NAMESPACE;
+
+    private static JacksonJsonEnumHelper<MembershipSourceType> enumHelper = new JacksonJsonEnumHelper<>(MembershipSourceType.class);
+
+    @JsonCreator
+    public static MembershipSourceType forValue(String value) {
+        return enumHelper.forValue(value);
+    }
+
+    @JsonValue
+    public String toValue() {
+        return (enumHelper.toString(this));
+    }
+
+    @Override
+    public String toString() {
+        return (enumHelper.toString(this));
+    }
+}

src/main/java/org/gitlab4j/api/models/Project.java

@@ -6,6 +6,7 @@ import java.util.List;
 
 import org.gitlab4j.api.Constants.AutoDevopsDeployStrategy;
 import org.gitlab4j.api.Constants.BuildGitStrategy;
+import org.gitlab4j.api.Constants.SquashOption;
 import org.gitlab4j.api.ProjectLicense;
 import org.gitlab4j.api.models.ImportStatus.Status;
 import org.gitlab4j.api.utils.JacksonJson;
@@ -104,6 +105,8 @@ public class Project {
     private AutoDevopsDeployStrategy autoDevopsDeployStrategy;
     private Boolean autocloseReferencedIssues;
     private Boolean emailsDisabled;
+    private String suggestionCommitMessage;
+    private SquashOption squashOption;
 
     @JsonSerialize(using = JacksonJson.DateOnlySerializer.class)
     private Date markedForDeletionOn;
@@ -787,6 +790,11 @@ public class Project {
         this.removeSourceBranchAfterMerge = removeSourceBranchAfterMerge;
     }
 
+    public Project withRemoveSourceBranchAfterMerge(Boolean removeSourceBranchAfterMerge) {
+        this.removeSourceBranchAfterMerge = removeSourceBranchAfterMerge;
+        return this;
+    }
+
     public Boolean getAutoDevopsEnabled() {
         return autoDevopsEnabled;
     }
@@ -823,4 +831,30 @@ public class Project {
         this.emailsDisabled = emailsDisabled;
         return this;
     }
+
+    public String getSuggestionCommitMessage() {
+        return this.suggestionCommitMessage;
+    }
+
+    public Project withSuggestionCommitMessage(String suggestionCommitMessage) {
+        this.suggestionCommitMessage = suggestionCommitMessage;
+        return this;
+    }
+
+    public void setSuggestionCommitMessage(String suggestionCommitMessage) {
+        this.suggestionCommitMessage = suggestionCommitMessage;
+    }
+
+    public SquashOption getSquashOption() {
+        return squashOption;
+    }
+
+    public void setSquashOption(SquashOption squashOption) {
+        this.squashOption = squashOption;
+    }
+
+    public Project withSquashOption(SquashOption squashOption) {
+        this.squashOption = squashOption;
+        return this;
+    }
 }

src/main/java/org/gitlab4j/api/models/ProjectHook.java

 
 package org.gitlab4j.api.models;
 
-import org.gitlab4j.api.utils.JacksonJson;
-
 import java.util.Date;
 
+import org.gitlab4j.api.utils.JacksonJson;
+
 public class ProjectHook {
 
     private Boolean buildEvents;
@@ -12,8 +12,6 @@ public class ProjectHook {
     private Boolean enableSslVerification;
     private Integer id;
     private Boolean issuesEvents;
-    private Boolean deploymentEvents;
-    private Boolean releasesEvents;
     private Boolean mergeRequestsEvents;
     private Boolean noteEvents;
     private Boolean jobEvents;
@@ -30,6 +28,9 @@ public class ProjectHook {
     private Boolean confidentialNoteEvents;
     private String pushEventsBranchFilter;
 
+    private Boolean deploymentEvents;
+    private Boolean releasesEvents;
+
     public Boolean getBuildEvents() {
         return buildEvents;
     }
@@ -158,6 +159,22 @@ public class ProjectHook {
         this.repositoryUpdateEvents = repositoryUpdateEvents;
     }
 
+    public Boolean getDeploymentEvents() {
+        return deploymentEvents;
+    }
+
+    public void setDeploymentEvents(Boolean releasesEvents) {
+        this.deploymentEvents = releasesEvents;
+    }
+
+    public Boolean getReleasesEvents() {
+        return releasesEvents;
+    }
+
+    public void setReleasesEvents(Boolean releasesEvents) {
+        this.releasesEvents = releasesEvents;
+    }
+
     public Boolean getConfidentialIssuesEvents() {
         return confidentialIssuesEvents;
     }
@@ -182,22 +199,6 @@ public class ProjectHook {
         this.pushEventsBranchFilter = pushEventsBranchFilter;
     }
 
-    public Boolean getDeploymentEvents() {
-        return deploymentEvents;
-    }
-
-    public void setDeploymentEvents(Boolean deploymentEvents) {
-        this.deploymentEvents = deploymentEvents;
-    }
-
-    public Boolean getReleasesEvents() {
-        return releasesEvents;
-    }
-
-    public void setReleasesEvents(Boolean releasesEvents) {
-        this.releasesEvents = releasesEvents;
-    }
-
     public ProjectHook withIssuesEvents(Boolean issuesEvents) {
         this.issuesEvents = issuesEvents;
         return (this);

src/main/java/org/gitlab4j/api/models/SystemHook.java

@@ -13,6 +13,7 @@ public class SystemHook {
     private Boolean tagPushEvents;
     private Boolean enableSslVerification;
     private Boolean repositoryUpdateEvents;
+    private Boolean mergeRequestsEvents;
 
     public Integer getId() {
         return id;
@@ -70,6 +71,14 @@ public class SystemHook {
         return repositoryUpdateEvents;
     }
 
+    public void setMergeRequestsEvents(Boolean mergeRequestsEvents) {
+        this.mergeRequestsEvents = mergeRequestsEvents;
+    }
+
+    public Boolean getMergeRequestsEvents() {
+        return mergeRequestsEvents;
+    }
+
     public SystemHook withId(Integer id) {
         this.id = id;
         return (this);
@@ -105,6 +114,11 @@ public class SystemHook {
         return (this);
     }
 
+    public SystemHook withMergeRequestsEvents(Boolean mergeRequestsEvents) {
+        this.mergeRequestsEvents = mergeRequestsEvents;
+        return (this);
+    }
+
     @Override
     public String toString() {
         return (JacksonJson.toJsonString(this));

src/main/java/org/gitlab4j/api/models/User.java

@@ -8,6 +8,7 @@ import org.gitlab4j.api.utils.JacksonJson;
 public class User extends AbstractUser<User> {
 
     private String bio;
+    private Boolean bot;
     private Boolean canCreateGroup;
     private Boolean canCreateProject;
     private Integer colorSchemeId;
@@ -45,6 +46,14 @@ public class User extends AbstractUser<User> {
         this.bio = bio;
     }
 
+    public Boolean getBot() {
+        return bot;
+    }
+
+    public void setBot(Boolean bot) {
+        this.bot = bot;
+    }
+
     public Boolean getCanCreateGroup() {
         return canCreateGroup;
     }

src/test/java/org/gitlab4j/api/PropertyConstants.java

@@ -2,33 +2,32 @@ package org.gitlab4j.api;
 
 public interface PropertyConstants {
 
-    public static final String TEST_PROJECT_SUBDIRECTORY_PATH = "src/main/docs/test-project.txt";
-    public static final String TEST_PROPERTIES_FILENAME = "test-gitlab4j.properties";
+    String TEST_PROJECT_SUBDIRECTORY_PATH = "src/main/docs/test-project.txt";
 
-    // The following are keys used to look up values in the test propertiues file
-    public static final String ADMIN_PASSWORD_KEY = "TEST_ADMIN_PASSWORD";
-    public static final String ADMIN_USERNAME_KEY = "TEST_ADMIN_USERNAME";
-    public static final String ACCESS_TOKEN_KEY = "TEST_ACCESS_TOKEN";
-    public static final String BLOCK_USERNAME_KEY = "TEST_BLOCK_USERNAME";
-    public static final String GROUP_KEY = "TEST_GROUP";
-    public static final String GROUP_MEMBER_USERNAME_KEY = "TEST_GROUP_MEMBER_USERNAME";
-    public static final String GROUP_PROJECT_KEY = "TEST_GROUP_PROJECT";
-    public static final String HEALTH_CHECK_TOKEN_KEY = "TEST_HEALTH_CHECK_TOKEN";
-    public static final String HOST_URL_KEY = "TEST_HOST_URL";
-    public static final String LOGIN_PASSWORD_KEY = "TEST_LOGIN_PASSWORD";
-    public static final String LOGIN_USERNAME_KEY = "TEST_LOGIN_USERNAME";
-    public static final String NAMESPACE_KEY =  "TEST_NAMESPACE";
-    public static final String PRIVATE_TOKEN_KEY =  "TEST_PRIVATE_TOKEN";
-    public static final String PROJECT_NAME_KEY = "TEST_PROJECT_NAME";
-    public static final String PROXY_PASSWORD_KEY = "TEST_PROXY_PASSWORD";
-    public static final String PROXY_URI_KEY = "TEST_PROXY_URI";
-    public static final String PROXY_USERNAME_KEY = "TEST_PROXY_USERNAME";
-    public static final String SUB_GROUP_KEY = "TEST_SUB_GROUP";
-    public static final String SUDO_AS_USERNAME_KEY = "TEST_SUDO_AS_USERNAME";
-    public static final String TEST_REQUEST_ACCESS_USERNAME_KEY = "TEST_REQUEST_ACCESS_USERNAME";
-    public static final String USERNAME_KEY = "TEST_USERNAME";
-    public static final String XFER_NAMESPACE_KEY = "TEST_XFER_NAMESPACE";
-    public static final String EXTERNAL_PROVIDER_KEY = "TEST_EXTERNAL_PROVIDER";
-    public static final String EXTERNAL_UID_KEY = "TEST_EXTERNAL_UID";
-    public static final String EXTERNAL_USERNAME_KEY = "TEST_EXTERNAL_USERNAME";
+    // The following are keys used to look up values in the test properties file
+    String ADMIN_PASSWORD_KEY = "TEST_ADMIN_PASSWORD";
+    String ADMIN_USERNAME_KEY = "TEST_ADMIN_USERNAME";
+    String ACCESS_TOKEN_KEY = "TEST_ACCESS_TOKEN";
+    String BLOCK_USERNAME_KEY = "TEST_BLOCK_USERNAME";
+    String GROUP_KEY = "TEST_GROUP";
+    String GROUP_MEMBER_USERNAME_KEY = "TEST_GROUP_MEMBER_USERNAME";
+    String GROUP_PROJECT_KEY = "TEST_GROUP_PROJECT";
+    String HEALTH_CHECK_TOKEN_KEY = "TEST_HEALTH_CHECK_TOKEN";
+    String HOST_URL_KEY = "TEST_HOST_URL";
+    String LOGIN_PASSWORD_KEY = "TEST_LOGIN_PASSWORD";
+    String LOGIN_USERNAME_KEY = "TEST_LOGIN_USERNAME";
+    String NAMESPACE_KEY =  "TEST_NAMESPACE";
+    String PRIVATE_TOKEN_KEY =  "TEST_PRIVATE_TOKEN";
+    String PROJECT_NAME_KEY = "TEST_PROJECT_NAME";
+    String PROXY_PASSWORD_KEY = "TEST_PROXY_PASSWORD";
+    String PROXY_URI_KEY = "TEST_PROXY_URI";
+    String PROXY_USERNAME_KEY = "TEST_PROXY_USERNAME";
+    String SUB_GROUP_KEY = "TEST_SUB_GROUP";
+    String SUDO_AS_USERNAME_KEY = "TEST_SUDO_AS_USERNAME";
+    String TEST_REQUEST_ACCESS_USERNAME_KEY = "TEST_REQUEST_ACCESS_USERNAME";
+    String USERNAME_KEY = "TEST_USERNAME";
+    String XFER_NAMESPACE_KEY = "TEST_XFER_NAMESPACE";
+    String EXTERNAL_PROVIDER_KEY = "TEST_EXTERNAL_PROVIDER";
+    String EXTERNAL_UID_KEY = "TEST_EXTERNAL_UID";
+    String EXTERNAL_USERNAME_KEY = "TEST_EXTERNAL_USERNAME";
 }

src/test/java/org/gitlab4j/api/TestDeploymentsApi.java

+package org.gitlab4j.api;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.junit.Assume.assumeTrue;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Stream;
+
+import org.gitlab4j.api.Constants.DeploymentStatus;
+import org.gitlab4j.api.models.Commit;
+import org.gitlab4j.api.models.Deployment;
+import org.gitlab4j.api.models.DeploymentFilter;
+import org.gitlab4j.api.models.Project;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+/**
+ * In order for these tests to run you must set the following properties in
+ * test-gitlab4j.properties
+ *
+ * TEST_HOST_URL TEST_PRIVATE_TOKEN TEST_USERNAME
+ *
+ * If any of the above are NULL, all tests in this class will be skipped.
+ *
+ */
+@Category(IntegrationTest.class)
+public class TestDeploymentsApi extends AbstractIntegrationTest {
+
+    // The following needs to be set to your test repository
+    private static final String TEST_USERNAME = HelperUtils.getProperty(USERNAME_KEY);
+
+    private static GitLabApi gitLabApi;
+    private static Project testProject;
+
+    public TestDeploymentsApi() {
+        super();
+    }
+
+    @BeforeClass
+    public static void setup() {
+
+        // Must setup the connection to the GitLab test server
+        gitLabApi = baseTestSetup();
+        testProject = getTestProject();
+
+        if (TEST_USERNAME == null || TEST_USERNAME.trim().isEmpty()) {
+            System.err.println("TEST_USER_NAME cannot be empty");
+        }
+    }
+
+    @Before
+    public void beforeMethod() {
+        assumeTrue(gitLabApi != null);
+        assumeTrue(testProject != null);
+    }
+
+    @Test
+    public void testCreateDeployment() throws GitLabApiException {
+
+        assertNotNull(testProject);
+
+        String environment = "environment-" + HelperUtils.getRandomInt(1000);
+        List<Commit> commits = gitLabApi.getCommitsApi().getCommits(testProject);
+
+        assertTrue("Commits list should not be empty.", commits.size() > 0);
+
+        Deployment deployment = gitLabApi.getDeploymentsApi().addDeployment(testProject,
+            environment,
+            commits.get(0).getId(),
+            testProject.getDefaultBranch(),
+            false,
+            DeploymentStatus.RUNNING);
+
+        assertNotNull(deployment);
+        assertEquals(environment, deployment.getEnvironment().getName());
+        assertEquals(commits.get(0).getId(), deployment.getSha());
+        assertEquals(testProject.getDefaultBranch(), deployment.getRef());
+        assertEquals(DeploymentStatus.RUNNING, deployment.getStatus());
+    }
+
+    @Test
+    public void testUpdateDeployment() throws GitLabApiException {
+
+        assertNotNull(testProject);
+
+        String environment = "environment-" + HelperUtils.getRandomInt(1000);
+        List<Commit> commits = gitLabApi.getCommitsApi().getCommits(testProject);
+
+        assertTrue("Commits list should not be empty.", commits.size() > 0);
+
+        Deployment deployment = gitLabApi.getDeploymentsApi().addDeployment(testProject,
+            environment,
+            commits.get(0).getId(),
+            testProject.getDefaultBranch(),
+            false,
+            DeploymentStatus.RUNNING);
+
+        assertNotNull(deployment);
+        assertEquals(environment, deployment.getEnvironment().getName());
+        assertEquals(commits.get(0).getId(), deployment.getSha());
+        assertEquals(testProject.getDefaultBranch(), deployment.getRef());
+        assertEquals(DeploymentStatus.RUNNING, deployment.getStatus());
+
+        Deployment updatedDeployment = gitLabApi.getDeploymentsApi().updateDeployment(testProject, deployment.getId(),
+            DeploymentStatus.SUCCESS);
+
+        assertNotNull(updatedDeployment);
+        assertEquals(environment, updatedDeployment.getEnvironment().getName());
+        assertEquals(commits.get(0).getId(), updatedDeployment.getSha());
+        assertEquals(testProject.getDefaultBranch(), updatedDeployment.getRef());
+        assertEquals(DeploymentStatus.SUCCESS, updatedDeployment.getStatus());
+    }
+
+    @Test
+    public void testGetDeployment() throws GitLabApiException {
+
+        assertNotNull(testProject);
+
+        String environment = "environment-" + HelperUtils.getRandomInt(1000);
+
+        List<Commit> commits = gitLabApi.getCommitsApi().getCommits(testProject);
+
+        assertTrue("Commits list should not be empty.", commits.size() > 0);
+
+        Deployment deployment = gitLabApi.getDeploymentsApi().addDeployment(testProject,
+            environment,
+            commits.get(0).getId(),
+            testProject.getDefaultBranch(),
+            false,
+            DeploymentStatus.SUCCESS);
+
+        assertNotNull(deployment);
+        assertEquals(environment, deployment.getEnvironment().getName());
+        assertEquals(commits.get(0).getId(), deployment.getSha());
+        assertEquals(testProject.getDefaultBranch(), deployment.getRef());
+        assertEquals(DeploymentStatus.SUCCESS, deployment.getStatus());
+
+        Deployment getDeployment = gitLabApi.getDeploymentsApi().getDeployment(testProject, deployment.getId());
+
+        assertNotNull(getDeployment);
+        assertEquals(environment, getDeployment.getEnvironment().getName());
+        assertEquals(commits.get(0).getId(), getDeployment.getSha());
+        assertEquals(testProject.getDefaultBranch(), getDeployment.getRef());
+        assertEquals(DeploymentStatus.SUCCESS, getDeployment.getStatus());
+        assertEquals(deployment.getCreatedAt(), getDeployment.getCreatedAt());
+
+        Optional<Deployment> optionalDeployment = gitLabApi.getDeploymentsApi().getOptionalDeployment(testProject,
+            getDeployment.getId());
+
+        optionalDeployment.ifPresent(d -> {
+            assertEquals(environment, d.getEnvironment().getName());
+            assertEquals(commits.get(0).getId(), d.getSha());
+            assertEquals(testProject.getDefaultBranch(), d.getRef());
+            assertEquals(DeploymentStatus.SUCCESS, d.getStatus());
+            assertEquals(deployment.getCreatedAt(), d.getCreatedAt());
+        });
+
+        if (!optionalDeployment.isPresent()) {
+            fail("A deployment should be present.");
+        }
+    }
+
+    @Test
+    public void testGetDeployments() throws GitLabApiException {
+
+        assertNotNull(testProject);
+
+        String environment = "environment-" + HelperUtils.getRandomInt(1000);
+
+        List<Commit> commits = gitLabApi.getCommitsApi().getCommits(testProject);
+
+        assertTrue("Commits list should not be empty.", commits.size() > 0);
+
+        for (int i = 0; i < 20; i++) {
+            gitLabApi.getDeploymentsApi().addDeployment(testProject,
+                environment,
+                commits.get(0).getId(),
+                testProject.getDefaultBranch(),
+                false,
+                DeploymentStatus.SUCCESS);
+        }
+
+        gitLabApi.getDeploymentsApi().addDeployment(testProject,
+            environment + "-other",
+            commits.get(0).getId(),
+            testProject.getDefaultBranch(),
+            false,
+            DeploymentStatus.SUCCESS);
+
+        Pager<Deployment> pager = gitLabApi.getDeploymentsApi().getProjectDeployments(testProject, 2);
+        while (pager.hasNext()) {
+            pager.next();
+            assertTrue(pager.current().size() == 1 || pager.current().size() == 2);
+        }
+
+        List<Deployment> deployments = gitLabApi.getDeploymentsApi().getProjectDeployments(testProject);
+        int unfilteredeploymentNb = deployments.size();
+        assertTrue(unfilteredeploymentNb >= 10);
+
+        DeploymentFilter deploymentFilter = new DeploymentFilter();
+        deploymentFilter.setEnvironment(environment);
+
+        Pager<Deployment> filteredPager = gitLabApi.getDeploymentsApi().getProjectDeployments(testProject, deploymentFilter);
+        while (filteredPager.hasNext()) {
+            filteredPager.next();
+            assertTrue(filteredPager.current().size() > 1 && filteredPager.current().size() < unfilteredeploymentNb);
+        }
+
+        deploymentFilter.setEnvironment("none");
+
+        filteredPager = gitLabApi.getDeploymentsApi().getProjectDeployments(testProject, deploymentFilter);
+        if (filteredPager.hasNext()) {
+            filteredPager.next();
+            assertTrue("Should be no deployments for environment `none`", filteredPager.current().size() == 0);
+        }
+
+        Stream<Deployment> projectDeploymentsStream = gitLabApi.getDeploymentsApi().getProjectDeploymentsStream(testProject);
+        assertTrue(projectDeploymentsStream.count() >= 10);
+
+        projectDeploymentsStream = gitLabApi.getDeploymentsApi().getProjectDeploymentsStream(testProject, deploymentFilter);
+        assertEquals(0L, projectDeploymentsStream.count());
+
+    }
+
+}

src/test/java/org/gitlab4j/api/TestMarkdownApi.java

+package org.gitlab4j.api;
+
+import org.gitlab4j.api.models.Markdown;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+import static org.junit.Assert.*;
+import static org.junit.Assume.assumeTrue;
+
+@Category(IntegrationTest.class)
+public class TestMarkdownApi extends AbstractIntegrationTest {
+
+    private static final String EXPECTED_HTML_FOR_SPECIAL = "<p data-sourcepos=\"1:1-1:104\" dir=\"auto\">Hello world! <gl-emoji title=\"party popper\" data-name=\"tada\" data-unicode-version=\"6.0\">🎉</gl-emoji> <code>xml &lt;profiles&gt; &lt;version&gt;${maven-surefire-plugin.version}&lt;/version&gt; &lt;/profiles&gt;</code></p>";
+    public static final String SPECIAL_CHAR_EXAMPLE = "Hello world! :tada: ```xml <profiles> <version>${maven-surefire-plugin.version}</version> </profiles>```";
+
+    public static final String NORMAL_HTML_EXAMPLE = "<h1 data-sourcepos=\"1:1-1:4\" dir=\"auto\">\n" +
+            "<a id=\"user-content-h1\" class=\"anchor\" href=\"#h1\" aria-hidden=\"true\"></a>H1</h1>\n" +
+            "<h2 data-sourcepos=\"2:2-2:6\" dir=\"auto\">\n" +
+            "<a id=\"user-content-h2\" class=\"anchor\" href=\"#h2\" aria-hidden=\"true\"></a>H2</h2>\n" +
+            "<h3 data-sourcepos=\"3:2-3:7\" dir=\"auto\">\n" +
+            "<a id=\"user-content-h3\" class=\"anchor\" href=\"#h3\" aria-hidden=\"true\"></a>H3</h3>\n" +
+            "<h4 data-sourcepos=\"4:2-4:8\" dir=\"auto\">\n" +
+            "<a id=\"user-content-h4\" class=\"anchor\" href=\"#h4\" aria-hidden=\"true\"></a>H4</h4>\n" +
+            "<h5 data-sourcepos=\"5:2-5:9\" dir=\"auto\">\n" +
+            "<a id=\"user-content-h5\" class=\"anchor\" href=\"#h5\" aria-hidden=\"true\"></a>H5</h5>\n" +
+            "<h6 data-sourcepos=\"6:2-6:10\" dir=\"auto\">\n" +
+            "<a id=\"user-content-h6\" class=\"anchor\" href=\"#h6\" aria-hidden=\"true\"></a>H6</h6>";
+
+    private static GitLabApi gitLabApi;
+
+    @BeforeClass
+    public static void setUp() throws Exception {
+        gitLabApi = baseTestSetup();
+    }
+
+    @Before
+    public void beforeMethod() {
+        assumeTrue(gitLabApi != null);
+    }
+
+    @Test
+    public void testMarkdownWithSpecialCharacters() throws GitLabApiException {
+        Markdown markdown = gitLabApi.getMarkdownApi().getMarkdown(SPECIAL_CHAR_EXAMPLE);
+
+        assertEquals(EXPECTED_HTML_FOR_SPECIAL, markdown.getHtml());
+    }
+
+    @Test
+    public void testMarkdownWithNormalText() throws GitLabApiException {
+        Markdown markdown = gitLabApi.getMarkdownApi().getMarkdown("# H1 \n ## H2 \n ### H3 \n #### H4 \n ##### H5 \n ###### H6");
+
+        assertEquals(NORMAL_HTML_EXAMPLE, markdown.getHtml());
+    }
+}
\ No newline at end of file

src/test/java/org/gitlab4j/api/TestProjectApi.java

@@ -235,7 +235,10 @@ public class TestProjectApi extends AbstractIntegrationTest {
                 .withWikiEnabled(true)
                 .withSnippetsEnabled(true)
                 .withVisibility(Visibility.PUBLIC)
-                .withTagList(Arrays.asList("tag1", "tag2"));
+                .withTagList(Arrays.asList("tag1", "tag2"))
+                .withMergeMethod(Project.MergeMethod.MERGE)
+                .withSuggestionCommitMessage("SuggestionCommitMessageOriginal")
+                .withRemoveSourceBranchAfterMerge(false);
 
         Project newProject = gitLabApi.getProjectApi().createProject(project);
         assertNotNull(newProject);
@@ -247,6 +250,9 @@ public class TestProjectApi extends AbstractIntegrationTest {
         assertEquals(project.getSnippetsEnabled(), newProject.getSnippetsEnabled());
         assertEquals(project.getTagList(), newProject.getTagList());
         assertTrue(Visibility.PUBLIC == newProject.getVisibility() || Boolean.TRUE == newProject.getPublic());
+        assertEquals(Project.MergeMethod.MERGE, newProject.getMergeMethod());
+        assertEquals(project.getSuggestionCommitMessage(), newProject.getSuggestionCommitMessage());
+        assertEquals(project.getRemoveSourceBranchAfterMerge(), newProject.getRemoveSourceBranchAfterMerge());
 
         project = new Project()
             .withId(newProject.getId())
@@ -256,7 +262,10 @@ public class TestProjectApi extends AbstractIntegrationTest {
             .withMergeRequestsEnabled(false)
             .withWikiEnabled(false)
             .withSnippetsEnabled(false)
-            .withVisibility(Visibility.PRIVATE);
+            .withVisibility(Visibility.PRIVATE)
+            .withMergeMethod(Project.MergeMethod.REBASE_MERGE)
+            .withSuggestionCommitMessage("SuggestionCommitMessageUpdated")
+            .withRemoveSourceBranchAfterMerge(true);
 
         Project updatedProject = gitLabApi.getProjectApi().updateProject(project);
         assertNotNull(updatedProject);
@@ -267,6 +276,9 @@ public class TestProjectApi extends AbstractIntegrationTest {
         assertEquals(project.getWikiEnabled(), updatedProject.getWikiEnabled());
         assertEquals(project.getSnippetsEnabled(), updatedProject.getSnippetsEnabled());
         assertTrue(Visibility.PRIVATE == updatedProject.getVisibility() || Boolean.FALSE == updatedProject.getPublic());
+        assertEquals(Project.MergeMethod.REBASE_MERGE, updatedProject.getMergeMethod());
+        assertEquals(project.getSuggestionCommitMessage(), updatedProject.getSuggestionCommitMessage());
+        assertEquals(true, updatedProject.getRemoveSourceBranchAfterMerge());
     }
 
     @Test

src/test/java/org/gitlab4j/api/TestSystemHooksApi.java

@@ -59,17 +59,53 @@ public class TestSystemHooksApi extends AbstractIntegrationTest {
     public void testAddSystemHook() throws GitLabApiException {
 
         SystemHook hook = gitLabApi.getSystemHooksApi().addSystemHook(TEST_HOOK_URL, TEST_SECRET_TOKEN, true, false, true);
-        assertNotNull(hook);
-        assertEquals(TEST_HOOK_URL, hook.getUrl());
-        assertTrue(hook.getPushEvents());
-        assertFalse(hook.getTagPushEvents());
-        assertTrue(hook.getEnableSslVerification());
-        
-        gitLabApi.getSystemHooksApi().deleteSystemHook(hook);
+        try {
+            assertNotNull(hook);
+            assertEquals(TEST_HOOK_URL, hook.getUrl());
+            assertTrue(hook.getPushEvents());
+            assertFalse(hook.getTagPushEvents());
+            assertFalse(hook.getMergeRequestsEvents());
+
+            // TODO: Attribute "repository_update_events" is not being honored by GitLab API as per issue
+            //       https://gitlab.com/gitlab-org/gitlab/-/issues/335129
+            //       Revisit and update this test if/when the GitLab API/documentation is fixed
+            assertTrue(hook.getRepositoryUpdateEvents());
+
+            assertTrue(hook.getEnableSslVerification());
+        } finally {
+            // Ensure we remove the hook we added even if we had failures
+            gitLabApi.getSystemHooksApi().deleteSystemHook(hook);
+        }
+
+        hook.withPushEvents(false)
+            .withTagPushEvents(true)
+            .withMergeRequestsEvents(true)
+            .withRepositoryUpdateEvents(false)
+            .withEnableSslVerification(false);
+
+        SystemHook updatedHook = gitLabApi.getSystemHooksApi().addSystemHook(TEST_HOOK_URL, TEST_SECRET_TOKEN, hook);
+        try {
+            assertNotNull(updatedHook);
+            assertEquals(TEST_HOOK_URL, updatedHook.getUrl());
+            assertFalse(updatedHook.getPushEvents());
+            assertTrue(updatedHook.getTagPushEvents());
+            assertTrue(updatedHook.getMergeRequestsEvents());
+
+            // TODO: Attribute "repository_update_events" is not being honored by GitLab API as per issue
+            //       https://gitlab.com/gitlab-org/gitlab/-/issues/335129
+            //       Revisit and update this test if/when the GitLab API/documentation is fixed
+            assertTrue(updatedHook.getRepositoryUpdateEvents());
+
+            assertFalse(updatedHook.getEnableSslVerification());
+        } finally {
+            // Ensure we remove the hook we added even if we had failures
+            gitLabApi.getSystemHooksApi().deleteSystemHook(updatedHook);
+        }
+
     }
 
     @Test
-    public void testGerSystemHooks() throws GitLabApiException {
+    public void testGetSystemHooks() throws GitLabApiException {
 
         SystemHook hook = gitLabApi.getSystemHooksApi().addSystemHook(TEST_HOOK_URL, TEST_SECRET_TOKEN, true, false, true);
         assertNotNull(hook);
@@ -77,7 +113,7 @@ public class TestSystemHooksApi extends AbstractIntegrationTest {
         List<SystemHook> hooks = gitLabApi.getSystemHooksApi().getSystemHooks();
         assertNotNull(hooks);
         assertFalse(hooks.isEmpty());
-        
+
         gitLabApi.getSystemHooksApi().deleteSystemHook(hook);
     }
 }

src/test/java/org/gitlab4j/api/TestUserApi.java

@@ -18,9 +18,13 @@ import java.util.Optional;
 
 import javax.ws.rs.core.Response;
 
+import org.gitlab4j.api.models.AccessLevel;
 import org.gitlab4j.api.models.Email;
+import org.gitlab4j.api.models.GpgKey;
 import org.gitlab4j.api.models.ImpersonationToken;
 import org.gitlab4j.api.models.ImpersonationToken.Scope;
+import org.gitlab4j.api.models.Membership;
+import org.gitlab4j.api.models.MembershipSourceType;
 import org.gitlab4j.api.models.SshKey;
 import org.gitlab4j.api.models.User;
 import org.gitlab4j.api.models.Version;
@@ -57,7 +61,7 @@ public class TestUserApi extends AbstractIntegrationTest {
     private static final String TEST_SUDO_AS_USERNAME = HelperUtils.getProperty(SUDO_AS_USERNAME_KEY);
 
     private static final String TEST_IMPERSONATION_TOKEN_NAME = "token1";
-    private static final String TEST_SSH_KEY = 
+    private static final String TEST_SSH_KEY =
 	"ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC3rWzl/oPAD+Em2iGTmR81HcYZsopvnKp7jelI4XS91fT1NjCRrGsxf5Mw/" +
         "KnmtBjhk+kQjkhIrnsBDcs6DZWtNcHJtyWJZrYsfxMTqWCaQv+OTRwVboqS2pmPcbK3gizUd5GCLFTKbg4OMpdywTwi6NAPwQ" +
 	"rtn3xwiVnGGCfBSyRFppcYP81otALctrlAW57V5+bQwFIJteJ+NWe1UmPxrqQ0N/a+dEEoJHzwX8RtVSkULafrRw8avn6Zp2x" +
@@ -65,6 +69,58 @@ public class TestUserApi extends AbstractIntegrationTest {
 
     private static final String TEST_USER_EMAIL = "test-user-email123@gitlab4j.org";
 
+    // Key for fake@fake.com - set to never expire
+    private static final String TEST_GPG_KEY = "-----BEGIN PGP PUBLIC KEY BLOCK-----\n\n" +
+            "mQINBGBHltIBEADW8zSGAs/XEkwWI36xOusuOqSINhTDVuqq3n50Oazb+a9Ai/MM\n" +
+            "8GTm900ZZghGBVUXGm8PkWuSmabcpbDbjYmJx8aIY71UipXxXrfBzr8S2yOx7IjU\n" +
+            "m6AEw0HwNUF6ayBwsklUFFWMyCeCVSCeZNldFwKRQApP6YOlTlwmZFESv32J6AHz\n" +
+            "goeEsIcoea484nVJKOl7unneb8TyuF6kmViyZtiDkjeiH5vNy8XjSWH9xl5tcBxy\n" +
+            "70NxkZt9EKnMq8izy51OBdzA+oWByGIGRjRPrW+5niMCGltV0w12M0uMDa2pJU2B\n" +
+            "Z0U7uL/Lj3srMnD54OjbjK++wtYbshhGKXhAzshk9RgZq5fEN7Jjn1CTvue5EcHz\n" +
+            "D27RD4yy35MledJ0hrvcTVVxvFmTg3TfDFdQBVLHjRATdXo7xT1Wg35M3z3aVSRt\n" +
+            "PoynOxGNSotKUGfW5bhCB9XjUNpNY7+IphLS4LuQ3vZdEs9MTTWagoOoDx5w2PRS\n" +
+            "7VNccRsqgIbNkpPjy78wN9m1QV97ytFs57eE+FfNDkKYeeCQDeHbeBlOmoEP/vSc\n" +
+            "plOb6K3mdJgs0d5klXTOrFRVCYHHQ84p1YyQDKZO2Qd6JtHo5FNeqvgj5JwnBdfH\n" +
+            "NGUdnaSn6hQTd8UB0AfwB+CC7cJq/fhbgcNvfK0ErHd24tsCif8vP9AG4QARAQAB\n" +
+            "tBtGYWtlIFBlcnNvbiA8ZmFrZUBmYWtlLmNvbT6JAk4EEwEIADgWIQSE5/Jy7XYO\n" +
+            "8riBcF/RhpwhMYJMpwUCYEeW0gIbAwULCQgHAgYVCgkICwIEFgIDAQIeAQIXgAAK\n" +
+            "CRDRhpwhMYJMp+ESD/99LNCF1bqg/jhQOC4UIdwzCCVkUP8imrL6NnBUso+FAwH6\n" +
+            "AT+Pbg8JLpM0lfcjzD5PV+ekLtWTZZVsyObfdRo7GrtBt/wcLKfJU5uQmrJfRClN\n" +
+            "mdiHbh8LyVwfhLp20JRqV6NiEWSdWwNBq8zMZGgZ6HONC7JPGokak0MKpU2Woyc3\n" +
+            "BlAU+998mdoDPKWT8XEr8cnHFFuUpZb4oWhqNV36mFrkdBZovEbnfefA+JvcxwEs\n" +
+            "khAeaNLmpZWZ95YSimJuL4sKUjPCXlkHs9nayTFeDdNcZPAuZwfBCLpdCSj4ErYV\n" +
+            "MyMHs/8J7CibulJB/o8qpp07oa3Qlcd62XNpqDOEIxiWHefnaYgkyIHtmzhXH4Fa\n" +
+            "O7Ir3zGcwARXpQfobRUmtFdzeJT3zVVdUWjkKr5rgwYZZraADXGvOo8xJ5cvdrzq\n" +
+            "4/yvOaNNoIA4KkuZcXbnqsh31pT77PxsqK60+TpLzw/jyzTqmVTEG+6SUobW7o6D\n" +
+            "qrpqR2RPH0GtyzKHuGKSCJClDmiLF+XSyjScGUAlQ9hcFquI6F1Vddy88yURaESK\n" +
+            "qy2agvhSkgpRxeuglytl6ZbWp/AIXrkh3F6qJozMNMFzEokapRYsQe+QdXCDSGDQ\n" +
+            "DNvXXfIvxrFv+vQLy4jjM+DwJfrw0eN2XZ+U3E9sP0uloiVgU1zg1wc2tyPv77kC\n" +
+            "DQRgR5bSARAAwumSlVvzb3JORu2ezPsCh8C+VJe2nPo8m+vR1Dni58UB3xnixZnF\n" +
+            "lPaEprnIO5TSDwELJJN3oNM+AVAPjUJYHotKny5iBSFPIbHYYHs/mGRqo4jHa4b6\n" +
+            "riNRWJ1xoYdvzH7PKAcV36tl27Y4SuQVMYmnaSXbDkGOqd9cenqVHikhj9+SJxNr\n" +
+            "yIHrw/SNbNbRl3cMVfke2vgRp9Eso5Ivpl6tjNoohAwDp3L6MGbHliEYQgk8pjzq\n" +
+            "bIR4lakKNVdRQoW/ZaQM2GkDlbCIEuY/7Rr4ZA1L0tsALY+bnv+9SMtA1OnMvNQ7\n" +
+            "7Pn2uTSHeIbSVxsRk9aWmK63l20OEcB/YPmTSeNvq0JVzJ2fLG2ZL6NUHBBF2DB4\n" +
+            "x66FA8mu9cK3Y9Jnc/3KWdzGA74R4HSIcuDPGkZmPtDMXSgXArRuD0s71QgH5E3U\n" +
+            "9/QJ8g4s9Mjb/8aBhbg+7lm8HzN3XANmbR+y/s71Askw/ewlbhfmwxK+/XI3xDr0\n" +
+            "1jkf42cmoLq4/Y292mQjFkcq6cCFIxDOXM89Qopbtm6PnaQsKyz0GoiyHsP846yS\n" +
+            "RdiHTVHrUdiLl+6TIK90cm8CzNoiF+UGvdD4HObWbySh8O8n1nno+lX9EwSoq20o\n" +
+            "0WobXesDjNIrzJHow0WGGbx5gTxlZq0WwmgXgwYM0PbqlfjxFjct+98AEQEAAYkC\n" +
+            "NgQYAQgAIBYhBITn8nLtdg7yuIFwX9GGnCExgkynBQJgR5bSAhsMAAoJENGGnCEx\n" +
+            "gkynbOkQAI+N/wFxOTbewuTiy0P11saqqYr7Jwc7NLhqOVZ1tHKaTB6ZDbIrlWjN\n" +
+            "u2tFk7PqsA4/zI6KO9JoKiQYbopZ+xjd1nCJUjkUKI/wi4rl0t7ELQKhlSlUC11f\n" +
+            "Nz0C6Q+9cwRQCCT4sX/ZkzVQbGWx9fkAYVHzezDqh43xorXJ2ix5y63pr1NGuUgx\n" +
+            "EujMlUbXFzXpUrCmdUVWujlp4gSEfd6tLW0WMw0tYJe6UY7xx4EmWsT+kAGj7QLH\n" +
+            "L06yFigDQ0eUkGQ1T7Z0AjG4EXGETbX6lSLwzIBnmaZXQxdx4LiRy9TcaNtcowH4\n" +
+            "U2yxCoG0o0kS7sS/rI77TV6WZ46DPCJmlNJ+MP8lt0j/nsDA3AECB1AA+8SNepbA\n" +
+            "LSZY7MJmh4nsqJ+iy/XMosipluZx2u6ZwlXAHxAzHhs7FBsvdMtq/gLNAlZzVyeH\n" +
+            "UqzRaMJps7xIbap5d5jZT5jaZwFeGi+63YVRx3Jm6dkiBCPFffLyWdrzkFTZdWqZ\n" +
+            "PkiRbJ64wYPIWQgAN/RhmCcRBhxJE8f7kgo/nBkZ5dwmfXgnXpheEaaCSzvJ4nMh\n" +
+            "TUdg6ZLna12QndjI5gy5aenrr5H/HmDKKSNkuWZv0+NS4GhwnL8NFs+MRk6znpLN\n" +
+            "aEjPdfYxINCMz+uotKJV9NieDWIbEJLlfZUf2hJwuwwjQGAyVf7b\n" +
+            "=ryCD\n" +
+            "-----END PGP PUBLIC KEY BLOCK-----";
+
     private static final String TEST_EXTERNAL_USERNAME = HelperUtils.getProperty(EXTERNAL_USERNAME_KEY);
     private static final String TEST_EXTERNAL_PROVIDER = HelperUtils.getProperty(EXTERNAL_PROVIDER_KEY);
     private static final String TEST_EXTERNAL_UID = HelperUtils.getProperty(EXTERNAL_UID_KEY);
@@ -150,7 +206,7 @@ public class TestUserApi extends AbstractIntegrationTest {
         assertNotNull(version.getVersion());
         assertNotNull(version.getRevision());
     }
-    
+
     @Test
     public void testGetCurrentUser() throws GitLabApiException {
         User currentUser = gitLabApi.getUserApi().getCurrentUser();
@@ -268,7 +324,7 @@ public class TestUserApi extends AbstractIntegrationTest {
 
         User user = gitLabApi.getUserApi().getCurrentUser();
 
-        // NOTE: READ_REGISTRY scope is left out because the GitLab server docker instance does not have the 
+        // NOTE: READ_REGISTRY scope is left out because the GitLab server docker instance does not have the
         // registry configured and the test would thus fail.
         Scope[] scopes = {Scope.API, Scope.READ_USER, Scope.READ_REPOSITORY, Scope.WRITE_REPOSITORY, Scope.SUDO};
         Date expiresAt = ISO8601.toDate("2018-01-01T00:00:00Z");
@@ -440,11 +496,79 @@ public class TestUserApi extends AbstractIntegrationTest {
         assertTrue(emails.size() == currentSize + 1);
         Email found = emails.stream().filter(e -> e.getEmail().equals(TEST_USER_EMAIL)).findAny().orElse(null);
         assertNotNull(found);
- 
+
         gitLabApi.getUserApi().deleteEmail(currentUser, email.getId());
         emails = gitLabApi.getUserApi().getEmails(currentUser);
         assertEquals(currentSize, emails.size());
         found = emails.stream().filter(e -> e.getEmail().equals(TEST_USER_EMAIL)).findAny().orElse(null);
         assertNull(found);
     }
+
+    @Test
+    public void testGpgKeys() throws GitLabApiException {
+        User currentUser = gitLabApi.getUserApi().getCurrentUser();
+        assertNotNull(currentUser);
+        List<GpgKey> keys = gitLabApi.getUserApi().listGpgKeys(currentUser.getId());
+        assertNotNull(keys);
+        int currentSize = keys.size();
+
+        GpgKey key = gitLabApi.getUserApi().addGpgKey(currentUser.getId(), TEST_GPG_KEY);
+        keys = gitLabApi.getUserApi().listGpgKeys(currentUser.getId());
+        assertTrue(keys.size() == currentSize + 1);
+        GpgKey found = keys.stream().filter(e -> e.getKey().equals(TEST_GPG_KEY)).findAny().orElse(null);
+        assertNotNull(found);
+
+        gitLabApi.getUserApi().deleteGpgKey(currentUser.getId(), key.getId());
+        keys = gitLabApi.getUserApi().listGpgKeys(currentUser.getId());
+        assertEquals(currentSize, keys.size());
+        found = keys.stream().filter(e -> e.getKey().equals(TEST_GPG_KEY)).findAny().orElse(null);
+        assertNull(found);
+    }
+
+    @Test
+    public void testGpgKeysCurrentUser() throws GitLabApiException {
+        List<GpgKey> keys = gitLabApi.getUserApi().listGpgKeys();
+        assertNotNull(keys);
+        int currentSize = keys.size();
+
+        GpgKey key = gitLabApi.getUserApi().addGpgKey(TEST_GPG_KEY);
+        keys = gitLabApi.getUserApi().listGpgKeys();
+        assertTrue(keys.size() == currentSize + 1);
+        GpgKey found = keys.stream().filter(e -> e.getKey().equals(TEST_GPG_KEY)).findAny().orElse(null);
+        assertNotNull(found);
+
+        gitLabApi.getUserApi().deleteGpgKey(key.getId());
+        keys = gitLabApi.getUserApi().listGpgKeys();
+        assertEquals(currentSize, keys.size());
+        found = keys.stream().filter(e -> e.getKey().equals(TEST_GPG_KEY)).findAny().orElse(null);
+        assertNull(found);
+    }
+
+    public void testGetMemberships() throws GitLabApiException {
+        User currentUser = gitLabApi.getUserApi().getCurrentUser();
+        assertNotNull(currentUser);
+        List<Membership> memberships = gitLabApi.getUserApi().getMemberships(currentUser.getId());
+        assertNotNull(memberships);
+        assertEquals(3, memberships.size());
+
+        Membership membership1 = memberships.get(0);
+        assertMembershipEquals(membership1, 1, "test-project", MembershipSourceType.PROJECT, AccessLevel.MAINTAINER);
+
+        Membership membership2 = memberships.get(1);
+        assertMembershipEquals(membership2, 4, "Test Group", MembershipSourceType.NAMESPACE, AccessLevel.OWNER);
+
+        Membership membership3 = memberships.get(2);
+        assertMembershipEquals(membership3, 5, "subgroup", MembershipSourceType.NAMESPACE, AccessLevel.OWNER);
+    }
+
+    private void assertMembershipEquals(Membership actualMembership,
+                                        int expectedSourceId,
+                                        String expectedSourceName,
+                                        MembershipSourceType expectedSourceType,
+                                        AccessLevel expectedAccessLevel) {
+        assertEquals(expectedSourceId, actualMembership.getSourceId().intValue());
+        assertEquals(expectedSourceName, actualMembership.getSourceName());
+        assertEquals(expectedSourceType, actualMembership.getSourceType());
+        assertEquals(expectedAccessLevel, actualMembership.getAccessLevel());
+    }
 }

src/test/resources/org/gitlab4j/api/branch.json

@@ -2,8 +2,11 @@
   "name": "master",
   "merged": false,
   "protected": true,
+  "default": true,
   "developers_can_push": false,
   "developers_can_merge": false,
+  "can_push": true,
+  "web_url": "http://gitlab.example.com/my-group/my-project/-/tree/master",
   "commit": {
     "author_email": "john@example.com",
     "author_name": "John Smith",
@@ -12,6 +15,8 @@
     "committer_email": "john@example.com",
     "committer_name": "John Smith",
     "id": "7b5c3cc8be40ee161ae89a06bba6229da1032a0c",
+    "short_id": "7b5c3cc",
+    "title": "add projects API",
     "message": "add projects API",
     "parent_ids": [
       "4ad91d3c1144c406e50c7b33bae684bd6837faf8"

src/test/resources/org/gitlab4j/api/hook.json

@@ -6,6 +6,8 @@
   "push_events_branch_filter": "",
   "issues_events": true,
   "confidential_issues_events": true,
+  "deployment_events": true,
+  "releases_events": true,
   "merge_requests_events": true,
   "tag_push_events": true,
   "note_events": true,
@@ -14,4 +16,4 @@
   "wiki_page_events": true,
   "enable_ssl_verification": true,
   "created_at": "2012-10-12T17:04:47Z"
-}
\ No newline at end of file
+}