test/jalview/ext/ensembl/EnsemblSeqProxyTest.java

   1 package jalview.ext.ensembl;
   2
   3 import static org.testng.AssertJUnit.assertEquals;
   4
   5 import jalview.datamodel.Alignment;
   6 import jalview.datamodel.AlignmentI;
   7 import jalview.datamodel.Sequence;
   8 import jalview.datamodel.SequenceFeature;
   9 import jalview.datamodel.SequenceI;
  10 import jalview.io.AppletFormatAdapter;
  11 import jalview.io.FastaFile;
  12 import jalview.io.FileParse;
  13 import jalview.io.gff.SequenceOntologyFactory;
  14 import jalview.io.gff.SequenceOntologyLite;
  15
  16 import java.lang.reflect.Method;
  17 import java.net.MalformedURLException;
  18 import java.net.URL;
  19 import java.util.ArrayList;
  20 import java.util.Arrays;
  21 import java.util.List;
  22
  23 import org.testng.Assert;
  24 import org.testng.annotations.AfterClass;
  25 import org.testng.annotations.BeforeClass;
  26 import org.testng.annotations.DataProvider;
  27 import org.testng.annotations.Test;
  28
  29
  30 public class EnsemblSeqProxyTest
  31 {
  32   private static final Object[][] allSeqs = new Object[][] {
  33       {
  34           new EnsemblProtein(),
  35           "CCDS5863.1",
  36           ">CCDS5863.1\n"
  37                   + "MAALSGGGGGGAEPGQALFNGDMEPEAGAGAGAAASSAADPAIPEEVWNIKQMIKLTQEH\n"
  38                   + "IEALLDKFGGEHNPPSIYLEAYEEYTSKLDALQQREQQLLESLGNGTDFSVSSSASMDTV\n"
  39                   + "TSSSSSSLSVLPSSLSVFQNPTDVARSNPKSPQKPIVRVFLPNKQRTVVPARCGVTVRDS\n"
  40                   + "LKKALMMRGLIPECCAVYRIQDGEKKPIGWDTDISWLTGEELHVEVLENVPLTTHNFVRK\n"
  41                   + "TFFTLAFCDFCRKLLFQGFRCQTCGYKFHQRCSTEVPLMCVNYDQLDLLFVSKFFEHHPI\n"
  42                   + "PQEEASLAETALTSGSSPSAPASDSIGPQILTSPSPSKSIPIPQPFRPADEDHRNQFGQR\n"
  43                   + "DRSSSAPNVHINTIEPVNIDDLIRDQGFRGDGGSTTGLSATPPASLPGSLTNVKALQKSP\n"
  44                   + "GPQRERKSSSSSEDRNRMKTLGRRDSSDDWEIPDGQITVGQRIGSGSFGTVYKGKWHGDV\n"
  45                   + "AVKMLNVTAPTPQQLQAFKNEVGVLRKTRHVNILLFMGYSTKPQLAIVTQWCEGSSLYHH\n"
  46                   + "LHIIETKFEMIKLIDIARQTAQGMDYLHAKSIIHRDLKSNNIFLHEDLTVKIGDFGLATV\n"
  47                   + "KSRWSGSHQFEQLSGSILWMAPEVIRMQDKNPYSFQSDVYAFGIVLYELMTGQLPYSNIN\n"
  48                   + "NRDQIIFMVGRGYLSPDLSKVRSNCPKAMKRLMAECLKKKRDERPLFPQILASIELLARS\n"
  49                   + "LPKIHRSASEPSLNRAGFQTEDFSLYACASPKTPIQAGGYGAFPVH\n" },
  50       {
  51           new EnsemblCdna(),
  52           "CCDS5863.1",
  53           ">CCDS5863.1\n"
  54                   + "ATGGCGGCGCTGAGCGGTGGCGGTGGTGGCGGCGCGGAGCCGGGCCAGGCTCTGTTCAAC\n"
  55                   + "GGGGACATGGAGCCCGAGGCCGGCGCCGGCGCCGGCGCCGCGGCCTCTTCGGCTGCGGAC\n"
  56                   + "CCTGCCATTCCGGAGGAGGTGTGGAATATCAAACAAATGATTAAGTTGACACAGGAACAT\n"
  57                   + "ATAGAGGCCCTATTGGACAAATTTGGTGGGGAGCATAATCCACCATCAATATATCTGGAG\n"
  58                   + "GCCTATGAAGAATACACCAGCAAGCTAGATGCACTCCAACAAAGAGAACAACAGTTATTG\n"
  59                   + "GAATCTCTGGGGAACGGAACTGATTTTTCTGTTTCTAGCTCTGCATCAATGGATACCGTT\n"
  60                   + "ACATCTTCTTCCTCTTCTAGCCTTTCAGTGCTACCTTCATCTCTTTCAGTTTTTCAAAAT\n"
  61                   + "CCCACAGATGTGGCACGGAGCAACCCCAAGTCACCACAAAAACCTATCGTTAGAGTCTTC\n"
  62                   + "CTGCCCAACAAACAGAGGACAGTGGTACCTGCAAGGTGTGGAGTTACAGTCCGAGACAGT\n"
  63                   + "CTAAAGAAAGCACTGATGATGAGAGGTCTAATCCCAGAGTGCTGTGCTGTTTACAGAATT\n"
  64                   + "CAGGATGGAGAGAAGAAACCAATTGGTTGGGACACTGATATTTCCTGGCTTACTGGAGAA\n"
  65                   + "GAATTGCATGTGGAAGTGTTGGAGAATGTTCCACTTACAACACACAACTTTGTACGAAAA\n"
  66                   + "ACGTTTTTCACCTTAGCATTTTGTGACTTTTGTCGAAAGCTGCTTTTCCAGGGTTTCCGC\n"
  67                   + "TGTCAAACATGTGGTTATAAATTTCACCAGCGTTGTAGTACAGAAGTTCCACTGATGTGT\n"
  68                   + "GTTAATTATGACCAACTTGATTTGCTGTTTGTCTCCAAGTTCTTTGAACACCACCCAATA\n"
  69                   + "CCACAGGAAGAGGCGTCCTTAGCAGAGACTGCCCTAACATCTGGATCATCCCCTTCCGCA\n"
  70                   + "CCCGCCTCGGACTCTATTGGGCCCCAAATTCTCACCAGTCCGTCTCCTTCAAAATCCATT\n"
  71                   + "CCAATTCCACAGCCCTTCCGACCAGCAGATGAAGATCATCGAAATCAATTTGGGCAACGA\n"
  72                   + "GACCGATCCTCATCAGCTCCCAATGTGCATATAAACACAATAGAACCTGTCAATATTGAT\n"
  73                   + "GACTTGATTAGAGACCAAGGATTTCGTGGTGATGGAGGATCAACCACAGGTTTGTCTGCT\n"
  74                   + "ACCCCCCCTGCCTCATTACCTGGCTCACTAACTAACGTGAAAGCCTTACAGAAATCTCCA\n"
  75                   + "GGACCTCAGCGAGAAAGGAAGTCATCTTCATCCTCAGAAGACAGGAATCGAATGAAAACA\n"
  76                   + "CTTGGTAGACGGGACTCGAGTGATGATTGGGAGATTCCTGATGGGCAGATTACAGTGGGA\n"
  77                   + "CAAAGAATTGGATCTGGATCATTTGGAACAGTCTACAAGGGAAAGTGGCATGGTGATGTG\n"
  78                   + "GCAGTGAAAATGTTGAATGTGACAGCACCTACACCTCAGCAGTTACAAGCCTTCAAAAAT\n"
  79                   + "GAAGTAGGAGTACTCAGGAAAACACGACATGTGAATATCCTACTCTTCATGGGCTATTCC\n"
  80                   + "ACAAAGCCACAACTGGCTATTGTTACCCAGTGGTGTGAGGGCTCCAGCTTGTATCACCAT\n"
  81                   + "CTCCATATCATTGAGACCAAATTTGAGATGATCAAACTTATAGATATTGCACGACAGACT\n"
  82                   + "GCACAGGGCATGGATTACTTACACGCCAAGTCAATCATCCACAGAGACCTCAAGAGTAAT\n"
  83                   + "AATATATTTCTTCATGAAGACCTCACAGTAAAAATAGGTGATTTTGGTCTAGCTACAGTG\n"
  84                   + "AAATCTCGATGGAGTGGGTCCCATCAGTTTGAACAGTTGTCTGGATCCATTTTGTGGATG\n"
  85                   + "GCACCAGAAGTCATCAGAATGCAAGATAAAAATCCATACAGCTTTCAGTCAGATGTATAT\n"
  86                   + "GCATTTGGAATTGTTCTGTATGAATTGATGACTGGACAGTTACCTTATTCAAACATCAAC\n"
  87                   + "AACAGGGACCAGATAATTTTTATGGTGGGACGAGGATACCTGTCTCCAGATCTCAGTAAG\n"
  88                   + "GTACGGAGTAACTGTCCAAAAGCCATGAAGAGATTAATGGCAGAGTGCCTCAAAAAGAAA\n"
  89                   + "AGAGATGAGAGACCACTCTTTCCCCAAATTCTCGCCTCTATTGAGCTGCTGGCCCGCTCA\n"
  90                   + "TTGCCAAAAATTCACCGCAGTGCATCAGAACCCTCCTTGAATCGGGCTGGTTTCCAAACA\n"
  91                   + "GAGGATTTTAGTCTATATGCTTGTGCTTCTCCAAAAACACCCATCCAGGCAGGGGGATAT\n"
  92                   + "GGTGCGTTTCCTGTCCACTGA\n" },
  93       {
  94           new EnsemblProtein(),
  95           "ENSP00000288602",
  96           ">ENSP00000288602\n"
  97                   + "MAALSGGGGGGAEPGQALFNGDMEPEAGAGAGAAASSAADPAIPEEVWNIKQMIKLTQEH\n"
  98                   + "IEALLDKFGGEHNPPSIYLEAYEEYTSKLDALQQREQQLLESLGNGTDFSVSSSASMDTV\n"
  99                   + "TSSSSSSLSVLPSSLSVFQNPTDVARSNPKSPQKPIVRVFLPNKQRTVVPARCGVTVRDS\n"
 100                   + "LKKALMMRGLIPECCAVYRIQDGEKKPIGWDTDISWLTGEELHVEVLENVPLTTHNFVRK\n"
 101                   + "TFFTLAFCDFCRKLLFQGFRCQTCGYKFHQRCSTEVPLMCVNYDQLDLLFVSKFFEHHPI\n"
 102                   + "PQEEASLAETALTSGSSPSAPASDSIGPQILTSPSPSKSIPIPQPFRPADEDHRNQFGQR\n"
 103                   + "DRSSSAPNVHINTIEPVNIDDLIRDQGFRGDGGSTTGLSATPPASLPGSLTNVKALQKSP\n"
 104                   + "GPQRERKSSSSSEDRNRMKTLGRRDSSDDWEIPDGQITVGQRIGSGSFGTVYKGKWHGDV\n"
 105                   + "AVKMLNVTAPTPQQLQAFKNEVGVLRKTRHVNILLFMGYSTKPQLAIVTQWCEGSSLYHH\n"
 106                   + "LHIIETKFEMIKLIDIARQTAQGMDYLHAKSIIHRDLKSNNIFLHEDLTVKIGDFGLATV\n"
 107                   + "KSRWSGSHQFEQLSGSILWMAPEVIRMQDKNPYSFQSDVYAFGIVLYELMTGQLPYSNIN\n"
 108                   + "NRDQIIFMVGRGYLSPDLSKVRSNCPKAMKRLMAECLKKKRDERPLFPQILASIELLARS\n"
 109                   + "LPKIHRSASEPSLNRAGFQTEDFSLYACASPKTPIQAGGYGAFPVH" } };
 110
 111   @BeforeClass
 112   public void setUp()
 113   {
 114     SequenceOntologyFactory.setInstance(new SequenceOntologyLite());
 115   }
 116
 117   @AfterClass
 118   public void tearDown()
 119   {
 120     SequenceOntologyFactory.setInstance(null);
 121   }
 122
 123   @DataProvider(name = "queries")
 124   public Object[][] createQueryData(Method m)
 125   {
 126     return new Object[][] { { "CCDS5863.1" }, { "ENSP00000288602" } };
 127   }
 128
 129   @Test(dataProvider = "queries")
 130   public void testIsValidReference(String query) throws Exception
 131   {
 132     EnsemblSequenceFetcher esq = new EnsemblProtein();
 133     Assert.assertTrue(esq.isValidReference(query),
 134             "Expected reference string " + query
 135                     + " to be valid for regex "
 136                     + esq.getAccessionValidator().toString());
 137   }
 138
 139   @DataProvider(name = "ens_seqs")
 140   public Object[][] createData(Method m)
 141   {
 142     System.out.println(m.getName());
 143     return allSeqs;
 144   }
 145
 146   @Test(dataProvider = "ens_seqs", suiteName = "live")
 147   public void testGetOneSeqs(EnsemblRestClient proxy, String sq, String fastasq)
 148           throws Exception
 149   {
 150     FileParse fp = proxy.getSequenceReader(Arrays
 151             .asList(new String[]
 152     { sq }));
 153     SequenceI[] sqs = new FastaFile(fp).getSeqsAsArray();
 154     FastaFile trueRes = new FastaFile(fastasq, AppletFormatAdapter.PASTE);
 155     SequenceI[] trueSqs = trueRes.getSeqsAsArray();
 156     Assert.assertEquals(sqs.length, trueSqs.length,
 157             "Different number of sequences retrieved for query " + sq);
 158     Alignment ral = new Alignment(sqs);
 159     for (SequenceI tr : trueSqs)
 160     {
 161       SequenceI[] rseq;
 162       Assert.assertNotNull(
 163               rseq = ral.findSequenceMatch(tr.getName()),
 164               "Couldn't find sequences matching expected sequence "
 165                       + tr.getName());
 166       Assert.assertEquals(rseq.length, 1,
 167               "Expected only one sequence for sequence ID " + tr.getName());
 168       Assert.assertEquals(
 169               rseq[0].getSequenceAsString(),
 170               tr.getSequenceAsString(),
 171               "Sequences differ for " + tr.getName() + "\n" + "Exp:"
 172                       + tr.getSequenceAsString() + "\n" + "Got:"
 173                       + rseq[0].getSequenceAsString());
 174
 175     }
 176   }
 177
 178   @Test(suiteName = "live")
 179   public void testLiveCheckEnsembl()
 180   {
 181     EnsemblRestClient sf = new EnsemblRestClient()
 182     {
 183
 184       @Override
 185       public String getDbName()
 186       {
 187         // TODO Auto-generated method stub
 188         return null;
 189       }
 190
 191       @Override
 192       public AlignmentI getSequenceRecords(String queries) throws Exception
 193       {
 194         // TODO Auto-generated method stub
 195         return null;
 196       }
 197
 198       @Override
 199       protected URL getUrl(List<String> ids) throws MalformedURLException
 200       {
 201         // TODO Auto-generated method stub
 202         return null;
 203       }
 204
 205       @Override
 206       protected boolean useGetRequest()
 207       {
 208         // TODO Auto-generated method stub
 209         return false;
 210       }
 211
 212       @Override
 213       protected String getRequestMimeType(boolean b)
 214       {
 215         // TODO Auto-generated method stub
 216         return null;
 217       }
 218
 219       @Override
 220       protected String getResponseMimeType()
 221       {
 222         // TODO Auto-generated method stub
 223         return null;
 224       }
 225
 226     };
 227     boolean isAvailable = sf.isEnsemblAvailable();
 228     System.out.println("Ensembl is "
 229             + (isAvailable ? "UP!"
 230                     : "DOWN or unreachable ******************* BAD!"));
 231   }
 232
 233   /**
 234    * Tests for the method that computes all peptide variants given codon
 235    * variants
 236    */
 237   @Test(groups = "Functional")
 238   public void testComputePeptideVariants()
 239   {
 240     String[][] codonVariants = new String[][] { { "A" }, { "G" }, { "T" } };
 241
 242     /*
 243      * AGT codes for S - this is not included in the variants returned
 244      */
 245     List<String> variants = EnsemblSeqProxy.computePeptideVariants(codonVariants, "S");
 246     assertEquals("[]", variants.toString());
 247
 248     // S is reported if it differs from the current value (A):
 249     variants = EnsemblSeqProxy.computePeptideVariants(codonVariants, "A");
 250     assertEquals("[S]", variants.toString());
 251
 252     /*
 253      * synonymous variant is not reported
 254      */
 255     codonVariants = new String[][] { { "A" }, { "G" }, { "C", "T" } };
 256     // AGC and AGT both code for S
 257     variants = EnsemblSeqProxy.computePeptideVariants(codonVariants, "s");
 258     assertEquals("[]", variants.toString());
 259
 260     /*
 261      * equivalent variants are only reported once
 262      */
 263     codonVariants = new String[][] { { "C" }, { "T" },
 264         { "A", "C", "G", "T" } };
 265     // CTA CTC CTG CTT all code for L
 266     variants = EnsemblSeqProxy.computePeptideVariants(codonVariants, "S");
 267     assertEquals("[L]", variants.toString());
 268
 269     /*
 270      * vary codons 1 and 2; variant products are sorted and non-redundant
 271      */
 272     codonVariants = new String[][] { { "a", "C" }, { "g", "T" }, { "A" } };
 273     // aga ata cga cta code for R, I, R, L
 274     variants = EnsemblSeqProxy.computePeptideVariants(codonVariants, "S");
 275     assertEquals("[I, L, R]", variants.toString());
 276
 277     /*
 278      * vary codons 2 and 3
 279      */
 280     codonVariants = new String[][] { { "a" }, { "g", "T" }, { "A", "c" } };
 281     // aga agc ata atc code for R, S, I, I
 282     variants = EnsemblSeqProxy.computePeptideVariants(codonVariants, "S");
 283     assertEquals("[I, R]", variants.toString());
 284
 285     /*
 286      * vary codons 1 and 3
 287      */
 288     codonVariants = new String[][] { { "a", "t" }, { "a" }, { "t", "g" } };
 289     // aat aag tat tag code for N, K, Y, STOP - STOP sorted to end
 290     variants = EnsemblSeqProxy.computePeptideVariants(codonVariants, "S");
 291     assertEquals("[K, N, Y, STOP]", variants.toString());
 292
 293     /*
 294      * vary codons 1, 2 and 3
 295      */
 296     codonVariants = new String[][] { { "a", "t" }, { "G", "C" },
 297         { "t", "g" } };
 298     // agt agg act acg tgt tgg tct tcg code for S, R, T, T, C, W, S, S
 299     variants = EnsemblSeqProxy.computePeptideVariants(codonVariants, "S");
 300     assertEquals("[C, R, T, W]", variants.toString());
 301   }
 302
 303   /**
 304    * Tests for the method that maps the subset of a dna sequence that has CDS
 305    * (or subtype) feature.
 306    */
 307   @Test(groups = "Functional")
 308   public void testGetCdsRanges()
 309   {
 310     EnsemblSeqProxy testee = new EnsemblSeqProxyAdapter();
 311
 312     SequenceI dnaSeq = new Sequence("dna", "aaaGGGcccAAATTTttt");
 313     dnaSeq.createDatasetSequence();
 314     SequenceI ds = dnaSeq.getDatasetSequence();
 315
 316     // CDS for dna 3-6
 317     SequenceFeature sf = new SequenceFeature("CDS", "", 4, 6, 0f, null);
 318     ds.addSequenceFeature(sf);
 319     // exon feature should be ignored here
 320     sf = new SequenceFeature("exon", "", 7, 9, 0f, null);
 321     ds.addSequenceFeature(sf);
 322     // CDS for dna 10-12
 323     sf = new SequenceFeature("CDS_predicted", "", 10, 12, 0f, null);
 324     ds.addSequenceFeature(sf);
 325
 326     List<int[]> ranges = new ArrayList<int[]>();
 327     int mappedLength = testee.getCdsRanges(dnaSeq, ranges);
 328     assertEquals(6, mappedLength);
 329     assertEquals(2, ranges.size());
 330     assertEquals(4, ranges.get(0)[0]);
 331     assertEquals(6, ranges.get(0)[1]);
 332     assertEquals(10, ranges.get(1)[0]);
 333     assertEquals(12, ranges.get(1)[1]);
 334
 335   }
 336
 337   @Test(groups = "Functional")
 338   public void getGenomicRangesFromFeatures()
 339   {
 340
 341   }
 342
 343   /**
 344    * Tests for the method that maps the subset of a dna sequence that has CDS
 345    * (or subtype) feature - case where the start codon is incomplete.
 346    */
 347   @Test(groups = "Functional")
 348   public void testGetCdsRanges_fivePrimeIncomplete()
 349   {
 350     EnsemblSeqProxy testee = new EnsemblSeqProxyAdapter();
 351
 352     SequenceI dnaSeq = new Sequence("dna", "aaagGGCCCaaaTTTttt");
 353     dnaSeq.createDatasetSequence();
 354     SequenceI ds = dnaSeq.getDatasetSequence();
 355
 356     // CDS for dna 5-6 (incomplete codon), 7-9
 357     SequenceFeature sf = new SequenceFeature("CDS", "", 5, 9, 0f, null);
 358     sf.setPhase("2"); // skip 2 bases to start of next codon
 359     ds.addSequenceFeature(sf);
 360     ds.addSequenceFeature(sf);
 361     // CDS for dna 13-15
 362     sf = new SequenceFeature("CDS_predicted", "", 13, 15, 0f, null);
 363     ds.addSequenceFeature(sf);
 364
 365     List<int[]> ranges = new ArrayList<int[]>();
 366     int mappedLength = testee.getCdsRanges(dnaSeq, ranges);
 367
 368     /*
 369      * check the mapping starts with the first complete codon
 370      */
 371     assertEquals(6, mappedLength);
 372     assertEquals(2, ranges.size());
 373     assertEquals(7, ranges.get(0)[0]);
 374     assertEquals(9, ranges.get(0)[1]);
 375     assertEquals(13, ranges.get(1)[0]);
 376     assertEquals(15, ranges.get(1)[1]);
 377   }
 378 }