/test/edu/ucsb/nceas/metacattest/NonAsciiCharacterTest.java - Diff - Metacat - Ecoinformatics Redmine

« Previous | Next »

Revision 4356

Added by daigle over 15 years ago

Increase test cases to include testing read action which reads file from disk and squery which reads from db. Create separate cases for eml 2.0.1 and 2.1.0

+    	}
         private String prefix = "test";
         private String newdocid = null;
         private String testdocument = "";
         private Metacat m;
         private boolean SUCCESS = true;
         private boolean FAILURE = false;
         /**
          * These variables are for eml-2.0.1 only. For other eml versions,
          * this function might have to modified
          */
         private String testEml_Header =
         private String testEml_201_Header =
             "<?xml version=\"1.0\"?><eml:eml" +
             " xmlns:eml=\"eml://ecoinformatics.org/eml-2.0.1\"" +
             " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"" +
             " packageId=\"eml.1.1\" system=\"knb\"" +
             " xsi:schemaLocation=\"eml://ecoinformatics.org/eml-2.0.1 eml.xsd\"" +
             " scope=\"system\">";
         private String testEml_210_Header =
             "<?xml version=\"1.0\"?><eml:eml" +
             " xmlns:eml=\"eml://ecoinformatics.org/eml-2.1.0\"" +
             " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"" +
             " packageId=\"eml.1.1\" system=\"knb\"" +
             " xsi:schemaLocation=\"eml://ecoinformatics.org/eml-2.1.0 eml.xsd\"" +
             " scope=\"system\">";
         private String testEmlCreatorBlock =
             "<creator scope=\"document\">                                       " +
-...
          * This function is for eml-2.0.1 only. For other eml versions,
          * this function might have to modified
          */
         private String getTestEmlDoc(String title) {
         private String getTestEmlDoc(String title, String emlVersion) {
             String testDocument = "";
             testDocument = testDocument + testEml_Header +
             String header;
     		if (emlVersion == EML2_0_1) {
     			header = testEml_201_Header;
     		} else {
     			header = testEml_210_Header;
+    		}
             testDocument = testDocument + header +
                 "<dataset scope=\"document\"><title>" + title + "</title>" +
                 testEmlCreatorBlock;
-...
             return testDocument;
+        }
         /**
          * Returns an xml squery that searches for the doc id in the
          * title of documents. This function is for eml-2.0.1 only. For
          * other eml versions, this function might have to modified.
          */
         private String getTestEmlQuery(String docid, String emlVersion) {
         	String docType;
         	if (emlVersion.equals(EML2_0_1)) {
         		docType = "eml://ecoinformatics.org/eml-2.0.1";
         	} else {
         		docType = "eml://ecoinformatics.org/eml-2.1.0";
+        	}
             String sQuery = "";
             sQuery =
             	"<pathquery version=\"1.0\">" +
             		"<meta_file_id>unspecified</meta_file_id>" +
             		"<querytitle>unspecified</querytitle>" +
             		"<returnfield>dataset/title</returnfield>" +
             		"<returndoctype>" + docType + "</returndoctype>" +
             		"<querygroup operator=\"UNION\">" +
             			"<queryterm casesensitive=\"false\" searchmode=\"contains\">" +
             				"<value>" + docid + "</value>" +
             				"<pathexpr>dataset/title</pathexpr>" +
             			"</queryterm>" +
             		"</querygroup>" +
             	"</pathquery>";
             return sQuery;
+        }
         /**
          * Constructor to build the test
+         *
-...
          */
         public NonAsciiCharacterTest(String name) {
             super(name);
             newdocid = generateDocid();
+        }
         /**
-...
             TestSuite suite = new TestSuite();
             suite.addTest(new NonAsciiCharacterTest("initialize"));
             // Test basic functions
             suite.addTest(new NonAsciiCharacterTest("invalidXMLCharactersTest"));
             suite.addTest(new NonAsciiCharacterTest("symbolEncodedFormatTest"));
             suite.addTest(new NonAsciiCharacterTest("quoteTest"));
             suite.addTest(new NonAsciiCharacterTest("numericCharacterReferenceFormatTest"));
             suite.addTest(new NonAsciiCharacterTest("nonLatinUnicodeCharacterTest"));
             suite.addTest(new NonAsciiCharacterTest("invalidXMLCharacters201Test"));
             suite.addTest(new NonAsciiCharacterTest("invalidXMLCharacters210Test"));
             suite.addTest(new NonAsciiCharacterTest("symbolEncodedFormat201Test"));
             suite.addTest(new NonAsciiCharacterTest("symbolEncodedFormat210Test"));
             suite.addTest(new NonAsciiCharacterTest("quote201Test"));
             suite.addTest(new NonAsciiCharacterTest("quote210Test"));
             suite.addTest(new NonAsciiCharacterTest("numericCharacterReferenceFormat201Test"));
             suite.addTest(new NonAsciiCharacterTest("numericCharacterReferenceFormat210Test"));
             suite.addTest(new NonAsciiCharacterTest("nonLatinUnicodeCharacter201Test"));
             suite.addTest(new NonAsciiCharacterTest("nonLatinUnicodeCharacter210Test"));
             return suite;
+        }
-...
             assertTrue(1 == 1);
+        }
         /** *********
          * Test inserting document with > & <
         /**
          * Test inserting an EML 2.0.1 document with > & <
          * should fail because this means an invalid xml document is being inserted
          */
         public void invalidXMLCharactersTest() {
         public void invalidXMLCharacters201Test() {
         	debug("\nRunning: invalidXMLCharacters201Test");
             try {
                 newdocid = generateDocid();
                 String newdocid = generateDocid();
                 m.login(username, password);
                 testdocument = getTestEmlDoc("Checking > & <");
                 testdocument = getTestEmlDoc("Checking > & < in doc: " + newdocid, EML2_0_1);
                 insertDocid(newdocid + ".1", testdocument, FAILURE, true);
                 m.logout();
+            }
-...
                 fail("General exception:\n" + e.getMessage());
+            }
+        }
         /** *********
          * Test inserting document with &gt; &amp; &lt;
         /**
          * Test inserting an EML 2.1.0 document with > & <
          * should fail because this means an invalid xml document is being inserted
          */
         public void symbolEncodedFormatTest() {
         public void invalidXMLCharacters210Test() {
         	debug("\nRunning: invalidXMLCharacters210Test");
             try {
                 newdocid = generateDocid();
                 String newdocid = generateDocid();
                 m.login(username, password);
                 testdocument = getTestEmlDoc("Checking &gt; &lt; &quot; &apos; &amp;");
                 insertDocid(newdocid + ".1", testdocument, SUCCESS, false);
                 testdocument = getTestEmlDoc("Checking > & < in doc: " + newdocid, EML2_1_0);
                 insertDocid(newdocid + ".1", testdocument, FAILURE, true);
                 m.logout();
+            }
             catch (MetacatAuthException mae) {
                 fail("Authorization failed:\n" + mae.getMessage());
+            }
             catch (MetacatInaccessibleException mie) {
                 fail("Metacat Inaccessible:\n" + mie.getMessage());
+            }
             catch (Exception e) {
                 fail("General exception:\n" + e.getMessage());
+            }
+        }
         /**
          * Test inserting and reading an EML 2.0.1 document with &gt; &amp; &lt;
          * Read should succeed since the same document should be read
          * back from disk that was submitted. Query should succeed as
          * well because the characters in this test are not changed in
          * the database.
          */
         public void symbolEncodedFormat201Test() {
         	debug("\nRunning: symbolEncodedFormat201Test");
             try {
                 String newdocid = generateDocid();
                 m.login(username, password);
                 String testTitle =
                 	"Checking &gt; &lt; &quot; &apos; &amp; in doc: " + newdocid  + ".1";
                 testdocument = getTestEmlDoc(testTitle, EML2_0_1);
                 insertDocid(newdocid  + ".1", testdocument, SUCCESS, false);
                 // this tests reading the document back from disk
                 readDocidWhichEqualsDoc(newdocid, testdocument, SUCCESS, false);
                 // this tests searching for the document in the database
                 Thread.sleep(3000);
                 queryDocWhichHasTitle(newdocid  + ".1", testTitle, EML2_0_1, SUCCESS);
                 m.logout();
+            }
             catch (MetacatAuthException mae) {
-...
                 fail("General exception:\n" + e.getMessage());
+            }
+        }
         /**
          * Test inserting and reading an EML 2.1.0 document with &gt; &amp; &lt;
          * Read should succeed since the same document should be read
          * back from disk that was submitted. Query should succeed as
          * well because the characters in this test are not changed in
          * the database.
          */
         public void symbolEncodedFormat210Test() {
         	debug("\nRunning: symbolEncodedFormat210Test");
             try {
                 String newdocid = generateDocid();
                 m.login(username, password);
                 String testTitle =
                 	"Checking &gt; &lt; &quot; &apos; &amp; in doc: " + newdocid + ".1";
                 testdocument = getTestEmlDoc(testTitle, EML2_1_0);
                 insertDocid(newdocid  + ".1", testdocument, SUCCESS, false);
                 // this tests reading the document back from disk
                 readDocidWhichEqualsDoc(newdocid, testdocument, SUCCESS, false);
                 // this tests searching for the document in the database
                 Thread.sleep(3000);
                 queryDocWhichHasTitle(newdocid  + ".1", testTitle, EML2_1_0, SUCCESS);
                 m.logout();
+            }
             catch (MetacatAuthException mae) {
                 fail("Authorization failed:\n" + mae.getMessage());
+            }
             catch (MetacatInaccessibleException mie) {
                 fail("Metacat Inaccessible:\n" + mie.getMessage());
+            }
             catch (Exception e) {
                 fail("General exception:\n" + e.getMessage());
+            }
+        }
         /** *********
          * Test inserting document with single quote and double quote
          * should fail because this means an invalid xml document is being inserted
         /**
          * Test inserting and reading an EML 2.0.1 document with single quote and double quote.
          * Read should succeed since the same document should be read back from disk
          * that was submitted.  Query should succeed because we look for the converted
          * character (&apos; and &quot;).
          */
         public void quoteTest() {
         public void quote201Test() {
         	debug("\nRunning: quote201Test");
             try {
                 newdocid = generateDocid();
                 String newdocid = generateDocid();
                 m.login(username, password);
                 testdocument = getTestEmlDoc("Checking ' ` \"");
                 String testTitle = "Checking ' ` \" in doc: " + newdocid  + ".1";
                 String convertedTestTitle = "Checking &apos; ` &quot; in doc: " + newdocid  + ".1";
                 testdocument = getTestEmlDoc(testTitle, EML2_0_1);
                 insertDocid(newdocid + ".1", testdocument, SUCCESS, true);
                 testdocument = getTestEmlDoc("Checking &apos; ` &quot;");
                 // this tests reading the document back from disk
                 readDocidWhichEqualsDoc(newdocid, testdocument, SUCCESS, true);
                 // this tests searching for the document in the database
                 Thread.sleep(3000);
                 queryDocWhichHasTitle(newdocid  + ".1", convertedTestTitle, EML2_0_1, SUCCESS);
                 m.logout();
+            }
             catch (MetacatAuthException mae) {
-...
                 fail("General exception:\n" + e.getMessage());
+            }
+        }
         /**
          * Test inserting and reading an EML 2.1.0 document with single quote and double quote.
          * Read should succeed since the same document should be read back from disk
          * that was submitted.  Query shoud succeed because we look for the converted
          * character (&apos; and &quot;).
          */
         public void quote210Test() {
         	debug("\nRunning: quote210Test");
             try {
                 String newdocid = generateDocid();
                 m.login(username, password);
                 String testTitle = "Checking ' ` \" in doc: " + newdocid  + ".1";
                 String convertedTestTitle = "Checking &apos; ` &quot; in doc: " + newdocid  + ".1";
                 testdocument = getTestEmlDoc(testTitle, EML2_1_0);
                 insertDocid(newdocid + ".1", testdocument, SUCCESS, true);
                 // this tests reading the document back from disk
                 readDocidWhichEqualsDoc(newdocid, testdocument, SUCCESS, true);
                 // this tests searching for the document in the database
                 Thread.sleep(3000);
                 queryDocWhichHasTitle(newdocid  + ".1", convertedTestTitle, EML2_1_0, SUCCESS);
                 m.logout();
+            }
             catch (MetacatAuthException mae) {
                 fail("Authorization failed:\n" + mae.getMessage());
+            }
             catch (MetacatInaccessibleException mie) {
                 fail("Metacat Inaccessible:\n" + mie.getMessage());
+            }
             catch (Exception e) {
                 fail("General exception:\n" + e.getMessage());
+            }
+        }
         /**
          * Test inserting and reading an EML 2.0.1 document with the code representation
          * of a micro sign (&#181). Read should succeed since the same document should be
          * read back from disk that was submitted.  Query should succeed because we look
          * for the converted character (µ).
          */
         public void numericCharacterReferenceFormat201Test() {
         	debug("\nRunning: numericCharacterReferenceFormat201Test");
             try {
                 String newdocid = generateDocid();
                 m.login(username, password);
                 String testTitle = "Checking &#181; in doc: " + newdocid  + ".1";
                 String convertedTestTitle = "Checking µ in doc: " + newdocid  + ".1";
                 testdocument = getTestEmlDoc(testTitle, EML2_0_1);
                 insertDocid(newdocid + ".1", testdocument, SUCCESS, true);
                 // this tests reading the document back from disk
                 readDocidWhichEqualsDoc(newdocid, testdocument, SUCCESS, true);
                 // this tests searching for the document in the database
                 Thread.sleep(3000);
                 queryDocWhichHasTitle(newdocid  + ".1", convertedTestTitle, EML2_0_1, SUCCESS);
                 m.logout();
+            }
             catch (MetacatAuthException mae) {
                 fail("Authorization failed:\n" + mae.getMessage());
+            }
             catch (MetacatInaccessibleException mie) {
                 fail("Metacat Inaccessible:\n" + mie.getMessage());
+            }
             catch (Exception e) {
                 fail("General exception:\n" + e.getMessage());
+            }
+        }
         /** *********
          * Test inserting document with micro sign
          * should fail because this means an invalid xml document is being inserted
         /**
          * Test inserting and reading an EML 2.1.0 document with the code representation
          * of a micro sign (&#181). Read should succeed since the same document should be
          * read back from disk that was submitted.  Query should succeed because we look
          * for the converted character (µ).
          */
         public void numericCharacterReferenceFormatTest() {
         public void numericCharacterReferenceFormat210Test() {
         	debug("\nRunning: numericCharacterReferenceFormat210Test");
             try {
                 newdocid = generateDocid();
                 String newdocid = generateDocid();
                 m.login(username, password);
                 testdocument = getTestEmlDoc("Checking &#181;");
                 String testTitle = "Checking &#181; in doc: " + newdocid  + ".1";
                 String convertedTestTitle = "Checking µ in doc: " + newdocid  + ".1";
                 testdocument = getTestEmlDoc(testTitle, EML2_1_0);
                 insertDocid(newdocid + ".1", testdocument, SUCCESS, true);
                 testdocument = getTestEmlDoc("Checking µ");
                 // this tests reading the document back from disk
                 readDocidWhichEqualsDoc(newdocid, testdocument, SUCCESS, true);
                 // this tests searching for the document in the database
                 Thread.sleep(3000);
                 queryDocWhichHasTitle(newdocid  + ".1", convertedTestTitle, EML2_1_0, SUCCESS);
                 m.logout();
+            }
             catch (MetacatAuthException mae) {
-...
+            }
+        }
         /** *********
          * Test inserting document with characters like µ
          * should fail because this means an invalid xml document is being inserted
         /**
          * Test inserting and reading an EML 2.0.1 document with the micro sign (µ).
          * Read should succeed since the same document should be read back from disk
          * that was submitted.  Query should succeed because we look for the same
          * character (µ).
          */
         public void nonLatinUnicodeCharacterTest() {
         public void nonLatinUnicodeCharacter201Test() {
         	debug("\nRunning: nonLatinUnicodeCharacter201Test");
             try {
                 newdocid = generateDocid();
                 String newdocid = generateDocid();
                 m.login(username, password);
                 testdocument = getTestEmlDoc("Checking charcters like µ");
                 String testTitle = "Checking characters like µ in doc: " + newdocid  + ".1";
                 testdocument = getTestEmlDoc(testTitle, EML2_0_1);
                 insertDocid(newdocid + ".1", testdocument, SUCCESS, false);
                 //testdocument = getTestEmlDoc("Checking charcters like &#181;");
                 // this tests reading the document back from disk
                 readDocidWhichEqualsDoc(newdocid, testdocument, SUCCESS, true);
                 // this tests searching for the document in the database
                 Thread.sleep(3000);
                 queryDocWhichHasTitle(newdocid  + ".1", testTitle, EML2_0_1, SUCCESS);
                 m.logout();
+            }
             catch (MetacatAuthException mae) {
-...
                 fail("General exception:\n" + e.getMessage());
+            }
+        }
         /**
          * Test inserting and reading an EML 2.1.0 document with the micro sign (µ).
          * Read should succeed since the same document should be read back from disk
          * that was submitted.  Query should succeed because we look for the same
          * character (µ).
          */
         public void nonLatinUnicodeCharacter210Test() {
         	debug("\nRunning: nonLatinUnicodeCharacter210Test");
             try {
                 String newdocid = generateDocid();
                 m.login(username, password);
                 String testTitle = "Checking characters like µ in doc: " + newdocid  + ".1";
                 testdocument = getTestEmlDoc(testTitle, EML2_1_0);
                 insertDocid(newdocid + ".1", testdocument, SUCCESS, false);
                 // this tests reading the document back from disk
                 readDocidWhichEqualsDoc(newdocid, testdocument, SUCCESS, true);
                 // this tests searching for the document in the database
                 Thread.sleep(3000);
                 queryDocWhichHasTitle(newdocid  + ".1", testTitle, EML2_1_0, SUCCESS);
                 m.logout();
+            }
             catch (MetacatAuthException mae) {
                 fail("Authorization failed:\n" + mae.getMessage());
+            }
             catch (MetacatInaccessibleException mie) {
                 fail("Metacat Inaccessible:\n" + mie.getMessage());
+            }
             catch (Exception e) {
                 fail("General exception:\n" + e.getMessage());
+            }
+        }
         /**
          * Insert a document into metacat. The expected result is passed as result
          */
         private String insertDocid(String docid, String docText, boolean result,
                                    boolean expectMetacatException) {
             String response = null;
-...
         /**
          * Insert a document into metacat. The expected result is passed as result
          */
         private String uploadDocid(String docid, String filePath, boolean result,
                                    boolean expectedKarmaException) {
             String response = null;
-...
+        }
         /**
          * Delete a document into metacat. The expected result is passed as result
          * Delete a document from metacat. The expected result is passed as result
          */
         private void deleteDocid(String docid, boolean result,
                                  boolean expextedKarmaFailure) {
-...
          * Read a document from metacat and check if it is equal to a given string.
          * The expected result is passed as result
          */
         private void readDocidWhichEqualsDoc(String docid, String testDoc,
                                              boolean result,
                                              boolean expextedKarmaFailure) {
                                              boolean expectedKarmaFailure) {
             try {
                 Reader r = m.read(docid);
                 String doc = IOUtil.getAsString(r, true);
-...
                 fail("Metacat Inaccessible:\n" + mie.getMessage());
+            }
             catch (InsufficientKarmaException ike) {
                 if (!expextedKarmaFailure) {
                 if (!expectedKarmaFailure) {
                     fail("Insufficient karma:\n" + ike.getMessage());
+                }
+            }
-...
+            }
+        }
         /**
          * Query a document by looking for it's doc id in the title element.
          * Then check if the testTitle exists in the doc.
          * @param docId the id of the doc to look for
          * @param testTitle the title containing special characters
          * @param result are we expecting SUCCESS or FAILURE
          * @param expextedKarmaFailure
          */
         private void queryDocWhichHasTitle(String docId, String testTitle,
                                              String emlVersion, boolean result) {
             try {
                 String sQuery = getTestEmlQuery(docId, emlVersion);
             	debug("sQuery: " + sQuery);
             	Reader queryReader = new StringReader(sQuery);
                 Reader resultReader = m.query(queryReader);
                 String queryResult = IOUtil.getAsString(resultReader, true);
                 if (result) {
                     if (!queryResult.contains(testTitle)) {
                         System.out.println("queryResult: " + queryResult);
                         System.out.println("does not contain title: " + testTitle);
+                    }
                     assertTrue(queryResult.contains(testTitle));
+                }
                 else {
                     assertTrue(queryResult.indexOf("<error>") != -1);
+                }
+            }
             catch (MetacatInaccessibleException mie) {
                 fail("Metacat Inaccessible:\n" + mie.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.

Also available in: Unified diff

Project

General

Profile

Metacat

Revision 4356

Added by daigle over 15 years ago