test/jalview/ws/SequenceFetcherTest.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.ws;
  22
  23 import jalview.analysis.CrossRef;
  24 import jalview.datamodel.Alignment;
  25 import jalview.datamodel.AlignmentI;
  26 import jalview.datamodel.DBRefSource;
  27 import jalview.datamodel.SequenceI;
  28 import jalview.gui.JvOptionPane;
  29 import jalview.ws.seqfetcher.ASequenceFetcher;
  30 import jalview.ws.seqfetcher.DbSourceProxy;
  31
  32 import java.util.Enumeration;
  33 import java.util.HashMap;
  34 import java.util.List;
  35 import java.util.Map;
  36 import java.util.Vector;
  37
  38 import org.testng.Assert;
  39 import org.testng.annotations.BeforeClass;
  40 import org.testng.annotations.Test;
  41
  42 public class SequenceFetcherTest
  43 {
  44
  45   @BeforeClass(alwaysRun = true)
  46   public void setUpJvOptionPane()
  47   {
  48     JvOptionPane.setInteractiveMode(false);
  49     JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION);
  50   }
  51
  52   @Test(groups = "Functional")
  53   public void testNoDuplicatesInFetchDbRefs()
  54   {
  55     Map<String, List<DbSourceProxy>> seen = new HashMap<>();
  56     jalview.ws.SequenceFetcher sfetcher = new jalview.ws.SequenceFetcher();
  57     String dupes = "";
  58     // for (String src : sfetcher.getOrderedSupportedSources())
  59     for (String src : sfetcher.getNonAlignmentSources())
  60     {
  61       List<DbSourceProxy> seenitem = seen.get(src);
  62       if (seenitem != null)
  63       {
  64         dupes += (dupes.length() > 0 ? "," : "") + src;
  65       }
  66       else
  67       {
  68         seen.put(src, sfetcher.getSourceProxy(src));
  69       }
  70     }
  71     if (dupes.length() > 0)
  72     {
  73       Assert.fail("Duplicate sources : " + dupes);
  74     }
  75   }
  76
  77   /**
  78    * simple run method to test dbsources.
  79    *
  80    * @param argv
  81    * @j2sIgnore
  82    */
  83   public static void main(String[] argv)
  84   {
  85     // TODO: extracted from SequenceFetcher - convert to network dependent
  86     // functional integration test with
  87     // assertions
  88
  89     String usage = "SequenceFetcher.main [-nodas] [<DBNAME> [<ACCNO>]]\n"
  90             + "With no arguments, all DbSources will be queried with their test Accession number.\n"
  91             + "With one argument, the argument will be resolved to one or more db sources and each will be queried with their test accession only.\n"
  92             + "If given two arguments, SequenceFetcher will try to find the DbFetcher corresponding to <DBNAME> and retrieve <ACCNO> from it.";
  93
  94     if (argv != null && argv.length > 0)
  95     {
  96       String targs[] = new String[argv.length - 1];
  97       System.arraycopy(argv, 1, targs, 0, targs.length);
  98       argv = targs;
  99     }
 100     if (argv != null && argv.length > 0)
 101     {
 102       List<DbSourceProxy> sps = new SequenceFetcher()
 103               .getSourceProxy(argv[0]);
 104
 105       if (sps != null)
 106       {
 107         for (DbSourceProxy sp : sps)
 108         {
 109           AlignmentI al = null;
 110           try
 111           {
 112             testRetrieval(argv[0], sp,
 113                     argv.length > 1 ? argv[1] : sp.getTestQuery());
 114           } catch (Exception e)
 115           {
 116             e.printStackTrace();
 117             System.err.println("Error when retrieving "
 118                     + (argv.length > 1 ? argv[1] : sp.getTestQuery())
 119                     + " from " + argv[0] + "\nUsage: " + usage);
 120           }
 121         }
 122         return;
 123       }
 124       else
 125       {
 126         System.err.println("Can't resolve " + argv[0]
 127                 + " as a database name. Allowed values are :\n"
 128                 + new SequenceFetcher().getSupportedDb());
 129       }
 130       System.out.println(usage);
 131       return;
 132     }
 133     ASequenceFetcher sfetcher = new SequenceFetcher();
 134     String[] dbSources = sfetcher.getSupportedDb();
 135     for (int dbsource = 0; dbsource < dbSources.length; dbsource++)
 136     {
 137       String db = dbSources[dbsource];
 138       // skip me
 139       if (db.equals(DBRefSource.PDB))
 140       {
 141         continue;
 142       }
 143       for (DbSourceProxy sp : sfetcher.getSourceProxy(db))
 144       {
 145         testRetrieval(db, sp, sp.getTestQuery());
 146       }
 147     }
 148
 149   }
 150
 151   private static void testRetrieval(String db, DbSourceProxy sp,
 152           String testQuery)
 153   {
 154     AlignmentI ds = null;
 155     Vector<Object[]> noProds = new Vector<>();
 156     System.out.println("Source: " + sp.getDbName() + " (" + db
 157             + "): retrieving test:" + sp.getTestQuery());
 158     {
 159       AlignmentI al = null;
 160       try
 161       {
 162         al = sp.getSequenceRecords(testQuery);
 163         if (al != null && al.getHeight() > 0)
 164         {
 165           boolean dna = sp.isDnaCoding();
 166           al.setDataset(null);
 167           AlignmentI alds = al.getDataset();
 168           // try and find products
 169           CrossRef crossRef = new CrossRef(al.getSequencesArray(), alds);
 170           List<String> types = crossRef.findXrefSourcesForSequences(dna);
 171           if (types != null)
 172           {
 173             System.out.println("Xref Types for: " + (dna ? "dna" : "prot"));
 174             for (String source : types)
 175             {
 176               System.out.println("Type: " + source);
 177               SequenceI[] prod = crossRef.findXrefSequences(source, dna)
 178                       .getSequencesArray();
 179               System.out.println("Found "
 180                       + ((prod == null) ? "no" : "" + prod.length)
 181                       + " products");
 182               if (prod != null)
 183               {
 184                 for (int p = 0; p < prod.length; p++)
 185                 {
 186                   System.out.println("Prod " + p + ": "
 187                           + prod[p].getDisplayId(true));
 188                 }
 189               }
 190             }
 191           }
 192           else
 193           {
 194             noProds.addElement((dna ? new Object[] { al, al }
 195                     : new Object[] { al }));
 196           }
 197
 198         }
 199       } catch (Exception ex)
 200       {
 201         System.out.println("ERROR:Failed to retrieve test query.");
 202         ex.printStackTrace(System.out);
 203       }
 204
 205       if (al == null)
 206       {
 207         System.out.println("ERROR:No alignment retrieved.");
 208         StringBuffer raw = sp.getRawRecords();
 209         if (raw != null)
 210         {
 211           System.out.println(raw.toString());
 212         }
 213         else
 214         {
 215           System.out.println("ERROR:No Raw results.");
 216         }
 217       }
 218       else
 219       {
 220         System.out.println("Retrieved " + al.getHeight() + " sequences.");
 221         if (ds == null)
 222         {
 223           ds = al.getDataset();
 224         }
 225         else
 226         {
 227           ds.append(al.getDataset());
 228           al.setDataset(ds);
 229         }
 230       }
 231       System.out.flush();
 232       System.err.flush();
 233     }
 234     if (noProds.size() > 0)
 235     {
 236       Enumeration<Object[]> ts = noProds.elements();
 237       while (ts.hasMoreElements())
 238
 239       {
 240         Object[] typeSq = ts.nextElement();
 241         boolean dna = (typeSq.length > 1);
 242         AlignmentI al = (AlignmentI) typeSq[0];
 243         System.out.println("Trying getProducts for "
 244                 + al.getSequenceAt(0).getDisplayId(true));
 245         System.out.println("Search DS Xref for: " + (dna ? "dna" : "prot"));
 246         // have a bash at finding the products amongst all the retrieved
 247         // sequences.
 248         SequenceI[] seqs = al.getSequencesArray();
 249         Alignment prodal = new CrossRef(seqs, ds).findXrefSequences(null,
 250                 dna);
 251         System.out.println("Found "
 252                 + ((prodal == null) ? "no" : "" + prodal.getHeight())
 253                 + " products");
 254         if (prodal != null)
 255         {
 256           SequenceI[] prod = prodal.getSequencesArray(); // note
 257           // should
 258           // test
 259           // rather
 260           // than
 261           // throw
 262           // away
 263           // codon
 264           // mapping
 265           // (if
 266           // present)
 267           for (int p = 0; p < prod.length; p++)
 268           {
 269             System.out.println("Prod " + p + ": "
 270                     + prod[p].getDisplayId(true));
 271           }
 272         }
 273       }
 274     }
 275   }
 276 }