Add GUI

Signed-off-by: Yuuta Liang <yuutaw@student.cs.ubc.ca>

8 files changed, 281 insertions, 6 deletions

diff --git a/src/test/model/GroupObserverTest.java b/src/test/model/GroupObserverTest.java
new file mode 100644
index 0000000..618f0eb
--- /dev/null
+++ b/src/test/model/GroupObserverTest.java
@@ -0,0 +1,65 @@
+package model;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class GroupObserverTest {
+    private GroupObserver target;
+
+    private MockObserver<Integer> obsInt;
+    private MockObserver<String> obsStr;
+
+    private MockObserver<Observer> obsObs;
+
+    private MockObserver<ArrayList> obsArrList;
+
+    private MockObserver<List> obsList;
+
+    @BeforeEach
+    void setup() {
+        target = new GroupObserver();
+        obsInt = new MockObserver<>();
+        obsStr = new MockObserver<>();
+        obsObs = new MockObserver<>();
+        obsArrList = new MockObserver<>();
+        obsList = new MockObserver<>();
+        target.register(Integer.class, obsInt);
+        target.register(String.class, obsStr);
+        target.register(Observer.class, obsObs);
+        target.register(List.class, obsList);
+        target.register(ArrayList.class, obsArrList);
+    }
+
+    @Test
+    void testRegister() {
+        assertEquals(5, target.getRegisteredObserverCount());
+    }
+
+    @Test
+    void testAccept() {
+        target.accept(this, Observer.DIRECTION_CHANGE, 100);
+        assertEquals(0, obsInt.getCount());
+        assertEquals(0, obsStr.getCount());
+
+        target.accept("123", Observer.DIRECTION_CHANGE, 1000);
+        obsStr.assertCalled(Observer.DIRECTION_CHANGE);
+        assertEquals(0, obsInt.getCount());
+        assertEquals(1000, obsStr.getIndex());
+
+        target.accept(114514, Observer.DIRECTION_ADD, 1919810);
+        obsInt.assertCalled(Observer.DIRECTION_ADD);
+        assertEquals(1919810, obsInt.getIndex());
+
+        target.accept(obsInt, Observer.DIRECTION_CHANGE, 1);
+        obsObs.assertCalled(Observer.DIRECTION_CHANGE);
+
+        target.accept(new ArrayList<>(), Observer.DIRECTION_CHANGE, 2);
+        obsArrList.assertCalled(Observer.DIRECTION_CHANGE);
+        assertEquals(0, obsList.getCount());
+    }
+}
diff --git a/src/test/model/MockObserver.java b/src/test/model/MockObserver.java
new file mode 100644
index 0000000..bd3e79f
--- /dev/null
+++ b/src/test/model/MockObserver.java
@@ -0,0 +1,41 @@
+package model;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class MockObserver<T> implements Observer<T> {
+    private int countPrev;
+    private int count;
+    private T data;
+    private int dir;
+    private int index;
+
+    @Override
+    public void accept(T data, int direction, int index) {
+        this.count++;
+        this.data = data;
+        this.dir = direction;
+        this.index = index;
+    }
+
+    public void assertCalled(int dir) {
+        assertEquals(countPrev + 1, count);
+        assertEquals(dir, this.dir);
+        countPrev = count;
+    }
+
+    public int getCount() {
+        return count;
+    }
+
+    public T getData() {
+        return data;
+    }
+
+    public int getDir() {
+        return dir;
+    }
+
+    public int getIndex() {
+        return index;
+    }
+}
diff --git a/src/test/model/ObservedDataTest.java b/src/test/model/ObservedDataTest.java
new file mode 100644
index 0000000..60ed2ed
--- /dev/null
+++ b/src/test/model/ObservedDataTest.java
@@ -0,0 +1,44 @@
+package model;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+public class ObservedDataTest {
+    private ObservedData<Integer> target;
+
+    private int callbackCount = 0;
+    private int callbackDirection = Integer.MIN_VALUE;
+    private int callbackIndex = Integer.MIN_VALUE;
+
+    private final Observer<Integer> obs = ((data, direction, index) -> {
+        callbackCount++;
+        callbackDirection = direction;
+        callbackIndex = index;
+    });
+
+    @BeforeEach
+    void setup() {
+        target = new ObservedData<>(0, obs);
+        callbackCount = 0;
+        callbackDirection = Integer.MIN_VALUE;
+        callbackIndex = Integer.MIN_VALUE;
+    }
+
+    @Test
+    void testConstructor() {
+        assertEquals(0, target.get());
+        assertNotNull(target.getAcceptor());
+    }
+
+    @Test
+    void testSet() {
+        target.set(114514);
+        assertEquals(114514, target.get());
+        assertEquals(1, callbackCount);
+        assertEquals(Observer.DIRECTION_CHANGE, callbackDirection);
+        assertEquals(Observer.INDEX_NOT_IN_LIST, callbackIndex);
+    }
+}
diff --git a/src/test/model/asn1/ObjectIdentifierTest.java b/src/test/model/asn1/ObjectIdentifierTest.java
index 367e349..5d49821 100644
--- a/src/test/model/asn1/ObjectIdentifierTest.java
+++ b/src/test/model/asn1/ObjectIdentifierTest.java
@@ -86,4 +86,21 @@ public class ObjectIdentifierTest {
                 new ObjectIdentifier(new BytesReader(new Byte[]{0x6, 0x9, 0x2A, -122, 0x48, -122, -9, 0x0D,
                         0x01, 0x01, -117}), false));
     }
+
+    @Test
+    void testGetKnown() throws ParseException {
+        assertNotNull(ObjectIdentifier.getKnown("C"));
+        assertNotNull(ObjectIdentifier.getKnown("CN"));
+        assertNotNull(ObjectIdentifier.getKnown("O"));
+        assertNotNull(ObjectIdentifier.getKnown("OU"));
+        assertNotNull(ObjectIdentifier.getKnown("DC"));
+        assertNotNull(ObjectIdentifier.getKnown("L"));
+
+        assertNotNull(ObjectIdentifier.getKnown("oU"));
+        assertNotNull(ObjectIdentifier.getKnown("Dc"));
+        assertNotNull(ObjectIdentifier.getKnown("cn"));
+
+        assertThrows(ParseException.class, () -> ObjectIdentifier.getKnown("114514"));
+        assertThrows(ParseException.class, () -> ObjectIdentifier.getKnown("SN"));
+    }
 }
diff --git a/src/test/model/ca/CertificationAuthorityTest.java b/src/test/model/ca/CertificationAuthorityTest.java
index 0a9a3eb..7a2e50c 100644
--- a/src/test/model/ca/CertificationAuthorityTest.java
+++ b/src/test/model/ca/CertificationAuthorityTest.java
@@ -1,5 +1,8 @@
 package model.ca;
 
+import model.GroupObserver;
+import model.MockObserver;
+import model.Observer;
 import model.asn1.ASN1Object;
 import model.asn1.ObjectIdentifier;
 import model.asn1.UtcTime;
@@ -17,6 +20,11 @@ import ui.Utils;
 
 import java.math.BigInteger;
 import java.nio.charset.StandardCharsets;
+import java.security.InvalidKeyException;
+import java.security.NoSuchAlgorithmException;
+import java.security.SignatureException;
+import java.security.interfaces.RSAPublicKey;
+import java.security.spec.InvalidKeySpecException;
 import java.time.ZoneId;
 import java.time.ZonedDateTime;
 
@@ -302,6 +310,14 @@ public class CertificationAuthorityTest {
 
     private CertificationAuthority caWithPrivateKey;
 
+    private MockObserver<RSAPublicKey> obsPkey;
+    private MockObserver<Certificate> obsCrt;
+    private MockObserver<RevokedCertificate> obsRev;
+    private MockObserver<Template> obsTmp;
+    private MockObserver<AuditLogEntry> obsLog;
+
+    private GroupObserver obs = new GroupObserver();
+
     private static Certificate getCert(String pem) throws ParseException {
         return new Certificate(new BytesReader(Utils.parsePEM(Utils.byteToByte(pem.getBytes(StandardCharsets.UTF_8)),
                 "CERTIFICATE")), false);
@@ -418,17 +434,15 @@ public class CertificationAuthorityTest {
                 new Template(template.getName(), true, (Name) null, template.getValidity()));
         assertEquals(csr.getCertificationRequestInfo().getSubject().toString(),
                 cert.getCertificate().getSubject().toString());
-        assertEquals(60,
-                cert.getCertificate().getValidity().getNotAfter().getTimestamp().getDayOfYear()
-                        - cert.getCertificate().getValidity().getNotBefore().getTimestamp().getDayOfYear());
+        assertEquals(cert.getCertificate().getValidity().getNotBefore().getTimestamp(),
+                cert.getCertificate().getValidity().getNotAfter().getTimestamp().minusDays(60));
         assertEquals(1, caWithPrivateKey.getSigned().size());
         assertEquals(logCount + 1, caWithPrivateKey.getLogs().size());
 
         Template tmp = new Template(template.getName(), true, "ABCC", template.getValidity());
         cert = caWithPrivateKey.signCert(csr.getCertificationRequestInfo(), tmp);
-        assertEquals(60,
-                cert.getCertificate().getValidity().getNotAfter().getTimestamp().getDayOfYear()
-                        - cert.getCertificate().getValidity().getNotBefore().getTimestamp().getDayOfYear());
+        assertEquals(cert.getCertificate().getValidity().getNotBefore().getTimestamp(),
+                cert.getCertificate().getValidity().getNotAfter().getTimestamp().minusDays(60));
         assertEquals(tmp.getSubject().toString(), cert.getCertificate().getSubject().toString());
         assertEquals(2, caWithPrivateKey.getSigned().size());
         assertEquals(logCount + 2, caWithPrivateKey.getLogs().size());
@@ -489,4 +503,57 @@ public class CertificationAuthorityTest {
         assertEquals(++logCount, ca.getLogs().size());
         assertNull(ca.findTemplate(template.getName(), false));
     }
+
+    @Test
+    void testObservers() throws NoSuchAlgorithmException, InvalidKeySpecException, InvalidCAException, ParseException,
+            SignatureException, InvalidKeyException {
+        obs.register(RSAPublicKey.class, obsPkey = new MockObserver<>());
+        obs.register(Certificate.class, obsCrt = new MockObserver<>());
+        obs.register(RevokedCertificate.class, obsRev = new MockObserver<>());
+        obs.register(Template.class, obsTmp = new MockObserver<>());
+        obs.register(AuditLogEntry.class, obsLog = new MockObserver<>());
+        ca.registerObserver(obs);
+
+        ca.loadKey(KEY_N, KEY_P, KEY_E);
+        obsPkey.assertCalled(Observer.DIRECTION_CHANGE);
+        obsLog.assertCalled(Observer.DIRECTION_ADD);
+
+        ca.signCSR();
+        obsLog.assertCalled(Observer.DIRECTION_ADD);
+
+        ca.installCertificate(crtNormal);
+        obsCrt.assertCalled(Observer.DIRECTION_CHANGE);
+        obsLog.assertCalled(Observer.DIRECTION_ADD);
+
+        ca.addTemplate(template);
+        obsTmp.assertCalled(Observer.DIRECTION_ADD);
+        obsLog.assertCalled(Observer.DIRECTION_ADD);
+
+        ca.removeTemplate(template);
+        obsTmp.assertCalled(Observer.DIRECTION_REMOVE);
+        obsLog.assertCalled(Observer.DIRECTION_ADD);
+
+        ca.addTemplate(template);
+        obsTmp.assertCalled(Observer.DIRECTION_ADD);
+        obsLog.assertCalled(Observer.DIRECTION_ADD);
+
+        ca.setTemplateEnable(template, true);
+        obsTmp.assertCalled(Observer.DIRECTION_CHANGE);
+        obsLog.assertCalled(Observer.DIRECTION_ADD);
+
+        final Certificate cert = ca.signCert(csr.getCertificationRequestInfo(),
+                new Template(template.getName(), true, (Name) null, template.getValidity()));
+        obsCrt.assertCalled(Observer.DIRECTION_ADD);
+        obsLog.assertCalled(Observer.DIRECTION_ADD);
+
+        ca.revoke(new RevokedCertificate(ASN1Object.TAG_SEQUENCE, null,
+                cert.getCertificate().getSerialNumber(),
+                new UtcTime(UtcTime.TAG, null, ZonedDateTime.now(ZoneId.of("UTC"))),
+                Reason.KEY_COMPROMISE));
+        obsRev.assertCalled(Observer.DIRECTION_ADD);
+        obsLog.assertCalled(Observer.DIRECTION_ADD);
+
+        ca.signCRL();
+        obsLog.assertCalled(Observer.DIRECTION_ADD);
+    }
 }
diff --git a/src/test/model/ca/TemplateTest.java b/src/test/model/ca/TemplateTest.java
index 1926078..774d38c 100644
--- a/src/test/model/ca/TemplateTest.java
+++ b/src/test/model/ca/TemplateTest.java
@@ -34,6 +34,9 @@ public class TemplateTest {
                                         new PrintableString(PrintableString.TAG, null, "CA"))})}),
                 123);
         assertEquals("CN=Test,C=CA", template.getSubject().toString());
+
+        template = new Template("123", true, (String) null, 123);
+        assertNull(template.getSubject());
     }
 
     @Test
diff --git a/src/test/model/x501/AttributeTypeAndValueTest.java b/src/test/model/x501/AttributeTypeAndValueTest.java
index 7739e55..b3948fe 100644
--- a/src/test/model/x501/AttributeTypeAndValueTest.java
+++ b/src/test/model/x501/AttributeTypeAndValueTest.java
@@ -86,5 +86,9 @@ public class AttributeTypeAndValueTest {
         assertEquals("C=IT", new AttributeTypeAndValue(new BytesReader(new Byte[]{
                 0x30, 0x9, 0x6, 0x3, 0x55, 0x4, 0x6, 0x13, 0x2, 0x49, 0x54
         }), false).toString());
+        assertEquals("CN=IT\\,\\+\\=", new AttributeTypeAndValue(ASN1Object.TAG_SEQUENCE, null,
+                new ObjectIdentifier(TAG, null, OID_CN),
+                new PrintableString(PrintableString.TAG, null, "IT,+="))
+                .toString());
     }
 }
diff --git a/src/test/model/x501/NameTest.java b/src/test/model/x501/NameTest.java
index 22307f2..435ed71 100644
--- a/src/test/model/x501/NameTest.java
+++ b/src/test/model/x501/NameTest.java
@@ -164,4 +164,38 @@ public class NameTest {
         assertEquals("CN=yuuta,OU=users,C=CA", TestConstants.NAME_1.toString());
         assertEquals("SN=Qwq,O=IT,C=CN", TestConstants.NAME_2.toString());
     }
+
+    private static void assertParseString(String dn) throws ParseException {
+        assertEquals(dn, Name.parseString(dn).toString());
+    }
+
+    @Test
+    void testParseStringSuccess() throws ParseException {
+        assertParseString("CN=a");
+        assertParseString("CN=a+L=b");
+        assertParseString("CN=a+L=b,OU=c");
+        assertParseString("CN=a+L=b,OU=c+CN=d");
+        assertParseString("CN=a+L=b,OU=c+CN=d,C=e");
+        assertParseString("CN=Web,OU=Computers,O=IT");
+        assertParseString("CN=Web,OU=Computers,O=IT\\,Meow\\+qwq,C=CN");
+    }
+
+    @Test
+    void testParseStringFail() {
+        assertThrows(ParseException.class, () -> Name.parseString(""));
+        assertThrows(ParseException.class, () -> Name.parseString("C"));
+        assertThrows(ParseException.class, () -> Name.parseString("CN="));
+        assertThrows(ParseException.class, () -> Name.parseString("CN=a+"));
+        assertThrows(ParseException.class, () -> Name.parseString("CN=+"));
+        assertThrows(ParseException.class, () -> Name.parseString("CN=,"));
+        assertThrows(ParseException.class, () -> Name.parseString("CN=a,C="));
+        assertThrows(ParseException.class, () -> Name.parseString("CN=a,="));
+        assertThrows(ParseException.class, () -> Name.parseString("CN=a,C=,"));
+        assertThrows(ParseException.class, () -> Name.parseString("CN=a,C+"));
+        assertThrows(ParseException.class, () -> Name.parseString("CN=a,C=b,OOO"));
+        assertThrows(ParseException.class, () -> Name.parseString("CN=a,C=b,OOO="));
+        assertThrows(ParseException.class, () -> Name.parseString("CN=a,C=b,OU=+"));
+        assertThrows(ParseException.class, () -> Name.parseString("CN=a,C=b,OU,"));
+        assertThrows(ParseException.class, () -> Name.parseString("CN=a,C=b=c"));
+    }
 }