diff --git a/oak-upgrade/src/main/java/org/apache/jackrabbit/oak/upgrade/JackrabbitNodeState.java b/oak-upgrade/src/main/java/org/apache/jackrabbit/oak/upgrade/JackrabbitNodeState.java index 0ba3bb0..2aae77b 100644 --- a/oak-upgrade/src/main/java/org/apache/jackrabbit/oak/upgrade/JackrabbitNodeState.java +++ b/oak-upgrade/src/main/java/org/apache/jackrabbit/oak/upgrade/JackrabbitNodeState.java @@ -94,6 +94,8 @@ class JackrabbitNodeState extends AbstractNodeState { private static final Logger log = LoggerFactory.getLogger(JackrabbitNodeState.class); + private static final String MIX_SIMPLE_VERSIONABLE = "mix:simpleVersionable"; + private JackrabbitNodeState parent; private final String name; @@ -117,6 +119,8 @@ class JackrabbitNodeState extends AbstractNodeState { private final TypePredicate isVersionable; + private final TypePredicate isSimpleVersionable; + private final TypePredicate isVersionHistory; private final TypePredicate isFrozenNode; @@ -189,6 +193,7 @@ class JackrabbitNodeState extends AbstractNodeState { this.workspaceName = parent.workspaceName; this.isReferenceable = parent.isReferenceable; this.isOrderable = parent.isOrderable; + this.isSimpleVersionable = parent.isSimpleVersionable; this.isVersionable = parent.isVersionable; this.isVersionHistory = parent.isVersionHistory; this.isFrozenNode = parent.isFrozenNode; @@ -217,6 +222,7 @@ class JackrabbitNodeState extends AbstractNodeState { this.isReferenceable = new TypePredicate(root, MIX_REFERENCEABLE); this.isOrderable = TypePredicate.isOrderable(root); this.isVersionable = new TypePredicate(root, MIX_VERSIONABLE); + this.isSimpleVersionable = new TypePredicate(root, MIX_SIMPLE_VERSIONABLE); this.isVersionHistory = new TypePredicate(root, NT_VERSIONHISTORY); this.isFrozenNode = new TypePredicate(root, NT_FROZENNODE); this.uriToPrefix = uriToPrefix; @@ -400,7 +406,8 @@ class JackrabbitNodeState extends AbstractNodeState { } if (bundle.isReferenceable() - || isReferenceable.apply(primary, mixins)) { + || isReferenceable.apply(primary, mixins) + || isSimpleVersionable.apply(primary, mixins)) { properties.put(JCR_UUID, PropertyStates.createProperty( JCR_UUID, bundle.getId().toString())); } diff --git a/oak-upgrade/src/main/java/org/apache/jackrabbit/oak/upgrade/RepositoryUpgrade.java b/oak-upgrade/src/main/java/org/apache/jackrabbit/oak/upgrade/RepositoryUpgrade.java index 1b1f46e..4a6f851 100644 --- a/oak-upgrade/src/main/java/org/apache/jackrabbit/oak/upgrade/RepositoryUpgrade.java +++ b/oak-upgrade/src/main/java/org/apache/jackrabbit/oak/upgrade/RepositoryUpgrade.java @@ -114,6 +114,7 @@ import org.apache.jackrabbit.oak.upgrade.nodestate.report.ReportingNodeState; import org.apache.jackrabbit.oak.upgrade.nodestate.NodeStateCopier; import org.apache.jackrabbit.oak.upgrade.security.GroupEditorProvider; import org.apache.jackrabbit.oak.upgrade.security.RestrictionEditorProvider; +import org.apache.jackrabbit.oak.upgrade.version.SimpleVersionableEditor; import org.apache.jackrabbit.oak.upgrade.version.VersionCopyConfiguration; import org.apache.jackrabbit.oak.upgrade.version.VersionableEditor; import org.apache.jackrabbit.spi.Name; @@ -465,7 +466,8 @@ public class RepositoryUpgrade { new RestrictionEditorProvider(), new GroupEditorProvider(groupsPath), // copy referenced version histories - new VersionableEditor.Provider(sourceRoot, workspaceName, versionCopyConfiguration) + new VersionableEditor.Provider(sourceRoot, workspaceName, versionCopyConfiguration), + new SimpleVersionableEditor.Provider() ))); // security-related hooks diff --git a/oak-upgrade/src/main/java/org/apache/jackrabbit/oak/upgrade/version/SimpleVersionableEditor.java b/oak-upgrade/src/main/java/org/apache/jackrabbit/oak/upgrade/version/SimpleVersionableEditor.java new file mode 100644 index 0000000..50fca59 --- /dev/null +++ b/oak-upgrade/src/main/java/org/apache/jackrabbit/oak/upgrade/version/SimpleVersionableEditor.java @@ -0,0 +1,135 @@ +/* + * 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.jackrabbit.oak.upgrade.version; + +import org.apache.jackrabbit.JcrConstants; +import org.apache.jackrabbit.oak.api.CommitFailedException; +import org.apache.jackrabbit.oak.api.Type; +import org.apache.jackrabbit.oak.plugins.nodetype.TypePredicate; +import org.apache.jackrabbit.oak.spi.commit.CommitInfo; +import org.apache.jackrabbit.oak.spi.commit.DefaultEditor; +import org.apache.jackrabbit.oak.spi.commit.Editor; +import org.apache.jackrabbit.oak.spi.commit.EditorProvider; +import org.apache.jackrabbit.oak.spi.state.ChildNodeEntry; +import org.apache.jackrabbit.oak.spi.state.NodeBuilder; +import org.apache.jackrabbit.oak.spi.state.NodeState; + +import java.util.ArrayList; +import java.util.List; +import java.util.Set; + +import static com.google.common.collect.Sets.newHashSet; +import static org.apache.jackrabbit.JcrConstants.JCR_BASEVERSION; +import static org.apache.jackrabbit.JcrConstants.JCR_MIXINTYPES; +import static org.apache.jackrabbit.JcrConstants.JCR_PREDECESSORS; +import static org.apache.jackrabbit.JcrConstants.JCR_ROOTVERSION; +import static org.apache.jackrabbit.JcrConstants.JCR_UUID; +import static org.apache.jackrabbit.JcrConstants.JCR_VERSIONHISTORY; +import static org.apache.jackrabbit.JcrConstants.MIX_VERSIONABLE; +import static org.apache.jackrabbit.oak.api.Type.REFERENCE; +import static org.apache.jackrabbit.oak.api.Type.REFERENCES; +import static org.apache.jackrabbit.oak.plugins.memory.MultiGenericPropertyState.nameProperty; + +/** + * The SimpleVersionableEditor converts the nodes under simple versioning into + * full versioning. + */ +public class SimpleVersionableEditor extends DefaultEditor { + + private static final String JCR_FROZEN_MIXIN_TYPES = "jcr:frozenMixinTypes"; + + static final String MIX_SIMPLE_VERSIONABLE = "mix:simpleVersionable"; + + private final NodeBuilder rootBuilder; + + private final NodeBuilder builder; + + private final TypePredicate isSimpleVersionable; + + private SimpleVersionableEditor(NodeBuilder rootBuilder) { + this.builder = rootBuilder; + this.rootBuilder = rootBuilder; + this.isSimpleVersionable = new TypePredicate(rootBuilder.getNodeState(), MIX_SIMPLE_VERSIONABLE); + } + + private SimpleVersionableEditor(SimpleVersionableEditor parent, NodeBuilder builder) { + this.builder = builder; + this.rootBuilder = parent.rootBuilder; + this.isSimpleVersionable = parent.isSimpleVersionable; + } + + public static class Provider implements EditorProvider { + @Override + public Editor getRootEditor(NodeState before, NodeState after, NodeBuilder builder, CommitInfo info) + throws CommitFailedException { + return new SimpleVersionableEditor(builder); + } + } + + @Override + public Editor childNodeAdded(String name, NodeState after) throws CommitFailedException { + NodeBuilder node = builder.getChildNode(name); + if (updateMixins(node, JCR_FROZEN_MIXIN_TYPES)) { + return null; + } else if (updateMixins(node, JCR_MIXINTYPES)) { + addProperties(node); + return null; + } else { + return new SimpleVersionableEditor(this, node); + } + } + + private static boolean updateMixins(NodeBuilder builder, String propertyName) { + if (builder.hasProperty(propertyName)) { + final Set mixins = newHashSet(builder.getProperty(propertyName).getValue(Type.NAMES)); + if (mixins.remove(MIX_SIMPLE_VERSIONABLE)) { + mixins.add(MIX_VERSIONABLE); + builder.setProperty(nameProperty(propertyName, mixins)); + return true; + } + } + return false; + } + + private void addProperties(NodeBuilder node) { + NodeState versionHistory = VersionHistoryUtil.getVersionHistoryNodeState(rootBuilder.getNodeState(), node.getString(JCR_UUID)); + + String baseVersion = getLastVersion(versionHistory); + node.setProperty(JCR_VERSIONHISTORY, versionHistory.getString(JCR_UUID), REFERENCE); + node.setProperty(JCR_BASEVERSION, baseVersion, REFERENCE); + List predecessors = new ArrayList(); + if (node.getBoolean(JcrConstants.JCR_ISCHECKEDOUT)) { + predecessors.add(baseVersion); + } + node.setProperty(JCR_PREDECESSORS, predecessors, REFERENCES); + } + + private String getLastVersion(NodeState versionHistory) { + NodeState lastVersion = versionHistory.getChildNode(JCR_ROOTVERSION); + for (ChildNodeEntry child : versionHistory.getChildNodeEntries()) { + if (!JCR_ROOTVERSION.equals(child.getName()) && isSimpleVersionable.apply(child.getNodeState())) { + lastVersion = child.getNodeState(); + } + } + return lastVersion.getString(JCR_UUID); + } + + @Override + public Editor childNodeChanged(String name, NodeState before, NodeState after) throws CommitFailedException { + return childNodeAdded(name, after); + } +} diff --git a/oak-upgrade/src/main/java/org/apache/jackrabbit/oak/upgrade/version/VersionableEditor.java b/oak-upgrade/src/main/java/org/apache/jackrabbit/oak/upgrade/version/VersionableEditor.java index 1473811..ce52f81 100644 --- a/oak-upgrade/src/main/java/org/apache/jackrabbit/oak/upgrade/version/VersionableEditor.java +++ b/oak-upgrade/src/main/java/org/apache/jackrabbit/oak/upgrade/version/VersionableEditor.java @@ -31,6 +31,7 @@ import java.util.Set; import static com.google.common.collect.ImmutableSet.of; import static com.google.common.collect.Sets.newHashSet; +import static java.util.Arrays.asList; import static org.apache.jackrabbit.JcrConstants.JCR_BASEVERSION; import static org.apache.jackrabbit.JcrConstants.JCR_ISCHECKEDOUT; import static org.apache.jackrabbit.JcrConstants.JCR_MIXINTYPES; @@ -41,6 +42,7 @@ import static org.apache.jackrabbit.JcrConstants.MIX_REFERENCEABLE; import static org.apache.jackrabbit.JcrConstants.MIX_VERSIONABLE; import static org.apache.jackrabbit.oak.plugins.memory.MultiGenericPropertyState.nameProperty; import static org.apache.jackrabbit.oak.plugins.version.VersionConstants.MIX_REP_VERSIONABLE_PATHS; +import static org.apache.jackrabbit.oak.upgrade.version.SimpleVersionableEditor.MIX_SIMPLE_VERSIONABLE; /** * The VersionableEditor provides two possible ways to handle @@ -66,6 +68,8 @@ public class VersionableEditor extends DefaultEditor { private final TypePredicate isVersionable; + private final TypePredicate isSimpleVersionable; + private final VersionCopier versionCopier; private String path; @@ -75,6 +79,7 @@ public class VersionableEditor extends DefaultEditor { this.rootBuilder = builder; this.isVersionable = new TypePredicate(builder.getNodeState(), MIX_VERSIONABLE); this.isReferenceable = new TypePredicate(builder.getNodeState(), MIX_REFERENCEABLE); + this.isSimpleVersionable = new TypePredicate(builder.getNodeState(), MIX_SIMPLE_VERSIONABLE); this.versionCopier = new VersionCopier(provider.sourceRoot, builder); this.path = "/"; } @@ -111,7 +116,7 @@ public class VersionableEditor extends DefaultEditor { this.path = path; final VersionCopyConfiguration c = provider.config; - if (isVersionable.apply(after)) { + if (isVersionable.apply(after) || isSimpleVersionable.apply(after)) { final String versionableUuid = getProperty(after, JCR_UUID, Type.STRING); boolean versionHistoryExists = isVersionHistoryExists(versionableUuid); if (c.isCopyVersions() && c.skipOrphanedVersionsCopy()) { @@ -156,14 +161,14 @@ public class VersionableEditor extends DefaultEditor { private void removeVersionProperties(final NodeBuilder versionableBuilder) { assert versionableBuilder.exists(); - removeMixin(versionableBuilder, MIX_VERSIONABLE); - // we don't know if the UUID is otherwise referenced, // so make sure the node remains referencable if (!isReferenceable.apply(versionableBuilder.getNodeState())) { addMixin(versionableBuilder, MIX_REFERENCEABLE); } + removeMixin(versionableBuilder, MIX_VERSIONABLE, MIX_SIMPLE_VERSIONABLE); + versionableBuilder.removeProperty(JCR_VERSIONHISTORY); versionableBuilder.removeProperty(JCR_PREDECESSORS); versionableBuilder.removeProperty(JCR_BASEVERSION); @@ -211,10 +216,10 @@ public class VersionableEditor extends DefaultEditor { } } - private static void removeMixin(NodeBuilder builder, String name) { + private static void removeMixin(NodeBuilder builder, String... name) { if (builder.hasProperty(JCR_MIXINTYPES)) { final Set mixins = newHashSet(builder.getProperty(JCR_MIXINTYPES).getValue(Type.NAMES)); - if (mixins.remove(name)) { + if (mixins.removeAll(asList(name))) { if (mixins.isEmpty()) { builder.removeProperty(JCR_MIXINTYPES); } else { diff --git a/oak-upgrade/src/test/java/org/apache/jackrabbit/oak/upgrade/CopyVersionHistoryTest.java b/oak-upgrade/src/test/java/org/apache/jackrabbit/oak/upgrade/CopyVersionHistoryTest.java index ae3f461..69298b6 100644 --- a/oak-upgrade/src/test/java/org/apache/jackrabbit/oak/upgrade/CopyVersionHistoryTest.java +++ b/oak-upgrade/src/test/java/org/apache/jackrabbit/oak/upgrade/CopyVersionHistoryTest.java @@ -16,6 +16,7 @@ */ package org.apache.jackrabbit.oak.upgrade; +import org.apache.jackrabbit.JcrConstants; import org.apache.jackrabbit.core.RepositoryContext; import org.apache.jackrabbit.core.config.RepositoryConfig; import org.apache.jackrabbit.oak.Oak; @@ -27,6 +28,7 @@ import org.apache.jackrabbit.oak.upgrade.util.VersionCopyTestUtils.VersionCopySe import org.apache.jackrabbit.oak.upgrade.version.VersionCopyConfiguration; import org.junit.After; import org.junit.AfterClass; +import org.junit.Assert; import org.junit.Test; import javax.jcr.Node; @@ -34,6 +36,8 @@ import javax.jcr.Property; import javax.jcr.PropertyType; import javax.jcr.RepositoryException; import javax.jcr.Session; +import javax.jcr.version.VersionHistory; +import javax.jcr.version.VersionIterator; import javax.jcr.version.VersionManager; import java.io.File; @@ -48,7 +52,6 @@ import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; import static org.apache.jackrabbit.oak.plugins.version.VersionConstants.MIX_REP_VERSIONABLE_PATHS; import static org.apache.jackrabbit.oak.upgrade.util.VersionCopyTestUtils.createVersionableNode; -import static org.apache.jackrabbit.oak.upgrade.util.VersionCopyTestUtils.isVersionable; public class CopyVersionHistoryTest extends AbstractRepositoryUpgradeTest { @@ -78,13 +81,17 @@ public class CopyVersionHistoryTest extends AbstractRepositoryUpgradeTest { @Override protected void createSourceContent(Session session) throws Exception { - oldHistory = createVersionableNode(session, VERSIONABLES_OLD); - oldOrphanedHistory = createVersionableNode(session, VERSIONABLES_OLD_ORPHANED); + createVersionables(session, false); + } + + protected void createVersionables(Session session, boolean simpleVersioning) throws Exception { + oldHistory = createVersionableNode(session, VERSIONABLES_OLD, simpleVersioning); + oldOrphanedHistory = createVersionableNode(session, VERSIONABLES_OLD_ORPHANED, simpleVersioning); Thread.sleep(10); betweenHistories = Calendar.getInstance(); Thread.sleep(10); - youngOrphanedHistory = createVersionableNode(session, VERSIONABLES_YOUNG_ORPHANED); - youngHistory = createVersionableNode(session, VERSIONABLES_YOUNG); + youngOrphanedHistory = createVersionableNode(session, VERSIONABLES_YOUNG_ORPHANED, simpleVersioning); + youngHistory = createVersionableNode(session, VERSIONABLES_YOUNG, simpleVersioning); session.getNode(VERSIONABLES_OLD_ORPHANED).remove(); session.getNode(VERSIONABLES_YOUNG_ORPHANED).remove(); @@ -110,10 +117,9 @@ public class CopyVersionHistoryTest extends AbstractRepositoryUpgradeTest { // copying all versions is enabled by default } }); - assertTrue(isVersionable(session, VERSIONABLES_OLD)); - assertTrue(isVersionable(session, VERSIONABLES_YOUNG)); - assertExisting(session, oldOrphanedHistory, youngOrphanedHistory, oldHistory, youngHistory); - assertHasVersionablePath(session, oldHistory, youngHistory); + assertHasVersionHistory(session, VERSIONABLES_OLD); + assertHasVersionHistory(session, VERSIONABLES_YOUNG); + assertExisting(session, oldOrphanedHistory, youngOrphanedHistory); } @Test @@ -125,11 +131,9 @@ public class CopyVersionHistoryTest extends AbstractRepositoryUpgradeTest { } }); - assertFalse(isVersionable(session, VERSIONABLES_OLD)); - assertTrue(isVersionable(session, VERSIONABLES_YOUNG)); + assertHasVersionHistory(session, VERSIONABLES_YOUNG); assertMissing(session, oldHistory, oldOrphanedHistory); - assertExisting(session, youngHistory, youngOrphanedHistory); - assertHasVersionablePath(session, youngHistory); + assertExisting(session, youngOrphanedHistory); } @Test @@ -141,11 +145,10 @@ public class CopyVersionHistoryTest extends AbstractRepositoryUpgradeTest { } }); - assertTrue(isVersionable(session, VERSIONABLES_OLD)); - assertTrue(isVersionable(session, VERSIONABLES_YOUNG)); + assertHasVersionHistory(session, VERSIONABLES_OLD); + assertHasVersionHistory(session, VERSIONABLES_YOUNG); assertMissing(session, oldOrphanedHistory); - assertExisting(session, oldHistory, youngHistory, youngOrphanedHistory); - assertHasVersionablePath(session, oldHistory, youngHistory); + assertExisting(session, youngOrphanedHistory); } @Test @@ -156,11 +159,9 @@ public class CopyVersionHistoryTest extends AbstractRepositoryUpgradeTest { config.setCopyOrphanedVersions(null); } }); - assertTrue(isVersionable(session, VERSIONABLES_OLD)); - assertTrue(isVersionable(session, VERSIONABLES_YOUNG)); + assertHasVersionHistory(session, VERSIONABLES_OLD); + assertHasVersionHistory(session, VERSIONABLES_YOUNG); assertMissing(session, oldOrphanedHistory, youngOrphanedHistory); - assertExisting(session, oldHistory, youngHistory); - assertHasVersionablePath(session, oldHistory, youngHistory); } @Test @@ -172,29 +173,12 @@ public class CopyVersionHistoryTest extends AbstractRepositoryUpgradeTest { config.setCopyOrphanedVersions(null); } }); - assertFalse(isVersionable(session, VERSIONABLES_OLD)); - assertTrue(isVersionable(session, VERSIONABLES_YOUNG)); + assertHasVersionHistory(session, VERSIONABLES_YOUNG); assertMissing(session, oldHistory, oldOrphanedHistory, youngOrphanedHistory); - assertExisting(session, youngHistory); - assertHasVersionablePath(session, youngHistory); } @Test - public void onlyOrphaned() throws RepositoryException, IOException { - Session session = performCopy(new VersionCopySetup() { - @Override - public void setup(VersionCopyConfiguration config) { - config.setCopyVersions(null); - } - }); - - assertFalse(isVersionable(session, VERSIONABLES_OLD)); - assertFalse(isVersionable(session, VERSIONABLES_YOUNG)); - assertMissing(session, oldHistory, youngHistory, oldOrphanedHistory, youngOrphanedHistory); - } - - @Test - public void onlyOrphanedAfterDate() throws RepositoryException, IOException { + public void overrideOrphaned() throws RepositoryException, IOException { Session session = performCopy(new VersionCopySetup() { @Override public void setup(VersionCopyConfiguration config) { @@ -203,8 +187,6 @@ public class CopyVersionHistoryTest extends AbstractRepositoryUpgradeTest { } }); - assertFalse(isVersionable(session, VERSIONABLES_OLD)); - assertFalse(isVersionable(session, VERSIONABLES_YOUNG)); assertMissing(session, oldHistory, youngHistory, oldOrphanedHistory, youngOrphanedHistory); } @@ -218,8 +200,6 @@ public class CopyVersionHistoryTest extends AbstractRepositoryUpgradeTest { } }); - assertFalse(isVersionable(session, VERSIONABLES_OLD)); - assertFalse(isVersionable(session, VERSIONABLES_YOUNG)); assertMissing(session, oldHistory, youngHistory, oldOrphanedHistory, youngOrphanedHistory); } @@ -264,18 +244,24 @@ public class CopyVersionHistoryTest extends AbstractRepositoryUpgradeTest { assertFalse("node " + path + " should not exist", session.getRootNode().hasNode(relPath)); } } - - public static void assertHasVersionablePath(final Session session, final String... historyPaths) throws RepositoryException { - for (String historyPath : historyPaths) { - final String workspaceName = session.getWorkspace().getName(); - final Node versionHistory = session.getNode(historyPath); - assertTrue(versionHistory.isNodeType(MIX_REP_VERSIONABLE_PATHS)); - assertTrue(versionHistory.hasProperty(workspaceName)); - final Property pathProperty = versionHistory.getProperty(workspaceName); - assertEquals(PropertyType.PATH, pathProperty.getType()); - - final VersionManager vm = session.getWorkspace().getVersionManager(); - assertEquals(historyPath, vm.getVersionHistory(pathProperty.getString()).getPath()); - } + + public static void assertHasVersionHistory(Session session, String path) throws RepositoryException { + Node node = session.getNode(path); + assertTrue(node.isNodeType(JcrConstants.MIX_VERSIONABLE)); + + VersionManager vMgr = session.getWorkspace().getVersionManager(); + VersionHistory history = vMgr.getVersionHistory(path); + VersionIterator vIt = history.getAllVersions(); + assertFalse(vIt.nextVersion().getFrozenNode().hasProperty("version")); //jcr:root + assertEquals("1.0", vIt.nextVersion().getFrozenNode().getProperty("version").getString()); + assertEquals("1.1", vIt.nextVersion().getFrozenNode().getProperty("version").getString()); + assertEquals("1.2", vIt.nextVersion().getFrozenNode().getProperty("version").getString()); + + final String workspaceName = session.getWorkspace().getName(); + assertTrue(history.isNodeType(MIX_REP_VERSIONABLE_PATHS)); + assertTrue(history.hasProperty(workspaceName)); + final Property pathProperty = history.getProperty(workspaceName); + assertEquals(PropertyType.PATH, pathProperty.getType()); + assertEquals(path, pathProperty.getString()); } } diff --git a/oak-upgrade/src/test/java/org/apache/jackrabbit/oak/upgrade/SimpleVersionableSupportTest.java b/oak-upgrade/src/test/java/org/apache/jackrabbit/oak/upgrade/SimpleVersionableSupportTest.java new file mode 100644 index 0000000..5c38d72 --- /dev/null +++ b/oak-upgrade/src/test/java/org/apache/jackrabbit/oak/upgrade/SimpleVersionableSupportTest.java @@ -0,0 +1,28 @@ +/* + * 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.jackrabbit.oak.upgrade; + +import javax.jcr.Session; + +public class SimpleVersionableSupportTest extends CopyVersionHistoryTest { + + @Override + protected void createSourceContent(Session session) throws Exception { + createVersionables(session, true); + } + +} diff --git a/oak-upgrade/src/test/java/org/apache/jackrabbit/oak/upgrade/util/VersionCopyTestUtils.java b/oak-upgrade/src/test/java/org/apache/jackrabbit/oak/upgrade/util/VersionCopyTestUtils.java index 51d4cbf..c4bcf53 100644 --- a/oak-upgrade/src/test/java/org/apache/jackrabbit/oak/upgrade/util/VersionCopyTestUtils.java +++ b/oak-upgrade/src/test/java/org/apache/jackrabbit/oak/upgrade/util/VersionCopyTestUtils.java @@ -32,12 +32,16 @@ import org.apache.jackrabbit.oak.upgrade.version.VersionCopyConfiguration; public class VersionCopyTestUtils { - public static String createVersionableNode(Session session, String versionablePath) + public static String createVersionableNode(Session session, String versionablePath, boolean simpleVersionable) throws RepositoryException, InterruptedException { final VersionManager versionManager = session.getWorkspace().getVersionManager(); final Node versionable = JcrUtils.getOrCreateUniqueByPath(session.getRootNode(), versionablePath, JcrConstants.NT_UNSTRUCTURED); - versionable.addMixin("mix:versionable"); + if (simpleVersionable) { + versionable.addMixin("mix:simpleVersionable"); + } else { + versionable.addMixin("mix:versionable"); + } versionable.setProperty("version", "root"); session.save(); @@ -57,10 +61,6 @@ public class VersionCopyTestUtils { return history.getPath(); } - public static boolean isVersionable(Session session, String path) throws RepositoryException { - return session.getNode(path).isNodeType(JcrConstants.MIX_VERSIONABLE); - } - public interface VersionCopySetup { void setup(VersionCopyConfiguration config); }