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