mirror of
https://github.com/Alfresco/alfresco-community-repo.git
synced 2025-10-29 15:21:53 +00:00
6afb44e712
125606 rmunteanu: Merged 5.1.1 (5.1.1) to 5.1.N (5.1.2)
125515 slanglois: MNT-16155 Update source headers - add new Copyrights for Java and JSP source files + automatic check in the build
git-svn-id: https://svn.alfresco.com/repos/alfresco-enterprise/alfresco/BRANCHES/DEV/5.2.N/root@125788 c4b6b30b-aa2e-2d43-bbcb-ca4b014f7261
465 lines
19 KiB
Java
465 lines
19 KiB
Java
/*
|
|
* #%L
|
|
* Alfresco Repository
|
|
* %%
|
|
* Copyright (C) 2005 - 2016 Alfresco Software Limited
|
|
* %%
|
|
* This file is part of the Alfresco software.
|
|
* If the software was purchased under a paid Alfresco license, the terms of
|
|
* the paid license agreement will prevail. Otherwise, the software is
|
|
* provided under the following open source license terms:
|
|
*
|
|
* 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/>.
|
|
* #L%
|
|
*/
|
|
package org.alfresco.repo.content.metadata;
|
|
|
|
import java.io.File;
|
|
import java.io.Serializable;
|
|
import java.util.Arrays;
|
|
import java.util.Collections;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
import java.util.Map;
|
|
import java.util.Properties;
|
|
import java.util.Set;
|
|
|
|
import junit.framework.TestCase;
|
|
|
|
import org.alfresco.error.AlfrescoRuntimeException;
|
|
import org.alfresco.repo.content.ContentMinimalContextTestSuite;
|
|
import org.alfresco.repo.content.MimetypeMap;
|
|
import org.alfresco.repo.content.filestore.FileContentReader;
|
|
import org.alfresco.repo.content.filestore.FileContentWriter;
|
|
import org.alfresco.repo.content.metadata.MetadataExtracter.OverwritePolicy;
|
|
import org.alfresco.repo.content.transform.AbstractContentTransformerTest;
|
|
import org.alfresco.service.cmr.repository.ContentReader;
|
|
import org.alfresco.service.namespace.NamespaceService;
|
|
import org.alfresco.service.namespace.QName;
|
|
import org.alfresco.util.TempFileProvider;
|
|
import org.springframework.context.ApplicationContext;
|
|
|
|
/**
|
|
* @see org.alfresco.repo.content.metadata.AbstractMappingMetadataExtracter
|
|
*
|
|
* @author Derek Hulley
|
|
*/
|
|
public class MappingMetadataExtracterTest extends TestCase
|
|
{
|
|
private DummyMappingMetadataExtracter extracter;
|
|
private ContentReader reader;
|
|
private Map<QName, Serializable> destination;
|
|
|
|
@Override
|
|
protected void setUp() throws Exception
|
|
{
|
|
extracter = new DummyMappingMetadataExtracter();
|
|
extracter.register();
|
|
reader = new FileContentReader(AbstractContentTransformerTest.loadQuickTestFile("txt"));
|
|
reader.setMimetype(MimetypeMap.MIMETYPE_TEXT_PLAIN);
|
|
|
|
destination = new HashMap<QName, Serializable>(7);
|
|
destination.put(DummyMappingMetadataExtracter.QNAME_A1, JunkValue.INSTANCE);
|
|
destination.put(DummyMappingMetadataExtracter.QNAME_A2, "");
|
|
destination.put(DummyMappingMetadataExtracter.QNAME_B, null);
|
|
}
|
|
|
|
public void testSetUp()
|
|
{
|
|
assertNotNull(reader);
|
|
assertNotNull(extracter);
|
|
assertTrue("Extracter not initialized.", extracter.initCheck);
|
|
}
|
|
|
|
/** Test the new alfresco/metadata properties location */
|
|
public void testSetUpPropertiesLocationMetadata()
|
|
{
|
|
DummyPropertiesInMetadataLocationMappingMetadataExtracter metadataLocationExtracter =
|
|
new DummyPropertiesInMetadataLocationMappingMetadataExtracter();
|
|
metadataLocationExtracter.register();
|
|
assertNotNull("Extracter not initialized.", metadataLocationExtracter.getMapping());
|
|
assertNotNull("Mapping not found",
|
|
metadataLocationExtracter.getMapping().get(DummyMappingMetadataExtracter.PROP_A));
|
|
}
|
|
|
|
/** Test that the old package-based properties location still works */
|
|
public void testSetUpPropertiesLocationPackage()
|
|
{
|
|
DummyPropertiesInPackageLocationMappingMetadataExtracter packageLocationExtracter =
|
|
new DummyPropertiesInPackageLocationMappingMetadataExtracter();
|
|
packageLocationExtracter.register();
|
|
assertNotNull("Extracter not initialized.", packageLocationExtracter.getMapping());
|
|
assertNotNull("Mapping not found",
|
|
packageLocationExtracter.getMapping().get(DummyMappingMetadataExtracter.PROP_A));
|
|
}
|
|
|
|
/** Test that an extract with missing location throws the correct error */
|
|
public void testSetUpPropertiesMissing()
|
|
{
|
|
DummyPropertiesMissingMappingMetadataExtracter propertiesMissingExtracter =
|
|
new DummyPropertiesMissingMappingMetadataExtracter();
|
|
try
|
|
{
|
|
propertiesMissingExtracter.register();
|
|
} catch (AlfrescoRuntimeException e)
|
|
{
|
|
assertTrue(e.getMessage().contains("alfresco/metadata/"));
|
|
}
|
|
}
|
|
|
|
public void testDefaultExtract() throws Exception
|
|
{
|
|
destination.clear();
|
|
extracter.extract(reader, destination);
|
|
assertEquals(4, destination.size());
|
|
assertTrue(destination.containsKey(DummyMappingMetadataExtracter.QNAME_A1));
|
|
assertTrue(destination.containsKey(DummyMappingMetadataExtracter.QNAME_A2));
|
|
assertTrue(destination.containsKey(DummyMappingMetadataExtracter.QNAME_B));
|
|
assertTrue(destination.containsKey(DummyMappingMetadataExtracter.QNAME_IMG));
|
|
}
|
|
|
|
public void testPropertyMappingOverride() throws Exception
|
|
{
|
|
Properties props = new Properties();
|
|
props.put("namespace.prefix.my", DummyMappingMetadataExtracter.NAMESPACE_MY);
|
|
props.put(DummyMappingMetadataExtracter.PROP_A, " my:a1, my:a2 ");
|
|
extracter.setMappingProperties(props);
|
|
extracter.register();
|
|
// Only mapped 'a'
|
|
destination.clear();
|
|
extracter.extract(reader, destination);
|
|
assertEquals(2, destination.size());
|
|
assertTrue(destination.containsKey(DummyMappingMetadataExtracter.QNAME_A1));
|
|
assertTrue(destination.containsKey(DummyMappingMetadataExtracter.QNAME_A2));
|
|
}
|
|
|
|
public void testPropertyMappingGlobalOverride() throws Exception
|
|
{
|
|
String propertyPrefix = AbstractMappingMetadataExtracter.PROPERTY_PREFIX_METADATA +
|
|
DummyMappingMetadataExtracter.EXTRACTER_NAME +
|
|
AbstractMappingMetadataExtracter.PROPERTY_COMPONENT_EXTRACT;
|
|
|
|
ApplicationContext ctx = ContentMinimalContextTestSuite.getContext();
|
|
Properties globalProperties = (Properties) ctx.getBean("global-properties");
|
|
globalProperties.setProperty(
|
|
propertyPrefix + "namespace.prefix.my",
|
|
DummyMappingMetadataExtracter.NAMESPACE_MY);
|
|
globalProperties.setProperty(
|
|
propertyPrefix + DummyMappingMetadataExtracter.PROP_A,
|
|
" my:a1, my:a2, my:c ");
|
|
|
|
extracter.setApplicationContext(ctx);
|
|
|
|
extracter.register();
|
|
// Only mapped 'a'
|
|
destination.clear();
|
|
extracter.extract(reader, destination);
|
|
assertEquals(DummyMappingMetadataExtracter.VALUE_A, destination.get(DummyMappingMetadataExtracter.QNAME_C));
|
|
}
|
|
|
|
public void testPropertyMappingMerge() throws Exception
|
|
{
|
|
Properties props = new Properties();
|
|
props.put("namespace.prefix.my", DummyMappingMetadataExtracter.NAMESPACE_MY);
|
|
props.put(DummyMappingMetadataExtracter.PROP_A, " my:a3 ");
|
|
extracter.setMappingProperties(props);
|
|
extracter.setInheritDefaultMapping(true);
|
|
extracter.register();
|
|
// Added a3
|
|
destination.clear();
|
|
extracter.extract(reader, destination);
|
|
assertEquals(3, destination.size());
|
|
assertTrue(destination.containsKey(DummyMappingMetadataExtracter.QNAME_A3));
|
|
assertTrue(destination.containsKey(DummyMappingMetadataExtracter.QNAME_B));
|
|
assertTrue(destination.containsKey(DummyMappingMetadataExtracter.QNAME_IMG));
|
|
}
|
|
|
|
public void testPropertyMappingDisable() throws Exception
|
|
{
|
|
Properties props = new Properties();
|
|
props.put("namespace.prefix.my", DummyMappingMetadataExtracter.NAMESPACE_MY);
|
|
props.put(DummyMappingMetadataExtracter.PROP_A, "");
|
|
extracter.setMappingProperties(props);
|
|
extracter.setInheritDefaultMapping(true);
|
|
extracter.register();
|
|
// Added a3
|
|
destination.clear();
|
|
extracter.extract(reader, destination);
|
|
assertEquals(2, destination.size());
|
|
assertTrue(destination.containsKey(DummyMappingMetadataExtracter.QNAME_B));
|
|
assertTrue(destination.containsKey(DummyMappingMetadataExtracter.QNAME_IMG));
|
|
}
|
|
|
|
public void testPropertyMappingOverrideExtra() throws Exception
|
|
{
|
|
Properties props = new Properties();
|
|
props.put("namespace.prefix.my", DummyMappingMetadataExtracter.NAMESPACE_MY);
|
|
props.put(DummyMappingMetadataExtracter.PROP_C, " my:c ");
|
|
props.put(DummyMappingMetadataExtracter.PROP_D, " my:d ");
|
|
props.put(DummyMappingMetadataExtracter.PROP_E, " my:e ");
|
|
extracter.setMappingProperties(props);
|
|
extracter.register();
|
|
// Added a3
|
|
destination.clear();
|
|
extracter.extract(reader, destination);
|
|
assertEquals(2, destination.size());
|
|
assertTrue(destination.containsKey(DummyMappingMetadataExtracter.QNAME_C));
|
|
assertTrue(destination.containsKey(DummyMappingMetadataExtracter.QNAME_D));
|
|
}
|
|
|
|
public void testOverwritePolicyEager()
|
|
{
|
|
extracter.setOverwritePolicy(OverwritePolicy.EAGER);
|
|
extracter.extract(reader, destination);
|
|
assertEquals(4, destination.size());
|
|
assertEquals(DummyMappingMetadataExtracter.VALUE_A, destination.get(DummyMappingMetadataExtracter.QNAME_A1));
|
|
assertEquals(DummyMappingMetadataExtracter.VALUE_A, destination.get(DummyMappingMetadataExtracter.QNAME_A2));
|
|
assertEquals(DummyMappingMetadataExtracter.VALUE_B, destination.get(DummyMappingMetadataExtracter.QNAME_B));
|
|
assertEquals(DummyMappingMetadataExtracter.VALUE_IMG, destination.get(DummyMappingMetadataExtracter.QNAME_IMG));
|
|
}
|
|
|
|
public void testOverwritePolicyPragmatic()
|
|
{
|
|
extracter.setOverwritePolicy(OverwritePolicy.PRAGMATIC);
|
|
|
|
// Put some values in to start with
|
|
destination.put(DummyMappingMetadataExtracter.QNAME_C, "Will not change");
|
|
destination.put(DummyMappingMetadataExtracter.QNAME_IMG, "Will be changed");
|
|
|
|
// Extract
|
|
extracter.extract(reader, destination);
|
|
assertEquals(5, destination.size());
|
|
|
|
// Check the values as extracted
|
|
assertEquals(JunkValue.INSTANCE, destination.get(DummyMappingMetadataExtracter.QNAME_A1));
|
|
assertEquals(DummyMappingMetadataExtracter.VALUE_A, destination.get(DummyMappingMetadataExtracter.QNAME_A2));
|
|
assertEquals(DummyMappingMetadataExtracter.VALUE_B, destination.get(DummyMappingMetadataExtracter.QNAME_B));
|
|
|
|
// Normal values not changed
|
|
assertEquals("Will not change", destination.get(DummyMappingMetadataExtracter.QNAME_C));
|
|
|
|
// Media parts are always overridden
|
|
assertEquals(DummyMappingMetadataExtracter.VALUE_IMG, destination.get(DummyMappingMetadataExtracter.QNAME_IMG));
|
|
}
|
|
|
|
public void testOverwritePolicyPrudent()
|
|
{
|
|
extracter.setOverwritePolicy(OverwritePolicy.PRUDENT);
|
|
|
|
// Add a media property, won't be changed
|
|
destination.put(DummyMappingMetadataExtracter.QNAME_IMG, "Won't be changed");
|
|
|
|
// Extract and check
|
|
extracter.extract(reader, destination);
|
|
assertEquals(4, destination.size());
|
|
assertEquals(JunkValue.INSTANCE, destination.get(DummyMappingMetadataExtracter.QNAME_A1));
|
|
assertEquals(DummyMappingMetadataExtracter.VALUE_A, destination.get(DummyMappingMetadataExtracter.QNAME_A2));
|
|
assertEquals(DummyMappingMetadataExtracter.VALUE_B, destination.get(DummyMappingMetadataExtracter.QNAME_B));
|
|
|
|
// Media behaves the same as the others
|
|
assertEquals("Won't be changed", destination.get(DummyMappingMetadataExtracter.QNAME_IMG));
|
|
}
|
|
|
|
public void testOverwritePolicyCautious()
|
|
{
|
|
extracter.setOverwritePolicy(OverwritePolicy.CAUTIOUS);
|
|
extracter.extract(reader, destination);
|
|
assertEquals(4, destination.size());
|
|
assertEquals(JunkValue.INSTANCE, destination.get(DummyMappingMetadataExtracter.QNAME_A1));
|
|
assertEquals("", destination.get(DummyMappingMetadataExtracter.QNAME_A2));
|
|
assertEquals(null, destination.get(DummyMappingMetadataExtracter.QNAME_B));
|
|
}
|
|
|
|
/**
|
|
* @see <a href="https://issues.alfresco.com/jira/browse/MNT-13919">MNT-13919</a>
|
|
*/
|
|
public void testEmbedSupportDifferentFromExtract()
|
|
{
|
|
DummyMetadataEmbedder embedder = new DummyMetadataEmbedder();
|
|
Map<QName, Serializable> propertiesToEmbed = new HashMap<QName, Serializable>();
|
|
|
|
// make a writer for the target of the embed, we won't actually use it
|
|
File targetFile = TempFileProvider.createTempFile(
|
|
getClass().getSimpleName() + "_" + getName() + "_embed",
|
|
".txt");
|
|
FileContentWriter writer = new FileContentWriter(targetFile);
|
|
writer.setMimetype(DummyMetadataEmbedder.MIMETYPE_EMBEDDABLE);
|
|
|
|
try
|
|
{
|
|
embedder.embed(propertiesToEmbed, reader, writer);
|
|
}
|
|
catch (AlfrescoRuntimeException e)
|
|
{
|
|
if (e.getMessage().contains("Metadata extracter does not support embedding mimetype"))
|
|
{
|
|
fail("Embed mimetype should not be tied to extracter's extract mimetypes");
|
|
}
|
|
else
|
|
{
|
|
fail(e.getMessage());
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
if (targetFile != null && targetFile.exists())
|
|
{
|
|
targetFile.delete();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* A spoofed-up extracter that extracts the following:
|
|
* <pre>
|
|
* <b>a:</b> - A --> my:a1, my:a2
|
|
* <b>b:</b> - B --> my:b
|
|
* <b>c:</b> - C
|
|
* <b>d:</b> - D
|
|
* </pre>
|
|
* @author Derek Hulley
|
|
*/
|
|
public static class DummyMappingMetadataExtracter extends AbstractMappingMetadataExtracter
|
|
{
|
|
public static final String PROP_A = "a";
|
|
public static final String PROP_B = "b";
|
|
public static final String PROP_C = "c";
|
|
public static final String PROP_D = "d";
|
|
public static final String PROP_E = "e";
|
|
public static final String PROP_IMG = "exif";
|
|
public static final String VALUE_A = "AAA";
|
|
public static final String VALUE_B = "BBB";
|
|
public static final String VALUE_C = "CCC";
|
|
public static final String VALUE_D = "DDD";
|
|
public static final String VALUE_IMG = "IMAGE";
|
|
|
|
public static final String EXTRACTER_NAME = "extracter.Dummy";
|
|
public static final String NAMESPACE_MY = "http://DummyMappingMetadataExtracter";
|
|
public static final QName QNAME_A1 = QName.createQName(NAMESPACE_MY, "a1");
|
|
public static final QName QNAME_A2 = QName.createQName(NAMESPACE_MY, "a2");
|
|
public static final QName QNAME_A3 = QName.createQName(NAMESPACE_MY, "a3");
|
|
public static final QName QNAME_B = QName.createQName(NAMESPACE_MY, "b");
|
|
public static final QName QNAME_C = QName.createQName(NAMESPACE_MY, "c");
|
|
public static final QName QNAME_D = QName.createQName(NAMESPACE_MY, "d");
|
|
public static final QName QNAME_E = QName.createQName(NAMESPACE_MY, "e"); // not extracted
|
|
public static final QName QNAME_IMG = QName.createQName(NamespaceService.EXIF_MODEL_1_0_URI, "test");
|
|
private static final Set<String> MIMETYPES;
|
|
static
|
|
{
|
|
MIMETYPES = new HashSet<String>(5);
|
|
MIMETYPES.add(MimetypeMap.MIMETYPE_TEXT_PLAIN);
|
|
MIMETYPES.add(MimetypeMap.MIMETYPE_XML);
|
|
}
|
|
|
|
Map<String, Set<QName>> defaultMapping;
|
|
private boolean initCheck;
|
|
|
|
public DummyMappingMetadataExtracter()
|
|
{
|
|
super(MIMETYPES);
|
|
initCheck = false;
|
|
setBeanName(EXTRACTER_NAME);
|
|
}
|
|
|
|
@Override
|
|
protected void init()
|
|
{
|
|
defaultMapping = new HashMap<String, Set<QName>>(7);
|
|
defaultMapping.put(PROP_A, new HashSet<QName>(Arrays.asList(QNAME_A1, QNAME_A2)));
|
|
defaultMapping.put(PROP_B, new HashSet<QName>(Arrays.asList(QNAME_B)));
|
|
defaultMapping.put(PROP_IMG, new HashSet<QName>(Arrays.asList(QNAME_IMG)));
|
|
|
|
initCheck = true;
|
|
|
|
super.init();
|
|
}
|
|
|
|
@Override
|
|
protected Map<String, Set<QName>> getDefaultMapping()
|
|
{
|
|
return defaultMapping;
|
|
}
|
|
|
|
@Override
|
|
protected Map<String, Serializable> extractRaw(ContentReader reader)
|
|
{
|
|
reader.getContentString();
|
|
|
|
Map<String, Serializable> ret = new HashMap<String, Serializable>(7);
|
|
ret.put(PROP_A, VALUE_A);
|
|
ret.put(PROP_B, VALUE_B);
|
|
ret.put(PROP_C, VALUE_C);
|
|
ret.put(PROP_D, VALUE_D);
|
|
ret.put(PROP_IMG, VALUE_IMG);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
public static class DummyPropertiesInPackageLocationMappingMetadataExtracter extends AbstractMappingMetadataExtracter
|
|
{
|
|
@Override
|
|
protected Map<String, Serializable> extractRaw(ContentReader reader) throws Throwable
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static class DummyPropertiesInMetadataLocationMappingMetadataExtracter extends AbstractMappingMetadataExtracter
|
|
{
|
|
@Override
|
|
protected Map<String, Serializable> extractRaw(ContentReader reader) throws Throwable
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static class DummyPropertiesMissingMappingMetadataExtracter extends AbstractMappingMetadataExtracter
|
|
{
|
|
@Override
|
|
protected Map<String, Serializable> extractRaw(ContentReader reader) throws Throwable
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
private static class JunkValue implements Serializable
|
|
{
|
|
private static final JunkValue INSTANCE = new JunkValue();
|
|
private static final long serialVersionUID = 1L;
|
|
}
|
|
|
|
/**
|
|
* Mock metadata embedder which has a set of supported embed mimetypes different than
|
|
* the supported extract mimetypes.
|
|
*/
|
|
private class DummyMetadataEmbedder extends AbstractMappingMetadataExtracter
|
|
{
|
|
private static final String MIMETYPE_EXTRACTABLE = "extractableMimetype";
|
|
private static final String MIMETYPE_EMBEDDABLE = "embeddableMimetype";
|
|
|
|
public DummyMetadataEmbedder()
|
|
{
|
|
super(Collections.singleton(MIMETYPE_EXTRACTABLE),
|
|
Collections.singleton(MIMETYPE_EMBEDDABLE));
|
|
init();
|
|
}
|
|
|
|
@Override
|
|
protected Map<String, Serializable> extractRaw(ContentReader reader) throws Throwable
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
}
|