trunk/chemistry-opencmis-test/chemistry-opencmis-test-tck/src/main/java/org/apache/chemistry/opencmis/tck/tests/crud/ChangeTokenTest.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.chemistry.opencmis.tck.tests.crud;

import static org.apache.chemistry.opencmis.tck.CmisTestResultStatus.FAILURE;
import static org.apache.chemistry.opencmis.tck.CmisTestResultStatus.INFO;
import static org.apache.chemistry.opencmis.tck.CmisTestResultStatus.SKIPPED;
import static org.apache.chemistry.opencmis.tck.CmisTestResultStatus.WARNING;

import java.io.ByteArrayInputStream;
import java.math.BigInteger;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.chemistry.opencmis.client.api.Document;
import org.apache.chemistry.opencmis.client.api.Folder;
import org.apache.chemistry.opencmis.client.api.ObjectId;
import org.apache.chemistry.opencmis.client.api.Session;
import org.apache.chemistry.opencmis.commons.PropertyIds;
import org.apache.chemistry.opencmis.commons.data.ContentStream;
import org.apache.chemistry.opencmis.commons.definitions.DocumentTypeDefinition;
import org.apache.chemistry.opencmis.commons.definitions.PropertyDefinition;
import org.apache.chemistry.opencmis.commons.enums.Action;
import org.apache.chemistry.opencmis.commons.enums.CapabilityContentStreamUpdates;
import org.apache.chemistry.opencmis.commons.enums.Updatability;
import org.apache.chemistry.opencmis.commons.exceptions.CmisUpdateConflictException;
import org.apache.chemistry.opencmis.commons.impl.IOUtils;
import org.apache.chemistry.opencmis.commons.impl.dataobjects.ContentStreamImpl;
import org.apache.chemistry.opencmis.tck.impl.AbstractSessionTest;

public class ChangeTokenTest extends AbstractSessionTest {

    @Override
    public void init(Map<String, String> parameters) {
        super.init(parameters);
        setName("Change Token Test");
        setDescription("Creates a document and a folder and updates them with an outdated change token.");
    }

    @Override
    public void run(Session session) {
        // create a test folder
        Folder testFolder = createTestFolder(session);

        try {
            // update document properties test
            runUpdateDocumentTest(session, testFolder);

            // content update test
            runContentTest(session, testFolder);

            // update folder properties test
            runUpdateFolderTest(session, testFolder);

            // add child and update folder properties test
            runAddChildFolderTest(session, testFolder);
        } finally {
            // delete the test folder
            deleteTestFolder();
        }
    }

    private void runUpdateDocumentTest(Session session, Folder testFolder) {
        Document doc = createDocument(session, testFolder, "update1.txt", "Hello World!");

        try {
            if (doc.getChangeToken() == null) {
                addResult(createResult(SKIPPED,
                        "Repository does not provide change tokens for documents. Test skipped!"));
                return;
            }

            DocumentTypeDefinition type = (DocumentTypeDefinition) doc.getType();
            PropertyDefinition<?> namePropDef = type.getPropertyDefinitions().get(PropertyIds.NAME);
            if (namePropDef.getUpdatability() == Updatability.WHENCHECKEDOUT
                    || !doc.getAllowableActions().getAllowableActions().contains(Action.CAN_UPDATE_PROPERTIES)) {
                addResult(createResult(SKIPPED, "Document name can't be changed. Test skipped!"));
                return;
            }

            // the first update should succeed
            Map<String, Object> properties2 = new HashMap<String, Object>();
            properties2.put(PropertyIds.NAME, "update2.txt");
            ObjectId newId = doc.updateProperties(properties2, false);

            if (!doc.getId().equals(newId.getId())) {
                // the repository created a new version
                // -> a change token test does not make sense
                addResult(createResult(INFO,
                        "The repository created a new version. Change tokens are not relevant here."));
            } else {
                try {
                    Map<String, Object> properties3 = new HashMap<String, Object>();
                    properties3.put(PropertyIds.NAME, "update3.txt");
                    doc.updateProperties(properties3, false);

                    addResult(createResult(FAILURE, "Updating properties a second time with the same change token "
                            + "should result in an UpdateConflict exception!"));
                } catch (CmisUpdateConflictException e) {
                    // expected exception
                }
            }
        } finally {
            deleteObject(doc);
        }
    }

    private void runContentTest(Session session, Folder testFolder) {
        if (session.getRepositoryInfo().getCapabilities().getContentStreamUpdatesCapability() != CapabilityContentStreamUpdates.ANYTIME) {
            addResult(createResult(SKIPPED, "Repository doesn't allow to replace content. Test skipped!"));
            return;
        }

        Document doc = createDocument(session, testFolder, "content1.txt", "Hello World!");

        try {
            if (doc.getChangeToken() == null) {
                addResult(createResult(SKIPPED,
                        "Repository does not provide change tokens for documents. Test skipped!"));
                return;
            }

            if (!doc.getAllowableActions().getAllowableActions().contains(Action.CAN_SET_CONTENT_STREAM)) {
                addResult(createResult(SKIPPED, "Document content can't be changed. Test skipped!"));
                return;
            }

            byte[] contentBytes = IOUtils.toUTF8Bytes("New content");
            ContentStream contentStream = new ContentStreamImpl("content2.txt",
                    BigInteger.valueOf(contentBytes.length), "text/plain", new ByteArrayInputStream(contentBytes));

            ObjectId newId = doc.setContentStream(contentStream, true, false);

            if (newId == null) {
                // the AtomPub binding does not return an id here
                // -> get the latest id from the version series
                if (Boolean.TRUE.equals(((DocumentTypeDefinition) doc.getType()).isVersionable())) {
                    List<Document> versions = doc.getAllVersions();
                    if (versions == null || versions.size() < 1) {
                        addResult(createResult(FAILURE, "Repository returned an empty list of document versions!"));
                    } else {
                        // the latest document is at the top of the list
                        newId = versions.get(0);
                    }
                } else {
                    // the document type is not versionable
                    // -> the repository couldn't create a new version
                    newId = doc;
                }
            }

            if (newId != null) {
                if (!doc.getId().equals(newId.getId())) {
                    // the repository created a new version
                    // -> a change token test does not make sense
                    addResult(createResult(INFO,
                            "The repository created a new version. Change tokens are not relevant here."));
                } else {
                    try {
                        doc.setContentStream(contentStream, true, false);

                        addResult(createResult(FAILURE, "Updating content a second time with the same change token "
                                + "should result in an UpdateConflict exception!"));
                    } catch (CmisUpdateConflictException uce) {
                        // expected exception
                    }
                }
            }
        } finally {
            deleteObject(doc);
        }
    }

    private void runUpdateFolderTest(Session session, Folder testFolder) {
        Folder folder = createFolder(session, testFolder, "folder1");

        try {
            if (folder.getChangeToken() == null) {
                addResult(createResult(SKIPPED, "Repository does not provide change tokens for folders. Test skipped!"));
                return;
            }

            if (!folder.getAllowableActions().getAllowableActions().contains(Action.CAN_UPDATE_PROPERTIES)) {
                addResult(createResult(SKIPPED, "Folder name can't be changed. Test skipped!"));
                return;
            }

            // the first update should succeed
            Map<String, Object> properties2 = new HashMap<String, Object>();
            properties2.put(PropertyIds.NAME, "folder2");
            folder.updateProperties(properties2, false);

            try {
                Map<String, Object> properties3 = new HashMap<String, Object>();
                properties3.put(PropertyIds.NAME, "folder3");
                folder.updateProperties(properties3, false);

                addResult(createResult(FAILURE, "Updating properties a second time with the same change token "
                        + "should result in an UpdateConflict exception!"));
            } catch (CmisUpdateConflictException e) {
                // expected exception
            }

        } finally {
            deleteObject(folder);
        }
    }

    private void runAddChildFolderTest(Session session, Folder testFolder) {
        Folder folder = createFolder(session, testFolder, "folder1");

        try {
            if (folder.getChangeToken() == null) {
                addResult(createResult(SKIPPED, "Repository does not provide change tokens for folders. Test skipped!"));
                return;
            }

            if (!folder.getAllowableActions().getAllowableActions().contains(Action.CAN_UPDATE_PROPERTIES)) {
                addResult(createResult(SKIPPED, "Folder name can't be changed. Test skipped!"));
                return;
            }

            createDocument(session, folder, "doc1", "content");

            try {
                Map<String, Object> properties2 = new HashMap<String, Object>();
                properties2.put(PropertyIds.NAME, "folder2");
                folder.updateProperties(properties2, false);
            } catch (CmisUpdateConflictException e) {
                addResult(createResult(WARNING, "Adding a child to a folder changes the change token of the folder. "
                        + "CMIS clients might not expect that."));
            }

        } finally {
            deleteObject(folder);
        }
    }
}