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