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 org.testng.annotations.Test;
  31
  32 public class UrlLinkTest
  33 {
  34
  35   final static String DB = "Test";
  36
  37   final static String URL_PREFIX = "http://www.jalview.org/";
  38
  39   final static String URL_SUFFIX = "/blah";
  40
  41   final static String SEP = "|";
  42
  43   final static String DELIM = "$";
  44
  45   final static String REGEX_NESTED = "=/^(?:Label:)?(?:(?:gi\\|(\\d+))|([^:]+))/=";
  46
  47   final static String REGEX_RUBBISH = "=/[0-9]++/=";
  48
  49   /**
  50    * Test URL link creation when the input string has no regex
  51    */
  52   @Test(groups = { "Functional" })
  53   public void testUrlLinkCreationNoRegex()
  54   {
  55     // SEQUENCE_NAME
  56     UrlLink ul = new UrlLink(DB + SEP + URL_PREFIX + DELIM + SEQUENCE_NAME
  57             + DELIM + URL_SUFFIX);
  58     assertEquals(DB.toUpperCase(), ul.getTarget());
  59     assertEquals(DB, ul.getLabel());
  60     assertEquals(URL_PREFIX, ul.getUrl_prefix());
  61     assertEquals(URL_SUFFIX, ul.getUrl_suffix());
  62     assertTrue(ul.isDynamic());
  63     assertFalse(ul.usesSeqId());
  64     assertNull(ul.getRegexReplace());
  65     assertTrue(ul.isValid());
  66     assertNull(ul.getInvalidMessage());
  67
  68     // SEQUENCE_ID
  69     ul = new UrlLink(DB + SEP + URL_PREFIX + DELIM + SEQUENCE_ID + DELIM
  70             + URL_SUFFIX);
  71     assertEquals(DB.toUpperCase(), ul.getTarget());
  72     assertEquals(DB, ul.getLabel());
  73     assertEquals(URL_PREFIX, ul.getUrl_prefix());
  74     assertEquals(URL_SUFFIX, ul.getUrl_suffix());
  75     assertTrue(ul.isDynamic());
  76     assertTrue(ul.usesSeqId());
  77     assertNull(ul.getRegexReplace());
  78     assertTrue(ul.isValid());
  79     assertNull(ul.getInvalidMessage());
  80
  81     // Not dynamic
  82     ul = new UrlLink(DB + SEP + URL_PREFIX + URL_SUFFIX.substring(1));
  83     assertEquals(DB.toUpperCase(), ul.getTarget());
  84     assertEquals(DB, ul.getLabel());
  85     assertEquals(URL_PREFIX + URL_SUFFIX.substring(1), ul.getUrl_prefix());
  86     assertFalse(ul.isDynamic());
  87     assertFalse(ul.usesSeqId());
  88     assertNull(ul.getRegexReplace());
  89     assertTrue(ul.isValid());
  90     assertNull(ul.getInvalidMessage());
  91   }
  92
  93   /**
  94    * Test URL link creation when the input string has regex
  95    */
  96   @Test(groups = { "Functional" })
  97   public void testUrlLinkCreationWithRegex()
  98   {
  99     // SEQUENCE_NAME
 100     UrlLink ul = new UrlLink(DB + SEP + URL_PREFIX + DELIM + SEQUENCE_NAME
 101             + REGEX_NESTED + DELIM + URL_SUFFIX);
 102     assertEquals(DB.toUpperCase(), ul.getTarget());
 103     assertEquals(DB, ul.getLabel());
 104     assertEquals(URL_PREFIX, ul.getUrl_prefix());
 105     assertEquals(URL_SUFFIX, ul.getUrl_suffix());
 106     assertTrue(ul.isDynamic());
 107     assertFalse(ul.usesSeqId());
 108     assertEquals(REGEX_NESTED.substring(2, REGEX_NESTED.length() - 2),
 109             ul.getRegexReplace());
 110     assertTrue(ul.isValid());
 111     assertNull(ul.getInvalidMessage());
 112
 113     // SEQUENCE_ID
 114     ul = new UrlLink(DB + SEP + URL_PREFIX + DELIM + SEQUENCE_ID
 115             + REGEX_NESTED + DELIM + URL_SUFFIX);
 116     assertEquals(DB.toUpperCase(), ul.getTarget());
 117     assertEquals(DB, ul.getLabel());
 118     assertEquals(URL_PREFIX, ul.getUrl_prefix());
 119     assertEquals(URL_SUFFIX, ul.getUrl_suffix());
 120     assertTrue(ul.isDynamic());
 121     assertTrue(ul.usesSeqId());
 122     assertEquals(REGEX_NESTED.substring(2, REGEX_NESTED.length() - 2),
 123             ul.getRegexReplace());
 124     assertTrue(ul.isValid());
 125     assertNull(ul.getInvalidMessage());
 126
 127     // invalid regex
 128     ul = new UrlLink(DB + SEP + URL_PREFIX + DELIM + SEQUENCE_ID
 129             + REGEX_RUBBISH + DELIM + URL_SUFFIX);
 130     assertEquals(DB.toUpperCase(), ul.getTarget());
 131     assertEquals(DB, ul.getLabel());
 132     assertEquals(URL_PREFIX, ul.getUrl_prefix());
 133     assertEquals(URL_SUFFIX, ul.getUrl_suffix());
 134     assertTrue(ul.isDynamic());
 135     assertTrue(ul.usesSeqId());
 136     assertEquals(REGEX_RUBBISH.substring(2, REGEX_RUBBISH.length() - 2),
 137             ul.getRegexReplace());
 138     assertFalse(ul.isValid());
 139     assertEquals(
 140             "Invalid Regular Expression : '"
 141                     + REGEX_RUBBISH.substring(2, REGEX_RUBBISH.length() - 2)
 142                     + "'\n",
 143             ul.getInvalidMessage());
 144   }
 145
 146   /**
 147    * Test construction of link by substituting sequence id or name
 148    */
 149   @Test(groups = { "Functional" })
 150   public void testMakeUrlNoRegex()
 151   {
 152     // Single non-regex
 153     UrlLink ul = new UrlLink(DB + SEP + URL_PREFIX + DELIM + SEQUENCE_NAME
 154             + DELIM + URL_SUFFIX);
 155     String idstring = "FER_CAPAA";
 156     String[] urls = ul.makeUrls(idstring, true);
 157
 158     assertEquals(2, urls.length);
 159     assertEquals(idstring, urls[0]);
 160     assertEquals(URL_PREFIX + idstring + URL_SUFFIX, urls[1]);
 161
 162     urls = ul.makeUrls(idstring, false);
 163
 164     assertEquals(2, urls.length);
 165     assertEquals(idstring, urls[0]);
 166     assertEquals(URL_PREFIX + idstring + URL_SUFFIX, urls[1]);
 167   }
 168
 169   /**
 170    * Test construction of link by substituting sequence id or name
 171    */
 172   @Test(groups = { "Functional" })
 173   public void testMakeUrlWithRegex()
 174   {
 175     // Unused regex
 176     UrlLink ul = new UrlLink(DB + SEP + URL_PREFIX + DELIM + SEQUENCE_ID
 177             + REGEX_NESTED + DELIM + URL_SUFFIX);
 178     String idstring = "FER_CAPAA";
 179     String[] urls = ul.makeUrls(idstring, true);
 180
 181     assertEquals(2, urls.length);
 182     assertEquals(idstring, urls[0]);
 183     assertEquals(URL_PREFIX + idstring + URL_SUFFIX, urls[1]);
 184     assertTrue(ul.isValid());
 185     assertNull(ul.getInvalidMessage());
 186
 187     urls = ul.makeUrls(idstring, false);
 188
 189     assertEquals(2, urls.length);
 190     assertEquals(idstring, urls[0]);
 191     assertEquals(URL_PREFIX + idstring + URL_SUFFIX, urls[1]);
 192     assertTrue(ul.isValid());
 193     assertNull(ul.getInvalidMessage());
 194
 195     // nested regex
 196     idstring = "Label:gi|9234|pdb|102L|A";
 197     urls = ul.makeUrls(idstring, true);
 198
 199     assertEquals(2, urls.length);
 200     assertEquals("9234", urls[0]);
 201     assertEquals(URL_PREFIX + "9234" + URL_SUFFIX, urls[1]);
 202     assertTrue(ul.isValid());
 203     assertNull(ul.getInvalidMessage());
 204
 205     urls = ul.makeUrls(idstring, false);
 206
 207     assertEquals(2, urls.length);
 208     assertEquals("9234", urls[0]);
 209     assertEquals(URL_PREFIX + "9234" + URL_SUFFIX, urls[1]);
 210     assertTrue(ul.isValid());
 211     assertNull(ul.getInvalidMessage());
 212
 213     // unmatched regex
 214     idstring = "this does not match";
 215     urls = ul.makeUrls(idstring, true);
 216
 217     assertEquals(2, urls.length);
 218     assertEquals(idstring, urls[0]);
 219     assertEquals(URL_PREFIX + idstring + URL_SUFFIX, urls[1]);
 220     assertTrue(ul.isValid());
 221     assertNull(ul.getInvalidMessage());
 222
 223     urls = ul.makeUrls(idstring, false);
 224
 225     assertEquals(2, urls.length);
 226     assertEquals(idstring, urls[0]);
 227     assertEquals(URL_PREFIX + idstring + URL_SUFFIX, urls[1]);
 228     assertTrue(ul.isValid());
 229     assertNull(ul.getInvalidMessage());
 230
 231     // empty idstring
 232     idstring = "";
 233     urls = ul.makeUrls(idstring, true);
 234
 235     assertNull(urls);
 236
 237     urls = ul.makeUrls(idstring, false);
 238
 239     assertEquals(2, urls.length);
 240     assertEquals("", urls[0]);
 241     assertEquals(URL_PREFIX + URL_SUFFIX, urls[1]);
 242     assertTrue(ul.isValid());
 243     assertNull(ul.getInvalidMessage());
 244   }
 245
 246 }