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 java.util.Locale;
  24
  25 import static org.testng.AssertJUnit.assertEquals;
  26 import static org.testng.AssertJUnit.assertFalse;
  27 import static org.testng.AssertJUnit.assertTrue;
  28
  29 import jalview.api.FeatureSettingsModelI;
  30 import jalview.bin.Cache;
  31 import jalview.datamodel.Sequence;
  32 import jalview.datamodel.SequenceDummy;
  33 import jalview.datamodel.SequenceFeature;
  34 import jalview.datamodel.SequenceI;
  35 import jalview.gui.JvOptionPane;
  36 import jalview.io.gff.SequenceOntologyFactory;
  37 import jalview.io.gff.SequenceOntologyLite;
  38 import jalview.util.MapList;
  39
  40 import java.awt.Color;
  41 import java.util.List;
  42
  43 import org.testng.annotations.AfterClass;
  44 import org.testng.annotations.BeforeClass;
  45 import org.testng.annotations.Test;
  46
  47 public class EnsemblGeneTest
  48 {
  49
  50   @BeforeClass(alwaysRun = true)
  51   public void setUpJvOptionPane()
  52   {
  53     JvOptionPane.setInteractiveMode(false);
  54     JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION);
  55   }
  56
  57   @BeforeClass(alwaysRun = true)
  58   public void setUp()
  59   {
  60     Cache.loadProperties("test/jalview/io/testProps.jvprops");
  61     SequenceOntologyFactory.setInstance(new SequenceOntologyLite());
  62   }
  63
  64   @AfterClass(alwaysRun = true)
  65   public void tearDown()
  66   {
  67     SequenceOntologyFactory.setInstance(null);
  68   }
  69
  70   /**
  71    * Test that the gene part of genomic sequence is uniquely identified by a
  72    * 'gene' features (or subtype) with the correct gene ID
  73    */
  74   @Test(groups = "Functional")
  75   public void testGetGenomicRangesFromFeatures()
  76   {
  77     EnsemblGene testee = new EnsemblGene();
  78     SequenceI genomic = new SequenceDummy("chr7");
  79     genomic.setStart(10000);
  80     genomic.setEnd(50000);
  81     String geneId = "ABC123";
  82
  83     // gene at (start + 10500) length 101
  84     SequenceFeature sf = new SequenceFeature("gene", "", 10500, 10600, 0f,
  85             null);
  86     sf.setValue("id", geneId);
  87     sf.setStrand("+");
  88     genomic.addSequenceFeature(sf);
  89
  90     MapList ranges = testee.getGenomicRangesFromFeatures(genomic, geneId,
  91             23);
  92     List<int[]> fromRanges = ranges.getFromRanges();
  93     assertEquals(1, fromRanges.size());
  94     assertEquals(10500, fromRanges.get(0)[0]);
  95     assertEquals(10600, fromRanges.get(0)[1]);
  96     // to range should start from given start numbering
  97     List<int[]> toRanges = ranges.getToRanges();
  98     assertEquals(1, toRanges.size());
  99     assertEquals(23, toRanges.get(0)[0]);
 100     assertEquals(123, toRanges.get(0)[1]);
 101   }
 102
 103   /**
 104    * Test variant using a sub-type of gene from the Sequence Ontology
 105    */
 106   @Test(groups = "Functional")
 107   public void testGetGenomicRangesFromFeatures_ncRNA_gene_reverseStrand()
 108   {
 109     EnsemblGene testee = new EnsemblGene();
 110     SequenceI genomic = new SequenceDummy("chr7");
 111     genomic.setStart(10000);
 112     genomic.setEnd(50000);
 113     String geneId = "ABC123";
 114
 115     // gene at (start + 10500) length 101
 116     SequenceFeature sf = new SequenceFeature("gene", "", 10500, 10600, 0f,
 117             null);
 118     sf.setValue("id", geneId);
 119     sf.setStrand("+");
 120     genomic.addSequenceFeature(sf);
 121
 122     MapList ranges = testee.getGenomicRangesFromFeatures(genomic, geneId,
 123             23);
 124     List<int[]> fromRanges = ranges.getFromRanges();
 125     assertEquals(1, fromRanges.size());
 126     // from range on reverse strand:
 127     assertEquals(10500, fromRanges.get(0)[0]);
 128     assertEquals(10600, fromRanges.get(0)[1]);
 129     // to range should start from given start numbering
 130     List<int[]> toRanges = ranges.getToRanges();
 131     assertEquals(1, toRanges.size());
 132     assertEquals(23, toRanges.get(0)[0]);
 133     assertEquals(123, toRanges.get(0)[1]);
 134   }
 135
 136   /**
 137    * Test the method that extracts transcript (or subtype) features with a
 138    * specified gene as parent
 139    */
 140   @Test(groups = "Functional")
 141   public void testGetTranscriptFeatures()
 142   {
 143     SequenceI genomic = new SequenceDummy("chr7");
 144     genomic.setStart(10000);
 145     genomic.setEnd(50000);
 146     String geneId = "ABC123";
 147
 148     // transcript feature
 149     SequenceFeature sf1 = new SequenceFeature("transcript", "", 20000,
 150             20500, 0f, null);
 151     sf1.setValue("Parent", geneId);
 152     sf1.setValue("id", "transcript1");
 153     genomic.addSequenceFeature(sf1);
 154
 155     // transcript sub-type feature
 156     SequenceFeature sf2 = new SequenceFeature("snRNA", "", 21000, 21500,
 157             0f, null);
 158     sf2.setValue("Parent", geneId);
 159     sf2.setValue("id", "transcript2");
 160     genomic.addSequenceFeature(sf2);
 161
 162     // NMD_transcript_variant treated like transcript in Ensembl
 163     SequenceFeature sf3 = new SequenceFeature("NMD_transcript_variant", "",
 164             22000, 22500, 0f, null);
 165     // id matching should not be case-sensitive
 166     sf3.setValue("Parent", geneId.toLowerCase(Locale.ROOT));
 167     sf3.setValue("id", "transcript3");
 168     genomic.addSequenceFeature(sf3);
 169
 170     // transcript for a different gene - ignored
 171     SequenceFeature sf4 = new SequenceFeature("snRNA", "", 23000, 23500,
 172             0f, null);
 173     sf4.setValue("Parent", "XYZ");
 174     sf4.setValue("id", "transcript4");
 175     genomic.addSequenceFeature(sf4);
 176
 177     EnsemblGene testee = new EnsemblGene();
 178
 179     /*
 180      * with no filter
 181      */
 182     List<SequenceFeature> features = testee.getTranscriptFeatures(geneId,
 183             genomic);
 184     assertEquals(3, features.size());
 185     assertTrue(features.contains(sf1));
 186     assertTrue(features.contains(sf2));
 187     assertTrue(features.contains(sf3));
 188   }
 189
 190   /**
 191    * Test the method that retains features except for 'gene', or 'transcript'
 192    * with parent other than the given id
 193    */
 194   @Test(groups = "Functional")
 195   public void testRetainFeature()
 196   {
 197     String geneId = "ABC123";
 198     EnsemblGene testee = new EnsemblGene();
 199     SequenceFeature sf = new SequenceFeature("gene", "", 20000, 20500, 0f,
 200             null);
 201     sf.setValue("id", geneId);
 202     assertFalse(testee.retainFeature(sf, geneId));
 203
 204     sf = new SequenceFeature("transcript", "", 20000, 20500, 0f, null);
 205     sf.setValue("Parent", geneId);
 206     assertTrue(testee.retainFeature(sf, geneId));
 207
 208     sf = new SequenceFeature("mature_transcript", "", 20000, 20500, 0f,
 209             null);
 210     sf.setValue("Parent", geneId);
 211     assertTrue(testee.retainFeature(sf, geneId));
 212
 213     sf = new SequenceFeature("NMD_transcript_variant", "", 20000, 20500,
 214             0f, null);
 215     sf.setValue("Parent", geneId);
 216     assertTrue(testee.retainFeature(sf, geneId));
 217
 218     sf.setValue("Parent", "ßXYZ");
 219     assertFalse(testee.retainFeature(sf, geneId));
 220
 221     sf = new SequenceFeature("anything", "", 20000, 20500, 0f, null);
 222     assertTrue(testee.retainFeature(sf, geneId));
 223   }
 224
 225   /**
 226    * Test the method that picks out 'gene' (or subtype) features with the
 227    * accession id as ID
 228    */
 229   @Test(groups = "Functional")
 230   public void testGetIdentifyingFeatures()
 231   {
 232     String accId = "ABC123";
 233     SequenceI seq = new Sequence(accId, "HIBEES");
 234
 235     // gene with no ID not valid
 236     SequenceFeature sf1 = new SequenceFeature("gene", "", 1, 2, 0f, null);
 237     seq.addSequenceFeature(sf1);
 238
 239     // gene with wrong ID not valid
 240     SequenceFeature sf2 = new SequenceFeature("gene", "a", 1, 2, 0f, null);
 241     sf2.setValue("id", "XYZ");
 242     seq.addSequenceFeature(sf2);
 243
 244     // gene with right ID is valid
 245     SequenceFeature sf3 = new SequenceFeature("gene", "b", 1, 2, 0f, null);
 246     sf3.setValue("id", accId);
 247     seq.addSequenceFeature(sf3);
 248
 249     // gene sub-type with right ID is valid
 250     SequenceFeature sf4 = new SequenceFeature("snRNA_gene", "", 1, 2, 0f, null);
 251     sf4.setValue("id", accId);
 252     seq.addSequenceFeature(sf4);
 253
 254     // transcript not valid:
 255     SequenceFeature sf5 = new SequenceFeature("transcript", "", 1, 2, 0f, null);
 256     sf5.setValue("id", accId);
 257     seq.addSequenceFeature(sf5);
 258
 259     // exon not valid:
 260     SequenceFeature sf6 = new SequenceFeature("exon", "", 1, 2, 0f, null);
 261     sf6.setValue("id", accId);
 262     seq.addSequenceFeature(sf6);
 263
 264     List<SequenceFeature> sfs = new EnsemblGene()
 265             .getIdentifyingFeatures(seq, accId);
 266     assertFalse(sfs.contains(sf1));
 267     assertFalse(sfs.contains(sf2));
 268     assertTrue(sfs.contains(sf3));
 269     assertTrue(sfs.contains(sf4));
 270     assertFalse(sfs.contains(sf5));
 271     assertFalse(sfs.contains(sf6));
 272   }
 273
 274   /**
 275    * Check behaviour of feature colour scheme for EnsemblGene sequences.
 276    * Currently coded to hide all except exon and sequence_variant (or sub-types)
 277    * only, with sequence_variant in red above exon coloured by label.
 278    */
 279   @Test(groups = "Functional")
 280   public void testGetFeatureColourScheme()
 281   {
 282     FeatureSettingsModelI fc = new EnsemblGene().getFeatureColourScheme();
 283     assertFalse(fc.isFeatureDisplayed("exon"));
 284     assertFalse(fc.isFeatureHidden("exon"));
 285     assertFalse(fc.isFeatureDisplayed("coding_exon")); // subtype of exon
 286     assertFalse(fc.isFeatureHidden("coding_exon")); // subtype of exon
 287     assertFalse(fc.isFeatureDisplayed("sequence_variant"));
 288     assertFalse(fc.isFeatureHidden("sequence_variant"));
 289     assertFalse(fc.isFeatureDisplayed("feature_variant")); // subtype
 290     assertFalse(fc.isFeatureHidden("feature_variant")); // subtype
 291     assertTrue(fc.isFeatureHidden("transcript"));
 292     assertTrue(fc.isFeatureHidden("CDS"));
 293
 294     assertEquals(Color.RED, fc.getFeatureColour("sequence_variant")
 295             .getColour());
 296     assertEquals(Color.RED, fc.getFeatureColour("feature_variant")
 297             .getColour());
 298     assertTrue(fc.getFeatureColour("exon").isColourByLabel());
 299     assertTrue(fc.getFeatureColour("coding_exon").isColourByLabel());
 300     assertEquals(1, fc.compare("sequence_variant", "exon"));
 301     assertEquals(-1, fc.compare("exon", "sequence_variant"));
 302     assertEquals(1, fc.compare("feature_variant", "coding_exon"));
 303     assertEquals(-1, fc.compare("coding_exon", "feature_variant"));
 304     assertEquals(1f, fc.getTransparency());
 305   }
 306
 307   @Test(groups = "Network")
 308   public void testGetGeneIds()
 309   {
 310     /*
 311      * ENSG00000158828 gene id PINK1 human
 312      * ENST00000321556 transcript for the same gene - should not be duplicated
 313      * P30419 Uniprot identifier for ENSG00000136448
 314      * ENST00000592782 transcript for Uniprot gene - should not be duplicated
 315      * BRAF - gene name resolvabe (at time of writing) for 6 model species
 316      */
 317     String ids = "ENSG00000158828 ENST00000321556 P30419 ENST00000592782 BRAF";
 318     EnsemblGene testee = new EnsemblGene();
 319     List<String> geneIds = testee.getGeneIds(ids);
 320     assertEquals(8, geneIds.size());
 321     assertTrue(geneIds.contains("ENSG00000158828"));
 322     assertTrue(geneIds.contains("ENSG00000136448"));
 323     assertTrue(geneIds.contains("ENSG00000157764")); // BRAF human
 324     assertTrue(geneIds.contains("ENSMUSG00000002413")); // mouse
 325     assertTrue(geneIds.contains("ENSRNOG00000010957")); // rat
 326     assertTrue(geneIds.contains("ENSXETG00000004845")); // xenopus
 327     assertTrue(geneIds.contains("ENSDARG00000017661")); // zebrafish
 328     assertTrue(geneIds.contains("ENSGALG00000012865")); // chicken
 329   }
 330 }