ConnectorsTest.java

/*
 * ModeShape (http://www.modeshape.org)
 *
 * Licensed 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.modeshape.jcr;

import static org.hamcrest.core.Is.is;
import static org.hamcrest.core.IsInstanceOf.instanceOf;
import static org.hamcrest.core.IsNull.notNullValue;
import static org.junit.Assert.assertThat;
import java.io.File;
import java.util.Collection;
import java.util.HashSet;
import java.util.Set;
import org.junit.Before;
import org.junit.Test;
import org.modeshape.connector.filesystem.FileSystemConnector;
import org.modeshape.jcr.Connectors.PathMappings;
import org.modeshape.jcr.spi.federation.Connector;
import org.modeshape.jcr.value.Path;
import org.modeshape.jcr.value.WorkspaceAndPath;

/**
 * Because the {@link Connectors} test expects a {@link JcrRepository.RunningState} instance and directly manipulates the
 * repository content with the correct projection definitions, this class is actually relatively difficult to unit test.
 * Therefore, this test simply starts up a ModeShape repository instance in the normal fashion, and then uses package-level
 * methods to access the Connectors instance.
 */
public class ConnectorsTest extends SingleUseAbstractTest {

    private Connectors connectors;

    @Before
    @Override
    public void beforeEach() throws Exception {
        // And make sure that the 'generated-surefire' directory exists (it often doesn't when running in Eclipse)
        // and create an empty 'tmp' directory underneath it ...
        new File("target/generated-surefire/tmp").mkdirs();
        // Now start the repository ...
        startRepositoryWithConfigurationFrom("config/repo-config-filesystem-federation-with-persistence.json");
        printMessage("Started repository...");
        connectors = repository().runningState().connectors();
    }
    
    @Test
    public void shouldObtainPathMappingsForConnectorAndResolvePathsCorrectly() {
        Connector conn = connectors.getConnectorForSourceName("targetDirectory");
        assertThat(conn, is(instanceOf(FileSystemConnector.class)));
        PathMappings mappings = connectors.getPathMappings(conn);
        assertThat(mappings.getConnectorSourceName(), is("targetDirectory"));
        assertThat(mappings.getPathFactory(), is(notNullValue()));
        assertPathResolves(mappings, "/classes", "default", "/federation/classes");
        assertPathResolves(mappings, "/classes/org", "default", "/federation/classes/org");
        assertPathResolves(mappings, "/classes/org/modeshape", "default", "/federation/classes/org/modeshape");
        assertPathResolves(mappings, "/generated-sources", "default", "/federation/generated-sources");
        assertPathResolves(mappings, "/generated-surefire", "default", "/federation/surefire");
        assertPathResolves(mappings, "/generated-surefire/tmp", "default", "/federation/surefire/tmp");
    }

    protected void assertPathResolves( PathMappings mappings,
                                       String externalPath,
                                       String... workspaceNameAndPathPairs ) {
        Path extPath = mappings.getPathFactory().create(externalPath);
        Set<WorkspaceAndPath> expectedWsAndPaths = new HashSet<WorkspaceAndPath>();
        for (int i = 0; i != workspaceNameAndPathPairs.length; ++i) {
            String workspaceName = workspaceNameAndPathPairs[i];
            String repoPath = workspaceNameAndPathPairs[++i];
            Path repPath = mappings.getPathFactory().create(repoPath);
            expectedWsAndPaths.add(new WorkspaceAndPath(workspaceName, repPath));
        }
        Collection<WorkspaceAndPath> wsAndPaths = mappings.resolveExternalPathToInternal(extPath);
        Set<WorkspaceAndPath> actualWsAndPaths = new HashSet<WorkspaceAndPath>(wsAndPaths);
        assertThat(actualWsAndPaths, is(expectedWsAndPaths));
    }

}