k-joseph

Untitled

Aug 12th, 2013
72
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 8.86 KB | None | 0 0
  1. /**
  2. * The contents of this file are subject to the OpenMRS Public License
  3. * Version 1.0 (the "License"); you may not use this file except in
  4. * compliance with the License. You may obtain a copy of the License at
  5. * http://license.openmrs.org
  6. *
  7. * Software distributed under the License is distributed on an "AS IS"
  8. * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
  9. * License for the specific language governing rights and limitations
  10. * under the License.
  11. *
  12. * Copyright (C) OpenMRS, LLC. All Rights Reserved.
  13. */
  14. package org.openmrs;
  15.  
  16. import java.util.Date;
  17. import java.util.UUID;
  18.  
  19. import org.junit.Assert;
  20. import org.junit.Before;
  21. import org.junit.Test;
  22. import org.openmrs.api.context.Context;
  23. import org.openmrs.test.Verifies;
  24.  
  25. public class PatientStateTest {
  26.  
  27. private Date leftRange;
  28.  
  29. private Date inRange;
  30.  
  31. private Date rightRange;
  32.  
  33. private Date rightOutOfRange;
  34.  
  35. private Date leftOutOfRange;
  36.  
  37. private String uuid1 = UUID.randomUUID().toString();
  38.  
  39. private String uuid2 = UUID.randomUUID().toString();
  40.  
  41. @Before
  42. public void before() {
  43. inRange = new Date();
  44. leftRange = new Date(inRange.getTime() - 10000);
  45. rightRange = new Date(inRange.getTime() + 10000);
  46. rightOutOfRange = new Date(rightRange.getTime() + 10000);
  47. leftOutOfRange = new Date(leftRange.getTime() - 10000);
  48. }
  49.  
  50. /**
  51. * @see PatientState#getActive(Date)
  52. * @verifies return false if voided and date in range
  53. */
  54. @Test
  55. public void getActive_shouldReturnFalseIfVoidedAndDateInRange() throws Exception {
  56. //given
  57. PatientState patientState = new PatientState();
  58. patientState.setStartDate(leftRange);
  59. patientState.setEndDate(rightRange);
  60. patientState.setVoided(true);
  61.  
  62. //when
  63. boolean active = patientState.getActive(inRange);
  64.  
  65. //then
  66. Assert.assertFalse(active);
  67. }
  68.  
  69. /**
  70. * @see PatientState#getActive(Date)
  71. * @verifies return false if voided and date not in range
  72. */
  73. @Test
  74. public void getActive_shouldReturnFalseIfVoidedAndDateNotInRange() throws Exception {
  75. //given
  76. PatientState patientState = new PatientState();
  77. patientState.setStartDate(leftRange);
  78. patientState.setEndDate(rightRange);
  79. patientState.setVoided(true);
  80.  
  81. //when
  82. boolean active = patientState.getActive(rightOutOfRange);
  83.  
  84. //then
  85. Assert.assertFalse(active);
  86. }
  87.  
  88. /**
  89. * @see PatientState#getActive(Date)
  90. * @verifies return true if not voided and date in range
  91. */
  92. @Test
  93. public void getActive_shouldReturnTrueIfNotVoidedAndDateInRange() throws Exception {
  94. //given
  95. PatientState patientState = new PatientState();
  96. patientState.setStartDate(leftRange);
  97. patientState.setEndDate(rightRange);
  98. patientState.setVoided(false);
  99.  
  100. //when
  101. boolean active = patientState.getActive(inRange);
  102.  
  103. //then
  104. Assert.assertTrue(active);
  105. }
  106.  
  107. /**
  108. * @see PatientState#getActive(Date)
  109. * @verifies return true if not voided and date in range with null startDate
  110. */
  111. @Test
  112. public void getActive_shouldReturnTrueIfNotVoidedAndDateInRangeWithNullStartDate() throws Exception {
  113. //given
  114. PatientState patientState = new PatientState();
  115. patientState.setStartDate(null);
  116. patientState.setEndDate(rightRange);
  117. patientState.setVoided(false);
  118.  
  119. //when
  120. boolean active = patientState.getActive(inRange);
  121.  
  122. //then
  123. Assert.assertTrue(active);
  124. }
  125.  
  126. /**
  127. * @see PatientState#getActive(Date)
  128. * @verifies return true if not voided and date in range with null endDate
  129. */
  130. @Test
  131. public void getActive_shouldReturnTrueIfNotVoidedAndDateInRangeWithNullEndDate() throws Exception {
  132. //given
  133. PatientState patientState = new PatientState();
  134. patientState.setStartDate(leftRange);
  135. patientState.setEndDate(null);
  136. patientState.setVoided(false);
  137.  
  138. //when
  139. boolean active = patientState.getActive(inRange);
  140.  
  141. //then
  142. Assert.assertTrue(active);
  143. }
  144.  
  145. /**
  146. * @see PatientState#getActive(Date)
  147. * @verifies return true if not voided and both startDate and endDate nulled
  148. */
  149. @Test
  150. public void getActive_shouldReturnTrueIfNotVoidedAndBothStartDateAndEndDateNulled() throws Exception {
  151. //given
  152. PatientState patientState = new PatientState();
  153. patientState.setStartDate(null);
  154. patientState.setEndDate(null);
  155. patientState.setVoided(false);
  156.  
  157. //when
  158. boolean active = patientState.getActive(inRange);
  159.  
  160. //then
  161. Assert.assertTrue(active);
  162. }
  163.  
  164. /**
  165. * @see PatientState#getActive(Date)
  166. * @verifies compare with current date if date null
  167. */
  168. @Test
  169. public void getActive_shouldCompareWithCurrentDateIfDateNull() throws Exception {
  170. //given
  171. PatientState patientState = new PatientState();
  172. patientState.setStartDate(leftRange);
  173. patientState.setEndDate(leftRange);
  174. patientState.setVoided(false);
  175.  
  176. //when
  177. boolean active = patientState.getActive(null);
  178.  
  179. //then
  180. Assert.assertFalse(active);
  181. }
  182.  
  183. /**
  184. * @see PatientState#getActive(Date)
  185. * @verifies return false if not voided and date earlier than startDate
  186. */
  187. @Test
  188. public void getActive_shouldReturnFalseIfNotVoidedAndDateEarlierThanStartDate() throws Exception {
  189. //given
  190. PatientState patientState = new PatientState();
  191. patientState.setStartDate(leftRange);
  192. patientState.setEndDate(rightRange);
  193. patientState.setVoided(false);
  194.  
  195. //when
  196. boolean active = patientState.getActive(leftOutOfRange);
  197.  
  198. //then
  199. Assert.assertFalse(active);
  200. }
  201.  
  202. /**
  203. * @see PatientState#getActive(Date)
  204. * @verifies return false if not voided and date later than endDate
  205. */
  206. @Test
  207. public void getActive_shouldReturnFalseIfNotVoidedAndDateLaterThanEndDate() throws Exception {
  208. //given
  209. PatientState patientState = new PatientState();
  210. patientState.setStartDate(leftRange);
  211. patientState.setEndDate(rightRange);
  212. patientState.setVoided(false);
  213.  
  214. //when
  215. boolean active = patientState.getActive(rightOutOfRange);
  216.  
  217. //then
  218. Assert.assertFalse(active);
  219. }
  220.  
  221. /**
  222. * @see PatientState#compareTo(PatientState)
  223. * @verifies return positive if startDates equal and this endDate null
  224. */
  225. @Test
  226. public void compareTo_shouldReturnPositiveIfStartDatesEqualAndThisEndDateNull() throws Exception {
  227. //given
  228. PatientState patientState = new PatientState();
  229. patientState.setStartDate(leftRange);
  230. patientState.setEndDate(null);
  231. patientState.setVoided(false);
  232.  
  233. PatientState patientState2 = new PatientState();
  234. patientState2.setStartDate(leftRange);
  235. patientState2.setEndDate(rightRange);
  236. patientState2.setVoided(false);
  237.  
  238. //when
  239. int result = patientState.compareTo(patientState2);
  240.  
  241. //then
  242. Assert.assertTrue(result > 0);
  243. }
  244.  
  245. /**
  246. * @see PatientState#compareTo(PatientState)
  247. * @verifies return negative if this startDate null
  248. */
  249. @Test
  250. public void compareTo_shouldReturnNegativeIfThisStartDateNull() throws Exception {
  251. //given
  252. PatientState patientState = new PatientState();
  253. patientState.setStartDate(null);
  254. patientState.setEndDate(rightRange);
  255. patientState.setVoided(false);
  256.  
  257. PatientState patientState2 = new PatientState();
  258. patientState2.setStartDate(leftRange);
  259. patientState2.setEndDate(rightRange);
  260. patientState2.setVoided(false);
  261.  
  262. //when
  263. int result = patientState.compareTo(patientState2);
  264.  
  265. //then
  266. Assert.assertTrue(result < 0);
  267. }
  268.  
  269. /**
  270. * @see PatientState#compareTo(PatientState)
  271. */
  272. @Test
  273. @Verifies(value = "pass if two states have the same start date, end date and uuid", method = "compareTo(PatientState)")
  274. public void compareTo_shouldPassIfTwoStatesHaveTheSameStartDateEndDateAndUuid() throws Exception {
  275. PatientState patientState = new PatientState();
  276.  
  277. patientState.setStartDate(leftRange);
  278. patientState.setEndDate(rightRange);
  279. patientState.setUuid(uuid1);
  280. patientState.setVoided(false);
  281.  
  282. PatientState patientState2 = new PatientState();
  283. patientState2.setStartDate(leftRange);
  284. patientState2.setEndDate(rightRange);
  285. patientState2.setUuid(uuid1);
  286. patientState2.setVoided(false);
  287.  
  288. Assert.assertTrue(patientState.compareTo(patientState2) == 0);
  289. }
  290.  
  291. /**
  292. * @see PatientState#compareTo(PatientState)
  293. */
  294. @Test
  295. @Verifies(value = "return positive or negative if two states have the same start date and end date butdifferent uuids", method = "compareTo(PatientState)")
  296. public void compareTo_shouldReturnPositiveOrNegativeIfTwoStatesHaveTheSameStartDatesEndDatesAndUuids() throws Exception {
  297. PatientState patientState = new PatientState();
  298. patientState.setStartDate(leftRange);
  299. patientState.setEndDate(rightRange);
  300. patientState.setUuid(uuid1);
  301. patientState.setVoided(false);
  302.  
  303. PatientState patientState2 = new PatientState();
  304. patientState2.setStartDate(leftRange);
  305. patientState2.setEndDate(rightRange);
  306. patientState2.setUuid(uuid2);
  307. patientState2.setVoided(false);
  308.  
  309. int result = (patientState.compareTo(patientState2));
  310.  
  311. Assert.assertTrue(result <= -1 || result >= 1);
  312. }
  313. }
Advertisement
Add Comment
Please, Sign In to add comment