/* Copyright (c) 2012-2014 Boundless and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Distribution License v1.0
* which accompanies this distribution, and is available at
* https://www.eclipse.org/org/documents/edl-v10.html
*
* Contributors:
* Gabriel Roldan (Boundless) - initial implementation
*/
package org.locationtech.geogig.repository;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.locationtech.geogig.api.ObjectId.NULL;
import static org.locationtech.geogig.api.RevObject.TYPE.FEATURE;
import static org.locationtech.geogig.api.RevObject.TYPE.TREE;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.io.File;
import java.io.IOException;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.locationtech.geogig.api.Context;
import org.locationtech.geogig.api.GeoGIG;
import org.locationtech.geogig.api.MemoryModule;
import org.locationtech.geogig.api.Node;
import org.locationtech.geogig.api.NodeRef;
import org.locationtech.geogig.api.ObjectId;
import org.locationtech.geogig.api.Platform;
import org.locationtech.geogig.api.RevObject.TYPE;
import org.locationtech.geogig.api.RevTree;
import org.locationtech.geogig.api.RevTreeBuilder;
import org.locationtech.geogig.api.TestPlatform;
import org.locationtech.geogig.api.plumbing.CreateTree;
import org.locationtech.geogig.api.plumbing.RevObjectParse;
import org.locationtech.geogig.api.plumbing.WriteBack;
import org.locationtech.geogig.di.GeogigModule;
import org.locationtech.geogig.storage.ObjectDatabase;
import com.google.common.base.Optional;
import com.google.inject.Guice;
import com.google.inject.util.Modules;
/**
*
*/
public class DepthSearchTest {
@Rule
public final TemporaryFolder tempFolder = new TemporaryFolder();
private GeoGIG fakeGeogig;
private ObjectDatabase odb;
private DepthSearch search;
private ObjectId rootTreeId;
private ObjectId fakeTreeMetadataId = ObjectId.forString("fakeMdId");
@Before
public void setUp() throws IOException {
File envHome = tempFolder.getRoot();
Platform testPlatform = new TestPlatform(envHome);
Context injector = Guice.createInjector(Modules.override(new GeogigModule()).with(
new MemoryModule(testPlatform))).getInstance(Context.class);
fakeGeogig = new GeoGIG(injector);
Repository fakeRepo = fakeGeogig.getOrCreateRepository();
odb = fakeRepo.objectDatabase();
search = new DepthSearch(odb);
RevTreeBuilder root = new RevTreeBuilder(odb);
root = addTree(root, "path/to/tree1", "node11", "node12", "node13");
root = addTree(root, "path/to/tree2", "node21", "node22", "node23");
root = addTree(root, "tree3", "node31", "node32", "node33");
RevTree rootTree = root.build();
odb.put(rootTree);
rootTreeId = rootTree.getId();
}
private RevTreeBuilder addTree(RevTreeBuilder root, final String treePath,
String... singleNodeNames) {
Context mockInjector = mock(Context.class);
when(mockInjector.objectDatabase()).thenReturn(odb);
CreateTree op = new CreateTree().setIndex(false);
op.setContext(mockInjector);
RevTreeBuilder subTreeBuilder =op.call();
if (singleNodeNames != null) {
for (String singleNodeName : singleNodeNames) {
String nodePath = NodeRef.appendChild(treePath, singleNodeName);
ObjectId fakeFeatureOId = ObjectId.forString(nodePath);
ObjectId fakeTypeOId = ObjectId.NULL;// forString(treePath);
subTreeBuilder.put(Node.create(singleNodeName, fakeFeatureOId, fakeTypeOId,
TYPE.FEATURE, null));
}
}
RevTree subtree = subTreeBuilder.build();
WriteBack writeBack = fakeGeogig.command(WriteBack.class).setAncestor(root)
.setChildPath(treePath).setTree(subtree).setMetadataId(fakeTreeMetadataId);
ObjectId newRootId = writeBack.call();
return fakeGeogig.command(RevObjectParse.class).setObjectId(newRootId).call(RevTree.class)
.get().builder(odb);
}
@Test
public void testFindFromRoot() {
final ObjectId mdId = fakeTreeMetadataId;
assertNode(find(rootTreeId, "path"), TREE, NULL, "path");
assertNode(find(rootTreeId, "path/to"), TREE, NULL, "path/to");
assertNode(find(rootTreeId, "path/to/tree1"), TREE, mdId, "path/to/tree1");
assertNode(find(rootTreeId, "path/to/tree1/node11"), FEATURE, fakeTreeMetadataId,
"path/to/tree1/node11");
assertNode(find(rootTreeId, "path/to/tree1/node12"), FEATURE, fakeTreeMetadataId,
"path/to/tree1/node12");
assertNode(find(rootTreeId, "path/to/tree1/node13"), FEATURE, fakeTreeMetadataId,
"path/to/tree1/node13");
assertFalse(find(rootTreeId, "path/to/tree1/node14").isPresent());
assertNode(find(rootTreeId, "path/to/tree2"), TREE, mdId, "path/to/tree2");
assertNode(find(rootTreeId, "path/to/tree2/node21"), FEATURE, mdId, "path/to/tree2/node21");
assertNode(find(rootTreeId, "path/to/tree2/node22"), FEATURE, mdId, "path/to/tree2/node22");
assertNode(find(rootTreeId, "path/to/tree2/node23"), FEATURE, mdId, "path/to/tree2/node23");
assertFalse(find(rootTreeId, "path/to/tree2/node24").isPresent());
assertNode(find(rootTreeId, "tree3"), TYPE.TREE, mdId, "tree3");
assertNode(find(rootTreeId, "tree3/node31"), FEATURE, mdId, "tree3/node31");
assertNode(find(rootTreeId, "tree3/node32"), FEATURE, mdId, "tree3/node32");
assertNode(find(rootTreeId, "tree3/node33"), FEATURE, mdId, "tree3/node33");
assertFalse(find(rootTreeId, "tree3/node34").isPresent());
assertFalse(find(rootTreeId, "tree4").isPresent());
try {
find(rootTreeId, "");
fail("expected IAE on empty child path");
} catch (IllegalArgumentException expected) {
assertTrue(expected.getMessage().contains("empty child path"));
}
try {
find(rootTreeId, "/");
fail("expected IAE on empty child path");
} catch (IllegalArgumentException expected) {
assertTrue(true);
}
}
private Optional<NodeRef> find(ObjectId rootTreeId, String rootChildPath) {
return search.find(rootTreeId, rootChildPath);
}
private void assertNode(Optional<NodeRef> ref, TYPE type, ObjectId expectedMdId, String path) {
assertTrue(ref.isPresent());
assertEquals(type, ref.get().getType());
assertEquals(path, ref.get().path());
assertEquals(expectedMdId, ref.get().getMetadataId());
}
}