/*******************************************************************************
* Copyright (c) 2012-2017 Codenvy, S.A.
* 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:
* Codenvy, S.A. - initial API and implementation
*******************************************************************************/
package org.eclipse.che.plugin.docker.machine.local.node.provider;
import com.google.inject.Provider;
import org.eclipse.che.api.core.ServerException;
import org.eclipse.che.api.workspace.server.WorkspaceManager;
import org.eclipse.che.api.workspace.server.model.impl.WorkspaceConfigImpl;
import org.eclipse.che.api.workspace.server.model.impl.WorkspaceImpl;
import org.eclipse.che.plugin.docker.machine.WindowsHostUtils;
import org.mockito.Mock;
import org.mockito.testng.MockitoTestNGListener;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Listeners;
import org.testng.annotations.Test;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertFalse;
import static org.testng.Assert.assertTrue;
@Listeners(value = {MockitoTestNGListener.class})
public class LocalWorkspaceFolderPathProviderTest {
private static final String WS_ID = "testWsId";
private static final String WS_NAME = "testWsName";
@Mock
private WorkspaceManager workspaceManager;
private Provider<WorkspaceManager> workspaceManagerProvider = new TestProvider();
private String singleFolderForAllWorkspaces;
private String oldWorkspacesRoot;
private File workspacesRootFile;
private String workspacesRoot;
@BeforeMethod
public void setUp() throws Exception {
WorkspaceImpl workspace = mock(WorkspaceImpl.class);
WorkspaceConfigImpl workspaceConfig = mock(WorkspaceConfigImpl.class);
when(workspaceManager.getWorkspace(WS_ID)).thenReturn(workspace);
when(workspace.getConfig()).thenReturn(workspaceConfig);
when(workspaceConfig.getName()).thenReturn(WS_NAME);
Path tempDirectory = Files.createTempDirectory(getClass().getSimpleName());
workspacesRoot = tempDirectory.toString();
workspacesRootFile = tempDirectory.toFile();
singleFolderForAllWorkspaces = Paths.get(workspacesRoot, "singleFolderForAllWorkspaces").toString();
oldWorkspacesRoot = Paths.get(workspacesRoot, "oldWorkspacesRoot").toString();
}
@Test
public void createsFoldersByDefault() throws Exception {
assertTrue(workspacesRootFile.delete());
LocalWorkspaceFolderPathProvider provider = new LocalWorkspaceFolderPathProvider(workspacesRoot,
workspaceManagerProvider);
provider.init();
assertTrue(workspacesRootFile.exists());
assertTrue(workspacesRootFile.isDirectory());
String providerPath = provider.getPath(WS_ID);
assertTrue(new File(providerPath).exists());
assertTrue(new File(providerPath).isDirectory());
}
@Test
public void returnSpecificFolderOnOnWindows() throws Exception {
LocalWorkspaceFolderPathProvider provider = new LocalWorkspaceFolderPathProvider(workspacesRoot,
oldWorkspacesRoot,
singleFolderForAllWorkspaces,
workspaceManagerProvider,
false,// with true can not be tested on other OSes
true);
provider.init();
String providerPath = provider.getPath(WS_ID);
assertEquals(providerPath, WindowsHostUtils.getCheHome().resolve("vfs").resolve(WS_NAME).toString());
}
@Test
public void returnsSingleFolderForAllWorkspacesIfConfigured() throws Exception {
LocalWorkspaceFolderPathProvider provider = new LocalWorkspaceFolderPathProvider(workspacesRoot,
oldWorkspacesRoot,
singleFolderForAllWorkspaces,
workspaceManagerProvider,
false,
false);
provider.init();
String providerPath = provider.getPath(WS_ID);
assertEquals(providerPath, singleFolderForAllWorkspaces);
}
@Test
public void useOlderFolderIfConfigured() throws Exception {
LocalWorkspaceFolderPathProvider provider = new LocalWorkspaceFolderPathProvider(workspacesRoot,
oldWorkspacesRoot,
null,
workspaceManagerProvider,
false,
false);
provider.init();
String providerPath = provider.getPath(WS_ID);
assertEquals(providerPath, Paths.get(oldWorkspacesRoot, WS_NAME).toString());
}
@Test
public void neitherCheckNorCreateFoldersIfCreationIsDisabled() throws Exception {
assertTrue(workspacesRootFile.delete());
LocalWorkspaceFolderPathProvider provider = new LocalWorkspaceFolderPathProvider(workspacesRoot,
null,
null,
workspaceManagerProvider,
false,
false);
provider.init();
String providerPath = provider.getPath(WS_ID);
assertFalse(workspacesRootFile.exists());
assertFalse(new File(providerPath).exists());
}
@Test
public void createsFoldersIfConfigured() throws Exception {
assertTrue(workspacesRootFile.delete());
LocalWorkspaceFolderPathProvider provider = new LocalWorkspaceFolderPathProvider(workspacesRoot,
null,
null,
workspaceManagerProvider,
true,
false);
provider.init();
assertTrue(workspacesRootFile.exists());
assertTrue(workspacesRootFile.isDirectory());
String providerPath = provider.getPath(WS_ID);
assertTrue(new File(providerPath).exists());
assertTrue(new File(providerPath).isDirectory());
}
@Test
public void worksIfWorkspaceFolderExists() throws Exception {
assertTrue(Paths.get(workspacesRoot, WS_NAME).toFile().mkdir());
LocalWorkspaceFolderPathProvider provider = new LocalWorkspaceFolderPathProvider(workspacesRoot,
null,
null,
workspaceManagerProvider,
true,
false);
provider.init();
assertTrue(workspacesRootFile.exists());
assertTrue(workspacesRootFile.isDirectory());
String providerPath = provider.getPath(WS_ID);
assertTrue(new File(providerPath).exists());
assertTrue(new File(providerPath).isDirectory());
}
@Test(expectedExceptions = IOException.class,
expectedExceptionsMessageRegExp = "Workspace folder '.*' is not directory")
public void throwsExceptionIfFileIsFoundByWorkspacesPath() throws Exception {
assertTrue(Paths.get(workspacesRoot, WS_NAME).toFile().createNewFile());
LocalWorkspaceFolderPathProvider provider = new LocalWorkspaceFolderPathProvider(workspacesRoot,
null,
null,
workspaceManagerProvider,
true,
false);
provider.init();
provider.getPath(WS_ID);
}
@Test(expectedExceptions = IOException.class,
expectedExceptionsMessageRegExp = "Workspace folder '.*' is not directory. Check .* configuration property")
public void throwsExceptionIfFileIsFoundByWorkspacesRootPath() throws Exception {
Path tempFile = Files.createTempFile(getClass().getSimpleName(), null);
LocalWorkspaceFolderPathProvider provider = new LocalWorkspaceFolderPathProvider(tempFile.toString(),
null,
null,
workspaceManagerProvider,
true,
false);
provider.init();
}
@Test(expectedExceptions = IOException.class,
expectedExceptionsMessageRegExp = "Workspace folder '.*' is not directory. Check .* configuration property")
public void throwsExceptionIfFileIsFoundBySingleWorkspacePath() throws Exception {
Path tempFile = Files.createTempFile(getClass().getSimpleName(), null);
LocalWorkspaceFolderPathProvider provider = new LocalWorkspaceFolderPathProvider(workspacesRoot,
oldWorkspacesRoot,
tempFile.toString(),
workspaceManagerProvider,
true,
false);
provider.init();
provider.getPath(WS_ID);
}
@Test(expectedExceptions = IOException.class,
expectedExceptionsMessageRegExp = "expected test exception")
public void throwsIOExceptionIfWorkspaceRetrievalFails() throws Exception {
when(workspaceManager.getWorkspace(WS_ID)).thenThrow(new ServerException("expected test exception"));
LocalWorkspaceFolderPathProvider provider = new LocalWorkspaceFolderPathProvider(workspacesRoot,
null,
null,
workspaceManagerProvider,
true,
false);
provider.init();
provider.getPath(WS_ID);
}
private class TestProvider implements Provider<WorkspaceManager> {
@Override
public WorkspaceManager get() {
return workspaceManager;
}
}
}