1 package org.cacert.gigi.dbObjects;
3 import static org.junit.Assert.*;
5 import java.io.IOException;
6 import java.sql.Timestamp;
8 import org.cacert.gigi.GigiApiException;
9 import org.cacert.gigi.database.GigiPreparedStatement;
10 import org.cacert.gigi.testUtils.BusinessTest;
11 import org.cacert.gigi.util.DayDate;
12 import org.cacert.gigi.util.Notary;
13 import org.junit.Before;
14 import org.junit.Test;
16 public class TestAssurance extends BusinessTest {
18 private final Timestamp yesterday = new Timestamp(System.currentTimeMillis() - DayDate.MILLI_DAY);
20 private final Timestamp tomorrow = new Timestamp(System.currentTimeMillis() + DayDate.MILLI_DAY);
23 * at least 39 months ago, so is outside the window of
24 * {@link User#VERIFICATION_MONTHS}
26 private final Timestamp min39month = new Timestamp(System.currentTimeMillis() - DayDate.MILLI_DAY * 39 * 31);
29 * at least 24 months ago (but less than 39), so is inside the window of
30 * {@link User#VERIFICATION_MONTHS}
32 private final Timestamp min24month = new Timestamp(System.currentTimeMillis() - DayDate.MILLI_DAY * 24 * 31);
38 private int applicantID;
40 private int applicantMultID;
42 public TestAssurance() throws GigiApiException {
46 // test for verification in 39 month period
47 private void enterAssurance(int agentID, int applicantID) {
48 try (GigiPreparedStatement ps = new GigiPreparedStatement("INSERT INTO `notary` SET `from`=?, `to`=?, `points`=?, `location`=?, `date`=?")) {
49 ps.setInt(1, agentID);
50 ps.setInt(2, applicantID);
52 ps.setString(4, "test-location");
53 ps.setString(5, "2010-01-01");
59 private void enterAssuranceExpired(int agentID, int applicantID, Timestamp expired) {
60 try (GigiPreparedStatement ps = new GigiPreparedStatement("INSERT INTO `notary` SET `from`=?, `to`=?, `points`=?, `location`=?, `date`=?, `expire`=? ")) {
61 ps.setInt(1, agentID);
62 ps.setInt(2, applicantID);
64 ps.setString(4, "test-location");
65 ps.setString(5, "2010-01-01");
66 ps.setTimestamp(6, expired);
71 private void enterAssuranceWhen(int agentID, int applicantID, Timestamp when) {
72 try (GigiPreparedStatement ps = new GigiPreparedStatement("INSERT INTO `notary` SET `from`=?, `to`=?, `points`=?, `location`=?, `date`=?, `when`=? ")) {
73 ps.setInt(1, agentID);
74 ps.setInt(2, applicantID);
76 ps.setString(4, "test-location");
77 ps.setString(5, "2010-01-01");
78 ps.setTimestamp(6, when);
83 private void enterAssuranceWhen(int agentID, int applicantID, Timestamp when, int points) {
84 try (GigiPreparedStatement ps = new GigiPreparedStatement("INSERT INTO `notary` SET `from`=?, `to`=?, `points`=?, `location`=?, `date`=?, `when`=? ")) {
85 ps.setInt(1, agentID);
86 ps.setInt(2, applicantID);
88 ps.setString(4, "test-location");
89 ps.setString(5, "2010-01-01");
90 ps.setTimestamp(6, when);
95 private void enterAssuranceDeleted(int agentID, int applicantID, Timestamp deleted) {
96 try (GigiPreparedStatement ps = new GigiPreparedStatement("INSERT INTO `notary` SET `from`=?, `to`=?, `points`=?, `location`=?, `date`=?, `deleted`=? ")) {
97 ps.setInt(1, agentID);
98 ps.setInt(2, applicantID);
100 ps.setString(4, "test-location");
101 ps.setString(5, "2010-01-01");
102 ps.setTimestamp(6, deleted);
108 public void initTest() throws GigiApiException {
109 agentID = createAssuranceUser("a", "b", createUniqueName() + "@example.com", TEST_PASSWORD);
110 agent2ID = createAssuranceUser("a", "d", createUniqueName() + "@example.com", TEST_PASSWORD);
111 applicantID = createVerifiedUser("a", "c", createUniqueName() + "@example.com", TEST_PASSWORD);
112 applicantMultID = createVerifiedUser("a", "e", createUniqueName() + "@example.com", TEST_PASSWORD);
116 public void testVerificationYesterday() throws IOException {
117 enterAssuranceWhen(agentID, applicantID, yesterday);
118 assertTrue(User.isInVerificationLimit(applicantID));
122 public void testApprox24MonthAgo() throws IOException {
123 enterAssuranceWhen(agentID, applicantID, min24month);
124 assertTrue(User.isInVerificationLimit(applicantID));
128 public void testApprox39MonthAgo() throws IOException {
129 enterAssuranceWhen(agentID, applicantID, min39month);
130 assertFalse(User.isInVerificationLimit(applicantID));
134 public void testTomorrowExpired() throws IOException {
135 enterAssuranceExpired(agentID, applicantID, tomorrow);
136 assertTrue(User.isInVerificationLimit(applicantID));
140 public void testYesterdayExpired() throws IOException {
141 enterAssuranceExpired(agentID, applicantID, yesterday);
142 assertFalse(User.isInVerificationLimit(applicantID));
146 public void testNormal() throws IOException {
147 enterAssurance(agentID, applicantID);
148 assertTrue(User.isInVerificationLimit(applicantID));
152 public void testDeletedYesterday() throws IOException {
153 enterAssuranceDeleted(agentID, applicantID, yesterday);
154 assertFalse(User.isInVerificationLimit(applicantID));
158 public void testMultipleAssurancePossible() throws IOException {
160 User agent = User.getById(agentID);
161 User applicantMult = User.getById(applicantMultID);
163 enterAssuranceWhen(agentID, applicantMultID, min39month);
165 // test that new entry would be possible
167 Notary.checkAssuranceIsPossible(agent, applicantMult);
168 } catch (GigiApiException e) {
173 enterAssuranceWhen(agentID, applicantMultID, yesterday);
175 // test that new entry is not possible
177 Notary.checkAssuranceIsPossible(agent, applicantMult);
178 } catch (GigiApiException e) {
185 public void testMultipleAssurancePointsCalculation() throws IOException {
187 User agent = User.getById(agentID);
188 User applicantMult = User.getById(applicantMultID);
190 enterAssuranceWhen(agentID, applicantMultID, min39month);
192 int xPoints = agent.getExperiencePoints();
194 // test that VP after first entry
196 assertEquals(applicantMult.getAssurancePoints(), 10);
198 // enter second entry to check correct calculation with larger points
199 enterAssuranceWhen(agentID, applicantMultID, min24month, 20);
200 assertEquals(applicantMult.getAssurancePoints(), 20);
202 // test correct XP calculation
203 assertEquals(agent.getExperiencePoints(), xPoints);
205 // enter third entry to check correct calculation with less points
206 enterAssuranceWhen(agentID, applicantMultID, yesterday, 15);
207 assertEquals(applicantMult.getAssurancePoints(), 15);
209 // test correct XP calculation
210 assertEquals(agent.getExperiencePoints(), xPoints);
212 // enter expired entry
213 enterAssuranceExpired(agentID, applicantMultID, yesterday);
214 assertEquals(applicantMult.getAssurancePoints(), 15);
216 // enter deleted entry same agent
217 enterAssuranceDeleted(agentID, applicantMultID, yesterday);
218 assertEquals(applicantMult.getAssurancePoints(), 15);
220 // enter expired entry future
221 enterAssuranceExpired(agentID, applicantMultID, tomorrow);
222 assertEquals(applicantMult.getAssurancePoints(), 10);
224 // test correct XP calculation
225 assertEquals(agent.getExperiencePoints(), xPoints);
227 // enter entry from different agent
228 enterAssuranceWhen(agent2ID, applicantMultID, yesterday);
229 assertEquals(applicantMult.getAssurancePoints(), 20);
231 // enter entry for second applicant
232 enterAssuranceWhen(agentID, applicantID, yesterday);
233 assertEquals(agent.getExperiencePoints(), xPoints + 2);