test/jalview/ws/dbsources/PDBRestClientTest.java

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