test/jalview/analysis/CrossRefTest.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.analysis;
  22
  23 import static org.testng.AssertJUnit.assertEquals;
  24 import static org.testng.AssertJUnit.assertFalse;
  25 import static org.testng.AssertJUnit.assertNotNull;
  26 import static org.testng.AssertJUnit.assertNotSame;
  27 import static org.testng.AssertJUnit.assertNull;
  28 import static org.testng.AssertJUnit.assertSame;
  29 import static org.testng.AssertJUnit.assertTrue;
  30
  31 import jalview.datamodel.AlignedCodonFrame;
  32 import jalview.datamodel.AlignedCodonFrame.SequenceToSequenceMapping;
  33 import jalview.datamodel.Alignment;
  34 import jalview.datamodel.AlignmentI;
  35 import jalview.datamodel.DBRefEntry;
  36 import jalview.datamodel.Mapping;
  37 import jalview.datamodel.Sequence;
  38 import jalview.datamodel.SequenceFeature;
  39 import jalview.datamodel.SequenceI;
  40 import jalview.gui.JvOptionPane;
  41 import jalview.util.DBRefUtils;
  42 import jalview.util.MapList;
  43 import jalview.ws.SequenceFetcher;
  44 import jalview.ws.SequenceFetcherFactory;
  45
  46 import java.util.ArrayList;
  47 import java.util.List;
  48
  49 import org.testng.annotations.AfterClass;
  50 import org.testng.annotations.BeforeClass;
  51 import org.testng.annotations.Test;
  52
  53 public class CrossRefTest
  54 {
  55
  56   @BeforeClass(alwaysRun = true)
  57   public void setUpJvOptionPane()
  58   {
  59     JvOptionPane.setInteractiveMode(false);
  60     JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION);
  61   }
  62
  63   @Test(groups = { "Functional" })
  64   public void testFindXDbRefs()
  65   {
  66     DBRefEntry ref1 = new DBRefEntry("UNIPROT", "1", "A123");
  67     DBRefEntry ref2 = new DBRefEntry("UNIPROTKB/TREMBL", "1", "A123");
  68     DBRefEntry ref3 = new DBRefEntry("pdb", "1", "A123");
  69     DBRefEntry ref4 = new DBRefEntry("EMBLCDSPROTEIN", "1", "A123");
  70     DBRefEntry ref5 = new DBRefEntry("embl", "1", "A123");
  71     DBRefEntry ref6 = new DBRefEntry("emblCDS", "1", "A123");
  72     DBRefEntry ref7 = new DBRefEntry("GeneDB", "1", "A123");
  73     DBRefEntry ref8 = new DBRefEntry("PFAM", "1", "A123");
  74     // ENSEMBL is a source of either dna or protein sequence data
  75     DBRefEntry ref9 = new DBRefEntry("ENSEMBL", "1", "A123");
  76     DBRefEntry[] refs = new DBRefEntry[] { ref1, ref2, ref3, ref4, ref5,
  77         ref6, ref7, ref8, ref9 };
  78
  79     /*
  80      * Just the DNA refs:
  81      */
  82     DBRefEntry[] found = DBRefUtils.selectDbRefs(true, refs);
  83     assertEquals(4, found.length);
  84     assertSame(ref5, found[0]);
  85     assertSame(ref6, found[1]);
  86     assertSame(ref7, found[2]);
  87     assertSame(ref9, found[3]);
  88
  89     /*
  90      * Just the protein refs:
  91      */
  92     found = DBRefUtils.selectDbRefs(false, refs);
  93     assertEquals(4, found.length);
  94     assertSame(ref1, found[0]);
  95     assertSame(ref2, found[1]);
  96     assertSame(ref4, found[2]);
  97     assertSame(ref9, found[3]);
  98   }
  99
 100   /**
 101    * Test the method that finds a sequence's "product" xref source databases,
 102    * which may be direct (dbrefs on the sequence), or indirect (dbrefs on
 103    * sequences which share a dbref with the sequence
 104    */
 105   @Test(groups = { "Functional" }, enabled = true)
 106   public void testFindXrefSourcesForSequence_proteinToDna()
 107   {
 108     SequenceI seq = new Sequence("Seq1", "MGKYQARLSS");
 109     List<String> sources = new ArrayList<>();
 110     AlignmentI al = new Alignment(new SequenceI[] {});
 111
 112     /*
 113      * first with no dbrefs to search
 114      */
 115     sources = new CrossRef(new SequenceI[] { seq }, al)
 116             .findXrefSourcesForSequences(false);
 117     assertTrue(sources.isEmpty());
 118
 119     /*
 120      * add some dbrefs to sequence
 121      */
 122     // protein db is not a candidate for findXrefSources
 123     seq.addDBRef(new DBRefEntry("UNIPROT", "0", "A1234"));
 124     // dna coding databatases are
 125     seq.addDBRef(new DBRefEntry("EMBL", "0", "E2345"));
 126     // a second EMBL xref should not result in a duplicate
 127     seq.addDBRef(new DBRefEntry("EMBL", "0", "E2346"));
 128     seq.addDBRef(new DBRefEntry("EMBLCDS", "0", "E2347"));
 129     seq.addDBRef(new DBRefEntry("GENEDB", "0", "E2348"));
 130     seq.addDBRef(new DBRefEntry("ENSEMBL", "0", "E2349"));
 131     seq.addDBRef(new DBRefEntry("ENSEMBLGENOMES", "0", "E2350"));
 132     sources = new CrossRef(new SequenceI[] { seq }, al)
 133             .findXrefSourcesForSequences(false);
 134     // method is patched to remove EMBL from the sources to match
 135     assertEquals(4, sources.size());
 136     assertEquals("[EMBLCDS, GENEDB, ENSEMBL, ENSEMBLGENOMES]",
 137             sources.toString());
 138
 139     /*
 140      * add a sequence to the alignment which has a dbref to UNIPROT|A1234
 141      * and others to dna coding databases
 142      */
 143     sources.clear();
 144     seq.setDBRefs(null);
 145     seq.addDBRef(new DBRefEntry("UNIPROT", "0", "A1234"));
 146     seq.addDBRef(new DBRefEntry("EMBLCDS", "0", "E2347"));
 147     SequenceI seq2 = new Sequence("Seq2", "MGKYQARLSS");
 148     seq2.addDBRef(new DBRefEntry("UNIPROT", "0", "A1234"));
 149     seq2.addDBRef(new DBRefEntry("EMBL", "0", "E2345"));
 150     seq2.addDBRef(new DBRefEntry("GENEDB", "0", "E2348"));
 151     // TODO include ENSEMBLGENOMES in DBRefSource.DNACODINGDBS ?
 152     al.addSequence(seq2);
 153     sources = new CrossRef(new SequenceI[] { seq, seq2 }, al)
 154             .findXrefSourcesForSequences(false);
 155     // method removed EMBL from sources to match
 156     assertEquals(2, sources.size());
 157     assertEquals("[EMBLCDS, GENEDB]", sources.toString());
 158   }
 159
 160   /**
 161    * Test for finding 'product' sequences for the case where only an indirect
 162    * xref is found - not on the nucleotide sequence but on a peptide sequence in
 163    * the alignment which which it shares a nucleotide dbref
 164    */
 165   @Test(groups = { "Functional" }, enabled = true)
 166   public void testFindXrefSequences_indirectDbrefToProtein()
 167   {
 168     /*
 169      * Alignment setup:
 170      *   - nucleotide dbref  EMBL|AF039662
 171      *   - peptide    dbrefs EMBL|AF039662, UNIPROT|Q9ZTS2
 172      */
 173     SequenceI emblSeq = new Sequence("AF039662", "GGGGCAGCACAAGAAC");
 174     emblSeq.addDBRef(new DBRefEntry("EMBL", "0", "AF039662"));
 175     SequenceI uniprotSeq = new Sequence("Q9ZTS2", "MASVSATMISTS");
 176     uniprotSeq.addDBRef(new DBRefEntry("EMBL", "0", "AF039662"));
 177     uniprotSeq.addDBRef(new DBRefEntry("UNIPROT", "0", "Q9ZTS2"));
 178
 179     /*
 180      * Find UNIPROT xrefs for nucleotide
 181      * - it has no UNIPROT dbref of its own
 182      * - but peptide with matching nucleotide dbref does, so is returned
 183      */
 184     AlignmentI al = new Alignment(new SequenceI[] { emblSeq, uniprotSeq });
 185     Alignment xrefs = new CrossRef(new SequenceI[] { emblSeq }, al)
 186             .findXrefSequences("UNIPROT", true);
 187     assertEquals(1, xrefs.getHeight());
 188     assertSame(uniprotSeq, xrefs.getSequenceAt(0));
 189   }
 190
 191   /**
 192    * Test for finding 'product' sequences for the case where only an indirect
 193    * xref is found - not on the peptide sequence but on a nucleotide sequence in
 194    * the alignment which which it shares a protein dbref
 195    */
 196   @Test(groups = { "Functional" }, enabled = true)
 197   public void testFindXrefSequences_indirectDbrefToNucleotide()
 198   {
 199     /*
 200      * Alignment setup:
 201      *   - peptide    dbref  UNIPROT|Q9ZTS2
 202      *   - nucleotide dbref  EMBL|AF039662, UNIPROT|Q9ZTS2
 203      */
 204     SequenceI uniprotSeq = new Sequence("Q9ZTS2", "MASVSATMISTS");
 205     uniprotSeq.addDBRef(new DBRefEntry("UNIPROT", "0", "Q9ZTS2"));
 206     SequenceI emblSeq = new Sequence("AF039662", "GGGGCAGCACAAGAAC");
 207     emblSeq.addDBRef(new DBRefEntry("EMBL", "0", "AF039662"));
 208     emblSeq.addDBRef(new DBRefEntry("UNIPROT", "0", "Q9ZTS2"));
 209
 210     /*
 211      * find EMBL xrefs for peptide sequence - it has no direct
 212      * dbrefs, but the 'corresponding' nucleotide sequence does, so is returned
 213      */
 214     /*
 215      * Find EMBL xrefs for peptide
 216      * - it has no EMBL dbref of its own
 217      * - but nucleotide with matching peptide dbref does, so is returned
 218      */
 219     AlignmentI al = new Alignment(new SequenceI[] { emblSeq, uniprotSeq });
 220     Alignment xrefs = new CrossRef(new SequenceI[] { uniprotSeq }, al)
 221             .findXrefSequences("EMBL", false);
 222     assertEquals(1, xrefs.getHeight());
 223     assertSame(emblSeq, xrefs.getSequenceAt(0));
 224   }
 225
 226   /**
 227    * Test for finding 'product' sequences for the case where the selected
 228    * sequence has no dbref to the desired source, and there are no indirect
 229    * references via another sequence in the alignment
 230    */
 231   @Test(groups = { "Functional" })
 232   public void testFindXrefSequences_noDbrefs()
 233   {
 234     /*
 235      * two nucleotide sequences, one with UNIPROT dbref
 236      */
 237     SequenceI dna1 = new Sequence("AF039662", "GGGGCAGCACAAGAAC");
 238     dna1.addDBRef(new DBRefEntry("UNIPROT", "0", "Q9ZTS2"));
 239     SequenceI dna2 = new Sequence("AJ307031", "AAACCCTTT");
 240
 241     /*
 242      * find UNIPROT xrefs for peptide sequence - it has no direct
 243      * dbrefs, and the other sequence (which has a UNIPROT dbref) is not
 244      * equatable to it, so no results found
 245      */
 246     AlignmentI al = new Alignment(new SequenceI[] { dna1, dna2 });
 247     Alignment xrefs = new CrossRef(new SequenceI[] { dna2 }, al)
 248             .findXrefSequences("UNIPROT", true);
 249     assertNull(xrefs);
 250   }
 251
 252   /**
 253    * Tests for the method that searches an alignment (with one sequence
 254    * excluded) for protein/nucleotide sequences with a given cross-reference
 255    */
 256   @Test(groups = { "Functional" }, enabled = true)
 257   public void testSearchDataset()
 258   {
 259     /*
 260      * nucleotide sequence with UNIPROT AND EMBL dbref
 261      * peptide sequence with UNIPROT dbref
 262      */
 263     SequenceI dna1 = new Sequence("AF039662", "GGGGCAGCACAAGAAC");
 264     Mapping map = new Mapping(new Sequence("pep2", "MLAVSRG"), new MapList(
 265             new int[] { 1, 21 }, new int[] { 1, 7 }, 3, 1));
 266     DBRefEntry dbref = new DBRefEntry("UNIPROT", "0", "Q9ZTS2", map);
 267     dna1.addDBRef(dbref);
 268     dna1.addDBRef(new DBRefEntry("EMBL", "0", "AF039662"));
 269     SequenceI pep1 = new Sequence("Q9ZTS2", "MLAVSRGQ");
 270     dbref = new DBRefEntry("UNIPROT", "0", "Q9ZTS2");
 271     pep1.addDBRef(new DBRefEntry("UNIPROT", "0", "Q9ZTS2"));
 272     AlignmentI al = new Alignment(new SequenceI[] { dna1, pep1 });
 273
 274     List<SequenceI> result = new ArrayList<>();
 275
 276     /*
 277      * first search for a dbref nowhere on the alignment:
 278      */
 279     dbref = new DBRefEntry("UNIPROT", "0", "P30419");
 280     CrossRef testee = new CrossRef(al.getSequencesArray(), al);
 281     AlignedCodonFrame acf = new AlignedCodonFrame();
 282     boolean found = testee.searchDataset(true, dna1, dbref, result, acf,
 283             true);
 284     assertFalse(found);
 285     assertTrue(result.isEmpty());
 286     assertTrue(acf.isEmpty());
 287
 288     /*
 289      * search for a protein sequence with dbref UNIPROT:Q9ZTS2
 290      */
 291     acf = new AlignedCodonFrame();
 292     dbref = new DBRefEntry("UNIPROT", "0", "Q9ZTS2");
 293     found = testee.searchDataset(!dna1.isProtein(), dna1, dbref, result,
 294             acf, false); // search dataset with a protein xref from a dna
 295                          // sequence to locate the protein product
 296     assertTrue(found);
 297     assertEquals(1, result.size());
 298     assertSame(pep1, result.get(0));
 299     assertTrue(acf.isEmpty());
 300
 301     /*
 302      * search for a nucleotide sequence with dbref UNIPROT:Q9ZTS2
 303      */
 304     result.clear();
 305     acf = new AlignedCodonFrame();
 306     dbref = new DBRefEntry("UNIPROT", "0", "Q9ZTS2");
 307     found = testee.searchDataset(!pep1.isProtein(), pep1, dbref, result,
 308             acf, false); // search dataset with a protein's direct dbref to
 309                          // locate dna sequences with matching xref
 310     assertTrue(found);
 311     assertEquals(1, result.size());
 312     assertSame(dna1, result.get(0));
 313     // should now have a mapping from dna to pep1
 314     List<SequenceToSequenceMapping> mappings = acf.getMappings();
 315     assertEquals(1, mappings.size());
 316     SequenceToSequenceMapping mapping = mappings.get(0);
 317     assertSame(dna1, mapping.getFromSeq());
 318     assertSame(pep1, mapping.getMapping().getTo());
 319     MapList mapList = mapping.getMapping().getMap();
 320     assertEquals(1, mapList.getToRatio());
 321     assertEquals(3, mapList.getFromRatio());
 322     assertEquals(1, mapList.getFromRanges().size());
 323     assertEquals(1, mapList.getFromRanges().get(0)[0]);
 324     assertEquals(21, mapList.getFromRanges().get(0)[1]);
 325     assertEquals(1, mapList.getToRanges().size());
 326     assertEquals(1, mapList.getToRanges().get(0)[0]);
 327     assertEquals(7, mapList.getToRanges().get(0)[1]);
 328   }
 329
 330   /**
 331    * Test for finding 'product' sequences for the case where the selected
 332    * sequence has a dbref with a mapping to a sequence. This represents the case
 333    * where either
 334    * <ul>
 335    * <li>a fetched sequence is already decorated with its cross-reference (e.g.
 336    * EMBL + translation), or</li>
 337    * <li>Get Cross-References has been done once resulting in instantiated
 338    * cross-reference mappings</li>
 339    * </ul>
 340    */
 341   @Test(groups = { "Functional" })
 342   public void testFindXrefSequences_fromDbRefMap()
 343   {
 344     /*
 345      * scenario: nucleotide sequence AF039662
 346      *   with dbref + mapping to Q9ZTS2 and P30419
 347      *     which themselves each have a dbref and feature
 348      */
 349     SequenceI dna1 = new Sequence("AF039662", "GGGGCAGCACAAGAAC");
 350     SequenceI pep1 = new Sequence("Q9ZTS2", "MALFQRSV");
 351     SequenceI pep2 = new Sequence("P30419", "MTRRSQIF");
 352     dna1.createDatasetSequence();
 353     pep1.createDatasetSequence();
 354     pep2.createDatasetSequence();
 355
 356     pep1.getDatasetSequence().addDBRef(
 357             new DBRefEntry("Pfam", "0", "PF00111"));
 358     pep1.addSequenceFeature(new SequenceFeature("type", "desc", 12, 14, 1f,
 359             "group"));
 360     pep2.getDatasetSequence().addDBRef(new DBRefEntry("PDB", "0", "3JTK"));
 361     pep2.addSequenceFeature(new SequenceFeature("type2", "desc2", 13, 15,
 362             12f, "group2"));
 363
 364     MapList mapList = new MapList(new int[] { 1, 24 }, new int[] { 1, 3 },
 365             3, 1);
 366     Mapping map = new Mapping(pep1, mapList);
 367     DBRefEntry dbRef1 = new DBRefEntry("UNIPROT", "0", "Q9ZTS2", map);
 368     dna1.getDatasetSequence().addDBRef(dbRef1);
 369     mapList = new MapList(new int[] { 1, 24 }, new int[] { 1, 3 }, 3, 1);
 370     map = new Mapping(pep2, mapList);
 371     DBRefEntry dbRef2 = new DBRefEntry("UNIPROT", "0", "P30419", map);
 372     dna1.getDatasetSequence().addDBRef(dbRef2);
 373
 374     /*
 375      * find UNIPROT xrefs for nucleotide sequence - it should pick up
 376      * mapped sequences
 377      */
 378     AlignmentI al = new Alignment(new SequenceI[] { dna1 });
 379     Alignment xrefs = new CrossRef(new SequenceI[] { dna1 }, al)
 380             .findXrefSequences("UNIPROT", true);
 381     assertEquals(2, xrefs.getHeight());
 382
 383     /*
 384      * cross-refs alignment holds copies of the mapped sequences
 385      * including copies of their dbrefs and features
 386      */
 387     checkCopySequence(pep1, xrefs.getSequenceAt(0));
 388     checkCopySequence(pep2, xrefs.getSequenceAt(1));
 389   }
 390
 391   /**
 392    * Helper method that verifies that 'copy' has the same name, start, end,
 393    * sequence and dataset sequence object as 'original' (but is not the same
 394    * object)
 395    *
 396    * @param copy
 397    * @param original
 398    */
 399   private void checkCopySequence(SequenceI copy, SequenceI original)
 400   {
 401     assertNotSame(copy, original);
 402     assertSame(copy.getDatasetSequence(), original.getDatasetSequence());
 403     assertEquals(copy.getName(), original.getName());
 404     assertEquals(copy.getStart(), original.getStart());
 405     assertEquals(copy.getEnd(), original.getEnd());
 406     assertEquals(copy.getSequenceAsString(), original.getSequenceAsString());
 407   }
 408
 409   /**
 410    * Test for finding 'product' sequences for the case where the selected
 411    * sequence has a dbref with no mapping, triggering a fetch from database
 412    */
 413   @Test(groups = { "Functional" })
 414   public void testFindXrefSequences_withFetch()
 415   {
 416     SequenceI dna1 = new Sequence("AF039662", "GGGGCAGCACAAGAAC");
 417     dna1.addDBRef(new DBRefEntry("UNIPROT", "ENA:0", "Q9ZTS2"));
 418     dna1.addDBRef(new DBRefEntry("UNIPROT", "ENA:0", "P30419"));
 419     dna1.addDBRef(new DBRefEntry("UNIPROT", "ENA:0", "P00314"));
 420     final SequenceI pep1 = new Sequence("Q9ZTS2", "MYQLIRSSW");
 421     pep1.addDBRef(new DBRefEntry("UNIPROT", "0", "Q9ZTS2"));
 422
 423     final SequenceI pep2 = new Sequence("P00314", "MRKLLAASG");
 424     pep2.addDBRef(new DBRefEntry("UNIPROT", "0", "P00314"));
 425
 426     /*
 427      * argument false suppresses adding DAS sources
 428      * todo: define an interface type SequenceFetcherI and mock that
 429      */
 430     SequenceFetcher mockFetcher = new SequenceFetcher(false)
 431     {
 432       @Override
 433       public boolean isFetchable(String source)
 434       {
 435         return true;
 436       }
 437
 438       @Override
 439       public SequenceI[] getSequences(List<DBRefEntry> refs, boolean dna)
 440       {
 441         return new SequenceI[] { pep1, pep2 };
 442       }
 443     };
 444     SequenceFetcherFactory.setSequenceFetcher(mockFetcher);
 445
 446     /*
 447      * find UNIPROT xrefs for nucleotide sequence
 448      */
 449     AlignmentI al = new Alignment(new SequenceI[] { dna1 });
 450     Alignment xrefs = new CrossRef(new SequenceI[] { dna1 }, al)
 451             .findXrefSequences("UNIPROT", true);
 452     assertEquals(2, xrefs.getHeight());
 453     assertSame(pep1, xrefs.getSequenceAt(0));
 454     assertSame(pep2, xrefs.getSequenceAt(1));
 455   }
 456
 457   @AfterClass
 458   public void tearDown()
 459   {
 460     SequenceFetcherFactory.setSequenceFetcher(null);
 461   }
 462
 463   /**
 464    * Test for finding 'product' sequences for the case where both gene and
 465    * transcript sequences have dbrefs to Uniprot.
 466    */
 467   @Test(groups = { "Functional" })
 468   public void testFindXrefSequences_forGeneAndTranscripts()
 469   {
 470     /*
 471      * 'gene' sequence
 472      */
 473     SequenceI gene = new Sequence("ENSG00000157764", "CGCCTCCCTTCCCC");
 474     gene.addDBRef(new DBRefEntry("UNIPROT", "0", "P15056"));
 475     gene.addDBRef(new DBRefEntry("UNIPROT", "0", "H7C5K3"));
 476
 477     /*
 478      * 'transcript' with CDS feature (supports mapping to protein)
 479      */
 480     SequenceI braf001 = new Sequence("ENST00000288602", "taagATGGCGGCGCTGa");
 481     braf001.addDBRef(new DBRefEntry("UNIPROT", "0", "P15056"));
 482     braf001.addSequenceFeature(new SequenceFeature("CDS", "", 5, 16, 0f,
 483             null));
 484
 485     /*
 486      * 'spliced transcript' with CDS ranges
 487      */
 488     SequenceI braf002 = new Sequence("ENST00000497784", "gCAGGCtaTCTGTTCaa");
 489     braf002.addDBRef(new DBRefEntry("UNIPROT", "ENSEMBL|0", "H7C5K3"));
 490     braf002.addSequenceFeature(new SequenceFeature("CDS", "", 2, 6, 0f,
 491             null));
 492     braf002.addSequenceFeature(new SequenceFeature("CDS", "", 9, 15, 0f,
 493             null));
 494
 495     /*
 496      * TODO code is fragile - use of SequenceIdMatcher depends on fetched
 497      * sequences having a name starting Source|Accession
 498      * which happens to be true for Uniprot,PDB,EMBL but not Pfam,Rfam,Ensembl
 499      */
 500     final SequenceI pep1 = new Sequence("UNIPROT|P15056", "MAAL");
 501     pep1.addDBRef(new DBRefEntry("UNIPROT", "0", "P15056"));
 502     final SequenceI pep2 = new Sequence("UNIPROT|H7C5K3", "QALF");
 503     pep2.addDBRef(new DBRefEntry("UNIPROT", "0", "H7C5K3"));
 504     /*
 505      * argument false suppresses adding DAS sources
 506      * todo: define an interface type SequenceFetcherI and mock that
 507      */
 508     SequenceFetcher mockFetcher = new SequenceFetcher(false)
 509     {
 510       @Override
 511       public boolean isFetchable(String source)
 512       {
 513         return true;
 514       }
 515
 516       @Override
 517       public SequenceI[] getSequences(List<DBRefEntry> refs, boolean dna)
 518       {
 519         return new SequenceI[] { pep1, pep2 };
 520       }
 521     };
 522     SequenceFetcherFactory.setSequenceFetcher(mockFetcher);
 523
 524     /*
 525      * find UNIPROT xrefs for gene and transcripts
 526      * verify that
 527      * - the two proteins are retrieved but not duplicated
 528      * - mappings are built from transcript (CDS) to proteins
 529      * - no mappings from gene to proteins
 530      */
 531     SequenceI[] seqs = new SequenceI[] { gene, braf001, braf002 };
 532     AlignmentI al = new Alignment(seqs);
 533     Alignment xrefs = new CrossRef(seqs, al).findXrefSequences("UNIPROT",
 534             true);
 535     assertEquals(2, xrefs.getHeight());
 536     assertSame(pep1, xrefs.getSequenceAt(0));
 537     assertSame(pep2, xrefs.getSequenceAt(1));
 538   }
 539
 540   /**
 541    * <pre>
 542    * Test that emulates this (real but simplified) case:
 543    * Alignment:          DBrefs
 544    *     UNIPROT|P0CE19  EMBL|J03321, EMBL|X06707, EMBL|M19487
 545    *     UNIPROT|P0CE20  EMBL|J03321, EMBL|X06707, EMBL|X07547
 546    * Find cross-references for EMBL. These are mocked here as
 547    *     EMBL|J03321     with mappings to P0CE18, P0CE19, P0CE20
 548    *     EMBL|X06707     with mappings to P0CE17, P0CE19, P0CE20
 549    *     EMBL|M19487     with mappings to P0CE19, Q46432
 550    *     EMBL|X07547     with mappings to P0CE20, B0BCM4
 551    * EMBL sequences are first 'fetched' (mocked here) for P0CE19.
 552    * The 3 EMBL sequences are added to the alignment dataset.
 553    * Their dbrefs to Uniprot products P0CE19 and P0CE20 should be matched in the
 554    * alignment dataset and updated to reference the original Uniprot sequences.
 555    * For the second Uniprot sequence, the J03321 and X06707 xrefs should be
 556    * resolved from the dataset, and only the X07547 dbref fetched.
 557    * So the end state to verify is:
 558    * - 4 cross-ref sequences returned: J03321, X06707,  M19487, X07547
 559    * - P0CE19/20 dbrefs to EMBL sequences now have mappings
 560    * - J03321 dbrefs to P0CE19/20 mapped to original Uniprot sequences
 561    * - X06707 dbrefs to P0CE19/20 mapped to original Uniprot sequences
 562    * </pre>
 563    */
 564   @Test(groups = { "Functional" })
 565   public void testFindXrefSequences_uniprotEmblManyToMany()
 566   {
 567     /*
 568      * Uniprot sequences, both with xrefs to EMBL|J03321
 569      * and EMBL|X07547
 570      */
 571     SequenceI p0ce19 = new Sequence("UNIPROT|P0CE19", "KPFG");
 572     p0ce19.addDBRef(new DBRefEntry("EMBL", "0", "J03321"));
 573     p0ce19.addDBRef(new DBRefEntry("EMBL", "0", "X06707"));
 574     p0ce19.addDBRef(new DBRefEntry("EMBL", "0", "M19487"));
 575     SequenceI p0ce20 = new Sequence("UNIPROT|P0CE20", "PFGK");
 576     p0ce20.addDBRef(new DBRefEntry("EMBL", "0", "J03321"));
 577     p0ce20.addDBRef(new DBRefEntry("EMBL", "0", "X06707"));
 578     p0ce20.addDBRef(new DBRefEntry("EMBL", "0", "X07547"));
 579
 580     /*
 581      * EMBL sequences to be 'fetched', complete with dbrefs and mappings
 582      * to their protein products (CDS location  and translations  are provided
 583      * in  EMBL XML); these should be matched to, and replaced with,
 584      * the corresponding uniprot sequences after fetching
 585      */
 586
 587     /*
 588      * J03321 with mappings to P0CE19 and P0CE20
 589      */
 590     final SequenceI j03321 = new Sequence("EMBL|J03321", "AAACCCTTTGGGAAAA");
 591     DBRefEntry dbref1 = new DBRefEntry("UNIPROT", "0", "P0CE19");
 592     MapList mapList = new MapList(new int[] { 1, 12 }, new int[] { 1, 4 },
 593             3, 1);
 594     Mapping map = new Mapping(new Sequence("UNIPROT|P0CE19", "KPFG"),
 595             mapList);
 596     // add a dbref to the mapped to sequence - should get copied to p0ce19
 597     map.getTo().addDBRef(new DBRefEntry("PIR", "0", "S01875"));
 598     dbref1.setMap(map);
 599     j03321.addDBRef(dbref1);
 600     DBRefEntry dbref2 = new DBRefEntry("UNIPROT", "0", "P0CE20");
 601     mapList = new MapList(new int[] { 4, 15 }, new int[] { 2, 5 }, 3, 1);
 602     dbref2.setMap(new Mapping(new Sequence("UNIPROT|P0CE20", "PFGK"),
 603             new MapList(mapList)));
 604     j03321.addDBRef(dbref2);
 605
 606     /*
 607      * X06707 with mappings to P0CE19 and P0CE20
 608      */
 609     final SequenceI x06707 = new Sequence("EMBL|X06707", "atgAAACCCTTTGGG");
 610     DBRefEntry dbref3 = new DBRefEntry("UNIPROT", "0", "P0CE19");
 611     MapList map2 = new MapList(new int[] { 4, 15 }, new int[] { 1, 4 }, 3,
 612             1);
 613     dbref3.setMap(new Mapping(new Sequence("UNIPROT|P0CE19", "KPFG"), map2));
 614     x06707.addDBRef(dbref3);
 615     DBRefEntry dbref4 = new DBRefEntry("UNIPROT", "0", "P0CE20");
 616     MapList map3 = new MapList(new int[] { 4, 15 }, new int[] { 1, 4 }, 3,
 617             1);
 618     dbref4.setMap(new Mapping(new Sequence("UNIPROT|P0CE20", "PFGK"), map3));
 619     x06707.addDBRef(dbref4);
 620
 621     /*
 622      * M19487 with mapping to P0CE19 and Q46432
 623      */
 624     final SequenceI m19487 = new Sequence("EMBL|M19487", "AAACCCTTTGGG");
 625     DBRefEntry dbref5 = new DBRefEntry("UNIPROT", "0", "P0CE19");
 626     dbref5.setMap(new Mapping(new Sequence("UNIPROT|P0CE19", "KPFG"),
 627             new MapList(mapList)));
 628     m19487.addDBRef(dbref5);
 629     DBRefEntry dbref6 = new DBRefEntry("UNIPROT", "0", "Q46432");
 630     dbref6.setMap(new Mapping(new Sequence("UNIPROT|Q46432", "KPFG"),
 631             new MapList(mapList)));
 632     m19487.addDBRef(dbref6);
 633
 634     /*
 635      * X07547 with mapping to P0CE20 and B0BCM4
 636      */
 637     final SequenceI x07547 = new Sequence("EMBL|X07547", "cccAAACCCTTTGGG");
 638     DBRefEntry dbref7 = new DBRefEntry("UNIPROT", "0", "P0CE20");
 639     dbref7.setMap(new Mapping(new Sequence("UNIPROT|P0CE20", "PFGK"),
 640             new MapList(map2)));
 641     x07547.addDBRef(dbref7);
 642     DBRefEntry dbref8 = new DBRefEntry("UNIPROT", "0", "B0BCM4");
 643     dbref8.setMap(new Mapping(new Sequence("UNIPROT|B0BCM4", "KPFG"),
 644             new MapList(map2)));
 645     x07547.addDBRef(dbref8);
 646
 647     /*
 648      * mock sequence fetcher to 'return' the EMBL sequences
 649      * TODO: Mockito would allow .thenReturn().thenReturn() here,
 650      * and also capture and verification of the parameters
 651      * passed in calls to getSequences() - important to verify that
 652      * duplicate sequence fetches are not requested
 653      */
 654     SequenceFetcher mockFetcher = new SequenceFetcher(false)
 655     {
 656       int call = 0;
 657
 658       @Override
 659       public boolean isFetchable(String source)
 660       {
 661         return true;
 662       }
 663
 664       @Override
 665       public SequenceI[] getSequences(List<DBRefEntry> refs, boolean dna)
 666       {
 667         call++;
 668         if (call == 1)
 669         {
 670           assertEquals("Expected 3 embl seqs in first fetch", 3,
 671                   refs.size());
 672           return new SequenceI[] { j03321, x06707, m19487 };
 673         }
 674         else
 675         {
 676           assertEquals("Expected 1 embl seq in second fetch", 1,
 677                   refs.size());
 678           return new SequenceI[] { x07547 };
 679         }
 680       }
 681     };
 682     SequenceFetcherFactory.setSequenceFetcher(mockFetcher);
 683
 684     /*
 685      * find EMBL xrefs for Uniprot seqs and verify that
 686      * - the EMBL xref'd sequences are retrieved without duplicates
 687      * - mappings are added to the Uniprot dbrefs
 688      * - mappings in the EMBL-to-Uniprot dbrefs are updated to the
 689      *   alignment sequences
 690      * - dbrefs on the EMBL sequences are added to the original dbrefs
 691      */
 692     SequenceI[] seqs = new SequenceI[] { p0ce19, p0ce20 };
 693     AlignmentI al = new Alignment(seqs);
 694     Alignment xrefs = new CrossRef(seqs, al).findXrefSequences("EMBL",
 695             false);
 696
 697     /*
 698      * verify retrieved sequences
 699      */
 700     assertNotNull(xrefs);
 701     assertEquals(4, xrefs.getHeight());
 702     assertSame(j03321, xrefs.getSequenceAt(0));
 703     assertSame(x06707, xrefs.getSequenceAt(1));
 704     assertSame(m19487, xrefs.getSequenceAt(2));
 705     assertSame(x07547, xrefs.getSequenceAt(3));
 706
 707     /*
 708      * verify mappings added to Uniprot-to-EMBL dbrefs
 709      */
 710     Mapping mapping = p0ce19.getDBRefs()[0].getMap();
 711     assertSame(j03321, mapping.getTo());
 712     mapping = p0ce19.getDBRefs()[1].getMap();
 713     assertSame(x06707, mapping.getTo());
 714     mapping = p0ce20.getDBRefs()[0].getMap();
 715     assertSame(j03321, mapping.getTo());
 716     mapping = p0ce20.getDBRefs()[1].getMap();
 717     assertSame(x06707, mapping.getTo());
 718
 719     /*
 720      * verify dbrefs on EMBL are mapped to alignment seqs
 721      */
 722     assertSame(p0ce19, j03321.getDBRefs()[0].getMap().getTo());
 723     assertSame(p0ce20, j03321.getDBRefs()[1].getMap().getTo());
 724     assertSame(p0ce19, x06707.getDBRefs()[0].getMap().getTo());
 725     assertSame(p0ce20, x06707.getDBRefs()[1].getMap().getTo());
 726
 727     /*
 728      * verify new dbref on EMBL dbref mapping is copied to the
 729      * original Uniprot sequence
 730      */
 731     assertEquals(4, p0ce19.getDBRefs().length);
 732     assertEquals("PIR", p0ce19.getDBRefs()[3].getSource());
 733     assertEquals("S01875", p0ce19.getDBRefs()[3].getAccessionId());
 734   }
 735
 736   @Test(groups = "Functional")
 737   public void testSameSequence()
 738   {
 739     assertTrue(CrossRef.sameSequence(null, null));
 740     SequenceI seq1 = new Sequence("seq1", "ABCDEF");
 741     assertFalse(CrossRef.sameSequence(seq1, null));
 742     assertFalse(CrossRef.sameSequence(null, seq1));
 743     assertTrue(CrossRef.sameSequence(seq1, new Sequence("seq2", "ABCDEF")));
 744     assertTrue(CrossRef.sameSequence(seq1, new Sequence("seq2", "abcdef")));
 745     assertFalse(CrossRef
 746             .sameSequence(seq1, new Sequence("seq2", "ABCDE-F")));
 747     assertFalse(CrossRef.sameSequence(seq1, new Sequence("seq2", "BCDEF")));
 748   }
 749 }