test/jalview/ws/dbsources/PDBRestClientTest.java

   1 package jalview.ws.dbsources;
   2
   3 import static org.testng.AssertJUnit.assertEquals;
   4 import static org.testng.AssertJUnit.assertTrue;
   5 import org.testng.annotations.AfterMethod;
   6 import org.testng.annotations.Test;
   7 import org.testng.annotations.BeforeMethod;
   8 import org.testng.Assert;
   9 import jalview.ws.dbsources.PDBRestClient.PDBDocField;
  10 import jalview.ws.uimodel.PDBRestRequest;
  11 import jalview.ws.uimodel.PDBRestResponse;
  12
  13 import java.io.BufferedReader;
  14 import java.io.FileReader;
  15 import java.io.IOException;
  16 import java.util.ArrayList;
  17 import java.util.Iterator;
  18 import java.util.List;
  19
  20 import javax.ws.rs.core.MediaType;
  21
  22 import org.json.simple.JSONArray;
  23 import org.json.simple.JSONObject;
  24 import org.json.simple.parser.JSONParser;
  25 import org.json.simple.parser.ParseException;
  26 import com.sun.jersey.api.client.Client;
  27 import com.sun.jersey.api.client.ClientResponse;
  28 import com.sun.jersey.api.client.WebResource;
  29 import com.sun.jersey.api.client.config.ClientConfig;
  30 import com.sun.jersey.api.client.config.DefaultClientConfig;
  31
  32 public class PDBRestClientTest
  33 {
  34
  35   @BeforeMethod
  36   public void setUp() throws Exception
  37   {
  38   }
  39
  40   @AfterMethod
  41   public void tearDown() throws Exception
  42   {
  43   }
  44
  45   @Test
  46   public void executeRequestTest()
  47   {
  48     List<PDBDocField> wantedFields = new ArrayList<PDBDocField>();
  49     wantedFields.add(PDBDocField.MOLECULE_TYPE);
  50     wantedFields.add(PDBDocField.PDB_ID);
  51     wantedFields.add(PDBDocField.GENUS);
  52     wantedFields.add(PDBDocField.GENE_NAME);
  53     wantedFields.add(PDBDocField.TITLE);
  54
  55     PDBRestRequest request = new PDBRestRequest();
  56     request.setAllowEmptySeq(false);
  57     request.setResponseSize(100);
  58     request.setFieldToSearchBy("text:");
  59     request.setSearchTerm("abc");
  60     request.setWantedFields(wantedFields);
  61
  62     PDBRestResponse response;
  63     try
  64     {
  65       response = new PDBRestClient().executeRequest(request);
  66     } catch (Exception e)
  67     {
  68       e.printStackTrace();
  69       Assert.fail("Couldn't execute webservice call!");
  70       return;
  71     }
  72     assertTrue(response.getNumberOfItemsFound() > 99);
  73     assertTrue(response.getSearchSummary() != null);
  74     assertTrue(response.getSearchSummary().size() > 99);
  75   }
  76
  77   @Test
  78   public void getPDBDocFieldsAsCommaDelimitedStringTest()
  79   {
  80     List<PDBDocField> wantedFields = new ArrayList<PDBDocField>();
  81     wantedFields.add(PDBDocField.MOLECULE_TYPE);
  82     wantedFields.add(PDBDocField.PDB_ID);
  83     wantedFields.add(PDBDocField.GENUS);
  84     wantedFields.add(PDBDocField.GENE_NAME);
  85     wantedFields.add(PDBDocField.TITLE);
  86
  87     String expectedResult = "molecule_type,pdb_id,genus,gene_name,title";
  88     String actualResult = PDBRestClient
  89             .getPDBDocFieldsAsCommaDelimitedString(wantedFields);
  90
  91     assertEquals("", expectedResult, actualResult);
  92   }
  93
  94   @Test
  95   public void parsePDBJsonExceptionStringTest()
  96   {
  97     List<PDBDocField> wantedFields = new ArrayList<PDBDocField>();
  98     wantedFields.add(PDBDocField.MOLECULE_TYPE);
  99     wantedFields.add(PDBDocField.PDB_ID);
 100     wantedFields.add(PDBDocField.GENUS);
 101     wantedFields.add(PDBDocField.GENE_NAME);
 102     wantedFields.add(PDBDocField.TITLE);
 103
 104     PDBRestRequest request = new PDBRestRequest();
 105     request.setAllowEmptySeq(false);
 106     request.setResponseSize(100);
 107     request.setFieldToSearchBy("text:");
 108     request.setSearchTerm("abc");
 109     request.setWantedFields(wantedFields);
 110
 111     String jsonErrorResponse = "";
 112     try
 113     {
 114       jsonErrorResponse = readJsonStringFromFile("test/jalview/io/pdb_request_json_error.txt");
 115     } catch (IOException e)
 116     {
 117       e.printStackTrace();
 118     }
 119
 120     String parsedErrorResponse = PDBRestClient
 121             .parseJsonExceptionString(jsonErrorResponse);
 122
 123     String expectedErrorMsg = "\n============= PDB Rest Client RunTime error =============\n"
 124             + "Status: 400\n"
 125             + "Message: org.apache.solr.search.SyntaxError: Cannot parse 'text:abc OR text:go:abc AND molecule_sequence:['' TO *]': Encountered \" \":\" \": \"\" at line 1, column 19.\n"
 126             + "query: text:abc OR text:go:abc AND molecule_sequence:['' TO *]\n"
 127             + "fl: pdb_id\n";
 128
 129     assertEquals(expectedErrorMsg, parsedErrorResponse);
 130   }
 131
 132   @Test(expectedExceptions = Exception.class)
 133   public void testForExpectedRuntimeException() throws Exception
 134   {
 135     List<PDBDocField> wantedFields = new ArrayList<PDBDocField>();
 136     wantedFields.add(PDBDocField.PDB_ID);
 137
 138     PDBRestRequest request = new PDBRestRequest();
 139     request.setFieldToSearchBy("text:");
 140     request.setSearchTerm("abc OR text:go:abc");
 141     request.setWantedFields(wantedFields);
 142     new PDBRestClient().executeRequest(request);
 143   }
 144
 145   @Test
 146   public void parsePDBJsonResponseTest()
 147   {
 148     List<PDBDocField> wantedFields = new ArrayList<PDBDocField>();
 149     wantedFields.add(PDBDocField.MOLECULE_TYPE);
 150     wantedFields.add(PDBDocField.PDB_ID);
 151     wantedFields.add(PDBDocField.GENUS);
 152     wantedFields.add(PDBDocField.GENE_NAME);
 153     wantedFields.add(PDBDocField.TITLE);
 154
 155     PDBRestRequest request = new PDBRestRequest();
 156     request.setAllowEmptySeq(false);
 157     request.setWantedFields(wantedFields);
 158
 159     String jsonString = "";
 160     try
 161     {
 162       jsonString = readJsonStringFromFile("test/jalview/io/pdb_response_json.txt");
 163     } catch (IOException e)
 164     {
 165       e.printStackTrace();
 166     }
 167     PDBRestResponse response = PDBRestClient.parsePDBJsonResponse(
 168             jsonString, request);
 169     assertTrue(response.getSearchSummary() != null);
 170     assertTrue(response.getNumberOfItemsFound() == 931);
 171     assertTrue(response.getSearchSummary().size() == 14);
 172   }
 173
 174   @Test
 175   public void getPDBIdColumIndexTest()
 176   {
 177     List<PDBDocField> wantedFields = new ArrayList<PDBDocField>();
 178     wantedFields.add(PDBDocField.MOLECULE_TYPE);
 179     wantedFields.add(PDBDocField.GENUS);
 180     wantedFields.add(PDBDocField.GENE_NAME);
 181     wantedFields.add(PDBDocField.TITLE);
 182     wantedFields.add(PDBDocField.PDB_ID);
 183     assertEquals(5, PDBRestClient.getPDBIdColumIndex(wantedFields, true));
 184     assertEquals(4, PDBRestClient.getPDBIdColumIndex(wantedFields, false));
 185   }
 186
 187   @Test
 188   public void externalServiceIntegrationTest()
 189   {
 190     ClientConfig clientConfig = new DefaultClientConfig();
 191     Client client = Client.create(clientConfig);
 192
 193     // Build request parameters for the REST Request
 194     WebResource webResource = client
 195             .resource(PDBRestClient.PDB_SEARCH_ENDPOINT)
 196             .queryParam("wt", "json").queryParam("rows", String.valueOf(1))
 197             .queryParam("q", "text:abc AND molecule_sequence:['' TO *]");
 198
 199     // Execute the REST request
 200     ClientResponse clientResponse = webResource.accept(
 201             MediaType.APPLICATION_JSON).get(ClientResponse.class);
 202
 203     // Get the JSON string from the response object
 204     String pdbJsonResponseString = clientResponse.getEntity(String.class);
 205
 206     // Check the response status and report exception if one occurs
 207     if (clientResponse.getStatus() != 200)
 208     {
 209       Assert.fail("Webservice call failed!!!");
 210     }
 211     else
 212     {
 213       try
 214       {
 215         JSONParser jsonParser = new JSONParser();
 216         JSONObject jsonObj = (JSONObject) jsonParser
 217                 .parse(pdbJsonResponseString);
 218         JSONObject pdbResponse = (JSONObject) jsonObj.get("response");
 219         String queryTime = ((JSONObject) jsonObj.get("responseHeader"))
 220                 .get("QTime").toString();
 221         String numFound = pdbResponse.get("numFound").toString();
 222         JSONArray docs = (JSONArray) pdbResponse.get("docs");
 223         Iterator<JSONObject> docIter = docs.iterator();
 224
 225         assertTrue("Couldn't Retrieve 'response' object",
 226                 pdbResponse != null);
 227         assertTrue("Couldn't Retrieve 'QTime' value", queryTime != null);
 228         assertTrue("Couldn't Retrieve 'numFound' value", numFound != null);
 229         assertTrue("Couldn't Retrieve 'docs' object", docs != null
 230                 || !docIter.hasNext());
 231
 232         JSONObject pdbJsonDoc = docIter.next();
 233
 234         for (PDBDocField field : PDBDocField.values())
 235         {
 236           if (field == PDBDocField.ALL)
 237           {
 238             continue;
 239           }
 240           if (pdbJsonDoc.get(field.getCode()) == null)
 241           {
 242             // System.out.println(">>>\t" + field.getCode());
 243             assertTrue(field.getClass()
 244                     + " has been removed from PDB doc Entity",
 245                     !pdbJsonResponseString.contains(field.getCode()));
 246           }
 247         }
 248       } catch (ParseException e)
 249       {
 250         Assert.fail(">>>  Test failed due to exception while parsing pdb response json !!!");
 251         e.printStackTrace();
 252       }
 253     }
 254   }
 255
 256   public String readJsonStringFromFile(String filePath) throws IOException
 257   {
 258     String fileContent;
 259     BufferedReader br = new BufferedReader(new FileReader(filePath));
 260     try
 261     {
 262       StringBuilder sb = new StringBuilder();
 263       String line = br.readLine();
 264
 265       while (line != null)
 266       {
 267         sb.append(line);
 268         sb.append(System.lineSeparator());
 269         line = br.readLine();
 270         }
 271       fileContent = sb.toString();
 272     } finally
 273     {
 274       br.close();
 275     }
 276     return fileContent;
 277   }
 278
 279 }