Class |
Line # |
Actions |
|||
---|---|---|---|---|---|
SiftsClientTest | 54 | 240 | 31 |
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.sifts; | |
22 | ||
23 | import static org.testng.Assert.assertEquals; | |
24 | import static org.testng.Assert.assertTrue; | |
25 | ||
26 | import jalview.api.DBRefEntryI; | |
27 | import jalview.bin.Cache; | |
28 | import jalview.datamodel.DBRefEntry; | |
29 | import jalview.datamodel.DBRefSource; | |
30 | import jalview.datamodel.Sequence; | |
31 | import jalview.datamodel.SequenceI; | |
32 | import jalview.gui.JvOptionPane; | |
33 | import jalview.io.DataSourceType; | |
34 | import jalview.structure.StructureMapping; | |
35 | import jalview.xml.binding.sifts.Entry.Entity; | |
36 | ||
37 | import java.io.File; | |
38 | import java.io.IOException; | |
39 | import java.util.ArrayList; | |
40 | import java.util.HashMap; | |
41 | import java.util.Iterator; | |
42 | import java.util.Map; | |
43 | ||
44 | import org.testng.Assert; | |
45 | import org.testng.FileAssert; | |
46 | import org.testng.annotations.AfterTest; | |
47 | import org.testng.annotations.BeforeClass; | |
48 | import org.testng.annotations.BeforeTest; | |
49 | import org.testng.annotations.Test; | |
50 | ||
51 | import mc_view.Atom; | |
52 | import mc_view.PDBfile; | |
53 | ||
54 | public class SiftsClientTest | |
55 | { | |
56 | ||
57 | 1 | @BeforeClass(alwaysRun = true) |
58 | public void setUpJvOptionPane() | |
59 | { | |
60 | 1 | JvOptionPane.setInteractiveMode(false); |
61 | 1 | JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION); |
62 | } | |
63 | ||
64 | public static final String DEFAULT_SIFTS_DOWNLOAD_DIR = System | |
65 | .getProperty("user.home") + File.separatorChar | |
66 | + ".sifts_downloads" + File.separatorChar; | |
67 | ||
68 | private String testPDBId = "1a70"; | |
69 | ||
70 | private SiftsClient siftsClient = null; | |
71 | ||
72 | SequenceI testSeq = new Sequence("P00221", | |
73 | "MAAT..TTTMMG..MATTFVPKPQAPPMMAALPSNTGR..SLFGLKT.GSR..GGRMTMA" | |
74 | + "AYKVTLVTPTGNVEFQCPDDVYILDAAEEEGIDLPYSCRAGSCSSCAGKLKTGSLNQDD" | |
75 | + "QSFLDDDQIDEGWVLTCAAYPVSDVTIETHKEEELTA.", | |
76 | 1, 147); | |
77 | ||
78 | int u = SiftsClient.UNASSIGNED; | |
79 | ||
80 | HashMap<Integer, int[]> expectedMapping = new HashMap<Integer, int[]>(); | |
81 | ||
82 | 4 | @BeforeTest(alwaysRun = true) |
83 | public void populateExpectedMapping() throws SiftsException | |
84 | { | |
85 | 4 | expectedMapping.put(51, new int[] { 1, 2, 1 }); |
86 | 4 | expectedMapping.put(52, new int[] { 2, 7, 2 }); |
87 | 4 | expectedMapping.put(53, new int[] { 3, 12, 3 }); |
88 | 4 | expectedMapping.put(54, new int[] { 4, 24, 4 }); |
89 | 4 | expectedMapping.put(55, new int[] { 5, 33, 5 }); |
90 | 4 | expectedMapping.put(56, new int[] { 6, 40, 6 }); |
91 | 4 | expectedMapping.put(57, new int[] { 7, 47, 7 }); |
92 | 4 | expectedMapping.put(58, new int[] { 8, 55, 8 }); |
93 | 4 | expectedMapping.put(59, new int[] { 9, 62, 9 }); |
94 | 4 | expectedMapping.put(60, new int[] { 10, 69, 10 }); |
95 | 4 | expectedMapping.put(61, new int[] { 11, 76, 11 }); |
96 | 4 | expectedMapping.put(62, new int[] { 12, 83, 12 }); |
97 | 4 | expectedMapping.put(63, new int[] { 13, 87, 13 }); |
98 | 4 | expectedMapping.put(64, new int[] { 14, 95, 14 }); |
99 | 4 | expectedMapping.put(65, new int[] { 15, 102, 15 }); |
100 | 4 | expectedMapping.put(66, new int[] { 16, 111, 16 }); |
101 | 4 | expectedMapping.put(67, new int[] { 17, 122, 17 }); |
102 | 4 | expectedMapping.put(68, new int[] { 18, 131, 18 }); |
103 | 4 | expectedMapping.put(69, new int[] { 19, 137, 19 }); |
104 | 4 | expectedMapping.put(70, new int[] { 20, 144, 20 }); |
105 | 4 | expectedMapping.put(71, new int[] { 21, 152, 21 }); |
106 | 4 | expectedMapping.put(72, new int[] { 22, 160, 22 }); |
107 | 4 | expectedMapping.put(73, new int[] { 23, 167, 23 }); |
108 | 4 | expectedMapping.put(74, new int[] { 24, 179, 24 }); |
109 | 4 | expectedMapping.put(75, new int[] { 25, 187, 25 }); |
110 | 4 | expectedMapping.put(76, new int[] { 26, 195, 26 }); |
111 | 4 | expectedMapping.put(77, new int[] { 27, 203, 27 }); |
112 | 4 | expectedMapping.put(78, new int[] { 28, 208, 28 }); |
113 | 4 | expectedMapping.put(79, new int[] { 29, 213, 29 }); |
114 | 4 | expectedMapping.put(80, new int[] { 30, 222, 30 }); |
115 | 4 | expectedMapping.put(81, new int[] { 31, 231, 31 }); |
116 | 4 | expectedMapping.put(82, new int[] { 32, 240, 32 }); |
117 | 4 | expectedMapping.put(83, new int[] { 33, 244, 33 }); |
118 | 4 | expectedMapping.put(84, new int[] { 34, 252, 34 }); |
119 | 4 | expectedMapping.put(85, new int[] { 35, 260, 35 }); |
120 | 4 | expectedMapping.put(86, new int[] { 36, 268, 36 }); |
121 | 4 | expectedMapping.put(87, new int[] { 37, 275, 37 }); |
122 | 4 | expectedMapping.put(88, new int[] { 38, 287, 38 }); |
123 | 4 | expectedMapping.put(89, new int[] { 39, 293, 39 }); |
124 | 4 | expectedMapping.put(90, new int[] { 40, 299, 40 }); |
125 | 4 | expectedMapping.put(91, new int[] { 41, 310, 41 }); |
126 | 4 | expectedMapping.put(92, new int[] { 42, 315, 42 }); |
127 | 4 | expectedMapping.put(93, new int[] { 43, 319, 43 }); |
128 | 4 | expectedMapping.put(94, new int[] { 44, 325, 44 }); |
129 | 4 | expectedMapping.put(95, new int[] { 45, 331, 45 }); |
130 | 4 | expectedMapping.put(96, new int[] { 46, 337, 46 }); |
131 | 4 | expectedMapping.put(97, new int[] { 47, 343, 47 }); |
132 | 4 | expectedMapping.put(98, new int[] { 48, 349, 48 }); |
133 | 4 | expectedMapping.put(99, new int[] { 49, 354, 49 }); |
134 | 4 | expectedMapping.put(100, new int[] { 50, 358, 50 }); |
135 | 4 | expectedMapping.put(101, new int[] { 51, 367, 51 }); |
136 | 4 | expectedMapping.put(102, new int[] { 52, 375, 52 }); |
137 | 4 | expectedMapping.put(103, new int[] { 53, 384, 53 }); |
138 | 4 | expectedMapping.put(104, new int[] { 54, 391, 54 }); |
139 | 4 | expectedMapping.put(105, new int[] { 55, 395, 55 }); |
140 | 4 | expectedMapping.put(106, new int[] { 56, 401, 56 }); |
141 | 4 | expectedMapping.put(107, new int[] { 57, 409, 57 }); |
142 | 4 | expectedMapping.put(108, new int[] { 58, 417, 58 }); |
143 | 4 | expectedMapping.put(109, new int[] { 59, 426, 59 }); |
144 | 4 | expectedMapping.put(110, new int[] { 60, 434, 60 }); |
145 | 4 | expectedMapping.put(111, new int[] { 61, 442, 61 }); |
146 | 4 | expectedMapping.put(112, new int[] { 62, 451, 62 }); |
147 | 4 | expectedMapping.put(113, new int[] { 63, 457, 63 }); |
148 | 4 | expectedMapping.put(114, new int[] { 64, 468, 64 }); |
149 | 4 | expectedMapping.put(115, new int[] { 65, 476, 65 }); |
150 | 4 | expectedMapping.put(116, new int[] { 66, 484, 66 }); |
151 | 4 | expectedMapping.put(117, new int[] { 67, 492, 67 }); |
152 | 4 | expectedMapping.put(118, new int[] { 68, 500, 68 }); |
153 | 4 | expectedMapping.put(119, new int[] { 69, 509, 69 }); |
154 | 4 | expectedMapping.put(120, new int[] { 70, 517, 70 }); |
155 | 4 | expectedMapping.put(121, new int[] { 71, 525, 71 }); |
156 | 4 | expectedMapping.put(122, new int[] { 72, 534, 72 }); |
157 | 4 | expectedMapping.put(123, new int[] { 73, 538, 73 }); |
158 | 4 | expectedMapping.put(124, new int[] { 74, 552, 74 }); |
159 | 4 | expectedMapping.put(125, new int[] { 75, 559, 75 }); |
160 | 4 | expectedMapping.put(126, new int[] { 76, 567, 76 }); |
161 | 4 | expectedMapping.put(127, new int[] { 77, 574, 77 }); |
162 | 4 | expectedMapping.put(128, new int[] { 78, 580, 78 }); |
163 | 4 | expectedMapping.put(129, new int[] { 79, 585, 79 }); |
164 | 4 | expectedMapping.put(130, new int[] { 80, 590, 80 }); |
165 | 4 | expectedMapping.put(131, new int[] { 81, 602, 81 }); |
166 | 4 | expectedMapping.put(132, new int[] { 82, 609, 82 }); |
167 | 4 | expectedMapping.put(133, new int[] { 83, 616, 83 }); |
168 | 4 | expectedMapping.put(134, new int[] { 84, 622, 84 }); |
169 | 4 | expectedMapping.put(135, new int[] { 85, 630, 85 }); |
170 | 4 | expectedMapping.put(136, new int[] { 86, 637, 86 }); |
171 | 4 | expectedMapping.put(137, new int[] { 87, 644, 87 }); |
172 | 4 | expectedMapping.put(138, new int[] { 88, 652, 88 }); |
173 | 4 | expectedMapping.put(139, new int[] { 89, 661, 89 }); |
174 | 4 | expectedMapping.put(140, new int[] { 90, 668, 90 }); |
175 | 4 | expectedMapping.put(141, new int[] { 91, 678, 91 }); |
176 | 4 | expectedMapping.put(142, new int[] { 92, 687, 92 }); |
177 | 4 | expectedMapping.put(143, new int[] { 93, 696, 93 }); |
178 | 4 | expectedMapping.put(144, new int[] { 94, 705, 94 }); |
179 | 4 | expectedMapping.put(145, new int[] { 95, 714, 95 }); |
180 | 4 | expectedMapping.put(146, new int[] { 96, 722, 96 }); |
181 | 4 | expectedMapping.put(147, new int[] { 97, 729, 97 }); |
182 | } | |
183 | ||
184 | 4 | @BeforeTest(alwaysRun = true) |
185 | public void setUpSiftsClient() throws SiftsException, IOException | |
186 | { | |
187 | // read test props before manipulating config | |
188 | 4 | Cache.loadProperties("test/jalview/io/testProps.jvprops"); |
189 | // SIFTs entries are updated weekly - so use saved SIFTs file to enforce | |
190 | // test reproducibility | |
191 | 4 | new SiftsSettings(); |
192 | 4 | SiftsSettings.setSiftDownloadDirectory(jalview.bin.Cache |
193 | .getDefault("sifts_download_dir", DEFAULT_SIFTS_DOWNLOAD_DIR)); | |
194 | 4 | SiftsSettings.setMapWithSifts(true); |
195 | 4 | SiftsSettings.setCacheThresholdInDays("2"); |
196 | 4 | SiftsSettings.setFailSafePIDThreshold("70"); |
197 | 4 | PDBfile pdbFile; |
198 | ||
199 | 4 | pdbFile = new PDBfile(false, false, false, |
200 | "test/jalview/io/" + testPDBId + ".pdb", DataSourceType.FILE); | |
201 | // TODO: this uses a network connection - we should mock the sifts | |
202 | // testPDBId.xml.gz | |
203 | 4 | siftsClient = new SiftsClient(pdbFile); |
204 | } | |
205 | ||
206 | 4 | @AfterTest(alwaysRun = true) |
207 | public void cleanUpSiftsClient() | |
208 | { | |
209 | 4 | siftsClient = null; |
210 | } | |
211 | ||
212 | 1 | @Test(groups = { "Functional" }) |
213 | public void testSIFTsDownloadURL() | |
214 | { | |
215 | 1 | String expectedUrl = "https://ftp.ebi.ac.uk/pub/databases/msd/sifts/split_xml/xy/1xyz.sifts.xml.gz"; |
216 | 1 | Assert.assertEquals(SiftsClient.getDownloadUrlFor("1xyz.sifts.xml.gz"), |
217 | expectedUrl); | |
218 | } | |
219 | ||
220 | 0 | @Test(groups = { "Network" }) |
221 | public void getSIFTsFileTest() throws SiftsException, IOException | |
222 | { | |
223 | 0 | File siftsFile; |
224 | 0 | siftsFile = SiftsClient.downloadSiftsFile(testPDBId); |
225 | 0 | FileAssert.assertFile(siftsFile); |
226 | 0 | long t1 = siftsFile.lastModified(); |
227 | ||
228 | // re-read file should be returned from cache | |
229 | 0 | siftsFile = SiftsClient.getSiftsFile(testPDBId); |
230 | 0 | FileAssert.assertFile(siftsFile); |
231 | 0 | long t2 = siftsFile.lastModified(); |
232 | 0 | assertEquals(t1, t2); |
233 | ||
234 | /* | |
235 | * force fetch by having 0 expiry of cache | |
236 | * also wait one second, because file timestamp does not | |
237 | * give millisecond resolution :-( | |
238 | */ | |
239 | 0 | synchronized (this) |
240 | { | |
241 | 0 | try |
242 | { | |
243 | 0 | wait(1000); |
244 | } catch (InterruptedException e) | |
245 | { | |
246 | } | |
247 | } | |
248 | 0 | SiftsSettings.setCacheThresholdInDays("0"); |
249 | 0 | siftsFile = SiftsClient.getSiftsFile(testPDBId); |
250 | 0 | FileAssert.assertFile(siftsFile); |
251 | 0 | long t3 = siftsFile.lastModified(); |
252 | 0 | assertTrue(t3 > t2, "file timestamp unchanged at " + t3); |
253 | ||
254 | 0 | SiftsSettings.setCacheThresholdInDays("2"); |
255 | } | |
256 | ||
257 | 0 | @Test(groups = { "Network" }) |
258 | public void downloadSiftsFileTest() throws SiftsException, IOException | |
259 | { | |
260 | // Assert that file isn't yet downloaded - if already downloaded, assert it | |
261 | // is deleted | |
262 | 0 | Assert.assertTrue(SiftsClient.deleteSiftsFileByPDBId(testPDBId)); |
263 | 0 | File siftsFile; |
264 | 0 | siftsFile = SiftsClient.downloadSiftsFile(testPDBId); |
265 | 0 | FileAssert.assertFile(siftsFile); |
266 | 0 | SiftsClient.downloadSiftsFile(testPDBId); |
267 | } | |
268 | ||
269 | 0 | @Test(groups = { "Network" }) |
270 | public void getAllMappingAccessionTest() | |
271 | { | |
272 | 0 | Assert.assertNotNull(siftsClient); |
273 | 0 | Assert.assertNotNull(siftsClient.getAllMappingAccession()); |
274 | 0 | Assert.assertTrue(siftsClient.getAllMappingAccession().size() > 1); |
275 | } | |
276 | ||
277 | 0 | @Test(groups = { "Network" }) |
278 | public void getGreedyMappingTest() | |
279 | { | |
280 | 0 | Assert.assertNotNull(siftsClient); |
281 | 0 | Assert.assertNotNull(testSeq); |
282 | 0 | Assert.assertNotNull(expectedMapping); |
283 | ||
284 | // TODO delete when auto-fetching of DBRefEntry is implemented | |
285 | 0 | DBRefEntry dbRef = new DBRefEntry("uniprot", "", "P00221"); |
286 | 0 | testSeq.addDBRef(dbRef); |
287 | // testSeq.setSourceDBRef(dbRef); | |
288 | ||
289 | 0 | try |
290 | { | |
291 | 0 | HashMap<Integer, int[]> actualMapping = siftsClient |
292 | .getGreedyMapping("A", testSeq, null); | |
293 | 0 | Assert.assertEquals(testSeq.getStart(), 1); |
294 | 0 | Assert.assertEquals(testSeq.getEnd(), 147); |
295 | // Can't do Assert.assertEquals(actualMapping, expectedMapping); | |
296 | // because this fails in our version of TestNG | |
297 | 0 | Assert.assertEquals(actualMapping.size(), expectedMapping.size()); |
298 | 0 | Iterator<Map.Entry<Integer, int[]>> it = expectedMapping.entrySet() |
299 | .iterator(); | |
300 | 0 | while (it.hasNext()) |
301 | { | |
302 | 0 | Map.Entry<Integer, int[]> pair = it.next(); |
303 | 0 | Assert.assertTrue(actualMapping.containsKey(pair.getKey())); |
304 | 0 | Assert.assertEquals(actualMapping.get(pair.getKey()), |
305 | pair.getValue()); | |
306 | } | |
307 | ||
308 | } catch (Exception e) | |
309 | { | |
310 | 0 | e.printStackTrace(); |
311 | 0 | Assert.fail("Exception thrown while generating mapping..."); |
312 | } | |
313 | } | |
314 | ||
315 | 0 | @Test(groups = { "Network" }) |
316 | private void getAtomIndexTest() | |
317 | { | |
318 | 0 | ArrayList<Atom> atoms = new ArrayList<Atom>(); |
319 | 0 | Atom atom = new Atom(u, u, u); |
320 | 0 | atom.resNumber = 43; |
321 | 0 | atom.atomIndex = 7; |
322 | 0 | atoms.add(atom); |
323 | 0 | int actualAtomIndex = siftsClient.getAtomIndex(1, atoms); |
324 | 0 | Assert.assertEquals(actualAtomIndex, siftsClient.UNASSIGNED); |
325 | 0 | actualAtomIndex = siftsClient.getAtomIndex(43, atoms); |
326 | 0 | Assert.assertEquals(actualAtomIndex, 7); |
327 | } | |
328 | ||
329 | 0 | @Test( |
330 | groups = | |
331 | { "Network" }, | |
332 | expectedExceptions = IllegalArgumentException.class) | |
333 | private void getAtomIndexNullTest() | |
334 | { | |
335 | 0 | siftsClient.getAtomIndex(1, null); |
336 | } | |
337 | ||
338 | 0 | @Test(groups = { "Network" }) |
339 | private void padWithGapsTest() | |
340 | { | |
341 | ||
342 | } | |
343 | ||
344 | 0 | @Test(groups = { "Network" }, expectedExceptions = SiftsException.class) |
345 | private void populateAtomPositionsNullTest1() | |
346 | throws IllegalArgumentException, SiftsException | |
347 | { | |
348 | 0 | siftsClient.populateAtomPositions(null, null); |
349 | } | |
350 | ||
351 | 0 | @Test(groups = { "Network" }, expectedExceptions = SiftsException.class) |
352 | private void populateAtomPositionsNullTest2() | |
353 | throws IllegalArgumentException, SiftsException | |
354 | { | |
355 | 0 | siftsClient.populateAtomPositions("A", null); |
356 | } | |
357 | ||
358 | 0 | @Test(groups = { "Network" }) |
359 | public void getValidSourceDBRefTest() throws SiftsException | |
360 | { | |
361 | 0 | DBRefEntryI actualValidSrcDBRef = siftsClient |
362 | .getValidSourceDBRef(testSeq); | |
363 | 0 | DBRefEntryI expectedDBRef = new DBRefEntry(); |
364 | 0 | expectedDBRef.setSource(DBRefSource.UNIPROT); |
365 | 0 | expectedDBRef.setAccessionId("P00221"); |
366 | 0 | expectedDBRef.setVersion(""); |
367 | 0 | Assert.assertEquals(actualValidSrcDBRef, expectedDBRef); |
368 | } | |
369 | ||
370 | 0 | @Test(groups = { "Network" }, expectedExceptions = SiftsException.class) |
371 | public void getValidSourceDBRefExceptionTest() throws SiftsException | |
372 | { | |
373 | 0 | SequenceI invalidTestSeq = new Sequence("testSeq", "ABCDEFGH"); |
374 | 0 | siftsClient.getValidSourceDBRef(invalidTestSeq); |
375 | } | |
376 | ||
377 | 0 | @Test(groups = { "Network" }, expectedExceptions = SiftsException.class) |
378 | public void getValidSourceDBRefExceptionXTest() throws SiftsException | |
379 | { | |
380 | 0 | SequenceI invalidTestSeq = new Sequence("testSeq", "ABCDEFGH"); |
381 | 0 | DBRefEntry invalidDBRef = new DBRefEntry(); |
382 | 0 | invalidDBRef.setAccessionId("BLAR"); // note no version is set, so also |
383 | // invalid | |
384 | 0 | invalidTestSeq.addDBRef(invalidDBRef); |
385 | 0 | siftsClient.getValidSourceDBRef(invalidTestSeq); |
386 | } | |
387 | ||
388 | 0 | @Test(groups = { "Network" }) |
389 | public void isValidDBRefEntryTest() | |
390 | { | |
391 | 0 | DBRefEntryI validDBRef = new DBRefEntry(); |
392 | 0 | validDBRef.setSource(DBRefSource.UNIPROT); |
393 | 0 | validDBRef.setAccessionId("P00221"); |
394 | 0 | validDBRef.setVersion(""); |
395 | 0 | Assert.assertTrue(siftsClient.isValidDBRefEntry(validDBRef)); |
396 | } | |
397 | ||
398 | 0 | @Test(groups = { "Network" }) |
399 | public void getSiftsStructureMappingTest() throws SiftsException | |
400 | { | |
401 | 0 | Assert.assertTrue(SiftsSettings.isMapWithSifts()); |
402 | 0 | StructureMapping strucMapping = siftsClient |
403 | .getSiftsStructureMapping(testSeq, testPDBId, "A"); | |
404 | 0 | String expectedMappingOutput = "\nSequence ⟷ Structure mapping details\n" |
405 | + "Method: SIFTS\n\n" + "P00221 : 51 - 147 Maps to \n" | |
406 | + "1A70|A : 1 - 97\n\n" | |
407 | + "P00221 AAYKVTLVTPTGNVEFQCPDDVYILDAAEEEGIDLPYSCRAGSCSSCAGKLKTGSLNQDDQSFLD\n" | |
408 | + " |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||\n" | |
409 | + "1A70|A AAYKVTLVTPTGNVEFQCPDDVYILDAAEEEGIDLPYSCRAGSCSSCAGKLKTGSLNQDDQSFLD\n\n" | |
410 | ||
411 | + "P00221 DDQIDEGWVLTCAAYPVSDVTIETHKEEELTA\n" | |
412 | + " |||||||||||||||||||||||||| |||||\n" | |
413 | + "1A70|A DDQIDEGWVLTCAAYPVSDVTIETHKKEELTA\n\n" + | |
414 | ||
415 | "Length of alignment = 97\n" + "Percentage ID = 98.97\n"; | |
416 | ||
417 | 0 | Assert.assertEquals(strucMapping.getMappingDetailsOutput(), |
418 | expectedMappingOutput); | |
419 | ||
420 | // Can't do Assert.assertEquals(strucMapping.getMapping(), expectedMapping); | |
421 | // because this fails in our version of TestNG | |
422 | 0 | Assert.assertEquals(strucMapping.getMapping().size(), |
423 | expectedMapping.size()); | |
424 | 0 | Iterator<Map.Entry<Integer, int[]>> it = expectedMapping.entrySet() |
425 | .iterator(); | |
426 | 0 | while (it.hasNext()) |
427 | { | |
428 | 0 | Map.Entry<Integer, int[]> pair = it.next(); |
429 | 0 | Assert.assertTrue( |
430 | strucMapping.getMapping().containsKey(pair.getKey())); | |
431 | 0 | Assert.assertEquals(strucMapping.getMapping().get(pair.getKey()), |
432 | pair.getValue()); | |
433 | } | |
434 | } | |
435 | ||
436 | 0 | @Test(groups = { "Network" }) |
437 | public void getEntityCountTest() | |
438 | { | |
439 | 0 | int actualEntityCount = siftsClient.getEntityCount(); |
440 | 0 | System.out.println("actual entity count : " + actualEntityCount); |
441 | 0 | Assert.assertEquals(actualEntityCount, 1); |
442 | } | |
443 | ||
444 | 0 | @Test(groups = { "Network" }) |
445 | public void getDbAccessionIdTest() | |
446 | { | |
447 | 0 | String actualDbAccId = siftsClient.getDbAccessionId(); |
448 | 0 | System.out.println("Actual Db Accession Id: " + actualDbAccId); |
449 | 0 | Assert.assertEquals(actualDbAccId, "1a70"); |
450 | } | |
451 | ||
452 | 0 | @Test(groups = { "Network" }) |
453 | public void getDbCoordSysTest() | |
454 | { | |
455 | 0 | String actualDbCoordSys = siftsClient.getDbCoordSys(); |
456 | 0 | System.out.println("Actual DbCoordSys: " + actualDbCoordSys); |
457 | 0 | Assert.assertEquals(actualDbCoordSys, "PDBe"); |
458 | } | |
459 | ||
460 | 0 | @Test(groups = { "Network" }) |
461 | public void getDbSourceTest() | |
462 | { | |
463 | 0 | String actualDbSource = siftsClient.getDbSource(); |
464 | 0 | System.out.println("Actual DbSource: " + actualDbSource); |
465 | 0 | Assert.assertEquals(actualDbSource, "PDBe"); |
466 | } | |
467 | ||
468 | 0 | @Test(groups = { "Network" }) |
469 | public void getDbVersionTest() | |
470 | { | |
471 | 0 | String actualDbVersion = siftsClient.getDbVersion(); |
472 | 0 | System.out.println("Actual DbVersion: " + actualDbVersion); |
473 | 0 | Assert.assertEquals(actualDbVersion, "2.0"); |
474 | } | |
475 | ||
476 | 0 | @Test(groups = { "Network" }) |
477 | public void getEntityByMostOptimalMatchedIdTest1() | |
478 | throws IOException, SiftsException | |
479 | { | |
480 | 0 | SiftsClient siftsClientX = null; |
481 | 0 | PDBfile pdbFile; |
482 | 0 | pdbFile = new PDBfile(false, false, false, |
483 | "test/jalview/io/2nq2" + ".pdb", DataSourceType.FILE); | |
484 | 0 | siftsClientX = new SiftsClient(pdbFile); |
485 | 0 | Entity entityA = siftsClientX.getEntityByMostOptimalMatchedId("A"); |
486 | 0 | Assert.assertEquals(entityA.getEntityId(), "A"); |
487 | 0 | Entity entityB = siftsClientX.getEntityByMostOptimalMatchedId("B"); |
488 | 0 | Assert.assertEquals(entityB.getEntityId(), "C"); |
489 | 0 | Entity entityC = siftsClientX.getEntityByMostOptimalMatchedId("C"); |
490 | 0 | Assert.assertEquals(entityC.getEntityId(), "B"); |
491 | 0 | Entity entityD = siftsClientX.getEntityByMostOptimalMatchedId("D"); |
492 | 0 | Assert.assertEquals(entityD.getEntityId(), "D"); |
493 | ||
494 | } | |
495 | ||
496 | 0 | @Test(groups = { "Network" }) |
497 | public void getEntityByMostOptimalMatchedIdTest2() | |
498 | throws IOException, SiftsException | |
499 | { | |
500 | // This test is for a SIFTS file in which entity A should map to chain P for | |
501 | // the given PDB Id. All the other chains shouldn't be mapped as there are | |
502 | // no SIFTS entity records for them. | |
503 | 0 | SiftsClient siftsClientX = null; |
504 | 0 | PDBfile pdbFile; |
505 | 0 | pdbFile = new PDBfile(false, false, false, "test/jalview/io/3ucu.cif", |
506 | DataSourceType.FILE); | |
507 | 0 | siftsClientX = new SiftsClient(pdbFile); |
508 | 0 | Entity entityA = siftsClientX.getEntityByMostOptimalMatchedId("P"); |
509 | 0 | Entity entityP = siftsClientX.getEntityByMostOptimalMatchedId("A"); |
510 | 0 | Entity entityR = siftsClientX.getEntityByMostOptimalMatchedId("R"); |
511 | 0 | Assert.assertEquals(entityA.getEntityId(), "A"); |
512 | 0 | Assert.assertNotEquals(entityR, "A"); |
513 | 0 | Assert.assertNotEquals(entityP, "A"); |
514 | 0 | Assert.assertNotEquals(entityR, "R"); |
515 | 0 | Assert.assertNotEquals(entityP, "P"); |
516 | 0 | Assert.assertNull(entityR); |
517 | 0 | Assert.assertNull(entityP); |
518 | ||
519 | } | |
520 | ||
521 | 0 | @Test(groups = { "Network" }) |
522 | public void getLeadingIntegerFromString() | |
523 | { | |
524 | 0 | Assert.assertEquals(SiftsClient.getLeadingIntegerValue("1234abcd", -1), |
525 | 1234); | |
526 | 0 | Assert.assertEquals(SiftsClient.getLeadingIntegerValue("1234", -1), |
527 | 1234); | |
528 | 0 | Assert.assertEquals(SiftsClient.getLeadingIntegerValue("abcd", -1), -1); |
529 | 0 | Assert.assertEquals(SiftsClient.getLeadingIntegerValue("abcd1234", -1), |
530 | -1); | |
531 | 0 | Assert.assertEquals(SiftsClient.getLeadingIntegerValue("None", -1), -1); |
532 | 0 | Assert.assertEquals(SiftsClient.getLeadingIntegerValue("Null", -1), -1); |
533 | } | |
534 | } |