Examples with Analysis org.icgc.dcc.song.server.model.analysis.Analysis used on opensource projects

Example 1 with Analysis

use of org.icgc.dcc.song.server.model.analysis.Analysis in project SONG by overture-stack.

the class ExportServiceTest method generateData.

/**
 * Generate {@code numStudies} studies and for each study generate {@code numAnalysisPerStudy} analyses, and put
 * everything in a map, where the keys are studyIds and the values are all the analyses for that study
 */
private Map<String, List<? extends Analysis>> generateData(Class<? extends Analysis> analysisClass, int numStudies, int numAnalysesPerStudy, boolean includeAnalysisId, boolean includeOtherIds) {
    val studyGenerator = createStudyGenerator(studyService, randomGenerator);
    val map = Maps.<String, List<? extends Analysis>>newHashMap();
    for (int s = 0; s < numStudies; s++) {
        val studyId = studyGenerator.createRandomStudy();
        val analysisGenerator = createAnalysisGenerator(studyId, analysisService, randomGenerator);
        val analyses = range(0, numAnalysesPerStudy).boxed().map(x -> analysisGenerator.createDefaultRandomAnalysis(analysisClass)).peek(x -> massageAnalysisInplace(x, includeAnalysisId, includeOtherIds)).collect(toImmutableList());
        map.put(studyId, analyses);
    }
    return ImmutableMap.copyOf(map);
}

Example 2 with Analysis

use of org.icgc.dcc.song.server.model.analysis.Analysis in project SONG by overture-stack.

the class ExportServiceTest method runExportTest.

public void runExportTest(Class<? extends Analysis> analysisClass, int numStudies, int numAnalysesPerStudy) {
    val includeAnalysisId = true;
    val includeOtherIds = false;
    // Check config
    assertCorrectConfig(numStudies, numAnalysesPerStudy);
    // Generate data
    val expectedData = generateData(analysisClass, numStudies, numAnalysesPerStudy, includeAnalysisId, includeOtherIds);
    // Process StudyMode Data
    val actualStudyModeExportedPayloads = expectedData.keySet().stream().map(s -> exportService.exportPayloadsForStudy(s, includeAnalysisId, includeOtherIds)).flatMap(Collection::stream).collect(toImmutableList());
    assertThat(actualStudyModeExportedPayloads).hasSize(numStudies);
    val actualStudyModeData = Maps.<String, List<? extends Analysis>>newHashMap();
    for (val exportedPayload : actualStudyModeExportedPayloads) {
        val studyId = exportedPayload.getStudyId();
        val analyses = exportedPayload.getPayloads().stream().map(x -> fromJson(x, Analysis.class)).collect(toImmutableList());
        actualStudyModeData.put(studyId, analyses);
    }
    // Process AnalysisMode Data
    val expectedAnalysisIds = expectedData.values().stream().flatMap(Collection::stream).map(Analysis::getAnalysisId).collect(toImmutableList());
    val actualAnalysisModeExportedPayloads = exportService.exportPayload(expectedAnalysisIds, includeAnalysisId, includeOtherIds);
    assertThat(actualAnalysisModeExportedPayloads).hasSize(numStudies);
    val actualAnalysisModeData = Maps.<String, List<? extends Analysis>>newHashMap();
    for (val exportedPayload : actualAnalysisModeExportedPayloads) {
        val studyId = exportedPayload.getStudyId();
        val analyses = exportedPayload.getPayloads().stream().map(x -> fromJson(x, Analysis.class)).collect(toImmutableList());
        actualAnalysisModeData.put(studyId, analyses);
    }
    assertMatchingData(actualAnalysisModeData, expectedData);
    assertMatchingData(actualStudyModeData, expectedData);
}

Example 3 with Analysis

use of org.icgc.dcc.song.server.model.analysis.Analysis in project SONG by overture-stack.

the class ExportServiceTest method assertMatchingData.

private static void assertMatchingData(Map<String, List<? extends Analysis>> actualData, Map<String, List<? extends Analysis>> expectedData) {
    assertSetsMatch(expectedData.keySet(), actualData.keySet());
    for (val studyId : expectedData.keySet()) {
        val expectedAnalyses = expectedData.get(studyId);
        // Assumed that all analyses in the list are unique
        val actualAnalysisMap = groupUnique(actualData.get(studyId), Analysis::getAnalysisId);
        for (val expectedAnalysis : expectedAnalyses) {
            assertThat(actualAnalysisMap).containsKey(expectedAnalysis.getAnalysisId());
            val actualAnalysis = actualAnalysisMap.get(expectedAnalysis.getAnalysisId());
            assertAnalysis(actualAnalysis, expectedAnalysis);
        }
    }
}

Example 4 with Analysis

use of org.icgc.dcc.song.server.model.analysis.Analysis in project SONG by overture-stack.

the class ExportServiceTest method runSingleExportTest.

private void runSingleExportTest(Class<? extends Analysis> analysisClass, boolean includeAnalysisId, boolean includeOtherIds) {
    val studyId = studyGenerator.createRandomStudy();
    val analysisGenerator = createAnalysisGenerator(studyId, analysisService, randomGenerator);
    val expectedAnalysis = analysisGenerator.createDefaultRandomAnalysis(analysisClass);
    val analysisId = expectedAnalysis.getAnalysisId();
    massageAnalysisInplace(expectedAnalysis, includeAnalysisId, includeOtherIds);
    val exportedPayloads = exportService.exportPayload(newArrayList(analysisId), includeAnalysisId, includeOtherIds);
    assertThat(exportedPayloads).hasSize(1);
    val exportedPayload = exportedPayloads.get(0);
    assertThat(exportedPayload.getStudyId()).isEqualTo(studyId);
    val analyses = exportedPayload.getPayloads().stream().map(x -> fromJson(x, Analysis.class)).collect(toImmutableList());
    assertThat(analyses).hasSize(1);
    val actualAnalysis = analyses.get(0);
    assertAnalysis(actualAnalysis, expectedAnalysis);
}

Example 5 with Analysis

use of org.icgc.dcc.song.server.model.analysis.Analysis in project SONG by overture-stack.

the class AnalysisServiceTest method testGetAnalysisAndIdSearch.

@Test
public void testGetAnalysisAndIdSearch() {
    val studyGenerator = createStudyGenerator(studyService, randomGenerator);
    val studyId = studyGenerator.createRandomStudy();
    val analysisGenerator = createAnalysisGenerator(studyId, service, payloadGenerator);
    val numAnalysis = 10;
    val sraMap = Maps.<String, SequencingReadAnalysis>newHashMap();
    val vcaMap = Maps.<String, VariantCallAnalysis>newHashMap();
    val expectedAnalyses = Sets.<Analysis>newHashSet();
    for (int i = 1; i <= numAnalysis; i++) {
        if (i % 2 == 0) {
            val sra = analysisGenerator.createDefaultRandomSequencingReadAnalysis();
            assertThat(sraMap.containsKey(sra.getAnalysisId())).isFalse();
            sraMap.put(sra.getAnalysisId(), sra);
            expectedAnalyses.add(sra);
        } else {
            val vca = analysisGenerator.createDefaultRandomVariantCallAnalysis();
            assertThat(sraMap.containsKey(vca.getAnalysisId())).isFalse();
            vcaMap.put(vca.getAnalysisId(), vca);
            expectedAnalyses.add(vca);
        }
    }
    assertThat(expectedAnalyses).hasSize(numAnalysis);
    assertThat(sraMap.keySet().size() + vcaMap.keySet().size()).isEqualTo(numAnalysis);
    val expectedVCAs = newHashSet(vcaMap.values());
    val expectedSRAs = newHashSet(sraMap.values());
    assertThat(expectedSRAs).hasSize(sraMap.keySet().size());
    assertThat(expectedVCAs).hasSize(vcaMap.keySet().size());
    val actualAnalyses = service.getAnalysis(studyId);
    val actualSRAs = actualAnalyses.stream().filter(x -> resolveAnalysisType(x.getAnalysisType()) == SEQUENCING_READ).collect(toSet());
    val actualVCAs = actualAnalyses.stream().filter(x -> resolveAnalysisType(x.getAnalysisType()) == VARIANT_CALL).collect(toSet());
    assertThat(actualSRAs).hasSize(sraMap.keySet().size());
    assertThat(actualVCAs).hasSize(vcaMap.keySet().size());
    assertThat(actualSRAs).containsAll(expectedSRAs);
    assertThat(actualVCAs).containsAll(expectedVCAs);
    // Do a study-wide idSearch and verify the response effectively has the same
    // number of results as the getAnalysis method
    val searchedAnalyses = service.idSearch(studyId, createIdSearchRequest(null, null, null, null));
    assertThat(searchedAnalyses).hasSameSizeAs(expectedAnalyses);
    assertThat(searchedAnalyses).containsOnlyElementsOf(expectedAnalyses);
}