test/jalview/util/UrlLinkTest.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.util;
  22
  23 import static jalview.util.UrlConstants.DB_ACCESSION;
  24 import static jalview.util.UrlConstants.SEQUENCE_ID;
  25 import static org.testng.AssertJUnit.assertEquals;
  26 import static org.testng.AssertJUnit.assertFalse;
  27 import static org.testng.AssertJUnit.assertNull;
  28 import static org.testng.AssertJUnit.assertTrue;
  29
  30 import jalview.datamodel.DBRefEntry;
  31 import jalview.datamodel.DBRefSource;
  32 import jalview.datamodel.Sequence;
  33 import jalview.gui.JvOptionPane;
  34
  35 import java.util.ArrayList;
  36 import java.util.LinkedHashMap;
  37 import java.util.List;
  38 import java.util.Map;
  39
  40 import org.testng.annotations.BeforeClass;
  41 import org.testng.annotations.Test;
  42
  43 public class UrlLinkTest
  44 {
  45
  46   @BeforeClass(alwaysRun = true)
  47   public void setUpJvOptionPane()
  48   {
  49     JvOptionPane.setInteractiveMode(false);
  50     JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION);
  51   }
  52
  53   final static String DB = "Test";
  54
  55   final static String URL_PREFIX = "http://www.jalview.org/";
  56
  57   final static String URL_SUFFIX = "/blah";
  58
  59   final static String SEP = "|";
  60
  61   final static String DELIM = "$";
  62
  63   final static String REGEX_NESTED = "=/^(?:Label:)?(?:(?:gi\\|(\\d+))|([^:]+))/=";
  64
  65   final static String REGEX_RUBBISH = "=/[0-9]++/=";
  66
  67   /**
  68    * Test URL link creation when the input string has no regex
  69    */
  70   @Test(groups = { "Functional" })
  71   public void testUrlLinkCreationNoRegex()
  72   {
  73     // SEQUENCE_ID
  74     UrlLink ul = new UrlLink(DB + SEP + URL_PREFIX + DELIM + SEQUENCE_ID
  75             + DELIM + URL_SUFFIX);
  76     assertEquals(DB, ul.getTarget());
  77     assertEquals(DB, ul.getLabel());
  78     assertEquals(URL_PREFIX, ul.getUrl_prefix());
  79     assertEquals(URL_SUFFIX, ul.getUrl_suffix());
  80     assertTrue(ul.isDynamic());
  81     assertFalse(ul.usesDBAccession());
  82     assertNull(ul.getRegexReplace());
  83     assertTrue(ul.isValid());
  84     assertNull(ul.getInvalidMessage());
  85
  86     // DB_ACCESSION
  87     ul = new UrlLink(DB + SEP + URL_PREFIX + DELIM + DB_ACCESSION + DELIM
  88             + URL_SUFFIX);
  89     assertEquals(DB, ul.getTarget());
  90     assertEquals(DB, ul.getLabel());
  91     assertEquals(URL_PREFIX, ul.getUrl_prefix());
  92     assertEquals(URL_SUFFIX, ul.getUrl_suffix());
  93     assertTrue(ul.isDynamic());
  94     assertTrue(ul.usesDBAccession());
  95     assertNull(ul.getRegexReplace());
  96     assertTrue(ul.isValid());
  97     assertNull(ul.getInvalidMessage());
  98
  99     // Not dynamic
 100     ul = new UrlLink(DB + SEP + URL_PREFIX + URL_SUFFIX.substring(1));
 101     assertEquals(DB, ul.getTarget());
 102     assertEquals(DB, ul.getLabel());
 103     assertEquals(URL_PREFIX + URL_SUFFIX.substring(1), ul.getUrl_prefix());
 104     assertFalse(ul.isDynamic());
 105     assertFalse(ul.usesDBAccession());
 106     assertNull(ul.getRegexReplace());
 107     assertTrue(ul.isValid());
 108     assertNull(ul.getInvalidMessage());
 109   }
 110
 111   /**
 112    * Test URL link creation when the input string has regex
 113    */
 114   @Test(groups = { "Functional" })
 115   public void testUrlLinkCreationWithRegex()
 116   {
 117     // SEQUENCE_ID
 118     UrlLink ul = new UrlLink(DB + SEP + URL_PREFIX + DELIM + SEQUENCE_ID
 119             + REGEX_NESTED + DELIM + URL_SUFFIX);
 120     assertEquals(DB, ul.getTarget());
 121     assertEquals(DB, ul.getLabel());
 122     assertEquals(URL_PREFIX, ul.getUrl_prefix());
 123     assertEquals(URL_SUFFIX, ul.getUrl_suffix());
 124     assertTrue(ul.isDynamic());
 125     assertFalse(ul.usesDBAccession());
 126     assertEquals(REGEX_NESTED.substring(2, REGEX_NESTED.length() - 2),
 127             ul.getRegexReplace());
 128     assertTrue(ul.isValid());
 129     assertNull(ul.getInvalidMessage());
 130
 131     // DB_ACCESSION
 132     ul = new UrlLink(DB + SEP + URL_PREFIX + DELIM + DB_ACCESSION
 133             + REGEX_NESTED + DELIM + URL_SUFFIX);
 134     assertEquals(DB, ul.getTarget());
 135     assertEquals(DB, ul.getLabel());
 136     assertEquals(URL_PREFIX, ul.getUrl_prefix());
 137     assertEquals(URL_SUFFIX, ul.getUrl_suffix());
 138     assertTrue(ul.isDynamic());
 139     assertTrue(ul.usesDBAccession());
 140     assertEquals(REGEX_NESTED.substring(2, REGEX_NESTED.length() - 2),
 141             ul.getRegexReplace());
 142     assertTrue(ul.isValid());
 143     assertNull(ul.getInvalidMessage());
 144
 145     // invalid regex
 146     ul = new UrlLink(DB + SEP + URL_PREFIX + DELIM + DB_ACCESSION
 147             + REGEX_RUBBISH + DELIM + URL_SUFFIX);
 148     assertEquals(DB, ul.getTarget());
 149     assertEquals(DB, ul.getLabel());
 150     assertEquals(URL_PREFIX, ul.getUrl_prefix());
 151     assertEquals(URL_SUFFIX, ul.getUrl_suffix());
 152     assertTrue(ul.isDynamic());
 153     assertTrue(ul.usesDBAccession());
 154     assertEquals(REGEX_RUBBISH.substring(2, REGEX_RUBBISH.length() - 2),
 155             ul.getRegexReplace());
 156     assertFalse(ul.isValid());
 157     assertEquals(
 158             "Invalid Regular Expression : '"
 159                     + REGEX_RUBBISH.substring(2, REGEX_RUBBISH.length() - 2)
 160                     + "'\n",
 161             ul.getInvalidMessage());
 162   }
 163
 164   /**
 165    * Test construction of link by substituting sequence id or name
 166    */
 167   @Test(groups = { "Functional" })
 168   public void testMakeUrlNoRegex()
 169   {
 170     // Single non-regex
 171     UrlLink ul = new UrlLink(DB + SEP + URL_PREFIX + DELIM + SEQUENCE_ID
 172             + DELIM + URL_SUFFIX);
 173     String idstring = "FER_CAPAA";
 174     String[] urls = ul.makeUrls(idstring, true);
 175
 176     assertEquals(2, urls.length);
 177     assertEquals(idstring, urls[0]);
 178     assertEquals(URL_PREFIX + idstring + URL_SUFFIX, urls[1]);
 179
 180     urls = ul.makeUrls(idstring, false);
 181
 182     assertEquals(2, urls.length);
 183     assertEquals(idstring, urls[0]);
 184     assertEquals(URL_PREFIX + idstring + URL_SUFFIX, urls[1]);
 185   }
 186
 187   /**
 188    * Test construction of link by substituting sequence id or name using regular
 189    * expression
 190    */
 191   @Test(groups = { "Functional" })
 192   public void testMakeUrlWithRegex()
 193   {
 194     // Unused regex
 195     UrlLink ul = new UrlLink(DB + SEP + URL_PREFIX + DELIM + DB_ACCESSION
 196             + REGEX_NESTED + DELIM + URL_SUFFIX);
 197     String idstring = "FER_CAPAA";
 198     String[] urls = ul.makeUrls(idstring, true);
 199
 200     assertEquals(2, urls.length);
 201     assertEquals(idstring, urls[0]);
 202     assertEquals(URL_PREFIX + idstring + URL_SUFFIX, urls[1]);
 203     assertTrue(ul.isValid());
 204     assertNull(ul.getInvalidMessage());
 205
 206     urls = ul.makeUrls(idstring, false);
 207
 208     assertEquals(2, urls.length);
 209     assertEquals(idstring, urls[0]);
 210     assertEquals(URL_PREFIX + idstring + URL_SUFFIX, urls[1]);
 211     assertTrue(ul.isValid());
 212     assertNull(ul.getInvalidMessage());
 213
 214     // nested regex
 215     idstring = "Label:gi|9234|pdb|102L|A";
 216     urls = ul.makeUrls(idstring, true);
 217
 218     assertEquals(2, urls.length);
 219     assertEquals("9234", urls[0]);
 220     assertEquals(URL_PREFIX + "9234" + URL_SUFFIX, urls[1]);
 221     assertTrue(ul.isValid());
 222     assertNull(ul.getInvalidMessage());
 223
 224     urls = ul.makeUrls(idstring, false);
 225
 226     assertEquals(2, urls.length);
 227     assertEquals("9234", urls[0]);
 228     assertEquals(URL_PREFIX + "9234" + URL_SUFFIX, urls[1]);
 229     assertTrue(ul.isValid());
 230     assertNull(ul.getInvalidMessage());
 231
 232     // unmatched regex
 233     idstring = "this does not match";
 234     urls = ul.makeUrls(idstring, true);
 235
 236     assertEquals(2, urls.length);
 237     assertEquals(idstring, urls[0]);
 238     assertEquals(URL_PREFIX + idstring + URL_SUFFIX, urls[1]);
 239     assertTrue(ul.isValid());
 240     assertNull(ul.getInvalidMessage());
 241
 242     urls = ul.makeUrls(idstring, false);
 243
 244     assertEquals(2, urls.length);
 245     assertEquals(idstring, urls[0]);
 246     assertEquals(URL_PREFIX + idstring + URL_SUFFIX, urls[1]);
 247     assertTrue(ul.isValid());
 248     assertNull(ul.getInvalidMessage());
 249
 250     // empty idstring
 251     idstring = "";
 252     urls = ul.makeUrls(idstring, true);
 253
 254     assertNull(urls);
 255
 256     urls = ul.makeUrls(idstring, false);
 257
 258     assertEquals(2, urls.length);
 259     assertEquals("", urls[0]);
 260     assertEquals(URL_PREFIX + URL_SUFFIX, urls[1]);
 261     assertTrue(ul.isValid());
 262     assertNull(ul.getInvalidMessage());
 263   }
 264
 265   /**
 266    * Test creating links with null sequence
 267    */
 268   @Test(groups = { "Functional" })
 269   public void testCreateLinksFromNullSequence()
 270   {
 271     UrlLink ul = new UrlLink(DB + SEP + URL_PREFIX + DELIM + SEQUENCE_ID
 272             + DELIM + URL_SUFFIX);
 273
 274     Map<String, List<String>> linkset = new LinkedHashMap<String, List<String>>();
 275     ul.createLinksFromSeq(null, linkset);
 276
 277     String key = DB + SEP + URL_PREFIX;
 278     assertEquals(1, linkset.size());
 279     assertTrue(linkset.containsKey(key));
 280     assertEquals(linkset.get(key).get(0), DB);
 281     assertEquals(linkset.get(key).get(1), DB);
 282     assertEquals(linkset.get(key).get(2), null);
 283     assertEquals(linkset.get(key).get(3), URL_PREFIX);
 284   }
 285
 286   /**
 287    * Test creating links with non-dynamic urlLink
 288    */
 289   @Test(groups = { "Functional" })
 290   public void testCreateLinksForNonDynamic()
 291   {
 292     UrlLink ul = new UrlLink(DB + SEP + URL_PREFIX + URL_SUFFIX);
 293
 294     Map<String, List<String>> linkset = new LinkedHashMap<String, List<String>>();
 295     ul.createLinksFromSeq(null, linkset);
 296
 297     String key = DB + SEP + URL_PREFIX + URL_SUFFIX;
 298     assertEquals(1, linkset.size());
 299     assertTrue(linkset.containsKey(key));
 300     assertEquals(linkset.get(key).get(0), DB);
 301     assertEquals(linkset.get(key).get(1), DB);
 302     assertEquals(linkset.get(key).get(2), null);
 303     assertEquals(linkset.get(key).get(3), URL_PREFIX + URL_SUFFIX);
 304   }
 305
 306   /**
 307    * Test creating links
 308    */
 309   @Test(groups = { "Functional" })
 310   public void testCreateLinksFromSequence()
 311   {
 312
 313     // create list of links and list of DBRefs
 314     List<String> links = new ArrayList<String>();
 315     List<DBRefEntry> refs = new ArrayList<DBRefEntry>();
 316
 317     // links as might be added into Preferences | Connections dialog
 318     links.add("EMBL-EBI Search | http://www.ebi.ac.uk/ebisearch/search.ebi?db=allebi&query=$"
 319             + SEQUENCE_ID + "$");
 320     links.add("UNIPROT | http://www.uniprot.org/uniprot/$" + DB_ACCESSION
 321             + "$");
 322     links.add("INTERPRO | http://www.ebi.ac.uk/interpro/entry/$"
 323             + DB_ACCESSION + "$");
 324
 325     // make seq0 dbrefs
 326     refs.add(new DBRefEntry(DBRefSource.UNIPROT, "1", "P83527"));
 327     refs.add(new DBRefEntry("INTERPRO", "1", "IPR001041"));
 328     refs.add(new DBRefEntry("INTERPRO", "1", "IPR006058"));
 329     refs.add(new DBRefEntry("INTERPRO", "1", "IPR012675"));
 330
 331     Sequence seq0 = new Sequence("FER1", "AKPNGVL");
 332
 333     // add all the dbrefs to the sequence
 334     seq0.addDBRef(refs.get(0));
 335     seq0.addDBRef(refs.get(1));
 336     seq0.addDBRef(refs.get(2));
 337     seq0.addDBRef(refs.get(3));
 338     seq0.createDatasetSequence();
 339
 340     // Test where link takes a sequence id as replacement
 341     UrlLink ul = new UrlLink(DB + SEP + URL_PREFIX + DELIM + SEQUENCE_ID
 342             + DELIM + URL_SUFFIX);
 343
 344     Map<String, List<String>> linkset = new LinkedHashMap<String, List<String>>();
 345     ul.createLinksFromSeq(seq0, linkset);
 346
 347     String key = seq0.getName() + SEP + URL_PREFIX + seq0.getName()
 348             + URL_SUFFIX;
 349     assertEquals(1, linkset.size());
 350     assertTrue(linkset.containsKey(key));
 351     assertEquals(linkset.get(key).get(0), DB);
 352     assertEquals(linkset.get(key).get(1), DB);
 353     assertEquals(linkset.get(key).get(2), seq0.getName());
 354     assertEquals(linkset.get(key).get(3), URL_PREFIX + seq0.getName()
 355             + URL_SUFFIX);
 356
 357     // Test where link takes a db annotation id and only has one dbref
 358     ul = new UrlLink(links.get(1));
 359     linkset = new LinkedHashMap<String, List<String>>();
 360     ul.createLinksFromSeq(seq0, linkset);
 361
 362     key = "P83527|http://www.uniprot.org/uniprot/P83527";
 363     assertEquals(1, linkset.size());
 364     assertTrue(linkset.containsKey(key));
 365     assertEquals(linkset.get(key).get(0), DBRefSource.UNIPROT);
 366     assertEquals(linkset.get(key).get(1), DBRefSource.UNIPROT + SEP
 367             + "P83527");
 368     assertEquals(linkset.get(key).get(2), "P83527");
 369     assertEquals(linkset.get(key).get(3),
 370             "http://www.uniprot.org/uniprot/P83527");
 371
 372     // Test where link takes a db annotation id and has multiple dbrefs
 373     ul = new UrlLink(links.get(2));
 374     linkset = new LinkedHashMap<String, List<String>>();
 375     ul.createLinksFromSeq(seq0, linkset);
 376     assertEquals(3, linkset.size());
 377
 378     // check each link made it in correctly
 379     key = "IPR001041|http://www.ebi.ac.uk/interpro/entry/IPR001041";
 380     assertTrue(linkset.containsKey(key));
 381     assertEquals(linkset.get(key).get(0), "INTERPRO");
 382     assertEquals(linkset.get(key).get(1), "INTERPRO" + SEP + "IPR001041");
 383     assertEquals(linkset.get(key).get(2), "IPR001041");
 384     assertEquals(linkset.get(key).get(3),
 385             "http://www.ebi.ac.uk/interpro/entry/IPR001041");
 386
 387     key = "IPR006058|http://www.ebi.ac.uk/interpro/entry/IPR006058";
 388     assertTrue(linkset.containsKey(key));
 389     assertEquals(linkset.get(key).get(0), "INTERPRO");
 390     assertEquals(linkset.get(key).get(1), "INTERPRO" + SEP + "IPR006058");
 391     assertEquals(linkset.get(key).get(2), "IPR006058");
 392     assertEquals(linkset.get(key).get(3),
 393             "http://www.ebi.ac.uk/interpro/entry/IPR006058");
 394
 395     key = "IPR012675|http://www.ebi.ac.uk/interpro/entry/IPR012675";
 396     assertTrue(linkset.containsKey(key));
 397     assertEquals(linkset.get(key).get(0), "INTERPRO");
 398     assertEquals(linkset.get(key).get(1), "INTERPRO" + SEP + "IPR012675");
 399     assertEquals(linkset.get(key).get(2), "IPR012675");
 400     assertEquals(linkset.get(key).get(3),
 401             "http://www.ebi.ac.uk/interpro/entry/IPR012675");
 402
 403     // Test where there are no matching dbrefs for the link
 404     ul = new UrlLink(DB + SEP + URL_PREFIX + DELIM + DB_ACCESSION + DELIM
 405             + URL_SUFFIX);
 406     linkset = new LinkedHashMap<String, List<String>>();
 407     ul.createLinksFromSeq(seq0, linkset);
 408     assertTrue(linkset.isEmpty());
 409   }
 410
 411 }