shared/modules/impl-vlt/src/test/java/org/apache/sling/ide/impl/vlt/AddOrUpdateNodeCommandTest.java - sling-ide-tooling - Git at Google

 /*
  * 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.sling.ide.impl.vlt;

 import static org.apache.sling.ide.transport.Repository.CommandExecutionFlag.CREATE_ONLY_WHEN_MISSING;
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.junit.Assert.assertThat;

 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.util.concurrent.Callable;

 import javax.jcr.Credentials;
 import javax.jcr.Node;
 import javax.jcr.Property;
 import javax.jcr.Repository;
 import javax.jcr.RepositoryException;
 import javax.jcr.Session;
 import javax.jcr.SimpleCredentials;
 import javax.jcr.UnsupportedRepositoryOperationException;
 import javax.jcr.Value;
 import javax.jcr.nodetype.InvalidNodeTypeDefinitionException;
 import javax.jcr.nodetype.NodeType;
 import javax.jcr.nodetype.NodeTypeExistsException;

 import org.apache.jackrabbit.commons.cnd.CndImporter;
 import org.apache.jackrabbit.commons.cnd.ParseException;
 import org.apache.jackrabbit.core.TransientRepository;
 import org.apache.sling.ide.filter.Filter;
 import org.apache.sling.ide.filter.FilterResult;
 import org.apache.sling.ide.log.Logger;
 import org.apache.sling.ide.transport.CommandContext;
 import org.apache.sling.ide.transport.ResourceProxy;
 import org.hamcrest.Matchers;
 import org.junit.Ignore;
 import org.junit.Test;

 public class AddOrUpdateNodeCommandTest {

     private static final CommandContext DEFAULT_CONTEXT = new CommandContext(new Filter() {
         @Override
         public FilterResult filter(String repositoryPath) {
             return FilterResult.ALLOW;
         }
     });

     private static final String PROP_NAME = "jcr:title";

     private Logger logger = new Slf4jLogger();

     @Test
     public void setProperty() throws Exception {

         doPropertyChangeTest(null, "Title");
     }

     private void doPropertyChangeTest(final Object initialPropertyValues, final Object newPropertyValues)
             throws Exception {

         doWithTransientRepository(new CallableWithSession() {
             @Override
             public Void call() throws Exception {
                 Node contentNode = session().getRootNode().addNode("content");
                 if (initialPropertyValues instanceof String) {
                     contentNode.setProperty(PROP_NAME, (String) initialPropertyValues);
                 } else if (initialPropertyValues instanceof String[]) {
                     contentNode.setProperty(PROP_NAME, (String[]) initialPropertyValues);
                 }

                 session().save();

                 ResourceProxy resource = newResource("/content", NodeType.NT_UNSTRUCTURED);
                 if (newPropertyValues != null) {
                     resource.addProperty(PROP_NAME, newPropertyValues);
                 }

                 AddOrUpdateNodeCommand cmd = new AddOrUpdateNodeCommand(repo(), credentials(), DEFAULT_CONTEXT, null, resource, logger);
                 cmd.execute().get();

                 session().refresh(false);

                 if (newPropertyValues == null) {
                     assertThat(session().getNode("/content").hasProperty(PROP_NAME), equalTo(false));
                     return null;
                 }

                 Property newProp = session().getNode("/content").getProperty(PROP_NAME);
                 if (newPropertyValues instanceof String) {
                     assertThat("property.isMultiple", newProp.isMultiple(), equalTo(Boolean.FALSE));
                     assertThat(newProp.getString(), equalTo((String) newPropertyValues));

                 } else {

                     String[] expectedValues = (String[]) newPropertyValues;
                     assertThat("property.isMultiple", newProp.isMultiple(), equalTo(Boolean.TRUE));

                     Value[] values = session().getNode("/content").getProperty(PROP_NAME).getValues();

                     assertThat(values.length, equalTo(expectedValues.length));
                     for (int i = 0; i < values.length; i++) {
                         assertThat(values[i].getString(), equalTo(expectedValues[i]));
                     }

                 }

                 return null;
             }
         });

     }

     @Test
     public void removeProperty() throws Exception {

         doPropertyChangeTest("Title", null);
     }

     @Test
     public void singlePropertyToMultiValued() throws Exception {

         doPropertyChangeTest("Title", new String[] { "Title", "Title 2" });
     }

     @Test
     public void multiValuesPropertyToSingle() throws Exception {

         doPropertyChangeTest(new String[] { "Title", "Title 2" }, "Title");
     }

     @Test
     public void changeNtFolderToSlingFolderWithAddedProperty() throws Exception {

         doWithTransientRepository(new CallableWithSession() {
             @Override
             public Void call() throws Exception {
                 session().getRootNode().addNode("content", "nt:folder");

                 session().save();

                 ResourceProxy resource = newResource("/content", "sling:Folder");
                 resource.getProperties().put("newProperty", "some/value");

                 AddOrUpdateNodeCommand cmd = new AddOrUpdateNodeCommand(repo(), credentials(), DEFAULT_CONTEXT, null, resource, logger);
                 cmd.execute().get();

                 session().refresh(false);

                 Node content = session().getRootNode().getNode("content");
                 assertThat(content.getPrimaryNodeType().getName(), equalTo("sling:Folder"));

                 return null;
             }
         });
     }

     @Test
     public void changeSlingFolderToNtFolderWithExistingProperty() throws Exception {
         doWithTransientRepository(new CallableWithSession() {
             @Override
             public Void call() throws Exception {
                 Node content = session().getRootNode().addNode("content", "sling:Folder");
                 content.setProperty("newProperty", "some/value");

                 session().save();

                 ResourceProxy resource = newResource("/content", "nt:folder");

                 AddOrUpdateNodeCommand cmd = new AddOrUpdateNodeCommand(repo(), credentials(), DEFAULT_CONTEXT, null, resource, logger);
                 cmd.execute().get();

                 session().refresh(false);

                 content = session().getRootNode().getNode("content");
                 assertThat(content.getPrimaryNodeType().getName(), equalTo("nt:folder"));

                 return null;
             }
         });
     }

     @Test
     @Ignore("SLING-4036")
     public void updateNtUnstructuredToNodeWithRequiredProperty() throws Exception {

         doWithTransientRepository(new CallableWithSession() {
             @Override
             public Void call() throws Exception {
                 Node content = session().getRootNode().addNode("content", "nt:unstructured");

                 session().save();

                 ResourceProxy resource = newResource("/content", "custom");
                 resource.getProperties().put("attribute", "some value");

                 AddOrUpdateNodeCommand cmd = new AddOrUpdateNodeCommand(repo(), credentials(), DEFAULT_CONTEXT, null, resource, logger);
                 cmd.execute().get();

                 session().refresh(false);

                 content = session().getRootNode().getNode("content");
                 assertThat(content.getPrimaryNodeType().getName(), equalTo("custom"));

                 return null;
             }
         });
     }

     @Test
     public void nodeNotPresentButOutsideOfFilterIsNotRemoved() throws Exception {

         final CommandContext context = new CommandContext(new Filter() {

             @Override
             public FilterResult filter(String repositoryPath) {
                 if ( repositoryPath.equals("/content/not-included-child")) {
                     return FilterResult.DENY;
                 }

                 return FilterResult.ALLOW;
             }
         });

         doWithTransientRepository(new CallableWithSession() {
             @Override
             public Void call() throws Exception {
                 Node content = session().getRootNode().addNode("content", "nt:unstructured");
                 content.addNode("included-child");
                 content.addNode("not-included-child");

                 session().save();

                 ResourceProxy resource = newResource("/content", "nt:unstructured");
                 resource.addChild(newResource("/content/included-child", "nt:unstructured"));

                 AddOrUpdateNodeCommand cmd = new AddOrUpdateNodeCommand(repo(), credentials(), context, null, resource, logger);
                 cmd.execute().get();

                 session().refresh(false);

                 content = session().getRootNode().getNode("content");
                 content.getNode("included-child");
                 content.getNode("not-included-child");
                 return null;
             }
         });

     }

     private ResourceProxy newResource(String path, String primaryType) {

         ResourceProxy resource = new ResourceProxy(path);
         resource.addProperty("jcr:primaryType", primaryType);
         return resource;
     }

     @Test
     public void createIfRequiredFlagSkipsExistingResources() throws Exception {

         doWithTransientRepository(new CallableWithSession() {
             @Override
             public Void call() throws Exception {
                 Node content = session().getRootNode().addNode("content", "nt:folder");

                 session().save();

                 ResourceProxy resource = newResource("/content", "nt:unstructured");

                 AddOrUpdateNodeCommand cmd = new AddOrUpdateNodeCommand(repo(), credentials(), DEFAULT_CONTEXT, null, resource, logger,
                         CREATE_ONLY_WHEN_MISSING);
                 cmd.execute().get();

                 session().refresh(false);

                 content = session().getRootNode().getNode("content");
                 assertThat(content.getPrimaryNodeType().getName(), equalTo("nt:folder"));

                 return null;
             }
         });
     }

     @Test
     public void createIfRequiredFlagCreatesNeededResources() throws Exception {

         doWithTransientRepository(new CallableWithSession() {
             @Override
             public Void call() throws Exception {
                 ResourceProxy resource = newResource("/content", "nt:unstructured");

                 AddOrUpdateNodeCommand cmd = new AddOrUpdateNodeCommand(repo(), credentials(), DEFAULT_CONTEXT, null, resource, logger,
                         CREATE_ONLY_WHEN_MISSING);
                 cmd.execute().get();

                 session().refresh(false);

                 Node content = session().getRootNode().getNode("content");
                 assertThat(content.getPrimaryNodeType().getName(), equalTo("nt:unstructured"));

                 return null;
             }
         });
     }

     @Test
     public void createIfRequiredFlagCreatesNeededResourcesEvenWhenPrimaryTypeIsMissing() throws Exception {

         doWithTransientRepository(new CallableWithSession() {
             @Override
             public Void call() throws Exception {
                 ResourceProxy resource = new ResourceProxy("/content");

                 AddOrUpdateNodeCommand cmd = new AddOrUpdateNodeCommand(repo(), credentials(), DEFAULT_CONTEXT, null, resource, logger,
                         CREATE_ONLY_WHEN_MISSING);
                 cmd.execute().get();

                 session().refresh(false);

                 Node content = session().getRootNode().getNode("content");
                 assertThat(content.getPrimaryNodeType().getName(), equalTo("nt:unstructured"));

                 return null;
             }
         });
     }

     @Test
     public void autoCreatedPropertiesAreNotRemoved() throws Exception {

         doWithTransientRepository(new CallableWithSession() {
             @Override
             public Void call() throws Exception {
                 Node content = session().getRootNode().addNode("content", "nt:folder");

                 session().save();

                 ResourceProxy resource = newResource("/content", "nt:folder");
                 resource.addProperty("jcr:mixinTypes", "mix:lastModified");

                 AddOrUpdateNodeCommand cmd = new AddOrUpdateNodeCommand(repo(), credentials(), DEFAULT_CONTEXT, null, resource, logger);
                 cmd.execute().get();
                 cmd.execute().get(); // second time since mixins are processed after properties so we need two
                                      // executions to
                                      // expose the problem

                 session().refresh(false);

                 content = session().getRootNode().getNode("content");
                 assertThat("jcr:lastModified property not present", content.hasProperty("jcr:lastModified"),
                         equalTo(true));
                 assertThat("jcr:lastModifiedBy property not present", content.hasProperty("jcr:lastModifiedBy"),
                         equalTo(true));

                 return null;
             }
         });
     }

     @Test
     public void autoCreatedPropertiesAreUpdatedIfPresent() throws Exception {

         doWithTransientRepository(new CallableWithSession() {
             @Override
             public Void call() throws Exception {
                 Node content = session().getRootNode().addNode("content", "nt:folder");

                 session().save();

                 ResourceProxy resource = newResource("/content", "nt:folder");
                 resource.addProperty("jcr:mixinTypes", "mix:lastModified");
                 resource.addProperty("jcr:lastModifiedBy", "admin2");

                 AddOrUpdateNodeCommand cmd = new AddOrUpdateNodeCommand(repo(), credentials(), DEFAULT_CONTEXT, null, resource, logger);
                 cmd.execute().get();
                 cmd.execute().get(); // second time since mixins are processed after properties so we need two
                                      // executions to
                                      // expose the problem

                 session().refresh(false);

                 content = session().getRootNode().getNode("content");
                 assertThat("jcr:lastModifiedBy property not modified", content.getProperty("jcr:lastModifiedBy")
                         .getString(), equalTo("admin2"));

                 return null;
             }
         });
     }

     @Test
     public void setEmptyMixinTypes() throws Exception {
         setMixinTypes0();
     }

     private void setMixinTypes0(final String... mixinTypeNames) throws Exception {

         doWithTransientRepository(new CallableWithSession() {
             @Override
             public Void call() throws Exception {
                 ResourceProxy resource = newResource("/content", "nt:unstructured");
                 resource.addProperty("jcr:mixinTypes", mixinTypeNames);

                 AddOrUpdateNodeCommand cmd = new AddOrUpdateNodeCommand(repo(), credentials(), DEFAULT_CONTEXT, null, resource, logger);
                 cmd.execute().get();

                 session().refresh(false);

                 Node content = session().getRootNode().getNode("content");
                 assertThat(content.getMixinNodeTypes(), Matchers.arrayWithSize(mixinTypeNames.length));

                 return null;
             }
         });
     }

     @Test
     public void setMixinTypes() throws Exception {

         setMixinTypes0("mix:created");
     }

     private void doWithTransientRepository(CallableWithSession callable) throws Exception {

         File out = new File(new File("target"), "jackrabbit");
         TransientRepository repo = new TransientRepository(new File(out, "repository.xml"), new File(out, "repository"));
         SimpleCredentials credentials = new SimpleCredentials("admin", "admin".toCharArray());
         Session session = repo.login(credentials);

         importNodeTypeDefinitions(session, "test-definitions.cnd");
         importNodeTypeDefinitions(session, "folder.cnd");

         try {
             callable.setCredentials(credentials);
             callable.setSession(session);
             callable.call();
         } finally {
             if (session.itemExists("/content"))
                 session.removeItem("/content");
             session.save();
             session.logout();
         }

     }

     private void importNodeTypeDefinitions(Session session, String cndFile) throws InvalidNodeTypeDefinitionException,
             NodeTypeExistsException, UnsupportedRepositoryOperationException, ParseException, RepositoryException,
             IOException {
         try ( InputStream cndInput = getClass().getResourceAsStream(cndFile) ) {
             if (cndInput == null) {
                 throw new IllegalArgumentException("Unable to read classpath resource " + cndFile);
             }
             CndImporter.registerNodeTypes(new InputStreamReader(cndInput), session);
         }
     }

     private static abstract class CallableWithSession implements Callable<Void> {

         private Session session;
         private Credentials credentials;

         public void setSession(Session session) {

             this.session = session;
         }

         public void setCredentials(Credentials credentials) {

             this.credentials = credentials;
         }

         protected Session session() {

             if (session == null)
                 throw new IllegalStateException("session is null");

             return session;
         }

         protected Credentials credentials() {

             if (credentials == null)
                 throw new IllegalStateException("credentials is null");

             return credentials;
         }

         protected Repository repo() {

             return session().getRepository();
         }
     }
 }
	/*
	* 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.sling.ide.impl.vlt;

	import static org.apache.sling.ide.transport.Repository.CommandExecutionFlag.CREATE_ONLY_WHEN_MISSING;
	import static org.hamcrest.CoreMatchers.equalTo;
	import static org.junit.Assert.assertThat;

	import java.io.File;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.InputStreamReader;
	import java.util.concurrent.Callable;

	import javax.jcr.Credentials;
	import javax.jcr.Node;
	import javax.jcr.Property;
	import javax.jcr.Repository;
	import javax.jcr.RepositoryException;
	import javax.jcr.Session;
	import javax.jcr.SimpleCredentials;
	import javax.jcr.UnsupportedRepositoryOperationException;
	import javax.jcr.Value;
	import javax.jcr.nodetype.InvalidNodeTypeDefinitionException;
	import javax.jcr.nodetype.NodeType;
	import javax.jcr.nodetype.NodeTypeExistsException;

	import org.apache.jackrabbit.commons.cnd.CndImporter;
	import org.apache.jackrabbit.commons.cnd.ParseException;
	import org.apache.jackrabbit.core.TransientRepository;
	import org.apache.sling.ide.filter.Filter;
	import org.apache.sling.ide.filter.FilterResult;
	import org.apache.sling.ide.log.Logger;
	import org.apache.sling.ide.transport.CommandContext;
	import org.apache.sling.ide.transport.ResourceProxy;
	import org.hamcrest.Matchers;
	import org.junit.Ignore;
	import org.junit.Test;

	public class AddOrUpdateNodeCommandTest {

	private static final CommandContext DEFAULT_CONTEXT = new CommandContext(new Filter() {
	@Override
	public FilterResult filter(String repositoryPath) {
	return FilterResult.ALLOW;
	}
	});

	private static final String PROP_NAME = "jcr:title";

	private Logger logger = new Slf4jLogger();

	@Test
	public void setProperty() throws Exception {

	doPropertyChangeTest(null, "Title");
	}

	private void doPropertyChangeTest(final Object initialPropertyValues, final Object newPropertyValues)
	throws Exception {

	doWithTransientRepository(new CallableWithSession() {
	@Override
	public Void call() throws Exception {
	Node contentNode = session().getRootNode().addNode("content");
	if (initialPropertyValues instanceof String) {
	contentNode.setProperty(PROP_NAME, (String) initialPropertyValues);
	} else if (initialPropertyValues instanceof String[]) {
	contentNode.setProperty(PROP_NAME, (String[]) initialPropertyValues);
	}

	session().save();

	ResourceProxy resource = newResource("/content", NodeType.NT_UNSTRUCTURED);
	if (newPropertyValues != null) {
	resource.addProperty(PROP_NAME, newPropertyValues);
	}

	AddOrUpdateNodeCommand cmd = new AddOrUpdateNodeCommand(repo(), credentials(), DEFAULT_CONTEXT, null, resource, logger);
	cmd.execute().get();

	session().refresh(false);

	if (newPropertyValues == null) {
	assertThat(session().getNode("/content").hasProperty(PROP_NAME), equalTo(false));
	return null;
	}

	Property newProp = session().getNode("/content").getProperty(PROP_NAME);
	if (newPropertyValues instanceof String) {
	assertThat("property.isMultiple", newProp.isMultiple(), equalTo(Boolean.FALSE));
	assertThat(newProp.getString(), equalTo((String) newPropertyValues));

	} else {

	String[] expectedValues = (String[]) newPropertyValues;
	assertThat("property.isMultiple", newProp.isMultiple(), equalTo(Boolean.TRUE));

	Value[] values = session().getNode("/content").getProperty(PROP_NAME).getValues();

	assertThat(values.length, equalTo(expectedValues.length));
	for (int i = 0; i < values.length; i++) {
	assertThat(values[i].getString(), equalTo(expectedValues[i]));
	}

	}

	return null;
	}
	});

	}

	@Test
	public void removeProperty() throws Exception {

	doPropertyChangeTest("Title", null);
	}

	@Test
	public void singlePropertyToMultiValued() throws Exception {

	doPropertyChangeTest("Title", new String[] { "Title", "Title 2" });
	}

	@Test
	public void multiValuesPropertyToSingle() throws Exception {

	doPropertyChangeTest(new String[] { "Title", "Title 2" }, "Title");
	}

	@Test
	public void changeNtFolderToSlingFolderWithAddedProperty() throws Exception {

	doWithTransientRepository(new CallableWithSession() {
	@Override
	public Void call() throws Exception {
	session().getRootNode().addNode("content", "nt:folder");

	session().save();

	ResourceProxy resource = newResource("/content", "sling:Folder");
	resource.getProperties().put("newProperty", "some/value");

	AddOrUpdateNodeCommand cmd = new AddOrUpdateNodeCommand(repo(), credentials(), DEFAULT_CONTEXT, null, resource, logger);
	cmd.execute().get();

	session().refresh(false);

	Node content = session().getRootNode().getNode("content");
	assertThat(content.getPrimaryNodeType().getName(), equalTo("sling:Folder"));

	return null;
	}
	});
	}

	@Test
	public void changeSlingFolderToNtFolderWithExistingProperty() throws Exception {
	doWithTransientRepository(new CallableWithSession() {
	@Override
	public Void call() throws Exception {
	Node content = session().getRootNode().addNode("content", "sling:Folder");
	content.setProperty("newProperty", "some/value");

	session().save();

	ResourceProxy resource = newResource("/content", "nt:folder");

	AddOrUpdateNodeCommand cmd = new AddOrUpdateNodeCommand(repo(), credentials(), DEFAULT_CONTEXT, null, resource, logger);
	cmd.execute().get();

	session().refresh(false);

	content = session().getRootNode().getNode("content");
	assertThat(content.getPrimaryNodeType().getName(), equalTo("nt:folder"));

	return null;
	}
	});
	}

	@Test
	@Ignore("SLING-4036")
	public void updateNtUnstructuredToNodeWithRequiredProperty() throws Exception {

	doWithTransientRepository(new CallableWithSession() {
	@Override
	public Void call() throws Exception {
	Node content = session().getRootNode().addNode("content", "nt:unstructured");

	session().save();

	ResourceProxy resource = newResource("/content", "custom");
	resource.getProperties().put("attribute", "some value");

	AddOrUpdateNodeCommand cmd = new AddOrUpdateNodeCommand(repo(), credentials(), DEFAULT_CONTEXT, null, resource, logger);
	cmd.execute().get();

	session().refresh(false);

	content = session().getRootNode().getNode("content");
	assertThat(content.getPrimaryNodeType().getName(), equalTo("custom"));

	return null;
	}
	});
	}

	@Test
	public void nodeNotPresentButOutsideOfFilterIsNotRemoved() throws Exception {

	final CommandContext context = new CommandContext(new Filter() {

	@Override
	public FilterResult filter(String repositoryPath) {
	if ( repositoryPath.equals("/content/not-included-child")) {
	return FilterResult.DENY;
	}

	return FilterResult.ALLOW;
	}
	});

	doWithTransientRepository(new CallableWithSession() {
	@Override
	public Void call() throws Exception {
	Node content = session().getRootNode().addNode("content", "nt:unstructured");
	content.addNode("included-child");
	content.addNode("not-included-child");

	session().save();

	ResourceProxy resource = newResource("/content", "nt:unstructured");
	resource.addChild(newResource("/content/included-child", "nt:unstructured"));

	AddOrUpdateNodeCommand cmd = new AddOrUpdateNodeCommand(repo(), credentials(), context, null, resource, logger);
	cmd.execute().get();

	session().refresh(false);

	content = session().getRootNode().getNode("content");
	content.getNode("included-child");
	content.getNode("not-included-child");
	return null;
	}
	});

	}

	private ResourceProxy newResource(String path, String primaryType) {

	ResourceProxy resource = new ResourceProxy(path);
	resource.addProperty("jcr:primaryType", primaryType);
	return resource;
	}

	@Test
	public void createIfRequiredFlagSkipsExistingResources() throws Exception {

	doWithTransientRepository(new CallableWithSession() {
	@Override
	public Void call() throws Exception {
	Node content = session().getRootNode().addNode("content", "nt:folder");

	session().save();

	ResourceProxy resource = newResource("/content", "nt:unstructured");

	AddOrUpdateNodeCommand cmd = new AddOrUpdateNodeCommand(repo(), credentials(), DEFAULT_CONTEXT, null, resource, logger,
	CREATE_ONLY_WHEN_MISSING);
	cmd.execute().get();

	session().refresh(false);

	content = session().getRootNode().getNode("content");
	assertThat(content.getPrimaryNodeType().getName(), equalTo("nt:folder"));

	return null;
	}
	});
	}

	@Test
	public void createIfRequiredFlagCreatesNeededResources() throws Exception {

	doWithTransientRepository(new CallableWithSession() {
	@Override
	public Void call() throws Exception {
	ResourceProxy resource = newResource("/content", "nt:unstructured");

	AddOrUpdateNodeCommand cmd = new AddOrUpdateNodeCommand(repo(), credentials(), DEFAULT_CONTEXT, null, resource, logger,
	CREATE_ONLY_WHEN_MISSING);
	cmd.execute().get();

	session().refresh(false);

	Node content = session().getRootNode().getNode("content");
	assertThat(content.getPrimaryNodeType().getName(), equalTo("nt:unstructured"));

	return null;
	}
	});
	}

	@Test
	public void createIfRequiredFlagCreatesNeededResourcesEvenWhenPrimaryTypeIsMissing() throws Exception {

	doWithTransientRepository(new CallableWithSession() {
	@Override
	public Void call() throws Exception {
	ResourceProxy resource = new ResourceProxy("/content");

	AddOrUpdateNodeCommand cmd = new AddOrUpdateNodeCommand(repo(), credentials(), DEFAULT_CONTEXT, null, resource, logger,
	CREATE_ONLY_WHEN_MISSING);
	cmd.execute().get();

	session().refresh(false);

	Node content = session().getRootNode().getNode("content");
	assertThat(content.getPrimaryNodeType().getName(), equalTo("nt:unstructured"));

	return null;
	}
	});
	}

	@Test
	public void autoCreatedPropertiesAreNotRemoved() throws Exception {

	doWithTransientRepository(new CallableWithSession() {
	@Override
	public Void call() throws Exception {
	Node content = session().getRootNode().addNode("content", "nt:folder");

	session().save();

	ResourceProxy resource = newResource("/content", "nt:folder");
	resource.addProperty("jcr:mixinTypes", "mix:lastModified");

	AddOrUpdateNodeCommand cmd = new AddOrUpdateNodeCommand(repo(), credentials(), DEFAULT_CONTEXT, null, resource, logger);
	cmd.execute().get();
	cmd.execute().get(); // second time since mixins are processed after properties so we need two
	// executions to
	// expose the problem

	session().refresh(false);

	content = session().getRootNode().getNode("content");
	assertThat("jcr:lastModified property not present", content.hasProperty("jcr:lastModified"),
	equalTo(true));
	assertThat("jcr:lastModifiedBy property not present", content.hasProperty("jcr:lastModifiedBy"),
	equalTo(true));

	return null;
	}
	});
	}

	@Test
	public void autoCreatedPropertiesAreUpdatedIfPresent() throws Exception {

	doWithTransientRepository(new CallableWithSession() {
	@Override
	public Void call() throws Exception {
	Node content = session().getRootNode().addNode("content", "nt:folder");

	session().save();

	ResourceProxy resource = newResource("/content", "nt:folder");
	resource.addProperty("jcr:mixinTypes", "mix:lastModified");
	resource.addProperty("jcr:lastModifiedBy", "admin2");

	AddOrUpdateNodeCommand cmd = new AddOrUpdateNodeCommand(repo(), credentials(), DEFAULT_CONTEXT, null, resource, logger);
	cmd.execute().get();
	cmd.execute().get(); // second time since mixins are processed after properties so we need two
	// executions to
	// expose the problem

	session().refresh(false);

	content = session().getRootNode().getNode("content");
	assertThat("jcr:lastModifiedBy property not modified", content.getProperty("jcr:lastModifiedBy")
	.getString(), equalTo("admin2"));

	return null;
	}
	});
	}

	@Test
	public void setEmptyMixinTypes() throws Exception {
	setMixinTypes0();
	}

	private void setMixinTypes0(final String... mixinTypeNames) throws Exception {

	doWithTransientRepository(new CallableWithSession() {
	@Override
	public Void call() throws Exception {
	ResourceProxy resource = newResource("/content", "nt:unstructured");
	resource.addProperty("jcr:mixinTypes", mixinTypeNames);

	AddOrUpdateNodeCommand cmd = new AddOrUpdateNodeCommand(repo(), credentials(), DEFAULT_CONTEXT, null, resource, logger);
	cmd.execute().get();

	session().refresh(false);

	Node content = session().getRootNode().getNode("content");
	assertThat(content.getMixinNodeTypes(), Matchers.arrayWithSize(mixinTypeNames.length));

	return null;
	}
	});
	}

	@Test
	public void setMixinTypes() throws Exception {

	setMixinTypes0("mix:created");
	}

	private void doWithTransientRepository(CallableWithSession callable) throws Exception {

	File out = new File(new File("target"), "jackrabbit");
	TransientRepository repo = new TransientRepository(new File(out, "repository.xml"), new File(out, "repository"));
	SimpleCredentials credentials = new SimpleCredentials("admin", "admin".toCharArray());
	Session session = repo.login(credentials);

	importNodeTypeDefinitions(session, "test-definitions.cnd");
	importNodeTypeDefinitions(session, "folder.cnd");

	try {
	callable.setCredentials(credentials);
	callable.setSession(session);
	callable.call();
	} finally {
	if (session.itemExists("/content"))
	session.removeItem("/content");
	session.save();
	session.logout();
	}

	}

	private void importNodeTypeDefinitions(Session session, String cndFile) throws InvalidNodeTypeDefinitionException,
	NodeTypeExistsException, UnsupportedRepositoryOperationException, ParseException, RepositoryException,
	IOException {
	try ( InputStream cndInput = getClass().getResourceAsStream(cndFile) ) {
	if (cndInput == null) {
	throw new IllegalArgumentException("Unable to read classpath resource " + cndFile);
	}
	CndImporter.registerNodeTypes(new InputStreamReader(cndInput), session);
	}
	}

	private static abstract class CallableWithSession implements Callable<Void> {

	private Session session;
	private Credentials credentials;

	public void setSession(Session session) {

	this.session = session;
	}

	public void setCredentials(Credentials credentials) {

	this.credentials = credentials;
	}

	protected Session session() {

	if (session == null)
	throw new IllegalStateException("session is null");

	return session;
	}

	protected Credentials credentials() {

	if (credentials == null)
	throw new IllegalStateException("credentials is null");

	return credentials;
	}

	protected Repository repo() {

	return session().getRepository();
	}
	}
	}