Project

General

Profile

1
/**
2
 *  '$RCSfile$'
3
 *  Copyright: 2010 Regents of the University of California and the
4
 *              National Center for Ecological Analysis and Synthesis
5
 *  Purpose: To test the Access Controls in metacat by JUnit
6
 *
7
 *   '$Author: tao $'
8
 *     '$Date: 2015-04-14 14:44:20 -0700 (Tue, 14 Apr 2015) $'
9
 * '$Revision: 9171 $'
10
 *
11
 * This program is free software; you can redistribute it and/or modify
12
 * it under the terms of the GNU General Public License as published by
13
 * the Free Software Foundation; either version 2 of the License, or
14
 * (at your option) any later version.
15
 *
16
 * This program is distributed in the hope that it will be useful,
17
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19
 * GNU General Public License for more details.
20
 *
21
 * You should have received a copy of the GNU General Public License
22
 * along with this program; if not, write to the Free Software
23
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
24
 */
25

    
26
package edu.ucsb.nceas.metacat.dataone;
27

    
28

    
29
import java.io.ByteArrayInputStream;
30
import java.io.InputStream;
31
import java.math.BigInteger;
32
import java.text.SimpleDateFormat;
33
import java.util.Calendar;
34
import java.util.Date;
35
import java.util.List;
36

    
37
import junit.framework.Test;
38
import junit.framework.TestSuite;
39

    
40
import org.apache.commons.io.IOUtils;
41
import org.dataone.client.v2.itk.D1Client;
42
import org.dataone.service.exceptions.BaseException;
43
import org.dataone.service.exceptions.InvalidRequest;
44
import org.dataone.service.exceptions.InvalidSystemMetadata;
45
import org.dataone.service.exceptions.NotAuthorized;
46
import org.dataone.service.exceptions.NotFound;
47
import org.dataone.service.exceptions.NotImplemented;
48
import org.dataone.service.exceptions.ServiceFailure;
49
import org.dataone.service.types.v1.AccessPolicy;
50
import org.dataone.service.types.v1.AccessRule;
51
import org.dataone.service.types.v1.Checksum;
52
import org.dataone.service.types.v1.DescribeResponse;
53
import org.dataone.service.types.v1.Event;
54
import org.dataone.service.types.v1.Identifier;
55
import org.dataone.service.types.v1.NodeReference;
56
import org.dataone.service.types.v1.NodeType;
57
import org.dataone.service.types.v1.ObjectFormatIdentifier;
58
import org.dataone.service.types.v1.ObjectList;
59
import org.dataone.service.types.v1.Permission;
60
import org.dataone.service.types.v1.Replica;
61
import org.dataone.service.types.v1.ReplicationPolicy;
62
import org.dataone.service.types.v1.ReplicationStatus;
63
import org.dataone.service.types.v1.Session;
64
import org.dataone.service.types.v1.Subject;
65
import org.dataone.service.types.v2.Log;
66
import org.dataone.service.types.v2.Node;
67
import org.dataone.service.types.v2.NodeList;
68
import org.dataone.service.types.v2.ObjectFormat;
69
import org.dataone.service.types.v2.ObjectFormatList;
70
import org.dataone.service.types.v2.OptionList;
71
import org.dataone.service.types.v2.SystemMetadata;
72
import org.dataone.service.util.Constants;
73

    
74
import edu.ucsb.nceas.metacat.dataone.CNodeService;
75
import edu.ucsb.nceas.metacat.dataone.MNodeService;
76

    
77
/**
78
 * A JUnit test for testing the dataone CNCore implementation
79
 */
80
public class CNodeServiceTest extends D1NodeServiceTest {   
81
    
82
    /**
83
    * constructor for the test
84
    */
85
    public CNodeServiceTest(String name)
86
    {
87
        super(name);
88
    }
89

    
90
	/**
91
	 * Create a suite of tests to be run together
92
	 */
93
	public static Test suite() 
94
	{
95
		TestSuite suite = new TestSuite();
96
		suite.addTest(new CNodeServiceTest("initialize"));
97
		
98
		suite.addTest(new CNodeServiceTest("testChecksum"));
99
		suite.addTest(new CNodeServiceTest("testCreate"));
100
		suite.addTest(new CNodeServiceTest("testGet"));
101
		suite.addTest(new CNodeServiceTest("testGetFormat"));
102
		suite.addTest(new CNodeServiceTest("testGetLogRecords"));
103
		suite.addTest(new CNodeServiceTest("testGetSystemMetadata"));
104
		suite.addTest(new CNodeServiceTest("testIsAuthorized"));
105
		suite.addTest(new CNodeServiceTest("testListFormats"));
106
		suite.addTest(new CNodeServiceTest("testListNodes"));
107
		suite.addTest(new CNodeServiceTest("testObjectFormatNotFoundException"));
108
		suite.addTest(new CNodeServiceTest("testRegisterSystemMetadata"));
109
		suite.addTest(new CNodeServiceTest("testReplicationPolicy"));
110
		suite.addTest(new CNodeServiceTest("testReplicationStatus"));
111
		suite.addTest(new CNodeServiceTest("testReserveIdentifier"));
112
		suite.addTest(new CNodeServiceTest("testSearch"));
113
		suite.addTest(new CNodeServiceTest("testSetAccessPolicy"));
114
		suite.addTest(new CNodeServiceTest("testSetOwner"));
115
		suite.addTest(new CNodeServiceTest("readDeletedObject"));
116
		suite.addTest(new CNodeServiceTest("testGetSID"));
117
		suite.addTest(new CNodeServiceTest("testListViews"));
118
		suite.addTest(new CNodeServiceTest("testUpdateSystemMetadata"));
119
	
120
		return suite;
121
	}
122
	
123
	
124
	/**
125
	 * test for registering standalone system metadata
126
	 */
127
	public Identifier testRegisterSystemMetadata() {
128
	    printTestHeader("testRegisterSystemMetadata");
129

    
130
	    try {
131
            Session session = getTestSession();
132
			Identifier guid = new Identifier();
133
			guid.setValue("testRegisterSystemMetadata." + System.currentTimeMillis());
134
			InputStream object = new ByteArrayInputStream("test".getBytes("UTF-8"));
135
			SystemMetadata sysmeta = createSystemMetadata(guid, session.getSubject(), object);
136
			Identifier retGuid = CNodeService.getInstance(request).registerSystemMetadata(session, guid, sysmeta);
137
			assertEquals(guid.getValue(), retGuid.getValue());
138
			return retGuid;
139
        } catch(Exception e) {
140
            fail("Unexpected error: " + e.getMessage());
141
        }
142
        return null;
143
	}
144
	
145
	/**
146
	 * test for getting system metadata
147
	 */
148
	public void testGetSystemMetadata() {
149
	    printTestHeader("testGetSystemMetadata");
150

    
151
	    try {
152
            Session session = getTestSession();
153
			Identifier guid = new Identifier();
154
			guid.setValue("testGetSystemMetadata." + System.currentTimeMillis());
155
			InputStream object = new ByteArrayInputStream("test".getBytes("UTF-8"));
156
			SystemMetadata sysmeta = createSystemMetadata(guid, session.getSubject(), object);
157
			Identifier retGuid = CNodeService.getInstance(request).registerSystemMetadata(session, guid, sysmeta);
158
			assertEquals(guid.getValue(), retGuid.getValue());
159
			// get it
160
			SystemMetadata retSysmeta = CNodeService.getInstance(request).getSystemMetadata(session, guid);
161
			// check it
162
			assertEquals(sysmeta.getIdentifier().getValue(), retSysmeta.getIdentifier().getValue());
163
        } catch(Exception e) {
164
            fail("Unexpected error: " + e.getMessage());
165
        }
166
	}
167
	
168
	public void testGetLogRecords() {
169
	    printTestHeader("testGetLogRecords");
170
	    try {
171

    
172
		    Session session = getTestSession();
173
		    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
174
		    Date fromDate = sdf.parse("2010-01-01");
175
		    Date toDate = new Date();
176
		    Event event = Event.CREATE;
177
		    int start = 0;
178
		    int count = 1;
179
	    
180
		    Log log = CNodeService.getInstance(request).getLogRecords(session, fromDate, toDate, 
181
		    	event.xmlValue(), null, start, count);
182
		    assertNotNull(log);
183
		    assertTrue(log.getCount() == count);
184
		    assertTrue(log.getStart() == start);
185
		    assertTrue(log.getTotal() > 0);
186
	    } catch (Exception e) {
187
		    e.printStackTrace();
188
		    fail("Unexpected error: " + e.getMessage());
189
	    } 
190
	}
191
	
192
	public void testCreate() {
193
	    printTestHeader("testCreate");
194

    
195
	    try {
196
            Session session = getTestSession();
197
			Identifier guid = new Identifier();
198
			guid.setValue("testCreate." + System.currentTimeMillis());
199
			InputStream object = new ByteArrayInputStream("test".getBytes("UTF-8"));
200
			SystemMetadata sysmeta = createSystemMetadata(guid, session.getSubject(), object);
201
			Identifier pid = CNodeService.getInstance(request).create(session, guid, object, sysmeta);
202
			assertEquals(guid, pid);
203
        } catch(Exception e) {
204
        	e.printStackTrace();
205
            fail("Unexpected error: " + e.getMessage());
206
        }
207
	}
208
	
209
	public void testGet() {
210
	    printTestHeader("testGet");
211

    
212
	    try {
213
            Session session = getTestSession();
214
			Identifier guid = new Identifier();
215
			guid.setValue("testGet." + System.currentTimeMillis());
216
			InputStream object = new ByteArrayInputStream("test".getBytes("UTF-8"));
217
			SystemMetadata sysmeta = createSystemMetadata(guid, session.getSubject(), object);
218
			Identifier pid = CNodeService.getInstance(request).create(session, guid, object, sysmeta);
219
			assertEquals(guid.getValue(), pid.getValue());
220
			System.out.println("the pid is+++++++++++++++++++++++++"+guid.getValue());
221
			// get it
222
			InputStream retObject = CNodeService.getInstance(request).get(session, pid);
223
			// check it
224
			object.reset();
225
			assertTrue(IOUtils.contentEquals(object, retObject));
226
        } catch(Exception e) {
227
        	e.printStackTrace();
228
            fail("Unexpected error: " + e.getMessage());
229
        }
230
	}
231
	
232
	public void testChecksum() {
233
	    printTestHeader("testChecksum");
234

    
235
	    try {
236
            Session session = getTestSession();
237
			Identifier guid = new Identifier();
238
			guid.setValue("testChecksum." + System.currentTimeMillis());
239
			InputStream object = new ByteArrayInputStream("test".getBytes("UTF-8"));
240
			SystemMetadata sysmeta = createSystemMetadata(guid, session.getSubject(), object);
241
			// save it
242
			Identifier retGuid = CNodeService.getInstance(request).registerSystemMetadata(session, guid, sysmeta);
243
			assertEquals(guid.getValue(), retGuid.getValue());
244
			// check it
245
			Checksum checksum = CNodeService.getInstance(request).getChecksum(session, guid);
246
			assertEquals(sysmeta.getChecksum().getValue(), checksum.getValue());
247
        } catch(Exception e) {
248
            fail("Unexpected error: " + e.getMessage());
249
        }
250
	}
251
	
252
	public void testListNodes() {
253
	    printTestHeader("testListNodes");
254

    
255
	    try {
256
	    	CNodeService.getInstance(request).listNodes();
257
        } catch(NotImplemented e) {
258
        	// expecting not implemented
259
            assertTrue(true);
260
        } catch(Exception e) {
261
            fail("Unexpected error: " + e.getMessage());
262
        }
263
	}
264
	
265
	public void testReserveIdentifier() {
266
	    printTestHeader("testReserveIdentifier");
267

    
268
	    try {
269
            Session session = getTestSession();
270
			Identifier guid = new Identifier();
271
			guid.setValue("testReserveIdentifier." + System.currentTimeMillis());
272
			// reserve it
273
			Identifier resultPid = CNodeService.getInstance(request).reserveIdentifier(session, guid);
274
			assertNotNull(resultPid);
275
			assertEquals(guid.getValue(), resultPid.getValue());
276
	    } catch(NotImplemented ni) {
277
        	// this is not implemented in Metacat
278
            assertTrue(true);	
279
        } catch(Exception e) {
280
        	e.printStackTrace();
281
            fail("Unexpected error: " + e.getMessage());
282
        }
283
	}
284
	
285
	public void testSearch() {
286
	    printTestHeader("testSearch");
287

    
288
	    try {
289
            Session session = getTestSession();
290
			
291
			// search for objects, but expect a NotImplemented exception
292
			try {
293
				ObjectList objectList = CNodeService.getInstance(request).search(session, null, null);
294
			} catch (NotImplemented ne) {
295
				assertTrue(true);
296
				return;
297
			}
298
			fail("Metacat should not implement CN.search");
299
			
300
        } catch(Exception e) {
301
            fail("Unexpected error: " + e.getMessage());
302
        }
303
	}
304
	
305
	public void testSetOwner() {
306
	    printTestHeader("testSetOwner");
307

    
308
	    try {
309
            Session session = getTestSession();
310
			Identifier guid = new Identifier();
311
			guid.setValue("testSetOwner." + System.currentTimeMillis());
312
			InputStream object = new ByteArrayInputStream("test".getBytes("UTF-8"));
313
			SystemMetadata sysmeta = createSystemMetadata(guid, session.getSubject(), object);
314
			long serialVersion = 1L;
315
			// save it
316
			Identifier retGuid = CNodeService.getInstance(request).registerSystemMetadata(session, guid, sysmeta);
317
			assertEquals(guid.getValue(), retGuid.getValue());
318
			Subject rightsHolder = new Subject();
319
			rightsHolder.setValue("newUser");
320
			// set it
321
			Identifier retPid = CNodeService.getInstance(request).setRightsHolder(session, guid, rightsHolder, serialVersion);
322
			assertEquals(guid, retPid);
323
			// get it
324
			sysmeta = CNodeService.getInstance(request).getSystemMetadata(session, guid);
325
			assertNotNull(sysmeta);
326
			// check it
327
			assertTrue(rightsHolder.equals(sysmeta.getRightsHolder()));
328
			
329
        } catch(Exception e) {
330
            fail("Unexpected error: " + e.getMessage());
331
        }
332
	}
333
	
334
	public void testSetAccessPolicy() {
335
	    printTestHeader("testSetAccessPolicy");
336

    
337
	    try {
338
            Session session = getTestSession();
339
			Identifier guid = new Identifier();
340
			guid.setValue("testSetAccessPolicy." + System.currentTimeMillis());
341
			InputStream object = new ByteArrayInputStream("test".getBytes("UTF-8"));
342
			SystemMetadata sysmeta = createSystemMetadata(guid, session.getSubject(), object);
343
	    long serialVersion = 1L;
344

    
345
			// save it
346
			Identifier retGuid = CNodeService.getInstance(request).registerSystemMetadata(session, guid, sysmeta);
347
			assertEquals(guid.getValue(), retGuid.getValue());
348
			AccessPolicy accessPolicy = new AccessPolicy();
349
			AccessRule accessRule = new AccessRule();
350
			accessRule.addPermission(Permission.WRITE);
351
			Subject publicSubject = new Subject();
352
			publicSubject.setValue(Constants.SUBJECT_PUBLIC);
353
			accessRule.addSubject(publicSubject);
354
			accessPolicy.addAllow(accessRule);
355
			// set it
356
			boolean result = CNodeService.getInstance(request).setAccessPolicy(session, guid, accessPolicy, serialVersion );
357
			assertTrue(result);
358
			// check it
359
			result = CNodeService.getInstance(request).isAuthorized(session, guid, Permission.WRITE);
360
			assertTrue(result);
361
        } catch(Exception e) {
362
            fail("Unexpected error: " + e.getMessage());
363
        }
364
	}
365
	
366
	public void testIsAuthorized() {
367
	    printTestHeader("testIsAuthorized");
368

    
369
	    try {
370
            Session session = getTestSession();
371
			Identifier guid = new Identifier();
372
			guid.setValue("testIsAuthorized." + System.currentTimeMillis());
373
			InputStream object = new ByteArrayInputStream("test".getBytes("UTF-8"));
374
			SystemMetadata sysmeta = createSystemMetadata(guid, session.getSubject(), object);
375
			// save it
376
			Identifier retGuid = CNodeService.getInstance(request).registerSystemMetadata(session, guid, sysmeta);
377
			assertEquals(guid.getValue(), retGuid.getValue());
378
			// check it
379
			Subject publicSubject = new Subject();
380
			publicSubject.setValue(Constants.SUBJECT_PUBLIC);
381
			session.setSubject(publicSubject);
382
			// public read
383
			boolean result = CNodeService.getInstance(request).isAuthorized(session, guid, Permission.READ);
384
			assertTrue(result);
385
			// not public write
386
			try {
387
				result = false;
388
				result = CNodeService.getInstance(request).isAuthorized(session, guid, Permission.WRITE);
389
				fail("Public WRITE should be denied");
390
			} catch (NotAuthorized nae) {
391
				result = true;
392
			}
393
			assertTrue(result);
394
        } catch(Exception e) {
395
            fail("Unexpected error: " + e.getMessage());
396
        }
397
	}
398
	
399
	public void testReplicationPolicy() {
400
	    printTestHeader("testReplicationPolicy");
401

    
402
	    try {
403
            Session session = getTestSession();
404
			Identifier guid = new Identifier();
405
			guid.setValue("testReplicationPolicy." + System.currentTimeMillis());
406
			InputStream object = new ByteArrayInputStream("test".getBytes("UTF-8"));
407
			SystemMetadata sysmeta = createSystemMetadata(guid, session.getSubject(), object);
408
	    long serialVersion = 1L;
409

    
410
			// save it
411
			Identifier retGuid = CNodeService.getInstance(request).registerSystemMetadata(session, guid, sysmeta);
412
			assertEquals(guid.getValue(), retGuid.getValue());
413
			
414
			ReplicationPolicy policy = new ReplicationPolicy();
415
			NodeReference node = new NodeReference();
416
			node.setValue("testNode");
417
			policy.addPreferredMemberNode(node );
418
			// set it
419
			boolean result = CNodeService.getInstance(request).setReplicationPolicy(session, guid, policy, serialVersion);
420
			assertTrue(result);
421
			// get it
422
			sysmeta = CNodeService.getInstance(request).getSystemMetadata(session, guid);
423
			assertNotNull(sysmeta);
424
			// check it
425
			assertEquals(policy.getPreferredMemberNode(0).getValue(), sysmeta.getReplicationPolicy().getPreferredMemberNode(0).getValue());
426
			
427
        } catch(Exception e) {
428
            fail("Unexpected error: " + e.getMessage());
429
        }
430
	}
431
	
432
	public void testReplicationStatus() {
433
	    printTestHeader("testReplicationStatus");
434

    
435
	    try {
436
            Session session = getTestSession();
437
			Identifier guid = new Identifier();
438
			guid.setValue("testReplicationStatus." + System.currentTimeMillis());
439
			InputStream object = new ByteArrayInputStream("test".getBytes("UTF-8"));
440
			SystemMetadata sysmeta = createSystemMetadata(guid, session.getSubject(), object);
441
			Replica replica = new Replica();
442
			NodeReference replicaMemberNode = new NodeReference();
443
			replicaMemberNode.setValue("testNode");
444
			replica.setReplicationStatus(ReplicationStatus.REQUESTED);
445
			replica.setReplicaMemberNode(replicaMemberNode);
446
			replica.setReplicaVerified(Calendar.getInstance().getTime());
447
			sysmeta.addReplica(replica );
448
			// save it
449
			Identifier retGuid = CNodeService.getInstance(request).registerSystemMetadata(session, guid, sysmeta);
450
			assertEquals(guid.getValue(), retGuid.getValue());
451
			// set it
452
			ReplicationStatus status = ReplicationStatus.COMPLETED;
453
			BaseException failure = new NotAuthorized("000", "Mock exception for " + this.getClass().getName());
454
			boolean result = CNodeService.getInstance(request).setReplicationStatus(session, guid, replicaMemberNode, status, failure);
455
			assertTrue(result);
456
			// get it
457
			sysmeta = CNodeService.getInstance(request).getSystemMetadata(session, guid);
458
			assertNotNull(sysmeta);
459
			// check it
460
			assertEquals(status, sysmeta.getReplica(0).getReplicationStatus());
461
			
462
        } catch(Exception e) {
463
            fail("Unexpected error: " + e.getMessage());
464
        }
465
	}
466
	
467
	/**
468
	 * Run an initial test that always passes to check that the test harness is
469
	 * working.
470
	 */
471
	public void initialize() 
472
	{
473
	    printTestHeader("initialize");
474
		assertTrue(1 == 1);
475
	}
476
	
477
	/**
478
	 * We want to act as the CN itself
479
	 * @throws ServiceFailure 
480
	 * @throws Exception 
481
	 */
482
	@Override
483
	public Session getTestSession() throws Exception {
484
		Session session = super.getTestSession();
485
		
486
		// use the first CN we find in the nodelist
487
        NodeList nodeList = D1Client.getCN().listNodes();
488
        for (Node node : nodeList.getNodeList()) {
489
            if ( node.getType().equals(NodeType.CN) ) {
490
                
491
                List<Subject> subjects = node.getSubjectList();
492
                for (Subject subject : subjects) {
493
                   session.setSubject(subject);
494
                   // we are done here
495
                   return session;
496
                }
497
            }
498
        }
499
        // in case we didn't find it
500
        return session;
501
	}
502
	
503

    
504
	/**
505
	 * test to list the object formats registered in metacat
506
	 */
507
	public void testListFormats() {
508
		
509
    printTestHeader("testListFormats");
510
    
511
    // make sure we are set up
512
    setUpFormats();
513
    
514
    // there should be at least 59 formats in the list
515
  	int formatsCount = 59;
516
  	ObjectFormatList objectFormatList;
517
  	
518
  	try {
519
	    objectFormatList = CNodeService.getInstance(request).listFormats();
520
	  	assertTrue(objectFormatList.getTotal() >= formatsCount);
521
  	
522
  	} catch (ServiceFailure e) {
523
  		fail("Could not get the object format list: " + e.getMessage());
524

    
525
    } catch (NotImplemented e) {
526
  		fail("Could not get the object format list: " + e.getMessage());
527

    
528
    }
529
    
530
	}
531
	
532
  /**
533
   * Test getting a single object format from the registered list
534
   */
535
  public void testGetFormat() {
536
  	
537
    printTestHeader("testGetFormat");
538

    
539
    // make sure we are set up
540
    setUpFormats();
541
    
542
    String knownFormat = "text/plain";
543
    ObjectFormatIdentifier fmtid = new ObjectFormatIdentifier();
544
    fmtid.setValue(knownFormat);
545
  	
546
    try {
547
	    
548
			String result = 
549
				CNodeService.getInstance(request).getFormat(fmtid).getFormatId().getValue();
550
	  	System.out.println("Expected result: " + knownFormat);
551
	  	System.out.println("Found    result: " + result);
552
	  	assertTrue(result.equals(knownFormat));
553
  
554
    } catch (NullPointerException npe) {	  
555
	    fail("The returned format was null: " + npe.getMessage());
556
    
557
    } catch (NotFound nfe) {     
558
    	fail("The format " + knownFormat + " was not found: " + nfe.getMessage());
559
    	
560
    } catch (ServiceFailure sfe) {
561
    	fail("The format " + knownFormat + " was not found: " + sfe.getMessage());
562

    
563
    } catch (NotImplemented nie) {
564
    	fail("The getFormat() method has not been implemented: " + nie.getMessage());
565

    
566
    }
567
  	
568
  }
569
	
570
  /**
571
   * Test getting a non-existent object format, returning NotFound
572
   */
573
  public void testObjectFormatNotFoundException() {
574
  
575
    printTestHeader("testObjectFormatNotFoundException");
576

    
577
    ObjectFormatIdentifier fmtid = new ObjectFormatIdentifier();
578
  	String badFormat = "text/bad-format";
579
  	fmtid.setValue(badFormat);
580
  	
581
  	try {
582
  		
583
	    ObjectFormat objectFormat = 
584
	    	CNodeService.getInstance(request).getFormat(fmtid);
585
      
586
  	} catch (Exception e) {
587
	    
588
  		assertTrue(e instanceof NotFound);
589
  	}
590
  	
591
  }
592
  
593
  public void readDeletedObject() {
594
      printTestHeader("testCreate");
595

    
596
      try {
597
          Session session = getTestSession();
598
          Identifier guid = new Identifier();
599
          guid.setValue("testCreate." + System.currentTimeMillis());
600
          InputStream object = new ByteArrayInputStream("test".getBytes("UTF-8"));
601
          SystemMetadata sysmeta = createSystemMetadata(guid, session.getSubject(), object);
602
          Identifier pid = CNodeService.getInstance(request).create(session, guid, object, sysmeta);
603
          assertEquals(guid, pid);
604
          
605
          Thread.sleep(3000);
606
          // use MN admin to delete
607
          session = getMNSession();
608
          Identifier deletedPid = CNodeService.getInstance(request).delete(session, pid);
609
          System.out.println("after deleting");
610
          assertEquals(pid.getValue(), deletedPid.getValue());
611
          // check that we cannot get the object
612
          session = getTestSession();
613
          InputStream deletedObject = null;
614
          try {
615
              //System.out.println("before read ===============");
616
              deletedObject = CNodeService.getInstance(request).get(session, deletedPid);
617
              //System.out.println("after read ===============");
618
          } catch (NotFound nf) {
619
              //System.out.println("the exception is1 "+nf.getMessage());
620
              //nf.printStackTrace();
621
              assertTrue(nf.getMessage().contains("deleted"));
622
          }
623
          try {
624
              //System.out.println("before read ===============");
625
              SystemMetadata sysmeta2 = CNodeService.getInstance(request).getSystemMetadata(session, deletedPid);
626
              //System.out.println("after read ===============");
627
          } catch (NotFound nf) {
628
              //System.out.println("the exception is "+nf.getMessage());
629
              //nf.printStackTrace();
630
              assertTrue(nf.getMessage().contains("deleted"));
631
          }
632
          
633
          try {
634
              //System.out.println("before read ===============");
635
              DescribeResponse describeResponse = CNodeService.getInstance(request).describe(session, pid);
636
              //System.out.println("after read ===============");
637
          } catch (NotFound nf) {
638
              //System.out.println("the exception is "+nf.getMessage());
639
              //nf.printStackTrace();
640
              assertTrue(nf.getMessage().contains("deleted"));
641
          }
642
          
643
          try {
644
              //System.out.println("before read ===============");
645
              Checksum checksum = CNodeService.getInstance(request).getChecksum(session, pid);
646
              //System.out.println("after read ===============");
647
          } catch (NotFound nf) {
648
              //System.out.println("the exception 3 is "+nf.getMessage());
649
              //nf.printStackTrace();
650
              assertTrue(nf.getMessage().contains("deleted"));
651
          }
652
          
653
          try {
654
              //System.out.println("before read ===============");
655
              boolean isAuthorized = 
656
                      CNodeService.getInstance(request).isAuthorized(session, pid, Permission.READ);
657
              //System.out.println("after read ===============");
658
          } catch (NotFound nf) {
659
              //System.out.println("the exception 4 is "+nf.getMessage());
660
              //nf.printStackTrace();
661
              assertTrue(nf.getMessage().contains("deleted"));
662
          }
663
          
664
         
665
          
666
          assertNull(deletedObject);
667
      } catch(Exception e) {
668
          e.printStackTrace();
669
          fail("Unexpected error: " + e.getMessage());
670
      }
671
  }
672
  
673
  /**
674
   * Test the method - get api  for a speicified SID
675
   */
676
  public void testGetSID() {
677
      String str1 = "object1";
678
      String str2 = "object2";
679
      String str3 = "object3";
680
      try {
681
          //insert test documents with a series id
682
          Session session = getTestSession();
683
          Identifier guid = new Identifier();
684
          guid.setValue(generateDocumentId());
685
          InputStream object1 = new ByteArrayInputStream(str1.getBytes("UTF-8"));
686
          SystemMetadata sysmeta = createSystemMetadata(guid, session.getSubject(), object1);
687
          String sid1= "sid."+System.nanoTime();
688
          Identifier seriesId = new Identifier();
689
          seriesId.setValue(sid1);
690
          System.out.println("the first sid is "+seriesId.getValue());
691
          sysmeta.setSeriesId(seriesId);
692
          CNodeService.getInstance(request).create(session, guid, object1, sysmeta);
693
          System.out.println("the first pid is "+guid.getValue());
694
          //test the get(pid) for v2
695
          InputStream result = CNodeService.getInstance(request).get(session, guid);
696
          // go back to beginning of original stream
697
          object1.reset();
698
          // check
699
          assertTrue(object1.available() > 0);
700
          assertTrue(result.available() > 0);
701
          assertTrue(IOUtils.contentEquals(result, object1));
702
          // test the get(id) for v2
703
          InputStream result1 = CNodeService.getInstance(request).get(session, seriesId);
704
          object1.reset();
705
          // check
706
          assertTrue(object1.available() > 0);
707
          assertTrue(result1.available() > 0);
708
          assertTrue(IOUtils.contentEquals(result1, object1));
709
          //test the get(pid) for v1
710
          InputStream result2 = edu.ucsb.nceas.metacat.dataone.v1.CNodeService.getInstance(request).get(session, guid);
711
          object1.reset();
712
          // check
713
          assertTrue(object1.available() > 0);
714
          assertTrue(result2.available() > 0);
715
          assertTrue(IOUtils.contentEquals(result2, object1));
716
          //test the get(sid) for v1
717
          try {
718
              InputStream result3 = edu.ucsb.nceas.metacat.dataone.v1.CNodeService.getInstance(request).get(session, seriesId);
719
              fail("the get(sid) methoud should throw a not found exception for the sid "+seriesId.getValue());
720
          } catch (NotFound ee) {
721
              
722
          }
723
          SystemMetadata metadata = CNodeService.getInstance(request).getSystemMetadata(session, seriesId);
724
          assertTrue(metadata.getIdentifier().getValue().equals(guid.getValue()));
725
          assertTrue(metadata.getSeriesId().getValue().equals(seriesId.getValue()));
726
          DescribeResponse describeResponse = CNodeService.getInstance(request).describe(session, seriesId);
727
          assertEquals(describeResponse.getDataONE_Checksum().getValue(), metadata.getChecksum().getValue());
728
          assertEquals(describeResponse.getDataONE_ObjectFormatIdentifier().getValue(), metadata.getFormatId().getValue());
729
          
730
          metadata = CNodeService.getInstance(request).getSystemMetadata(session, guid);
731
          assertTrue(metadata.getIdentifier().getValue().equals(guid.getValue()));
732
          assertTrue(metadata.getSeriesId().getValue().equals(seriesId.getValue()));
733
          describeResponse = CNodeService.getInstance(request).describe(session, guid);
734
          assertEquals(describeResponse.getDataONE_Checksum().getValue(), metadata.getChecksum().getValue());
735
          assertEquals(describeResponse.getDataONE_ObjectFormatIdentifier().getValue(), metadata.getFormatId().getValue());
736
          
737
          org.dataone.service.types.v1.SystemMetadata sys1=edu.ucsb.nceas.metacat.dataone.v1.CNodeService.getInstance(request).getSystemMetadata(session, guid);
738
          assertTrue(metadata.getIdentifier().getValue().equals(guid.getValue()));
739
          
740
          try {
741
              org.dataone.service.types.v1.SystemMetadata sys2=edu.ucsb.nceas.metacat.dataone.v1.CNodeService.getInstance(request).getSystemMetadata(session, seriesId);
742
              fail("the getSystemMetadata(sid) methoud should throw a not found exception for the sid "+seriesId.getValue());
743
          } catch(NotFound nf2) {
744
              
745
          }
746
          
747
          describeResponse = edu.ucsb.nceas.metacat.dataone.v1.CNodeService.getInstance(request).describe(session, guid);
748
          assertEquals(describeResponse.getDataONE_Checksum().getValue(), sys1.getChecksum().getValue());
749
          assertEquals(describeResponse.getDataONE_ObjectFormatIdentifier().getValue(), sys1.getFormatId().getValue());
750
          try {
751
              describeResponse = edu.ucsb.nceas.metacat.dataone.v1.CNodeService.getInstance(request).describe(session, seriesId);
752
              fail("the describe(sid) methoud should throw a not found exception for the sid "+seriesId.getValue());
753
          } catch(NotFound nf2) {
754
              
755
          }
756
          
757
          Checksum sum = CNodeService.getInstance(request).getChecksum(session, guid);
758
          assertTrue(sum.getValue().equals("5b78f9689b9aab1ebc0f3c1df916dd97"));
759
          
760
          try {
761
              sum = CNodeService.getInstance(request).getChecksum(session, seriesId);
762
              fail("the getCheckSum shouldn't work for sid");
763
          } catch(NotFound nf3) {
764
              
765
          }
766
          
767
          sum = edu.ucsb.nceas.metacat.dataone.v1.CNodeService.getInstance(request).getChecksum(session, guid);
768
          assertTrue(sum.getValue().equals("5b78f9689b9aab1ebc0f3c1df916dd97"));
769
          
770
          try {
771
              sum = edu.ucsb.nceas.metacat.dataone.v1.CNodeService.getInstance(request).getChecksum(session, seriesId);
772
              fail("the getCheckSum shouldn't work for sid");
773
          } catch(NotFound nf3) {
774
              
775
          }
776
          
777
          boolean isAuthorized = 
778
                  CNodeService.getInstance(request).isAuthorized(session, guid, Permission.READ);
779
          assertEquals(isAuthorized, true);
780
          
781
          isAuthorized = 
782
                  CNodeService.getInstance(request).isAuthorized(session, seriesId, Permission.READ);
783
          assertEquals(isAuthorized, true);
784
          
785
          isAuthorized = 
786
                  edu.ucsb.nceas.metacat.dataone.v1.CNodeService.getInstance(request).isAuthorized(session, guid, Permission.READ);
787
          assertEquals(isAuthorized, true);
788
          
789
          try {
790
              isAuthorized = 
791
                      edu.ucsb.nceas.metacat.dataone.v1.CNodeService.getInstance(request).isAuthorized(session, seriesId, Permission.READ);
792
              fail("we can't reach here since the v1 isAuthorized method doesn't suppport series id");
793
          } catch (NotFound e) {
794
              
795
          }
796

    
797
          //do a update with the same series id
798
          Thread.sleep(1000);
799
          Identifier newPid = new Identifier();
800
          newPid.setValue(generateDocumentId()+"1");
801
          System.out.println("the second pid is "+newPid.getValue());
802
          InputStream object2 = new ByteArrayInputStream(str2.getBytes("UTF-8"));
803
          SystemMetadata newSysMeta = createSystemMetadata(newPid, session.getSubject(), object2);
804
          newSysMeta.setObsoletes(guid);
805
          newSysMeta.setSeriesId(seriesId);
806
          //CNodeService.getInstance(request).update(session, guid, object2, newPid, newSysMeta);
807
          CNodeService.getInstance(request).create(session, newPid, object2, newSysMeta);
808
          //update the system metadata of previous version.
809
          sysmeta.setObsoletedBy(newPid);
810
          CNodeService.getInstance(request).updateSystemMetadata(session, guid, sysmeta);
811
          InputStream result4 = CNodeService.getInstance(request).get(session, guid);
812
          // go back to beginning of original stream
813
          object1.reset();
814
          // check
815
          assertTrue(object1.available() > 0);
816
          assertTrue(result4.available() > 0);
817
          assertTrue(IOUtils.contentEquals(result4, object1));
818
          
819
          InputStream result5 = CNodeService.getInstance(request).get(session, newPid);
820
          // go back to beginning of original stream
821
          object2.reset();
822
          // check
823
          assertTrue(object2.available() > 0);
824
          assertTrue(result5.available() > 0);
825
          assertTrue(IOUtils.contentEquals(result5, object2));
826
          
827

    
828
          InputStream result6 = CNodeService.getInstance(request).get(session, seriesId);
829
          object2.reset();
830
          // check
831
          assertTrue(object2.available() > 0);
832
          assertTrue(result6.available() > 0);
833
          assertTrue(IOUtils.contentEquals(result6, object2));
834
          //test the get(pid) for v1
835
          InputStream result7 = edu.ucsb.nceas.metacat.dataone.v1.CNodeService.getInstance(request).get(session, guid);
836
          //System.out.println("+++++++++++++++++++++"+IOUtils.toString(result7));
837
          object1.reset();
838
          // check
839
          assertTrue(object1.available() > 0);
840
          assertTrue(result7.available() > 0);
841
          assertTrue(IOUtils.contentEquals(result7, object1));
842
          
843
          InputStream result8 = edu.ucsb.nceas.metacat.dataone.v1.CNodeService.getInstance(request).get(session, newPid);
844
          object2.reset();
845
          // check
846
          assertTrue(object2.available() > 0);
847
          assertTrue(result8.available() > 0);
848
          assertTrue(IOUtils.contentEquals(result8, object2));
849
          //test the get(sid) for v1
850
          try {
851
              InputStream result3 = edu.ucsb.nceas.metacat.dataone.v1.CNodeService.getInstance(request).get(session, seriesId);
852
              fail("the get(sid) methoud should throw a not found exception for the sid "+seriesId.getValue());
853
          } catch (NotFound ee) {
854
              
855
          }
856
          
857
          SystemMetadata metadata1 = CNodeService.getInstance(request).getSystemMetadata(session, seriesId);
858
          assertTrue(metadata1.getIdentifier().getValue().equals(newPid.getValue()));
859
          assertTrue(metadata1.getSeriesId().getValue().equals(seriesId.getValue()));
860
          describeResponse = CNodeService.getInstance(request).describe(session, seriesId);
861
          assertEquals(describeResponse.getDataONE_Checksum().getValue(), metadata1.getChecksum().getValue());
862
          assertEquals(describeResponse.getDataONE_ObjectFormatIdentifier().getValue(), metadata1.getFormatId().getValue());
863
          
864
          SystemMetadata metadata2 = CNodeService.getInstance(request).getSystemMetadata(session, guid);
865
          assertTrue(metadata2.getIdentifier().getValue().equals(guid.getValue()));
866
          assertTrue(metadata2.getSeriesId().getValue().equals(seriesId.getValue()));
867
          describeResponse = CNodeService.getInstance(request).describe(session, guid);
868
          assertEquals(describeResponse.getDataONE_Checksum().getValue(), metadata2.getChecksum().getValue());
869
          assertEquals(describeResponse.getDataONE_ObjectFormatIdentifier().getValue(), metadata2.getFormatId().getValue());
870
          
871
          SystemMetadata metadata3 = CNodeService.getInstance(request).getSystemMetadata(session, newPid);
872
          assertTrue(metadata3.getIdentifier().getValue().equals(newPid.getValue()));
873
          assertTrue(metadata3.getSeriesId().getValue().equals(seriesId.getValue()));
874
          describeResponse = CNodeService.getInstance(request).describe(session, newPid);
875
          assertEquals(describeResponse.getDataONE_Checksum().getValue(), metadata3.getChecksum().getValue());
876
          assertEquals(describeResponse.getDataONE_ObjectFormatIdentifier().getValue(), metadata3.getFormatId().getValue());
877
          
878
          //do another update with different series id
879
          Thread.sleep(1000);
880
          String sid2 = "sid."+System.nanoTime();
881
          Identifier seriesId2= new Identifier();
882
          seriesId2.setValue(sid2);
883
          System.out.println("the second sid is "+seriesId2.getValue());
884
          Identifier newPid2 = new Identifier();
885
          newPid2.setValue(generateDocumentId()+"2");
886
          System.out.println("the third pid is "+newPid2.getValue());
887
          InputStream object3 = new ByteArrayInputStream(str3.getBytes("UTF-8"));
888
          SystemMetadata sysmeta3 = createSystemMetadata(newPid2, session.getSubject(), object3);
889
          sysmeta3.setObsoletes(newPid);
890
          sysmeta3.setSeriesId(seriesId2);
891
          //CNodeService.getInstance(request).update(session, newPid, object3, newPid2, sysmeta3);
892
          CNodeService.getInstance(request).create(session, newPid2, object3, sysmeta3);
893
          //update the system metadata of the previous version 
894
          newSysMeta.setObsoletedBy(newPid2);
895
          CNodeService.getInstance(request).updateSystemMetadata(session, newPid, newSysMeta);
896
          
897
          InputStream result9 = CNodeService.getInstance(request).get(session, guid);
898
          // go back to beginning of original stream
899
          object1.reset();
900
          // check
901
          assertTrue(object1.available() > 0);
902
          assertTrue(result9.available() > 0);
903
          assertTrue(IOUtils.contentEquals(result9, object1));
904
          
905
          InputStream result10 = CNodeService.getInstance(request).get(session, newPid);
906
          // go back to beginning of original stream
907
          object2.reset();
908
          // check
909
          assertTrue(object2.available() > 0);
910
          assertTrue(result10.available() > 0);
911
          assertTrue(IOUtils.contentEquals(result10, object2));
912
          
913
          
914
          InputStream result11 = CNodeService.getInstance(request).get(session, newPid2);
915
          // go back to beginning of original stream
916
          object3.reset();
917
          // check
918
          assertTrue(object3.available() > 0);
919
          assertTrue(result11.available() > 0);
920
          assertTrue(IOUtils.contentEquals(result11, object3));
921
          
922
          InputStream result12 = CNodeService.getInstance(request).get(session, seriesId2);
923
          object3.reset();
924
          // check
925
          assertTrue(object3.available() > 0);
926
          assertTrue(result12.available() > 0);
927
          assertTrue(IOUtils.contentEquals(result12, object3));
928
          
929
          InputStream result16 = CNodeService.getInstance(request).get(session, seriesId);
930
          object2.reset();
931
          // check
932
          assertTrue(object2.available() > 0);
933
          assertTrue(result16.available() > 0);
934
          assertTrue(IOUtils.contentEquals(result16, object2));
935
         
936
          //test the get(pid) for v1
937
          InputStream result13 = edu.ucsb.nceas.metacat.dataone.v1.CNodeService.getInstance(request).get(session, guid);
938
          object1.reset();
939
          // check
940
          assertTrue(object1.available() > 0);
941
          assertTrue(result13.available() > 0);
942
          assertTrue(IOUtils.contentEquals(result13, object1));
943
          
944
          InputStream result14 = edu.ucsb.nceas.metacat.dataone.v1.CNodeService.getInstance(request).get(session, newPid);
945
          object2.reset();
946
          // check
947
          assertTrue(object2.available() > 0);
948
          assertTrue(result14.available() > 0);
949
          assertTrue(IOUtils.contentEquals(result14, object2));
950
          
951
          InputStream result15 = edu.ucsb.nceas.metacat.dataone.v1.CNodeService.getInstance(request).get(session, newPid2);
952
          object3.reset();
953
          // check
954
          assertTrue(object3.available() > 0);
955
          assertTrue(result15.available() > 0);
956
          assertTrue(IOUtils.contentEquals(result15, object3));
957
          
958
          SystemMetadata metadata4 = CNodeService.getInstance(request).getSystemMetadata(session, seriesId);
959
          assertTrue(metadata4.getIdentifier().getValue().equals(newPid.getValue()));
960
          assertTrue(metadata4.getSeriesId().getValue().equals(seriesId.getValue()));
961
          describeResponse = CNodeService.getInstance(request).describe(session, seriesId);
962
          assertEquals(describeResponse.getDataONE_Checksum().getValue(), metadata4.getChecksum().getValue());
963
          assertEquals(describeResponse.getDataONE_ObjectFormatIdentifier().getValue(), metadata4.getFormatId().getValue());
964
          
965
          SystemMetadata metadata5 = CNodeService.getInstance(request).getSystemMetadata(session, seriesId2);
966
          assertTrue(metadata5.getIdentifier().getValue().equals(newPid2.getValue()));
967
          assertTrue(metadata5.getSeriesId().getValue().equals(seriesId2.getValue()));
968
          describeResponse = CNodeService.getInstance(request).describe(session, seriesId2);
969
          assertEquals(describeResponse.getDataONE_Checksum().getValue(), metadata5.getChecksum().getValue());
970
          assertEquals(describeResponse.getDataONE_ObjectFormatIdentifier().getValue(), metadata5.getFormatId().getValue());
971
          
972
          SystemMetadata metadata6 = CNodeService.getInstance(request).getSystemMetadata(session, guid);
973
          assertTrue(metadata6.getIdentifier().getValue().equals(guid.getValue()));
974
          assertTrue(metadata6.getSeriesId().getValue().equals(seriesId.getValue()));
975
          describeResponse = CNodeService.getInstance(request).describe(session, guid);
976
          assertEquals(describeResponse.getDataONE_Checksum().getValue(), metadata6.getChecksum().getValue());
977
          assertEquals(describeResponse.getDataONE_ObjectFormatIdentifier().getValue(), metadata6.getFormatId().getValue());
978
          
979
          SystemMetadata metadata7 = CNodeService.getInstance(request).getSystemMetadata(session, newPid);
980
          assertTrue(metadata7.getIdentifier().getValue().equals(newPid.getValue()));
981
          assertTrue(metadata7.getSeriesId().getValue().equals(seriesId.getValue()));
982
          describeResponse = CNodeService.getInstance(request).describe(session, newPid);
983
          assertEquals(describeResponse.getDataONE_Checksum().getValue(), metadata7.getChecksum().getValue());
984
          assertEquals(describeResponse.getDataONE_ObjectFormatIdentifier().getValue(), metadata7.getFormatId().getValue());
985
          
986
          SystemMetadata metadata8 = CNodeService.getInstance(request).getSystemMetadata(session, newPid2);
987
          assertTrue(metadata8.getIdentifier().getValue().equals(newPid2.getValue()));
988
          assertTrue(metadata8.getSeriesId().getValue().equals(seriesId2.getValue()));
989
          describeResponse = CNodeService.getInstance(request).describe(session, newPid2);
990
          assertEquals(describeResponse.getDataONE_Checksum().getValue(), metadata8.getChecksum().getValue());
991
          assertEquals(describeResponse.getDataONE_ObjectFormatIdentifier().getValue(), metadata8.getFormatId().getValue());
992
          
993
          
994
          
995
          System.out.println("here===========================");
996
          //test the get(sid) for v1
997
          try {
998
              InputStream result3 = edu.ucsb.nceas.metacat.dataone.v1.CNodeService.getInstance(request).get(session, seriesId);
999
              fail("the get(sid) methoud should throw a not found exception for the sid "+seriesId.getValue());
1000
          } catch (NotFound ee) {
1001
              
1002
          }
1003
          
1004
          //test the get(sid) for v1
1005
          try {
1006
              InputStream result3 = edu.ucsb.nceas.metacat.dataone.v1.CNodeService.getInstance(request).get(session, seriesId2);
1007
              fail("the get(sid) methoud should throw a not found exception for the sid "+seriesId.getValue());
1008
          } catch (NotFound ee) {
1009
              
1010
          }
1011
          
1012
          //test to get non-existing id for v2
1013
          try {
1014
           // the pid should be null when we try to get a no-exist sid
1015
              Identifier non_exist_sid = new Identifier();
1016
              non_exist_sid.setValue("no-sid-exist-123qwe");
1017
              InputStream result3 = CNodeService.getInstance(request).get(session, non_exist_sid);
1018
              fail("the get(sid) methoud should throw a not found exception for the sid "+seriesId.getValue());
1019
          } catch (NotFound ee) {
1020
              
1021
          }
1022
          
1023
          try {
1024
              // the pid should be null when we try to get a no-exist sid
1025
                 Identifier non_exist_sid = new Identifier();
1026
                 non_exist_sid.setValue("no-sid-exist-123qwe");
1027
                 SystemMetadata result3 = CNodeService.getInstance(request).getSystemMetadata(session, non_exist_sid);
1028
                 fail("the getSystemMetadata(sid) methoud should throw a not found exception for the sid "+seriesId.getValue());
1029
          } catch (NotFound ee) {
1030
                 
1031
          }
1032
          
1033
          try {
1034
              // the pid should be null when we try to get a no-exist sid
1035
                 Identifier non_exist_sid = new Identifier();
1036
                 non_exist_sid.setValue("no-sid-exist-123qwe");
1037
                  CNodeService.getInstance(request).describe(session, non_exist_sid);
1038
                 fail("the describe(sid) methoud should throw a not found exception for the sid "+seriesId.getValue());
1039
             } catch (NotFound ee) {
1040
                 
1041
             }
1042
          
1043
          
1044
          //do another update with invalid series ids
1045
          Thread.sleep(1000);
1046
          Identifier newPid3 = new Identifier();
1047
          newPid3.setValue(generateDocumentId()+"3");
1048
          System.out.println("the third pid is "+newPid3.getValue());
1049
          InputStream object4 = new ByteArrayInputStream(str3.getBytes("UTF-8"));
1050
          SystemMetadata sysmeta4 = createSystemMetadata(newPid3, session.getSubject(), object4);
1051
          sysmeta4.setObsoletes(newPid2);
1052
          sysmeta4.setSeriesId(seriesId);
1053
          /*try {
1054
              CNodeService.getInstance(request).create(session, newPid3, object4, sysmeta4);
1055
              fail("we can't reach here since the sid is using an old one ");
1056
          } catch (InvalidSystemMetadata eee) {
1057
              
1058
          } */
1059
          
1060
          /*sysmeta4.setSeriesId(newPid3);
1061
          try {
1062
              CNodeService.getInstance(request).create(session, newPid3, object4, sysmeta4);
1063
              fail("we can't reach here since the sid is using the pid ");
1064
          } catch (InvalidSystemMetadata eee) {
1065
              
1066
          }*/
1067
          
1068
          //test archive a series id by v1
1069
          try {
1070
              edu.ucsb.nceas.metacat.dataone.v1.CNodeService.getInstance(request).archive(session, seriesId2);
1071
              fail("we can't reach here since the v1 archive method doesn't support the sid ");
1072
          } catch (NotFound nf2) {
1073
              
1074
          }
1075
          
1076
          // test delete a series id by v1
1077
          Session mnSession = getMNSession();
1078
          try {
1079
              edu.ucsb.nceas.metacat.dataone.v1.CNodeService.getInstance(request).delete(mnSession, seriesId2);
1080
              fail("we can't reach here since the v1 delete method doesn't support the sid ");
1081
          } catch (NotFound nf2) {
1082
              
1083
          }
1084
          
1085
          // test archive a series id by v2
1086
          CNodeService.getInstance(request).archive(session, seriesId2);
1087
          SystemMetadata archived = CNodeService.getInstance(request).getSystemMetadata(session, seriesId2);
1088
          assertTrue(archived.getArchived());
1089
          archived = CNodeService.getInstance(request).getSystemMetadata(session, newPid2);
1090
          assertTrue(archived.getArchived());
1091
          
1092
          // test delete a series id by v2
1093
          CNodeService.getInstance(request).delete(mnSession, seriesId2);
1094
          try {
1095
              CNodeService.getInstance(request).get(session, seriesId2);
1096
              fail("we can't reach here since the series id was deleted ");
1097
          } catch (NotFound nf3) {
1098
              System.out.println("the message is ============="+nf3.getMessage());
1099
              //assertTrue(nf3.getMessage().indexOf("delete") >0);
1100
          }
1101
          
1102
          try {
1103
              CNodeService.getInstance(request).get(session, newPid2);
1104
              fail("we can't reach here since the series id was deleted ");
1105
          } catch (NotFound nf3) {
1106
              //System.out.println("the message is ============="+nf3.getMessage());
1107
              assertTrue(nf3.getMessage().indexOf("delete") >0);
1108
          }
1109
          
1110
          try {
1111
              edu.ucsb.nceas.metacat.dataone.v1.CNodeService.getInstance(request).get(session, newPid2);
1112
              fail("we can't reach here since the series id was deleted ");
1113
          } catch (NotFound nf3) {
1114
              System.out.println("the message is ============="+nf3.getMessage());
1115
              assertTrue(nf3.getMessage().indexOf("delete") >0);
1116
          }
1117
          
1118
          //archive seriesId
1119
          CNodeService.getInstance(request).archive(mnSession, seriesId);
1120
          archived = CNodeService.getInstance(request).getSystemMetadata(session, seriesId);
1121
          assertTrue(archived.getArchived());
1122
          archived = CNodeService.getInstance(request).getSystemMetadata(session, newPid);
1123
          assertTrue(archived.getArchived());
1124
          
1125
          
1126
          //delete seriesId
1127
          CNodeService.getInstance(request).delete(mnSession, seriesId);
1128
          try {
1129
              CNodeService.getInstance(request).get(session, newPid);
1130
              fail("we can't reach here since the series id was deleted ");
1131
          } catch (NotFound nf3) {
1132
              //System.out.println("the message is ============="+nf3.getMessage());
1133
              assertTrue(nf3.getMessage().indexOf("delete") >0);
1134
          }
1135
          SystemMetadata meta = CNodeService.getInstance(request).getSystemMetadata(session, seriesId);
1136
          assertTrue(meta.getIdentifier().getValue().equals(guid.getValue()));
1137
          
1138
      } catch (Exception e) {
1139
          e.printStackTrace();
1140
          fail(e.getMessage());
1141
      }
1142
  }
1143
 
1144
  /**
1145
   * Test the listView methods.
1146
   * @throws Excpetion
1147
   */
1148
  public void testListViews() throws Exception {
1149
      OptionList list = CNodeService.getInstance(request).listViews();
1150
      assertTrue(list.sizeOptionList() >0);
1151
      List<String> names = list.getOptionList();
1152
      for(String name : names) {
1153
          System.out.println("It has the view named "+name);
1154
      }
1155
  }
1156
  
1157
  public void testUpdateSystemMetadata() throws Exception {
1158
          String str1 = "object1";
1159
          String str2 = "object2";
1160
          String str3 = "object3";
1161
  
1162
          //insert test documents with a series id
1163
          Session session = getTestSession();
1164
          Identifier guid = new Identifier();
1165
          guid.setValue(generateDocumentId());
1166
          InputStream object1 = new ByteArrayInputStream(str1.getBytes("UTF-8"));
1167
          SystemMetadata sysmeta = createSystemMetadata(guid, session.getSubject(), object1);
1168
          String sid1= "sid."+System.nanoTime();
1169
          Identifier seriesId = new Identifier();
1170
          seriesId.setValue(sid1);
1171
          System.out.println("the first sid is "+seriesId.getValue());
1172
          sysmeta.setSeriesId(seriesId);
1173
          sysmeta.setArchived(false);
1174
          CNodeService.getInstance(request).create(session, guid, object1, sysmeta);
1175
          //Test the generating object succeeded. 
1176
          SystemMetadata metadata = CNodeService.getInstance(request).getSystemMetadata(session, guid);
1177
          assertTrue(metadata.getIdentifier().equals(guid));
1178
          assertTrue(metadata.getArchived().equals(false));
1179
          System.out.println("the checksum from request is "+metadata.getChecksum().getValue());
1180
          assertTrue(metadata.getSize().equals(sysmeta.getSize()));
1181
          
1182
          //update system metadata sucessfully
1183
          metadata.setArchived(true);
1184
          CNodeService.getInstance(request).updateSystemMetadata(session, guid, metadata);
1185
          SystemMetadata metadata2 = CNodeService.getInstance(request).getSystemMetadata(session, seriesId);
1186
          assertTrue(metadata2.getIdentifier().equals(guid));
1187
          assertTrue(metadata2.getSeriesId().equals(seriesId));
1188
          assertTrue(metadata2.getArchived().equals(true));
1189
          assertTrue(metadata2.getChecksum().getValue().equals(metadata.getChecksum().getValue()));
1190
          
1191
          Identifier newId = new Identifier();
1192
          newId.setValue("newValue");
1193
          metadata.setIdentifier(newId);
1194
          try {
1195
              CNodeService.getInstance(request).updateSystemMetadata(session, guid, metadata);
1196
              fail("We shouldn't get there");
1197
          } catch (Exception e) {
1198
              assertTrue(e instanceof InvalidRequest);
1199
          }
1200
          
1201
          newId.setValue("newValue");
1202
          metadata.setSeriesId(newId);
1203
          try {
1204
              CNodeService.getInstance(request).updateSystemMetadata(session, guid, metadata);
1205
              fail("We shouldn't get there");
1206
          } catch (Exception e) {
1207
              assertTrue(e instanceof InvalidRequest);
1208
          }
1209
          
1210
          Date newDate = new Date();
1211
          metadata.setDateUploaded(newDate);
1212
          try {
1213
              CNodeService.getInstance(request).updateSystemMetadata(session, guid, metadata);
1214
              fail("We shouldn't get there");
1215
          } catch (Exception e) {
1216
              assertTrue(e instanceof InvalidRequest);
1217
          }
1218
          
1219
          Checksum checkSum = new Checksum();
1220
          checkSum.setValue("12345");
1221
          metadata.setChecksum(checkSum);
1222
          try {
1223
              CNodeService.getInstance(request).updateSystemMetadata(session, guid, metadata);
1224
              fail("We shouldn't get there");
1225
          } catch (Exception e) {
1226
              assertTrue(e instanceof InvalidRequest);
1227
          }
1228
          
1229
          BigInteger size = new BigInteger("4000");
1230
          metadata.setSize(size);
1231
          try {
1232
              CNodeService.getInstance(request).updateSystemMetadata(session, guid, metadata);
1233
              fail("We shouldn't get there");
1234
          } catch (Exception e) {
1235
              assertTrue(e instanceof InvalidRequest);
1236
          }
1237
  }
1238
}
(1-1/7)