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