/*
* 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.client.bindings.framework;
import junit.framework.TestCase;
import org.apache.chemistry.opencmis.commons.PropertyIds;
import org.apache.chemistry.opencmis.commons.data.Ace;
import org.apache.chemistry.opencmis.commons.data.Acl;
import org.apache.chemistry.opencmis.commons.data.AllowableActions;
import org.apache.chemistry.opencmis.commons.data.ContentStream;
import org.apache.chemistry.opencmis.commons.data.ExtensionsData;
import org.apache.chemistry.opencmis.commons.data.ObjectData;
import org.apache.chemistry.opencmis.commons.data.ObjectInFolderData;
import org.apache.chemistry.opencmis.commons.data.ObjectInFolderList;
import org.apache.chemistry.opencmis.commons.data.ObjectParentData;
import org.apache.chemistry.opencmis.commons.data.Properties;
import org.apache.chemistry.opencmis.commons.data.PropertyData;
import org.apache.chemistry.opencmis.commons.data.PropertyDateTime;
import org.apache.chemistry.opencmis.commons.data.PropertyId;
import org.apache.chemistry.opencmis.commons.data.PropertyString;
import org.apache.chemistry.opencmis.commons.data.RenditionData;
import org.apache.chemistry.opencmis.commons.data.RepositoryInfo;
import org.apache.chemistry.opencmis.commons.definitions.DocumentTypeDefinition;
import org.apache.chemistry.opencmis.commons.definitions.PropertyDefinition;
import org.apache.chemistry.opencmis.commons.definitions.TypeDefinition;
import org.apache.chemistry.opencmis.commons.enums.AclPropagation;
import org.apache.chemistry.opencmis.commons.enums.Action;
import org.apache.chemistry.opencmis.commons.enums.CapabilityAcl;
import org.apache.chemistry.opencmis.commons.enums.CapabilityChanges;
import org.apache.chemistry.opencmis.commons.enums.CapabilityQuery;
import org.apache.chemistry.opencmis.commons.enums.CapabilityRenditions;
import org.apache.chemistry.opencmis.commons.enums.IncludeRelationships;
import org.apache.chemistry.opencmis.commons.enums.UnfileObject;
import org.apache.chemistry.opencmis.commons.enums.VersioningState;
import org.apache.chemistry.opencmis.commons.exceptions.CmisObjectNotFoundException;
import org.apache.chemistry.opencmis.commons.spi.BindingsObjectFactory;
import org.apache.chemistry.opencmis.commons.spi.CmisBinding;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.InputStream;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.Set;
/**
* Base test case for CMIS tests.
*
* @author <a href="mailto:fmueller@opentext.com">Florian Müller</a>
*
*/
public abstract class AbstractCmisTestCase extends TestCase {
public static final String DEFAULT_TESTS_ENABLED = "true";
public static final String DEFAULT_USERNAME = "admin";
public static final String DEFAULT_PASSWORD = "admin";
public static final String DEFAULT_ATOMPUB_URL = "http://localhost:8080/chemistry-opencmis-server-jcr/atom";
public static final String DEFAULT_WEBSERVICES_URLPREFIX = "http://localhost:8080/cmis/services/";
public static final String DEFAULT_DOCTYPE = "cmis:document";
public static final String DEFAULT_FOLDERTYPE = "cmis:folder";
public static final String PROP_TESTS_ENABLED = "opencmis.test";
public static final String PROP_USERNAME = "opencmis.test.username";
public static final String PROP_PASSWORD = "opencmis.test.password";
public static final String PROP_REPOSITORY = "opencmis.test.repository";
public static final String PROP_TESTFOLDER = "opencmis.test.testfolder";
public static final String PROP_DOCTYPE = "opencmis.test.documenttype";
public static final String PROP_FOLDERTYPE = "opencmis.test.foldertype";
public static final String PROP_CONFIG_FILE = "opencmis.test.config";
public static final String PROP_ATOMPUB_URL = "opencmis.test.atompub.url";
public static final String PROP_WEBSERVICES_URLPREFIX = "opencmis.test.webservices.url";
private CmisBinding binding;
private String fTestRepositoryId;
private String fTestFolderId;
private static final Log log = LogFactory.getLog(AbstractCmisTestCase.class);
/**
* Read configuration file.
*/
static {
String configFileName = System.getProperty(PROP_CONFIG_FILE);
if (configFileName != null) {
try {
java.util.Properties properties = new java.util.Properties();
properties.load(new FileInputStream(configFileName));
for (Enumeration<?> e = properties.propertyNames(); e.hasMoreElements();) {
String key = (String) e.nextElement();
String value = properties.getProperty(key);
System.setProperty(key, value);
}
} catch (Exception e) {
System.err.println("Could not load test properties: " + e.toString());
}
}
}
/**
* Returns the binding object or creates one if does not exist.
*/
protected CmisBinding getBinding() {
if (binding == null) {
log.info("Creating binding...");
binding = createBinding();
}
return binding;
}
/**
* Creates a binding object.
*/
protected abstract CmisBinding createBinding();
/**
* Returns a set of test names that enabled.
*/
protected abstract Set<String> getEnabledTests();
/**
* Returns the test repository id.
*/
protected String getTestRepositoryId() {
if (fTestRepositoryId != null) {
return fTestRepositoryId;
}
fTestRepositoryId = System.getProperty(PROP_REPOSITORY);
if (fTestRepositoryId != null) {
log.info("Test repository: " + fTestRepositoryId);
return fTestRepositoryId;
}
fTestRepositoryId = getFirstRepositoryId();
log.info("Test repository: " + fTestRepositoryId);
return fTestRepositoryId;
}
/**
* Returns the test root folder id.
*/
protected String getTestRootFolder() {
if (fTestFolderId != null) {
return fTestFolderId;
}
fTestFolderId = System.getProperty(PROP_TESTFOLDER);
if (fTestFolderId != null) {
log.info("Test root folder: " + fTestFolderId);
return fTestFolderId;
}
fTestFolderId = getRootFolderId();
log.info("Test root folder: " + fTestFolderId);
return fTestFolderId;
}
/**
* Returns if the test is enabled.
*/
protected boolean isEnabled(String name) {
boolean testsEnabled = Boolean.parseBoolean(System.getProperty(PROP_TESTS_ENABLED, DEFAULT_TESTS_ENABLED));
if (testsEnabled && getEnabledTests().contains(name)) {
return true;
}
log.info("Skipping test '" + name + "'!");
return false;
}
/**
* Returns the test username.
*/
protected String getUsername() {
return System.getProperty(PROP_USERNAME, DEFAULT_USERNAME);
}
/**
* Returns the test password.
*/
protected String getPassword() {
return System.getProperty(PROP_PASSWORD, DEFAULT_PASSWORD);
}
/**
* Returns the default document type.
*/
protected String getDefaultDocumentType() {
return System.getProperty(PROP_DOCTYPE, DEFAULT_DOCTYPE);
}
/**
* Returns the default folder type.
*/
protected String getDefaultFolderType() {
return System.getProperty(PROP_FOLDERTYPE, DEFAULT_FOLDERTYPE);
}
/**
* Returns the AtomPub URL.
*/
protected String getAtomPubURL() {
return System.getProperty(PROP_ATOMPUB_URL, DEFAULT_ATOMPUB_URL);
}
/**
* Returns the Web Services URL prefix.
*/
protected String getWebServicesURL() {
return System.getProperty(PROP_WEBSERVICES_URLPREFIX, DEFAULT_WEBSERVICES_URLPREFIX);
}
/**
* Returns the object factory.
*/
protected BindingsObjectFactory getObjectFactory() {
return getBinding().getObjectFactory();
}
/**
* Returns the id of the first repository.
*/
protected String getFirstRepositoryId() {
List<RepositoryInfo> repositories = getBinding().getRepositoryService().getRepositoryInfos(null);
assertNotNull(repositories);
assertFalse(repositories.isEmpty());
assertNotNull(repositories.get(0).getId());
return repositories.get(0).getId();
}
/**
* Returns the info object of the test repository.
*/
protected RepositoryInfo getRepositoryInfo() {
RepositoryInfo repositoryInfo = getBinding().getRepositoryService().getRepositoryInfo(getTestRepositoryId(),
null);
assertNotNull(repositoryInfo);
assertNotNull(repositoryInfo.getId());
assertEquals(getTestRepositoryId(), repositoryInfo.getId());
return repositoryInfo;
}
/**
* Returns the root folder of the test repository.
*/
protected String getRootFolderId() {
RepositoryInfo repository = getRepositoryInfo();
assertNotNull(repository.getRootFolderId());
return repository.getRootFolderId();
}
/**
* Returns if the test repository supports reading ACLs.
*/
protected boolean supportsDiscoverACLs() {
RepositoryInfo repository = getRepositoryInfo();
assertNotNull(repository.getCapabilities());
return repository.getCapabilities().getAclCapability() != CapabilityAcl.NONE;
}
/**
* Returns if the test repository supports setting ACLs.
*/
protected boolean supportsManageACLs() {
RepositoryInfo repository = getRepositoryInfo();
assertNotNull(repository.getCapabilities());
return repository.getCapabilities().getAclCapability() == CapabilityAcl.MANAGE;
}
/**
* Returns if the test repository supports renditions.
*/
protected boolean supportsRenditions() {
RepositoryInfo repository = getRepositoryInfo();
assertNotNull(repository.getCapabilities());
if (repository.getCapabilities().getRenditionsCapability() == null) {
return false;
}
return repository.getCapabilities().getRenditionsCapability() != CapabilityRenditions.NONE;
}
/**
* Returns if the test repository supports descendants.
*/
protected boolean supportsDescendants() {
RepositoryInfo repository = getRepositoryInfo();
assertNotNull(repository.getCapabilities());
if (repository.getCapabilities().isGetDescendantsSupported() == null) {
return false;
}
return repository.getCapabilities().isGetDescendantsSupported();
}
/**
* Returns if the test repository supports descendants.
*/
protected boolean supportsFolderTree() {
RepositoryInfo repository = getRepositoryInfo();
assertNotNull(repository.getCapabilities());
if (repository.getCapabilities().isGetFolderTreeSupported() == null) {
return false;
}
return repository.getCapabilities().isGetFolderTreeSupported();
}
/**
* Returns if the test repository supports content changes.
*/
protected boolean supportsContentChanges() {
RepositoryInfo repository = getRepositoryInfo();
assertNotNull(repository.getCapabilities());
if (repository.getCapabilities().getChangesCapability() == null) {
return false;
}
return repository.getCapabilities().getChangesCapability() != CapabilityChanges.NONE;
}
/**
* Returns if the test repository supports query.
*/
protected boolean supportsQuery() {
RepositoryInfo repository = getRepositoryInfo();
assertNotNull(repository.getCapabilities());
if (repository.getCapabilities().getQueryCapability() == null) {
return false;
}
return repository.getCapabilities().getQueryCapability() != CapabilityQuery.NONE;
}
/**
* Returns if the test repository supports relationships.
*/
protected boolean supportsRelationships() {
TypeDefinition relType = null;
try {
relType = getBinding().getRepositoryService().getTypeDefinition(getTestRepositoryId(), "cmis:relationship",
null);
} catch (CmisObjectNotFoundException e) {
return false;
}
return relType != null;
}
/**
* Returns if the test repository supports policies.
*/
protected boolean supportsPolicies() {
TypeDefinition relType = null;
try {
relType = getBinding().getRepositoryService().getTypeDefinition(getTestRepositoryId(), "cmis:policy", null);
} catch (CmisObjectNotFoundException e) {
return false;
}
return relType != null;
}
/**
* Returns the AclPropagation from the ACL capabilities.
*/
protected AclPropagation getAclPropagation() {
RepositoryInfo repository = getRepositoryInfo();
assertNotNull(repository.getCapabilities());
if (repository.getAclCapabilities().getAclPropagation() == null) {
return AclPropagation.REPOSITORYDETERMINED;
}
return repository.getAclCapabilities().getAclPropagation();
}
// ---- helpers ----
/**
* Prints a warning.
*/
protected void warning(String message) {
System.out.println("**** " + message);
}
/**
* Creates a ContentStreamData object from a byte array.
*/
protected ContentStream createContentStreamData(String mimeType, byte[] content) {
assertNotNull(content);
return getObjectFactory().createContentStream("test", BigInteger.valueOf(content.length), mimeType,
new ByteArrayInputStream(content));
}
/**
* Extracts the path from a folder object.
*/
protected String getPath(ObjectData folderObject) {
assertNotNull(folderObject);
assertNotNull(folderObject.getProperties());
assertNotNull(folderObject.getProperties().getProperties());
assertTrue(folderObject.getProperties().getProperties().get(PropertyIds.PATH) instanceof PropertyString);
PropertyString pathProperty = (PropertyString) folderObject.getProperties().getProperties().get(
PropertyIds.PATH);
assertNotNull(pathProperty.getValues());
assertEquals(1, pathProperty.getValues().size());
assertNotNull(pathProperty.getValues().get(0));
return pathProperty.getValues().get(0);
}
// ---- short cuts ----
/**
* Retrieves an object.
*/
protected ObjectData getObject(String objectId, String filter, Boolean includeAllowableActions,
IncludeRelationships includeRelationships, String renditionFilter, Boolean includePolicyIds,
Boolean includeACL, ExtensionsData extension) {
ObjectData object = getBinding().getObjectService()
.getObject(getTestRepositoryId(), objectId, filter, includeAllowableActions, includeRelationships,
renditionFilter, includePolicyIds, includeACL, extension);
assertNotNull(object);
return object;
}
/**
* Retrieves a full blown object.
*/
protected ObjectData getObject(String objectId) {
ObjectData object = getObject(objectId, "*", Boolean.TRUE, IncludeRelationships.BOTH, null, Boolean.TRUE,
Boolean.TRUE, null);
assertBasicProperties(object.getProperties());
return object;
}
/**
* Retrieves an object by path.
*/
protected ObjectData getObjectByPath(String path, String filter, Boolean includeAllowableActions,
IncludeRelationships includeRelationships, String renditionFilter, Boolean includePolicyIds,
Boolean includeACL, ExtensionsData extension) {
ObjectData object = getBinding().getObjectService()
.getObjectByPath(getTestRepositoryId(), path, filter, includeAllowableActions, includeRelationships,
renditionFilter, includePolicyIds, includeACL, extension);
assertNotNull(object);
return object;
}
/**
* Retrieves a full blown object by path.
*/
protected ObjectData getObjectByPath(String path) {
ObjectData object = getObjectByPath(path, "*", Boolean.TRUE, IncludeRelationships.BOTH, null, Boolean.TRUE,
Boolean.TRUE, null);
assertBasicProperties(object.getProperties());
return object;
}
/**
* Returns <code>true</code> if the object with the given id exists,
* <code>false</code> otherwise.
*/
protected boolean existsObject(String objectId) {
try {
ObjectData object = getObject(objectId, PropertyIds.OBJECT_ID, Boolean.FALSE, IncludeRelationships.NONE,
null, Boolean.FALSE, Boolean.FALSE, null);
assertNotNull(object);
assertNotNull(object.getId());
} catch (CmisObjectNotFoundException e) {
return false;
}
return true;
}
/**
* Returns the child of a folder.
*/
protected ObjectInFolderData getChild(String folderId, String objectId) {
boolean hasMore = true;
while (hasMore) {
ObjectInFolderList children = getBinding().getNavigationService().getChildren(getTestRepositoryId(),
folderId, "*", null, Boolean.TRUE, IncludeRelationships.BOTH, null, Boolean.TRUE, null, null, null);
assertNotNull(children);
assertTrue(children.getObjects().size() > 0);
hasMore = (children.hasMoreItems() == null ? false : children.hasMoreItems().booleanValue());
for (ObjectInFolderData object : children.getObjects()) {
assertNotNull(object);
assertNotNull(object.getPathSegment());
assertNotNull(object.getObject());
assertNotNull(object.getObject().getId());
assertBasicProperties(object.getObject().getProperties());
if (object.getObject().getId().equals(objectId)) {
return object;
}
}
}
fail("Child not found!");
return null;
}
/**
* Gets the version series id of an object.
*/
protected String getVersionSeriesId(ObjectData object) {
PropertyData<?> versionSeriesId = object.getProperties().getProperties().get(PropertyIds.VERSION_SERIES_ID);
assertNotNull(versionSeriesId);
assertTrue(versionSeriesId instanceof PropertyId);
return ((PropertyId) versionSeriesId).getFirstValue();
}
/**
* Gets the version series id of an object.
*/
protected String getVersionSeriesId(String docId) {
return getVersionSeriesId(getObject(docId));
}
/**
* Creates a folder.
*/
protected String createFolder(Properties properties, String folderId, List<String> policies, Acl addACEs,
Acl removeACEs) {
String objectId = getBinding().getObjectService().createFolder(getTestRepositoryId(), properties, folderId,
policies, addACEs, removeACEs, null);
assertNotNull(objectId);
assertTrue(existsObject(objectId));
ObjectInFolderData folderChild = getChild(folderId, objectId);
// check canGetProperties
assertAllowableAction(folderChild.getObject().getAllowableActions(), Action.CAN_GET_PROPERTIES, true);
// check name
PropertyData<?> nameProp = properties.getProperties().get(PropertyIds.NAME);
if (nameProp != null) {
assertPropertyValue(folderChild.getObject().getProperties(), PropertyIds.NAME, PropertyString.class,
nameProp.getFirstValue());
}
// check object type
PropertyData<?> typeProp = properties.getProperties().get(PropertyIds.OBJECT_TYPE_ID);
assertNotNull(typeProp);
assertPropertyValue(folderChild.getObject().getProperties(), PropertyIds.OBJECT_TYPE_ID, PropertyId.class,
typeProp.getFirstValue());
// check parent
ObjectData parent = getBinding().getNavigationService().getFolderParent(getTestRepositoryId(), objectId, null,
null);
assertNotNull(parent);
assertNotNull(parent.getProperties());
assertNotNull(parent.getProperties().getProperties());
assertNotNull(parent.getProperties().getProperties().get(PropertyIds.OBJECT_ID));
assertEquals(folderId, parent.getProperties().getProperties().get(PropertyIds.OBJECT_ID).getFirstValue());
return objectId;
}
/**
* Creates a folder with the default type.
*/
protected String createDefaultFolder(String folderId, String name) {
List<PropertyData<?>> propList = new ArrayList<PropertyData<?>>();
propList.add(getObjectFactory().createPropertyStringData(PropertyIds.NAME, name));
propList.add(getObjectFactory().createPropertyIdData(PropertyIds.OBJECT_TYPE_ID, getDefaultFolderType()));
Properties properties = getObjectFactory().createPropertiesData(propList);
return createFolder(properties, folderId, null, null, null);
}
/**
* Creates a document.
*/
protected String createDocument(Properties properties, String folderId, ContentStream contentStream,
VersioningState versioningState, List<String> policies, Acl addACEs, Acl removeACEs) {
String objectId = getBinding().getObjectService().createDocument(getTestRepositoryId(), properties, folderId,
contentStream, versioningState, policies, addACEs, removeACEs, null);
assertNotNull(objectId);
assertTrue(existsObject(objectId));
if (folderId != null) {
ObjectInFolderData folderChild = getChild(folderId, objectId);
// check canGetProperties
assertAllowableAction(folderChild.getObject().getAllowableActions(), Action.CAN_GET_PROPERTIES, true);
// check canGetContentStream
if (contentStream != null) {
assertAllowableAction(folderChild.getObject().getAllowableActions(), Action.CAN_GET_CONTENT_STREAM,
true);
}
// check name
PropertyData<?> nameProp = properties.getProperties().get(PropertyIds.NAME);
if (nameProp != null) {
assertPropertyValue(folderChild.getObject().getProperties(), PropertyIds.NAME, PropertyString.class,
nameProp.getFirstValue());
}
// check object type
PropertyData<?> typeProp = properties.getProperties().get(PropertyIds.OBJECT_TYPE_ID);
assertNotNull(typeProp);
assertPropertyValue(folderChild.getObject().getProperties(), PropertyIds.OBJECT_TYPE_ID, PropertyId.class,
typeProp.getFirstValue());
// check parent
List<ObjectParentData> parents = getBinding().getNavigationService().getObjectParents(
getTestRepositoryId(), objectId, "*", Boolean.TRUE, IncludeRelationships.BOTH, null, Boolean.TRUE,
null);
assertNotNull(parents);
assertEquals(1, parents.size());
ObjectParentData parent = parents.get(0);
assertNotNull(parent);
assertNotNull(parent.getRelativePathSegment());
assertNotNull(parent.getObject());
assertNotNull(parent.getObject().getProperties().getProperties());
assertNotNull(parent.getObject().getProperties().getProperties().get(PropertyIds.OBJECT_ID));
assertEquals(folderId, parent.getObject().getProperties().getProperties().get(PropertyIds.OBJECT_ID)
.getFirstValue());
// get document by path (check relative path segment)
assertNotNull(parent.getObject().getProperties().getProperties().get(PropertyIds.PATH));
String parentPath = parent.getObject().getProperties().getProperties().get(PropertyIds.PATH)
.getFirstValue().toString();
ObjectData docByPath = getObjectByPath((parentPath.equals("/") ? "" : parentPath) + "/"
+ folderChild.getPathSegment());
PropertyData<?> idProp = docByPath.getProperties().getProperties().get(PropertyIds.OBJECT_ID);
assertNotNull(idProp);
assertEquals(objectId, idProp.getFirstValue());
} else {
List<ObjectParentData> parents = getBinding().getNavigationService().getObjectParents(
getTestRepositoryId(), objectId, null, Boolean.TRUE, IncludeRelationships.BOTH, null, Boolean.TRUE,
null);
assertNotNull(parents);
assertEquals(0, parents.size());
}
return objectId;
}
/**
* Creates a document with the default type.
*/
protected String createDefaultDocument(String folderId, String name, String contentType, byte[] content) {
VersioningState vs = (isVersionable(getDefaultDocumentType()) ? VersioningState.MAJOR : VersioningState.NONE);
List<PropertyData<?>> propList = new ArrayList<PropertyData<?>>();
propList.add(getObjectFactory().createPropertyStringData(PropertyIds.NAME, name));
propList.add(getObjectFactory().createPropertyIdData(PropertyIds.OBJECT_TYPE_ID, getDefaultDocumentType()));
Properties properties = getObjectFactory().createPropertiesData(propList);
ContentStream contentStream = createContentStreamData(contentType, content);
return createDocument(properties, folderId, contentStream, vs, null, null, null);
}
/**
* Creates a document from source.
*/
protected String createDocumentFromSource(String sourceId, Properties properties, String folderId,
VersioningState versioningState, List<String> policies, Acl addACEs, Acl removeACEs) {
String objectId = getBinding().getObjectService().createDocumentFromSource(getTestRepositoryId(), sourceId,
properties, folderId, versioningState, policies, addACEs, removeACEs, null);
assertNotNull(objectId);
assertTrue(existsObject(objectId));
if (folderId != null) {
ObjectInFolderData folderChild = getChild(folderId, objectId);
// check name
PropertyData<?> nameProp = properties.getProperties().get(PropertyIds.NAME);
if (nameProp != null) {
assertPropertyValue(folderChild.getObject().getProperties(), PropertyIds.NAME, PropertyString.class,
nameProp.getValues().get(0));
}
// check parent
List<ObjectParentData> parents = getBinding().getNavigationService().getObjectParents(
getTestRepositoryId(), objectId, null, Boolean.TRUE, IncludeRelationships.BOTH, null, Boolean.TRUE,
null);
assertNotNull(parents);
assertEquals(1, parents.size());
ObjectParentData parent = parents.get(0);
assertNotNull(parent);
assertNotNull(parent.getRelativePathSegment());
assertNotNull(parent.getObject());
assertNotNull(parent.getObject().getProperties().getProperties());
assertNotNull(parent.getObject().getProperties().getProperties().get(PropertyIds.OBJECT_ID));
assertEquals(folderId, parent.getObject().getProperties().getProperties().get(PropertyIds.OBJECT_ID)
.getFirstValue());
}
return objectId;
}
/**
* Deletes an object.
*/
protected void delete(String objectId, boolean allVersions) {
getBinding().getObjectService().deleteObject(getTestRepositoryId(), objectId, allVersions, null);
assertFalse(existsObject(objectId));
}
/**
* Deletes a tree.
*/
protected void deleteTree(String folderId) {
getBinding().getObjectService().deleteTree(getTestRepositoryId(), folderId, Boolean.TRUE, UnfileObject.DELETE,
Boolean.TRUE, null);
assertFalse(existsObject(folderId));
}
/**
* Gets a content stream.
*/
protected ContentStream getContent(String objectId, String streamId) {
ContentStream contentStream = getBinding().getObjectService().getContentStream(getTestRepositoryId(), objectId,
streamId, null, null, null);
assertNotNull(contentStream);
assertNotNull(contentStream.getMimeType());
assertNotNull(contentStream.getStream());
return contentStream;
}
/**
* Reads the content from a content stream into a byte array.
*/
protected byte[] readContent(ContentStream contentStream) throws Exception {
assertNotNull(contentStream);
assertNotNull(contentStream.getStream());
InputStream stream = contentStream.getStream();
ByteArrayOutputStream baos = new ByteArrayOutputStream();
byte[] buffer = new byte[4096];
int b;
while ((b = stream.read(buffer)) > -1) {
baos.write(buffer, 0, b);
}
return baos.toByteArray();
}
/**
* Returns a type definition.
*/
protected TypeDefinition getTypeDefinition(String typeName) {
TypeDefinition typeDef = getBinding().getRepositoryService().getTypeDefinition(getTestRepositoryId(), typeName,
null);
assertNotNull(typeDef);
assertNotNull(typeDef.getId());
return typeDef;
}
/**
* Returns if the type is versionable.
*/
protected boolean isVersionable(String typeName) {
TypeDefinition type = getTypeDefinition(typeName);
assertTrue(type instanceof DocumentTypeDefinition);
Boolean isVersionable = ((DocumentTypeDefinition) type).isVersionable();
assertNotNull(isVersionable);
return isVersionable;
}
// ---- asserts ----
protected void assertEquals(TypeDefinition expected, TypeDefinition actual, boolean checkPropertyDefintions) {
if (expected == null && actual == null) {
return;
}
if (expected == null) {
fail("Expected type definition is null!");
}
if (actual == null) {
fail("Actual type definition is null!");
}
assertEquals("TypeDefinition id:", expected.getId(), actual.getId());
assertEquals("TypeDefinition local name:", expected.getLocalName(), actual.getLocalName());
assertEquals("TypeDefinition local namespace:", expected.getLocalNamespace(), actual.getLocalNamespace());
assertEquals("TypeDefinition display name:", expected.getDisplayName(), actual.getDisplayName());
assertEquals("TypeDefinition description:", expected.getDescription(), actual.getDescription());
assertEquals("TypeDefinition query name:", expected.getQueryName(), actual.getQueryName());
assertEquals("TypeDefinition parent id:", expected.getParentTypeId(), actual.getParentTypeId());
assertEquals("TypeDefinition base id:", expected.getBaseTypeId(), actual.getBaseTypeId());
if (!checkPropertyDefintions) {
return;
}
if (expected.getPropertyDefinitions() == null && actual.getPropertyDefinitions() == null) {
return;
}
if (expected.getPropertyDefinitions() == null) {
fail("Expected property definition list is null!");
}
if (actual.getPropertyDefinitions() == null) {
fail("Actual property definition list is null!");
}
assertEquals(expected.getPropertyDefinitions().size(), actual.getPropertyDefinitions().size());
for (PropertyDefinition<?> expectedPropDef : expected.getPropertyDefinitions().values()) {
PropertyDefinition<?> actualPropDef = actual.getPropertyDefinitions().get(expectedPropDef.getId());
assertEquals(expectedPropDef, actualPropDef);
}
}
protected void assertEquals(PropertyDefinition<?> expected, PropertyDefinition<?> actual) {
if (expected == null && actual == null) {
return;
}
if (expected == null) {
fail("Expected property definition is null!");
}
if (actual == null) {
fail("Actual property definition is null!");
}
assertNotNull(expected.getId());
assertNotNull(actual.getId());
String id = expected.getId();
assertEquals("PropertyDefinition " + id + " id:", expected.getId(), actual.getId());
assertEquals("PropertyDefinition " + id + " local name:", expected.getLocalName(), actual.getLocalName());
assertEquals("PropertyDefinition " + id + " local namespace:", expected.getLocalNamespace(), actual
.getLocalNamespace());
assertEquals("PropertyDefinition " + id + " query name:", expected.getQueryName(), actual.getQueryName());
assertEquals("PropertyDefinition " + id + " display name:", expected.getDisplayName(), actual.getDisplayName());
assertEquals("PropertyDefinition " + id + " description:", expected.getDescription(), actual.getDescription());
assertEquals("PropertyDefinition " + id + " property type:", expected.getPropertyType(), actual
.getPropertyType());
assertEquals("PropertyDefinition " + id + " cardinality:", expected.getCardinality(), actual.getCardinality());
assertEquals("PropertyDefinition " + id + " updatability:", expected.getUpdatability(), actual
.getUpdatability());
}
protected void assertEquals(Properties expected, Properties actual) {
if (expected == null && actual == null) {
return;
}
if (expected == null) {
fail("Expected properties data is null!");
}
if (actual == null) {
fail("Actual properties data is null!");
}
if (expected.getProperties() == null && actual.getProperties() == null) {
return;
}
if (expected.getProperties() == null || actual.getProperties() == null) {
fail("Properties are null!");
}
if (expected.getProperties() == null) {
fail("Expected properties are null!");
}
if (actual.getProperties() == null) {
fail("Actual properties are null!");
}
assertEquals(expected.getProperties().size(), actual.getProperties().size());
for (String id : expected.getProperties().keySet()) {
PropertyData<?> expectedProperty = expected.getProperties().get(id);
assertNotNull(expectedProperty);
assertEquals(id, expectedProperty.getId());
PropertyData<?> actualProperty = actual.getProperties().get(id);
assertNotNull(actualProperty);
assertEquals(id, actualProperty.getId());
assertEquals(expectedProperty, actualProperty);
}
}
protected void assertEquals(PropertyData<?> expected, PropertyData<?> actual) {
if (expected == null && actual == null) {
return;
}
if (expected == null || actual == null) {
fail("Properties data is null!");
}
String id = expected.getId();
assertEquals("PropertyData " + id + " id:", expected.getId(), actual.getId());
assertEquals("PropertyData " + id + " display name:", expected.getDisplayName(), actual.getDisplayName());
assertEquals("PropertyData " + id + " local name:", expected.getLocalName(), actual.getLocalName());
assertEquals("PropertyData " + id + " query name:", expected.getQueryName(), actual.getQueryName());
assertEquals("PropertyData " + id + " values:", expected.getValues().size(), actual.getValues().size());
for (int i = 0; i < expected.getValues().size(); i++) {
assertEquals("PropertyData " + id + " value[" + i + "]:", expected.getValues().get(i), actual.getValues()
.get(i));
}
}
protected void assertBasicProperties(Properties properties) {
assertNotNull(properties);
assertNotNull(properties.getProperties());
assertProperty(properties.getProperties().get(PropertyIds.OBJECT_ID), PropertyIds.OBJECT_ID, PropertyId.class);
assertProperty(properties.getProperties().get(PropertyIds.OBJECT_TYPE_ID), PropertyIds.OBJECT_TYPE_ID,
PropertyId.class);
assertProperty(properties.getProperties().get(PropertyIds.BASE_TYPE_ID), PropertyIds.BASE_TYPE_ID,
PropertyId.class);
assertProperty(properties.getProperties().get(PropertyIds.NAME), PropertyIds.NAME, PropertyString.class);
assertProperty(properties.getProperties().get(PropertyIds.CREATED_BY), PropertyIds.CREATED_BY,
PropertyString.class);
assertProperty(properties.getProperties().get(PropertyIds.CREATION_DATE), PropertyIds.CREATION_DATE,
PropertyDateTime.class);
assertProperty(properties.getProperties().get(PropertyIds.LAST_MODIFIED_BY), PropertyIds.LAST_MODIFIED_BY,
PropertyString.class);
assertProperty(properties.getProperties().get(PropertyIds.LAST_MODIFICATION_DATE),
PropertyIds.LAST_MODIFICATION_DATE, PropertyDateTime.class);
}
protected void assertProperty(PropertyData<?> property, String id, Class<?> clazz) {
assertNotNull(property);
assertNotNull(property.getId());
assertEquals("PropertyData " + id + " id:", id, property.getId());
assertTrue(clazz.isAssignableFrom(property.getClass()));
assertNotNull(property.getValues());
assertFalse(property.getValues().isEmpty());
}
protected void assertPropertyValue(PropertyData<?> property, String id, Class<?> clazz, Object... values) {
assertProperty(property, id, clazz);
assertEquals("Property " + id + " values:", values.length, property.getValues().size());
int i = 0;
for (Object value : property.getValues()) {
assertEquals("Property " + id + " value[" + i + "]:", values[i], value);
i++;
}
}
protected void assertPropertyValue(Properties properties, String id, Class<?> clazz, Object... values) {
assertNotNull(properties);
assertNotNull(properties.getProperties());
PropertyData<?> property = properties.getProperties().get(id);
assertNotNull(property);
assertPropertyValue(property, id, clazz, values);
}
protected void assertEquals(AllowableActions expected, AllowableActions actual) {
if (expected == null && actual == null) {
return;
}
if (expected == null) {
fail("Expected allowable action data is null!");
}
if (actual == null) {
fail("Actual allowable action data is null!");
}
assertNotNull(expected.getAllowableActions());
assertNotNull(actual.getAllowableActions());
assertEquals("Allowable action size:", expected.getAllowableActions().size(), actual.getAllowableActions()
.size());
for (Action action : expected.getAllowableActions()) {
boolean expectedBoolean = expected.getAllowableActions().contains(action);
boolean actualBoolean = actual.getAllowableActions().contains(action);
assertEquals("AllowableAction " + action + ":", expectedBoolean, actualBoolean);
}
}
protected void assertAllowableAction(AllowableActions allowableActions, Action action, boolean expected) {
assertNotNull(allowableActions);
assertNotNull(allowableActions.getAllowableActions());
assertNotNull(action);
assertEquals("Allowable action \"" + action + "\":", expected, allowableActions.getAllowableActions().contains(
action));
}
protected void assertEquals(Acl expected, Acl actual) {
if (expected == null && actual == null) {
return;
}
if (expected == null) {
fail("Expected ACL data is null!");
}
if (actual == null) {
fail("Actual ACL data is null!");
}
if (expected.getAces() == null && actual.getAces() == null) {
return;
}
if (expected.getAces() == null) {
fail("Expected ACE data is null!");
}
if (actual.getAces() == null) {
fail("Actual ACE data is null!");
}
// assertEquals(expected.isExact(), actual.isExact());
assertEquals(expected.getAces().size(), actual.getAces().size());
for (int i = 0; i < expected.getAces().size(); i++) {
assertEquals(expected.getAces().get(i), actual.getAces().get(i));
}
}
protected void assertEquals(Ace expected, Ace actual) {
if (expected == null && actual == null) {
return;
}
if (expected == null) {
fail("Expected ACE data is null!");
}
if (actual == null) {
fail("Actual ACE data is null!");
}
assertNotNull(expected.getPrincipal());
assertNotNull(expected.getPrincipal().getId());
assertNotNull(actual.getPrincipal());
assertNotNull(actual.getPrincipal().getId());
assertEquals("ACE Principal:", expected.getPrincipal().getId(), actual.getPrincipal().getId());
assertEqualLists(expected.getPermissions(), actual.getPermissions());
}
protected void assertEquals(RenditionData expected, RenditionData actual) {
if (expected == null && actual == null) {
return;
}
if (expected == null) {
fail("Expected rendition is null!");
}
if (actual == null) {
fail("Actual rendition is null!");
}
assertEquals("Rendition kind:", expected.getKind(), actual.getKind());
assertEquals("Rendition MIME type:", expected.getMimeType(), actual.getMimeType());
assertEquals("Rendition length:", expected.getBigLength(), actual.getBigLength());
assertEquals("Rendition stream id:", expected.getStreamId(), actual.getStreamId());
assertEquals("Rendition title:", expected.getTitle(), actual.getTitle());
assertEquals("Rendition height:", expected.getBigHeight(), actual.getBigHeight());
assertEquals("Rendition width:", expected.getBigWidth(), actual.getBigWidth());
assertEquals("Rendition document id:", expected.getRenditionDocumentId(), actual.getRenditionDocumentId());
}
protected void assertContent(byte[] expected, byte[] actual) {
assertNotNull(expected);
assertNotNull(actual);
assertEquals("Content size:", expected.length, actual.length);
for (int i = 0; i < expected.length; i++) {
assertEquals("Content not equal.", expected[i], actual[i]);
}
}
protected void assertMimeType(String expected, String actual) {
assertNotNull(expected);
assertNotNull(actual);
int paramIdx = actual.indexOf(';');
if (paramIdx != -1) {
actual = actual.substring(0, paramIdx);
}
assertEquals(expected, actual);
}
protected void assertEqualLists(List<?> expected, List<?> actual) {
if (expected == null && actual == null) {
return;
}
if (expected == null) {
fail("Expected list is null!");
}
if (actual == null) {
fail("Actual list is null!");
}
assertEquals("List size:", expected.size(), actual.size());
for (int i = 0; i < expected.size(); i++) {
assertEquals("List element " + i + ":", expected.get(i), actual.get(i));
}
}
}