tests/org.eclipse.core.resources.semantic.test/src/org/eclipse/core/resources/semantic/test/TestsCachingProvider.java

/*******************************************************************************
 * Copyright (c) 2009 SAP AG.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Eduard Bartsch (SAP AG) - initial API and implementation
 *    Mathias Kinzler (SAP AG) - initial API and implementation
 *******************************************************************************/
package org.eclipse.core.resources.semantic.test;

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;

import junit.framework.Assert;

import org.eclipse.core.filesystem.EFS;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspaceRunnable;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.resources.semantic.ISemanticFile;
import org.eclipse.core.resources.semantic.ISemanticFileSystem;
import org.eclipse.core.resources.semantic.ISemanticFolder;
import org.eclipse.core.resources.semantic.SyncDirection;
import org.eclipse.core.resources.semantic.examples.remote.RemoteFile;
import org.eclipse.core.resources.semantic.examples.remote.RemoteStoreTransient;
import org.eclipse.core.resources.semantic.spi.Util;
import org.eclipse.core.resources.semantic.test.provider.CachingTestContentProvider;
import org.eclipse.core.resources.semantic.test.provider.CachingTestContentProviderBase;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.junit.Test;

/**
 * Caching Content provider tests
 * 
 */
public class TestsCachingProvider extends TestsContentProviderBase {

	private RemoteFile file1;

	@Override
	public void afterMethod() throws Exception {
		super.afterMethod();
		this.file1 = null;
	}

	@Override
	public void beforeMethod() throws Exception {
		super.beforeMethod();
		RemoteStoreTransient store = (RemoteStoreTransient) this.testProject.getAdapter(RemoteStoreTransient.class);
		this.file1 = (RemoteFile) store.getItemByPath(new Path("Folder1/File1"));

	}

	@Override
	public RemoteFile getRemoteFile() {
		return this.file1;
	}

	/**
	 * No-argument construcator
	 */
	public TestsCachingProvider() {
		super(false, "CachingTests", CachingTestContentProvider.class.getName());
	}

	/**
	 * 
	 * @throws Exception
	 */
	@Test
	public void testAddFileFromRemoteDeleteAndAddAgain() throws Exception {

		final IFolder root = this.testProject.getFolder("root");
		final IFolder parent = root.getFolder("Folder1");
		Assert.assertEquals("Folder existence", false, parent.exists());

		final IFile file = parent.getFile("File1");
		Assert.assertEquals("File existence", false, file.exists());

		IWorkspaceRunnable runnable = new IWorkspaceRunnable() {

			public void run(IProgressMonitor monitor) throws CoreException {
				ISemanticFolder sfr = (ISemanticFolder) parent.getAdapter(ISemanticFolder.class);
				ISemanticFile sfile = sfr.addFile("File1", TestsCachingProvider.this.options, monitor);
				Assert.assertTrue(sfile.getAdaptedFile().equals(file));
				file.getParent().refreshLocal(IResource.DEPTH_INFINITE, monitor);
				InputStream is = null;
				try {
					is = sfile.getAdaptedFile().getContents();
					try {
						Assert.assertTrue("Too few bytes available", is.available() > 0);
					} catch (IOException e) {
						// $JL-EXC$
						Assert.fail(e.getMessage());
					}
				} finally {
					Util.safeClose(is);
				}
			}
		};

		// we need to use the project since the root folder is not yet synched
		ResourcesPlugin.getWorkspace().run(runnable, this.testProject, 0, new NullProgressMonitor());

		Assert.assertEquals("File existence", true, file.exists());
		Assert.assertEquals("Folder existence", true, parent.exists());

		// we keep a file stream so that deletion goes wrong
		InputStream is = file.getContents();

		try {

			runnable = new IWorkspaceRunnable() {

				/**
				 * @throws CoreException
				 */
				public void run(IProgressMonitor monitor) throws CoreException {
					ISemanticFolder sfr = (ISemanticFolder) parent.getAdapter(ISemanticFolder.class);
					ISemanticFile sFile = (ISemanticFile) file.getAdapter(ISemanticFile.class);
					try {
						sFile.remove(TestsCachingProvider.this.options, monitor);
						sfr.getAdaptedResource().refreshLocal(IResource.DEPTH_ONE, monitor);
					} catch (CoreException e) {
						// $JL-EXC$
						Assert.fail("Remove failure");
					}

				}
			};

			ResourcesPlugin.getWorkspace().run(runnable, new NullProgressMonitor());

			Assert.assertEquals("File exsistence", false, file.exists());

			runnable = new IWorkspaceRunnable() {

				public void run(IProgressMonitor monitor) throws CoreException {
					ISemanticFolder sfr = (ISemanticFolder) parent.getAdapter(ISemanticFolder.class);
					// should work even if cache is deleted logically only
					ISemanticFile sfile = sfr.addFile("File1", TestsCachingProvider.this.options, monitor);
					// TODO verify that other operations fail
					// (write/read/timestamp)
					Assert.assertTrue(sfile.getAdaptedFile().equals(file));
					file.getParent().refreshLocal(IResource.DEPTH_INFINITE, monitor);
					InputStream is1 = null;
					try {
						is1 = sfile.getAdaptedFile().getContents();
						try {
							Assert.assertTrue("Too few bytes available", is1.available() > 0);
						} catch (IOException e) {
							// $JL-EXC$
							Assert.fail(e.getMessage());
						}
					} finally {
						Util.safeClose(is1);
					}
				}
			};

			try {
				// re-adding should not fail even if the input stream is still
				// open
				ResourcesPlugin.getWorkspace().run(runnable, new NullProgressMonitor());

			} catch (CoreException e) {
				// $JL-EXC$ expected

				Assert.fail("Should not fail");
			}
		} finally {
			Util.safeClose(is);
		}

		Assert.assertEquals("File existence", true, file.exists());

	}

	/**
	 * 
	 * @throws Exception
	 */
	@Test
	public void testWriteThrough() throws Exception {

		final IFolder root = this.testProject.getFolder("root");
		final IFolder parent = root.getFolder("Folder1");

		final IFile file = parent.getFile("File1");
		Assert.assertFalse("File should not exist", file.exists());

		IWorkspaceRunnable runnable = new IWorkspaceRunnable() {

			public void run(IProgressMonitor monitor) throws CoreException {
				ISemanticFolder sfr = (ISemanticFolder) parent.getAdapter(ISemanticFolder.class);
				sfr.addFile("File1", ISemanticFileSystem.NONE, monitor);
				Assert.assertEquals("File existence", true, file.exists());
			}
		};

		ResourcesPlugin.getWorkspace().run(runnable, new NullProgressMonitor());

		assertContentsEqual(file, "Hello");
		Assert.assertEquals("Wrong remote content", "Hello", new String(this.file1.getContent(), "UTF-8"));

		// setcontent without remote update
		runnable = new IWorkspaceRunnable() {

			public void run(IProgressMonitor monitor) throws CoreException {
				try {
					ISemanticFile sf = (ISemanticFile) file.getAdapter(ISemanticFile.class);
					IStatus stat = sf.validateEdit(null);

					Assert.assertTrue("ValidateEdit should have returned OK", stat.isOK());

					file.setContents(new ByteArrayInputStream("NewString".getBytes("UTF-8")), IResource.KEEP_HISTORY, monitor);

				} catch (UnsupportedEncodingException e) {
					// $JL-EXC$
					Assert.fail(e.getMessage());
				}
			}
		};

		ResourcesPlugin.getWorkspace().run(runnable, new NullProgressMonitor());

		assertContentsEqual(file, "NewString");
		Assert.assertEquals("Wrong remote content", "Hello", new String(this.file1.getContent(), "UTF-8"));

		// setcontent with remote update
		runnable = new IWorkspaceRunnable() {

			public void run(IProgressMonitor monitor) throws CoreException {
				try {
					ISemanticFile sf = (ISemanticFile) file.getAdapter(ISemanticFile.class);
					sf.setSessionProperty(CachingTestContentProviderBase.WRITE_THROUGH, "");

					IStatus stat = sf.validateEdit(null);

					Assert.assertTrue("ValidateEdit should have returned OK", stat.isOK());

					file.setContents(new ByteArrayInputStream("ThirdString".getBytes("UTF-8")), IResource.KEEP_HISTORY, monitor);

					sf.setSessionProperty(CachingTestContentProviderBase.WRITE_THROUGH, null);

				} catch (UnsupportedEncodingException e) {
					// $JL-EXC$
					Assert.fail(e.getMessage());
				}
			}
		};

		ResourcesPlugin.getWorkspace().run(runnable, new NullProgressMonitor());

		assertContentsEqual(file, "ThirdString");
		Assert.assertEquals("Wrong remote content", "ThirdString", new String(this.file1.getContent(), "UTF-8"));

		runnable = new IWorkspaceRunnable() {

			public void run(IProgressMonitor monitor) throws CoreException {
				ISemanticFile sf = (ISemanticFile) file.getAdapter(ISemanticFile.class);
				sf.remove(ISemanticFileSystem.NONE, null);
			}
		};

		ResourcesPlugin.getWorkspace().run(runnable, new NullProgressMonitor());

		Assert.assertEquals("File existence", false, file.exists());

	}

	@Test
	public void testBeforeCacheUpdate() throws Exception {

		final IFolder root = this.testProject.getFolder("root");
		final IFolder parent = root.getFolder("Folder1");

		final IFile file = parent.getFile("File1");
		Assert.assertFalse("File should not exist", file.exists());

		IWorkspaceRunnable runnable = new IWorkspaceRunnable() {

			public void run(IProgressMonitor monitor) throws CoreException {
				ISemanticFolder sfr = (ISemanticFolder) parent.getAdapter(ISemanticFolder.class);
				sfr.addFile("File1", ISemanticFileSystem.NONE, monitor);
				Assert.assertEquals("File existence", true, file.exists());
				ISemanticFile sf = (ISemanticFile) file.getAdapter(ISemanticFile.class);
				sf.setSessionProperty(CachingTestContentProviderBase.USE_BEFORE_CACHE_UPDATE, "x");
			}
		};

		ResourcesPlugin.getWorkspace().run(runnable, new NullProgressMonitor());

		assertContentsEqual(file, "Hello");
		Assert.assertEquals("Wrong remote content", "Hello", new String(this.file1.getContent(), "UTF-8"));

		// setcontent without remote update
		runnable = new IWorkspaceRunnable() {

			public void run(IProgressMonitor monitor) throws CoreException {
				try {
					ISemanticFile sf = (ISemanticFile) file.getAdapter(ISemanticFile.class);
					IStatus stat = sf.validateEdit(null);

					Assert.assertTrue("ValidateEdit should have returned OK", stat.isOK());

					file.setContents(new ByteArrayInputStream("NewString".getBytes("UTF-8")), IResource.KEEP_HISTORY, monitor);

				} catch (UnsupportedEncodingException e) {
					// $JL-EXC$
					Assert.fail(e.getMessage());
				}
			}
		};

		ResourcesPlugin.getWorkspace().run(runnable, new NullProgressMonitor());

		assertContentsEqual(file, "NewString");
		Assert.assertEquals("Wrong remote content", "Hello", new String(this.file1.getContent(), "UTF-8"));

		// setcontent with remote update
		runnable = new IWorkspaceRunnable() {

			public void run(IProgressMonitor monitor) throws CoreException {
				try {
					ISemanticFile sf = (ISemanticFile) file.getAdapter(ISemanticFile.class);
					sf.setSessionProperty(CachingTestContentProviderBase.WRITE_THROUGH, "");

					IStatus stat = sf.validateEdit(null);

					Assert.assertTrue("ValidateEdit should have returned OK", stat.isOK());

					file.setContents(new ByteArrayInputStream("ThirdString".getBytes("UTF-8")), IResource.KEEP_HISTORY, monitor);

					sf.setSessionProperty(CachingTestContentProviderBase.WRITE_THROUGH, null);

				} catch (UnsupportedEncodingException e) {
					// $JL-EXC$
					Assert.fail(e.getMessage());
				}
			}
		};

		ResourcesPlugin.getWorkspace().run(runnable, new NullProgressMonitor());

		assertContentsEqual(file, "ThirdString");
		Assert.assertEquals("Wrong remote content", "ThirdString", new String(this.file1.getContent(), "UTF-8"));

		runnable = new IWorkspaceRunnable() {

			public void run(IProgressMonitor monitor) throws CoreException {
				ISemanticFile sf = (ISemanticFile) file.getAdapter(ISemanticFile.class);
				sf.remove(ISemanticFileSystem.NONE, null);
			}
		};

		ResourcesPlugin.getWorkspace().run(runnable, new NullProgressMonitor());

		Assert.assertEquals("File existence", false, file.exists());

	}

	@Test
	public void testExceptionInBeforeCacheUpdate() throws Exception {

		final IFolder root = this.testProject.getFolder("root");
		final IFolder parent = root.getFolder("Folder1");

		final IFile file = parent.getFile("File1");
		Assert.assertFalse("File should not exist", file.exists());

		IWorkspaceRunnable runnable = new IWorkspaceRunnable() {

			public void run(IProgressMonitor monitor) throws CoreException {
				ISemanticFolder sfr = (ISemanticFolder) parent.getAdapter(ISemanticFolder.class);
				sfr.addFile("File1", ISemanticFileSystem.NONE, monitor);
				Assert.assertEquals("File existence", true, file.exists());
				ISemanticFile sf = (ISemanticFile) file.getAdapter(ISemanticFile.class);
				sf.setSessionProperty(CachingTestContentProviderBase.USE_BEFORE_CACHE_UPDATE, "x");
				sf.setSessionProperty(CachingTestContentProviderBase.EXCEPTION_IN_BEFORE_CACHE_UPDATE, "x");
			}
		};

		ResourcesPlugin.getWorkspace().run(runnable, new NullProgressMonitor());

		assertContentsEqual(file, "Hello");
		Assert.assertEquals("Wrong remote content", "Hello", new String(this.file1.getContent(), "UTF-8"));

		// setcontent without remote update
		runnable = new IWorkspaceRunnable() {

			public void run(IProgressMonitor monitor) throws CoreException {
				try {
					ISemanticFile sf = (ISemanticFile) file.getAdapter(ISemanticFile.class);
					IStatus stat = sf.validateEdit(null);

					Assert.assertTrue("ValidateEdit should have returned OK", stat.isOK());

					file.setContents(new ByteArrayInputStream("NewString".getBytes("UTF-8")), IResource.KEEP_HISTORY, monitor);
					Assert.fail("Should throw an exception");
				} catch (CoreException e) {
					// OK
				} catch (UnsupportedEncodingException e) {
					// $JL-EXC$
					Assert.fail(e.getMessage());
				}
			}
		};

		ResourcesPlugin.getWorkspace().run(runnable, new NullProgressMonitor());

		// cached file content must remain unchanged
		assertContentsEqual(file, "Hello");
		Assert.assertEquals("Wrong remote content", "Hello", new String(this.file1.getContent(), "UTF-8"));

		runnable = new IWorkspaceRunnable() {

			public void run(IProgressMonitor monitor) throws CoreException {
				ISemanticFile sf = (ISemanticFile) file.getAdapter(ISemanticFile.class);
				sf.remove(ISemanticFileSystem.NONE, null);
			}
		};

		ResourcesPlugin.getWorkspace().run(runnable, new NullProgressMonitor());

		Assert.assertEquals("File existence", false, file.exists());

	}

	@Test
	public void testReturnFalseInBeforeCacheUpdate() throws Exception {

		final IFolder root = this.testProject.getFolder("root");
		final IFolder parent = root.getFolder("Folder1");

		final IFile file = parent.getFile("File1");
		Assert.assertFalse("File should not exist", file.exists());

		IWorkspaceRunnable runnable = new IWorkspaceRunnable() {

			public void run(IProgressMonitor monitor) throws CoreException {
				ISemanticFolder sfr = (ISemanticFolder) parent.getAdapter(ISemanticFolder.class);
				sfr.addFile("File1", ISemanticFileSystem.NONE, monitor);
				Assert.assertEquals("File existence", true, file.exists());
				ISemanticFile sf = (ISemanticFile) file.getAdapter(ISemanticFile.class);
				sf.setSessionProperty(CachingTestContentProviderBase.USE_BEFORE_CACHE_UPDATE, "x");
				sf.setSessionProperty(CachingTestContentProviderBase.RETURN_FALSE_IN_BEFORE_CACHE_UPDATE, "x");
			}
		};

		ResourcesPlugin.getWorkspace().run(runnable, new NullProgressMonitor());

		assertContentsEqual(file, "Hello");
		Assert.assertEquals("Wrong remote content", "Hello", new String(this.file1.getContent(), "UTF-8"));

		// setcontent without remote update
		runnable = new IWorkspaceRunnable() {

			public void run(IProgressMonitor monitor) throws CoreException {
				try {
					ISemanticFile sf = (ISemanticFile) file.getAdapter(ISemanticFile.class);
					IStatus stat = sf.validateEdit(null);

					Assert.assertTrue("ValidateEdit should have returned OK", stat.isOK());

					file.setContents(new ByteArrayInputStream("NewString".getBytes("UTF-8")), IResource.KEEP_HISTORY, monitor);
				} catch (UnsupportedEncodingException e) {
					// $JL-EXC$
					Assert.fail(e.getMessage());
				}
			}
		};

		ResourcesPlugin.getWorkspace().run(runnable, new NullProgressMonitor());

		// cached file content must remain unchanged
		assertContentsEqual(file, "Hello");
		Assert.assertEquals("Wrong remote content", "Hello", new String(this.file1.getContent(), "UTF-8"));

		runnable = new IWorkspaceRunnable() {

			public void run(IProgressMonitor monitor) throws CoreException {
				ISemanticFile sf = (ISemanticFile) file.getAdapter(ISemanticFile.class);
				sf.remove(ISemanticFileSystem.NONE, null);
			}
		};

		ResourcesPlugin.getWorkspace().run(runnable, new NullProgressMonitor());

		Assert.assertEquals("File existence", false, file.exists());

	}

	/**
	 * 
	 * @throws Exception
	 */
	@Test
	public void testLocalFileSupport() throws Exception {

		final IFolder root = this.testProject.getFolder("root");
		final IFolder parent = root.getFolder("Folder1");

		final IFile file = parent.getFile("File1");
		Assert.assertFalse("File should not exist", file.exists());

		IWorkspaceRunnable runnable = new IWorkspaceRunnable() {

			public void run(IProgressMonitor monitor) throws CoreException {
				ISemanticFolder sfr = (ISemanticFolder) parent.getAdapter(ISemanticFolder.class);
				ISemanticFile sFile = sfr.addFile("File1", ISemanticFileSystem.NONE, monitor);

				File localFile = EFS.getStore(sFile.getAdaptedFile().getLocationURI()).toLocalFile(EFS.CACHE, monitor);
				Assert.assertNotNull("Cached Local File should not be null", localFile);
				Assert.assertTrue("Cached file should be in Eclipse file cache", localFile.getPath()
						.contains("org.eclipse.core.filesystem"));

				localFile = EFS.getStore(sFile.getAdaptedFile().getLocationURI()).toLocalFile(EFS.NONE, monitor);
				Assert.assertNotNull("Uncached Local File should not be null", localFile);
				Assert.assertTrue("Uncached file should be in SFS cache",
						localFile.getPath().contains("org.eclipse.core.resources.semantic"));
			}
		};

		ResourcesPlugin.getWorkspace().run(runnable, new NullProgressMonitor());

		runnable = new IWorkspaceRunnable() {

			public void run(IProgressMonitor monitor) throws CoreException {
				ISemanticFile sf = (ISemanticFile) file.getAdapter(ISemanticFile.class);
				sf.remove(ISemanticFileSystem.NONE, null);
			}
		};

		ResourcesPlugin.getWorkspace().run(runnable, new NullProgressMonitor());

		Assert.assertEquals("File existence", false, file.exists());

	}

	/**
	 * TODO move this to the base class to test all content provider after
	 * refactoring of tests wrt obtaining the remote file
	 * 
	 * @throws Exception
	 */
	@Test
	public void testParallelReadAndWrite() throws Exception {

		final IFolder root = this.testProject.getFolder("root");
		final IFolder parent = root.getFolder("Folder1");

		final IFile file = parent.getFile("File1");
		Assert.assertFalse("File should not exist", file.exists());

		IWorkspaceRunnable runnable = new IWorkspaceRunnable() {

			public void run(IProgressMonitor monitor) throws CoreException {
				ISemanticFolder sfr = (ISemanticFolder) parent.getAdapter(ISemanticFolder.class);
				sfr.addFile("File1", ISemanticFileSystem.NONE, monitor);
				try {
					Util.transferStreams(new ByteArrayInputStream("New Remote".getBytes("UTF-8")), file1.getOutputStream(false), monitor);
				} catch (UnsupportedEncodingException e) {
					throw new RuntimeException(e);
				}
			}
		};

		ResourcesPlugin.getWorkspace().run(runnable, new NullProgressMonitor());

		runnable = new IWorkspaceRunnable() {

			public void run(IProgressMonitor monitor) throws CoreException {
				InputStream is = null;
				try {
					is = file.getContents();
					assertContentsEqual(file, "Hello");

					ISemanticFile sFile = (ISemanticFile) file.getAdapter(ISemanticFile.class);
					sFile.synchronizeContentWithRemote(SyncDirection.INCOMING, ISemanticFileSystem.NONE, monitor);
					// we are still holding the file input stream, so we are
					// seeing the out dated content
					assertContentsEqual(file, "New Remote");
					// drop the input stream
					Util.safeClose(is);

					// TODO now we need a refresh!
					file.refreshLocal(IResource.DEPTH_INFINITE, monitor);

					assertContentsEqual(file, "New Remote");

				} finally {
					Util.safeClose(is);
				}

			}
		};

		ResourcesPlugin.getWorkspace().run(runnable, new NullProgressMonitor());

	}

	/**
	 * 
	 * TODO move this to the base class to test all content provider after
	 * refactoring of tests wrt obtaining the remote file
	 * 
	 * @throws Exception
	 */
	@Test
	public void testAppendContentsToOpenFile() throws Exception {

		final IFolder root = this.testProject.getFolder("root");
		final IFolder parent = root.getFolder("Folder1");

		final IFile file = parent.getFile("File1");

		final ISemanticFile sfile = (ISemanticFile) file.getAdapter(ISemanticFile.class);

		IWorkspaceRunnable runnable = new IWorkspaceRunnable() {

			public void run(IProgressMonitor monitor) throws CoreException {
				ISemanticFolder folder = (ISemanticFolder) file.getParent().getAdapter(ISemanticFolder.class);
				folder.addFile(file.getName(), ISemanticFileSystem.NONE, monitor);
				assertContentsEqual(file, "Hello");
				sfile.validateEdit(null);
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					// $JL-EXC$
				}
				file.appendContents(new ByteArrayInputStream(" appended".getBytes()), EFS.NONE, monitor);
				// TODO does not work with plain provider; fix after integration
				// of other tests
				assertContentsEqual(file, "Hello appended");
				InputStream is = null;
				try {
					is = file.getContents();
					assertContentsEqual(file, "Hello appended");
					file.appendContents(new ByteArrayInputStream(" again".getBytes()), EFS.NONE, monitor);
					assertContentsEqual(file, "Hello appended again");

					// TODO this should also work with an opened file
					sfile.synchronizeContentWithRemote(SyncDirection.OUTGOING, ISemanticFileSystem.NONE, monitor);
					Assert.assertEquals("Wrong remote content", new String(file1.getContent()), "Hello appended again");
				} finally {
					Util.safeClose(is);
				}
			}
		};

		ResourcesPlugin.getWorkspace().run(runnable, new NullProgressMonitor());

	}
}