diff options
Diffstat (limited to 'base/common/test/com/netscape/cmscore/request')
8 files changed, 1559 insertions, 0 deletions
diff --git a/base/common/test/com/netscape/cmscore/request/DBDynAttrMapperDefaultStub.java b/base/common/test/com/netscape/cmscore/request/DBDynAttrMapperDefaultStub.java new file mode 100644 index 000000000..cccbe600f --- /dev/null +++ b/base/common/test/com/netscape/cmscore/request/DBDynAttrMapperDefaultStub.java @@ -0,0 +1,33 @@ +package com.netscape.cmscore.request; + +import java.util.Enumeration; + +import netscape.ldap.LDAPAttributeSet; + +import com.netscape.certsrv.base.EBaseException; +import com.netscape.certsrv.dbs.IDBDynAttrMapper; +import com.netscape.certsrv.dbs.IDBObj; + +/** + * Default testing stub for the IRequest interface. + */ +public class DBDynAttrMapperDefaultStub implements IDBDynAttrMapper { + public boolean supportsLDAPAttributeName(String attrName) { + return false; + } + + public Enumeration<String> getSupportedLDAPAttributeNames() { + return null; + } + + public void mapObjectToLDAPAttributeSet(IDBObj parent, String name, Object obj, LDAPAttributeSet attrs) + throws EBaseException { + } + + public void mapLDAPAttributeSetToObject(LDAPAttributeSet attrs, String name, IDBObj parent) throws EBaseException { + } + + public String mapSearchFilter(String name, String op, String value) throws EBaseException { + return null; + } +} diff --git a/base/common/test/com/netscape/cmscore/request/ExtAttrDynMapperTest.java b/base/common/test/com/netscape/cmscore/request/ExtAttrDynMapperTest.java new file mode 100644 index 000000000..a0ad0a8a3 --- /dev/null +++ b/base/common/test/com/netscape/cmscore/request/ExtAttrDynMapperTest.java @@ -0,0 +1,278 @@ +package com.netscape.cmscore.request; + +import java.io.Serializable; +import java.util.ArrayList; +import java.util.Enumeration; +import java.util.Hashtable; + +import junit.framework.Test; +import junit.framework.TestSuite; +import netscape.ldap.LDAPAttribute; +import netscape.ldap.LDAPAttributeSet; + +import com.netscape.certsrv.base.EBaseException; +import com.netscape.certsrv.request.IRequestRecord; +import com.netscape.certsrv.request.RequestId; +import com.netscape.cmscore.dbs.RequestRecordDefaultStub; +import com.netscape.cmscore.test.CMSBaseTestCase; + +public class ExtAttrDynMapperTest extends CMSBaseTestCase { + + ExtAttrDynMapper mapper; + + public ExtAttrDynMapperTest(String name) { + super(name); + } + + public void cmsTestSetUp() { + mapper = new ExtAttrDynMapper(); + } + + public void cmsTestTearDown() { + } + + public static Test suite() { + return new TestSuite(ExtAttrDynMapperTest.class); + } + + public void testSupportLDAPAttributeName() { + assertNotNull(mapper); + + assertTrue(mapper.supportsLDAPAttributeName("extData-green")); + assertTrue(mapper.supportsLDAPAttributeName("EXTDATA-green")); + assertTrue(mapper.supportsLDAPAttributeName("extData-foo;0")); + assertTrue(mapper.supportsLDAPAttributeName("extData-bar;baz")); + + assertFalse(mapper.supportsLDAPAttributeName("extDatagreen")); + assertFalse(mapper.supportsLDAPAttributeName("extDatafoo;0")); + assertFalse(mapper.supportsLDAPAttributeName("extDatabar;baz")); + + assertFalse(mapper.supportsLDAPAttributeName(";extData")); + assertFalse(mapper.supportsLDAPAttributeName("fooextData")); + assertFalse(mapper.supportsLDAPAttributeName("foo-extData")); + + assertFalse(mapper.supportsLDAPAttributeName("")); + assertFalse(mapper.supportsLDAPAttributeName(null)); + } + + public void testGetSupportedLdapAttributesNames() { + Enumeration<String> attrs = mapper.getSupportedLDAPAttributeNames(); + ArrayList<String> attrsList = new ArrayList<String>(); + while (attrs.hasMoreElements()) { + attrsList.add(attrs.nextElement()); + } + + assertEquals(1, attrsList.size()); + assertEquals(Schema.LDAP_ATTR_EXT_ATTR, attrsList.get(0)); + } + + public void testIsAlphaNum() { + assertTrue(mapper.isAlphaNum('a')); + assertTrue(mapper.isAlphaNum('l')); + assertTrue(mapper.isAlphaNum('z')); + assertTrue(mapper.isAlphaNum('A')); + assertTrue(mapper.isAlphaNum('K')); + assertTrue(mapper.isAlphaNum('Z')); + assertTrue(mapper.isAlphaNum('0')); + assertTrue(mapper.isAlphaNum('5')); + assertTrue(mapper.isAlphaNum('9')); + + assertFalse(mapper.isAlphaNum('!')); + assertFalse(mapper.isAlphaNum('-')); + assertFalse(mapper.isAlphaNum('\u00ef')); + } + + public void testEncodeDecodeKey() { + // ; is 003b + // $ is 0024 + // % is 0025 + // - is 002d + + String decoded = ";a$c%d-"; + String encoded = "--003ba--0024c--0025d-"; + assertEquals(encoded, mapper.encodeKey(decoded)); + assertEquals(decoded, mapper.decodeKey(encoded)); + + decoded = ";-a-"; + encoded = "--003b--002da-"; + assertEquals(encoded, mapper.encodeKey(decoded)); + assertEquals(decoded, mapper.decodeKey(encoded)); + + decoded = "-ab;ab"; + encoded = "-ab--003bab"; + assertEquals(encoded, mapper.encodeKey(decoded)); + assertEquals(decoded, mapper.decodeKey(encoded)); + + decoded = "--a--b-a-b-"; + encoded = "--002d--002da--002d--002db-a-b-"; + assertEquals(encoded, mapper.encodeKey(decoded)); + assertEquals(decoded, mapper.decodeKey(encoded)); + + decoded = "--a;-"; + encoded = "--002d--002da--003b--002d"; + assertEquals(encoded, mapper.encodeKey(decoded)); + assertEquals(decoded, mapper.decodeKey(encoded)); + } + + public void testMapObjectToLDAPAttributeSet() throws EBaseException { + LDAPAttributeSet attrs = new LDAPAttributeSet(); + + // test with a key-value entry. + Hashtable<String, Serializable> extAttrsHash = new Hashtable<String, Serializable>(); + extAttrsHash.put("foo;", "bar"); + + mapper.mapObjectToLDAPAttributeSet(null, null, extAttrsHash, attrs); + assertEquals(1, attrs.size()); + assertEquals(ExtAttrDynMapper.extAttrPrefix + "foo--003b", + attrs.elementAt(0).getName()); + String vals[] = attrs.elementAt(0).getStringValueArray(); + assertEquals(1, vals.length); + assertEquals("bar", vals[0]); + + // test with a sub-hash. + // this is used by vector/arrays and hashtables + Hashtable<String, String> extAttrsValueHash = new Hashtable<String, String>(); + extAttrsValueHash.put("Baz", "Val1"); + extAttrsValueHash.put("bi;m", "val2"); + + extAttrsHash.clear(); + extAttrsHash.put("top;key", extAttrsValueHash); + + attrs = new LDAPAttributeSet(); + mapper.mapObjectToLDAPAttributeSet(null, null, extAttrsHash, attrs); + assertEquals(2, attrs.size()); + LDAPAttribute attrBaz = attrs.elementAt(0); + LDAPAttribute attrBim = attrs.elementAt(1); + // swap attributes if necessary + if (attrBaz.getName().equals(ExtAttrDynMapper.extAttrPrefix + + "top--003bkey;bi--003bm")) { + attrBaz = attrs.elementAt(1); + attrBim = attrs.elementAt(0); + } + + assertEquals(ExtAttrDynMapper.extAttrPrefix + "top--003bkey;Baz", + attrBaz.getName()); + vals = attrBaz.getStringValueArray(); + assertEquals(1, vals.length); + assertEquals("Val1", vals[0]); + assertTrue(attrBaz.hasSubtype("Baz")); + + assertEquals(ExtAttrDynMapper.extAttrPrefix + "top--003bkey;bi--003bm", + attrBim.getName()); + vals = attrBim.getStringValueArray(); + assertEquals(1, vals.length); + assertEquals("val2", vals[0]); + assertTrue(attrBim.hasSubtype("bi--003bm")); + } + + public void testMapLDAPAttributeSetToObject() throws EBaseException { + // + // Test simple key-value pairs + // + LDAPAttributeSet attrs = new LDAPAttributeSet(); + attrs.add(new LDAPAttribute( + ExtAttrDynMapper.extAttrPrefix + "o--003bkey1", "val1")); + attrs.add(new LDAPAttribute("junk", "junkval")); + attrs.add(new LDAPAttribute( + ExtAttrDynMapper.extAttrPrefix + "okey2", "val2")); + + RequestRecordStub requestRecord = new RequestRecordStub(); + + mapper.mapLDAPAttributeSetToObject(attrs, IRequestRecord.ATTR_EXT_DATA, + requestRecord); + + assertEquals(1, requestRecord.setCallCounter); + Hashtable<?, ?> extData = (Hashtable<?, ?>) requestRecord.extAttrData.get( + IRequestRecord.ATTR_EXT_DATA); + assertNotNull(extData); + + assertEquals(2, extData.keySet().size()); + assertTrue(extData.containsKey("o;key1")); + assertEquals("val1", extData.get("o;key1")); + assertTrue(extData.containsKey("okey2")); + assertEquals("val2", extData.get("okey2")); + + // + // Test subkeys + // + attrs = new LDAPAttributeSet(); + attrs.add(new LDAPAttribute( + ExtAttrDynMapper.extAttrPrefix + "o--003bkey1;i--003bkey11", "val11")); + attrs.add(new LDAPAttribute( + ExtAttrDynMapper.extAttrPrefix.toUpperCase() + "o--003bkey1;ikey12", "val12")); + attrs.add(new LDAPAttribute( + ExtAttrDynMapper.extAttrPrefix + "o--003bkey1;ikey13", "val13")); + attrs.add(new LDAPAttribute( + ExtAttrDynMapper.extAttrPrefix + "okey2;ikey21", "val21")); + attrs.add(new LDAPAttribute( + ExtAttrDynMapper.extAttrPrefix + "okey2;ikey22", "val22")); + attrs.add(new LDAPAttribute("foo", "bar")); + + requestRecord = new RequestRecordStub(); + + mapper.mapLDAPAttributeSetToObject(attrs, IRequestRecord.ATTR_EXT_DATA, + requestRecord); + + assertEquals(1, requestRecord.setCallCounter); + extData = (Hashtable<?, ?>) requestRecord.extAttrData.get( + IRequestRecord.ATTR_EXT_DATA); + assertNotNull(extData); + + assertTrue(extData.containsKey("o;key1")); + Hashtable<?, ?> okey1Data = (Hashtable<?, ?>) extData.get("o;key1"); + assertEquals(3, okey1Data.keySet().size()); + assertTrue(okey1Data.containsKey("i;key11")); + assertEquals("val11", (String) okey1Data.get("i;key11")); + assertTrue(okey1Data.containsKey("ikey12")); + assertEquals("val12", (String) okey1Data.get("ikey12")); + assertTrue(okey1Data.containsKey("ikey13")); + assertEquals("val13", (String) okey1Data.get("ikey13")); + + assertTrue(extData.containsKey("okey2")); + Hashtable<?, ?> okey2Data = (Hashtable<?, ?>) extData.get("okey2"); + assertEquals(2, okey2Data.keySet().size()); + assertTrue(okey2Data.containsKey("ikey21")); + assertEquals("val21", (String) okey2Data.get("ikey21")); + assertTrue(okey2Data.containsKey("ikey22")); + assertEquals("val22", (String) okey2Data.get("ikey22")); + + assertFalse(extData.containsKey("foo")); + + // + // test illegal data combination + // + attrs = new LDAPAttributeSet(); + attrs.add(new LDAPAttribute( + ExtAttrDynMapper.extAttrPrefix + "okey1", "val11")); + attrs.add(new LDAPAttribute( + ExtAttrDynMapper.extAttrPrefix + "okey1;ikey12", "val12")); + + requestRecord = new RequestRecordStub(); + + try { + mapper.mapLDAPAttributeSetToObject(attrs, IRequestRecord.ATTR_EXT_DATA, + requestRecord); + fail("Should have thrown EBaseException on illegal data"); + } catch (EBaseException e) { + // good + } + + } + + class RequestRecordStub extends RequestRecordDefaultStub { + private static final long serialVersionUID = 4106967075497999274L; + Hashtable<String, Object> extAttrData = new Hashtable<String, Object>(); + int setCallCounter = 0; + + public void set(String name, Object o) { + setCallCounter++; + if (IRequestRecord.ATTR_EXT_DATA.equals(name)) { + extAttrData.put(name, o); + } + } + + public RequestId getRequestId() { + return new RequestId("1"); + } + } +} diff --git a/base/common/test/com/netscape/cmscore/request/ExtDataHashtableTest.java b/base/common/test/com/netscape/cmscore/request/ExtDataHashtableTest.java new file mode 100644 index 000000000..c349b73d0 --- /dev/null +++ b/base/common/test/com/netscape/cmscore/request/ExtDataHashtableTest.java @@ -0,0 +1,81 @@ +package com.netscape.cmscore.request; + +import java.util.Hashtable; + +import junit.framework.Test; +import junit.framework.TestSuite; + +import com.netscape.cmscore.test.CMSBaseTestCase; + +public class ExtDataHashtableTest extends CMSBaseTestCase { + + ExtDataHashtable<String> hash; + + public ExtDataHashtableTest(String name) { + super(name); + } + + public void cmsTestSetUp() { + hash = new ExtDataHashtable<String>(); + } + + public void cmsTestTearDown() { + } + + public static Test suite() { + return new TestSuite(ExtDataHashtableTest.class); + } + + public void testContainsKey() { + hash.put("FOO", "bar"); + assertTrue(hash.containsKey("foo")); + assertTrue(hash.containsKey("Foo")); + } + + public void testGet() { + hash.put("FOO", "bar"); + assertEquals("bar", hash.get("foo")); + assertEquals("bar", hash.get("fOO")); + } + + public void testPut() { + hash.put("FOO", "bar"); + hash.put("foo", "bar2"); + assertEquals(1, hash.keySet().size()); + assertEquals("bar2", hash.get("foo")); + } + + public void testPutAll() { + Hashtable<String, String> hash2 = new Hashtable<String, String>(); + hash2.put("KEY1", "VAL1"); + hash2.put("KEY2", "val2"); + + hash.putAll(hash2); + + assertTrue(hash.containsKey("key1")); + assertEquals("VAL1", hash.get("key1")); + assertEquals("val2", hash.get("Key2")); + } + + public void testRemove() { + hash.put("foo", "bar"); + hash.put("one", "two"); + + hash.remove("FOO"); + assertFalse(hash.containsKey("foo")); + assertTrue(hash.containsKey("one")); + } + + public void testMapConstructor() { + Hashtable<String, String> hash2 = new Hashtable<String, String>(); + hash2.put("KEY1", "VAL1"); + hash2.put("KEY2", "val2"); + + hash = new ExtDataHashtable<String>(hash2); + + assertTrue(hash.containsKey("key1")); + assertEquals("VAL1", hash.get("key1")); + assertEquals("val2", hash.get("Key2")); + } + +} diff --git a/base/common/test/com/netscape/cmscore/request/RequestDefaultStub.java b/base/common/test/com/netscape/cmscore/request/RequestDefaultStub.java new file mode 100644 index 000000000..fd53c2ea9 --- /dev/null +++ b/base/common/test/com/netscape/cmscore/request/RequestDefaultStub.java @@ -0,0 +1,269 @@ +package com.netscape.cmscore.request; + +import java.math.BigInteger; +import java.util.Date; +import java.util.Enumeration; +import java.util.Hashtable; +import java.util.Locale; +import java.util.Vector; + +import netscape.security.x509.CertificateExtensions; +import netscape.security.x509.CertificateSubjectName; +import netscape.security.x509.RevokedCertImpl; +import netscape.security.x509.X509CertImpl; +import netscape.security.x509.X509CertInfo; + +import com.netscape.certsrv.authentication.IAuthToken; +import com.netscape.certsrv.base.IAttrSet; +import com.netscape.certsrv.request.IRequest; +import com.netscape.certsrv.request.RequestId; +import com.netscape.certsrv.request.RequestStatus; + +/** + * Default testing stub for the IRequest interface. + */ +public class RequestDefaultStub implements IRequest { + public RequestId getRequestId() { + return null; + } + + public RequestStatus getRequestStatus() { + return null; + } + + public String getSourceId() { + return null; + } + + public void setSourceId(String id) { + } + + public String getRequestOwner() { + return null; + } + + public void setRequestOwner(String owner) { + } + + public String getRequestType() { + return null; + } + + public void setRequestType(String type) { + } + + public String getRequestVersion() { + return null; + } + + public Date getCreationTime() { + return null; + } + + public Date getModificationTime() { + return null; + } + + public void set(String type, Object value) { + } + + public Object get(String type) { + return null; + } + + public Enumeration<String> getAttrNames() { + return null; + } + + public void deleteExtData(String type) { + } + + public void copyContents(IRequest req) { + } + + public String getContext() { + return null; + } + + public void setContext(String ctx) { + } + + public void setRequestStatus(RequestStatus s) { + } + + public boolean isSuccess() { + return false; + } + + public String getError(Locale locale) { + return null; + } + + public boolean setExtData(String key, String value) { + return false; + } + + public boolean setExtData(String key, Hashtable<String, String> value) { + return false; + } + + public boolean isSimpleExtDataValue(String key) { + return false; + } + + public String getExtDataInString(String key) { + return null; + } + + public Hashtable<String, String> getExtDataInHashtable(String key) { + return null; + } + + public Enumeration<String> getExtDataKeys() { + return null; + } + + public boolean setExtData(String key, String[] values) { + return false; + } + + public String[] getExtDataInStringArray(String key) { + return new String[0]; + } + + public boolean setExtData(String key, String subkey, String value) { + return false; + } + + public String getExtDataInString(String key, String subkey) { + return null; + } + + public boolean setExtData(String key, Integer value) { + return false; + } + + public Integer getExtDataInInteger(String key) { + return null; + } + + public boolean setExtData(String key, Integer[] values) { + return false; + } + + public Integer[] getExtDataInIntegerArray(String key) { + return new Integer[0]; + } + + public boolean setExtData(String key, BigInteger value) { + return false; + } + + public BigInteger getExtDataInBigInteger(String key) { + return null; + } + + public boolean setExtData(String key, BigInteger[] values) { + return false; + } + + public BigInteger[] getExtDataInBigIntegerArray(String key) { + return new BigInteger[0]; + } + + public boolean setExtData(String key, Throwable e) { + return false; + } + + public boolean setExtData(String key, byte[] data) { + return false; + } + + public byte[] getExtDataInByteArray(String key) { + return new byte[0]; + } + + public boolean setExtData(String key, X509CertImpl data) { + return false; + } + + public X509CertImpl getExtDataInCert(String key) { + return null; + } + + public boolean setExtData(String key, X509CertImpl[] data) { + return false; + } + + public X509CertImpl[] getExtDataInCertArray(String key) { + return new X509CertImpl[0]; + } + + public boolean setExtData(String key, X509CertInfo data) { + return false; + } + + public X509CertInfo getExtDataInCertInfo(String key) { + return null; + } + + public boolean setExtData(String key, X509CertInfo[] data) { + return false; + } + + public X509CertInfo[] getExtDataInCertInfoArray(String key) { + return new X509CertInfo[0]; + } + + public boolean setExtData(String key, RevokedCertImpl[] data) { + return false; + } + + public RevokedCertImpl[] getExtDataInRevokedCertArray(String key) { + return new RevokedCertImpl[0]; + } + + public boolean setExtData(String key, Vector<?> data) { + return false; + } + + public Vector<String> getExtDataInStringVector(String key) { + return null; + } + + public boolean getExtDataInBoolean(String type, boolean defVal) { + return false; + } + + public boolean getExtDataInBoolean(String prefix, String type, boolean defVal) { + return false; + } + + public boolean setExtData(String key, IAuthToken data) { + return false; + } + + public IAuthToken getExtDataInAuthToken(String key) { + return null; + } + + public boolean setExtData(String key, CertificateExtensions data) { + return false; + } + + public CertificateExtensions getExtDataInCertExts(String key) { + return null; + } + + public boolean setExtData(String key, CertificateSubjectName data) { + return false; + } + + public CertificateSubjectName getExtDataInCertSubjectName(String key) { + return null; + } + + public IAttrSet asIAttrSet() { + return null; + } +} diff --git a/base/common/test/com/netscape/cmscore/request/RequestModDefaultStub.java b/base/common/test/com/netscape/cmscore/request/RequestModDefaultStub.java new file mode 100644 index 000000000..730928bdb --- /dev/null +++ b/base/common/test/com/netscape/cmscore/request/RequestModDefaultStub.java @@ -0,0 +1,21 @@ +package com.netscape.cmscore.request; + +import java.util.Date; + +import com.netscape.certsrv.request.IRequest; +import com.netscape.certsrv.request.RequestStatus; +import com.netscape.certsrv.request.ldap.IRequestMod; + +/** + * Default testing stub for the IRequest interface. + */ +public class RequestModDefaultStub implements IRequestMod { + public void modRequestStatus(IRequest r, RequestStatus s) { + } + + public void modCreationTime(IRequest r, Date d) { + } + + public void modModificationTime(IRequest r, Date d) { + } +} diff --git a/base/common/test/com/netscape/cmscore/request/RequestQueueTest.java b/base/common/test/com/netscape/cmscore/request/RequestQueueTest.java new file mode 100644 index 000000000..a66326d03 --- /dev/null +++ b/base/common/test/com/netscape/cmscore/request/RequestQueueTest.java @@ -0,0 +1,60 @@ +package com.netscape.cmscore.request; + +import java.util.Arrays; +import java.util.Collections; +import java.util.Enumeration; + +import junit.framework.Test; +import junit.framework.TestSuite; + +import com.netscape.certsrv.base.EBaseException; +import com.netscape.cmscore.test.CMSBaseTestCase; + +public class RequestQueueTest extends CMSBaseTestCase { + RequestStub request; + RequestQueue queue; + + public RequestQueueTest(String name) { + super(name); + } + + public void cmsTestSetUp() { + request = new RequestStub(); + try { + queue = new RequestQueue("", 1, null, null, null, null); + } catch (EBaseException e) { + e.printStackTrace(); + } + } + + public void cmsTestTearDown() { + } + + public static Test suite() { + return new TestSuite(RequestQueueTest.class); + } + + public void testAddRequest() throws EBaseException { + assertFalse(request.getExtDataKeysCalled); + queue.addRequest(request); + assertTrue(request.getExtDataKeysCalled); + } + + class RequestStub extends RequestDefaultStub { + String[] keys = new String[] { "key1", "key2" }; + boolean getExtDataKeysCalled = false; + + public Enumeration<String> getExtDataKeys() { + getExtDataKeysCalled = true; + return Collections.enumeration(Arrays.asList(keys)); + } + + public boolean isSimpleExtDataValue(String key) { + return true; + } + + public String getExtDataInString(String key) { + return ""; + } + } +} diff --git a/base/common/test/com/netscape/cmscore/request/RequestRecordTest.java b/base/common/test/com/netscape/cmscore/request/RequestRecordTest.java new file mode 100644 index 000000000..0ebf3beab --- /dev/null +++ b/base/common/test/com/netscape/cmscore/request/RequestRecordTest.java @@ -0,0 +1,168 @@ +package com.netscape.cmscore.request; + +import java.util.Hashtable; + +import junit.framework.Test; +import junit.framework.TestSuite; + +import com.netscape.certsrv.base.EBaseException; +import com.netscape.certsrv.dbs.EDBException; +import com.netscape.certsrv.dbs.IDBAttrMapper; +import com.netscape.certsrv.dbs.IDBDynAttrMapper; +import com.netscape.certsrv.dbs.IDBRegistry; +import com.netscape.certsrv.dbs.ModificationSet; +import com.netscape.certsrv.request.IRequestRecord; +import com.netscape.certsrv.request.RequestId; +import com.netscape.cmscore.dbs.DBRegistryDefaultStub; +import com.netscape.cmscore.dbs.DBSubsystemDefaultStub; +import com.netscape.cmscore.test.CMSBaseTestCase; +import com.netscape.cmscore.test.TestHelper; + +public class RequestRecordTest extends CMSBaseTestCase { + + RequestRecord requestRecord; + Request request; + + public RequestRecordTest(String name) { + super(name); + } + + public void cmsTestSetUp() { + requestRecord = new RequestRecord(); + request = new Request(new RequestId("0xabcdef")); + } + + public void cmsTestTearDown() { + } + + public static Test suite() { + return new TestSuite(RequestRecordTest.class); + } + + public void testGetExtData() { + Hashtable<String, Object> hash = new Hashtable<String, Object>(); + + assertNotSame(hash, requestRecord.get(IRequestRecord.ATTR_EXT_DATA)); + requestRecord.mExtData = hash; + assertSame(hash, requestRecord.get(IRequestRecord.ATTR_EXT_DATA)); + } + + public void testSetExtData() { + Hashtable<String, Object> hash = new Hashtable<String, Object>(); + + assertNotSame(requestRecord.mExtData, hash); + requestRecord.set(IRequestRecord.ATTR_EXT_DATA, hash); + assertSame(requestRecord.mExtData, hash); + } + + public void testGetElements() { + assertTrue(TestHelper.enumerationContains(requestRecord.getElements(), + IRequestRecord.ATTR_EXT_DATA)); + } + + public void testAddExtData() throws EBaseException { + request.setExtData("foo", "bar"); + Hashtable<String, String> requestHashValue = new Hashtable<String, String>(); + requestHashValue.put("red", "rum"); + requestHashValue.put("blue", "gin"); + request.setExtData("hashkey", requestHashValue); + + requestRecord.add(request); + + assertEquals(request.mExtData, requestRecord.mExtData); + assertNotSame(request.mExtData, requestRecord.mExtData); + } + + public void testReadExtData() throws EBaseException { + Hashtable<String, Object> extData = new Hashtable<String, Object>(); + extData.put("foo", "bar"); + Hashtable<String, String> extDataHashValue = new Hashtable<String, String>(); + extDataHashValue.put("red", "rum"); + extDataHashValue.put("blue", "gin"); + extData.put("hashkey", extDataHashValue); + requestRecord.set(IRequestRecord.ATTR_EXT_DATA, extData); + requestRecord.mRequestType = "foo"; + + requestRecord.read(new RequestModDefaultStub(), request); + + // the request stores other attributes inside its mExtData when some + // of its setters are called, so we have to compare manually. + assertEquals("bar", request.mExtData.get("foo")); + assertEquals(extDataHashValue, request.mExtData.get("hashkey")); + assertNotSame(requestRecord.mExtData, request.mExtData); + } + + public void testModExtData() throws EBaseException { + ModificationSetStub mods = new ModificationSetStub(); + request.setExtData("foo", "bar"); + + RequestRecord.mod(mods, request); + + assertTrue(mods.addCalledWithExtData); + assertEquals(mods.addExtDataObject, request.mExtData); + } + + public void testRegister() throws EDBException { + DBSubsystemStub db = new DBSubsystemStub(); + + RequestRecord.register(db); + + assertTrue(db.registry.registerCalledWithExtAttr); + assertTrue(db.registry.extAttrMapper instanceof ExtAttrDynMapper); + + assertTrue(db.registry.registerObjectClassCalled); + assertTrue(TestHelper.contains(db.registry.registerObjectClassLdapNames, + "extensibleObject")); + + assertTrue(db.registry.registerDynamicMapperCalled); + assertTrue(db.registry.dynamicMapper instanceof ExtAttrDynMapper); + } + + class ModificationSetStub extends ModificationSet { + public boolean addCalledWithExtData = false; + public Object addExtDataObject = null; + + public void add(String name, int op, Object value) { + if (IRequestRecord.ATTR_EXT_DATA.equals(name)) { + addCalledWithExtData = true; + addExtDataObject = value; + } + } + } + + class DBSubsystemStub extends DBSubsystemDefaultStub { + DBRegistryStub registry = new DBRegistryStub(); + + public IDBRegistry getRegistry() { + return registry; + } + } + + class DBRegistryStub extends DBRegistryDefaultStub { + boolean registerCalledWithExtAttr = false; + IDBAttrMapper extAttrMapper = null; + + boolean registerObjectClassCalled = false; + String[] registerObjectClassLdapNames = null; + + private boolean registerDynamicMapperCalled = false; + private IDBDynAttrMapper dynamicMapper; + + public void registerObjectClass(String className, String ldapNames[]) throws EDBException { + registerObjectClassCalled = true; + registerObjectClassLdapNames = ldapNames; + } + + public void registerAttribute(String ufName, IDBAttrMapper mapper) throws EDBException { + if (IRequestRecord.ATTR_EXT_DATA.equals(ufName)) { + registerCalledWithExtAttr = true; + extAttrMapper = mapper; + } + } + + public void registerDynamicMapper(IDBDynAttrMapper mapper) { + registerDynamicMapperCalled = true; + dynamicMapper = mapper; + } + } +} diff --git a/base/common/test/com/netscape/cmscore/request/RequestTest.java b/base/common/test/com/netscape/cmscore/request/RequestTest.java new file mode 100644 index 000000000..5832f6af5 --- /dev/null +++ b/base/common/test/com/netscape/cmscore/request/RequestTest.java @@ -0,0 +1,649 @@ +package com.netscape.cmscore.request; + +import java.io.IOException; +import java.math.BigInteger; +import java.security.cert.CRLException; +import java.security.cert.CertificateEncodingException; +import java.security.cert.CertificateException; +import java.util.Hashtable; +import java.util.Vector; + +import junit.framework.Test; +import junit.framework.TestSuite; +import netscape.security.x509.BasicConstraintsExtension; +import netscape.security.x509.CertificateExtensions; +import netscape.security.x509.CertificateSubjectName; +import netscape.security.x509.PKIXExtensions; +import netscape.security.x509.RevokedCertImpl; +import netscape.security.x509.X500Name; +import netscape.security.x509.X509CertImpl; +import netscape.security.x509.X509CertInfo; + +import com.netscape.certsrv.app.CMSEngineDefaultStub; +import com.netscape.certsrv.apps.CMS; +import com.netscape.certsrv.authentication.AuthToken; +import com.netscape.certsrv.authentication.IAuthToken; +import com.netscape.certsrv.base.EBaseException; +import com.netscape.certsrv.request.RequestId; +import com.netscape.cmscore.test.CMSBaseTestCase; +import com.netscape.cmscore.test.TestHelper; + +public class RequestTest extends CMSBaseTestCase { + + Request request; + CMSMemoryStub cmsStub; + + public RequestTest(String name) { + super(name); + } + + public void cmsTestSetUp() { + // this is needed because of CMS.AtoB/BtoA calls + cmsStub = new CMSMemoryStub(); + CMS.setCMSEngine(cmsStub); + + request = new Request(new RequestId("0xabcdef")); + } + + public void cmsTestTearDown() { + } + + public static Test suite() { + return new TestSuite(RequestTest.class); + } + + public void testIsValidKey() { + assertTrue(request.isValidExtDataKey("foo")); + assertTrue(request.isValidExtDataKey("BARBAZ")); + assertTrue(request.isValidExtDataKey("1122")); + assertTrue(request.isValidExtDataKey("-")); + assertTrue(request.isValidExtDataKey("1a-22")); + assertTrue(request.isValidExtDataKey("a;b")); + assertTrue(request.isValidExtDataKey("_")); + assertTrue(request.isValidExtDataKey("this.is.encoded")); + assertTrue(request.isValidExtDataKey("spaces are too")); + + assertFalse(request.isValidExtDataKey(null)); + assertFalse(request.isValidExtDataKey("")); + } + + public void testIsSimpleExtDataValue() { + request.mExtData.put("simple1", "foo"); + request.mExtData.put("complex1", new Hashtable<String, Object>()); + + assertTrue(request.isSimpleExtDataValue("simple1")); + assertFalse(request.isSimpleExtDataValue("complex1")); + assertFalse(request.isSimpleExtDataValue("doesn't exist")); + } + + public void testSetExtStringData() { + request.setExtData("foo", "bar"); + request.setExtData("foo2", "bar2"); + assertEquals("bar", request.mExtData.get("foo")); + assertEquals("bar2", request.mExtData.get("foo2")); + + request.setExtData("foo", "newvalue"); + assertEquals("newvalue", request.mExtData.get("foo")); + + request.setExtData("UPPER", "CASE"); + assertEquals("CASE", request.mExtData.get("upper")); + + assertFalse(request.setExtData("key", (String) null)); + } + + public void testVerifyValidExtDataHashtable() { + Hashtable<String, String> valueHash = new Hashtable<String, String>(); + + valueHash.put("key1", "val1"); + valueHash.put("key;2", "val2"); + assertTrue(request.isValidExtDataHashtableValue(valueHash)); + + valueHash.clear(); + valueHash.put("", "bar"); + assertFalse(request.isValidExtDataHashtableValue(valueHash)); + } + + @SuppressWarnings({ "unchecked", "rawtypes" }) + public void testSetExtHashtableData() { + Hashtable<String, String> valueHash = new Hashtable<String, String>(); + + valueHash.put("key1", "val1"); + valueHash.put("KEY2", "val2"); + + request.setExtData("TOPKEY", valueHash); + + Hashtable<String, String> out = request.getExtDataInHashtable("topkey"); + assertNotNull(out); + + assertTrue(out.containsKey("key1")); + assertEquals("val1", out.get("key1")); + + assertTrue(out.containsKey("key2")); + assertEquals("val2", out.get("key2")); + + valueHash.put("", "value"); + assertFalse(request.setExtData("topkey2", valueHash)); + + assertFalse(request.setExtData("topkey3", (Hashtable) null)); + } + + public void testGetExtDataInString() { + request.mExtData.put("strkey", "strval"); + Hashtable<String, String> hashValue = new Hashtable<String, String>(); + hashValue.put("uh", "oh"); + request.mExtData.put("hashkey", hashValue); + + assertEquals("strval", request.getExtDataInString("strkey")); + assertEquals("strval", request.getExtDataInString("STRKEY")); + assertEquals(null, request.getExtDataInString("notfound")); + + assertNull(request.getExtDataInString("hashkey")); + } + + public void testGetExtDataInHashtable() { + request.mExtData.put("strkey", "strval"); + Hashtable<String, String> hashValue = new Hashtable<String, String>(); + hashValue.put("uh", "oh"); + request.mExtData.put("hashkey", hashValue); + + Hashtable<String, String> out = request.getExtDataInHashtable("HASHKEY"); + assertNotNull(out); + assertNull(request.getExtDataInHashtable("notfound")); + assertNull(request.getExtDataInHashtable("strkey")); + + // Check the bevaiour of the returned hash + assertEquals("oh", out.get("UH")); + + // check that we can't change the ExtData by altering the Hashtable + hashValue = request.getExtDataInHashtable("hashkey"); + hashValue.put("newhashkey", "newhashvalue"); + hashValue = request.getExtDataInHashtable("hashkey"); + assertFalse(hashValue.containsKey("newhashkey")); + } + + public void testGetExtDataKeys() { + request.setExtData("FOO", "val1"); + request.setExtData("bar", new Hashtable<String, String>()); + + assertTrue(TestHelper.enumerationContains(request.getExtDataKeys(), "foo")); + assertTrue(TestHelper.enumerationContains(request.getExtDataKeys(), "bar")); + } + + public void testSetExtDataSubkeyValue() { + // creates hashtable first time + assertNull(request.getExtDataInHashtable("topkey")); + request.setExtData("TOPKEY", "SUBKEY", "value"); + Hashtable<String, String> value = request.getExtDataInHashtable("topkey"); + assertNotNull(value); + assertTrue(value.containsKey("subkey")); + assertEquals("value", value.get("subkey")); + + // adds to existing hashtable + assertNull(request.getExtDataInHashtable("topkey2")); + value = new Hashtable<String, String>(); + value.put("subkey2", "value2"); + request.setExtData("topkey2", value); + request.setExtData("TOPKEY2", "subkey3", "value3"); + value = request.getExtDataInHashtable("topkey2"); + assertNotNull(value); + assertTrue(value.containsKey("subkey2")); + assertTrue(value.containsKey("subkey3")); + assertEquals("value3", value.get("subkey3")); + + // can't sneak a bad topkey or subkey in this way + assertFalse(request.setExtData("", "value", "value")); + assertNull(request.getExtDataInHashtable("")); + + assertFalse(request.setExtData("key", "", "value")); + assertNull(request.getExtDataInHashtable("key")); + + // can't sneak into an existing hashtable + // this key was added above + assertFalse(request.setExtData("topkey", "", "value")); + value = request.getExtDataInHashtable("topkey"); + assertNotNull(value); + assertFalse(value.containsKey("")); + + // Illegal values + assertFalse(request.setExtData((String) null, "b", "c")); + assertFalse(request.setExtData("a", (String) null, "c")); + assertFalse(request.setExtData("a", "b", (String) null)); + } + + public void testGetExtDataSubkeyValue() { + Hashtable<String, String> value = new Hashtable<String, String>(); + value.put("subkey", "value"); + + request.setExtData("topkey", value); + + assertEquals("value", request.getExtDataInString("topkey", "SUBKEY")); + assertNull(request.getExtDataInString("badkey", "subkey")); + assertNull(request.getExtDataInString("topkey", "badkey")); + } + + public void testGetSetExtDataInteger() { + request.setExtData("foo", new Integer(234)); + + assertNotNull(request.mExtData.get("foo")); + assertEquals("234", request.mExtData.get("foo")); + + assertEquals(new Integer(234), + request.getExtDataInInteger("foo")); + + request.setExtData("strkey", "bar"); + assertNull(request.getExtDataInInteger("strkey")); + assertNull(request.getExtDataInInteger("notfound")); + + assertFalse(request.setExtData("key", (Integer) null)); + } + + public void testGetSetExtDataIntegerArray() { + Integer[] data = new Integer[] { + new Integer(5), + new Integer(23), + new Integer(12) + }; + assertTrue(request.setExtData("topkey1", data)); + Integer[] retval = request.getExtDataInIntegerArray("topkey1"); + assertEquals(3, retval.length); + assertEquals(data[0], retval[0]); + assertEquals(data[1], retval[1]); + assertEquals(data[2], retval[2]); + + // invalid conversion + Hashtable<String, String> hashValue = new Hashtable<String, String>(); + hashValue.put("0", "5"); + hashValue.put("1", "bar"); + request.setExtData("topkey2", hashValue); + assertNull(request.getExtDataInIntegerArray("topkey2")); + + assertFalse(request.setExtData("key", (Integer[]) null)); + } + + public void testGetSetExtDataBigInteger() { + request.setExtData("foo", new BigInteger("234234234234")); + + assertNotNull(request.mExtData.get("foo")); + assertEquals("234234234234", request.mExtData.get("foo")); + + assertEquals(new BigInteger("234234234234"), + request.getExtDataInBigInteger("foo")); + + request.setExtData("strkey", "bar"); + assertNull(request.getExtDataInBigInteger("strkey")); + assertNull(request.getExtDataInBigInteger("notfound")); + + assertFalse(request.setExtData("key", (BigInteger) null)); + } + + public void testGetSetExtDataBigIntegerArray() { + BigInteger[] data = new BigInteger[] { + new BigInteger("111111111"), + new BigInteger("222222222"), + new BigInteger("333333333") + }; + assertTrue(request.setExtData("topkey1", data)); + BigInteger[] retval = request.getExtDataInBigIntegerArray("topkey1"); + assertEquals(3, retval.length); + assertEquals(data[0], retval[0]); + assertEquals(data[1], retval[1]); + assertEquals(data[2], retval[2]); + + // invalid conversion + Hashtable<String, String> hashValue = new Hashtable<String, String>(); + hashValue.put("0", "5"); + hashValue.put("1", "bar"); + request.setExtData("topkey2", hashValue); + assertNull(request.getExtDataInBigIntegerArray("topkey2")); + + assertFalse(request.setExtData("key", (BigInteger[]) null)); + } + + public void testSetExtDataThrowable() { + EBaseException e = new EBaseException("This is an error"); + + request.setExtData("key", e); + + assertEquals(e.toString(), request.mExtData.get("key")); + + assertFalse(request.setExtData("key", (Throwable) null)); + } + + public void testGetSetByteArray() { + byte[] data = new byte[] { 112, 96, 0, -12 }; + + assertFalse(cmsStub.bToACalled); + request.setExtData("key", data); + assertTrue(cmsStub.bToACalled); + assertEquals(data, cmsStub.bToACalledWith); + + assertFalse(cmsStub.aToBCalled); + byte[] out = request.getExtDataInByteArray("key"); + assertTrue(cmsStub.aToBCalled); + assertEquals(data, out); + + assertFalse(request.setExtData("key", (byte[]) null)); + } + + public void testGetSetCert() throws CertificateException { + X509CertImpl cert = getFakeCert(); + + assertFalse(cmsStub.bToACalled); + assertTrue(request.setExtData("key", cert)); + assertTrue(cmsStub.bToACalled); + + assertFalse(cmsStub.aToBCalled); + X509CertImpl retval = request.getExtDataInCert("key"); + assertTrue(cmsStub.aToBCalled); + assertEquals(cert, retval); + + assertFalse(request.setExtData("key", (X509CertImpl) null)); + } + + public void testGetSetCertArray() throws CertificateException { + // this test is also pretty weak, but fortunately relies on the + // building blocks. + X509CertImpl[] vals = new X509CertImpl[] { + getFakeCert(), + getFakeCert() + }; + + assertTrue(request.setExtData("key", vals)); + Hashtable<?, ?> hashVals = (Hashtable<?, ?>) request.mExtData.get("key"); + assertEquals(2, hashVals.keySet().size()); + + assertFalse(cmsStub.aToBCalled); + X509CertImpl[] retval = request.getExtDataInCertArray("key"); + assertTrue(cmsStub.aToBCalled); + + assertEquals(2, retval.length); + assertEquals(vals[0], retval[0]); + assertEquals(vals[1], retval[1]); + + assertFalse(request.setExtData("key", (X509CertImpl[]) null)); + } + + public void testGetSetStringArray() { + String[] value = new String[] { "blue", "green", "red", "orange" }; + assertTrue(request.setExtData("key", value)); + + assertTrue(request.mExtData.containsKey("key")); + @SuppressWarnings("unchecked") + Hashtable<String, String> hashValue = (Hashtable<String, String>) request.mExtData.get("key"); + assertTrue(hashValue.containsKey("0")); + assertTrue(hashValue.containsKey("1")); + assertTrue(hashValue.containsKey("2")); + assertTrue(hashValue.containsKey("3")); + assertEquals("blue", hashValue.get("0")); + assertEquals("green", hashValue.get("1")); + assertEquals("red", hashValue.get("2")); + assertEquals("orange", hashValue.get("3")); + + String[] retval = request.getExtDataInStringArray("key"); + assertEquals(4, retval.length); + assertEquals("blue", retval[0]); + assertEquals("green", retval[1]); + assertEquals("red", retval[2]); + assertEquals("orange", retval[3]); + + // Try with sparse input + hashValue = new Hashtable<String, String>(); + hashValue.put("0", "square"); + hashValue.put("4", "triangle"); + hashValue.put("6", "octogon"); + request.setExtData("kevin", hashValue); + + retval = request.getExtDataInStringArray("kevin"); + assertEquals(7, retval.length); + assertEquals("square", retval[0]); + assertNull(retval[1]); + assertNull(retval[2]); + assertNull(retval[3]); + assertEquals("triangle", retval[4]); + assertNull(retval[5]); + assertEquals("octogon", retval[6]); + + // invalid conversion + hashValue = new Hashtable<String, String>(); + hashValue.put("0", "foo"); + hashValue.put("badkey", "bar"); + request.setExtData("cory", hashValue); + assertNull(request.getExtDataInStringArray("cory")); + + assertFalse(request.setExtData("key", (String[]) null)); + + } + + public void testGetSetStringVector() { + Vector<String> stringVector = new Vector<String>(); + stringVector.add("blue"); + stringVector.add("green"); + stringVector.add("red"); + stringVector.add("orange"); + + assertTrue(request.setExtData("key", stringVector)); + + assertTrue(request.mExtData.containsKey("key")); + @SuppressWarnings("unchecked") + Hashtable<String, String> hashValue = (Hashtable<String, String>) request.mExtData.get("key"); + assertTrue(hashValue.containsKey("0")); + assertTrue(hashValue.containsKey("1")); + assertTrue(hashValue.containsKey("2")); + assertTrue(hashValue.containsKey("3")); + assertEquals("blue", hashValue.get("0")); + assertEquals("green", hashValue.get("1")); + assertEquals("red", hashValue.get("2")); + assertEquals("orange", hashValue.get("3")); + + Vector<String> retval = request.getExtDataInStringVector("key"); + assertEquals(4, retval.size()); + assertEquals("blue", retval.elementAt(0)); + assertEquals("green", retval.elementAt(1)); + assertEquals("red", retval.elementAt(2)); + assertEquals("orange", retval.elementAt(3)); + + // invalid conversion + hashValue = new Hashtable<String, String>(); + hashValue.put("0", "foo"); + hashValue.put("badkey", "bar"); + request.setExtData("cory", hashValue); + assertNull(request.getExtDataInStringVector("cory")); + + assertFalse(request.setExtData("key", (Vector<?>) null)); + } + + public void testGetSetCertInfo() { + X509CertInfoStub cert = new X509CertInfoStub(); + + assertFalse(cmsStub.bToACalled); + assertFalse(cert.getEncodedCalled); + assertTrue(request.setExtData("key", cert)); + assertTrue(cmsStub.bToACalled); + assertTrue(cert.getEncodedCalled); + + // this is a pretty weak test, but it's hard to assert much here + assertFalse(cmsStub.aToBCalled); + request.getExtDataInCertInfo("key"); + assertTrue(cmsStub.aToBCalled); + + assertFalse(request.setExtData("key", (X509CertInfo) null)); + } + + public void testGetSetCertInfoArray() { + X509CertInfo[] vals = new X509CertInfoStub[] { + new X509CertInfoStub(), + new X509CertInfoStub() + }; + + assertTrue(request.setExtData("key", vals)); + Hashtable<?, ?> hashVals = (Hashtable<?, ?>) request.mExtData.get("key"); + assertEquals(2, hashVals.keySet().size()); + + assertFalse(cmsStub.aToBCalled); + request.getExtDataInCertInfoArray("key"); + assertTrue(cmsStub.aToBCalled); + + assertFalse(request.setExtData("key", (X509CertInfo[]) null)); + } + + public void testGetBoolean() { + Hashtable<String, String> hashValue = new Hashtable<String, String>(); + hashValue.put("one", "false"); + hashValue.put("two", "true"); + hashValue.put("three", "on"); + hashValue.put("four", "off"); + request.mExtData.put("hashkey", hashValue); + + assertFalse(request.getExtDataInBoolean("hashkey", "one", true)); + assertTrue(request.getExtDataInBoolean("hashkey", "two", false)); + assertTrue(request.getExtDataInBoolean("hashkey", "three", false)); + assertFalse(request.getExtDataInBoolean("hashkey", "four", true)); + + assertTrue(request.getExtDataInBoolean("notfound", "nope", true)); + assertTrue(request.getExtDataInBoolean("hashkey", "notfound", true)); + + assertFalse(request.getExtDataInBoolean("notfound", "nope", false)); + assertFalse(request.getExtDataInBoolean("hashkey", "notfound", false)); + + request.mExtData.put("one", "false"); + request.mExtData.put("two", "true"); + request.mExtData.put("three", "on"); + request.mExtData.put("four", "off"); + + assertFalse(request.getExtDataInBoolean("one", true)); + assertTrue(request.getExtDataInBoolean("two", false)); + assertTrue(request.getExtDataInBoolean("three", false)); + assertFalse(request.getExtDataInBoolean("four", true)); + + assertTrue(request.getExtDataInBoolean("notfound", true)); + assertFalse(request.getExtDataInBoolean("notfound", false)); + } + + public void testGetSetRevokedCertArray() { + RevokedCertImpl[] vals = new RevokedCertImplStub[] { + new RevokedCertImplStub(), + new RevokedCertImplStub() + }; + + assertTrue(request.setExtData("key", vals)); + Hashtable<?, ?> hashVals = (Hashtable<?, ?>) request.mExtData.get("key"); + assertEquals(2, hashVals.keySet().size()); + + assertFalse(cmsStub.aToBCalled); + request.getExtDataInCertInfoArray("key"); + assertTrue(cmsStub.aToBCalled); + + assertFalse(request.setExtData("key", (RevokedCertImpl[]) null)); + } + + public void testGetSetCertExts() throws IOException { + CertificateExtensions exts = new CertificateExtensions(); + BasicConstraintsExtension ext = new BasicConstraintsExtension(false, 1); + + // check if empty CertificateExtensions work + assertTrue(request.setExtData("key", exts)); + CertificateExtensions retval = request.getExtDataInCertExts("key"); + assertNotNull(retval); + assertEquals(0, retval.size()); + + exts.set(PKIXExtensions.BasicConstraints_Id.toString(), ext); + assertTrue(request.setExtData("key2", exts)); + assertTrue(request.mExtData.containsKey("key2")); + + retval = request.getExtDataInCertExts("key2"); + assertNotNull(retval); + assertEquals(1, retval.size()); + + assertFalse(request.setExtData("key", (CertificateExtensions) null)); + } + + public void testGetSetCertSubjectName() throws IOException { + CertificateSubjectName name = new CertificateSubjectName( + new X500Name("cn=kevin")); + assertTrue(request.setExtData("key", name)); + assertTrue(request.mExtData.containsKey("key")); + + CertificateSubjectName retval = request.getExtDataInCertSubjectName("key"); + assertNotNull(retval); + // the 'CN=' is uppercased at some point + assertEquals("cn=kevin", + retval.get(CertificateSubjectName.DN_NAME).toString().toLowerCase()); + + assertFalse(request.setExtData("key", (CertificateSubjectName) null)); + } + + public void testGetSetAuthToken() { + AuthToken token = new AuthToken(null); + token.set("key1", "val1"); + token.set("key2", "val2"); + token.set("key3", Integer.valueOf(5)); + + assertTrue(request.setExtData("key", token)); + + IAuthToken retval = request.getExtDataInAuthToken("key"); + assertNotNull(retval); + + assertEquals(token.getInString("key1"), retval.getInString("key1")); + assertEquals(token.getInString("key2"), retval.getInString("key2")); + assertEquals(token.getInInteger("key3"), retval.getInInteger("key3")); + + assertFalse(request.setExtData("key", (AuthToken) null)); + } + + /** + * CMSMemoryStub + * + * This class is used to help test methods that rely on setting and then + * getting a value out. It assumes BtoA is always called first, stores + * the value passed in, and then returns that value for BtoA. + */ + class CMSMemoryStub extends CMSEngineDefaultStub { + boolean bToACalled = false; + byte[] bToACalledWith = null; + + boolean aToBCalled = false; + String aToBCalledWith = null; + + public String BtoA(byte data[]) { + bToACalled = true; + bToACalledWith = data; + return "garbagetostoreinthehash"; + } + + public byte[] AtoB(String data) { + aToBCalled = true; + aToBCalledWith = data; + return bToACalledWith; + } + } + + class X509CertInfoStub extends X509CertInfo { + /** + * + */ + private static final long serialVersionUID = -821992386369710423L; + boolean getEncodedCalled = false; + + public X509CertInfoStub() { + } + + public byte[] getEncodedInfo(boolean ignoreCache) throws CertificateEncodingException { + getEncodedCalled = true; + return new byte[] {}; + } + } + + class RevokedCertImplStub extends RevokedCertImpl { + /** + * + */ + private static final long serialVersionUID = -9088436260566619005L; + boolean getEncodedCalled = false; + + public byte[] getEncoded() throws CRLException { + getEncodedCalled = true; + return new byte[] {}; + } + } + +} |