test/jalview/ext/ensembl/EnsemblGeneTest.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
   3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
   4  *
   5  * This file is part of Jalview.
   6  *
   7  * Jalview is free software: you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation, either version 3
  10  * of the License, or (at your option) any later version.
  11  *
  12  * Jalview is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty
  14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE.  See the GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  19  * The Jalview Authors are detailed in the 'AUTHORS' file.
  20  */
  21 package jalview.ext.ensembl;
  22
  23 import static org.testng.AssertJUnit.assertEquals;
  24 import static org.testng.AssertJUnit.assertFalse;
  25 import static org.testng.AssertJUnit.assertSame;
  26 import static org.testng.AssertJUnit.assertTrue;
  27
  28 import jalview.api.FeatureSettingsModelI;
  29 import jalview.datamodel.SequenceDummy;
  30 import jalview.datamodel.SequenceFeature;
  31 import jalview.datamodel.SequenceI;
  32 import jalview.io.gff.SequenceOntologyFactory;
  33 import jalview.io.gff.SequenceOntologyLite;
  34 import jalview.util.MapList;
  35
  36 import java.awt.Color;
  37 import java.util.List;
  38
  39 import org.testng.annotations.AfterClass;
  40 import org.testng.annotations.BeforeClass;
  41 import org.testng.annotations.Test;
  42
  43 public class EnsemblGeneTest
  44 {
  45   @BeforeClass(alwaysRun = true)
  46   public void setUp()
  47   {
  48     SequenceOntologyFactory.setInstance(new SequenceOntologyLite());
  49   }
  50
  51   @AfterClass(alwaysRun = true)
  52   public void tearDown()
  53   {
  54     SequenceOntologyFactory.setInstance(null);
  55   }
  56
  57   /**
  58    * Test that the gene part of genomic sequence is uniquely identified by a
  59    * 'gene' features (or subtype) with the correct gene ID
  60    */
  61   @Test(groups = "Functional")
  62   public void testGetGenomicRangesFromFeatures()
  63   {
  64     EnsemblGene testee = new EnsemblGene();
  65     SequenceI genomic = new SequenceDummy("chr7");
  66     genomic.setStart(10000);
  67     genomic.setEnd(50000);
  68     String geneId = "ABC123";
  69
  70     // gene at (start+10000) length 501
  71     SequenceFeature sf = new SequenceFeature("gene", "", 20000, 20500, 0f,
  72             null);
  73     sf.setValue("ID", "gene:" + geneId);
  74     sf.setStrand("+");
  75     genomic.addSequenceFeature(sf);
  76
  77     // gene at (start + 10500) length 101
  78     // should be ignored - the first 'gene' found defines the whole range
  79     sf = new SequenceFeature("gene", "", 10500, 10600, 0f, null);
  80     sf.setValue("ID", "gene:" + geneId);
  81     sf.setStrand("+");
  82     genomic.addSequenceFeature(sf);
  83
  84     MapList ranges = testee.getGenomicRangesFromFeatures(genomic, geneId,
  85             23);
  86     List<int[]> fromRanges = ranges.getFromRanges();
  87     assertEquals(1, fromRanges.size());
  88     assertEquals(20000, fromRanges.get(0)[0]);
  89     assertEquals(20500, fromRanges.get(0)[1]);
  90     // to range should start from given start numbering
  91     List<int[]> toRanges = ranges.getToRanges();
  92     assertEquals(1, toRanges.size());
  93     assertEquals(23, toRanges.get(0)[0]);
  94     assertEquals(523, toRanges.get(0)[1]);
  95   }
  96
  97   /**
  98    * Test variant using a sub-type of gene from the Sequence Ontology
  99    */
 100   @Test(groups = "Functional")
 101   public void testGetGenomicRangesFromFeatures_ncRNA_gene_reverseStrand()
 102   {
 103     EnsemblGene testee = new EnsemblGene();
 104     SequenceI genomic = new SequenceDummy("chr7");
 105     genomic.setStart(10000);
 106     genomic.setEnd(50000);
 107     String geneId = "ABC123";
 108
 109     // gene at (start+10000) length 501
 110     SequenceFeature sf = new SequenceFeature("ncRNA_gene", "", 20000,
 111             20500, 0f, null);
 112     sf.setValue("ID", "gene:" + geneId);
 113     sf.setStrand("-");
 114     genomic.addSequenceFeature(sf);
 115
 116     // gene at (start + 10500) length 101
 117     // should be ignored - the first 'gene' found defines the whole range
 118     // (real data would only have one such feature)
 119     sf = new SequenceFeature("gene", "", 10500, 10600, 0f, null);
 120     sf.setValue("ID", "gene:" + geneId);
 121     sf.setStrand("+");
 122     genomic.addSequenceFeature(sf);
 123
 124     MapList ranges = testee.getGenomicRangesFromFeatures(genomic, geneId,
 125             23);
 126     List<int[]> fromRanges = ranges.getFromRanges();
 127     assertEquals(1, fromRanges.size());
 128     // from range on reverse strand:
 129     assertEquals(20500, fromRanges.get(0)[0]);
 130     assertEquals(20000, fromRanges.get(0)[1]);
 131     // to range should start from given start numbering
 132     List<int[]> toRanges = ranges.getToRanges();
 133     assertEquals(1, toRanges.size());
 134     assertEquals(23, toRanges.get(0)[0]);
 135     assertEquals(523, toRanges.get(0)[1]);
 136   }
 137
 138   /**
 139    * Test the method that extracts transcript (or subtype) features with a
 140    * specified gene as parent
 141    */
 142   @Test(groups = "Functional")
 143   public void testGetTranscriptFeatures()
 144   {
 145     SequenceI genomic = new SequenceDummy("chr7");
 146     genomic.setStart(10000);
 147     genomic.setEnd(50000);
 148     String geneId = "ABC123";
 149
 150     // transcript feature
 151     SequenceFeature sf1 = new SequenceFeature("transcript", "", 20000,
 152             20500, 0f, null);
 153     sf1.setValue("Parent", "gene:" + geneId);
 154     sf1.setValue("transcript_id", "transcript1");
 155     genomic.addSequenceFeature(sf1);
 156
 157     // transcript sub-type feature
 158     SequenceFeature sf2 = new SequenceFeature("snRNA", "", 20000, 20500,
 159             0f, null);
 160     sf2.setValue("Parent", "gene:" + geneId);
 161     sf2.setValue("transcript_id", "transcript2");
 162     genomic.addSequenceFeature(sf2);
 163
 164     // NMD_transcript_variant treated like transcript in Ensembl
 165     SequenceFeature sf3 = new SequenceFeature("NMD_transcript_variant", "",
 166             20000, 20500, 0f, null);
 167     sf3.setValue("Parent", "gene:" + geneId);
 168     sf3.setValue("transcript_id", "transcript3");
 169     genomic.addSequenceFeature(sf3);
 170
 171     // transcript for a different gene - ignored
 172     SequenceFeature sf4 = new SequenceFeature("snRNA", "", 20000, 20500,
 173             0f, null);
 174     sf4.setValue("Parent", "gene:XYZ");
 175     sf4.setValue("transcript_id", "transcript4");
 176     genomic.addSequenceFeature(sf4);
 177
 178     EnsemblGene testee = new EnsemblGene();
 179
 180     /*
 181      * with no filter
 182      */
 183     List<SequenceFeature> features = testee.getTranscriptFeatures(geneId,
 184             genomic);
 185     assertEquals(3, features.size());
 186     assertSame(sf1, features.get(0));
 187     assertSame(sf2, features.get(1));
 188     assertSame(sf3, features.get(2));
 189   }
 190
 191   /**
 192    * Test the method that retains features except for 'gene', or 'transcript'
 193    * with parent other than the given id
 194    */
 195   @Test(groups = "Functional")
 196   public void testRetainFeature()
 197   {
 198     String geneId = "ABC123";
 199     EnsemblGene testee = new EnsemblGene();
 200     SequenceFeature sf = new SequenceFeature("gene", "", 20000, 20500, 0f,
 201             null);
 202     sf.setValue("ID", "gene:" + geneId);
 203     assertFalse(testee.retainFeature(sf, geneId));
 204
 205     sf.setType("transcript");
 206     sf.setValue("Parent", "gene:" + geneId);
 207     assertTrue(testee.retainFeature(sf, geneId));
 208
 209     sf.setType("mature_transcript");
 210     sf.setValue("Parent", "gene:" + geneId);
 211     assertTrue(testee.retainFeature(sf, geneId));
 212
 213     sf.setType("NMD_transcript_variant");
 214     sf.setValue("Parent", "gene:" + geneId);
 215     assertTrue(testee.retainFeature(sf, geneId));
 216
 217     sf.setValue("Parent", "gene:XYZ");
 218     assertFalse(testee.retainFeature(sf, geneId));
 219
 220     sf.setType("anything");
 221     assertTrue(testee.retainFeature(sf, geneId));
 222   }
 223
 224   /**
 225    * Test the method that picks out 'gene' (or subtype) features with the
 226    * accession id as ID
 227    */
 228   @Test(groups = "Functional")
 229   public void testIdentifiesSequence()
 230   {
 231     String accId = "ABC123";
 232     EnsemblGene testee = new EnsemblGene();
 233
 234     // gene with no ID not valid
 235     SequenceFeature sf = new SequenceFeature("gene", "", 1, 2, 0f, null);
 236     assertFalse(testee.identifiesSequence(sf, accId));
 237
 238     // gene with wrong ID not valid
 239     sf.setValue("ID", "gene:XYZ");
 240     assertFalse(testee.identifiesSequence(sf, accId));
 241
 242     // gene with right ID is valid
 243     sf.setValue("ID", "gene:" + accId);
 244     assertTrue(testee.identifiesSequence(sf, accId));
 245
 246     // gene sub-type with right ID is valid
 247     sf.setType("snRNA_gene");
 248     assertTrue(testee.identifiesSequence(sf, accId));
 249
 250     // transcript not valid:
 251     sf.setType("transcript");
 252     assertFalse(testee.identifiesSequence(sf, accId));
 253
 254     // exon not valid:
 255     sf.setType("exon");
 256     assertFalse(testee.identifiesSequence(sf, accId));
 257   }
 258
 259   /**
 260    * Check behaviour of feature colour scheme for EnsemblGene sequences.
 261    * Currently coded to display exon and sequence_variant (or sub-types) only,
 262    * with sequence_variant in red above exon coloured by label.
 263    */
 264   @Test(groups = "Functional")
 265   public void testGetFeatureColourScheme()
 266   {
 267     FeatureSettingsModelI fc = new EnsemblGene().getFeatureColourScheme();
 268     assertTrue(fc.isFeatureDisplayed("exon"));
 269     assertTrue(fc.isFeatureDisplayed("coding_exon")); // subtype of exon
 270     assertTrue(fc.isFeatureDisplayed("sequence_variant"));
 271     assertTrue(fc.isFeatureDisplayed("feature_variant")); // subtype
 272     assertFalse(fc.isFeatureDisplayed("transcript"));
 273     assertEquals(Color.RED, fc.getFeatureColour("sequence_variant")
 274             .getColour());
 275     assertEquals(Color.RED, fc.getFeatureColour("feature_variant")
 276             .getColour());
 277     assertTrue(fc.getFeatureColour("exon").isColourByLabel());
 278     assertTrue(fc.getFeatureColour("coding_exon").isColourByLabel());
 279     assertEquals(1, fc.compare("sequence_variant", "exon"));
 280     assertEquals(-1, fc.compare("exon", "sequence_variant"));
 281     assertEquals(1, fc.compare("feature_variant", "coding_exon"));
 282     assertEquals(-1, fc.compare("coding_exon", "feature_variant"));
 283     assertEquals(1f, fc.getTransparency());
 284   }
 285 }