alfresco-community-repo/source/test-java/org/alfresco/rest/api/tests/NodeApiTest.java

/*
 * Copyright (C) 2005-2016 Alfresco Software Limited.
 *
 * This file is part of Alfresco
 *
 * Alfresco is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Alfresco is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
 */
package org.alfresco.rest.api.tests;

import static org.alfresco.rest.api.tests.util.RestApiUtil.parsePaging;
import static org.alfresco.rest.api.tests.util.RestApiUtil.toJsonAsStringNonNull;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;

import org.alfresco.model.ContentModel;
import org.alfresco.model.ForumModel;
import org.alfresco.repo.content.ContentLimitProvider.SimpleFixedLimitProvider;
import org.alfresco.repo.content.MimetypeMap;
import org.alfresco.repo.node.archive.NodeArchiveService;
import org.alfresco.repo.security.authentication.AuthenticationUtil;
import org.alfresco.repo.transaction.RetryingTransactionHelper.RetryingTransactionCallback;
import org.alfresco.rest.api.Nodes;
import org.alfresco.rest.api.model.NodeTarget;
import org.alfresco.rest.api.nodes.NodesEntityResource;
import org.alfresco.rest.api.tests.RepoService.TestNetwork;
import org.alfresco.rest.api.tests.RepoService.TestPerson;
import org.alfresco.rest.api.tests.RepoService.TestSite;
import org.alfresco.rest.api.tests.client.HttpResponse;
import org.alfresco.rest.api.tests.client.PublicApiClient;
import org.alfresco.rest.api.tests.client.PublicApiClient.ExpectedPaging;
import org.alfresco.rest.api.tests.client.PublicApiClient.Paging;
import org.alfresco.rest.api.tests.client.PublicApiHttpClient.BinaryPayload;
import org.alfresco.rest.api.tests.client.RequestContext;
import org.alfresco.rest.api.tests.client.data.ContentInfo;
import org.alfresco.rest.api.tests.client.data.Document;
import org.alfresco.rest.api.tests.client.data.Folder;
import org.alfresco.rest.api.tests.client.data.Node;
import org.alfresco.rest.api.tests.client.data.PathInfo;
import org.alfresco.rest.api.tests.client.data.PathInfo.ElementInfo;
import org.alfresco.rest.api.tests.client.data.SiteRole;
import org.alfresco.rest.api.tests.client.data.UserInfo;
import org.alfresco.rest.api.tests.util.JacksonUtil;
import org.alfresco.rest.api.tests.util.MultiPartBuilder;
import org.alfresco.rest.api.tests.util.MultiPartBuilder.FileData;
import org.alfresco.rest.api.tests.util.MultiPartBuilder.MultiPartRequest;
import org.alfresco.rest.api.tests.util.RestApiUtil;
import org.alfresco.rest.framework.jacksonextensions.JacksonHelper;
import org.alfresco.service.cmr.repository.NodeRef;
import org.alfresco.service.cmr.repository.NodeService;
import org.alfresco.service.cmr.repository.StoreRef;
import org.alfresco.service.cmr.security.MutableAuthenticationService;
import org.alfresco.service.cmr.security.PermissionService;
import org.alfresco.service.cmr.security.PersonService;
import org.alfresco.service.cmr.site.SiteVisibility;
import org.alfresco.util.TempFileProvider;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.Serializable;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.UUID;

/**
 * API tests for:
 * <ul>
 * <li> {@literal <host>:<port>/alfresco/api/<networkId>/public/alfresco/versions/1/nodes/<nodeId>} </li>
 * <li> {@literal <host>:<port>/alfresco/api/<networkId>/public/alfresco/versions/1/nodes/<nodeId>/children} </li>
 * </ul>
 *
 * TODO
 * - improve test 'fwk' to enable api tests to be run against remote repo (rather than embedded jetty)
 * - requires replacement of non-remote calls (eg. repoService, siteService, permissionService) with calls to remote (preferably public) apis
 *
 * @author Jamal Kaabi-Mofrad
 * @author janv
 */
public class NodeApiTest extends AbstractBaseApiTest
{
    private static final String URL_NODES = "nodes/";

    private static final String PROP_OWNER = "cm:owner";

    /**
     * User one from network one
     */
    private TestPerson userOneN1;
    /**
     * User two from network one
     */
    private TestPerson userTwoN1;
    /**
     * Private site of user one from network one
     */
    private TestSite userOneN1Site;
    private String user1;
    private String user2;
    private List<String> users = new ArrayList<>();

    protected MutableAuthenticationService authenticationService;
    protected PersonService personService;
    protected JacksonUtil jacksonUtil;
    protected PermissionService permissionService;

    protected NodeArchiveService nodeArchiveService;
    protected NodeService nodeService;


    @Before
    public void setup() throws Exception
    {
        authenticationService = applicationContext.getBean("authenticationService", MutableAuthenticationService.class);
        personService = applicationContext.getBean("personService", PersonService.class);
        jacksonUtil = new JacksonUtil(applicationContext.getBean("jsonHelper", JacksonHelper.class));
        permissionService = applicationContext.getBean("permissionService", PermissionService.class);

        // TODO replace with future V1 REST API for Trashcan
        nodeArchiveService = applicationContext.getBean("nodeArchiveService", NodeArchiveService.class);
        nodeService = applicationContext.getBean("nodeService", NodeService.class);

        user1 = createUser("user1" + System.currentTimeMillis());
        user2 = createUser("user2" + System.currentTimeMillis());
        // We just need to clean the on-premise-users,
        // so the tests for the specific network would work.
        users.add(user1);
        users.add(user2);

        TestNetwork networkOne = getTestFixture().getRandomNetwork();
        userOneN1 = networkOne.createUser();
        userTwoN1 = networkOne.createUser();

        userOneN1Site = createSite(networkOne, userOneN1, SiteVisibility.PRIVATE);
    }

    @After
    public void tearDown() throws Exception
    {
        AuthenticationUtil.setAdminUserAsFullyAuthenticatedUser();
        for (final String user : users)
        {
            transactionHelper.doInTransaction(new RetryingTransactionCallback<Void>()
            {
                @Override
                public Void execute() throws Throwable
                {
                    if (personService.personExists(user))
                    {
                        authenticationService.deleteAuthentication(user);
                        personService.deletePerson(user);
                    }
                    return null;
                }
            });
        }
        users.clear();
        AuthenticationUtil.clearCurrentSecurityContext();
    }

    /**
     * Tests get document library children.
     * <p>GET:</p>
     * {@literal <host>:<port>/alfresco/api/<networkId>/public/alfresco/versions/1/nodes/<nodeId>/children}
     */
    @Test
    public void testListDocLibChildren() throws Exception
    {
        AuthenticationUtil.setFullyAuthenticatedUser(userOneN1.getId());

        NodeRef docLibNodeRef = userOneN1Site.getContainerNodeRef(("documentLibrary"));

        String folder1 = "folder" + System.currentTimeMillis() + "_1";
        repoService.addToDocumentLibrary(userOneN1Site, folder1, ContentModel.TYPE_FOLDER);

        String folder2 = "folder" + System.currentTimeMillis() + "_2";
        repoService.addToDocumentLibrary(userOneN1Site, folder2, ContentModel.TYPE_FOLDER);

        String content1 = "content" + System.currentTimeMillis() + "_1";
        repoService.addToDocumentLibrary(userOneN1Site, content1, ContentModel.TYPE_CONTENT);

        String content2 = "content" + System.currentTimeMillis() + "_2";
        repoService.addToDocumentLibrary(userOneN1Site, content2, ContentModel.TYPE_CONTENT);

        String forum1 = "forum" + System.currentTimeMillis() + "_1";
        repoService.createObjectOfCustomType(docLibNodeRef, forum1, ForumModel.TYPE_TOPIC.toString());

        Paging paging = getPaging(0, 100);
        HttpResponse response = getAll(getChildrenUrl(docLibNodeRef), userOneN1.getId(), paging, 200);
        List<Node> nodes = jacksonUtil.parseEntries(response.getJsonResponse(), Node.class);
        assertEquals(4, nodes.size()); // forum is part of the default ignored types
        // Paging
        ExpectedPaging expectedPaging = RestApiUtil.parsePaging(response.getJsonResponse());
        assertEquals(4, expectedPaging.getCount().intValue());
        assertEquals(0, expectedPaging.getSkipCount().intValue());
        assertEquals(100, expectedPaging.getMaxItems().intValue());
        assertFalse(expectedPaging.getHasMoreItems().booleanValue());

        // Order by folders and modified date first
        Map<String, String> orderBy = Collections.singletonMap("orderBy", "isFolder DESC,modifiedAt DESC");
        response = getAll(getChildrenUrl(docLibNodeRef), userOneN1.getId(), paging, orderBy, 200);
        nodes = jacksonUtil.parseEntries(response.getJsonResponse(), Node.class);
        assertEquals(4, nodes.size());
        assertEquals(folder2, nodes.get(0).getName());
        assertTrue(nodes.get(0).getIsFolder());
        assertFalse(nodes.get(0).getIsFile());
        assertEquals(folder1, nodes.get(1).getName());
        assertTrue(nodes.get(1).getIsFolder());
        assertFalse(nodes.get(1).getIsFile());
        assertEquals(content2, nodes.get(2).getName());
        assertFalse(nodes.get(2).getIsFolder());
        assertTrue(nodes.get(2).getIsFile());
        assertEquals(content1, nodes.get(3).getName());
        assertFalse(nodes.get(3).getIsFolder());
        assertTrue(nodes.get(3).getIsFile());

        // Order by folders last and modified date first
        orderBy = Collections.singletonMap("orderBy", "isFolder ASC,modifiedAt DESC");
        response = getAll(getChildrenUrl(docLibNodeRef), userOneN1.getId(), paging, orderBy, 200);
        nodes = jacksonUtil.parseEntries(response.getJsonResponse(), Node.class);
        assertEquals(4, nodes.size());
        assertEquals(content2, nodes.get(0).getName());
        assertEquals(content1, nodes.get(1).getName());
        assertEquals(folder2, nodes.get(2).getName());
        assertEquals(folder1, nodes.get(3).getName());

        // Order by folders and modified date last
        orderBy = Collections.singletonMap("orderBy", "isFolder,modifiedAt");
        response = getAll(getChildrenUrl(docLibNodeRef), userOneN1.getId(), paging, orderBy, 200);
        nodes = jacksonUtil.parseEntries(response.getJsonResponse(), Node.class);
        assertEquals(4, nodes.size());
        assertEquals(content1, nodes.get(0).getName());
        assertEquals(content2, nodes.get(1).getName());
        assertEquals(folder1, nodes.get(2).getName());
        assertEquals(folder2, nodes.get(3).getName());

        // Order by folders and modified date first
        orderBy = Collections.singletonMap("orderBy", "isFolder DESC,modifiedAt DESC");
        // SkipCount=0,MaxItems=2
        paging = getPaging(0, 2);
        response = getAll(getChildrenUrl(docLibNodeRef), userOneN1.getId(), paging, orderBy, 200);
        nodes = jacksonUtil.parseEntries(response.getJsonResponse(), Node.class);
        assertEquals(2, nodes.size());
        assertEquals(folder2, nodes.get(0).getName());
        assertEquals(folder1, nodes.get(1).getName());
        expectedPaging = RestApiUtil.parsePaging(response.getJsonResponse());
        assertEquals(2, expectedPaging.getCount().intValue());
        assertEquals(0, expectedPaging.getSkipCount().intValue());
        assertEquals(2, expectedPaging.getMaxItems().intValue());
        assertTrue(expectedPaging.getHasMoreItems().booleanValue());

        // SkipCount=2,MaxItems=4
        paging = getPaging(2, 4);
        response = getAll(getChildrenUrl(docLibNodeRef), userOneN1.getId(), paging, orderBy, 200);
        nodes = jacksonUtil.parseEntries(response.getJsonResponse(), Node.class);
        assertEquals(2, nodes.size());
        assertEquals(content2, nodes.get(0).getName());
        assertEquals(content1, nodes.get(1).getName());
        expectedPaging = RestApiUtil.parsePaging(response.getJsonResponse());
        assertEquals(2, expectedPaging.getCount().intValue());
        assertEquals(2, expectedPaging.getSkipCount().intValue());
        assertEquals(4, expectedPaging.getMaxItems().intValue());
        assertFalse(expectedPaging.getHasMoreItems().booleanValue());

        // userTwoN1 tries to access userOneN1's docLib
        AuthenticationUtil.setFullyAuthenticatedUser(userTwoN1.getId());
        paging = getPaging(0, Integer.MAX_VALUE);
        getAll(getChildrenUrl(docLibNodeRef), userTwoN1.getId(), paging, 403);
    }

    /**
     * Tests get user's home children.
     * <p>GET:</p>
     * {@literal <host>:<port>/alfresco/api/-default-/public/alfresco/versions/1/nodes/<nodeId>/children}
     */
    @Test
    public void testListMyFilesChildren() throws Exception
    {
        AuthenticationUtil.setFullyAuthenticatedUser(user1);

        String myNodeId = getMyNodeId(user1);
        NodeRef myFilesNodeRef = new NodeRef(StoreRef.STORE_REF_WORKSPACE_SPACESSTORE, myNodeId);

        String myChildrenUrl = getChildrenUrl(Nodes.PATH_MY);
        String rootChildrenUrl = getChildrenUrl(Nodes.PATH_ROOT);

        Map<String, Object> props = new HashMap<>(1);
        props.put("cm:title", "This is folder 1");
        String folder1 = "folder " + System.currentTimeMillis() + " 1";
        String folder1_Id = createFolder(user1, myNodeId, folder1, props).getId();

        String contentF1 = "content" + System.currentTimeMillis() + " in folder 1";
        String contentF1_Id = repoService.createDocument(new NodeRef(StoreRef.STORE_REF_WORKSPACE_SPACESSTORE, folder1_Id), contentF1, "The quick brown fox jumps over the lazy dog 1.").getId();

        props = new HashMap<>(1);
        props.put("cm:title", "This is folder 2");
        String folder2 = "folder " + System.currentTimeMillis() + " 2";
        String folder2_Id = createFolder(user1, myNodeId, folder2, props).getId();

        String contentF2 = "content" + System.currentTimeMillis() + " in folder 2";
        String contentF2_Id = repoService.createDocument(new NodeRef(StoreRef.STORE_REF_WORKSPACE_SPACESSTORE, folder2_Id), contentF2, "The quick brown fox jumps over the lazy dog 2.").getId();

        String content1 = "content" + System.currentTimeMillis() + " 1";
        NodeRef contentNodeRef = repoService.createDocument(myFilesNodeRef, content1, "The quick brown fox jumps over the lazy dog.");
        repoService.getNodeService().setProperty(contentNodeRef, ContentModel.PROP_OWNER, user1);
        repoService.getNodeService().setProperty(contentNodeRef, ContentModel.PROP_LAST_THUMBNAIL_MODIFICATION_DATA,
                (Serializable) Collections.singletonList("doclib:1444660852296"));

        List<String> folderIds = Arrays.asList(folder1_Id, folder2_Id);
        List<String> contentIds = Arrays.asList(contentNodeRef.getId());


        Paging paging = getPaging(0, Integer.MAX_VALUE);
        HttpResponse response = getAll(myChildrenUrl, user1, paging, 200);
        List<Document> nodes = jacksonUtil.parseEntries(response.getJsonResponse(), Document.class);
        assertEquals(3, nodes.size());

        // Order by folders and modified date first
        Map<String, String> orderBy = Collections.singletonMap("orderBy", "isFolder DESC,modifiedAt DESC");
        response = getAll(myChildrenUrl, user1, paging, orderBy, 200);
        nodes = jacksonUtil.parseEntries(response.getJsonResponse(), Document.class);
        assertEquals(3, nodes.size());
        assertEquals(folder2, nodes.get(0).getName());
        assertEquals(folder1, nodes.get(1).getName());
        Document node = nodes.get(2);
        assertEquals(content1, node.getName());
        assertEquals("cm:content", node.getNodeType());
        assertEquals(contentNodeRef.getId(), node.getId());
        UserInfo createdByUser = node.getCreatedByUser();
        assertEquals(user1, createdByUser.getId());
        assertEquals(user1 + " " + user1, createdByUser.getDisplayName());
        UserInfo modifiedByUser = node.getModifiedByUser();
        assertEquals(user1, modifiedByUser.getId());
        assertEquals(user1 + " " + user1, modifiedByUser.getDisplayName());
        assertEquals(MimetypeMap.MIMETYPE_BINARY, node.getContent().getMimeType());
        assertNotNull(node.getContent().getMimeTypeName());
        assertNotNull(node.getContent().getEncoding());
        assertTrue(node.getContent().getSizeInBytes() > 0);

        // request without select
        Map<String, String> params = new LinkedHashMap<>();
        response = getAll(myChildrenUrl, user1, paging, params, 200);
        nodes = jacksonUtil.parseEntries(response.getJsonResponse(), Document.class);
        for (Node n : nodes)
        {
            assertNull("There shouldn't be a 'properties' object in the response.", n.getProperties());
            assertNull("There shouldn't be a 'isLink' object in the response.", n.getIsLink());
            assertNull("There shouldn't be a 'path' object in the response.", n.getPath());
            assertNull("There shouldn't be a 'aspectNames' object in the response.", n.getAspectNames());
        }

        // request with select - example 1
        params = new LinkedHashMap<>();
        params.put("select", "isLink");
        response = getAll(myChildrenUrl, user1, paging, params, 200);
        nodes = jacksonUtil.parseEntries(response.getJsonResponse(), Document.class);
        for (Node n : nodes)
        {
            assertNotNull("There should be a 'isLink' object in the response.", n.getIsLink());
        }

        // request with select - example 2
        params = new LinkedHashMap<>();
        params.put("select", "aspectNames,properties, path,isLink");
        response = getAll(myChildrenUrl, user1, paging, params, 200);
        nodes = jacksonUtil.parseEntries(response.getJsonResponse(), Document.class);
        for (Node n : nodes)
        {
            assertNotNull("There should be a 'properties' object in the response.", n.getProperties()); // eg. cm:title, see above
            assertNotNull("There should be a 'isLink' object in the response.", n.getIsLink());
            assertNotNull("There should be a 'path' object in the response.", n.getPath());
            assertNotNull("There should be a 'aspectNames' object in the response.", n.getAspectNames());
        }

        // request specific property via select
        params = new LinkedHashMap<>();
        params.put("select", "cm:lastThumbnailModification");
        params.put("orderBy", "isFolder DESC,modifiedAt DESC");
        response = getAll(myChildrenUrl, user1, paging, params, 200);
        nodes = jacksonUtil.parseEntries(response.getJsonResponse(), Document.class);
        assertEquals(3, nodes.size());
        assertNull("There shouldn't be a 'properties' object in the response.", nodes.get(0).getProperties());
        assertNull("There shouldn't be a 'properties' object in the response.", nodes.get(1).getProperties());
        assertNotNull("There should be a 'properties' object in the response.", nodes.get(2).getProperties());
        Set<Entry<String, Object>> propsSet = nodes.get(2).getProperties().entrySet();
        assertEquals(1, propsSet.size());
        Entry<String, Object> entry = propsSet.iterator().next();
        assertEquals("cm:lastThumbnailModification", entry.getKey());
        assertEquals("doclib:1444660852296", ((List<?>) entry.getValue()).get(0));


        // filtering, via where clause - folders only
        params = new LinkedHashMap<>();
        params.put("where", "(isFolder=true)");
        response = getAll(myChildrenUrl, user1, paging, params, 200);
        nodes = jacksonUtil.parseEntries(response.getJsonResponse(), Document.class);
        assertEquals(2, nodes.size());

        assertTrue(nodes.get(0).getIsFolder());
        assertFalse(nodes.get(0).getIsFile());
        assertTrue(folderIds.contains(nodes.get(0).getId()));

        assertTrue(nodes.get(1).getIsFolder());
        assertFalse(nodes.get(1).getIsFile());
        assertTrue(folderIds.contains(nodes.get(1).getId()));

        // filtering, via where clause - content only
        params = new LinkedHashMap<>();
        params.put("where", "(isContent=true)");
        response = getAll(myChildrenUrl, user1, paging, params, 200);
        nodes = jacksonUtil.parseEntries(response.getJsonResponse(), Document.class);
        assertEquals(1, nodes.size());
        assertFalse(nodes.get(0).getIsFolder());
        assertTrue(nodes.get(0).getIsFile());
        assertTrue(contentIds.contains(nodes.get(0).getId()));

        // list children via relativePath

        params = Collections.singletonMap("relativePath", folder1);
        response = getAll(myChildrenUrl, user1, paging, params, 200);
        nodes = jacksonUtil.parseEntries(response.getJsonResponse(), Document.class);
        assertEquals(1, nodes.size());
        assertEquals(contentF1_Id, nodes.get(0).getId());

        params = Collections.singletonMap("relativePath", "User Homes/" + user1 + "/" + folder2);
        response = getAll(rootChildrenUrl, user1, paging, params, 200);
        nodes = jacksonUtil.parseEntries(response.getJsonResponse(), Document.class);
        assertEquals(1, nodes.size());
        assertEquals(contentF2_Id, nodes.get(0).getId());

        // -ve test - Invalid QName (Namespace prefix cm... is not mapped to a namespace URI) for the orderBy parameter.
        params = Collections.singletonMap("orderBy", "isFolder DESC,cm" + System.currentTimeMillis() + ":modified DESC");
        getAll(myChildrenUrl, user1, paging, params, 400);

        paging = getPaging(0, 10);

        // -ve test - list folder children for non-folder node should return 400
        getAll(getChildrenUrl(contentNodeRef), user1, paging, 400);

        // -ve test - list folder children for unknown node should return 404
        getAll(getChildrenUrl(UUID.randomUUID().toString()), user1, paging, 404);

        // -ve test - user2 tries to access user1's home folder
        AuthenticationUtil.setFullyAuthenticatedUser(user2);
        getAll(getChildrenUrl(myFilesNodeRef), user2, paging, 403);

        // -ve test - try to list children using relative path to unknown node
        params = Collections.singletonMap("relativePath", "User Homes/" + user1 + "/unknown");
        getAll(rootChildrenUrl, user1, paging, params, 404);

        // -ve test - try to list children using relative path to node for which user does not have read permission
        params = Collections.singletonMap("relativePath", "User Homes/" + user2);
        getAll(rootChildrenUrl, user1, paging, params, 403);

        // -ve test - try to list children using relative path to node that is of wrong type (ie. not a folder/container)
        params = Collections.singletonMap("relativePath", folder1 + "/" + contentF1);
        getAll(myChildrenUrl, user1, paging, params, 400);

        // -ve test - list folder children for non-folder node with relative path should return 400
        params = Collections.singletonMap("relativePath", "/unknown");
        getAll(getChildrenUrl(contentNodeRef), user1, paging, params, 400);
    }

    /**
     * Tests get node with path information.
     * <p>GET:</p>
     * {@literal <host>:<port>/alfresco/api/<networkId>/public/alfresco/versions/1/nodes/<nodeId>?select=path}
     */
    @Test
    public void testGetPathElements_DocLib() throws Exception
    {
        String userId = userOneN1.getId();

        AuthenticationUtil.setFullyAuthenticatedUser(userId);
        userOneN1Site.inviteToSite(userTwoN1.getEmail(), SiteRole.SiteConsumer);

        NodeRef docLibNodeRef = userOneN1Site.getContainerNodeRef(("documentLibrary"));

        // /Company Home/Sites/RandomSite<timestamp>/documentLibrary/folder<timestamp>_A
        String folderA = "folder" + System.currentTimeMillis() + "_A";
        String folderA_Id = createFolder(userId, docLibNodeRef.getId(), folderA).getId();

        // /Company Home/Sites/RandomSite<timestamp>/documentLibrary/folder<timestamp>_A/folder<timestamp>_B
        String folderB = "folder" + System.currentTimeMillis() + "_B";
        String folderB_Id = createFolder(userId, folderA_Id, folderB).getId();
        NodeRef folderB_Ref = new NodeRef(StoreRef.STORE_REF_WORKSPACE_SPACESSTORE, folderB_Id);

        // /Company Home/Sites/RandomSite<timestamp>/documentLibrary/folder<timestamp>_A/folder<timestamp>_B/folder<timestamp>_C
        String folderC = "folder" + System.currentTimeMillis() + "_C";
        String folderC_Id = createFolder(userId, folderB_Id, folderC).getId();
        NodeRef folderC_Ref = new NodeRef(StoreRef.STORE_REF_WORKSPACE_SPACESSTORE, folderC_Id);

        // /Company Home/Sites/RandomSite<timestamp>/documentLibrary/folder<timestamp>_A/folder<timestamp>_B/folder<timestamp>_C/content<timestamp>
        String content = "content" + System.currentTimeMillis();
        NodeRef contentNodeRef = repoService.createDocument(folderC_Ref, content, "The quick brown fox jumps over the lazy dog.");

        // Revoke folderB inherited permissions
        permissionService.setInheritParentPermissions(folderB_Ref, false);
        // Grant userTwoN1 permission for folderC
        permissionService.setPermission(folderC_Ref, userTwoN1.getId(), PermissionService.CONSUMER, true);

        //...nodes/nodeId?select=path
        Map<String, String> params = Collections.singletonMap("select", "path");
        HttpResponse response = getSingle(NodesEntityResource.class, userOneN1.getId(), contentNodeRef.getId(), params, 200);
        Document node = jacksonUtil.parseEntry(response.getJsonResponse(), Document.class);
        PathInfo path = node.getPath();
        assertNotNull(path);
        assertTrue(path.getIsComplete());
        assertNotNull(path.getName());
        // the path should only include the parents (not the requested node)
        assertFalse(path.getName().endsWith(content));
        assertTrue(path.getName().startsWith("/Company Home"));
        List<ElementInfo> pathElements = path.getElements();
        assertEquals(7, pathElements.size());
        assertEquals("Company Home", pathElements.get(0).getName());
        assertEquals("Sites", pathElements.get(1).getName());
        assertEquals(userOneN1Site.getSiteId(), pathElements.get(2).getName());
        assertEquals("documentLibrary", pathElements.get(3).getName());
        assertEquals(folderA, pathElements.get(4).getName());
        assertEquals(folderB, pathElements.get(5).getName());
        assertEquals(folderC, pathElements.get(6).getName());

        // Try the above tests with userTwoN1 (site consumer)
        AuthenticationUtil.setFullyAuthenticatedUser(userTwoN1.getId());
        response = getSingle(NodesEntityResource.class, userTwoN1.getId(), contentNodeRef.getId(), params, 200);
        node = jacksonUtil.parseEntry(response.getJsonResponse(), Document.class);
        path = node.getPath();
        assertNotNull(path);
        assertFalse("The path is not complete as the user doesn't have permission to access the full path.", path.getIsComplete());
        assertNotNull(path.getName());
        // site consumer (userTwoN1) dose not have access to the folderB
        assertFalse("site consumer (userTwoN1) dose not have access to the folderB", path.getName().contains(folderB));
        assertFalse(path.getName().startsWith("/Company Home"));
        // Go up as far as they can, before getting access denied (i.e. "/folderC")
        assertTrue(path.getName().endsWith(folderC));
        pathElements = path.getElements();
        assertEquals(1, pathElements.size());
        assertEquals(folderC, pathElements.get(0).getName());
    }

    /**
     * Tests get node information.
     * <p>GET:</p>
     * {@literal <host>:<port>/alfresco/api/-default-/public/alfresco/versions/1/nodes/<nodeId>}
     */
    @Test
    public void testGetNodeInfo() throws Exception
    {
        AuthenticationUtil.setFullyAuthenticatedUser(user1);

        HttpResponse response = getSingle(NodesEntityResource.class, user1, Nodes.PATH_ROOT, null, 200);
        Node node = jacksonUtil.parseEntry(response.getJsonResponse(), Node.class);
        NodeRef companyHomeNodeRef = new NodeRef(StoreRef.STORE_REF_WORKSPACE_SPACESSTORE, node.getId());

        response = getSingle(NodesEntityResource.class, user1, Nodes.PATH_MY, null, 200);
        node = jacksonUtil.parseEntry(response.getJsonResponse(), Node.class);
        String myFilesNodeId = node.getId();
        assertNotNull(myFilesNodeId);
        assertEquals(user1, node.getName());
        assertTrue(node.getIsFolder());
        assertFalse(node.getIsFile());

        NodeRef myHomeNodeRef = new NodeRef(StoreRef.STORE_REF_WORKSPACE_SPACESSTORE, myFilesNodeId);
        NodeRef userHomesNodeRef = new NodeRef(StoreRef.STORE_REF_WORKSPACE_SPACESSTORE, node.getParentId());

        // /Company Home/User Homes/user<timestamp>/folder<timestamp>_A
        String folderA = "folder" + System.currentTimeMillis() + "_A";
        String folderA_Id = createFolder(user1, myFilesNodeId, folderA).getId();
        NodeRef folderA_Ref = new NodeRef(StoreRef.STORE_REF_WORKSPACE_SPACESSTORE, folderA_Id);

        // /Company Home/User Homes/user<timestamp>/folder<timestamp>_A/folder<timestamp>_B
        String folderB = "folder" + System.currentTimeMillis() + "_B";
        String folderB_Id = createFolder(user1, folderA_Id, folderB).getId();
        NodeRef folderB_Ref = new NodeRef(StoreRef.STORE_REF_WORKSPACE_SPACESSTORE, folderB_Id);

        // /Company Home/User Homes/user<timestamp>/folder<timestamp>_A/folder<timestamp>_B/content<timestamp>
        String contentName = "content " + System.currentTimeMillis();
        NodeRef contentNodeRef = repoService.createDocument(folderB_Ref, contentName, "The quick brown fox jumps over the lazy dog.");

        // Add property
        String title = "test title";
        repoService.getNodeService().setProperty(contentNodeRef, ContentModel.PROP_TITLE, title);

        // get node info
        response = getSingle(NodesEntityResource.class, user1, contentNodeRef.getId(), null, 200);
        Document documentResp = jacksonUtil.parseEntry(response.getJsonResponse(), Document.class);
        String content_Id = documentResp.getId();

        // Expected result ...
        UserInfo expectedUser = new UserInfo(user1, user1+" "+user1);

        Document d1 = new Document();
        d1.setId(content_Id);
        d1.setParentId(folderB_Id);
        d1.setName(contentName);
        d1.setNodeType("cm:content");
        ContentInfo ci = new ContentInfo();

        // TODO fix me !! (is this an issue with repoService.createDocument ?)
        //ci.setMimeType("text/plain");
        //ci.setMimeTypeName("Plain Text");
        ci.setMimeType("application/octet-stream");
        ci.setMimeTypeName("Binary File (Octet Stream)");

        ci.setSizeInBytes(44L);
        ci.setEncoding("UTF-8");
        d1.setContent(ci);
        d1.setCreatedByUser(expectedUser);
        d1.setModifiedByUser(expectedUser);

        Map<String,Object> props = new HashMap<>();
        props.put("cm:title",title);

        d1.setProperties(props);
        d1.setAspectNames(Arrays.asList("cm:auditable","cm:titled"));

        // Note: Path is not part of the default info
        d1.expected(documentResp);

        // get node info + path
        //...nodes/nodeId?select=path
        Map<String, String> params = Collections.singletonMap("select", "path");
        response = getSingle(NodesEntityResource.class, user1, contentNodeRef.getId(), params, 200);
        documentResp = jacksonUtil.parseEntry(response.getJsonResponse(), Document.class);

        // Expected path ...
        // note: the pathInfo should only include the parents (not the requested node)
        List<ElementInfo> elements = new ArrayList<>(5);
        elements.add(new ElementInfo(companyHomeNodeRef, "Company Home"));
        elements.add(new ElementInfo(userHomesNodeRef, "User Homes"));
        elements.add(new ElementInfo(myHomeNodeRef, user1));
        elements.add(new ElementInfo(folderA_Ref, folderA));
        elements.add(new ElementInfo(folderB_Ref, folderB));
        PathInfo expectedPath = new PathInfo("/Company Home/User Homes/"+user1+"/"+folderA+"/"+folderB, true, elements);
        d1.setPath(expectedPath);

        d1.expected(documentResp);

        // get node info via relativePath

        params = Collections.singletonMap("relativePath", "/"+folderA+"/"+folderB);
        response = getSingle(NodesEntityResource.class, user1, Nodes.PATH_MY, params, 200);
        Folder folderResp = jacksonUtil.parseEntry(response.getJsonResponse(), Folder.class);
        assertEquals(folderB_Id, folderResp.getId());

        params = Collections.singletonMap("relativePath", folderA+"/"+folderB+"/"+contentName);
        response = getSingle(NodesEntityResource.class, user1, Nodes.PATH_MY, params, 200);
        documentResp = jacksonUtil.parseEntry(response.getJsonResponse(), Document.class);
        assertEquals(content_Id, documentResp.getId());

        // test path with utf-8 encoded param (eg. ¢ => )
        String folderC = "folder" + System.currentTimeMillis() + " ¢";
        String folderC_Id = createFolder(user1, folderB_Id, folderC).getId();

        params = Collections.singletonMap("relativePath", "/"+folderA+"/"+folderB+"/"+folderC);
        response = getSingle(NodesEntityResource.class, user1, Nodes.PATH_MY, params, 200);
        folderResp = jacksonUtil.parseEntry(response.getJsonResponse(), Folder.class);
        assertEquals(folderC_Id, folderResp.getId());

        // -ve test - get info for unknown node should return 404
        getSingle(NodesEntityResource.class, user1, UUID.randomUUID().toString(), null, 404);

        // -ve test - user2 tries to get node info about user1's home folder
        AuthenticationUtil.setFullyAuthenticatedUser(user2);
        getSingle(NodesEntityResource.class, user2, myFilesNodeId, null, 403);

        // -ve test - try to get node info using relative path to unknown node
        params = Collections.singletonMap("relativePath", folderA+"/unknown");
        getSingle(NodesEntityResource.class, user1, Nodes.PATH_MY, params, 404);

        // -ve test - try to get node info using relative path to node for which user does not have read permission
        params = Collections.singletonMap("relativePath", "User Homes/"+user2);
        getSingle(NodesEntityResource.class, user1, Nodes.PATH_ROOT, params, 403);

        // -ve test - attempt to get node info for non-folder node with relative path should return 400
        params = Collections.singletonMap("relativePath", "/unknown");
        getSingle(NodesEntityResource.class, user1, content_Id, params, 400);
    }

    /**
     * Tests well-known aliases.
     * <p>GET:</p>
     * <ul>
     * <li> {@literal <host>:<port>/alfresco/api/-default-/public/alfresco/versions/1/nodes/-root-}</li>
     * <li> {@literal <host>:<port>/alfresco/api/-default-/public/alfresco/versions/1/nodes/-my-} </li>
     * <li> {@literal <host>:<port>/alfresco/api/-default-/public/alfresco/versions/1/nodes/-shared-} </li>
     * </ul>
     */
    @Test
    public void testGetNodeWithKnownAlias() throws Exception
    {
        HttpResponse response = getSingle(NodesEntityResource.class, user1, Nodes.PATH_ROOT, null, 200);
        Node node = jacksonUtil.parseEntry(response.getJsonResponse(), Node.class);
        assertEquals("Company Home", node.getName());
        assertNotNull(node.getId());
        assertNull(node.getPath());

        // unknown alias
        getSingle(NodesEntityResource.class, user1, "testSomeUndefinedAlias", null, 404);

        response = getSingle(NodesEntityResource.class, user1, Nodes.PATH_MY, null, 200);
        node = jacksonUtil.parseEntry(response.getJsonResponse(), Node.class);
        String myFilesNodeId = node.getId();
        assertNotNull(myFilesNodeId);
        assertEquals(user1, node.getName());
        assertTrue(node.getIsFolder());
        assertFalse(node.getIsFile());
        assertNull(node.getPath()); // note: path can be optionally "select"'ed - see separate test

        response = getSingle(NodesEntityResource.class, user1, Nodes.PATH_SHARED, null, 200);
        node = jacksonUtil.parseEntry(response.getJsonResponse(), Node.class);
        String sharedFilesNodeId = node.getId();
        assertNotNull(sharedFilesNodeId);
        assertEquals("Shared", node.getName());
        assertTrue(node.getIsFolder());
        assertFalse(node.getIsFile());
        assertNull(node.getPath());

        //Delete user1's home
        AuthenticationUtil.setAdminUserAsFullyAuthenticatedUser();
        repoService.getNodeService().deleteNode(new NodeRef(StoreRef.STORE_REF_WORKSPACE_SPACESSTORE, myFilesNodeId));

        AuthenticationUtil.setFullyAuthenticatedUser(user1);
        getSingle(NodesEntityResource.class, user1, Nodes.PATH_MY, null, 404); // Not found
    }

    /**
     * Tests Multipart upload to user's home (a.k.a My Files).
     * <p>POST:</p>
     * {@literal <host>:<port>/alfresco/api/-default-/public/alfresco/versions/1/nodes/<nodeId>/children}
     */
    @Test
    public void testUploadToMyFiles() throws Exception
    {
        final String fileName = "quick.pdf";
        final File file = getResourceFile(fileName);

        Paging paging = getPaging(0, Integer.MAX_VALUE);
        HttpResponse response = getAll(getChildrenUrl(Nodes.PATH_MY), user1, paging, 200);
        PublicApiClient.ExpectedPaging pagingResult = parsePaging(response.getJsonResponse());
        assertNotNull(paging);
        final int numOfNodes = pagingResult.getCount();

        MultiPartBuilder multiPartBuilder = MultiPartBuilder.create()
                    .setFileData(new FileData(fileName, file, MimetypeMap.MIMETYPE_PDF));
        MultiPartRequest reqBody = multiPartBuilder.build();

        // Try to upload into a non-existent folder
        post(getChildrenUrl(UUID.randomUUID().toString()), user1, reqBody.getBody(), null, reqBody.getContentType(), 404);

        // Upload
        response = post(getChildrenUrl(Nodes.PATH_MY), user1, reqBody.getBody(), null, reqBody.getContentType(), 201);
        Document document = jacksonUtil.parseEntry(response.getJsonResponse(), Document.class);
        // Check the upload response
        assertEquals(fileName, document.getName());
        ContentInfo contentInfo = document.getContent();
        assertNotNull(contentInfo);
        assertEquals(MimetypeMap.MIMETYPE_PDF, contentInfo.getMimeType());
        // Default encoding
        assertEquals("UTF-8", contentInfo.getEncoding());
        // Check there is no path info returned.
        // The path info should only be returned when it is requested via a select statement.
        assertNull(document.getPath());

        // Retrieve the uploaded file
        response = getSingle(NodesEntityResource.class, user1, document.getId(), null, 200);
        document = jacksonUtil.parseEntry(response.getJsonResponse(), Document.class);
        assertEquals(fileName, document.getName());
        contentInfo = document.getContent();
        assertNotNull(contentInfo);
        assertEquals(MimetypeMap.MIMETYPE_PDF, contentInfo.getMimeType());

        // Check 'get children' is confirming the upload
        response = getAll(getChildrenUrl(Nodes.PATH_MY), user1, paging, 200);
        pagingResult = parsePaging(response.getJsonResponse());
        assertNotNull(paging);
        assertEquals(numOfNodes + 1, pagingResult.getCount().intValue());

        // Upload the same file again to check the name conflicts handling
        post(getChildrenUrl(Nodes.PATH_MY), user1, reqBody.getBody(), null, reqBody.getContentType(), 409);

        response = getAll(getChildrenUrl(Nodes.PATH_MY), user1, paging, 200);
        pagingResult = parsePaging(response.getJsonResponse());
        assertNotNull(paging);
        assertEquals("Duplicate file name. The file shouldn't have been uploaded.", numOfNodes + 1, pagingResult.getCount().intValue());

        // Set autoRename=true and upload the same file again
        reqBody = MultiPartBuilder.copy(multiPartBuilder)
                          .setAutoRename(true)
                          .build();

        response = post(getChildrenUrl(Nodes.PATH_MY), user1, reqBody.getBody(), null, reqBody.getContentType(), 201);
        document = jacksonUtil.parseEntry(response.getJsonResponse(), Document.class);
        // Check the upload response
        assertEquals("quick-1.pdf", document.getName());

        // upload the same file again, and request the path info to be present in the response
        response = post(getChildrenUrl(Nodes.PATH_MY), user1, reqBody.getBody(), "?select=path", reqBody.getContentType(), 201);
        document = jacksonUtil.parseEntry(response.getJsonResponse(), Document.class);
        // Check the upload response
        assertEquals("quick-2.pdf", document.getName());
        assertNotNull(document.getPath());

        response = getAll(getChildrenUrl(Nodes.PATH_MY), user1, paging, 200);
        pagingResult = parsePaging(response.getJsonResponse());
        assertNotNull(paging);
        assertEquals(numOfNodes + 3, pagingResult.getCount().intValue());

        // User2 tries to upload a new file into the user1's home folder.
        response = getSingle(NodesEntityResource.class, user1, Nodes.PATH_MY, null, 200);
        Folder user1Home = jacksonUtil.parseEntry(response.getJsonResponse(), Folder.class);
        final String fileName2 = "quick-2.txt";
        final File file2 = getResourceFile(fileName2);
        reqBody = MultiPartBuilder.create()
                    .setFileData(new FileData(fileName2, file2, MimetypeMap.MIMETYPE_TEXT_PLAIN))
                    .build();
        post(getChildrenUrl(user1Home.getId()), user2, reqBody.getBody(), null, reqBody.getContentType(), 403);

        response = getAll(getChildrenUrl(Nodes.PATH_MY), user1, paging, 200);
        pagingResult = parsePaging(response.getJsonResponse());
        assertNotNull(paging);
        assertEquals("Access Denied. The file shouldn't have been uploaded.", numOfNodes + 3, pagingResult.getCount().intValue());

        // User1 tries to upload a file into a document rather than a folder!
        post(getChildrenUrl(document.getId()), user1, reqBody.getBody(), null, reqBody.getContentType(), 400);

        // Try to upload a file without defining the required formData
        reqBody = MultiPartBuilder.create().setAutoRename(true).build();
        post(getChildrenUrl(Nodes.PATH_MY), user1, reqBody.getBody(), null, reqBody.getContentType(), 400);

        // Test unsupported node type
        reqBody = MultiPartBuilder.create()
                    .setFileData(new FileData(fileName2, file2, null))
                    .setAutoRename(true)
                    .setNodeType("cm:link")
                    .build();
        post(getChildrenUrl(user1Home.getId()), user1, reqBody.getBody(), null, reqBody.getContentType(), 400);

        // User1 uploads a new file
        reqBody = MultiPartBuilder.create()
                    .setFileData(new FileData(fileName2, file2, MimetypeMap.MIMETYPE_TEXT_PLAIN, "windows-1252"))
                    .build();
        response = post(getChildrenUrl(user1Home.getId()), user1, reqBody.getBody(), null, reqBody.getContentType(), 201);
        document = jacksonUtil.parseEntry(response.getJsonResponse(), Document.class);
        // Check the upload response
        assertEquals(fileName2, document.getName());
        contentInfo = document.getContent();
        assertNotNull(contentInfo);
        assertEquals(MimetypeMap.MIMETYPE_TEXT_PLAIN, contentInfo.getMimeType());
        assertEquals("windows-1252", contentInfo.getEncoding());

        // Test invalid mimeType
        reqBody = MultiPartBuilder.create()
                    .setFileData(new FileData(fileName2, file2, "*/invalidSubType", "ISO-8859-1"))
                    .setAutoRename(true)
                    .build();
        post(getChildrenUrl(user1Home.getId()), user1, reqBody.getBody(), null, reqBody.getContentType(), 400);

        // Test content size limit
        final SimpleFixedLimitProvider limitProvider = applicationContext.getBean("defaultContentLimitProvider", SimpleFixedLimitProvider.class);
        final long defaultSizeLimit = limitProvider.getSizeLimit();
        limitProvider.setSizeLimitString("20000"); //20 KB

        try
        {
            // quick.pdf size is about 23 KB
            reqBody = MultiPartBuilder.create()
                        .setFileData(new FileData(fileName, file, MimetypeMap.MIMETYPE_PDF))
                        .setAutoRename(true)
                        .build();

            // Try to upload a file larger than the configured size limit
            post(getChildrenUrl(Nodes.PATH_MY), user1, reqBody.getBody(), null, reqBody.getContentType(), 413);
        }
        finally
        {
            limitProvider.setSizeLimitString(Long.toString(defaultSizeLimit));
        }
    }

    /**
     * Tests Multipart upload to a Site.
     * <p>POST:</p>
     * {@literal <host>:<port>/alfresco/api/<networkId>/public/alfresco/versions/1/nodes/<nodeId>/children}
     */
    @Test
    public void testUploadToSite() throws Exception
    {
        final String fileName = "quick-1.txt";
        final File file = getResourceFile(fileName);

        AuthenticationUtil.setFullyAuthenticatedUser(userOneN1.getId());
        String folderA = "folder" + System.currentTimeMillis() + "_A";
        NodeRef folderA_Ref = repoService.addToDocumentLibrary(userOneN1Site, folderA, ContentModel.TYPE_FOLDER);

        Paging paging = getPaging(0, Integer.MAX_VALUE);
        HttpResponse response = getAll(getChildrenUrl(folderA_Ref), userOneN1.getId(), paging, 200);
        PublicApiClient.ExpectedPaging pagingResult = parsePaging(response.getJsonResponse());
        assertNotNull(paging);
        final int numOfNodes = pagingResult.getCount();

        MultiPartBuilder multiPartBuilder = MultiPartBuilder.create()
                    .setFileData(new FileData(fileName, file, null));
        MultiPartRequest reqBody = multiPartBuilder.build();
        // Try to upload
        response = post(getChildrenUrl(folderA_Ref), userOneN1.getId(), reqBody.getBody(), null, reqBody.getContentType(), 201);
        Document document = jacksonUtil.parseEntry(response.getJsonResponse(), Document.class);
        // Check the upload response
        assertEquals(fileName, document.getName());
        ContentInfo contentInfo = document.getContent();
        assertNotNull(contentInfo);
        // As the client didn't set the mimeType, the API must guess it.
        assertEquals(MimetypeMap.MIMETYPE_TEXT_PLAIN, contentInfo.getMimeType());

        // Retrieve the uploaded file
        response = getSingle(NodesEntityResource.class, userOneN1.getId(), document.getId(), null, 200);
        document = jacksonUtil.parseEntry(response.getJsonResponse(), Document.class);
        assertEquals(fileName, document.getName());
        contentInfo = document.getContent();
        assertNotNull(contentInfo);
        assertEquals(MimetypeMap.MIMETYPE_TEXT_PLAIN, contentInfo.getMimeType());

        // Check 'get children' is confirming the upload
        response = getAll(getChildrenUrl(folderA_Ref), userOneN1.getId(), paging, 200);
        pagingResult = parsePaging(response.getJsonResponse());
        assertNotNull(paging);
        assertEquals(numOfNodes + 1, pagingResult.getCount().intValue());

        // Upload the same file again to check the name conflicts handling
        post(getChildrenUrl(folderA_Ref), userOneN1.getId(), reqBody.getBody(), null, reqBody.getContentType(), 409);

        response = getAll(getChildrenUrl(folderA_Ref), userOneN1.getId(), paging, 200);
        pagingResult = parsePaging(response.getJsonResponse());
        assertNotNull(paging);
        assertEquals(numOfNodes + 1, pagingResult.getCount().intValue());

        final String fileName2 = "quick-2.txt";
        final File file2 = getResourceFile(fileName2);
        reqBody = MultiPartBuilder.create()
                    .setFileData(new FileData(fileName2, file2, MimetypeMap.MIMETYPE_TEXT_PLAIN))
                    .build();
        // userTwoN1 tries to upload a new file into the folderA of userOneN1
        post(getChildrenUrl(folderA_Ref), userTwoN1.getId(), reqBody.getBody(), null, reqBody.getContentType(), 403);

        // Test upload with properties
        response = post(getChildrenUrl(folderA_Ref), userOneN1.getId(), reqBody.getBody(), null, reqBody.getContentType(), 201);
        document = jacksonUtil.parseEntry(response.getJsonResponse(), Document.class);
        // Check the upload response
        assertEquals(fileName2, document.getName());
        contentInfo = document.getContent();
        assertNotNull(contentInfo);
        assertEquals(MimetypeMap.MIMETYPE_TEXT_PLAIN, contentInfo.getMimeType());
        assertNotNull(document.getProperties());
        assertNull(document.getProperties().get("cm:title"));
        assertNull(document.getProperties().get("cm:description"));

        // upload a file with properties. Also, set autoRename=true
        Map<String, String> props = new HashMap<>(2);
        props.put("cm:title", "test title");
        props.put("cm:description", "test description");
        reqBody = MultiPartBuilder.create()
                    .setFileData(new FileData(fileName2, file2, MimetypeMap.MIMETYPE_TEXT_PLAIN))
                    .setAutoRename(true)
                    .setProperties(props)
                    .build();

        response = post(getChildrenUrl(folderA_Ref), userOneN1.getId(), reqBody.getBody(), null, reqBody.getContentType(), 201);
        document = jacksonUtil.parseEntry(response.getJsonResponse(), Document.class);
        // Check the upload response
        // "quick-2-1.txt" => fileName2 + autoRename
        assertEquals("quick-2-1.txt", document.getName());
        contentInfo = document.getContent();
        assertNotNull(contentInfo);
        assertEquals(MimetypeMap.MIMETYPE_TEXT_PLAIN, contentInfo.getMimeType());
        assertNotNull(document.getProperties());
        assertEquals("test title", document.getProperties().get("cm:title"));
        assertEquals("test description", document.getProperties().get("cm:description"));

        // Test unknown property name
        props = new HashMap<>(1);
        props.put("unknownPrefix" + System.currentTimeMillis() + ":description", "test description");
        reqBody = MultiPartBuilder.create()
                    .setFileData(new FileData(fileName2, file2, MimetypeMap.MIMETYPE_TEXT_PLAIN))
                    .setAutoRename(true)
                    .setProperties(props)
                    .build();
        // Prop prefix is unknown
        post(getChildrenUrl(folderA_Ref), userOneN1.getId(), reqBody.getBody(), null, reqBody.getContentType(), 400);
    }

    /**
     * Tests delete (file or folder)
     * <p>DELETE:</p>
     * {@literal <host>:<port>/alfresco/api/-default-/public/alfresco/versions/1/nodes/<nodeId>}
     */
    @Test
    public void testDelete() throws Exception
    {
        long runId = System.currentTimeMillis();

        AuthenticationUtil.setFullyAuthenticatedUser(user1);

        String myNodeId = getMyNodeId(user1);
        NodeRef myFilesNodeRef = new NodeRef(StoreRef.STORE_REF_WORKSPACE_SPACESSTORE, myNodeId);

        NodeRef content1Ref = repoService.createDocument(myFilesNodeRef,
                "content" + runId + "_1", "The quick brown fox jumps over the lazy dog.");
        String content1Id = content1Ref.getId();

        // delete file
        delete("nodes", user1, content1Ref.getId(), 204);

        assertTrue(existsArchiveNode(content1Id));

        // -ve test
        delete("nodes", user1, content1Ref.getId(), 404);

        String folder1Id = createFolder(user1, myNodeId, "folder " + runId + "_1").getId();
        String folder2Id = createFolder(user1, folder1Id, "folder " + runId + "_2").getId();

        NodeRef content2Ref = repoService.createDocument(new NodeRef(StoreRef.STORE_REF_WORKSPACE_SPACESSTORE, folder2Id),
                "content " + runId + "_2", "The quick brown fox jumps over the lazy dog.");
        String content2Id = content2Ref.getId();

        // cascade delete folder
        delete("nodes", user1, folder1Id, 204);

        assertTrue(existsArchiveNode(folder1Id));
        assertTrue(existsArchiveNode(folder2Id));
        assertTrue(existsArchiveNode(content2Id));

        // -ve test
        delete("nodes", user1, folder2Id, 404);
        delete("nodes", user1, content2Ref.getId(), 404);

        // -ve test
        String rootNodeId = getRootNodeId(user1);
        delete("nodes", user1, rootNodeId, 403);

        //
        // permanently delete - ie. bypass trashcan (archive store)
        //

        String folder3Id = createFolder(user1, myNodeId, "folder " + runId + "_3").getId();
        String folder4Id = createFolder(user1, folder3Id, "folder " + runId + "_4").getId();

        Map<String, String> params = Collections.singletonMap("permanent", "true");
        delete("nodes", user1, folder3Id, params, 204);

        assertFalse(existsArchiveNode(folder3Id));
        assertFalse(existsArchiveNode(folder4Id));

        String sharedNodeId = getSharedNodeId(user1);
        String folder5Id = createFolder(user1, sharedNodeId, "folder " + runId + "_5").getId();

        AuthenticationUtil.setFullyAuthenticatedUser(user2);

        // -ve test - another user cannot delete
        delete("nodes", user2, folder5Id, 403);

        AuthenticationUtil.setFullyAuthenticatedUser(user1);

        Map<String, Object> props = new HashMap<>();
        props.put(PROP_OWNER, user2);
        Node nUpdate = new Node();
        nUpdate.setProperties(props);

        HttpResponse response = put("nodes", user1, folder5Id, toJsonAsStringNonNull(nUpdate), null, 200);
        Node nodeResp = jacksonUtil.parseEntry(response.getJsonResponse(), Node.class);
        assertEquals(user2, ((Map)nodeResp.getProperties().get(PROP_OWNER)).get("id"));

        // -ve test - user1 can no longer delete
        delete("nodes", user1, folder5Id, 403);

        permissionService.setPermission(new NodeRef(StoreRef.STORE_REF_WORKSPACE_SPACESSTORE, folder5Id), user1, PermissionService.DELETE, true);

        // -ve test - non-owner cannot bypass trashcan
        params = Collections.singletonMap("permanent", "true");
        delete("nodes", user1, folder5Id, params, 403);

        // user1 has permission to delete (via trashcan)
        delete("nodes", user1, folder5Id, 204);

        // admin can permanently delete
        String folder6Id = createFolder(user1, sharedNodeId, "folder " + runId + "_6").getId();
        params = Collections.singletonMap("permanent", "true");

        // TODO improve - admin-related tests
        publicApiClient.setRequestContext(new RequestContext("-default-", "admin", "admin"));
        response = publicApiClient.delete(getScope(), 1, "nodes", folder6Id, null, null, params);
        checkStatus(204, response.getStatusCode());
    }

    private boolean existsArchiveNode(String nodeId)
    {
        // TODO replace with calls to future V1 REST API for Trashcan
        NodeRef originalNodeRef = new NodeRef(StoreRef.STORE_REF_WORKSPACE_SPACESSTORE, nodeId);
        NodeRef archiveNodeRef = nodeArchiveService.getArchivedNode(originalNodeRef);
        return nodeService.exists(archiveNodeRef);
    }

    /**
     * Tests move (file or folder)
     * <p>POST:</p>
     * {@literal <host>:<port>/alfresco/api/-default-/public/alfresco/versions/1/nodes/<nodeId>/move}
     */
    @Test
    public void testMove() throws Exception
    {
        AuthenticationUtil.setFullyAuthenticatedUser(user1);

        // create folder f1
        Folder folderResp = createFolder(user1, Nodes.PATH_MY, "f1");
        String f1Id = folderResp.getId();

        // create folder f2
        folderResp = createFolder(user1, Nodes.PATH_MY, "f2");
        String f2Id = folderResp.getId();

        // create doc d1
        NodeRef f1Ref = new NodeRef(StoreRef.STORE_REF_WORKSPACE_SPACESSTORE, f1Id);
        String d1Name = "content" + System.currentTimeMillis() + "_1";
        NodeRef d1Ref = repoService.createDocument(f1Ref, d1Name, "The quick brown fox jumps over the lazy dog.");
        String d1Id = d1Ref.getId();

        // create doc d2
        NodeRef f2Ref = new NodeRef(StoreRef.STORE_REF_WORKSPACE_SPACESSTORE, f2Id);
        String d2Name = "content" + System.currentTimeMillis() + "_2";
        NodeRef d2Ref = repoService.createDocument(f2Ref, d2Name, "The quick brown fox jumps over the lazy dog 2.");
        String d2Id = d2Ref.getId();

        // move file (without rename)

        NodeTarget tgt = new NodeTarget();
        tgt.setTargetParentId(f2Id);

        HttpResponse response = post("nodes/"+d1Id+"/move", user1, toJsonAsStringNonNull(tgt), null, 201);
        Document documentResp = RestApiUtil.parseRestApiEntry(response.getJsonResponse(), Document.class);

        assertEquals(d1Name, documentResp.getName());
        assertEquals(f2Id, documentResp.getParentId());

        // move file (with rename)

        String d1NewName = d1Name+" updated !!";

        tgt = new NodeTarget();
        tgt.setName(d1NewName);
        tgt.setTargetParentId(f1Id);

        response = post("nodes/"+d1Id+"/move", user1, toJsonAsStringNonNull(tgt), null, 201);
        documentResp = RestApiUtil.parseRestApiEntry(response.getJsonResponse(), Document.class);

        assertEquals(d1NewName, documentResp.getName());
        assertEquals(f1Id, documentResp.getParentId());

        // -ve tests

        // missing target
        tgt = new NodeTarget();
        tgt.setName("new name");
        post("nodes/"+d1Id+"/move", user1, toJsonAsStringNonNull(tgt), null, 400);

        // name already exists
        tgt = new NodeTarget();
        tgt.setName(d2Name);
        tgt.setTargetParentId(f2Id);
        post("nodes/"+d1Id+"/move", user1, toJsonAsStringNonNull(tgt), null, 409);

        // unknown source nodeId
        tgt = new NodeTarget();
        tgt.setTargetParentId(f2Id);
        post("nodes/"+UUID.randomUUID().toString()+"/move", user1, toJsonAsStringNonNull(tgt), null, 404);

        // unknown target nodeId
        tgt = new NodeTarget();
        tgt.setTargetParentId(UUID.randomUUID().toString());
        post("nodes/"+d1Id+"/move", user1, toJsonAsStringNonNull(tgt), null, 404);

        // target is not a folder
        tgt = new NodeTarget();
        tgt.setTargetParentId(d2Id);
        post("nodes/"+d1Id+"/move", user1, toJsonAsStringNonNull(tgt), null, 400);

        String rootNodeId = getRootNodeId(user1);

        // create folder f3 (sub-folder of f2)
        folderResp = createFolder(user1, f2Id, "f3");
        String f3Id = folderResp.getId();

        // can't create cycle (move into own subtree)
        tgt = new NodeTarget();
        tgt.setTargetParentId(f3Id);
        post("nodes/"+f2Id+"/move", user1, toJsonAsStringNonNull(tgt), null, 400);

        // no (write/create) permissions to move to target
        tgt = new NodeTarget();
        tgt.setTargetParentId(rootNodeId);
        post("nodes/"+d1Id+"/move", user1, toJsonAsStringNonNull(tgt), null, 403);

        AuthenticationUtil.setFullyAuthenticatedUser(user2);

        String my2NodeId = getMyNodeId(user2);

        // no (write/delete) permissions to move source
        tgt = new NodeTarget();
        tgt.setTargetParentId(my2NodeId);
        post("nodes/"+f1Id+"/move", user2, toJsonAsStringNonNull(tgt), null, 403);
    }

    /**
     * Tests copy (file or folder)
     * <p>POST:</p>
     * {@literal <host>:<port>/alfresco/api/-default-/public/alfresco/versions/1/nodes/<nodeId>/copy}
     */
    @Test
    public void testCopy() throws Exception
    {
        AuthenticationUtil.setFullyAuthenticatedUser(user1);

        // create folder
        Folder folderResp = createFolder(user1, Nodes.PATH_MY, "fsource");
        String source = folderResp.getId();
        NodeRef sourceRef = new NodeRef(StoreRef.STORE_REF_WORKSPACE_SPACESSTORE, source);

        // create folder
        folderResp = createFolder(user1, Nodes.PATH_MY, "ftarget");
        String target = folderResp.getId();
        NodeRef targetRef = new NodeRef(StoreRef.STORE_REF_WORKSPACE_SPACESSTORE, target);

        // create doc d1
        String d1Name = "content" + System.currentTimeMillis() + "_1";
        NodeRef d1Ref = repoService.createDocument(sourceRef, d1Name, "The quick brown fox jumps over the lazy dog.");
        String d1Id = d1Ref.getId();

        // create doc d2
        String d2Name = "content" + System.currentTimeMillis() + "_2";
        NodeRef d2Ref = repoService.createDocument(sourceRef, d2Name, "The quick brown fox jumps over the lazy dog 2.");
        String d2Id = d2Ref.getId();

        Map<String, String> body = new HashMap<>();
        body.put("targetParentId", target);

        HttpResponse response = post(user1, "nodes", d1Id, "copy", toJsonAsStringNonNull(body).getBytes(), null, null, 201);
        Document documentResp = RestApiUtil.parseRestApiEntry(response.getJsonResponse(), Document.class);

        assertEquals(d1Name, documentResp.getName());
        assertEquals(target, documentResp.getParentId());

        // copy file (with rename)
        String newD2Name = d2Name + " updated !!";

        body = new HashMap<>();
        body.put("targetParentId", target);
        body.put("name", newD2Name);

        response = post(user1, "nodes", d2Id, "copy", toJsonAsStringNonNull(body).getBytes(), null, null, 201);
        documentResp = RestApiUtil.parseRestApiEntry(response.getJsonResponse(), Document.class);

        assertEquals(newD2Name, documentResp.getName());
        assertEquals(target, documentResp.getParentId());

        // -ve tests

        // missing target
        NodeTarget tgt = new NodeTarget();
        tgt.setName("new name");
        post("nodes/"+d1Id+"/copy", user1, toJsonAsStringNonNull(tgt), null, 400);

        // name already exists
        tgt = new NodeTarget();
        tgt.setName(newD2Name);
        tgt.setTargetParentId(target);
        post("nodes/"+d1Id+"/copy", user1, toJsonAsStringNonNull(tgt), null, 409);

        // unknown source nodeId
        tgt = new NodeTarget();
        tgt.setTargetParentId(target);
        post("nodes/"+UUID.randomUUID().toString()+"/copy", user1, toJsonAsStringNonNull(tgt), null, 404);

        // unknown target nodeId
        tgt = new NodeTarget();
        tgt.setTargetParentId(UUID.randomUUID().toString());
        post("nodes/"+d1Id+"/copy", user1, toJsonAsStringNonNull(tgt), null, 404);

        // target is not a folder
        tgt = new NodeTarget();
        tgt.setTargetParentId(d2Id);
        post("nodes/"+d1Id+"/copy", user1, toJsonAsStringNonNull(tgt), null, 400);

        String rootNodeId = getRootNodeId(user1);

        // no (write/create) permissions to copy to target
        tgt = new NodeTarget();
        tgt.setTargetParentId(rootNodeId);
        post("nodes/"+d1Id+"/copy", user1, toJsonAsStringNonNull(tgt), null, 403);
    }
    /**
     * Tests create folder.
     * <p>POST:</p>
     * {@literal <host>:<port>/alfresco/api/-default-/public/alfresco/versions/1/nodes/<nodeId>/children}
     */
    @Test
    public void testCreateFolder() throws Exception
    {
        AuthenticationUtil.setFullyAuthenticatedUser(user1);

        String myNodeId = getMyNodeId(user1);

        UserInfo expectedUser = new UserInfo(user1, user1+" "+user1);

        String postUrl = getChildrenUrl(myNodeId);

        // create folder
        Folder folderResp = createFolder(user1, myNodeId, "f1");

        Folder f1 = new Folder();
        f1.setName("f1");
        f1.setNodeType("cm:folder");

        f1.setIsFolder(true);
        f1.setParentId(myNodeId);
        f1.setAspectNames(Collections.singletonList("cm:auditable"));

        f1.setCreatedByUser(expectedUser);
        f1.setModifiedByUser(expectedUser);

        f1.expected(folderResp);

        // create folder with properties
        Map<String,Object> props = new HashMap<>();
        props.put("cm:title","my folder title");
        props.put("cm:description","my folder description");

        folderResp = createFolder(user1, myNodeId, "f2", props);

        Folder f2 = new Folder();
        f2.setName("f2");
        f2.setNodeType("cm:folder");
        f2.setProperties(props);

        f2.setIsFolder(true);
        f2.setParentId(myNodeId);
        f2.setAspectNames(Arrays.asList("cm:auditable","cm:titled"));

        f2.setCreatedByUser(expectedUser);
        f2.setModifiedByUser(expectedUser);

        f2.expected(folderResp);

        // -ve test - name is mandatory
        Folder invalid = new Folder();
        invalid.setNodeType("cm:folder");
        post(postUrl, user1, toJsonAsStringNonNull(invalid), 400);

        // -ve test - node type is mandatory
        invalid = new Folder();
        invalid.setName("my folder");
        post(postUrl, user1, toJsonAsStringNonNull(invalid), 400);

        // create empty file
        Document d1 = new Document();
        d1.setName("d1.txt");
        d1.setNodeType("cm:content");
        ContentInfo ci = new ContentInfo();
        ci.setMimeType("text/plain");
        d1.setContent(ci);

        HttpResponse response = post(postUrl, user1, toJsonAsStringNonNull(d1), 201);
        Document documentResp = RestApiUtil.parseRestApiEntry(response.getJsonResponse(), Document.class);
        String d1Id = documentResp.getId();

        // -ve test - invalid (eg. not a folder) parent id
        Folder f3 = new Folder();
        f3.setName("f3");
        f3.setNodeType("cm:folder");
        post(getChildrenUrl(d1Id), user1, toJsonAsStringNonNull(f3), 400);

        // -ve test - it should not be possible to create a "system folder"
        invalid = new Folder();
        invalid.setName("my sys folder");
        invalid.setNodeType("cm:systemfolder");
        post(postUrl, user1, toJsonAsStringNonNull(invalid), 400);

        // -ve test - unknown parent folder node id
        post(getChildrenUrl(UUID.randomUUID().toString()), user1, toJsonAsStringNonNull(f3), 404);

        // -ve test - duplicate name
        post(postUrl, user1, toJsonAsStringNonNull(f1), 409);

        // Create a folder with a duplicate name (f1), but set the autoRename to true
        response = post(postUrl, user1, toJsonAsStringNonNull(f1), "?autoRename=true", 201);
        documentResp = RestApiUtil.parseRestApiEntry(response.getJsonResponse(), Document.class);
        assertEquals("f1-1", documentResp.getName());

        // Create a folder with a duplicate name (f1) again, but set the autoRename to true
        response = post(postUrl, user1, toJsonAsStringNonNull(f1), "?autoRename=true", 201);
        documentResp = RestApiUtil.parseRestApiEntry(response.getJsonResponse(), Document.class);
        assertEquals("f1-2", documentResp.getName());

        // -ve test - create a folder with a duplicate name (f1), but set the autoRename to false
        post(postUrl, user1, toJsonAsStringNonNull(f1), "?autoRename=false", 409);
    }

    // TODO test custom type with properties (sub-type of cm:cmobject)

    // note: app:folderlink & app:filelink both extend cm:link (which in turn extends cm:cmobject)
    //       (see applicationModel.xml / contentModel.xml)
    @Test
    public void testLinkCRUD() throws Exception
    {
        AuthenticationUtil.setFullyAuthenticatedUser(user1);

        String myNodeId = getMyNodeId(user1);
        UserInfo expectedUser = new UserInfo(user1, user1+" "+user1);
        String myChildrenUrl = getChildrenUrl(myNodeId);

        long timeNow = System.currentTimeMillis();

        // create folder f1
        Folder folderResp = createFolder(user1, myNodeId, "f1 "+timeNow);
        String f1Id = folderResp.getId();

        // create empty file d1 in f1
        Document d1 = new Document();
        d1.setName("d1.txt");
        d1.setNodeType("cm:content");
        ContentInfo ci = new ContentInfo();
        ci.setMimeType("text/plain");
        d1.setContent(ci);

        HttpResponse response = post(getChildrenUrl(f1Id), user1, toJsonAsStringNonNull(d1), 201);
        Document documentResp = RestApiUtil.parseRestApiEntry(response.getJsonResponse(), Document.class);
        String d1Id = documentResp.getId();

        // create folder f2
        folderResp = createFolder(user1, myNodeId, "f2 "+timeNow);
        String f2Id = folderResp.getId();

        // create folder link node in f2 (pointing to f1)
        String nodeName = "f1 link";
        String nodeType = "app:folderlink";

        Map<String,Object> props = new HashMap<>();
        props.put("cm:destination", f1Id);

        Node nodeResp = createNode(user1, f2Id, nodeName, nodeType, props);
        String n1Id = nodeResp.getId();

        Node n1 = new Node();
        n1.setName(nodeName);
        n1.setNodeType(nodeType);
        n1.setIsFolder(true);
        n1.setParentId(f2Id); // note: parent of the link (not where it is pointing)
        n1.setAspectNames(Collections.singletonList("cm:auditable"));
        n1.setProperties(props);
        n1.setCreatedByUser(expectedUser);
        n1.setModifiedByUser(expectedUser);

        n1.expected(nodeResp);

        // get node info
        response = getSingle(NodesEntityResource.class, user1, n1Id, null, 200);
        nodeResp = jacksonUtil.parseEntry(response.getJsonResponse(), Node.class);

        n1.expected(nodeResp);

        // create file link node in f2 pointing to d1
        nodeName = "d1 link";
        nodeType = "app:filelink";

        props = new HashMap<>();
        props.put("cm:destination", d1Id);

        nodeResp = createNode(user1, f2Id, nodeName, nodeType, props);
        String n2Id = nodeResp.getId();

        Node n2 = new Node();
        n2.setName(nodeName);
        n2.setNodeType(nodeType);
        n2.setIsFolder(false);
        n2.setParentId(f2Id); // note: parent of the link (not where it is pointing)
        n2.setAspectNames(Collections.singletonList("cm:auditable"));
        n2.setProperties(props);
        n2.setCreatedByUser(expectedUser);
        n2.setModifiedByUser(expectedUser);

        n2.expected(nodeResp);

        // get node info
        response = getSingle(NodesEntityResource.class, user1, n2Id, null, 200);
        nodeResp = jacksonUtil.parseEntry(response.getJsonResponse(), Node.class);

        n2.expected(nodeResp);


        // update node - rename

        String updatedName = "f1 link renamed";

        Node nUpdate = new Node();
        nUpdate.setName(updatedName);

        response = put("nodes", user1, n1Id, toJsonAsStringNonNull(nUpdate), null, 200);
        nodeResp = RestApiUtil.parseRestApiEntry(response.getJsonResponse(), Document.class);

        n1.setName(updatedName);
        n1.expected(nodeResp);


        // filtering, via where clause (nodeType + optionally including sub-types)

        List<String> linkIds = Arrays.asList(n1Id, n2Id);

        Map<String, String> params = new HashMap<>();
        params.put("where", "(nodeType='cm:link')");

        Paging paging = getPaging(0, Integer.MAX_VALUE);

        response = getAll(getChildrenUrl(f2Id), user1, paging, params, 200);
        List<Node> nodes = jacksonUtil.parseEntries(response.getJsonResponse(), Node.class);
        assertEquals(0, nodes.size());

        // filter by including sub-types - note: includesubtypes is case-insensitive

        params = new HashMap<>();
        params.put("where", "(nodeType='cm:link INCLUDESUBTYPES')");

        paging = getPaging(0, Integer.MAX_VALUE);

        response = getAll(getChildrenUrl(f2Id), user1, paging, params, 200);
        nodes = jacksonUtil.parseEntries(response.getJsonResponse(), Node.class);
        assertEquals(linkIds.size(), nodes.size());
        assertTrue(linkIds.contains(nodes.get(0).getId()));
        assertTrue(linkIds.contains(nodes.get(1).getId()));

        params = new HashMap<>();
        params.put("where", "(nodeType='cm:link includeSubTypes')");

        paging = getPaging(0, Integer.MAX_VALUE);

        response = getAll(getChildrenUrl(f2Id), user1, paging, params, 200);
        nodes = jacksonUtil.parseEntries(response.getJsonResponse(), Node.class);
        assertEquals(linkIds.size(), nodes.size());
        assertTrue(linkIds.contains(nodes.get(0).getId()));
        assertTrue(linkIds.contains(nodes.get(1).getId()));


        // delete link
        delete("nodes", user1, n1Id, 204);

        // -ve test - delete - cannot delete nonexistent link
        delete("nodes", user1, n1Id, 404);

        // -ve test - create - name is mandatory
        Node invalid = new Node();
        invalid.setNodeType("cm:link");
        post(myChildrenUrl, user1, toJsonAsStringNonNull(invalid), 400);

        // -ve test - create - node type is mandatory
        invalid = new Node();
        invalid.setName("my node");
        post(myChildrenUrl, user1, toJsonAsStringNonNull(invalid), 400);

        // -ve test - create - unsupported node type
        invalid = new Node();
        invalid.setName("my node");
        invalid.setNodeType("sys:base");
        post(myChildrenUrl, user1, toJsonAsStringNonNull(invalid), 400);

        // -ve test - create - duplicate name
        post(getChildrenUrl(f2Id), user1, toJsonAsStringNonNull(n2), 409);

        // -ve test - unknown nodeType when filtering
        params = new HashMap<>();
        params.put("where", "(nodeType='my:unknown'");
        getAll(getChildrenUrl(f2Id), user1, paging, params, 400);

        // -ver test - invalid node type localname format and suffix is not ' includesubtypes'
        params = new HashMap<>();
        params.put("where", "(nodeType='cm:link ')");
        getAll(getChildrenUrl(f2Id), user1, paging, params, 400);

        params = new HashMap<>();
        params.put("where", "(nodeType='cm:link blah')");
        getAll(getChildrenUrl(f2Id), user1, paging, params, 400);
    }


    /**
     * Tests create empty file.
     * <p>POST:</p>
     * {@literal <host>:<port>/alfresco/api/-default-/public/alfresco/versions/1/nodes/<nodeId>/children}
     */
    @Test
    public void testCreateEmptyFile() throws Exception
    {
        AuthenticationUtil.setFullyAuthenticatedUser(user1);

        String myNodeId = getMyNodeId(user1);

        UserInfo expectedUser = new UserInfo(user1, user1+" "+user1);

        String postUrl = getChildrenUrl(myNodeId);

        Document d1 = new Document();
        d1.setName("d1.txt");
        d1.setNodeType("cm:content");
        ContentInfo ci = new ContentInfo();
        ci.setMimeType("text/plain");
        d1.setContent(ci);

        // create empty file
        HttpResponse response = post(postUrl, user1, toJsonAsStringNonNull(d1), 201);
        Document documentResp = RestApiUtil.parseRestApiEntry(response.getJsonResponse(), Document.class);
        String d1Id = documentResp.getId();

        d1.setIsFolder(false);
        d1.setParentId(myNodeId);
        d1.setAspectNames(Collections.singletonList("cm:auditable"));

        d1.setCreatedByUser(expectedUser);
        d1.setModifiedByUser(expectedUser);

        d1.getContent().setMimeTypeName("Plain Text");
        d1.getContent().setSizeInBytes(0L);
        d1.getContent().setEncoding("UTF-8");

        d1.expected(documentResp);

        // create empty file with properties
        Map<String,Object> props = new HashMap<>();
        props.put("cm:title","my file title");
        props.put("cm:description","my file description");

        Document d2 = new Document();
        d2.setName("d2.txt");
        d2.setNodeType("cm:content");
        d2.setProperties(props);

        response = post(postUrl, user1, toJsonAsStringNonNull(d2), 201);

        documentResp = RestApiUtil.parseRestApiEntry(response.getJsonResponse(), Document.class);

        d2.setIsFolder(false);
        d2.setParentId(myNodeId);
        d2.setAspectNames(Arrays.asList("cm:auditable","cm:titled"));

        d2.setCreatedByUser(expectedUser);
        d2.setModifiedByUser(expectedUser);

        ContentInfo ciExpected = new ContentInfo();
        ciExpected.setMimeType("text/plain");
        ciExpected.setMimeTypeName("Plain Text");
        ciExpected.setSizeInBytes(0L);
        ciExpected.setEncoding("UTF-8");
        d2.setContent(ciExpected);

        d2.expected(documentResp);

        // -ve test - name is mandatory
        Document invalid = new Document();
        invalid.setNodeType("cm:content");
        post(postUrl, user1, toJsonAsStringNonNull(invalid), 400);

        // -ve test - node type is mandatory
        invalid = new Document();
        invalid.setName("my file.txt");
        post(postUrl, user1, toJsonAsStringNonNull(invalid), 400);

        // -ve test - invalid (eg. not a folder) parent id
        Document d3 = new Document();
        d3.setName("d3.txt");
        d3.setNodeType("cm:content");
        post(getChildrenUrl(d1Id), user1, toJsonAsStringNonNull(d3), 400);

        // -ve test - unknown parent folder node id
        post(getChildrenUrl(UUID.randomUUID().toString()), user1, toJsonAsStringNonNull(d3), 404);

        // -ve test - duplicate name
        post(postUrl, user1, toJsonAsStringNonNull(d1), 409);

        // Create a file with a duplicate name (d1.txt), but set the autoRename to true
        response = post(postUrl, user1, toJsonAsStringNonNull(d1), "?autoRename=true", 201);
        documentResp = RestApiUtil.parseRestApiEntry(response.getJsonResponse(), Document.class);
        assertEquals("d1-1.txt", documentResp.getName());

        // Create a file with a duplicate name (d1.txt) again, but set the autoRename to true
        response = post(postUrl, user1, toJsonAsStringNonNull(d1), "?autoRename=true", 201);
        documentResp = RestApiUtil.parseRestApiEntry(response.getJsonResponse(), Document.class);
        assertEquals("d1-2.txt", documentResp.getName());

        // Create a file with a duplicate name (d1-2.txt) again, but set the autoRename to true
        d1.setName("d1-2.txt");
        response = post(postUrl, user1, toJsonAsStringNonNull(d1), "?autoRename=true", 201);
        documentResp = RestApiUtil.parseRestApiEntry(response.getJsonResponse(), Document.class);
        assertEquals("d1-2-1.txt", documentResp.getName());

        // -ve test - create a file with a duplicate name (d1-2.txt), but set the autoRename to false
        post(postUrl, user1, toJsonAsStringNonNull(d1), "?autoRename=false", 409);
    }

    /**
     * Tests update node info (file or folder)
     * <p>PUT:</p>
     * {@literal <host>:<port>/alfresco/api/-default-/public/alfresco/versions/1/nodes/<nodeId>}
     */
    @Test
    public void testUpdateNodeInfo() throws Exception
    {
        AuthenticationUtil.setFullyAuthenticatedUser(user1);

        String myNodeId = getMyNodeId(user1);

        UserInfo expectedUser = new UserInfo(user1, user1+" "+user1);

        String postUrl = getChildrenUrl(myNodeId);

        String folderName = "My Folder";

        // create folder
        Folder folderResp = createFolder(user1, myNodeId, folderName);

        String fId = folderResp.getId();

        Folder f1 = new Folder();
        f1.setName(folderName);
        f1.setNodeType("cm:folder");

        f1.setIsFolder(true);
        f1.setParentId(myNodeId);
        f1.setAspectNames(Collections.singletonList("cm:auditable"));

        f1.setCreatedByUser(expectedUser);
        f1.setModifiedByUser(expectedUser);

        f1.expected(folderResp);

        // create empty file

        Document d1 = new Document();
        d1.setName("d1.txt");
        d1.setNodeType("cm:content");
        ContentInfo ci = new ContentInfo();
        ci.setMimeType("text/plain");
        d1.setContent(ci);

        HttpResponse response = post(postUrl, user1, toJsonAsStringNonNull(d1), 201);
        Document documentResp = RestApiUtil.parseRestApiEntry(response.getJsonResponse(), Document.class);

        String dId = documentResp.getId();

        d1.setIsFolder(false);
        d1.setParentId(myNodeId);
        d1.setAspectNames(Collections.singletonList("cm:auditable"));

        d1.setCreatedByUser(expectedUser);
        d1.setModifiedByUser(expectedUser);

        d1.getContent().setMimeTypeName("Plain Text");
        d1.getContent().setSizeInBytes(0L);
        d1.getContent().setEncoding("UTF-8");

        d1.expected(documentResp);

        // update file - name (=> rename within current folder)

        Document dUpdate = new Document();
        dUpdate.setName("d1b.txt");

        response = put("nodes", user1, dId, toJsonAsStringNonNull(dUpdate), null, 200);
        documentResp = RestApiUtil.parseRestApiEntry(response.getJsonResponse(), Document.class);

        d1.setName("d1b.txt");
        d1.expected(documentResp);

        // update file - add some properties

        Map<String,Object> props = new HashMap<>();
        props.put("cm:title","my file title");
        props.put("cm:description","my file description");

        dUpdate = new Document();
        dUpdate.setProperties(props);

        response = put("nodes", user1, dId, toJsonAsStringNonNull(dUpdate), null, 200);
        documentResp = RestApiUtil.parseRestApiEntry(response.getJsonResponse(), Document.class);

        d1.setProperties(props);
        d1.setAspectNames(Arrays.asList("cm:auditable","cm:titled"));
        d1.expected(documentResp);

        // update file - add versionable aspect

        dUpdate = new Document();
        dUpdate.setAspectNames(Arrays.asList("cm:auditable","cm:titled","cm:versionable"));

        response = put("nodes", user1, dId, toJsonAsStringNonNull(dUpdate), null, 200);
        documentResp = RestApiUtil.parseRestApiEntry(response.getJsonResponse(), Document.class);

        //d1.getProperties().put("cm:versionLabel","1.0"); // TODO ... fix api ?!
        d1.setAspectNames(Arrays.asList("cm:auditable","cm:titled","cm:versionable"));
        d1.expected(documentResp);

        response = getSingle("nodes", user1, dId, 200);
        documentResp = RestApiUtil.parseRestApiEntry(response.getJsonResponse(), Document.class);

        d1.getProperties().put("cm:versionLabel","1.0");
        d1.expected(documentResp);

        // update file - remove titled aspect (and it's related aspect properties)

        dUpdate = new Document();
        dUpdate.setAspectNames(Arrays.asList("cm:auditable","cm:versionable"));

        response = put("nodes", user1, dId, toJsonAsStringNonNull(dUpdate), null, 200);
        documentResp = RestApiUtil.parseRestApiEntry(response.getJsonResponse(), Document.class);

        d1.getProperties().remove("cm:title");
        d1.getProperties().remove("cm:description");
        d1.setAspectNames(Arrays.asList("cm:auditable","cm:versionable"));
        d1.expected(documentResp);

        // update folder - rename and add some properties

        props = new HashMap<>();
        props.put("cm:title","my folder title");
        props.put("cm:description","my folder description");

        folderName = "My Updated Folder";
        Folder fUpdate = new Folder();
        fUpdate.setProperties(props);
        fUpdate.setName(folderName);

        response = put("nodes", user1, fId, toJsonAsStringNonNull(fUpdate), null, 200);
        folderResp = RestApiUtil.parseRestApiEntry(response.getJsonResponse(), Folder.class);

        f1.setName(folderName);
        f1.setAspectNames(Arrays.asList("cm:auditable","cm:titled"));
        f1.setProperties(props);
        f1.expected(folderResp);

        // update folder - unset a property

        props = new HashMap<>();
        props.put("cm:title",null);

        fUpdate = new Folder();
        fUpdate.setProperties(props);

        response = put("nodes", user1, fId, toJsonAsStringNonNull(fUpdate), null, 200);
        folderResp = RestApiUtil.parseRestApiEntry(response.getJsonResponse(), Folder.class);

        f1.getProperties().remove("cm:title");
        f1.expected(folderResp);

        // update folder - specialise node type

        fUpdate = new Folder();
        fUpdate.setNodeType("app:glossary");

        response = put("nodes", user1, fId, toJsonAsStringNonNull(fUpdate), null, 200);
        folderResp = RestApiUtil.parseRestApiEntry(response.getJsonResponse(), Folder.class);

        f1.setNodeType("app:glossary");
        f1.expected(folderResp);

        // -ve test - fail on unknown property
        props = new HashMap<>();
        props.put("cm:xyz","my unknown property");
        dUpdate = new Document();
        dUpdate.setProperties(props);
        put("nodes", user1, dId, toJsonAsStringNonNull(dUpdate), null, 400);

        // -ve test - fail on unknown aspect
        List<String> aspects = new ArrayList<>(d1.getAspectNames());
        aspects.add("cm:unknownAspect");
        dUpdate = new Document();
        dUpdate.setAspectNames(aspects);
        put("nodes", user1, dId, toJsonAsStringNonNull(dUpdate), null, 400);

        // -ve test - duplicate name
        dUpdate = new Document();
        dUpdate.setName(folderName);
        put("nodes", user1, dId, toJsonAsStringNonNull(dUpdate), null, 409);

        // -ve test - unknown node id
        dUpdate = new Document();
        dUpdate.setName("some.txt");
        put("nodes", user1, UUID.randomUUID().toString(), toJsonAsStringNonNull(dUpdate), null, 404);

        // -ve test - generalise node type
        fUpdate = new Folder();
        fUpdate.setNodeType("cm:folder");
        put("nodes", user1, fId, toJsonAsStringNonNull(fUpdate), null, 400);

        // -ve test - try to move to a different parent using PUT (note: should use new POST /nodes/{nodeId}/move operation instead)

        folderResp = createFolder(user1, myNodeId, "folder 2");
        String f2Id = folderResp.getId();

        fUpdate = new Folder();
        fUpdate.setParentId(f2Id);
        put("nodes", user1, fId, toJsonAsStringNonNull(fUpdate), null, 400);

        // ok - if parent does not change
        fUpdate = new Folder();
        fUpdate.setParentId(myNodeId);
        put("nodes", user1, fId, toJsonAsStringNonNull(fUpdate), null, 200);
    }

    /**
     * Tests update owner (file or folder)
     * <p>PUT:</p>
     * {@literal <host>:<port>/alfresco/api/-default-/public/alfresco/versions/1/nodes/<nodeId>}
     */
    @Test
    public void testUpdateOwner() throws Exception
    {
        AuthenticationUtil.setFullyAuthenticatedUser(user1);

        // create folder f1
        String folderName = "f1 "+System.currentTimeMillis();
        Folder folderResp = createFolder(user1, Nodes.PATH_SHARED, folderName);
        String f1Id = folderResp.getId();

        assertNull(user1, folderResp.getProperties()); // owner is implied

        // explicitly set owner to oneself
        Map<String, Object> props = new HashMap<>();
        props.put(PROP_OWNER, user1);
        Folder fUpdate = new Folder();
        fUpdate.setProperties(props);

        HttpResponse response = put("nodes", user1, f1Id, toJsonAsStringNonNull(fUpdate), null, 200);
        folderResp = jacksonUtil.parseEntry(response.getJsonResponse(), Folder.class);

        assertEquals(user1, ((Map)folderResp.getProperties().get(PROP_OWNER)).get("id"));

        // create doc d1
        NodeRef f1Ref = new NodeRef(StoreRef.STORE_REF_WORKSPACE_SPACESSTORE, f1Id);
        String d1Name = "content1 " + System.currentTimeMillis();
        NodeRef d1Ref = repoService.createDocument(f1Ref, d1Name, "The quick brown fox jumps over the lazy dog.");
        String d1Id = d1Ref.getId();

        // get node info
        response = getSingle(NodesEntityResource.class, user1, d1Id, null, 200);
        Document documentResp = jacksonUtil.parseEntry(response.getJsonResponse(), Document.class);

        assertNull(user1, documentResp.getProperties()); // owner is implied

        props = new HashMap<>();
        props.put(PROP_OWNER, user1);
        Document dUpdate = new Document();
        dUpdate.setProperties(props);

        response = put("nodes", user1, d1Id, toJsonAsStringNonNull(dUpdate), null, 200);
        documentResp = jacksonUtil.parseEntry(response.getJsonResponse(), Document.class);

        assertEquals(user1, ((Map)documentResp.getProperties().get(PROP_OWNER)).get("id"));

        // -ve test - cannot set owner to a nonexistent user

        props = new HashMap<>();
        props.put(PROP_OWNER, "unknownusernamedoesnotexist");
        dUpdate = new Document();
        dUpdate.setProperties(props);

        put("nodes", user1, d1Id, toJsonAsStringNonNull(dUpdate), null, 400);

        AuthenticationUtil.setFullyAuthenticatedUser(user2);

        response = getSingle("nodes", user1, d1Id, 200);
        documentResp = RestApiUtil.parseRestApiEntry(response.getJsonResponse(), Document.class);

        assertEquals(user1, ((Map)documentResp.getProperties().get(PROP_OWNER)).get("id"));

        // -ve test - cannot take/change ownership

        props = new HashMap<>();
        props.put(PROP_OWNER, user2);
        dUpdate = new Document();
        dUpdate.setProperties(props);

        put("nodes", user2, d1Id, toJsonAsStringNonNull(dUpdate), null, 403);

        props = new HashMap<>();
        props.put(PROP_OWNER, user1);
        dUpdate = new Document();
        dUpdate.setProperties(props);

        put("nodes", user2, d1Id, toJsonAsStringNonNull(dUpdate), null, 403);

        AuthenticationUtil.setFullyAuthenticatedUser(user1);

        props = new HashMap<>();
        props.put(PROP_OWNER, user2);
        dUpdate = new Document();
        dUpdate.setProperties(props);

        response = put("nodes", user1, d1Id, toJsonAsStringNonNull(dUpdate), null, 200);
        documentResp = jacksonUtil.parseEntry(response.getJsonResponse(), Document.class);

        assertEquals(user2, ((Map)documentResp.getProperties().get(PROP_OWNER)).get("id"));

        AuthenticationUtil.setFullyAuthenticatedUser(user2);

        response = getSingle("nodes", user2, d1Id, 200);
        documentResp = RestApiUtil.parseRestApiEntry(response.getJsonResponse(), Document.class);

        assertEquals(user2, ((Map)documentResp.getProperties().get(PROP_OWNER)).get("id"));

        // -ve test - user2 cannot delete the test folder/file - TODO is that expected ?
        delete("nodes", user2, f1Id, 403);

        AuthenticationUtil.setFullyAuthenticatedUser(user1);

        delete("nodes", user1, f1Id, 204);
    }


    /**
     * Tests update file content
     * <p>PUT:</p>
     * {@literal <host>:<port>/alfresco/api/-default-/public/alfresco/versions/1/nodes/<nodeId>/content}
     */
    @Test
    public void testUpdateFileWithBinaryUpload() throws Exception
    {
        AuthenticationUtil.setFullyAuthenticatedUser(user1);

        String myNodeId = getMyNodeId(user1);
        NodeRef myFilesNodeRef = new NodeRef(StoreRef.STORE_REF_WORKSPACE_SPACESSTORE, myNodeId);

        Folder f1 = new Folder();
        f1.setName("F1");
        f1.setNodeType("cm:folder");

        HttpResponse response = post(getChildrenUrl(myFilesNodeRef), user1, toJsonAsStringNonNull(f1), 201);
        Folder folderResp = RestApiUtil.parseRestApiEntry(response.getJsonResponse(), Folder.class);
        assertEquals(f1.getName(), folderResp.getName());
        final String f1_nodeId = folderResp.getId();
        assertNotNull(f1_nodeId);

        Document doc = new Document();
        final String docName = "testdoc";
        doc.setName(docName);
        doc.setNodeType("cm:content");
        doc.setProperties(Collections.singletonMap("cm:title", (Object)"test title"));
        ContentInfo contentInfo = new ContentInfo();
        contentInfo.setMimeType(MimetypeMap.MIMETYPE_TEXT_PLAIN);
        doc.setContent(contentInfo);

        // create an empty file within F1 folder
        response = post(getChildrenUrl(f1_nodeId), user1, toJsonAsStringNonNull(doc), 201);
        Document docResp = RestApiUtil.parseRestApiEntry(response.getJsonResponse(), Document.class);
        assertEquals(docName, docResp.getName());
        assertNotNull(docResp.getContent());
        assertEquals(0, docResp.getContent().getSizeInBytes().intValue());
        assertEquals(MimetypeMap.MIMETYPE_TEXT_PLAIN, docResp.getContent().getMimeType());

        // Update content & Download URL
        final String url = URL_NODES + docResp.getId() + "/content";

        // Update the empty node's content
        String content = "The quick brown fox jumps over the lazy dog.";
        ByteArrayInputStream inputStream = new ByteArrayInputStream(content.getBytes());
        File txtFile = TempFileProvider.createTempFile(inputStream, getClass().getSimpleName(), ".txt");
        BinaryPayload payload = new BinaryPayload(txtFile, MimetypeMap.MIMETYPE_TEXT_PLAIN);

        // Try to update a folder!
        putBinary(URL_NODES + f1_nodeId + "/content", user1, payload, null, null, 400);

        // Try to update a non-existent file
        putBinary(URL_NODES + UUID.randomUUID().toString() + "/content", user1, payload, null, null, 404);

        // Update the empty file
        response = putBinary(url, user1, payload, null, null, 200);
        docResp = RestApiUtil.parseRestApiEntry(response.getJsonResponse(), Document.class);
        assertEquals(docName, docResp.getName());
        assertNotNull(docResp.getId());
        assertNotNull(docResp.getCreatedAt());
        assertNotNull(docResp.getCreatedByUser());
        assertNotNull(docResp.getModifiedAt());
        assertNotNull(docResp.getModifiedByUser());
        assertFalse(docResp.getIsFolder());
        assertTrue(docResp.getIsFile());
        assertNull(docResp.getIsLink());
        assertEquals("cm:content", docResp.getNodeType());
        assertNotNull(docResp.getParentId());
        assertEquals(f1_nodeId, docResp.getParentId());
        assertNotNull(docResp.getProperties());
        assertNotNull(docResp.getAspectNames());
        contentInfo = docResp.getContent();
        assertNotNull(contentInfo);
        assertNotNull(contentInfo.getEncoding());
        // Default encoding
        assertEquals("UTF-8", contentInfo.getEncoding());
        assertTrue(contentInfo.getSizeInBytes() > 0);
        assertEquals(MimetypeMap.MIMETYPE_TEXT_PLAIN, contentInfo.getMimeType());
        assertNotNull(contentInfo.getMimeTypeName());
        // path is not part of the default response
        assertNull(docResp.getPath());

        // Download the file
        response = getSingle(url, user1, null, 200);
        assertEquals(content, response.getResponse());

        // Update the node's content again. Also, change the mimeType and make the response to return path!
        File pdfFile = getResourceFile("quick.pdf");
        payload = new BinaryPayload(pdfFile, MimetypeMap.MIMETYPE_PDF, "ISO-8859-1");

        response = putBinary(url + "?select=path", user1, payload, null, null, 200);
        docResp = jacksonUtil.parseEntry(response.getJsonResponse(), Document.class);
        assertEquals(docName, docResp.getName());
        assertNotNull(docResp.getContent());
        assertEquals("ISO-8859-1", docResp.getContent().getEncoding());
        assertTrue(docResp.getContent().getSizeInBytes().intValue() > 0);
        assertEquals(MimetypeMap.MIMETYPE_PDF, docResp.getContent().getMimeType());
        PathInfo pathInfo = docResp.getPath();
        assertNotNull(pathInfo);
        assertTrue(pathInfo.getIsComplete());
        List<ElementInfo> pathElements = pathInfo.getElements();
        assertNotNull(pathElements);
        assertTrue(pathElements.size() > 0);
        // check the last element is F1
        assertEquals(f1.getName(), pathElements.get(pathElements.size() - 1).getName());

        // update the original content with different encoding
        payload = new BinaryPayload(txtFile, MimetypeMap.MIMETYPE_TEXT_PLAIN, "ISO-8859-15");
        response = putBinary(url, user1, payload, null, null, 200);
        docResp = jacksonUtil.parseEntry(response.getJsonResponse(), Document.class);
        assertEquals(docName, docResp.getName());
        assertNotNull(docResp.getContent());
        assertEquals("ISO-8859-15", docResp.getContent().getEncoding());
        assertTrue(docResp.getContent().getSizeInBytes().intValue() > 0);
        assertEquals(MimetypeMap.MIMETYPE_TEXT_PLAIN, docResp.getContent().getMimeType());

        // Download the file
        response = getSingle(url, user1, null, 200);
        assertNotNull(content, response.getResponse());
    }

    /**
     * Tests download of file/content.
     * <p>GET:</p>
     * {@literal <host>:<port>/alfresco/api/-default-/public/alfresco/versions/1/nodes/<nodeId>/content}
     */
    @Test
    public void testDownloadFileContent() throws Exception
    {
        //
        // Test plain text
        //

        String fileName = "quick-1.txt";
        File file = getResourceFile(fileName);

        MultiPartBuilder multiPartBuilder = MultiPartBuilder.create()
                .setFileData(new FileData(fileName, file, MimetypeMap.MIMETYPE_TEXT_PLAIN));
        MultiPartRequest reqBody = multiPartBuilder.build();

        // Upload text content
        HttpResponse response = post(getChildrenUrl(Nodes.PATH_MY), user1, reqBody.getBody(), null, reqBody.getContentType(), 201);
        Document document = jacksonUtil.parseEntry(response.getJsonResponse(), Document.class);

        String contentNodeId = document.getId();

        // Check the upload response
        assertEquals(fileName, document.getName());
        ContentInfo contentInfo = document.getContent();
        assertNotNull(contentInfo);
        assertEquals(MimetypeMap.MIMETYPE_TEXT_PLAIN, contentInfo.getMimeType());

        // Download text content - by default with Content-Disposition header
        response = getSingle(NodesEntityResource.class, user1, contentNodeId+"/content", null, 200);

        String textContent = response.getResponse();
        assertEquals("The quick brown fox jumps over the lazy dog", textContent);
        assertEquals("attachment; filename=\"quick-1.txt\"; filename*=UTF-8''quick-1.txt", response.getHeaders().get("Content-Disposition"));


        //
        // Test binary (eg. PDF)
        //

        fileName = "quick.pdf";
        file = getResourceFile(fileName);
        byte[] originalBytes = Files.readAllBytes(Paths.get(file.getAbsolutePath()));

        multiPartBuilder = MultiPartBuilder.create()
                .setFileData(new FileData(fileName, file, MimetypeMap.MIMETYPE_PDF));
        reqBody = multiPartBuilder.build();

        // Upload binary content
        response = post(getChildrenUrl(Nodes.PATH_MY), user1, reqBody.getBody(), null, reqBody.getContentType(), 201);
        document = jacksonUtil.parseEntry(response.getJsonResponse(), Document.class);

        contentNodeId = document.getId();

        // Check the upload response
        assertEquals(fileName, document.getName());
        contentInfo = document.getContent();
        assertNotNull(contentInfo);
        assertEquals(MimetypeMap.MIMETYPE_PDF, contentInfo.getMimeType());

        // Download binary content (as bytes) - without Content-Disposition header (attachment=false)
        Map<String, String> params = new LinkedHashMap<>();
        params.put("attachment", "false");

        response = getSingle(NodesEntityResource.class, user1, contentNodeId+"/content", params, 200);

        byte[] bytes = response.getResponseAsBytes();

        assertArrayEquals(originalBytes, bytes);
        assertNull(response.getHeaders().get("Content-Disposition"));
    }

    private String getChildrenUrl(NodeRef parentNodeRef)
    {
        return getChildrenUrl(parentNodeRef.getId());
    }

    private String getChildrenUrl(String parentId)
    {
        return URL_NODES + parentId + "/children";
    }

    @Override
    public String getScope()
    {
        return "public";
    }
}