honeymoose
/
hapi-fhir
mirror of https://github.com/hapifhir/hapi-fhir.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Rework tests for #381

This commit is contained in:
James Agnew 2016-06-10 09:29:30 -05:00
parent a3484f84c1
commit 4cfabfe4a6
4 changed files with 395 additions and 505 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

152
hapi-fhir-base/src/main/java/ca/uhn/fhir/model/primitive/BaseDateTimeDt.java
View File

@ -108,7 +108,7 @@ public abstract class BaseDateTimeDt extends BasePrimitive<Date> {
leftPadWithZeros(myFractionalSeconds, 3, b); leftPadWithZeros(myFractionalSeconds, 3, b);
} }
} }
if (myTimeZoneZulu) { if (myTimeZoneZulu) {
b.append('Z'); b.append('Z');
} else if (myTimeZone != null) { } else if (myTimeZone != null) {
@ -119,7 +119,7 @@ public abstract class BaseDateTimeDt extends BasePrimitive<Date> {
b.append('-'); b.append('-');
offset = Math.abs(offset); offset = Math.abs(offset);
} }
int hoursOffset = (int) (offset / DateUtils.MILLIS_PER_HOUR); int hoursOffset = (int) (offset / DateUtils.MILLIS_PER_HOUR);
leftPadWithZeros(hoursOffset, 2, b); leftPadWithZeros(hoursOffset, 2, b);
b.append(':'); b.append(':');
@ -223,20 +223,19 @@ public abstract class BaseDateTimeDt extends BasePrimitive<Date> {
theTarget.append(string); theTarget.append(string);
} }
@Override @Override
protected Date parse(String theValue) throws DataFormatException { protected Date parse(String theValue) throws DataFormatException {
Calendar cal = new GregorianCalendar(0, 0, 0); Calendar cal = new GregorianCalendar(0, 0, 0);
cal.setTimeZone(TimeZone.getDefault()); cal.setTimeZone(TimeZone.getDefault());
int length = theValue.length(); int length = theValue.length();
if (length == 0) { if (length == 0) {
return null; return null;
} }
if (length < 4) { if (length < 4) {
throwBadDateFormat(theValue); throwBadDateFormat(theValue);
} }
TemporalPrecisionEnum precision = null; TemporalPrecisionEnum precision = null;
cal.set(Calendar.YEAR, parseInt(theValue, theValue.substring(0, 4), 0, 9999)); cal.set(Calendar.YEAR, parseInt(theValue, theValue.substring(0, 4), 0, 9999));
precision = TemporalPrecisionEnum.YEAR; precision = TemporalPrecisionEnum.YEAR;
@ -265,11 +264,11 @@ public abstract class BaseDateTimeDt extends BasePrimitive<Date> {
} else { } else {
time = theValue.substring(11, offsetIdx); time = theValue.substring(11, offsetIdx);
String offsetString = theValue.substring(offsetIdx); String offsetString = theValue.substring(offsetIdx);
setTimeZone(offsetString); setTimeZone(theValue, offsetString);
cal.setTimeZone(getTimeZone()); cal.setTimeZone(getTimeZone());
} }
int timeLength = time.length(); int timeLength = time.length();
validateCharAtIndexIs(theValue, 13, ':'); validateCharAtIndexIs(theValue, 13, ':');
cal.set(Calendar.HOUR_OF_DAY, parseInt(theValue, theValue.substring(11, 13), 0, 23)); cal.set(Calendar.HOUR_OF_DAY, parseInt(theValue, theValue.substring(11, 13), 0, 23));
cal.set(Calendar.MINUTE, parseInt(theValue, theValue.substring(14, 16), 0, 59)); cal.set(Calendar.MINUTE, parseInt(theValue, theValue.substring(14, 16), 0, 59));
@ -288,7 +287,7 @@ public abstract class BaseDateTimeDt extends BasePrimitive<Date> {
} }
int millis; int millis;
if (endIndex > 23) { if (endIndex > 23) {
myFractionalSeconds = parseInt(theValue, theValue.substring(20,endIndex), 0, Integer.MAX_VALUE); myFractionalSeconds = parseInt(theValue, theValue.substring(20, endIndex), 0, Integer.MAX_VALUE);
endIndex = 23; endIndex = 23;
String millisString = theValue.substring(20, endIndex); String millisString = theValue.substring(20, endIndex);
millis = parseInt(theValue, millisString, 0, 999); millis = parseInt(theValue, millisString, 0, 999);
@ -308,115 +307,10 @@ public abstract class BaseDateTimeDt extends BasePrimitive<Date> {
} else { } else {
cal.set(Calendar.DATE, 1); cal.set(Calendar.DATE, 1);
} }
setPrecision(precision); setPrecision(precision);
return cal.getTime(); return cal.getTime();
// try {
// if (theValue.length() == 4 && ourYearPattern.matcher(theValue).matches()) {
// if (!isPrecisionAllowed(YEAR)) {
// ourLog.debug("Invalid date/time string (datatype " + getClass().getSimpleName() + " does not support YEAR precision): " + theValue);
// }
// setPrecision(YEAR);
// clearTimeZone();
// return ((ourYearFormat).parse(theValue));
// } else if (theValue.length() == 6 && ourYearMonthPattern.matcher(theValue).matches()) {
// // Eg. 198401 (allow this just to be lenient)
// if (!isPrecisionAllowed(MONTH)) {
// ourLog.debug("Invalid date/time string (datatype " + getClass().getSimpleName() + " does not support DAY precision): " + theValue);
// }
// setPrecision(MONTH);
// clearTimeZone();
// return ((ourYearMonthNoDashesFormat).parse(theValue));
// } else if (theValue.length() == 7 && ourYearDashMonthPattern.matcher(theValue).matches()) {
// // E.g. 1984-01 (this is valid according to the spec)
// if (!isPrecisionAllowed(MONTH)) {
// ourLog.debug("Invalid date/time string (datatype " + getClass().getSimpleName() + " does not support MONTH precision): " + theValue);
// }
// setPrecision(MONTH);
// clearTimeZone();
// return ((ourYearMonthFormat).parse(theValue));
// } else if (theValue.length() == 8 && ourYearMonthDayPattern.matcher(theValue).matches()) {
// // Eg. 19840101 (allow this just to be lenient)
// if (!isPrecisionAllowed(DAY)) {
// ourLog.debug("Invalid date/time string (datatype " + getClass().getSimpleName() + " does not support DAY precision): " + theValue);
// }
// setPrecision(DAY);
// clearTimeZone();
// return ((ourYearMonthDayNoDashesFormat).parse(theValue));
// } else if (theValue.length() == 10 && ourYearDashMonthDashDayPattern.matcher(theValue).matches()) {
// // E.g. 1984-01-01 (this is valid according to the spec)
// if (!isPrecisionAllowed(DAY)) {
// ourLog.debug("Invalid date/time string (datatype " + getClass().getSimpleName() + " does not support DAY precision): " + theValue);
// }
// setPrecision(DAY);
// clearTimeZone();
// return ((ourYearMonthDayFormat).parse(theValue));
// } else if (theValue.length() >= 18) { // date and time with possible time zone
// char timeSeparator = theValue.charAt(10);
// if (timeSeparator != 'T') {
// throw new DataFormatException("Invalid date/time string: " + theValue);
// }
// int dotIndex = theValue.indexOf('.', 18);
// boolean hasMillis = dotIndex > -1;
//
// if (!hasMillis && !isPrecisionAllowed(SECOND)) {
// ourLog.debug("Invalid date/time string (data type does not support SECONDS precision): " + theValue);
// } else if (hasMillis && !isPrecisionAllowed(MILLI)) {
// ourLog.debug("Invalid date/time string (data type " + getClass().getSimpleName() + " does not support MILLIS precision):" + theValue);
// }
//
// Date retVal;
// if (hasMillis) {
// String value = theValue;
//
// /*
// * If we have more than 3 digits of precision after the decimal point, we
// * only parse the first 3 since Java Dates don't support more than that and
// * FastDateFormat gets confused
// */
// int offsetIndex = getOffsetIndex(theValue);
// if (offsetIndex >= 24) {
// value = theValue.substring(0, 23) + theValue.substring(offsetIndex);
// }
//
// try {
// if (hasOffset(value)) {
// retVal = ourYearMonthDayTimeMilliZoneFormat.parse(value);
// } else if (value.endsWith("Z")) {
// retVal = ourYearMonthDayTimeMilliUTCZFormat.parse(value);
// } else {
// retVal = ourYearMonthDayTimeMilliFormat.parse(value);
// }
// } catch (ParseException p2) {
// throw new DataFormatException("Invalid data/time string (" + p2.getMessage() + "): " + theValue);
// }
// setTimeZone(theValue);
// setPrecision(TemporalPrecisionEnum.MILLI);
// } else {
// try {
// if (hasOffset(theValue)) {
// retVal = ourYearMonthDayTimeZoneFormat.parse(theValue);
// } else if (theValue.endsWith("Z")) {
// retVal = ourYearMonthDayTimeUTCZFormat.parse(theValue);
// } else {
// retVal = ourYearMonthDayTimeFormat.parse(theValue);
// }
// } catch (ParseException p2) {
// throw new DataFormatException("Invalid data/time string (" + p2.getMessage() + "): " + theValue);
// }
//
// setTimeZone(theValue);
// setPrecision(TemporalPrecisionEnum.SECOND);
// }
//
// return retVal;
// } else {
// throw new DataFormatException("Invalid date/time string (invalid length): " + theValue);
// }
// } catch (ParseException e) {
// throw new DataFormatException("Invalid date string (" + e.getMessage() + "): " + theValue);
// }
} }
private int parseInt(String theValue, String theSubstring, int theLowerBound, int theUpperBound) { private int parseInt(String theValue, String theSubstring, int theLowerBound, int theUpperBound) {
@ -426,11 +320,11 @@ public abstract class BaseDateTimeDt extends BasePrimitive<Date> {
} catch (NumberFormatException e) { } catch (NumberFormatException e) {
throwBadDateFormat(theValue); throwBadDateFormat(theValue);
} }
if (retVal < theLowerBound || retVal > theUpperBound) { if (retVal < theLowerBound || retVal > theUpperBound) {
throwBadDateFormat(theValue); throwBadDateFormat(theValue);
} }
return retVal; return retVal;
} }
@ -447,17 +341,23 @@ public abstract class BaseDateTimeDt extends BasePrimitive<Date> {
updateStringValue(); updateStringValue();
} }
private BaseDateTimeDt setTimeZone(String theValueString) { private BaseDateTimeDt setTimeZone(String theWholeValue, String theValue) {
if (isBlank(theValueString)) { if (isBlank(theValue)) {
throw new DataFormatException("Invalid time zone offset string: \"" + theValueString + "\""); throwBadDateFormat(theWholeValue);
} else if (theValue.charAt(0) == 'Z') {
clearTimeZone();
setTimeZoneZulu(true);
} else if (theValue.length() != 5) {
throwBadDateFormat(theWholeValue, "Timezone offset must be in the form \"Z\", \"-HH:mm\", or \"+HH:mm\"");
} else if (theValue.charAt(3) != ':' || !(theValue.charAt(0) == '+' || theValue.charAt(0) == '-')) {
throwBadDateFormat(theWholeValue, "Timezone offset must be in the form \"Z\", \"-HH:mm\", or \"+HH:mm\"");
} else {
parseInt(theWholeValue, theValue.substring(0, 2), 0, 23);
parseInt(theWholeValue, theValue.substring(3, 5), 0, 59);
clearTimeZone();
setTimeZone(TimeZone.getTimeZone("GMT" + theValue));
} }
clearTimeZone();
if (theValueString.charAt(0) == 'Z') {
setTimeZoneZulu(true);
} else {
setTimeZone(TimeZone.getTimeZone("GMT" + theValueString));
}
return this; return this;
} }

28
hapi-fhir-base/src/test/java/ca/uhn/fhir/model/api/InstantDtTest.java
View File

@ -1,28 +0,0 @@
package ca.uhn.fhir.model.api;
import static org.junit.Assert.*;
import java.util.Date;
import org.junit.Test;
import ca.uhn.fhir.model.primitive.InstantDt;
public class InstantDtTest {
@Test
public void testParseHandlesMillis() {
InstantDt dt = new InstantDt();
dt.setValueAsString("2015-06-22T15:44:32.831-04:00");
Date date = dt.getValue();
InstantDt dt2 = new InstantDt();
dt2.setValue(date);
dt2.setTimeZoneZulu(true);
String string = dt2.getValueAsString();
assertEquals("2015-06-22T19:44:32.831Z", string);
}
}

306
hapi-fhir-structures-dstu/src/test/java/ca/uhn/fhir/model/primitive/BaseDateTimeDtTest.java
View File

@ -1,306 +0,0 @@
package ca.uhn.fhir.model.primitive;
import static org.hamcrest.Matchers.containsString;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.fail;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.TimeZone;
import org.apache.commons.lang3.time.FastDateFormat;
import org.hamcrest.Matchers;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import ca.uhn.fhir.context.FhirContext;
import ca.uhn.fhir.model.api.TemporalPrecisionEnum;
import ca.uhn.fhir.model.dstu.resource.Condition;
import ca.uhn.fhir.model.dstu.resource.Patient;
import ca.uhn.fhir.parser.DataFormatException;
import ca.uhn.fhir.util.TestUtil;
import ca.uhn.fhir.validation.ValidationResult;
public class BaseDateTimeDtTest {
private SimpleDateFormat myDateInstantParser;
private FastDateFormat myDateInstantZoneParser;
private static final org.slf4j.Logger ourLog = org.slf4j.LoggerFactory.getLogger(BaseDateTimeDtTest.class);
private static FhirContext ourCtx = FhirContext.forDstu1();
@Before
public void before() {
myDateInstantParser = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
myDateInstantZoneParser = FastDateFormat.getInstance("yyyy-MM-dd HH:mm:ss.SSSZ", TimeZone.getTimeZone("GMT-02:00"));
}
/**
* See #101
*/
@Test
public void testPrecision() throws Exception {
Calendar cal = Calendar.getInstance();
cal.setTime(myDateInstantParser.parse("2012-01-02 22:31:02.333"));
cal.setTimeZone(TimeZone.getTimeZone("EST"));
Patient patient = new Patient();
patient.setBirthDate(cal.getTime(), TemporalPrecisionEnum.DAY);
String out = ourCtx.newXmlParser().encodeResourceToString(patient);
assertThat(out, containsString("<birthDate value=\"2012-01-02\"/>"));
}
@Test
public void testParseDate() {
new DateDt("2012-03-31");
}
@Test
public void setTimezoneToZulu() {
DateTimeDt dt = new DateTimeDt(new Date(816411488000L));
// assertEquals("1995-11-14T23:58:08", dt.getValueAsString());
dt.setTimeZoneZulu(true);
assertEquals("1995-11-15T04:58:08Z", dt.getValueAsString());
}
@Test
public void testDateTimeInLocalTimezone() {
DateTimeDt dt = DateTimeDt.withCurrentTime();
String str = dt.getValueAsString();
char offset = str.charAt(19);
if (offset != '+' && offset != '-' && offset != 'Z') {
fail("No timezone provided: " + str);
}
}
@Test
public void testInstantInLocalTimezone() {
InstantDt dt = InstantDt.withCurrentTime();
String str = dt.getValueAsString();
char offset = str.charAt(23);
if (offset != '+' && offset != '-' && offset != 'Z') {
fail("No timezone provided: " + str);
}
}
/**
* Test for #57
*/
@Test
public void testDateParsesWithInvalidPrecision() {
Condition c = new Condition();
c.setDateAsserted(new DateDt());
c.getDateAsserted().setValueAsString("2001-01-02T11:13:33");
assertEquals(TemporalPrecisionEnum.SECOND, c.getDateAsserted().getPrecision());
String encoded = ourCtx.newXmlParser().encodeResourceToString(c);
Assert.assertThat(encoded, Matchers.containsString("value=\"2001-01-02T11:13:33\""));
c = ourCtx.newXmlParser().parseResource(Condition.class, encoded);
assertEquals("2001-01-02T11:13:33", c.getDateAsserted().getValueAsString());
assertEquals(TemporalPrecisionEnum.SECOND, c.getDateAsserted().getPrecision());
ValidationResult outcome = ourCtx.newValidator().validateWithResult(c);
String outcomeStr = ourCtx.newJsonParser().setPrettyPrint(true).encodeResourceToString(outcome.getOperationOutcome());
ourLog.info(outcomeStr);
assertThat(outcomeStr, containsString("date-primitive"));
}
/**
* Test for #57
*/
@Test
public void testConstructorRejectsInvalidPrecision() {
try {
new DateDt("2001-01-02T11:13:33");
fail();
} catch (DataFormatException e) {
assertThat(e.getMessage(), containsString("precision"));
}
try {
new InstantDt("2001-01-02");
fail();
} catch (DataFormatException e) {
assertThat(e.getMessage(), containsString("precision"));
}
}
/**
* See #381
*/
@Test
public void testParseFailsForInvalidDate() {
try {
DateTimeDt dt = new DateTimeDt("9999-13-01");
fail(dt.getValue().toString());
} catch (DataFormatException e) {
// good
}
}
@Test
@Ignore
public void testFormats() throws Exception {
Date instant = myDateInstantParser.parse("2001-02-03 13:01:02.555");
for (FastDateFormat next : BaseDateTimeDt.getFormatters()) {
Calendar cal = Calendar.getInstance();
cal.setTime(instant);
String value = next.format(cal);
ourLog.info("String: {}", value);
DateTimeDt dt = new DateTimeDt(value);
String reEncoded = next.format(dt.getValue());
assertEquals(value, reEncoded);
}
}
@Test
public void testParseDay() throws DataFormatException {
DateTimeDt dt = new DateTimeDt();
dt.setValueAsString("2013-02-03");
assertEquals("2013-02-03", myDateInstantParser.format(dt.getValue()).substring(0, 10));
assertEquals("2013-02-03", dt.getValueAsString());
assertEquals(false, dt.isTimeZoneZulu());
assertNull(dt.getTimeZone());
assertEquals(TemporalPrecisionEnum.DAY, dt.getPrecision());
}
@Test(expected=DataFormatException.class)
public void testParseMalformatted() throws DataFormatException {
new DateTimeDt("20120102");
}
@Test
public void testParseMilli() throws DataFormatException {
InstantDt dt = new InstantDt();
dt.setValueAsString("2013-02-03T11:22:33.234");
assertEquals("2013-02-03 11:22:33.234", myDateInstantParser.format(dt.getValue()).substring(0, 23));
assertEquals("2013-02-03T11:22:33.234", dt.getValueAsString());
assertEquals(false, dt.isTimeZoneZulu());
assertNull(dt.getTimeZone());
assertEquals(TemporalPrecisionEnum.MILLI, dt.getPrecision());
}
@Test
public void testParseMilliZone() throws DataFormatException {
InstantDt dt = new InstantDt();
dt.setValueAsString("2013-02-03T11:22:33.234-02:00");
assertEquals("2013-02-03 11:22:33.234-0200", myDateInstantZoneParser.format(dt.getValue()));
assertEquals("2013-02-03T11:22:33.234-02:00", dt.getValueAsString());
assertEquals(false, dt.isTimeZoneZulu());
assertEquals(TimeZone.getTimeZone("GMT-02:00"), dt.getTimeZone());
assertEquals(TemporalPrecisionEnum.MILLI, dt.getPrecision());
}
@Test
public void testParseMilliZulu() throws DataFormatException {
InstantDt dt = new InstantDt();
dt.setValueAsString("2013-02-03T11:22:33.234Z");
assertEquals("2013-02-03 09:22:33.234-0200", myDateInstantZoneParser.format(dt.getValue()));
assertEquals("2013-02-03T11:22:33.234Z", dt.getValueAsString());
assertEquals(true, dt.isTimeZoneZulu());
assertEquals("GMT", dt.getTimeZone().getID());
assertEquals(TemporalPrecisionEnum.MILLI, dt.getPrecision());
}
@Test
public void testParseMonth() throws DataFormatException {
DateTimeDt dt = new DateTimeDt();
dt.setValueAsString("2013-02");
ourLog.info("Date: {}", dt.getValue());
assertEquals("2013-02", dt.getValueAsString());
assertEquals(false, dt.isTimeZoneZulu());
assertNull(dt.getTimeZone());
assertEquals(TemporalPrecisionEnum.MONTH, dt.getPrecision());
assertEquals("2013-02", myDateInstantParser.format(dt.getValue()).substring(0, 7));
}
@Test(expected=DataFormatException.class)
public void testParseMonthNoDashes() throws DataFormatException {
DateTimeDt dt = new DateTimeDt();
dt.setValueAsString("201302");
}
@Test
public void testParseSecond() throws DataFormatException {
DateTimeDt dt = new DateTimeDt();
dt.setValueAsString("2013-02-03T11:22:33");
assertEquals("2013-02-03 11:22:33", myDateInstantParser.format(dt.getValue()).substring(0, 19));
assertEquals("2013-02-03T11:22:33", dt.getValueAsString());
assertEquals(false, dt.isTimeZoneZulu());
assertNull(dt.getTimeZone());
assertEquals(TemporalPrecisionEnum.SECOND, dt.getPrecision());
}
@Test
public void testParseSecondulu() throws DataFormatException {
DateTimeDt dt = new DateTimeDt();
dt.setValueAsString("2013-02-03T11:22:33Z");
assertEquals("2013-02-03T11:22:33Z", dt.getValueAsString());
assertEquals(true, dt.isTimeZoneZulu());
assertEquals("GMT", dt.getTimeZone().getID());
assertEquals(TemporalPrecisionEnum.SECOND, dt.getPrecision());
}
@Test
public void testParseSecondZone() throws DataFormatException {
DateTimeDt dt = new DateTimeDt();
dt.setValueAsString("2013-02-03T11:22:33-02:00");
assertEquals("2013-02-03T11:22:33-02:00", dt.getValueAsString());
assertEquals(false, dt.isTimeZoneZulu());
assertEquals(TimeZone.getTimeZone("GMT-02:00"), dt.getTimeZone());
assertEquals(TemporalPrecisionEnum.SECOND, dt.getPrecision());
}
@Test
public void testParseYear() throws DataFormatException {
DateTimeDt dt = new DateTimeDt();
dt.setValueAsString("2013");
assertEquals("2013", myDateInstantParser.format(dt.getValue()).substring(0, 4));
assertEquals("2013", dt.getValueAsString());
assertEquals(false, dt.isTimeZoneZulu());
assertNull(dt.getTimeZone());
assertEquals(TemporalPrecisionEnum.YEAR, dt.getPrecision());
}
@Test
public void testSetValueByString() {
InstantDt i = new InstantDt();
i.setValueAsString("2014-06-20T20:22:09Z");
assertNotNull(i.getValue());
assertNotNull(i.getValueAsString());
assertEquals(1403295729000L, i.getValue().getTime());
assertEquals("2014-06-20T20:22:09Z", i.getValueAsString());
}
@AfterClass
public static void afterClassClearContext() {
TestUtil.clearAllStaticFieldsForUnitTest();
}
}

414
hapi-fhir-structures-dstu2/src/test/java/ca/uhn/fhir/model/primitive/BaseDateTimeDtDstu2Test.java
View File

@ -1,43 +1,133 @@
package ca.uhn.fhir.model.primitive; package ca.uhn.fhir.model.primitive;
import static org.hamcrest.Matchers.containsString; import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.Matchers.either;
import static org.hamcrest.Matchers.endsWith; import static org.hamcrest.Matchers.endsWith;
import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertThat; import static org.junit.Assert.assertThat;
import static org.junit.Assert.fail; import static org.junit.Assert.fail;
import java.text.ParseException;
import java.text.SimpleDateFormat; import java.text.SimpleDateFormat;
import java.util.Calendar; import java.util.Calendar;
import java.util.Date; import java.util.Date;
import java.util.Locale; import java.util.Locale;
import java.util.TimeZone; import java.util.TimeZone;
import org.apache.commons.lang3.time.FastDateFormat;
import org.hamcrest.Matchers;
import org.junit.AfterClass; import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.Before; import org.junit.Before;
import org.junit.BeforeClass; import org.junit.BeforeClass;
import org.junit.Test; import org.junit.Test;
import ca.uhn.fhir.context.FhirContext;
import ca.uhn.fhir.model.api.TemporalPrecisionEnum; import ca.uhn.fhir.model.api.TemporalPrecisionEnum;
import ca.uhn.fhir.model.dstu2.resource.Condition;
import ca.uhn.fhir.model.dstu2.resource.Patient;
import ca.uhn.fhir.parser.DataFormatException; import ca.uhn.fhir.parser.DataFormatException;
import ca.uhn.fhir.util.TestUtil; import ca.uhn.fhir.util.TestUtil;
import ca.uhn.fhir.validation.ValidationResult;
public class BaseDateTimeDtDstu2Test { public class BaseDateTimeDtDstu2Test {
private static FhirContext ourCtx = FhirContext.forDstu2();
private static Locale ourDefaultLocale; private static Locale ourDefaultLocale;
private static final org.slf4j.Logger ourLog = org.slf4j.LoggerFactory.getLogger(BaseDateTimeDtDstu2Test.class); private static final org.slf4j.Logger ourLog = org.slf4j.LoggerFactory.getLogger(BaseDateTimeDtDstu2Test.class);
private SimpleDateFormat myDateInstantParser; private SimpleDateFormat myDateInstantParser;
@AfterClass
public static void afterClassClearContext() { private FastDateFormat myDateInstantZoneParser;
TestUtil.clearAllStaticFieldsForUnitTest();
}
@Before @Before
public void before() { public void before() {
myDateInstantParser = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS"); myDateInstantParser = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
myDateInstantZoneParser = FastDateFormat.getInstance("yyyy-MM-dd HH:mm:ss.SSSZ", TimeZone.getTimeZone("GMT-02:00"));
}
@Test
public void setTimezoneToZulu() {
DateTimeDt dt = new DateTimeDt(new Date(816411488000L));
// assertEquals("1995-11-14T23:58:08", dt.getValueAsString());
dt.setTimeZoneZulu(true);
assertEquals("1995-11-15T04:58:08Z", dt.getValueAsString());
} }
/**
* Test for #57
*/
@Test
public void testConstructorRejectsInvalidPrecision() {
try {
new DateDt("2001-01-02T11:13:33");
fail();
} catch (DataFormatException e) {
assertThat(e.getMessage(), containsString("precision"));
}
try {
new InstantDt("2001-01-02");
fail();
} catch (DataFormatException e) {
assertThat(e.getMessage(), containsString("precision"));
}
}
/**
* Test for #57
*/
@Test
public void testDateParsesWithInvalidPrecision() {
Condition c = new Condition();
c.setDateRecorded(new DateDt());
c.getDateRecordedElement().setValueAsString("2001-01-02T11:13:33");
assertEquals(TemporalPrecisionEnum.SECOND, c.getDateRecordedElement().getPrecision());
String encoded = ourCtx.newXmlParser().encodeResourceToString(c);
Assert.assertThat(encoded, Matchers.containsString("value=\"2001-01-02T11:13:33\""));
c = ourCtx.newXmlParser().parseResource(Condition.class, encoded);
assertEquals("2001-01-02T11:13:33", c.getDateRecordedElement().getValueAsString());
assertEquals(TemporalPrecisionEnum.SECOND, c.getDateRecordedElement().getPrecision());
ValidationResult outcome = ourCtx.newValidator().validateWithResult(c);
String outcomeStr = ourCtx.newJsonParser().setPrettyPrint(true).encodeResourceToString(outcome.toOperationOutcome());
ourLog.info(outcomeStr);
assertThat(outcomeStr, containsString("date-primitive"));
}
@Test
public void testDateTimeInLocalTimezone() {
DateTimeDt dt = DateTimeDt.withCurrentTime();
String str = dt.getValueAsString();
char offset = str.charAt(19);
if (offset != '+' && offset != '-' && offset != 'Z') {
fail("No timezone provided: " + str);
}
}
@Test
public void testEncodeOffset() throws Exception {
String offset = InstantDt.withCurrentTime().setTimeZone(TimeZone.getTimeZone("America/Toronto")).getValueAsString();
assertThat(offset, either(endsWith("-05:00")).or(endsWith("-04:00")));
}
@Test
public void testInstantInLocalTimezone() {
InstantDt dt = InstantDt.withCurrentTime();
String str = dt.getValueAsString();
char offset = str.charAt(23);
if (offset != '+' && offset != '-' && offset != 'Z') {
fail("No timezone provided: " + str);
}
}
@Test @Test
public void testLargePrecision() { public void testLargePrecision() {
@ -46,34 +136,249 @@ public class BaseDateTimeDtDstu2Test {
myDateInstantParser.setTimeZone(TimeZone.getTimeZone("Z")); myDateInstantParser.setTimeZone(TimeZone.getTimeZone("Z"));
assertEquals("2014-03-06 17:39:58.912", myDateInstantParser.format(dt.getValue())); assertEquals("2014-03-06 17:39:58.912", myDateInstantParser.format(dt.getValue()));
} }
@Test @Test
public void testEncodeOffset() throws Exception { public void testMinutePrecisionEncode() throws Exception {
myDateInstantParser.parse("2011-01-01 11:11:11.0"); Calendar cal = Calendar.getInstance();
myDateInstantParser.setTimeZone(TimeZone.getTimeZone("America/Toronto")); cal.setTimeZone(TimeZone.getTimeZone("Europe/Berlin"));
String offset = InstantDt.withCurrentTime().setTimeZone(TimeZone.getTimeZone("America/Toronto")).getValueAsString(); cal.set(1990, Calendar.JANUARY, 3, 3, 22, 11);
assertThat(offset, endsWith("-05:00"));
DateTimeDt date = new DateTimeDt();
date.setValue(cal.getTime(), TemporalPrecisionEnum.MINUTE);
date.setTimeZone(TimeZone.getTimeZone("EST"));
assertEquals("1990-01-02T21:22-05:00", date.getValueAsString());
date.setTimeZoneZulu(true);
assertEquals("1990-01-03T02:22Z", date.getValueAsString());
}
@Test
public void testParseDate() {
new DateDt("2012-03-31");
}
@Test
public void testParseDay() throws DataFormatException {
DateTimeDt dt = new DateTimeDt();
dt.setValueAsString("2013-02-03");
assertEquals("2013-02-03", myDateInstantParser.format(dt.getValue()).substring(0, 10));
assertEquals("2013-02-03", dt.getValueAsString());
assertEquals(false, dt.isTimeZoneZulu());
assertNull(dt.getTimeZone());
assertEquals(TemporalPrecisionEnum.DAY, dt.getPrecision());
}
/**
* See #381
*/
@Test
public void testParseFailsForInvalidDate() {
try {
DateTimeDt dt = new DateTimeDt("9999-13-01");
fail(dt.getValue().toString());
} catch (DataFormatException e) {
// good
}
}
@Test
public void testParseHandlesMillis() {
InstantDt dt = new InstantDt();
dt.setValueAsString("2015-06-22T15:44:32.831-04:00");
Date date = dt.getValue();
InstantDt dt2 = new InstantDt();
dt2.setValue(date);
dt2.setTimeZoneZulu(true);
String string = dt2.getValueAsString();
assertEquals("2015-06-22T19:44:32.831Z", string);
}
@Test
public void testDateTimeFormatsInvalid() {
// Bad timezone
verifyFails("1974-12-01T00:00:00A");
verifyFails("1974-12-01T00:00:00=00:00");
verifyFails("1974-12-01T00:00:00+");
verifyFails("1974-12-01T00:00:00+25:00");
verifyFails("1974-12-01T00:00:00+00:61");
verifyFails("1974-12-01T00:00:00+00 401");
verifyFails("1974-12-01T00:00:00+0");
verifyFails("1974-12-01T00:00:00+01");
verifyFails("1974-12-01T00:00:00+011");
verifyFails("1974-12-01T00:00:00+0110");
// Out of range
verifyFails("1974-12-25T25:00:00Z");
verifyFails("1974-12-25T24:00:00Z");
verifyFails("1974-12-25T23:60:00Z");
verifyFails("1974-12-25T23:59:60Z");
// Invalid Separators
verifyFails("1974-12-25T23 59:00Z");
verifyFails("1974-12-25T23:59 00Z");
// Invalid length
verifyFails("1974-12-25T2Z");
verifyFails("1974-12-25T22:Z");
verifyFails("1974-12-25T22:1Z");
verifyFails("1974-12-25T22:11:Z");
verifyFails("1974-12-25T22:11:1Z");
} }
@Test @Test
public void testParseInvalid() { public void testDateFormatsInvalid() {
// No spaces in dates
verifyFails("1974 12-25");
verifyFails("1974-12 25");
// No letters
verifyFails("A974-12-25");
verifyFails("1974-A2-25");
verifyFails("1974-12-A5");
// Date shouldn't have a time zone
verifyFails("1974-12-25Z");
verifyFails("1974-12-25+10:00");
// Out of range
verifyFails("1974-13-25");
verifyFails("1974-12-32");
verifyFails("2015-02-29");
verifyFails("-016-02-01");
verifyFails("2016--2-01");
verifyFails("2016-02--1");
// Invalid length
verifyFails("2");
verifyFails("20");
verifyFails("201");
verifyFails("2016-0");
verifyFails("2016-02-0");
}
private void verifyFails(String input) {
try { try {
DateTimeDt dt = new DateTimeDt(); DateTimeDt dt = new DateTimeDt();
dt.setValueAsString("1974-12-25+10:00"); dt.setValueAsString(input);
fail(); fail();
} catch (ca.uhn.fhir.parser.DataFormatException e) { } catch (ca.uhn.fhir.parser.DataFormatException e) {
assertEquals("Invalid date/time format: \"1974-12-25+10:00\"", e.getMessage()); assertThat(e.getMessage(), containsString("Invalid date/time format: \"" + input + "\""));
} }
}
@Test
public void testParseInvalidZoneOffset() {
try { try {
DateTimeDt dt = new DateTimeDt(); new DateTimeDt("2010-01-01T00:00:00.1234-09:00Z");
dt.setValueAsString("1974-12-25Z");
fail(); fail();
} catch (ca.uhn.fhir.parser.DataFormatException e) { } catch (DataFormatException e) {
assertEquals("Invalid date/time format: \"1974-12-25Z\"", e.getMessage()); assertEquals("Invalid FHIR date/time string: 2010-01-01T00:00:00.1234-09:00Z", e.getMessage());
} }
} }
@Test(expected = DataFormatException.class)
public void testParseMalformatted() throws DataFormatException {
new DateTimeDt("20120102");
}
@Test
public void testParseMilli() throws DataFormatException {
InstantDt dt = new InstantDt();
dt.setValueAsString("2013-02-03T11:22:33.234");
assertEquals("2013-02-03 11:22:33.234", myDateInstantParser.format(dt.getValue()).substring(0, 23));
assertEquals("2013-02-03T11:22:33.234", dt.getValueAsString());
assertEquals(false, dt.isTimeZoneZulu());
assertNull(dt.getTimeZone());
assertEquals(TemporalPrecisionEnum.MILLI, dt.getPrecision());
}
@Test
public void testParseMilliZone() throws DataFormatException {
InstantDt dt = new InstantDt();
dt.setValueAsString("2013-02-03T11:22:33.234-02:00");
assertEquals("2013-02-03 11:22:33.234-0200", myDateInstantZoneParser.format(dt.getValue()));
assertEquals("2013-02-03T11:22:33.234-02:00", dt.getValueAsString());
assertEquals(false, dt.isTimeZoneZulu());
assertEquals(TimeZone.getTimeZone("GMT-02:00"), dt.getTimeZone());
assertEquals(TemporalPrecisionEnum.MILLI, dt.getPrecision());
}
@Test
public void testParseMilliZulu() throws DataFormatException {
InstantDt dt = new InstantDt();
dt.setValueAsString("2013-02-03T11:22:33.234Z");
assertEquals("2013-02-03 09:22:33.234-0200", myDateInstantZoneParser.format(dt.getValue()));
assertEquals("2013-02-03T11:22:33.234Z", dt.getValueAsString());
assertEquals(true, dt.isTimeZoneZulu());
assertEquals("GMT", dt.getTimeZone().getID());
assertEquals(TemporalPrecisionEnum.MILLI, dt.getPrecision());
}
@Test
public void testParseMonth() throws DataFormatException {
DateTimeDt dt = new DateTimeDt();
dt.setValueAsString("2013-02");
ourLog.info("Date: {}", dt.getValue());
assertEquals("2013-02", dt.getValueAsString());
assertEquals(false, dt.isTimeZoneZulu());
assertNull(dt.getTimeZone());
assertEquals(TemporalPrecisionEnum.MONTH, dt.getPrecision());
assertEquals("2013-02", myDateInstantParser.format(dt.getValue()).substring(0, 7));
}
@Test(expected = DataFormatException.class)
public void testParseMonthNoDashes() throws DataFormatException {
DateTimeDt dt = new DateTimeDt();
dt.setValueAsString("201302");
}
@Test
public void testParseSecond() throws DataFormatException {
DateTimeDt dt = new DateTimeDt();
dt.setValueAsString("2013-02-03T11:22:33");
assertEquals("2013-02-03 11:22:33", myDateInstantParser.format(dt.getValue()).substring(0, 19));
assertEquals("2013-02-03T11:22:33", dt.getValueAsString());
assertEquals(false, dt.isTimeZoneZulu());
assertNull(dt.getTimeZone());
assertEquals(TemporalPrecisionEnum.SECOND, dt.getPrecision());
}
@Test
public void testParseSecondulu() throws DataFormatException {
DateTimeDt dt = new DateTimeDt();
dt.setValueAsString("2013-02-03T11:22:33Z");
assertEquals("2013-02-03T11:22:33Z", dt.getValueAsString());
assertEquals(true, dt.isTimeZoneZulu());
assertEquals("GMT", dt.getTimeZone().getID());
assertEquals(TemporalPrecisionEnum.SECOND, dt.getPrecision());
}
@Test
public void testParseSecondZone() throws DataFormatException {
DateTimeDt dt = new DateTimeDt();
dt.setValueAsString("2013-02-03T11:22:33-02:00");
assertEquals("2013-02-03T11:22:33-02:00", dt.getValueAsString());
assertEquals(false, dt.isTimeZoneZulu());
assertEquals(TimeZone.getTimeZone("GMT-02:00"), dt.getTimeZone());
assertEquals(TemporalPrecisionEnum.SECOND, dt.getPrecision());
}
@Test @Test
public void testParseTimeZoneOffsetCorrectly0millis() { public void testParseTimeZoneOffsetCorrectly0millis() {
myDateInstantParser.setTimeZone(TimeZone.getTimeZone("America/Toronto")); myDateInstantParser.setTimeZone(TimeZone.getTimeZone("America/Toronto"));
@ -134,16 +439,6 @@ public class BaseDateTimeDtDstu2Test {
assertEquals("2010-01-01T09:00:00.123Z", dt.getValueAsString()); assertEquals("2010-01-01T09:00:00.123Z", dt.getValueAsString());
} }
@Test
public void testParseInvalidZoneOffset() {
try {
new DateTimeDt("2010-01-01T00:00:00.1234-09:00Z");
fail();
} catch (DataFormatException e) {
assertEquals("Invalid FHIR date/time string: 2010-01-01T00:00:00.1234-09:00Z", e.getMessage());
}
}
@Test @Test
public void testParseTimeZoneOffsetCorrectly4millis() { public void testParseTimeZoneOffsetCorrectly4millis() {
myDateInstantParser.setTimeZone(TimeZone.getTimeZone("America/Toronto")); myDateInstantParser.setTimeZone(TimeZone.getTimeZone("America/Toronto"));
@ -174,6 +469,33 @@ public class BaseDateTimeDtDstu2Test {
assertEquals("2010-01-01T09:00:00.12345Z", dt.getValueAsString()); assertEquals("2010-01-01T09:00:00.12345Z", dt.getValueAsString());
} }
@Test
public void testParseYear() throws DataFormatException {
DateTimeDt dt = new DateTimeDt();
dt.setValueAsString("2013");
assertEquals("2013", myDateInstantParser.format(dt.getValue()).substring(0, 4));
assertEquals("2013", dt.getValueAsString());
assertEquals(false, dt.isTimeZoneZulu());
assertNull(dt.getTimeZone());
assertEquals(TemporalPrecisionEnum.YEAR, dt.getPrecision());
}
/**
* See #101
*/
@Test
public void testPrecision() throws Exception {
Calendar cal = Calendar.getInstance();
cal.setTime(myDateInstantParser.parse("2012-01-02 22:31:02.333"));
cal.setTimeZone(TimeZone.getTimeZone("EST"));
Patient patient = new Patient();
patient.setBirthDate(cal.getTime(), TemporalPrecisionEnum.DAY);
String out = ourCtx.newXmlParser().encodeResourceToString(patient);
assertThat(out, containsString("<birthDate value=\"2012-01-02\"/>"));
}
/** /**
* See HAPI #101 - https://github.com/jamesagnew/hapi-fhir/issues/101 * See HAPI #101 - https://github.com/jamesagnew/hapi-fhir/issues/101
*/ */
@ -190,21 +512,6 @@ public class BaseDateTimeDtDstu2Test {
assertEquals("2012-01-02", date.getValueAsString()); assertEquals("2012-01-02", date.getValueAsString());
} }
@Test
public void testMinutePrecisionEncode() throws Exception {
Calendar cal = Calendar.getInstance();
cal.setTimeZone(TimeZone.getTimeZone("Europe/Berlin"));
cal.set(1990, Calendar.JANUARY, 3, 3, 22, 11);
DateTimeDt date = new DateTimeDt();
date.setValue(cal.getTime(), TemporalPrecisionEnum.MINUTE);
date.setTimeZone(TimeZone.getTimeZone("EST"));
assertEquals("1990-01-02T21:22-05:00", date.getValueAsString());
date.setTimeZoneZulu(true);
assertEquals("1990-01-03T02:22Z", date.getValueAsString());
}
/** /**
* See HAPI #101 - https://github.com/jamesagnew/hapi-fhir/issues/101 * See HAPI #101 - https://github.com/jamesagnew/hapi-fhir/issues/101
*/ */
@ -221,6 +528,18 @@ public class BaseDateTimeDtDstu2Test {
assertEquals("2012-01-02", date.getValueAsString()); assertEquals("2012-01-02", date.getValueAsString());
} }
@Test
public void testSetValueByString() {
InstantDt i = new InstantDt();
i.setValueAsString("2014-06-20T20:22:09Z");
assertNotNull(i.getValue());
assertNotNull(i.getValueAsString());
assertEquals(1403295729000L, i.getValue().getTime());
assertEquals("2014-06-20T20:22:09Z", i.getValueAsString());
}
@Test @Test
public void testToHumanDisplay() { public void testToHumanDisplay() {
DateTimeDt dt = new DateTimeDt("2012-01-05T12:00:00-08:00"); DateTimeDt dt = new DateTimeDt("2012-01-05T12:00:00-08:00");
@ -234,6 +553,11 @@ public class BaseDateTimeDtDstu2Test {
Locale.setDefault(ourDefaultLocale); Locale.setDefault(ourDefaultLocale);
} }
@AfterClass
public static void afterClassClearContext() {
TestUtil.clearAllStaticFieldsForUnitTest();
}
@BeforeClass @BeforeClass
public static void beforeClass() { public static void beforeClass() {
/* /*