From 68fd27e02d1dee7db4a6fbb99357090b3094ab0d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jacobo=20Coll=20Morag=C3=B3n?= Date: Tue, 8 May 2018 13:24:52 +0100 Subject: [PATCH] storage: Fail if annotator changes with partial annotation update. #830 --- .../DefaultVariantAnnotationManager.java | 23 +++- .../annotation/VariantAnnotationManager.java | 114 ++++++++++++------ ...java => VariantAnnotationManagerTest.java} | 77 ++++++++++-- ...> HadoopVariantAnnotationManagerTest.java} | 10 +- ... MongoDBVariantAnnotationManagerTest.java} | 4 +- 5 files changed, 174 insertions(+), 54 deletions(-) rename opencga-storage/opencga-storage-core/src/test/java/org/opencb/opencga/storage/core/variant/annotation/{VariantAnnotationSnapshotTest.java => VariantAnnotationManagerTest.java} (63%) rename opencga-storage/opencga-storage-hadoop/opencga-storage-hadoop-core/src/test/java/org/opencb/opencga/storage/hadoop/variant/annotation/{HadoopVariantAnnotationSnapshotTest.java => HadoopVariantAnnotationManagerTest.java} (72%) rename opencga-storage/opencga-storage-mongodb/src/test/java/org/opencb/opencga/storage/mongodb/variant/annotation/{MongoDBVariantAnnotationSnapshotTest.java => MongoDBVariantAnnotationManagerTest.java} (65%) diff --git a/opencga-storage/opencga-storage-core/src/main/java/org/opencb/opencga/storage/core/variant/annotation/DefaultVariantAnnotationManager.java b/opencga-storage/opencga-storage-core/src/main/java/org/opencb/opencga/storage/core/variant/annotation/DefaultVariantAnnotationManager.java index d7691c82f44..42ec5188f6e 100644 --- a/opencga-storage/opencga-storage-core/src/main/java/org/opencb/opencga/storage/core/variant/annotation/DefaultVariantAnnotationManager.java +++ b/opencga-storage/opencga-storage-core/src/main/java/org/opencb/opencga/storage/core/variant/annotation/DefaultVariantAnnotationManager.java @@ -107,11 +107,15 @@ public void annotate(Query query, ObjectMap params) throws VariantAnnotatorExcep doCreate = true; doLoad = true; } + boolean overwrite = params.getBoolean(OVERWRITE_ANNOTATIONS, false); + if (!overwrite) { + query.put(VariantQueryParam.ANNOTATION_EXISTS.key(), false); + } URI annotationFile; if (doCreate) { dbAdaptor.getStudyConfigurationManager().lockAndUpdateProject(projectMetadata -> { - checkCurrentAnnotation(variantAnnotator, projectMetadata); + checkCurrentAnnotation(variantAnnotator, projectMetadata, overwrite); return projectMetadata; }); @@ -136,6 +140,13 @@ public void annotate(Query query, ObjectMap params) throws VariantAnnotatorExcep logger.info("Starting annotation load"); loadAnnotation(annotationFile, params); logger.info("Finished annotation load {}ms", System.currentTimeMillis() - start); + + if (doCreate) { + dbAdaptor.getStudyConfigurationManager().lockAndUpdateProject(projectMetadata -> { + updateCurrentAnnotation(variantAnnotator, projectMetadata, overwrite); + return projectMetadata; + }); + } } } @@ -234,13 +245,17 @@ protected QueryOptions getIteratorQueryOptions(Query query, ObjectMap params) { public void loadAnnotation(URI uri, ObjectMap params) throws IOException, StorageEngineException { Path path = Paths.get(uri); String fileName = path.getFileName().toString().toLowerCase(); - if (VariantReaderUtils.isAvro(fileName) || VariantReaderUtils.isJson(fileName)) { - loadVariantAnnotation(uri, params); - } else { + if (isCustomAnnotation(fileName)) { loadCustomAnnotation(uri, params); + } else { + loadVariantAnnotation(uri, params); } } + protected boolean isCustomAnnotation(String fileName) { + return !VariantReaderUtils.isAvro(fileName) && !VariantReaderUtils.isJson(fileName); + } + /** * Loads variant annotations from an specified file into the selected Variant DataBase. * diff --git a/opencga-storage/opencga-storage-core/src/main/java/org/opencb/opencga/storage/core/variant/annotation/VariantAnnotationManager.java b/opencga-storage/opencga-storage-core/src/main/java/org/opencb/opencga/storage/core/variant/annotation/VariantAnnotationManager.java index ff20ba31a2b..37700a1c4d1 100644 --- a/opencga-storage/opencga-storage-core/src/main/java/org/opencb/opencga/storage/core/variant/annotation/VariantAnnotationManager.java +++ b/opencga-storage/opencga-storage-core/src/main/java/org/opencb/opencga/storage/core/variant/annotation/VariantAnnotationManager.java @@ -21,6 +21,8 @@ import org.opencb.commons.datastore.core.Query; import org.opencb.opencga.storage.core.exceptions.StorageEngineException; import org.opencb.opencga.storage.core.metadata.ProjectMetadata; +import org.opencb.opencga.storage.core.metadata.ProjectMetadata.VariantAnnotationMetadata; +import org.opencb.opencga.storage.core.metadata.ProjectMetadata.VariantAnnotatorProgram; import org.opencb.opencga.storage.core.variant.annotation.annotators.VariantAnnotator; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -61,78 +63,120 @@ public abstract class VariantAnnotationManager { public abstract void deleteAnnotationSnapshot(String name, ObjectMap options) throws StorageEngineException, VariantAnnotatorException; - protected final ProjectMetadata.VariantAnnotationMetadata checkCurrentAnnotation(VariantAnnotator annotator, - ProjectMetadata projectMetadata) - throws IOException { - ProjectMetadata.VariantAnnotatorProgram newAnnotator = annotator.getVariantAnnotatorProgram(); - List newSourceVersion = annotator.getVariantAnnotatorSourceVersion(); + protected final VariantAnnotationMetadata checkCurrentAnnotation(VariantAnnotator annotator, ProjectMetadata projectMetadata, + boolean overwrite) + throws VariantAnnotatorException { + VariantAnnotatorProgram newAnnotator; + List newSourceVersion; + try { + newAnnotator = annotator.getVariantAnnotatorProgram(); + newSourceVersion = annotator.getVariantAnnotatorSourceVersion(); + } catch (IOException e) { + throw new VariantAnnotatorException("Error reading current annotation metadata!", e); + } if (newSourceVersion == null) { newSourceVersion = Collections.emptyList(); } + if (newAnnotator == null) { + throw new IllegalArgumentException("Missing annotator information for VariantAnnotator: " + annotator.getClass()); + } + if (newSourceVersion.isEmpty()) { + throw new IllegalArgumentException("Missing annotator source version for VariantAnnotator: " + annotator.getClass()); + } + return checkCurrentAnnotation(projectMetadata, overwrite, newAnnotator, newSourceVersion); + } - ProjectMetadata.VariantAnnotationMetadata current = projectMetadata.getAnnotation().getCurrent(); + protected final VariantAnnotationMetadata checkCurrentAnnotation(ProjectMetadata projectMetadata, boolean overwrite, + VariantAnnotatorProgram newAnnotator, List newSourceVersion) + throws VariantAnnotatorException { + VariantAnnotationMetadata current = projectMetadata.getAnnotation().getCurrent(); if (current == null) { - current = new ProjectMetadata.VariantAnnotationMetadata(); + current = new VariantAnnotationMetadata(); projectMetadata.getAnnotation().setCurrent(current); current.setId(-1); current.setName(LATEST); } // Check using same annotator and same source version - ProjectMetadata.VariantAnnotatorProgram currentAnnotator = current.getAnnotator(); + VariantAnnotatorProgram currentAnnotator = current.getAnnotator(); if (currentAnnotator != null && !currentAnnotator.equals(newAnnotator)) { - if (newAnnotator == null) { - throw new IllegalArgumentException("Missing annotator information for VariantAnnotator: " + annotator.getClass()); - } if (!currentAnnotator.getName().equals(newAnnotator.getName()) || !currentAnnotator.getVersion().equals(newAnnotator.getVersion())) { String msg = "Using a different annotator! " + "Existing annotation calculated with " + currentAnnotator.toString() + ", attempting to annotate with " + newAnnotator.toString(); - logger.error(msg); -// throw new VariantAnnotatorException(msg); + if (overwrite) { + logger.info(msg); + } else { + throw new VariantAnnotatorException(msg); + } } else if (!currentAnnotator.getCommit().equals(newAnnotator.getCommit())) { - logger.warn("Using a different commit for annotating variants. " + String msg = "Using a different commit for annotating variants. " + "Existing annotation calculated with " + currentAnnotator.toString() - + ", attempting to annotate with " + newAnnotator.toString()); + + ", attempting to annotate with " + newAnnotator.toString(); + if (overwrite) { + logger.info(msg); + } else { + logger.warn(msg); + } } } - current.setAnnotator(newAnnotator); List currentSourceVersion = current.getSourceVersion(); if (CollectionUtils.isNotEmpty(currentSourceVersion) && !currentSourceVersion.equals(newSourceVersion)) { - if (newSourceVersion.isEmpty()) { - throw new IllegalArgumentException("Missing annotator source version for VariantAnnotator: " + annotator.getClass()); - } String msg = "Source version of the annotator has changed. " + "Existing annotation calculated with " + currentSourceVersion.stream().map(ObjectMap::toJson).collect(Collectors.joining(" , ", "[ ", " ]")) + ", attempting to annotate with " + newSourceVersion.stream().map(ObjectMap::toJson).collect(Collectors.joining(" , ", "[ ", " ]")); - logger.error(msg); -// throw new VariantAnnotatorException(msg); + if (overwrite) { + logger.info(msg); + } else { + throw new VariantAnnotatorException(msg); + } } - current.setSourceVersion(newSourceVersion); return current; } - protected final ProjectMetadata.VariantAnnotationMetadata registerNewAnnotationSnapshot(String name, VariantAnnotator annotator, + protected final void updateCurrentAnnotation(VariantAnnotator annotator, ProjectMetadata projectMetadata, + boolean overwrite) + throws VariantAnnotatorException { + VariantAnnotatorProgram newAnnotator; + List newSourceVersion; + try { + newAnnotator = annotator.getVariantAnnotatorProgram(); + newSourceVersion = annotator.getVariantAnnotatorSourceVersion(); + } catch (IOException e) { + throw new VariantAnnotatorException("Error reading current annotation metadata!", e); + } + if (newSourceVersion == null) { + newSourceVersion = Collections.emptyList(); + } + if (newAnnotator == null) { + throw new IllegalArgumentException("Missing annotator information for VariantAnnotator: " + annotator.getClass()); + } + if (newSourceVersion.isEmpty()) { + throw new IllegalArgumentException("Missing annotator source version for VariantAnnotator: " + annotator.getClass()); + } + checkCurrentAnnotation(projectMetadata, overwrite, newAnnotator, newSourceVersion); + + projectMetadata.getAnnotation().getCurrent().setAnnotator(newAnnotator); + projectMetadata.getAnnotation().getCurrent().setSourceVersion(newSourceVersion); + } + + protected final VariantAnnotationMetadata registerNewAnnotationSnapshot(String name, VariantAnnotator annotator, ProjectMetadata projectMetadata) throws VariantAnnotatorException { - ProjectMetadata.VariantAnnotationMetadata current = projectMetadata.getAnnotation().getCurrent(); + VariantAnnotationMetadata current = projectMetadata.getAnnotation().getCurrent(); if (current == null) { // Should never enter here - try { - current = checkCurrentAnnotation(annotator, projectMetadata); - } catch (IOException e) { - throw new VariantAnnotatorException("Missing current annotation metadata!", e); - } + current = checkCurrentAnnotation(annotator, projectMetadata, true); } boolean nameDuplicated = projectMetadata.getAnnotation().getSaved() .stream() - .map(ProjectMetadata.VariantAnnotationMetadata::getName) + .map(VariantAnnotationMetadata::getName) .anyMatch(s -> s.equalsIgnoreCase(name)); if (nameDuplicated) { @@ -140,11 +184,11 @@ protected final ProjectMetadata.VariantAnnotationMetadata registerNewAnnotationS } Integer maxId = projectMetadata.getAnnotation().getSaved() .stream() - .map(ProjectMetadata.VariantAnnotationMetadata::getId) + .map(VariantAnnotationMetadata::getId) .max(Integer::compareTo) .orElse(0); - ProjectMetadata.VariantAnnotationMetadata newSnapshot = new ProjectMetadata.VariantAnnotationMetadata( + VariantAnnotationMetadata newSnapshot = new VariantAnnotationMetadata( maxId + 1, name, Date.from(Instant.now()), @@ -155,10 +199,10 @@ protected final ProjectMetadata.VariantAnnotationMetadata registerNewAnnotationS return newSnapshot; } - protected final ProjectMetadata.VariantAnnotationMetadata removeAnnotationSnapshot(String name, ProjectMetadata projectMetadata) + protected final VariantAnnotationMetadata removeAnnotationSnapshot(String name, ProjectMetadata projectMetadata) throws VariantAnnotatorException { - Iterator iterator = projectMetadata.getAnnotation().getSaved().iterator(); - ProjectMetadata.VariantAnnotationMetadata annotation = null; + Iterator iterator = projectMetadata.getAnnotation().getSaved().iterator(); + VariantAnnotationMetadata annotation = null; boolean found = false; while (iterator.hasNext()) { annotation = iterator.next(); diff --git a/opencga-storage/opencga-storage-core/src/test/java/org/opencb/opencga/storage/core/variant/annotation/VariantAnnotationSnapshotTest.java b/opencga-storage/opencga-storage-core/src/test/java/org/opencb/opencga/storage/core/variant/annotation/VariantAnnotationManagerTest.java similarity index 63% rename from opencga-storage/opencga-storage-core/src/test/java/org/opencb/opencga/storage/core/variant/annotation/VariantAnnotationSnapshotTest.java rename to opencga-storage/opencga-storage-core/src/test/java/org/opencb/opencga/storage/core/variant/annotation/VariantAnnotationManagerTest.java index 92ea9b914b6..4d286a00d7d 100644 --- a/opencga-storage/opencga-storage-core/src/test/java/org/opencb/opencga/storage/core/variant/annotation/VariantAnnotationSnapshotTest.java +++ b/opencga-storage/opencga-storage-core/src/test/java/org/opencb/opencga/storage/core/variant/annotation/VariantAnnotationManagerTest.java @@ -22,17 +22,71 @@ import java.util.List; import java.util.stream.Collectors; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; -import static org.opencb.opencga.storage.core.variant.annotation.VariantAnnotationManager.ANNOTATOR; -import static org.opencb.opencga.storage.core.variant.annotation.VariantAnnotationManager.VARIANT_ANNOTATOR_CLASSNAME; +import static org.junit.Assert.*; +import static org.opencb.opencga.storage.core.variant.annotation.VariantAnnotationManager.*; /** * Created on 24/04/18. * * @author Jacobo Coll <jacobo167@gmail.com> */ -public abstract class VariantAnnotationSnapshotTest extends VariantStorageBaseTest { +public abstract class VariantAnnotationManagerTest extends VariantStorageBaseTest { + + @Test + public void testChangeAnnotator() throws Exception { + VariantStorageEngine variantStorageEngine = getVariantStorageEngine(); + runDefaultETL(smallInputUri, variantStorageEngine, newStudyConfiguration(), + new ObjectMap(VariantStorageEngine.Options.ANNOTATE.key(), false)); + + variantStorageEngine.getOptions() + .append(VARIANT_ANNOTATOR_CLASSNAME, TestAnnotator.class.getName()) + .append(ANNOTATOR, VariantAnnotatorFactory.AnnotationSource.OTHER); + + // First annotation. Should run ok. + variantStorageEngine.annotate(new Query(), new ObjectMap(TestAnnotator.ANNOT_KEY, "v1")); + assertEquals("v1", variantStorageEngine.getStudyConfigurationManager().getProjectMetadata().first().getAnnotation().getCurrent().getAnnotator().getVersion()); + + // Second annotation. New annotator. Overwrite. Should run ok. + variantStorageEngine.annotate(new Query(), new ObjectMap(TestAnnotator.ANNOT_KEY, "v2").append(OVERWRITE_ANNOTATIONS, true)); + assertEquals("v2", variantStorageEngine.getStudyConfigurationManager().getProjectMetadata().first().getAnnotation().getCurrent().getAnnotator().getVersion()); + + // Third annotation. New annotator. Do not overwrite. Should fail. + thrown.expect(VariantAnnotatorException.class); + variantStorageEngine.annotate(new Query(), new ObjectMap(TestAnnotator.ANNOT_KEY, "v3").append(OVERWRITE_ANNOTATIONS, false)); + } + + @Test + public void testChangeAnnotatorFail() throws Exception { + VariantStorageEngine variantStorageEngine = getVariantStorageEngine(); + runDefaultETL(smallInputUri, variantStorageEngine, newStudyConfiguration(), + new ObjectMap(VariantStorageEngine.Options.ANNOTATE.key(), false)); + + variantStorageEngine.getOptions() + .append(VARIANT_ANNOTATOR_CLASSNAME, TestAnnotator.class.getName()) + .append(ANNOTATOR, VariantAnnotatorFactory.AnnotationSource.OTHER); + + // First annotation. Should run ok. + variantStorageEngine.annotate(new Query(), new ObjectMap(TestAnnotator.ANNOT_KEY, "v1")); + + try { + // Second annotation. New annotator. Overwrite. Fail annotation + variantStorageEngine.annotate(new Query(), new ObjectMap(TestAnnotator.ANNOT_KEY, "v2") + .append(TestAnnotator.FAIL, true) + .append(OVERWRITE_ANNOTATIONS, true)); + fail("Expected to fail!"); + } catch (VariantAnnotatorException e) { + e.printStackTrace(); + // Annotator information does not change + assertEquals("v1", variantStorageEngine.getStudyConfigurationManager().getProjectMetadata().first().getAnnotation().getCurrent().getAnnotator().getVersion()); + } + + + // Second annotation bis. New annotator. Overwrite. + variantStorageEngine.annotate(new Query(), new ObjectMap(TestAnnotator.ANNOT_KEY, "v2") + .append(TestAnnotator.FAIL, false) + .append(OVERWRITE_ANNOTATIONS, true)); + assertEquals("v2", variantStorageEngine.getStudyConfigurationManager().getProjectMetadata().first().getAnnotation().getCurrent().getAnnotator().getVersion()); + } @Test public void testMultiAnnotations() throws Exception { @@ -46,11 +100,11 @@ public void testMultiAnnotations() throws Exception { .append(ANNOTATOR, VariantAnnotatorFactory.AnnotationSource.OTHER); variantStorageEngine.createAnnotationSnapshot("v0", new ObjectMap()); - variantStorageEngine.annotate(new Query(), new ObjectMap(TestAnnotator.ANNOT_KEY, "v1")); + variantStorageEngine.annotate(new Query(), new ObjectMap(TestAnnotator.ANNOT_KEY, "v1").append(OVERWRITE_ANNOTATIONS, true)); variantStorageEngine.createAnnotationSnapshot("v1", new ObjectMap()); - variantStorageEngine.annotate(new Query(), new ObjectMap(TestAnnotator.ANNOT_KEY, "v2")); + variantStorageEngine.annotate(new Query(), new ObjectMap(TestAnnotator.ANNOT_KEY, "v2").append(OVERWRITE_ANNOTATIONS, true)); variantStorageEngine.createAnnotationSnapshot("v2", new ObjectMap()); - variantStorageEngine.annotate(new Query(), new ObjectMap(TestAnnotator.ANNOT_KEY, "v3")); + variantStorageEngine.annotate(new Query(), new ObjectMap(TestAnnotator.ANNOT_KEY, "v3").append(OVERWRITE_ANNOTATIONS, true)); assertEquals(0, variantStorageEngine.getAnnotation("v0", null, null).getResult().size()); checkAnnotationSnapshot(variantStorageEngine, "v1", "v1"); @@ -98,6 +152,7 @@ public void checkAnnotationSnapshot(VariantStorageEngine variantStorageEngine, S int count = 0; for (VariantAnnotation annotation: variantStorageEngine.getAnnotation(name, null, null).getResult()) { assertEquals(expectedId, annotation.getId()); + assertEquals("1", annotation.getAdditionalAttributes().get("opencga").getAttribute().get("release")); count++; } assertEquals(count, variantStorageEngine.count(new Query()).first().intValue()); @@ -106,15 +161,21 @@ public void checkAnnotationSnapshot(VariantStorageEngine variantStorageEngine, S public static class TestAnnotator extends VariantAnnotator { public static final String ANNOT_KEY = "ANNOT_KEY"; + public static final String FAIL = "ANNOT_FAIL"; + private final boolean fail; private String key; public TestAnnotator(StorageConfiguration configuration, ProjectMetadata projectMetadata, ObjectMap options) throws VariantAnnotatorException { super(configuration, projectMetadata, options); key = options.getString(ANNOT_KEY); + fail = options.getBoolean(FAIL, false); } @Override public List annotate(List variants) throws VariantAnnotatorException { + if (fail) { + throw new VariantAnnotatorException("Fail because reasons"); + } return variants.stream().map(v -> { VariantAnnotation a = new VariantAnnotation(); a.setChromosome(v.getChromosome()); diff --git a/opencga-storage/opencga-storage-hadoop/opencga-storage-hadoop-core/src/test/java/org/opencb/opencga/storage/hadoop/variant/annotation/HadoopVariantAnnotationSnapshotTest.java b/opencga-storage/opencga-storage-hadoop/opencga-storage-hadoop-core/src/test/java/org/opencb/opencga/storage/hadoop/variant/annotation/HadoopVariantAnnotationManagerTest.java similarity index 72% rename from opencga-storage/opencga-storage-hadoop/opencga-storage-hadoop-core/src/test/java/org/opencb/opencga/storage/hadoop/variant/annotation/HadoopVariantAnnotationSnapshotTest.java rename to opencga-storage/opencga-storage-hadoop/opencga-storage-hadoop-core/src/test/java/org/opencb/opencga/storage/hadoop/variant/annotation/HadoopVariantAnnotationManagerTest.java index 8bfa48cae1a..e6d914eb19d 100644 --- a/opencga-storage/opencga-storage-hadoop/opencga-storage-hadoop-core/src/test/java/org/opencb/opencga/storage/hadoop/variant/annotation/HadoopVariantAnnotationSnapshotTest.java +++ b/opencga-storage/opencga-storage-hadoop/opencga-storage-hadoop-core/src/test/java/org/opencb/opencga/storage/hadoop/variant/annotation/HadoopVariantAnnotationManagerTest.java @@ -1,9 +1,9 @@ package org.opencb.opencga.storage.hadoop.variant.annotation; import org.junit.After; -import org.junit.Rule; +import org.junit.ClassRule; import org.junit.rules.ExternalResource; -import org.opencb.opencga.storage.core.variant.annotation.VariantAnnotationSnapshotTest; +import org.opencb.opencga.storage.core.variant.annotation.VariantAnnotationManagerTest; import org.opencb.opencga.storage.hadoop.variant.HadoopVariantStorageEngine; import org.opencb.opencga.storage.hadoop.variant.HadoopVariantStorageTest; import org.opencb.opencga.storage.hadoop.variant.VariantHbaseTestUtils; @@ -13,10 +13,10 @@ * * @author Jacobo Coll <jacobo167@gmail.com> */ -public class HadoopVariantAnnotationSnapshotTest extends VariantAnnotationSnapshotTest implements HadoopVariantStorageTest { +public class HadoopVariantAnnotationManagerTest extends VariantAnnotationManagerTest implements HadoopVariantStorageTest { - @Rule - public ExternalResource externalResource = new HadoopExternalResource(); + @ClassRule + public static ExternalResource externalResource = new HadoopExternalResource(); @After public void tearDown() throws Exception { diff --git a/opencga-storage/opencga-storage-mongodb/src/test/java/org/opencb/opencga/storage/mongodb/variant/annotation/MongoDBVariantAnnotationSnapshotTest.java b/opencga-storage/opencga-storage-mongodb/src/test/java/org/opencb/opencga/storage/mongodb/variant/annotation/MongoDBVariantAnnotationManagerTest.java similarity index 65% rename from opencga-storage/opencga-storage-mongodb/src/test/java/org/opencb/opencga/storage/mongodb/variant/annotation/MongoDBVariantAnnotationSnapshotTest.java rename to opencga-storage/opencga-storage-mongodb/src/test/java/org/opencb/opencga/storage/mongodb/variant/annotation/MongoDBVariantAnnotationManagerTest.java index 27a2840e8a5..44c879c9a32 100644 --- a/opencga-storage/opencga-storage-mongodb/src/test/java/org/opencb/opencga/storage/mongodb/variant/annotation/MongoDBVariantAnnotationSnapshotTest.java +++ b/opencga-storage/opencga-storage-mongodb/src/test/java/org/opencb/opencga/storage/mongodb/variant/annotation/MongoDBVariantAnnotationManagerTest.java @@ -1,6 +1,6 @@ package org.opencb.opencga.storage.mongodb.variant.annotation; -import org.opencb.opencga.storage.core.variant.annotation.VariantAnnotationSnapshotTest; +import org.opencb.opencga.storage.core.variant.annotation.VariantAnnotationManagerTest; import org.opencb.opencga.storage.mongodb.variant.MongoDBVariantStorageTest; /** @@ -8,5 +8,5 @@ * * @author Jacobo Coll <jacobo167@gmail.com> */ -public class MongoDBVariantAnnotationSnapshotTest extends VariantAnnotationSnapshotTest implements MongoDBVariantStorageTest { +public class MongoDBVariantAnnotationManagerTest extends VariantAnnotationManagerTest implements MongoDBVariantStorageTest { }