Skip to content

Commit

Permalink
Update tests for rapidReport filters
Browse files Browse the repository at this point in the history
Nithriel committed Oct 16, 2023
1 parent f16696c commit d80ce18
Showing 2 changed files with 38 additions and 407 deletions.
411 changes: 21 additions & 390 deletions test/routes/report/variants.test.js
Original file line number Diff line number Diff line change
@@ -4,7 +4,8 @@ const supertest = require('supertest');
const getPort = require('get-port');
const db = require('../../../app/models');

const mockReportData = require('../../testData/mockReportData.json');
const mockReportData = require('../../testData/mockRapidReportData.json');
const createReport = require('../../../app/libs/createReport');

const CONFIG = require('../../../app/config');
const {listen} = require('../../../app');
@@ -30,8 +31,7 @@ const checkVariants = (variantsObject) => {

const checkRapidReportMatches = (
variants,
expectedMatches,
unexpectedMatches,
expectedTable,
) => {
let found = true;

@@ -41,38 +41,27 @@ const checkRapidReportMatches = (
kbMatches = kbMatches.concat(variant.kbMatches);
}

expectedMatches.forEach((expectedMatch) => {
if (!(kbMatches.find((kbMatch) => {return kbMatch.ident === expectedMatch.ident;}))) {
kbMatches.forEach((match) => {
if (!match.evidenceLevel === expectedTable) {
found = false;
}
});

unexpectedMatches.forEach((unexpectedMatch) => {
if (kbMatches.find((kbMatch) => {return kbMatch.ident === unexpectedMatch.ident;})) {
found = false;
}
});
expect(found).toBe(true);
};

const checkVariantsFilter = (
variants,
expectedVariants,
unexpectedVariants,
expectedTable,
) => {
let found = true;

expectedVariants.forEach((expectedVariant) => {
if (!(variants.find((variant) => {return variant.ident === expectedVariant.ident;}))) {
variants.forEach((variant) => {
if (!variant.displayName === expectedTable) {
found = false;
}
});

unexpectedVariants.forEach((unexpectedVariant) => {
if ((variants.find((variant) => {return variant.ident === unexpectedVariant.ident;}))) {
found = false;
}
});
expect(found).toBe(true);
};

@@ -85,70 +74,10 @@ beforeAll(async () => {

// Tests for /kb-matches endpoint
describe('/reports/{REPORTID}/kb-matches', () => {
let rapidReport;

let rapidGeneTA;
let rapidGeneCR;
let rapidGeneGeneric;
let rapidGeneUSOncogene;
let rapidGeneUStumourSuppressor;
let rapidGeneUSAllTrue;
let rapidGeneUSAllFalse;

let rapidVariantTA;
let rapidVariantCR;
let rapidVariantTAGeneric;
let rapidVariantCRGeneric;
let rapidVariantUSOncogene;
let rapidVariantUStumourSuppressor;
let rapidVariantUSAllTrue;
let rapidVariantUSAllFalse;
let rapidVariantMsi;
let rapidVariantMss;
let rapidVariantTmb;

let rapidDataIprA;
let rapidDataIprAGeneric;
let rapidDataIprB;
let rapidDataAlreadyReported;
let rapidDataIprANotTherapeuticMsi;
let rapidDataIprANotTherapeuticTmb;
let rapidDataIprANotTherapeutic;
let rapidDataTherapeuticIprC;
let rapidDataTherapeuticIprCGeneric;
let rapidDataUnknownIprC;
let rapidDataUnknownNull;
let rapidDataTherapeuticNull;
let rapidDataIprAMatchedCancerFalse;
let rapidDataExp;

let kbMatchRapidDataIprA;
let kbMatchRapidDataIprAGeneric;
let kbMatchRapidDataIprB;
let kbMatchRapidDataIprANotTherapeutic;
let kbMatchRapidDataIprANotTherapeuticMsi;
let kbMatchRapidDataIprANotTherapeuticTmb;
let kbMatchRapidDataAlreadyReported;
let kbMatchRapidDataTherapeuticIprC;
let kbMatchRapidDataTherapeuticIprCGeneric;
let kbMatchRapidDataUnknownIprC;
let kbMatchRapidDataIprTherapeuticNull;
let kbMatchRapidDataIprUnknownNull;
let kbMatchRapidDataIprAMatchedCancerFalse;
let kbMatchRapidDataExp;

let therapeuticAssociationMatches;
let cancerRelevanceMatches;
let unknownSignificanceMatches;
let excludedMatches;

let therapeuticAssociationVariants;
let cancerRelevanceVariants;
let unknownSignificanceVariants;
let excludedVariants;
let rapidReportIdent;

beforeAll(async () => {
// Get genomic template
// Get rapid template
let rapidTemplate = await db.models.template.findOne({where: {name: 'rapid'}});

if (!rapidTemplate) {
@@ -158,304 +87,13 @@ describe('/reports/{REPORTID}/kb-matches', () => {
});
}

rapidReport = await db.models.report.create({
templateId: rapidTemplate.id,
patientId: mockReportData.patientId,
});
rapidGeneTA = await db.models.genes.create({
reportId: rapidReport.id,
name: 'TA',
});
rapidGeneCR = await db.models.genes.create({
reportId: rapidReport.id,
name: 'CR',
});
rapidGeneGeneric = await db.models.genes.create({
reportId: rapidReport.id,
name: 'Generic',
oncogene: true,
tumourSuppressor: true,
});

rapidGeneUSOncogene = await db.models.genes.create({
reportId: rapidReport.id,
name: 'US1',
oncogene: true,
tumourSuppressor: false,
});
rapidGeneUStumourSuppressor = await db.models.genes.create({
reportId: rapidReport.id,
name: 'US2',
oncogene: false,
tumourSuppressor: true,
});
rapidGeneUSAllTrue = await db.models.genes.create({
reportId: rapidReport.id,
name: 'US3',
oncogene: true,
tumourSuppressor: true,
});
rapidGeneUSAllFalse = await db.models.genes.create({
reportId: rapidReport.id,
name: 'US4',
oncogene: false,
tumourSuppressor: false,
});

rapidVariantTA = await db.models.copyVariants.create({
reportId: rapidReport.id,
geneId: rapidGeneTA.id,
});
rapidVariantCR = await db.models.copyVariants.create({
reportId: rapidReport.id,
geneId: rapidGeneCR.id,
});

rapidVariantTAGeneric = await db.models.smallMutations.create({
reportId: rapidReport.id,
geneId: rapidGeneGeneric.id,
});
rapidVariantCRGeneric = await db.models.smallMutations.create({
reportId: rapidReport.id,
geneId: rapidGeneGeneric.id,
});

rapidVariantUSOncogene = await db.models.smallMutations.create({
reportId: rapidReport.id,
geneId: rapidGeneUSOncogene.id,
});
rapidVariantUStumourSuppressor = await db.models.smallMutations.create({
reportId: rapidReport.id,
geneId: rapidGeneUStumourSuppressor.id,
});
rapidVariantUSAllTrue = await db.models.smallMutations.create({
reportId: rapidReport.id,
geneId: rapidGeneUSAllTrue.id,
});
rapidVariantUSAllFalse = await db.models.smallMutations.create({
reportId: rapidReport.id,
geneId: rapidGeneUSAllFalse.id,
});

rapidVariantMsi = await db.models.msi.create({
reportId: rapidReport.id,
score: 100.00,
});
rapidVariantMss = await db.models.msi.create({
reportId: rapidReport.id,
score: 15.00,
});
rapidVariantTmb = await db.models.tmburMutationBurden.create({
reportId: rapidReport.id,
});

rapidDataIprA = {
reportId: rapidReport.id,
variantId: rapidVariantTA.id,
category: 'therapeutic',
variantType: 'cnv',
iprEvidenceLevel: 'IPR-A',
kbVariant: 'this should be in table 1',
matchedCancer: true,
};

rapidDataIprB = {
reportId: rapidReport.id,
variantId: rapidVariantTA.id,
category: 'therapeutic',
variantType: 'cnv',
iprEvidenceLevel: 'IPR-B',
matchedCancer: true,
kbVariant: 'thisshouldbeintable1',
};

rapidDataAlreadyReported = {
reportId: rapidReport.id,
variantId: rapidVariantTA.id,
category: 'unknown',
variantType: 'cnv',
iprEvidenceLevel: 'IPR-A',
kbVariant: 'geneX specific mutation',
};

rapidDataIprANotTherapeutic = {
reportId: rapidReport.id,
variantId: rapidVariantCR.id,
category: 'unknown',
variantType: 'cnv',
iprEvidenceLevel: 'IPR-A',
kbVariant: 'this.should.be:table2',
};

rapidDataIprANotTherapeuticMsi = {
reportId: rapidReport.id,
variantId: rapidVariantMsi.id,
category: 'unknown',
variantType: 'msi',
iprEvidenceLevel: 'IPR-A',
kbVariant: 'also should be table 2',
};

rapidDataIprANotTherapeuticTmb = {
reportId: rapidReport.id,
variantId: rapidVariantTmb.id,
category: 'unknown',
variantType: 'tmb',
iprEvidenceLevel: 'IPR-A',
kbVariant: 'geneX specific mutation',
};

rapidDataTherapeuticIprC = {
reportId: rapidReport.id,
variantId: rapidVariantCR.id,
category: 'therapeutic',
variantType: 'cnv',
iprEvidenceLevel: 'IPR-C',
kbVariant: 'table2 specific mutation',
};

rapidDataUnknownIprC = {
reportId: rapidReport.id,
variantId: rapidVariantCR.id,
category: 'unknown',
variantType: 'cnv',
iprEvidenceLevel: 'IPR-C',
kbVariant: 'geneX specific mutation',
};

rapidDataUnknownNull = {
reportId: rapidReport.id,
variantId: rapidVariantCR.id,
category: 'unknown',
variantType: 'cnv',
iprEvidenceLevel: null,
kbVariant: 'geneX specific mutation',
};

rapidDataTherapeuticNull = {
reportId: rapidReport.id,
variantId: rapidVariantCR.id,
category: 'therapeutic',
variantType: 'cnv',
iprEvidenceLevel: null,
kbVariant: 'geneX specific mutation',
};

rapidDataIprAMatchedCancerFalse = {
reportId: rapidReport.id,
variantId: rapidVariantCR.id,
category: 'therapeutic',
variantType: 'cnv',
iprEvidenceLevel: 'IPR-A',
matchedCancer: false,
kbVariant: 'geneX specific mutation',
};

rapidDataExp = {
reportId: rapidReport.id,
variantId: rapidVariantCR.id,
category: 'therapeutic',
variantType: 'exp',
iprEvidenceLevel: 'IPR-A',
matchedCancer: true,
kbVariant: 'geneX specific mutation',
};

rapidDataIprAGeneric = {
reportId: rapidReport.id,
variantId: rapidVariantTAGeneric.id,
category: 'therapeutic',
variantType: 'mut',
iprEvidenceLevel: 'IPR-A',
kbVariant: 'geneX missense',
matchedCancer: true,
};

rapidDataTherapeuticIprCGeneric = {
reportId: rapidReport.id,
variantId: rapidVariantCRGeneric.id,
category: 'therapeutic',
variantType: 'mut',
iprEvidenceLevel: 'IPR-C',
kbVariant: 'geneX mutation',
};

kbMatchRapidDataIprA = await db.models.kbMatches.create(rapidDataIprA);
kbMatchRapidDataIprB = await db.models.kbMatches.create(rapidDataIprB);
kbMatchRapidDataIprANotTherapeutic = await db.models.kbMatches.create(
rapidDataIprANotTherapeutic,
);
kbMatchRapidDataIprANotTherapeuticMsi = await db.models.kbMatches.create(
rapidDataIprANotTherapeuticMsi,
);
kbMatchRapidDataIprANotTherapeuticTmb = await db.models.kbMatches.create(
rapidDataIprANotTherapeuticTmb,
);
kbMatchRapidDataAlreadyReported = await db.models.kbMatches.create(
rapidDataAlreadyReported,
);
kbMatchRapidDataTherapeuticIprC = await db.models.kbMatches.create(rapidDataTherapeuticIprC);
kbMatchRapidDataUnknownIprC = await db.models.kbMatches.create(rapidDataUnknownIprC);

kbMatchRapidDataIprTherapeuticNull = await db.models.kbMatches.create(rapidDataTherapeuticNull);
kbMatchRapidDataIprUnknownNull = await db.models.kbMatches.create(rapidDataUnknownNull);

kbMatchRapidDataIprAMatchedCancerFalse = await
db.models.kbMatches.create(rapidDataIprAMatchedCancerFalse);

kbMatchRapidDataExp = await
db.models.kbMatches.create(rapidDataExp);

kbMatchRapidDataIprAGeneric = await db.models.kbMatches.create(rapidDataIprAGeneric);
kbMatchRapidDataTherapeuticIprCGeneric = await db.models.kbMatches.create(
rapidDataTherapeuticIprCGeneric,
);

therapeuticAssociationMatches = [
kbMatchRapidDataIprA,
kbMatchRapidDataIprB,
];
cancerRelevanceMatches = [
kbMatchRapidDataIprANotTherapeutic,
kbMatchRapidDataTherapeuticIprC,
kbMatchRapidDataUnknownIprC,
kbMatchRapidDataIprTherapeuticNull,
kbMatchRapidDataIprUnknownNull,
kbMatchRapidDataIprAMatchedCancerFalse,
kbMatchRapidDataIprANotTherapeuticMsi,
kbMatchRapidDataIprANotTherapeuticTmb,
];
unknownSignificanceMatches = [
kbMatchRapidDataIprAGeneric,
kbMatchRapidDataTherapeuticIprCGeneric,
];
excludedMatches = [
kbMatchRapidDataExp,
kbMatchRapidDataAlreadyReported,
];

therapeuticAssociationVariants = [
rapidVariantTA,
];
cancerRelevanceVariants = [
rapidVariantCR,
rapidVariantMsi,
rapidVariantTmb,
];
unknownSignificanceVariants = [
rapidVariantUSOncogene,
rapidVariantUStumourSuppressor,
rapidVariantUSAllTrue,
rapidVariantTAGeneric,
rapidVariantCRGeneric,
];
excludedVariants = [rapidVariantUSAllFalse, rapidVariantMss];
rapidReportIdent = await createReport(mockReportData);
}, LONGER_TIMEOUT);

describe('GET', () => {
test('Getting Therapeutic Association - OK', async () => {
const res = await request
.get(`/api/reports/${rapidReport.ident}/variants`)
.get(`/api/reports/${rapidReportIdent}/variants`)
.query({rapidTable: 'therapeuticAssociation'})
.auth(username, password)
.type('json')
@@ -466,19 +104,17 @@ describe('/reports/{REPORTID}/kb-matches', () => {

checkVariantsFilter(
res.body,
therapeuticAssociationVariants,
[...cancerRelevanceVariants, ...excludedVariants, ...unknownSignificanceVariants],
'table 1',
);
checkRapidReportMatches(
res.body,
therapeuticAssociationMatches,
[...cancerRelevanceMatches, ...excludedMatches],
'table 1',
);
});

test('Getting Cancer Relevance - OK', async () => {
const res = await request
.get(`/api/reports/${rapidReport.ident}/variants`)
.get(`/api/reports/${rapidReportIdent}/variants`)
.query({rapidTable: 'cancerRelevance'})
.auth(username, password)
.type('json')
@@ -489,19 +125,17 @@ describe('/reports/{REPORTID}/kb-matches', () => {

checkVariantsFilter(
res.body,
cancerRelevanceVariants,
[...therapeuticAssociationVariants, ...excludedVariants, ...unknownSignificanceVariants],
'table 2',
);
checkRapidReportMatches(
res.body,
cancerRelevanceMatches,
[...therapeuticAssociationMatches, ...excludedMatches, ...unknownSignificanceVariants],
'table 2',
);
});

test('Getting Unknown Significance - OK', async () => {
const res = await request
.get(`/api/reports/${rapidReport.ident}/variants`)
.get(`/api/reports/${rapidReportIdent}/variants`)
.query({rapidTable: 'unknownSignificance'})
.auth(username, password)
.type('json')
@@ -512,21 +146,18 @@ describe('/reports/{REPORTID}/kb-matches', () => {

checkVariantsFilter(
res.body,
unknownSignificanceVariants,
[...therapeuticAssociationVariants, ...excludedVariants, ...cancerRelevanceVariants],
'table 3',
);

checkRapidReportMatches(
res.body,
unknownSignificanceMatches,
[...therapeuticAssociationMatches, ...excludedMatches, cancerRelevanceMatches],
'table 3',
);
});
});

// delete report
afterAll(async () => {
await db.models.report.destroy({where: {id: rapidReport.id}, force: true});
// await db.models.report.destroy({where: {ident: rapidReportIdent}, force: true});
}, LONGER_TIMEOUT);
});

34 changes: 17 additions & 17 deletions test/testData/mockRapidReportData.json
Original file line number Diff line number Diff line change
@@ -21,14 +21,6 @@
"matchedCancer": true,
"evidenceLevel": "table 1"
},
{
"category": "unknown",
"variantType": "cnv",
"variant": "TA",
"iprEvidenceLevel": "IPR-A",
"kbVariant": "geneX specific mutation 1",
"evidenceLevel": "table null"
},
{
"category": "unknown",
"variantType": "cnv",
@@ -94,15 +86,6 @@
"matchedCancer": false,
"evidenceLevel": "table 2"
},
{
"category": "therapeutic",
"variantType": "exp",
"variant": "alltrueexp",
"iprEvidenceLevel": "IPR-A",
"kbVariant": "geneX specific mutation 7",
"matchedCancer": true,
"evidenceLevel": "table null"
},
{
"category": "therapeutic",
"variantType": "mut",
@@ -119,6 +102,23 @@
"iprEvidenceLevel": "IPR-C",
"kbVariant": "geneX mutation",
"evidenceLevel": "table 3"
},
{
"category": "unknown",
"variantType": "cnv",
"variant": "TA",
"iprEvidenceLevel": "IPR-A",
"kbVariant": "geneX specific mutation 1",
"evidenceLevel": "table null"
},
{
"category": "therapeutic",
"variantType": "exp",
"variant": "alltrueexp",
"iprEvidenceLevel": "IPR-A",
"kbVariant": "geneX specific mutation 7",
"matchedCancer": true,
"evidenceLevel": "table null"
}
],
"genes": [

0 comments on commit d80ce18

Please sign in to comment.