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