Revision 5284
Added by Matt Jones about 14 years ago
| MetacatRestClientTest.java | ||
|---|---|---|
| 22 | 22 |
*/ |
| 23 | 23 |
package edu.ucsb.nceas.metacattest.restservice; |
| 24 | 24 |
|
| 25 |
import java.io.FileReader; |
|
| 26 | 25 |
import java.io.IOException; |
| 27 | 26 |
import java.io.Reader; |
| 28 |
import java.util.Calendar; |
|
| 29 |
import java.util.Date; |
|
| 30 |
import java.util.GregorianCalendar; |
|
| 31 |
import java.util.SimpleTimeZone; |
|
| 32 |
import java.util.TimeZone; |
|
| 27 |
import java.io.StringReader; |
|
| 33 | 28 |
import java.util.Vector; |
| 34 | 29 |
|
| 35 | 30 |
import junit.framework.Test; |
| 36 | 31 |
import junit.framework.TestSuite; |
| 37 | 32 |
import edu.ucsb.nceas.MCTestCase; |
| 33 |
import edu.ucsb.nceas.metacat.IdentifierManager; |
|
| 38 | 34 |
import edu.ucsb.nceas.metacat.client.DocumentNotFoundException; |
| 35 |
import edu.ucsb.nceas.metacat.client.InsufficientKarmaException; |
|
| 39 | 36 |
import edu.ucsb.nceas.metacat.client.MetacatAuthException; |
| 40 | 37 |
import edu.ucsb.nceas.metacat.client.MetacatException; |
| 41 | 38 |
import edu.ucsb.nceas.metacat.client.MetacatInaccessibleException; |
| ... | ... | |
| 63 | 60 |
} |
| 64 | 61 |
} |
| 65 | 62 |
|
| 66 |
|
|
| 67 |
|
|
| 68 | 63 |
private String failpass = "sdfsdfsdfsd"; |
| 69 |
private String prefix = "test"; |
|
| 70 |
private String newdocid = null; |
|
| 71 |
private String testfile = "test/jones.204.22.xml"; |
|
| 72 |
private String onlinetestdatafile = "test/onlineDataFile1"; |
|
| 73 |
private String queryFile = "test/query.xml"; |
|
| 74 |
private String testdocument = ""; |
|
| 75 | 64 |
private MetacatRest m; |
| 76 |
private String spatialTestFile = "test/spatialEml.xml"; |
|
| 77 |
private static final int TIME = 30; |
|
| 78 |
private static final String DOCID = "docid"; |
|
| 79 |
private static final String DATAID = "dataid"; |
|
| 65 |
private static final String DOC_TITLE = "Test MetacatRest service"; |
|
| 80 | 66 |
|
| 81 |
private static final String public_doc_id = "doi:12345.5/playing/in/dirt/rev1"; |
|
| 82 |
private static final String authorized_doc_id = "serhan.4.2"; |
|
| 83 |
private static final String notexisting_doc_id = "serhan.1.1"; |
|
| 84 |
private static final String ecogridQueryFile= "test/restfiles/ecogrid_query.xml"; |
|
| 85 |
|
|
| 86 |
|
|
| 87 |
private static final String insert_file = "test/restfiles/knb-lter-gce.109.6.xml"; |
|
| 88 |
|
|
| 89 |
|
|
| 90 | 67 |
/** |
| 91 | 68 |
* Constructor to build the test |
| 92 | 69 |
* |
| ... | ... | |
| 95 | 72 |
public MetacatRestClientTest(String name) |
| 96 | 73 |
{
|
| 97 | 74 |
super(name); |
| 98 |
newdocid = generateDocid(); |
|
| 99 | 75 |
} |
| 100 | 76 |
|
| 101 | 77 |
/** |
| ... | ... | |
| 103 | 79 |
*/ |
| 104 | 80 |
public void setUp() |
| 105 | 81 |
{
|
| 106 |
try {
|
|
| 107 |
FileReader fr = new FileReader(testfile); |
|
| 108 |
testdocument = IOUtil.getAsString(fr, true); |
|
| 109 |
} catch (IOException ioe) {
|
|
| 110 |
fail("Can't read test data to run the test: " + testfile);
|
|
| 111 |
} |
|
| 112 |
|
|
| 113 | 82 |
m = new MetacatRestClient(contextUrl); |
| 114 | 83 |
} |
| 115 | 84 |
|
| ... | ... | |
| 131 | 100 |
suite.addTest(new MetacatRestClientTest("login"));
|
| 132 | 101 |
suite.addTest(new MetacatRestClientTest("logout"));
|
| 133 | 102 |
suite.addTest(new MetacatRestClientTest("get"));
|
| 103 |
suite.addTest(new MetacatRestClientTest("invalidGet"));
|
|
| 134 | 104 |
suite.addTest(new MetacatRestClientTest("getPrivate"));
|
| 135 |
suite.addTest(new MetacatRestClientTest("invalidGet"));
|
|
| 136 | 105 |
suite.addTest(new MetacatRestClientTest("authenticatedGet"));
|
| 137 | 106 |
suite.addTest(new MetacatRestClientTest("query"));
|
| 138 |
suite.addTest(new MetacatRestClientTest("authenticatedQuery"));
|
|
| 107 |
suite.addTest(new MetacatRestClientTest("authenticatedQuery"));
|
|
| 139 | 108 |
suite.addTest(new MetacatRestClientTest("crud"));
|
| 140 | 109 |
suite.addTest(new MetacatRestClientTest("getNextObject"));
|
| 141 | 110 |
suite.addTest(new MetacatRestClientTest("getNextRevision"));
|
| ... | ... | |
| 150 | 119 |
* Run an initial test that always passes to check that the test |
| 151 | 120 |
* harness is working. |
| 152 | 121 |
*/ |
| 153 |
public void initialize() {
|
|
| 122 |
public void initialize() |
|
| 123 |
{
|
|
| 154 | 124 |
assertTrue(1 == 1); |
| 155 | 125 |
} |
| 156 | 126 |
|
| ... | ... | |
| 192 | 162 |
fail("Authorization should have failed.");
|
| 193 | 163 |
} catch (MetacatAuthException mae) {
|
| 194 | 164 |
debug("invalid login(): response=" + mae.getMessage());
|
| 195 |
//assertTrue(1 == 1);
|
|
| 165 |
assertNotNull(mae);
|
|
| 196 | 166 |
} catch (MetacatInaccessibleException mie) {
|
| 197 | 167 |
fail("Metacat Inaccessible:\n" + mie.getMessage());
|
| 198 | 168 |
} |
| ... | ... | |
| 231 | 201 |
public void get() |
| 232 | 202 |
{
|
| 233 | 203 |
debug("\nStarting get test...");
|
| 234 |
debug("-------------------------------------------------------");
|
|
| 204 |
debug("-------------------------------------------------------");
|
|
| 235 | 205 |
try {
|
| 236 |
Reader r = m.getObject(public_doc_id, null); |
|
| 206 |
IdentifierManager im = IdentifierManager.getInstance(); |
|
| 207 |
String docid = insertTestDocument(); |
|
| 208 |
String guid = "test:"+docid; |
|
| 209 |
im.createMapping(guid, docid); |
|
| 210 |
Reader r = m.getObject(guid, null); |
|
| 237 | 211 |
String doc = IOUtil.getAsString(r, true); |
| 238 | 212 |
doc = doc +"\n"; |
| 239 | 213 |
debug("document:\n"+doc);
|
| 214 |
assertTrue(doc.indexOf(DOC_TITLE) != -1); |
|
| 240 | 215 |
} catch (MetacatInaccessibleException mie) {
|
| 241 |
debug("Metacat Inaccessible:\n" + mie.getMessage());
|
|
| 216 |
fail("Metacat Inaccessible:\n" + mie.getMessage());
|
|
| 242 | 217 |
} catch (Exception e) {
|
| 243 |
e.printStackTrace(); |
|
| 244 |
debug("General exception:\n" + e.getMessage());
|
|
| 218 |
fail("General exception:\n" + e.getMessage());
|
|
| 245 | 219 |
} |
| 246 | 220 |
} |
| 247 | 221 |
|
| ... | ... | |
| 250 | 224 |
*/ |
| 251 | 225 |
public void getPrivate() |
| 252 | 226 |
{
|
| 227 |
assertTrue("Not implemented yet.", 1==1);
|
|
| 228 |
/* |
|
| 253 | 229 |
debug("\nStarting getprivate test...");
|
| 254 | 230 |
debug("-------------------------------------------------------");
|
| 255 | 231 |
try {
|
| ... | ... | |
| 258 | 234 |
doc = doc +"\n"; |
| 259 | 235 |
debug("document:\n"+doc);
|
| 260 | 236 |
} catch (MetacatInaccessibleException mie) {
|
| 261 |
debug("Metacat Inaccessible:\n" + mie.getMessage());
|
|
| 237 |
fail("Metacat Inaccessible:\n" + mie.getMessage());
|
|
| 262 | 238 |
} catch (Exception e) {
|
| 263 |
debug("General exception:\n" + e.getMessage());
|
|
| 239 |
fail("General exception:\n" + e.getMessage());
|
|
| 264 | 240 |
} |
| 241 |
*/ |
|
| 265 | 242 |
} |
| 266 | 243 |
|
| 267 | 244 |
/** |
| ... | ... | |
| 269 | 246 |
*/ |
| 270 | 247 |
public void authenticatedGet() |
| 271 | 248 |
{
|
| 249 |
assertTrue("Not implemented yet.", 1==1);
|
|
| 250 |
/* |
|
| 272 | 251 |
debug("\nStarting authorizedGet test...");
|
| 273 | 252 |
debug("-------------------------------------------------------");
|
| 274 | 253 |
try {
|
| ... | ... | |
| 282 | 261 |
} catch (Exception e) {
|
| 283 | 262 |
debug("General exception:\n" + e.getMessage());
|
| 284 | 263 |
} |
| 264 |
*/ |
|
| 285 | 265 |
} |
| 286 | 266 |
|
| 287 | 267 |
/** |
| ... | ... | |
| 292 | 272 |
debug("\nStarting invalid get test ...");
|
| 293 | 273 |
debug("-------------------------------------------------------");
|
| 294 | 274 |
try {
|
| 295 |
Reader r = m.getObject(notexisting_doc_id, null); |
|
| 275 |
String unregDocid = generateDocumentId() + ".1"; |
|
| 276 |
Reader r = m.getObject(unregDocid, null); |
|
| 296 | 277 |
String doc = IOUtil.getAsString(r, true); |
| 297 | 278 |
doc = doc +"\n"; |
| 298 | 279 |
debug("document:\n"+doc);
|
| 280 |
assertTrue(doc.indexOf("<error>") != -1);
|
|
| 299 | 281 |
} catch (MetacatInaccessibleException mie) {
|
| 300 | 282 |
debug("Metacat Inaccessible:\n" + mie.getMessage());
|
| 301 | 283 |
} catch (DocumentNotFoundException doe) {
|
| ... | ... | |
| 309 | 291 |
/** |
| 310 | 292 |
* Test the query() function with a public session |
| 311 | 293 |
*/ |
| 312 |
public void query(){
|
|
| 294 |
public void query() |
|
| 295 |
{
|
|
| 296 |
assertTrue("Not implemented yet.", 1==1);
|
|
| 297 |
/* |
|
| 313 | 298 |
debug("\nStarting query test ...");
|
| 314 | 299 |
debug("-------------------------------------------------------");
|
| 315 | 300 |
try {
|
| ... | ... | |
| 325 | 310 |
e.printStackTrace(); |
| 326 | 311 |
fail("General exception:\n" + e.getMessage());
|
| 327 | 312 |
} |
| 313 |
*/ |
|
| 328 | 314 |
} |
| 329 | 315 |
|
| 330 | 316 |
|
| ... | ... | |
| 332 | 318 |
/** |
| 333 | 319 |
* Test the authenticatedQuery() function |
| 334 | 320 |
*/ |
| 335 |
public void authenticatedQuery(){
|
|
| 321 |
public void authenticatedQuery() |
|
| 322 |
{
|
|
| 323 |
assertTrue("Not implemented yet.", 1==1);
|
|
| 324 |
/* |
|
| 336 | 325 |
debug("\nStarting authenticatedQuery test ...");
|
| 337 | 326 |
debug("-------------------------------------------------------");
|
| 338 | 327 |
try {
|
| ... | ... | |
| 351 | 340 |
e.printStackTrace(); |
| 352 | 341 |
fail("General exception:\n" + e.getMessage());
|
| 353 | 342 |
} |
| 343 |
*/ |
|
| 354 | 344 |
} |
| 355 | 345 |
|
| 356 | 346 |
/** |
| 357 | 347 |
* Test the insert,update and delete function |
| 358 | 348 |
*/ |
| 359 |
public void crud(){
|
|
| 349 |
public void crud() |
|
| 350 |
{
|
|
| 360 | 351 |
debug("\nStarting insert,update,delete document test ...");
|
| 361 | 352 |
debug("-------------------------------------------------------");
|
| 362 | 353 |
try {
|
| 363 |
FileReader fr = new FileReader(insert_file); |
|
| 354 |
String accessBlock = getAccessBlock("public", true, true,
|
|
| 355 |
false, false, false); |
|
| 356 |
String emldoc = getTestEmlDoc("Test MetacatRest service", EML2_1_0, null,
|
|
| 357 |
null, "http://fake.example.com/somedata", null, |
|
| 358 |
accessBlock, null, null, |
|
| 359 |
null, null); |
|
| 360 |
String docid = generateDocumentId(); |
|
| 361 |
|
|
| 362 |
StringReader sr = new StringReader(emldoc); |
|
| 364 | 363 |
m.login(username,password); |
| 365 | 364 |
|
| 366 | 365 |
debug("\nFirst insert the document...");
|
| 367 |
String response = m.putObject(newdocid+".1",fr,true); |
|
| 366 |
String response = m.putObject(docid + ".1",sr,true); |
|
| 367 |
sr.close(); |
|
| 368 | 368 |
debug("response:\n"+response);
|
| 369 |
|
|
| 370 |
fr = new FileReader(insert_file); |
|
| 369 |
assertTrue(response.indexOf("success") != -1);
|
|
| 370 |
|
|
| 371 |
sr = new StringReader(emldoc); |
|
| 371 | 372 |
debug("\nNow update the document...");
|
| 372 |
response = m.putObject(newdocid+".2",fr,false); |
|
| 373 |
debug("response:\n"+response);
|
|
| 374 |
fr.close(); |
|
| 373 |
response = m.putObject(docid + ".2",sr,false); |
|
| 374 |
debug("response:\n"+response);
|
|
| 375 |
assertTrue(response.indexOf("success") != -1);
|
|
| 376 |
sr.close(); |
|
| 375 | 377 |
|
| 376 | 378 |
Thread.sleep(10000); |
| 377 | 379 |
|
| 378 | 380 |
debug("\nFinally delete the document...");
|
| 379 |
response = m.deleteObject(newdocid+".2");
|
|
| 381 |
response = m.deleteObject(docid + ".2");
|
|
| 380 | 382 |
debug("response:\n"+response);
|
| 383 |
assertTrue(response.indexOf("success") != -1);
|
|
| 381 | 384 |
|
| 382 |
|
|
| 383 | 385 |
} catch (MetacatAuthException mae) {
|
| 384 |
debug("Authorization failed:\n" + mae.getMessage());
|
|
| 386 |
fail("Authorization failed:\n" + mae.getMessage());
|
|
| 385 | 387 |
} catch (MetacatInaccessibleException mie) {
|
| 386 |
debug("Metacat Inaccessible:\n" + mie.getMessage());
|
|
| 388 |
fail("Metacat Inaccessible:\n" + mie.getMessage());
|
|
| 387 | 389 |
} catch (Exception e) {
|
| 388 |
e.printStackTrace(); |
|
| 389 | 390 |
fail("General exception:\n" + e.getMessage());
|
| 390 | 391 |
} |
| 391 | 392 |
} |
| ... | ... | |
| 396 | 397 |
* that it matches the one we last inserted. Assumes this test is run |
| 397 | 398 |
* immediately following a successful insert() test. |
| 398 | 399 |
*/ |
| 399 |
public void getNextObject() {
|
|
| 400 |
public void getNextObject() |
|
| 401 |
{
|
|
| 400 | 402 |
debug("\nStarting getNextObject test...");
|
| 401 | 403 |
debug("-------------------------------------------------------");
|
| 402 | 404 |
try {
|
| ... | ... | |
| 412 | 414 |
} |
| 413 | 415 |
|
| 414 | 416 |
/** |
| 415 |
* Get the most recent document id for a given scope and be sure |
|
| 416 |
* that it matches the one we last inserted. Assumes this test is run |
|
| 417 |
* Get the next revision for a given id. Assumes this test is run |
|
| 417 | 418 |
* immediately following a successful insert() test. |
| 418 | 419 |
*/ |
| 419 |
public void getNextRevision() {
|
|
| 420 |
public void getNextRevision() |
|
| 421 |
{
|
|
| 420 | 422 |
debug("\nStarting getNextRevision test...");
|
| 421 | 423 |
debug("-------------------------------------------------------");
|
| 422 | 424 |
try {
|
| 423 |
|
|
| 424 |
int rev_id = m.getNextRevision(public_doc_id); |
|
| 425 |
IdentifierManager im = IdentifierManager.getInstance(); |
|
| 426 |
String docid = insertTestDocument(); |
|
| 427 |
int rev_id = m.getNextRevision(docid); |
|
| 425 | 428 |
debug("NextRevision number is " + rev_id);
|
| 426 | 429 |
|
| 427 | 430 |
} catch (MetacatException me) {
|
| ... | ... | |
| 435 | 438 |
/** |
| 436 | 439 |
* Test getAllDocids function |
| 437 | 440 |
*/ |
| 438 |
public void getAllDocids() {
|
|
| 441 |
public void getAllDocids() |
|
| 442 |
{
|
|
| 439 | 443 |
debug("\nStarting getAllDocids test...");
|
| 440 | 444 |
debug("-------------------------------------------------------");
|
| 441 | 445 |
try {
|
| ... | ... | |
| 453 | 457 |
} |
| 454 | 458 |
} |
| 455 | 459 |
|
| 456 |
/***
|
|
| 460 |
/** |
|
| 457 | 461 |
* Test isRegistered function |
| 458 | 462 |
*/ |
| 459 |
public void isRegistered() {
|
|
| 463 |
public void isRegistered() |
|
| 464 |
{
|
|
| 460 | 465 |
debug("\nStarting isRegistered test...");
|
| 461 | 466 |
debug("-------------------------------------------------------");
|
| 462 | 467 |
try {
|
| 463 |
boolean registered = m.isRegistered(public_doc_id); |
|
| 464 |
debug("isRegistered(): " + public_doc_id+" is "+(registered?"":"not ")+"registered");
|
|
| 465 |
registered = m.isRegistered(newdocid); |
|
| 466 |
debug("isRegistered(): " + newdocid+" is "+(registered?"":"not ")+"registered");
|
|
| 468 |
IdentifierManager im = IdentifierManager.getInstance(); |
|
| 469 |
String docid = insertTestDocument(); |
|
| 470 |
boolean registered = m.isRegistered(docid); |
|
| 471 |
debug("isRegistered(): " + docid + ".1" +" is "+(registered?"":"not ")+"registered");
|
|
| 472 |
assertTrue(registered); |
|
| 473 |
String unregDocid = generateDocumentId() + ".1"; |
|
| 474 |
registered = m.isRegistered(unregDocid); |
|
| 475 |
debug("isRegistered(): " + unregDocid+" is "+(registered?"":"not ")+"registered");
|
|
| 476 |
assertFalse(registered); |
|
| 467 | 477 |
} catch (MetacatException me) {
|
| 468 | 478 |
fail("Metacat Error:\n" + me.getMessage());
|
| 469 | 479 |
} catch (Exception e) {
|
| ... | ... | |
| 471 | 481 |
} |
| 472 | 482 |
} |
| 473 | 483 |
|
| 474 |
/***
|
|
| 484 |
/** |
|
| 475 | 485 |
* Test addLSID function |
| 476 | 486 |
*/ |
| 477 |
public void addLSID() {
|
|
| 487 |
public void addLSID() |
|
| 488 |
{
|
|
| 478 | 489 |
debug("\nStarting addLSID test...");
|
| 479 | 490 |
debug("-------------------------------------------------------");
|
| 480 | 491 |
try {
|
| 481 |
String response = m.addLSID(public_doc_id); |
|
| 492 |
String unregDocid = generateDocumentId() + ".1"; |
|
| 493 |
String response = m.addLSID(unregDocid); |
|
| 482 | 494 |
debug("response:\n"+response);
|
| 483 | 495 |
} catch (MetacatException me) {
|
| 484 | 496 |
fail("Metacat Error:\n" + me.getMessage());
|
| ... | ... | |
| 486 | 498 |
fail("General exception:\n" + e.getMessage());
|
| 487 | 499 |
} |
| 488 | 500 |
} |
| 489 |
|
|
| 490 |
|
|
| 491 |
/** |
|
| 492 |
* Create a hopefully unique docid for testing insert and update. Does |
|
| 493 |
* not include the 'revision' part of the id. |
|
| 494 |
* |
|
| 495 |
* @return a String docid based on the current date and time |
|
| 496 |
*/ |
|
| 497 |
private String generateDocid() |
|
| 501 |
|
|
| 502 |
/** Insert a test document, returning the docid that was used. */ |
|
| 503 |
private String insertTestDocument() |
|
| 498 | 504 |
{
|
| 499 |
StringBuffer docid = new StringBuffer(prefix); |
|
| 500 |
docid.append(".");
|
|
| 501 |
|
|
| 502 |
// Create a calendar to get the date formatted properly |
|
| 503 |
String[] ids = TimeZone.getAvailableIDs(-8 * 60 * 60 * 1000); |
|
| 504 |
SimpleTimeZone pdt = new SimpleTimeZone(-8 * 60 * 60 * 1000, ids[0]); |
|
| 505 |
pdt.setStartRule(Calendar.APRIL, 1, Calendar.SUNDAY, 2*60*60*1000); |
|
| 506 |
pdt.setEndRule(Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*60*60*1000); |
|
| 507 |
Calendar calendar = new GregorianCalendar(pdt); |
|
| 508 |
Date trialTime = new Date(); |
|
| 509 |
calendar.setTime(trialTime); |
|
| 510 |
|
|
| 511 |
int time = 0; |
|
| 512 |
|
|
| 513 |
docid.append(calendar.get(Calendar.YEAR)); |
|
| 514 |
|
|
| 515 |
time = calendar.get(Calendar.DAY_OF_YEAR); |
|
| 516 |
if(time < 10){
|
|
| 517 |
docid.append("0");
|
|
| 518 |
docid.append("0");
|
|
| 519 |
docid.append(time); |
|
| 520 |
} else if(time < 100) {
|
|
| 521 |
docid.append("0");
|
|
| 522 |
docid.append(time); |
|
| 523 |
} else {
|
|
| 524 |
docid.append(time); |
|
| 525 |
} |
|
| 526 |
|
|
| 527 |
time = calendar.get(Calendar.HOUR_OF_DAY); |
|
| 528 |
if(time < 10){
|
|
| 529 |
docid.append("0");
|
|
| 530 |
docid.append(time); |
|
| 531 |
} else {
|
|
| 532 |
docid.append(time); |
|
| 533 |
} |
|
| 534 |
|
|
| 535 |
time = calendar.get(Calendar.MINUTE); |
|
| 536 |
if(time < 10){
|
|
| 537 |
docid.append("0");
|
|
| 538 |
docid.append(time); |
|
| 539 |
} else {
|
|
| 540 |
docid.append(time); |
|
| 541 |
} |
|
| 542 |
|
|
| 543 |
time = calendar.get(Calendar.SECOND); |
|
| 544 |
if(time < 10){
|
|
| 545 |
docid.append("0");
|
|
| 546 |
docid.append(time); |
|
| 547 |
} else {
|
|
| 548 |
docid.append(time); |
|
| 549 |
} |
|
| 550 |
|
|
| 551 |
//sometimes this number is not unique, so we append a random number |
|
| 552 |
int random = (new Double(Math.random()*100)).intValue(); |
|
| 553 |
docid.append(random); |
|
| 554 |
return docid.toString(); |
|
| 505 |
String accessBlock = getAccessBlock("public", true, true,
|
|
| 506 |
false, false, false); |
|
| 507 |
String emldoc = getTestEmlDoc(DOC_TITLE, EML2_1_0, null, |
|
| 508 |
null, "http://fake.example.com/somedata", null, |
|
| 509 |
accessBlock, null, null, |
|
| 510 |
null, null); |
|
| 511 |
String docid = generateDocumentId() + ".1"; |
|
| 512 |
StringReader sr = new StringReader(emldoc); |
|
| 513 |
String response; |
|
| 514 |
try {
|
|
| 515 |
m.login(username,password); |
|
| 516 |
response = m.putObject(docid,sr,true); |
|
| 517 |
debug("response:\n"+response);
|
|
| 518 |
assertTrue(response.indexOf("success") != -1);
|
|
| 519 |
} catch (InsufficientKarmaException e) {
|
|
| 520 |
fail(e.getMessage()); |
|
| 521 |
} catch (MetacatException e) {
|
|
| 522 |
fail(e.getMessage()); |
|
| 523 |
} catch (IOException e) {
|
|
| 524 |
fail(e.getMessage()); |
|
| 525 |
} catch (MetacatInaccessibleException e) {
|
|
| 526 |
fail(e.getMessage()); |
|
| 527 |
} catch (MetacatAuthException e) {
|
|
| 528 |
fail(e.getMessage()); |
|
| 529 |
} |
|
| 530 |
return docid; |
|
| 555 | 531 |
} |
| 556 | 532 |
} |
Also available in: Unified diff
Updated MetacatRestClientTest so that the tests are actually calling fail()
when errors occur, and fixed all sixteen tests so that they run successfully
and can be run from any client (i.e., they don't depend on particular
documents being present in Metacat). The 'restfiles' directory can probably
be removed now -- will need to check.