/ - Diff - Metacat - Ecoinformatics Redmine

     public class MetacatClientTest extends TestCase
+    {
         private String metacatUrl =
             "http://dev.nceas.ucsb.edu/tao/servlet/metacat";
             //"http://dev.nceas.ucsb.edu/tao/servlet/metacat";
             "http://dev.nceas.ucsb.edu:8091/tao/servlet/metacat";
             //"http://knb.ecoinformatics.org/knb/servlet/metacat";
         private String username = "@mcuser@";
         private String password = "@mcpassword@";
         private String failpass = "uidfnkj43987yfdn";
         private String docid = "jones.204.22";
         private String prefix = "test";
         private String newdocid = null;
         private String testfile = "test/jones.204.22.xml";
         private String queryFile = "test/query.xml";
         //private String docid = "Gramling.61.26";
         private String testdocument = "";
         private Metacat m;
-...
             suite.addTest(new MetacatClientTest("insert"));
             suite.addTest(new MetacatClientTest("read"));
             suite.addTest(new MetacatClientTest("query"));
             suite.addTest(new MetacatClientTest("update"));
             suite.addTest(new MetacatClientTest("delete"));
             return suite;
+        }
-...
                 m.login(username, password);
                 String response = m.insert(identifier,
                         new StringReader(testdocument), null);
                 System.err.println(
                     DateFormat.getDateTimeInstance().format(new Date()));
                 //Thread.sleep(20000);
                 System.err.println(
                     DateFormat.getDateTimeInstance().format(new Date()));
                 assertTrue(response.indexOf("<success>") != -1);
                 assertTrue(response.indexOf(identifier) != -1);
                 System.err.println(response);
-...
+        }
         /**
          * Test the update() function with a known document
          */
         public void update()
+        {
             try {
                 String identifier = newdocid + ".2";
                 m.login(username, password);
                 String response = m.update(identifier,
                         new StringReader(testdocument), null);
                 assertTrue(response.indexOf("<success>") != -1);
                 assertTrue(response.indexOf(identifier) != -1);
                 System.err.println(response);
             } catch (MetacatAuthException mae) {
                 fail("Authorization failed:\n" + mae.getMessage());
             } catch (MetacatInaccessibleException mie) {
                 fail("Metacat Inaccessible:\n" + mie.getMessage());
             } catch (InsufficientKarmaException ike) {
                 fail("Insufficient karma:\n" + ike.getMessage());
             } catch (MetacatException me) {
                 fail("Metacat Error:\n" + me.getMessage());
             } catch (Exception e) {
                 fail("General exception:\n" + e.getMessage());
+            }
+        }
         /**
          * Test the delete() function with a known document
          */
         public void delete()
+        {
             try {
                 String identifier = newdocid + ".2";
                 m.login(username, password);
                 String response = m.delete(identifier);
                 assertTrue(response.indexOf("<success>") != -1);
                 System.err.println(response);
             } catch (MetacatAuthException mae) {
                 fail("Authorization failed:\n" + mae.getMessage());
             } catch (MetacatInaccessibleException mie) {
                 fail("Metacat Inaccessible:\n" + mie.getMessage());
             } catch (InsufficientKarmaException ike) {
                 fail("Insufficient karma:\n" + ike.getMessage());
             } catch (MetacatException me) {
                 fail("Metacat Error:\n" + me.getMessage());
             } catch (Exception e) {
                 fail("General exception:\n" + e.getMessage());
+            }
+        }
         /**
          * Create a hopefully unique docid for testing insert and update. Does
          * not include the 'revision' part of the id.
+         *

          * @param xmlDocument a Reader for accessing the XML text to be updated
          * @param schema a Reader for accessing the DTD or XML Schema for
          *               the document
          * @return the metacat response message
          * @throws InsufficientKarmaException when the user has insufficent rights
          *                                    for the operation
          * @throws MetacatInaccessibleException when the metacat server can not be
          *                                    reached or does not respond
          * @throws MetacatException when the metacat server generates another error
          * @throws IOException when there is an error reading the xml document
          */
         public void update(String docid, Reader xmlDocument, Reader schema)
             throws InsufficientKarmaException
         public String update(String docid, Reader xmlDocument, Reader schema)
             throws InsufficientKarmaException, MetacatException, IOException,
             MetacatInaccessibleException
+        {
             Reader reader = null;
             String doctext = null;
             String schematext = null;
             try {
               doctext = IOUtil.getAsString(xmlDocument, true);
               if (schema != null) {
                   schematext = IOUtil.getAsString(schema, true);
+              }
             } catch (IOException ioE) {
               throw ioE;
+            }
             //set up properties
             Properties prop = new Properties();
             prop.put("action", "update");
             prop.put("docid", docid);
             prop.put("doctext", doctext);
             if (schematext != null) {
                 prop.put("dtdtext", schematext);
+            }
             String response = null;
             try {
                 response = sendDataForString(prop);
             } catch (Exception e) {
                 throw new MetacatInaccessibleException(e.getMessage());
+            }
             // Check for an error condition
             if (response.indexOf("<error>") != -1) {
                 if (response.indexOf("does not have permission") != -1) {
                     throw new InsufficientKarmaException(response);
                 } else {
                     throw new MetacatException(response);
+                }
+            }
             return response;
+        }
         /**
          * Delete an XML document in the repository.
+         *
          * @param docid the docid to delete
          * @return the metacat response message
          * @throws InsufficientKarmaException when the user has insufficent rights
          *                                    for the operation
          * @throws MetacatInaccessibleException when the metacat server can not be
          *                                    reached or does not respond
          * @throws MetacatException when the metacat server generates another error
          */
         public void delete(String docid)
             throws InsufficientKarmaException
         public String delete(String docid)
             throws InsufficientKarmaException, MetacatException,
             MetacatInaccessibleException
+        {
             //set up properties
             Properties prop = new Properties();
             prop.put("action", "delete");
             prop.put("docid", docid);
             String response = null;
             try {
                 response = sendDataForString(prop);
             } catch (Exception e) {
                 throw new MetacatInaccessibleException(e.getMessage());
+            }
             // Check for an error condition
             if (response.indexOf("<error>") != -1) {
                 if (response.indexOf("does not have permission") != -1) {
                     throw new InsufficientKarmaException(response);
                 } else {
                     throw new MetacatException(response);
+                }
+            }
             return response;
+        }
         /**

          * @param xmlDocument a Reader for accessing the XML text to be updated
          * @param schema a Reader for accessing the DTD or XML Schema for
          *               the document
          * @return the metacat response message
          * @throws InsufficientKarmaException when the user has insufficent rights
          *                                    for the operation
          * @throws MetacatInaccessibleException when the metacat server can not be
          *                                    reached or does not respond
          * @throws MetacatException when the metacat server generates another error
          * @throws IOException when there is an error reading the xml document
          */
         public void update(String docid, Reader xmlDocument, Reader schema)
             throws InsufficientKarmaException;
         public String update(String docid, Reader xmlDocument, Reader schema)
             throws InsufficientKarmaException, MetacatException, IOException,
             MetacatInaccessibleException;
         /**
          * Delete an XML document in the repository.
+         *
          * @param docid the docid to delete
          * @return the metacat response message
          * @throws InsufficientKarmaException when the user has insufficent rights
          *                                    for the operation
          * @throws MetacatInaccessibleException when the metacat server can not be
          *                                    reached or does not respond
          * @throws MetacatException when the metacat server generates another error
          */
         public void delete(String docid)
             throws InsufficientKarmaException;
         public String delete(String docid)
             throws InsufficientKarmaException, MetacatException,
             MetacatInaccessibleException;
         /**
          * When the MetacatFactory creates an instance it needs to set the

Project

General

Profile

Metacat

Revision 1795

Added by Matt Jones over 21 years ago