JAL-2505 removed SequenceFeature constructor JAL-1641 include
[jalview.git] / test / jalview / gui / PopupMenuTest.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.gui;
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.assertTrue;
28
29 import jalview.datamodel.AlignmentAnnotation;
30 import jalview.datamodel.AlignmentI;
31 import jalview.datamodel.Annotation;
32 import jalview.datamodel.DBRefEntry;
33 import jalview.datamodel.DBRefSource;
34 import jalview.datamodel.Sequence;
35 import jalview.datamodel.SequenceI;
36 import jalview.io.DataSourceType;
37 import jalview.io.FileFormat;
38 import jalview.io.FormatAdapter;
39 import jalview.util.MessageManager;
40
41 import java.awt.Component;
42 import java.io.IOException;
43 import java.util.ArrayList;
44 import java.util.List;
45
46 import javax.swing.JMenu;
47 import javax.swing.JMenuItem;
48 import javax.swing.JPopupMenu;
49 import javax.swing.JSeparator;
50
51 import org.testng.annotations.BeforeClass;
52 import org.testng.annotations.BeforeMethod;
53 import org.testng.annotations.Test;
54
55 public class PopupMenuTest
56 {
57
58   @BeforeClass(alwaysRun = true)
59   public void setUpJvOptionPane()
60   {
61     JvOptionPane.setInteractiveMode(false);
62     JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION);
63   }
64
65   // 4 sequences x 13 positions
66   final static String TEST_DATA = ">FER_CAPAA Ferredoxin\n"
67           + "TIETHKEAELVG-\n"
68           + ">FER_CAPAN Ferredoxin, chloroplast precursor\n"
69           + "TIETHKEAELVG-\n"
70           + ">FER1_SOLLC Ferredoxin-1, chloroplast precursor\n"
71           + "TIETHKEEELTA-\n" + ">Q93XJ9_SOLTU Ferredoxin I precursor\n"
72           + "TIETHKEEELTA-\n";
73
74   AlignmentI alignment;
75
76   AlignmentPanel parentPanel;
77
78   PopupMenu testee = null;
79
80   @BeforeMethod(alwaysRun = true)
81   public void setUp() throws IOException
82   {
83     alignment = new FormatAdapter().readFile(TEST_DATA,
84             DataSourceType.PASTE, FileFormat.Fasta);
85     AlignFrame af = new AlignFrame(alignment, 700, 500);
86     parentPanel = new AlignmentPanel(af, af.getViewport());
87     testee = new PopupMenu(parentPanel, null, null);
88     int i = 0;
89     for (SequenceI seq : alignment.getSequences())
90     {
91       final AlignmentAnnotation annotation = new AlignmentAnnotation(
92               "label" + i, "desc" + i, i);
93       annotation.setCalcId("calcId" + i);
94       seq.addAlignmentAnnotation(annotation);
95       annotation.setSequenceRef(seq);
96     }
97   }
98
99   @Test(groups = { "Functional" })
100   public void testConfigureReferenceAnnotationsMenu_noSequenceSelected()
101   {
102     JMenuItem menu = new JMenuItem();
103     List<SequenceI> seqs = new ArrayList<SequenceI>();
104     testee.configureReferenceAnnotationsMenu(menu, seqs);
105     assertFalse(menu.isEnabled());
106     // now try null list
107     menu.setEnabled(true);
108     testee.configureReferenceAnnotationsMenu(menu, null);
109     assertFalse(menu.isEnabled());
110   }
111
112   /**
113    * Test building the 'add reference annotations' menu for the case where there
114    * are no reference annotations to add to the alignment. The menu item should
115    * be disabled.
116    */
117   @Test(groups = { "Functional" })
118   public void testConfigureReferenceAnnotationsMenu_noReferenceAnnotations()
119   {
120     JMenuItem menu = new JMenuItem();
121
122     /*
123      * Initial state is that sequences have annotations, and have dataset
124      * sequences, but the dataset sequences have no annotations. Hence nothing
125      * to add.
126      */
127     List<SequenceI> seqs = parentPanel.getAlignment().getSequences();
128
129     testee.configureReferenceAnnotationsMenu(menu, seqs);
130     assertFalse(menu.isEnabled());
131   }
132
133   /**
134    * Test building the 'add reference annotations' menu for the case where all
135    * reference annotations are already on the alignment. The menu item should be
136    * disabled.
137    */
138   @Test(groups = { "Functional" })
139   public void testConfigureReferenceAnnotationsMenu_alreadyAdded()
140   {
141     JMenuItem menu = new JMenuItem();
142     List<SequenceI> seqs = parentPanel.getAlignment().getSequences();
143
144     // make up new annotations and add to dataset sequences, sequences and
145     // alignment
146     attachReferenceAnnotations(seqs, true, true);
147
148     testee.configureReferenceAnnotationsMenu(menu, seqs);
149     assertFalse(menu.isEnabled());
150   }
151
152   /**
153    * Test building the 'add reference annotations' menu for the case where
154    * several reference annotations are on the dataset but not on the sequences.
155    * The menu item should be enabled, and acquire a tooltip which lists the
156    * annotation sources (calcIds) and type (labels).
157    */
158   @Test(groups = { "Functional" })
159   public void testConfigureReferenceAnnotationsMenu()
160   {
161     JMenuItem menu = new JMenuItem();
162     List<SequenceI> seqs = parentPanel.getAlignment().getSequences();
163
164     // make up new annotations and add to dataset sequences
165     attachReferenceAnnotations(seqs, false, false);
166
167     testee.configureReferenceAnnotationsMenu(menu, seqs);
168     assertTrue(menu.isEnabled());
169     String s = MessageManager.getString("label.add_annotations_for");
170     String expected = "<html><style> p.ttip {width: 350; text-align: justify; word-wrap: break-word;}</style><p class=\"ttip\">"
171             + s + "<br/>Jmol/secondary structure<br/>PDB/Temp</p></html>";
172     assertEquals(expected, menu.getToolTipText());
173   }
174
175   /**
176    * Test building the 'add reference annotations' menu for the case where
177    * several reference annotations are on the dataset and the sequences but not
178    * on the alignment. The menu item should be enabled, and acquire a tooltip
179    * which lists the annotation sources (calcIds) and type (labels).
180    */
181   @Test(groups = { "Functional" })
182   public void testConfigureReferenceAnnotationsMenu_notOnAlignment()
183   {
184     JMenuItem menu = new JMenuItem();
185     List<SequenceI> seqs = parentPanel.getAlignment().getSequences();
186
187     // make up new annotations and add to dataset sequences and sequences
188     attachReferenceAnnotations(seqs, true, false);
189
190     testee.configureReferenceAnnotationsMenu(menu, seqs);
191     assertTrue(menu.isEnabled());
192     String s = MessageManager.getString("label.add_annotations_for");
193     String expected = "<html><style> p.ttip {width: 350; text-align: justify; word-wrap: break-word;}</style><p class=\"ttip\">"
194             + s + "<br/>Jmol/secondary structure<br/>PDB/Temp</p></html>";
195     assertEquals(expected, menu.getToolTipText());
196   }
197
198   /**
199    * Generate annotations and add to dataset sequences and (optionally)
200    * sequences and/or alignment
201    * 
202    * @param seqs
203    * @param addToSequence
204    * @param addToAlignment
205    */
206   private void attachReferenceAnnotations(List<SequenceI> seqs,
207           boolean addToSequence, boolean addToAlignment)
208   {
209     // PDB.secondary structure on Sequence0
210     AlignmentAnnotation annotation = new AlignmentAnnotation(
211             "secondary structure", "", 0);
212     annotation.setCalcId("PDB");
213     seqs.get(0).getDatasetSequence().addAlignmentAnnotation(annotation);
214     if (addToSequence)
215     {
216       seqs.get(0).addAlignmentAnnotation(annotation);
217     }
218     if (addToAlignment)
219     {
220       this.alignment.addAnnotation(annotation);
221     }
222
223     // PDB.Temp on Sequence1
224     annotation = new AlignmentAnnotation("Temp", "", 0);
225     annotation.setCalcId("PDB");
226     seqs.get(1).getDatasetSequence().addAlignmentAnnotation(annotation);
227     if (addToSequence)
228     {
229       seqs.get(1).addAlignmentAnnotation(annotation);
230     }
231     if (addToAlignment)
232     {
233       this.alignment.addAnnotation(annotation);
234     }
235
236     // JMOL.secondary structure on Sequence0
237     annotation = new AlignmentAnnotation("secondary structure", "", 0);
238     annotation.setCalcId("Jmol");
239     seqs.get(0).getDatasetSequence().addAlignmentAnnotation(annotation);
240     if (addToSequence)
241     {
242       seqs.get(0).addAlignmentAnnotation(annotation);
243     }
244     if (addToAlignment)
245     {
246       this.alignment.addAnnotation(annotation);
247     }
248   }
249
250   /**
251    * Test building the 'add reference annotations' menu for the case where there
252    * are two alignment views:
253    * <ul>
254    * <li>in one view, reference annotations have been added (are on the
255    * datasets, sequences and alignment)</li>
256    * <li>in the current view, reference annotations are on the dataset and
257    * sequence, but not the alignment</li>
258    * </ul>
259    * The menu item should be enabled, and acquire a tooltip which lists the
260    * annotation sources (calcIds) and type (labels).
261    */
262   @Test(groups = { "Functional" })
263   public void testConfigureReferenceAnnotationsMenu_twoViews()
264   {
265   }
266
267   /**
268    * Test for building menu options including 'show' and 'hide' annotation
269    * types.
270    */
271   @Test(groups = { "Functional" })
272   public void testBuildAnnotationTypesMenus()
273   {
274     JMenu showMenu = new JMenu();
275     JMenu hideMenu = new JMenu();
276     List<SequenceI> seqs = parentPanel.getAlignment().getSequences();
277
278     // make up new annotations and add to sequences and to the alignment
279
280     // PDB.secondary structure on Sequence0
281     AlignmentAnnotation annotation = new AlignmentAnnotation(
282             "secondary structure", "", new Annotation[] {});
283     annotation.setCalcId("PDB");
284     annotation.visible = true;
285     seqs.get(0).addAlignmentAnnotation(annotation);
286     parentPanel.getAlignment().addAnnotation(annotation);
287
288     // JMOL.secondary structure on Sequence0 - hidden
289     annotation = new AlignmentAnnotation("secondary structure", "",
290             new Annotation[] {});
291     annotation.setCalcId("JMOL");
292     annotation.visible = false;
293     seqs.get(0).addAlignmentAnnotation(annotation);
294     parentPanel.getAlignment().addAnnotation(annotation);
295
296     // Jpred.SSP on Sequence0 - hidden
297     annotation = new AlignmentAnnotation("SSP", "", new Annotation[] {});
298     annotation.setCalcId("JPred");
299     annotation.visible = false;
300     seqs.get(0).addAlignmentAnnotation(annotation);
301     parentPanel.getAlignment().addAnnotation(annotation);
302
303     // PDB.Temp on Sequence1
304     annotation = new AlignmentAnnotation("Temp", "", new Annotation[] {});
305     annotation.setCalcId("PDB");
306     annotation.visible = true;
307     seqs.get(1).addAlignmentAnnotation(annotation);
308     parentPanel.getAlignment().addAnnotation(annotation);
309
310     /*
311      * Expect menu options to show "secondary structure" and "SSP", and to hide
312      * "secondary structure" and "Temp". Tooltip should be calcId.
313      */
314     testee.buildAnnotationTypesMenus(showMenu, hideMenu, seqs);
315
316     assertTrue(showMenu.isEnabled());
317     assertTrue(hideMenu.isEnabled());
318
319     Component[] showOptions = showMenu.getMenuComponents();
320     Component[] hideOptions = hideMenu.getMenuComponents();
321
322     assertEquals(4, showOptions.length); // includes 'All' and separator
323     assertEquals(4, hideOptions.length);
324     String all = MessageManager.getString("label.all");
325     assertEquals(all, ((JMenuItem) showOptions[0]).getText());
326     assertTrue(showOptions[1] instanceof JPopupMenu.Separator);
327     assertEquals(JSeparator.HORIZONTAL,
328             ((JSeparator) showOptions[1]).getOrientation());
329     assertEquals("secondary structure",
330             ((JMenuItem) showOptions[2]).getText());
331     assertEquals("JMOL", ((JMenuItem) showOptions[2]).getToolTipText());
332     assertEquals("SSP", ((JMenuItem) showOptions[3]).getText());
333     assertEquals("JPred", ((JMenuItem) showOptions[3]).getToolTipText());
334
335     assertEquals(all, ((JMenuItem) hideOptions[0]).getText());
336     assertTrue(hideOptions[1] instanceof JPopupMenu.Separator);
337     assertEquals(JSeparator.HORIZONTAL,
338             ((JSeparator) hideOptions[1]).getOrientation());
339     assertEquals("secondary structure",
340             ((JMenuItem) hideOptions[2]).getText());
341     assertEquals("PDB", ((JMenuItem) hideOptions[2]).getToolTipText());
342     assertEquals("Temp", ((JMenuItem) hideOptions[3]).getText());
343     assertEquals("PDB", ((JMenuItem) hideOptions[3]).getToolTipText());
344   }
345
346   /**
347    * Test for building menu options with only 'hide' annotation types enabled.
348    */
349   @Test(groups = { "Functional" })
350   public void testBuildAnnotationTypesMenus_showDisabled()
351   {
352     JMenu showMenu = new JMenu();
353     JMenu hideMenu = new JMenu();
354     List<SequenceI> seqs = parentPanel.getAlignment().getSequences();
355
356     // make up new annotations and add to sequences and to the alignment
357
358     // PDB.secondary structure on Sequence0
359     AlignmentAnnotation annotation = new AlignmentAnnotation(
360             "secondary structure", "", new Annotation[] {});
361     annotation.setCalcId("PDB");
362     annotation.visible = true;
363     seqs.get(0).addAlignmentAnnotation(annotation);
364     parentPanel.getAlignment().addAnnotation(annotation);
365
366     // PDB.Temp on Sequence1
367     annotation = new AlignmentAnnotation("Temp", "", new Annotation[] {});
368     annotation.setCalcId("PDB");
369     annotation.visible = true;
370     seqs.get(1).addAlignmentAnnotation(annotation);
371     parentPanel.getAlignment().addAnnotation(annotation);
372
373     /*
374      * Expect menu options to hide "secondary structure" and "Temp". Tooltip
375      * should be calcId. 'Show' menu should be disabled.
376      */
377     testee.buildAnnotationTypesMenus(showMenu, hideMenu, seqs);
378
379     assertFalse(showMenu.isEnabled());
380     assertTrue(hideMenu.isEnabled());
381
382     Component[] showOptions = showMenu.getMenuComponents();
383     Component[] hideOptions = hideMenu.getMenuComponents();
384
385     assertEquals(2, showOptions.length); // includes 'All' and separator
386     assertEquals(4, hideOptions.length);
387     String all = MessageManager.getString("label.all");
388     assertEquals(all, ((JMenuItem) showOptions[0]).getText());
389     assertTrue(showOptions[1] instanceof JPopupMenu.Separator);
390     assertEquals(JSeparator.HORIZONTAL,
391             ((JSeparator) showOptions[1]).getOrientation());
392
393     assertEquals(all, ((JMenuItem) hideOptions[0]).getText());
394     assertTrue(hideOptions[1] instanceof JPopupMenu.Separator);
395     assertEquals(JSeparator.HORIZONTAL,
396             ((JSeparator) hideOptions[1]).getOrientation());
397     assertEquals("secondary structure",
398             ((JMenuItem) hideOptions[2]).getText());
399     assertEquals("PDB", ((JMenuItem) hideOptions[2]).getToolTipText());
400     assertEquals("Temp", ((JMenuItem) hideOptions[3]).getText());
401     assertEquals("PDB", ((JMenuItem) hideOptions[3]).getToolTipText());
402   }
403
404   /**
405    * Test for building menu options with only 'show' annotation types enabled.
406    */
407   @Test(groups = { "Functional" })
408   public void testBuildAnnotationTypesMenus_hideDisabled()
409   {
410     JMenu showMenu = new JMenu();
411     JMenu hideMenu = new JMenu();
412     List<SequenceI> seqs = parentPanel.getAlignment().getSequences();
413
414     // make up new annotations and add to sequences and to the alignment
415
416     // PDB.secondary structure on Sequence0
417     AlignmentAnnotation annotation = new AlignmentAnnotation(
418             "secondary structure", "", new Annotation[] {});
419     annotation.setCalcId("PDB");
420     annotation.visible = false;
421     seqs.get(0).addAlignmentAnnotation(annotation);
422     parentPanel.getAlignment().addAnnotation(annotation);
423
424     // PDB.Temp on Sequence1
425     annotation = new AlignmentAnnotation("Temp", "", new Annotation[] {});
426     annotation.setCalcId("PDB2");
427     annotation.visible = false;
428     seqs.get(1).addAlignmentAnnotation(annotation);
429     parentPanel.getAlignment().addAnnotation(annotation);
430
431     /*
432      * Expect menu options to show "secondary structure" and "Temp". Tooltip
433      * should be calcId. 'hide' menu should be disabled.
434      */
435     testee.buildAnnotationTypesMenus(showMenu, hideMenu, seqs);
436
437     assertTrue(showMenu.isEnabled());
438     assertFalse(hideMenu.isEnabled());
439
440     Component[] showOptions = showMenu.getMenuComponents();
441     Component[] hideOptions = hideMenu.getMenuComponents();
442
443     assertEquals(4, showOptions.length); // includes 'All' and separator
444     assertEquals(2, hideOptions.length);
445     String all = MessageManager.getString("label.all");
446     assertEquals(all, ((JMenuItem) showOptions[0]).getText());
447     assertTrue(showOptions[1] instanceof JPopupMenu.Separator);
448     assertEquals(JSeparator.HORIZONTAL,
449             ((JSeparator) showOptions[1]).getOrientation());
450     assertEquals("secondary structure",
451             ((JMenuItem) showOptions[2]).getText());
452     assertEquals("PDB", ((JMenuItem) showOptions[2]).getToolTipText());
453     assertEquals("Temp", ((JMenuItem) showOptions[3]).getText());
454     assertEquals("PDB2", ((JMenuItem) showOptions[3]).getToolTipText());
455
456     assertEquals(all, ((JMenuItem) hideOptions[0]).getText());
457     assertTrue(hideOptions[1] instanceof JPopupMenu.Separator);
458     assertEquals(JSeparator.HORIZONTAL,
459             ((JSeparator) hideOptions[1]).getOrientation());
460   }
461
462   /**
463    * Test for adding feature links
464    */
465   @Test(groups = { "Functional" })
466   public void testAddFeatureLinks()
467   {
468     // sequences from the alignment
469     List<SequenceI> seqs = parentPanel.getAlignment().getSequences();
470
471     // create list of links and list of DBRefs
472     List<String> links = new ArrayList<String>();
473     List<DBRefEntry> refs = new ArrayList<DBRefEntry>();
474
475     // links as might be added into Preferences | Connections dialog
476     links.add("EMBL-EBI Search | http://www.ebi.ac.uk/ebisearch/search.ebi?db=allebi&query=$"
477             + SEQUENCE_ID + "$");
478     links.add("UNIPROT | http://www.uniprot.org/uniprot/$" + DB_ACCESSION
479             + "$");
480     links.add("INTERPRO | http://www.ebi.ac.uk/interpro/entry/$"
481             + DB_ACCESSION + "$");
482     // Gene3D entry tests for case (in)sensitivity
483     links.add("Gene3D | http://gene3d.biochem.ucl.ac.uk/Gene3D/search?sterm=$"
484             + DB_ACCESSION + "$&mode=protein");
485
486     // make seq0 dbrefs
487     refs.add(new DBRefEntry(DBRefSource.UNIPROT, "1", "P83527"));
488     refs.add(new DBRefEntry("INTERPRO", "1", "IPR001041"));
489     refs.add(new DBRefEntry("INTERPRO", "1", "IPR006058"));
490     refs.add(new DBRefEntry("INTERPRO", "1", "IPR012675"));
491     
492     // make seq1 dbrefs
493     refs.add(new DBRefEntry(DBRefSource.UNIPROT, "1", "Q9ZTS2"));
494     refs.add(new DBRefEntry("GENE3D", "1", "3.10.20.30"));
495
496     // add all the dbrefs to the sequences: Uniprot 1 each, Interpro all 3 to
497     // seq0, Gene3D to seq1
498     seqs.get(0).addDBRef(refs.get(0));
499
500     seqs.get(0).addDBRef(refs.get(1));
501     seqs.get(0).addDBRef(refs.get(2));
502     seqs.get(0).addDBRef(refs.get(3));
503     
504     seqs.get(1).addDBRef(refs.get(4));
505     seqs.get(1).addDBRef(refs.get(5));
506     
507     // get the Popup Menu for first sequence
508     testee = new PopupMenu(parentPanel, (Sequence) seqs.get(0), links);
509     Component[] seqItems = testee.sequenceMenu.getMenuComponents();
510     JMenu linkMenu = (JMenu) seqItems[6];
511     Component[] linkItems = linkMenu.getMenuComponents();
512     
513     // check the number of links are the expected number
514     assertEquals(5, linkItems.length);
515
516     // first entry is EMBL-EBI which just uses sequence id not accession id?
517     assertEquals("EMBL-EBI Search", ((JMenuItem) linkItems[0]).getText());
518
519     // sequence id for each link should match corresponding DB accession id
520     for (int i = 1; i < 4; i++)
521     {
522       assertEquals(refs.get(i - 1).getSource(), ((JMenuItem) linkItems[i])
523               .getText().split("\\|")[0]);
524       assertEquals(refs.get(i - 1).getAccessionId(),
525               ((JMenuItem) linkItems[i])
526               .getText().split("\\|")[1]);
527     }
528
529     // get the Popup Menu for second sequence
530     testee = new PopupMenu(parentPanel, (Sequence) seqs.get(1), links);
531     seqItems = testee.sequenceMenu.getMenuComponents();
532     linkMenu = (JMenu) seqItems[6];
533     linkItems = linkMenu.getMenuComponents();
534     
535     // check the number of links are the expected number
536     assertEquals(3, linkItems.length);
537
538     // first entry is EMBL-EBI which just uses sequence id not accession id?
539     assertEquals("EMBL-EBI Search", ((JMenuItem) linkItems[0]).getText());
540
541     // sequence id for each link should match corresponding DB accession id
542     for (int i = 1; i < 3; i++)
543     {
544       assertEquals(refs.get(i + 3).getSource(), ((JMenuItem) linkItems[i])
545               .getText().split("\\|")[0].toUpperCase());
546       assertEquals(refs.get(i + 3).getAccessionId(),
547               ((JMenuItem) linkItems[i]).getText().split("\\|")[1]);
548     }
549
550     // if there are no valid links the Links submenu is disabled
551     List<String> nomatchlinks = new ArrayList<String>();
552     nomatchlinks.add("NOMATCH | http://www.uniprot.org/uniprot/$"
553             + DB_ACCESSION + "$");
554
555     testee = new PopupMenu(parentPanel, (Sequence) seqs.get(0),
556             nomatchlinks);
557     seqItems = testee.sequenceMenu.getMenuComponents();
558     linkMenu = (JMenu) seqItems[6];
559     assertFalse(linkMenu.isEnabled());
560
561   }
562 }