Datasets:
Minata
/
src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Community
1
src_fm_fc_ms_ff
stringlengths
43
86.8k
target
stringlengths
20
276k
CommandLineRunner implements Runnable { protected Pattern getGlobFinderPattern() { if (globFinderPattern == null) { globFinderPattern = Pattern.compile("(" + getNormalPathPattern().pattern() + ").+"); } return globFinderPattern; } CommandLineRunner(CommandLine commandLine); CommandLineRunner(CommandLine commandLine, FileSystem fileSystem); @Override void run(); static boolean isValid(Path path); }
@Test void testGlobPattern() { FileSystem mockWindowsFileSystem = mock(FileSystem.class); String mockSeparator = ":"; when(mockWindowsFileSystem.getSeparator()).thenReturn(mockSeparator); CommandLineRunner runner = new CommandLineRunner(line(VALID_FILE), mockWindowsFileSystem); Truth.assertThat(runner.getGlobFinderPattern().pattern()).contains(mockSeparator); }
CommandLineRunner implements Runnable { public static boolean isValid(Path path) { return Files.isRegularFile(path) && Files.isReadable(path); } CommandLineRunner(CommandLine commandLine); CommandLineRunner(CommandLine commandLine, FileSystem fileSystem); @Override void run(); static boolean isValid(Path path); }
@Test void testValidPath_valid() { Path path = Paths.get(VALID_FILE); boolean valid = CommandLineRunner.isValid(path); Truth.assertThat(valid).isTrue(); } @Test void testValidPath_invalid() { Path path = Paths.get(INVALID_FILE); boolean invalid = CommandLineRunner.isValid(path); Truth.assertThat(invalid).isFalse(); }
MeasuredInputStreamSupplier implements Supplier<InputStream> { public static MeasuredInputStreamSupplier terminallyTransformInputStream(InputStream source) { Objects.requireNonNull(source, "source"); return new MeasuredInputStreamSupplier(source); } private MeasuredInputStreamSupplier(InputStream source); static MeasuredInputStreamSupplier terminallyTransformInputStream(InputStream source); @Override InputStream get(); int size(); }
@Test void testGetInputStreamReturnsUnique() { InputStream use = stream("mock"); MeasuredInputStreamSupplier objectToTest = MeasuredInputStreamSupplier.terminallyTransformInputStream(use); int expected = 5; long count = Stream.generate(objectToTest::get).limit(expected).distinct().count(); Truth.assertThat(count).isEqualTo(expected); } @Test void testTerminallyTransformInputStreamIsTerminal() throws IOException { InputStream use = stream("mock"); MeasuredInputStreamSupplier.terminallyTransformInputStream(use); Truth.assertThat(use.available()).isEqualTo(0); }
ConversionFileWriterWrapper { public void transform() { if (context == null) { context = new Context(); } Converter converter = new Converter(source, context); executeConverter(converter); } ConversionFileWriterWrapper(Path inFile); ConversionFileWriterWrapper setContext(Context context); void transform(); }
@Test public void testInvalidQpp() { Path path = Paths.get("src/test/resources/not-a-QRDA-III-file.xml"); ConversionFileWriterWrapper converterWrapper = new ConversionFileWriterWrapper(path); converterWrapper.transform(); assertFileExists("not-a-QRDA-III-file-error.json"); } @Test @PrepareForTest({Files.class, ConversionFileWriterWrapper.class}) public void testFailureToWriteQpp() throws IOException { PowerMockito.mockStatic(Files.class); PowerMockito.when(Files.newBufferedWriter(ArgumentMatchers.any(Path.class))).thenThrow(new IOException()); Path path = Paths.get("../qrda-files/valid-QRDA-III-latest.xml"); ConversionFileWriterWrapper converterWrapper = new ConversionFileWriterWrapper(path); converterWrapper.transform(); assertFileDoesNotExists("valid-QRDA-III-latest-qpp.json"); } @Test @PrepareForTest({Files.class, ConversionFileWriterWrapper.class}) public void testFailureToWriteErrors() throws IOException { PowerMockito.mockStatic(Files.class); PowerMockito.when(Files.newBufferedWriter(ArgumentMatchers.any(Path.class))).thenThrow(new IOException()); Path path = Paths.get("src/test/resources/not-a-QRDA-III-file.xml"); ConversionFileWriterWrapper converterWrapper = new ConversionFileWriterWrapper(path); converterWrapper.transform(); assertFileDoesNotExists("not-a-QRDA-III-file-error.json"); } @Test public void testErrorHasSourceId() throws IOException { Path path = Paths.get("src/test/resources/not-a-QRDA-III-file.xml"); ConversionFileWriterWrapper converterWrapper = new ConversionFileWriterWrapper(path); converterWrapper.transform(); String sourceId = JsonTestHelper.readJsonAtJsonPath(Paths.get("not-a-QRDA-III-file-error.json"), "$.errors[0].sourceIdentifier", String.class); assertThat(sourceId) .isEqualTo("not-a-QRDA-III-file.xml"); } @Test public void testErrorHasDetail() throws IOException { Path path = Paths.get("src/test/resources/not-a-QRDA-III-file.xml"); ConversionFileWriterWrapper converterWrapper = new ConversionFileWriterWrapper(path); converterWrapper.transform(); Detail detail = JsonTestHelper.readJsonAtJsonPath(Paths.get("not-a-QRDA-III-file-error.json"), "$.errors[0].details[0]", Detail.class); assertThat(detail.getMessage()) .isEqualTo(ProblemCode.NOT_VALID_QRDA_DOCUMENT.format(Context.REPORTING_YEAR, DocumentationReference.CLINICAL_DOCUMENT).getMessage()); assertThat(detail.getLocation().getPath()) .isEmpty(); } @Test public void testErrorHasMultipleDetails() throws IOException { LocalizedProblem firstError = ProblemCode.NUMERATOR_DENOMINATOR_INVALID_VALUE.format("Numerator", "-1"); LocalizedProblem secondError = ProblemCode.NUMERATOR_DENOMINATOR_INVALID_VALUE.format("Denominator", "-1"); Path path = Paths.get("src/test/resources/qrda_bad_denominator.xml"); ConversionFileWriterWrapper converterWrapper = new ConversionFileWriterWrapper(path); converterWrapper.transform(); Detail firstDetail = JsonTestHelper.readJsonAtJsonPath(Paths.get("qrda_bad_denominator-error.json"), "$.errors[0].details[0]", Detail.class); Detail secondDetail = JsonTestHelper.readJsonAtJsonPath(Paths.get("qrda_bad_denominator-error.json"), "$.errors[0].details[1]", Detail.class); JsonTestHelper.readJsonAtJsonPath(Paths.get("qrda_bad_denominator-error.json"), "$.errors[0].details"); assertThat(firstDetail.getMessage()).isEqualTo(firstError.getMessage()); assertThat(firstDetail.getLocation().getPath()).isNotNull(); assertThat(secondDetail.getMessage()).isEqualTo(secondError.getMessage()); assertThat(secondDetail.getLocation().getPath()).isNotNull(); }
CommandLineMain { static CommandLine cli(String... arguments) { try { return new DefaultParser().parse(OPTIONS, arguments); } catch (ParseException exception) { DEV_LOG.error("Problem parsing cli options, {}", exception.getMessage()); return null; } } static void main(String... arguments); static final String BYGONE; static final String SKIP_VALIDATION; static final String RECURSIVE; static final String HELP; }
@Test void testCliInvalidOption() { CommandLine line = CommandLineMain.cli("-" + CommandLineMain.SKIP_VALIDATION + " -InvalidArgument"); Truth.assertThat(line).isNull(); Truth.assertThat(getLogs()).isNotEmpty(); }
CommandLineMain { public static void main(String... arguments) { CommandLine commandLine = cli(arguments); if (commandLine != null) { new CommandLineRunner(commandLine).run(); } } static void main(String... arguments); static final String BYGONE; static final String SKIP_VALIDATION; static final String RECURSIVE; static final String HELP; }
@Test void testMainInvalidCli() { CommandLineMain.main("-InvalidArgument"); Truth.assertThat(getLogs()).isNotEmpty(); } @Test void testMain() { CommandLineMain.main(); Truth.assertThat(getLogs()).isEmpty(); }
ErrorCodeDocumentationGenerator extends AbstractMojo { protected String determinOffsetPath() { @SuppressWarnings("rawtypes") Map context = getPluginContext(); MavenProject project = (MavenProject) context.get("project"); MavenProject parent = project.getParent(); String offsetPath = ""; if (parent != null) { String parentPath = parent.getBasedir().getAbsolutePath(); String workingDir = System.getProperty("user.dir"); if (parentPath.equals(workingDir)) { offsetPath = "./"; } else { offsetPath = "../"; } } return offsetPath; } static void main(String... args); @Override void execute(); }
@Test public void test_determinOffsetPath_doubledot() { String workingDir = System.getProperty("user.dir"); File mockBaseDir = new File(workingDir); String generate = "/generate"; File mockParentDir = new File(workingDir.substring(0, workingDir.length()-generate.length())); MavenProject mockParentProject = mock(MavenProject.class); when(mockParentProject.getBasedir()).thenReturn(mockParentDir); MavenProject mockProject = mock(MavenProject.class); when(mockProject.getBasedir()).thenReturn(mockBaseDir); when(mockProject.getParent()).thenReturn(mockParentProject); Map<String, Object> mockContext = new HashMap<>(); mockContext.put("project", mockProject); gen.setPluginContext(mockContext); String expected = "../"; String actual = gen.determinOffsetPath(); assertWithMessage("When the working directory is the subproject then use the parent dir.") .that(actual).isEqualTo(expected); } @Test public void test_determinOffsetPath_dot() { String workingDir = System.getProperty("user.dir"); File mockBaseDir = new File(workingDir); String generate = "/generate"; workingDir = workingDir.substring(0, workingDir.length()-generate.length()); System.setProperty("user.dir", workingDir); File mockParentDir = new File(workingDir); MavenProject mockParentProject = mock(MavenProject.class); when(mockParentProject.getBasedir()).thenReturn(mockParentDir); MavenProject mockProject = mock(MavenProject.class); when(mockProject.getBasedir()).thenReturn(mockBaseDir); when(mockProject.getParent()).thenReturn(mockParentProject); Map<String, Object> mockContext = new HashMap<>(); mockContext.put("project", mockProject); gen.setPluginContext(mockContext); String expected = "./"; String actual = gen.determinOffsetPath(); assertWithMessage("When the working directory is the parent project then use the working dir.") .that(actual).isEqualTo(expected); }
CpcFileServiceImpl implements CpcFileService { @Override public InputStreamResource getQppById(String fileId) { Metadata metadata = getMetadataById(fileId); return new InputStreamResource(storageService.getFileByLocationId(metadata.getQppLocator())); } CpcFileServiceImpl(DbService dbService, StorageService storageService); @Override List<UnprocessedCpcFileData> getUnprocessedCpcPlusFiles(String orgAttribute); @Override InputStreamResource getFileById(String fileId); @Override InputStreamResource getQppById(String fileId); @Override String processFileById(String fileId, String orgName); @Override String unprocessFileById(String fileId, String orgName); @Override Metadata getMetadataById(String fileId); static final String FILE_NOT_FOUND; }
@Test void testGetQppById() throws IOException { String key = "test"; when(dbService.getMetadataById(key)).thenReturn(buildFakeMetadata(true, false, false)); when(storageService.getFileByLocationId(key)).thenReturn(new ByteArrayInputStream("1337".getBytes())); InputStreamResource outcome = objectUnderTest.getQppById(key); verify(dbService, times(1)).getMetadataById(key); verify(storageService, times(1)).getFileByLocationId(key); assertThat(IOUtils.toString(outcome.getInputStream(), StandardCharsets.UTF_8)).isEqualTo("1337"); }
XmlUtils { public static Element stringToDom(String xml) { if (xml == null) { return null; } return parseXmlStream(new ByteArrayInputStream(xml.getBytes(StandardCharsets.UTF_8))); } private XmlUtils(); static Element stringToDom(String xml); static Element parseXmlStream(InputStream xmlStream); static String buildString(String... parts); }
@Test void stringToDomCanParse() throws Exception { Element dom = XmlUtils.stringToDom(xmlFragment); assertWithMessage("returned dom should not be null") .that(dom).isNotNull(); } @Test void stringToDomRootChild() throws Exception { Element dom = XmlUtils.stringToDom(xmlFragment); List<Element> childElement = dom.getChildren(); assertWithMessage("test root has one child") .that(childElement) .hasSize(1); } @Test void stringToDomOtherDescendants() throws Exception { Element dom = XmlUtils.stringToDom(xmlFragment); List<Element> childElement = dom.getChildren(); List<Element> leafElements = childElement.get(0).getChildren(); assertWithMessage("test observation has five children") .that(leafElements).hasSize(5); } @Test void stringToDom_null() throws Exception { Element dom = XmlUtils.stringToDom(null); assertWithMessage("returned dom should be null") .that(dom).isNull(); } @Test void stringToDom_emptyString() throws Exception { Assertions.assertThrows(XmlException.class, () -> XmlUtils.stringToDom("")); } @Test void stringToDom_invalidXML() throws Exception { Assertions.assertThrows(XmlException.class, () -> XmlUtils.stringToDom("invalid XML")); }
JsonHelper { public static <T> T readJsonAtJsonPath(InputStream jsonStream, String jsonPath, TypeRef<T> returnType) { return JsonPath.parse(jsonStream).read(jsonPath, returnType); } private JsonHelper(); static T readJson(String json, Class<T> valueType); static T readJson(Path filePath, Class<T> valueType); static T readJson(InputStream json, Class<T> valueType); static T readJson(InputStream json, TypeReference<T> valueType); static T readJson(Path filePath, TypeReference<T> valueType); static T readJsonAtJsonPath(InputStream jsonStream, String jsonPath, TypeRef<T> returnType); static T readJsonAtJsonPath(String json, String jsonPath, TypeRef<T> returnType); }
@Test void readJsonAtJsonPath() throws Exception { String measureDataFileName = "measures-data.json"; List<MeasureConfig> configurations; InputStream measuresInput = ClasspathHelper.contextClassLoader().getResourceAsStream(measureDataFileName); configurations = JsonHelper.readJsonAtJsonPath(measuresInput, "$", new TypeRef<List<MeasureConfig>>() { }); assertWithMessage("Expect to get a List of measureConfigs") .that(configurations).isNotEmpty(); }
JsonHelper { public static <T> T readJson(String json, Class<T> valueType) { T returnValue; try { returnValue = new ObjectMapper().readValue(json, valueType); } catch (IOException ex) { throw new JsonReadException(PROBLEM_PARSING_JSON, ex); } return returnValue; } private JsonHelper(); static T readJson(String json, Class<T> valueType); static T readJson(Path filePath, Class<T> valueType); static T readJson(InputStream json, Class<T> valueType); static T readJson(InputStream json, TypeReference<T> valueType); static T readJson(Path filePath, TypeReference<T> valueType); static T readJsonAtJsonPath(InputStream jsonStream, String jsonPath, TypeRef<T> returnType); static T readJsonAtJsonPath(String json, String jsonPath, TypeRef<T> returnType); }
@Test void exceptionForReadJsonInputStream() { String testJson = "{ \"DogCow\": [ }"; try { JsonHelper.readJson(new ByteArrayInputStream(testJson.getBytes()), Map.class); Assertions.fail("An exception should have been thrown."); } catch(JsonReadException exception) { assertWithMessage("Wrong exception reason.") .that(exception).hasMessageThat().isSameInstanceAs("Problem parsing json string"); } catch(Exception exception) { Assertions.fail("Incorrect exception was thrown."); } } @Test void exceptionForReadJsonString() { String testJson = "{ \"DogCow\": [ }"; try { JsonHelper.readJson(testJson, Map.class); Assertions.fail("An exception should have been thrown."); } catch(JsonReadException exception) { assertWithMessage("Wrong exception reason.") .that(exception).hasMessageThat().isSameInstanceAs("Problem parsing json string"); } catch(Exception exception) { Assertions.fail("Incorrect exception was thrown."); } }
CpcFileServiceImpl implements CpcFileService { @Override public InputStreamResource getFileById(String fileId) { Metadata metadata = getMetadataById(fileId); if (isAnUnprocessedCpcFile(metadata)) { return new InputStreamResource(storageService.getFileByLocationId(metadata.getSubmissionLocator())); } throw new NoFileInDatabaseException(FILE_NOT_FOUND); } CpcFileServiceImpl(DbService dbService, StorageService storageService); @Override List<UnprocessedCpcFileData> getUnprocessedCpcPlusFiles(String orgAttribute); @Override InputStreamResource getFileById(String fileId); @Override InputStreamResource getQppById(String fileId); @Override String processFileById(String fileId, String orgName); @Override String unprocessFileById(String fileId, String orgName); @Override Metadata getMetadataById(String fileId); static final String FILE_NOT_FOUND; }
@Test void testGetFileById() throws IOException { when(dbService.getMetadataById(anyString())).thenReturn(buildFakeMetadata(true, false, false)); when(storageService.getFileByLocationId("test")).thenReturn(new ByteArrayInputStream("1337".getBytes())); InputStreamResource outcome = objectUnderTest.getFileById("test"); verify(dbService, times(1)).getMetadataById(anyString()); verify(storageService, times(1)).getFileByLocationId(anyString()); assertThat(IOUtils.toString(outcome.getInputStream(), StandardCharsets.UTF_8)).isEqualTo("1337"); }
DuplicationCheckHelper { public static int calculateDuplications(Node node, String type) { List<String> valueCountList = node.getDuplicateValues(type); return (valueCountList != null) ? (valueCountList.size() + ACCOUNT_FOR_ORIGINAL_VALUE) : ACCOUNT_FOR_MISSING_VALUE; } private DuplicationCheckHelper(); static int calculateDuplications(Node node, String type); static final int ACCOUNT_FOR_ORIGINAL_VALUE; static final int ACCOUNT_FOR_MISSING_VALUE; }
@Test void testDuplicateCheckerWithNoDuplicateAggregateCounts() { Node node = new Node(TemplateId.PI_AGGREGATE_COUNT); node.putValue(AggregateCountDecoder.AGGREGATE_COUNT, "1234", false); int duplicationValue = DuplicationCheckHelper.calculateDuplications(node, AggregateCountDecoder.AGGREGATE_COUNT); assertThat(duplicationValue).isEqualTo(0); } @Test void testDuplicateCheckerWithDuplicateAggregateCounts() { Node node = new Node(TemplateId.PI_AGGREGATE_COUNT); node.putValue(AggregateCountDecoder.AGGREGATE_COUNT, "1234", false); node.putValue(AggregateCountDecoder.AGGREGATE_COUNT, "1234", false); int duplicationValue = DuplicationCheckHelper.calculateDuplications(node, AggregateCountDecoder.AGGREGATE_COUNT); assertThat(duplicationValue).isEqualTo(2); }
FormatHelper { public static LocalDate formattedDateParse(String date) { String parse = cleanString(date); parse = parse.replace("-", "").replace("/", ""); if (parse.length() > DATE_FORMAT.length()) { parse = parse.substring(0, DATE_FORMAT.length()); } return LocalDate.parse(cleanString(parse), DateTimeFormatter.ofPattern(DATE_FORMAT)); } private FormatHelper(); static LocalDate formattedDateParse(String date); static String cleanString(String value); }
@Test void testFormattedDateParseRemovesDashes() { LocalDate date = FormatHelper.formattedDateParse(VALID_DASH_DATE); assertThat(date).isEqualTo(DATE_COMPARED); } @Test void testFormattedDateParseRemovesSlashes() { LocalDate date = FormatHelper.formattedDateParse(VALID_SLASH_DATE); assertThat(date).isEqualTo(DATE_COMPARED); } @Test void testFormattedDateParseRemovesTimeAndZone() { LocalDate date = FormatHelper.formattedDateParse(VALID_TIMEZONED_DATE); assertThat(date).isEqualTo(DATE_COMPARED); }
MeasureConfigHelper { public static MeasureConfig getMeasureConfig(Node node) { String measureId = node.getValue(MEASURE_ID); return findMeasureConfigByUuid(measureId); } private MeasureConfigHelper(); static MeasureConfig getMeasureConfig(Node node); static String getMeasureConfigIdByUuidOrDefault(String uuid); static String getPrioritizedId(Node node); static List<Node> createSubPopulationGrouping(Node node, MeasureConfig measureConfig); static boolean checkMultiToSinglePerformanceRateId(String measureId); static void setMultiToSinglePerfRateMeasureId(Set<String> multiToSinglePerfRateMeasureIdSet); static final String MEASURE_ID; static final String NO_MEASURE; static final String SINGLE_TO_MULTIPLE_SUP_POPULATION; final static String SINGLE_TO_MULTI_PERF_RATE_MEASURE_ID; }
@Test void testGetMeasureConfigSuccess() { Node measureNode = new Node(TemplateId.MEASURE_REFERENCE_RESULTS_CMS_V4); measureNode.putValue(MeasureConfigHelper.MEASURE_ID, THE_UUID); MeasureConfig config = MeasureConfigHelper.getMeasureConfig(measureNode); assertThat(config).isNotNull(); }
JsonWrapper { protected String validInteger(String value) { try { String cleanValue = FormatHelper.cleanString(value); Integer.parseInt(cleanValue); return cleanValue; } catch (RuntimeException e) { throw new EncodeException(value + " is not an integer.", e); } } JsonWrapper(); JsonWrapper(Kind kind); JsonWrapper(String value); JsonWrapper(Boolean value); JsonWrapper(Integer value); JsonWrapper(Float value); JsonWrapper(JsonWrapper wrapper); private JsonWrapper(JsonWrapper wrapper, boolean withMetadata); Type getType(); boolean isType(Type type); Kind getKind(); boolean isKind(Kind kind); String getKey(); JsonWrapper copyWithoutMetadata(); JsonWrapper clear(); JsonWrapper put(String name, String value); JsonWrapper put(String name, Integer value); JsonWrapper put(String name, Float value); JsonWrapper put(String name, Boolean value); JsonWrapper put(String value); JsonWrapper put(Integer value); JsonWrapper put(Float value); JsonWrapper put(Boolean value); JsonWrapper put(JsonWrapper value); JsonWrapper put(String name, JsonWrapper value); JsonWrapper putDate(String name, String value); JsonWrapper putDate(String value); JsonWrapper putInteger(String name, String value); JsonWrapper putInteger(String value); JsonWrapper putFloat(String name, String value); JsonWrapper putFloat(String value); JsonWrapper putBoolean(String name, String value); JsonWrapper putBoolean(String value); JsonWrapper remove(String name); String getString(String name); Integer getInteger(String name); Float getFloat(String name); @SuppressFBWarnings(value = "NP_BOOLEAN_RETURN_NULL", justification = "Null is desired when not found.") Boolean getBoolean(String name); boolean isDuplicateEntry(JsonWrapper wrapper); boolean isMap(); boolean isList(); boolean isValue(); boolean isMetadata(); boolean hasMetadata(); Stream<JsonWrapper> stream(); @Override String toString(); String toStringWithMetadata(); Object toObject(); Object stripWrapper(Object value); Source toSource(); JsonWrapper getMetadata(); JsonWrapper addMetadata(JsonWrapper newMetadata); JsonWrapper putMetadata(String name, String value); int size(); JsonWrapper getByJsonPath(String jsonPath); JsonWrapper get(JsonPath jsonPath); JsonWrapper get(String name); JsonWrapper get(int index); static final String METADATA_HOLDER; static final String ENCODING_KEY; static final ObjectMapper jsonMapper; }
@Test @DisplayName("should validate and fail null passed as integer") void testValidInterIsNull() { Throwable exception = assertThrows(EncodeException.class, () -> { objectObjWrapper.validInteger(null); }); assertThat(exception).hasCauseThat().isInstanceOf(NumberFormatException.class); } @Test @DisplayName("should validate and fail non-numeric string passed as integer") void testValidInterIsNotNumber() { Throwable exception = assertThrows(EncodeException.class, () -> { objectObjWrapper.validInteger("meep"); }); assertThat(exception).hasCauseThat().isInstanceOf(NumberFormatException.class); }
JsonWrapper { @Override public String toString() { try { return jsonWriter.writeValueAsString(toObject()); } catch (JsonProcessingException e) { throw new EncodeException("Issue rendering JSON from JsonWrapper Map", e); } } JsonWrapper(); JsonWrapper(Kind kind); JsonWrapper(String value); JsonWrapper(Boolean value); JsonWrapper(Integer value); JsonWrapper(Float value); JsonWrapper(JsonWrapper wrapper); private JsonWrapper(JsonWrapper wrapper, boolean withMetadata); Type getType(); boolean isType(Type type); Kind getKind(); boolean isKind(Kind kind); String getKey(); JsonWrapper copyWithoutMetadata(); JsonWrapper clear(); JsonWrapper put(String name, String value); JsonWrapper put(String name, Integer value); JsonWrapper put(String name, Float value); JsonWrapper put(String name, Boolean value); JsonWrapper put(String value); JsonWrapper put(Integer value); JsonWrapper put(Float value); JsonWrapper put(Boolean value); JsonWrapper put(JsonWrapper value); JsonWrapper put(String name, JsonWrapper value); JsonWrapper putDate(String name, String value); JsonWrapper putDate(String value); JsonWrapper putInteger(String name, String value); JsonWrapper putInteger(String value); JsonWrapper putFloat(String name, String value); JsonWrapper putFloat(String value); JsonWrapper putBoolean(String name, String value); JsonWrapper putBoolean(String value); JsonWrapper remove(String name); String getString(String name); Integer getInteger(String name); Float getFloat(String name); @SuppressFBWarnings(value = "NP_BOOLEAN_RETURN_NULL", justification = "Null is desired when not found.") Boolean getBoolean(String name); boolean isDuplicateEntry(JsonWrapper wrapper); boolean isMap(); boolean isList(); boolean isValue(); boolean isMetadata(); boolean hasMetadata(); Stream<JsonWrapper> stream(); @Override String toString(); String toStringWithMetadata(); Object toObject(); Object stripWrapper(Object value); Source toSource(); JsonWrapper getMetadata(); JsonWrapper addMetadata(JsonWrapper newMetadata); JsonWrapper putMetadata(String name, String value); int size(); JsonWrapper getByJsonPath(String jsonPath); JsonWrapper get(JsonPath jsonPath); JsonWrapper get(String name); JsonWrapper get(int index); static final String METADATA_HOLDER; static final String ENCODING_KEY; static final ObjectMapper jsonMapper; }
@Test void testValidDateFromInstant() throws Exception { ensureDateIsValid(Instant.now().toString()); } @Test void testValidDateFromLocalDate() throws Exception { ensureDateIsValid(LocalDate.now().toString()); } @Test void testValidDateFromLocalDateTime() throws Exception { ensureDateIsValid(LocalDateTime.now().toString()); }
StorageServiceImpl extends AnyOrderActionService<Supplier<PutObjectRequest>, String> implements StorageService { @Override public InputStream getFileByLocationId(String fileLocationId) { String bucketName = environment.getProperty(Constants.BUCKET_NAME_ENV_VARIABLE); if (StringUtils.isEmpty(bucketName)) { API_LOG.warn("No bucket name is specified."); return null; } API_LOG.info("Retrieving file {} from bucket {}", fileLocationId, bucketName); GetObjectRequest getObjectRequest = new GetObjectRequest(bucketName, fileLocationId); S3Object s3Object = amazonS3.getObject(getObjectRequest); API_LOG.info("Successfully retrieved file {} from S3 bucket {}", getObjectRequest.getKey(), getObjectRequest.getBucketName()); return s3Object.getObjectContent(); } StorageServiceImpl(TaskExecutor taskExecutor, TransferManager s3TransferManager, Environment environment, AmazonS3 amazonS3); @Override CompletableFuture<String> store(String keyName, Supplier<InputStream> inStream, long size); @Override InputStream getFileByLocationId(String fileLocationId); @Override InputStream getCpcPlusValidationFile(); @Override InputStream getApmValidationFile(); }
@Test void noBucket() { Mockito.when(environment.getProperty(Constants.BUCKET_NAME_ENV_VARIABLE)).thenReturn(null); InputStream inStream = underTest.getFileByLocationId("meep"); assertThat(inStream).isNull(); } @Test void envVariablesPresent() { S3Object s3ObjectMock = mock(S3Object.class); s3ObjectMock.setObjectContent(new ByteArrayInputStream("1234".getBytes())); Mockito.when(amazonS3Client.getObject(any(GetObjectRequest.class))).thenReturn(s3ObjectMock); Mockito.when(environment.getProperty(Constants.BUCKET_NAME_ENV_VARIABLE)).thenReturn("meep"); underTest.getFileByLocationId("meep"); verify(s3ObjectMock, times(1)).getObjectContent(); }
JsonWrapper { public JsonWrapper putDate(String name, String value) { try { put(name, validDate(value), Type.DATE); } catch (EncodeException e) { put(name, value, Type.DATE); throw e; } return this; } JsonWrapper(); JsonWrapper(Kind kind); JsonWrapper(String value); JsonWrapper(Boolean value); JsonWrapper(Integer value); JsonWrapper(Float value); JsonWrapper(JsonWrapper wrapper); private JsonWrapper(JsonWrapper wrapper, boolean withMetadata); Type getType(); boolean isType(Type type); Kind getKind(); boolean isKind(Kind kind); String getKey(); JsonWrapper copyWithoutMetadata(); JsonWrapper clear(); JsonWrapper put(String name, String value); JsonWrapper put(String name, Integer value); JsonWrapper put(String name, Float value); JsonWrapper put(String name, Boolean value); JsonWrapper put(String value); JsonWrapper put(Integer value); JsonWrapper put(Float value); JsonWrapper put(Boolean value); JsonWrapper put(JsonWrapper value); JsonWrapper put(String name, JsonWrapper value); JsonWrapper putDate(String name, String value); JsonWrapper putDate(String value); JsonWrapper putInteger(String name, String value); JsonWrapper putInteger(String value); JsonWrapper putFloat(String name, String value); JsonWrapper putFloat(String value); JsonWrapper putBoolean(String name, String value); JsonWrapper putBoolean(String value); JsonWrapper remove(String name); String getString(String name); Integer getInteger(String name); Float getFloat(String name); @SuppressFBWarnings(value = "NP_BOOLEAN_RETURN_NULL", justification = "Null is desired when not found.") Boolean getBoolean(String name); boolean isDuplicateEntry(JsonWrapper wrapper); boolean isMap(); boolean isList(); boolean isValue(); boolean isMetadata(); boolean hasMetadata(); Stream<JsonWrapper> stream(); @Override String toString(); String toStringWithMetadata(); Object toObject(); Object stripWrapper(Object value); Source toSource(); JsonWrapper getMetadata(); JsonWrapper addMetadata(JsonWrapper newMetadata); JsonWrapper putMetadata(String name, String value); int size(); JsonWrapper getByJsonPath(String jsonPath); JsonWrapper get(JsonPath jsonPath); JsonWrapper get(String name); JsonWrapper get(int index); static final String METADATA_HOLDER; static final String ENCODING_KEY; static final ObjectMapper jsonMapper; }
@Test @DisplayName("should invalidate null value for date") void testValidDateNullInvalid() throws Exception { Assertions.assertThrows(EncodeException.class, () -> objectObjWrapper.putDate(null)); } @Test void testValidDateYyMmDdIsInvalid() throws Exception { Assertions.assertThrows(EncodeException.class, () -> objectObjWrapper.putDate("690720")); } @Test void testBadKeyedPutDate_exception() { assertThrows(EncodeException.class, () -> objectObjWrapper.putDate("A date which will live in infamy", "December 7, 1941")); } @Test void testBadPutDate_exception() { assertThrows(EncodeException.class, () -> objectObjWrapper.putDate("December 7, 1941")); } @Test void putDate_invalid() { assertThrows(EncodeException.class, () -> { new JsonWrapper().putDate("date","not a date"); }); }
JsonWrapper { public JsonWrapper put(String name, String value) { put(name, value, Type.STRING); return this; } JsonWrapper(); JsonWrapper(Kind kind); JsonWrapper(String value); JsonWrapper(Boolean value); JsonWrapper(Integer value); JsonWrapper(Float value); JsonWrapper(JsonWrapper wrapper); private JsonWrapper(JsonWrapper wrapper, boolean withMetadata); Type getType(); boolean isType(Type type); Kind getKind(); boolean isKind(Kind kind); String getKey(); JsonWrapper copyWithoutMetadata(); JsonWrapper clear(); JsonWrapper put(String name, String value); JsonWrapper put(String name, Integer value); JsonWrapper put(String name, Float value); JsonWrapper put(String name, Boolean value); JsonWrapper put(String value); JsonWrapper put(Integer value); JsonWrapper put(Float value); JsonWrapper put(Boolean value); JsonWrapper put(JsonWrapper value); JsonWrapper put(String name, JsonWrapper value); JsonWrapper putDate(String name, String value); JsonWrapper putDate(String value); JsonWrapper putInteger(String name, String value); JsonWrapper putInteger(String value); JsonWrapper putFloat(String name, String value); JsonWrapper putFloat(String value); JsonWrapper putBoolean(String name, String value); JsonWrapper putBoolean(String value); JsonWrapper remove(String name); String getString(String name); Integer getInteger(String name); Float getFloat(String name); @SuppressFBWarnings(value = "NP_BOOLEAN_RETURN_NULL", justification = "Null is desired when not found.") Boolean getBoolean(String name); boolean isDuplicateEntry(JsonWrapper wrapper); boolean isMap(); boolean isList(); boolean isValue(); boolean isMetadata(); boolean hasMetadata(); Stream<JsonWrapper> stream(); @Override String toString(); String toStringWithMetadata(); Object toObject(); Object stripWrapper(Object value); Source toSource(); JsonWrapper getMetadata(); JsonWrapper addMetadata(JsonWrapper newMetadata); JsonWrapper putMetadata(String name, String value); int size(); JsonWrapper getByJsonPath(String jsonPath); JsonWrapper get(JsonPath jsonPath); JsonWrapper get(String name); JsonWrapper get(int index); static final String METADATA_HOLDER; static final String ENCODING_KEY; static final ObjectMapper jsonMapper; }
@Test void testJackson_simpleObject() throws Exception { Map<String, String> map = new LinkedHashMap<>(); map.put("name1", "value1"); map.put("name2", "value2"); String json = ow.writeValueAsString(map); String expect = "{\n \"name1\" : \"value1\",\n \"name2\" : \"value2\"\n}"; assertWithMessage("expect a simple object of JSON") .that(json) .isEqualTo(expect); } @Test void testJackson_objectWithArray() throws Exception { Map<String, Object> map = new LinkedHashMap<>(); map.put("name1", "value1"); map.put("name2", new String[] {"A","B","C"}); map.put("name3", "value3"); String json = ow.writeValueAsString(map); String expect = "{\n \"name1\" : \"value1\",\n"+ " \"name2\" : [ \"A\", \"B\", \"C\" ],\n" + " \"name3\" : \"value3\"\n}"; assertWithMessage("expect array to use [] rather than {} block") .that(json) .isEqualTo(expect); } @Test void testJackson_objectWithList() throws Exception { List<String> list = new LinkedList<>(); list.add("A"); list.add("B"); list.add("C"); Map<String, Object> map = new LinkedHashMap<>(); map.put("name1", "value1"); map.put("name2", list); map.put("name3", "value3"); String json = ow.writeValueAsString(map); String expect = "{\n \"name1\" : \"value1\",\n"+ " \"name2\" : [ \"A\", \"B\", \"C\" ],\n" + " \"name3\" : \"value3\"\n}"; assertWithMessage("expect list to look like array") .that(json) .isEqualTo(expect); } @Test void testJackson_objectWithChild() throws Exception { Map<String, Object> obj = new LinkedHashMap<>(); obj.put("obj1", "A"); obj.put("obj2", "B"); Map<String, Object> map = new LinkedHashMap<>(); map.put("name1", "value1"); map.put("name2", obj); map.put("name3", "value3"); String json = ow.writeValueAsString(map); String expect = "{\n \"name1\" : \"value1\",\n"+ " \"name2\" : {\n \"obj1\" : \"A\",\n \"obj2\" : \"B\"\n },\n" + " \"name3\" : \"value3\"\n}"; assertWithMessage("expect comma after child and no comma after last value pair") .that(json) .isEqualTo(expect); } @Test void testJackson_objectWithChild_commaAndOrder() throws Exception { Map<String, Object> obj = new LinkedHashMap<>(); obj.put("obj1", "A"); obj.put("obj2", "B"); Map<String, Object> map = new LinkedHashMap<>(); map.put("name1", "value1"); map.put("name3", "value3"); map.put("name2", obj); String json = ow.writeValueAsString(map); String expect = "{\n \"name1\" : \"value1\",\n"+ " \"name3\" : \"value3\",\n" + " \"name2\" : {\n \"obj1\" : \"A\",\n \"obj2\" : \"B\"\n }\n}"; assertWithMessage("expect no comma expected after the child and order as inserted") .that(json) .isEqualTo(expect); } @Test void testCheckState_objectThenList() { objectStrWrapper.put("name", "value"); assertThrows(IllegalStateException.class, () -> objectStrWrapper.put("value")); } @Test void testCheckState_listThenLObject() { listStrWrapper.put("value"); assertThrows(IllegalStateException.class, () -> listStrWrapper.put("name", "value")); } @Test void hasValue_true() throws Exception { JsonWrapper value = new JsonWrapper(Boolean.TRUE); boolean actual = Type.BOOLEAN.hasValue(value); assertWithMessage("Instance should have value") .that(actual).isTrue(); value = new JsonWrapper("01/01/2020"); actual = Type.DATE.hasValue(value); assertWithMessage("Instance should have value") .that(actual).isTrue(); value = new JsonWrapper(1); actual = Type.INTEGER.hasValue(value); assertWithMessage("Instance should have value") .that(actual).isTrue(); value = new JsonWrapper(1.1f); actual = Type.FLOAT.hasValue(value); assertWithMessage("Instance should have value") .that(actual).isTrue(); value = new JsonWrapper("value"); actual = Type.STRING.hasValue(value); assertWithMessage("Instance should have value") .that(actual).isTrue(); value = new JsonWrapper().put("name", "value"); actual = Type.MAP.hasValue(value); assertWithMessage("Instance should have value") .that(actual).isTrue(); value = new JsonWrapper().put("value"); actual = Type.LIST.hasValue(value); assertWithMessage("Instance should have value") .that(actual).isTrue(); } @Test void enumTypeMap() throws Exception { JsonGenerator gen = mock(JsonGenerator.class); JsonWrapper value = new JsonWrapper().put("name","value"); Type.MAP.json(value, gen); verify(gen, times(1)).writeObject(any(Map.class)); } @Test void enumTypeList() throws Exception { JsonGenerator gen = mock(JsonGenerator.class); JsonWrapper value = new JsonWrapper().put("value"); Type.LIST.json(value, gen); verify(gen, times(1)).writeObject(any(List.class)); } @Test void metadataMap_noMetadata() throws Exception { JsonGenerator gen = mock(JsonGenerator.class); InOrder order = Mockito.inOrder(gen); JsonWrapper value = new JsonWrapper().put("name","value").put("other","data"); Type.MAP.metadata(value, gen); order.verify(gen, times(1)).writeStartObject(); order.verify(gen, times(1)).writeObjectField("name","value"); order.verify(gen, times(1)).writeObjectField("other","data"); order.verify(gen, times(1)).writeEndObject(); } @Test void metadataMap_throwsIOE() throws Exception { JsonGenerator gen = mock(JsonGenerator.class); Mockito.doThrow(IOException.class).when(gen).writeObjectField("name", "value"); JsonWrapper value = new JsonWrapper().put("name","value"); assertThrows(RuntimeException.class, () -> {Type.MAP.metadata(value, gen);}); }
JsonWrapper { public JsonWrapper putInteger(String name, String value) { try { put(name, validInteger(value), Type.INTEGER); } catch (EncodeException e) { put(name, value, Type.INTEGER); throw e; } return this; } JsonWrapper(); JsonWrapper(Kind kind); JsonWrapper(String value); JsonWrapper(Boolean value); JsonWrapper(Integer value); JsonWrapper(Float value); JsonWrapper(JsonWrapper wrapper); private JsonWrapper(JsonWrapper wrapper, boolean withMetadata); Type getType(); boolean isType(Type type); Kind getKind(); boolean isKind(Kind kind); String getKey(); JsonWrapper copyWithoutMetadata(); JsonWrapper clear(); JsonWrapper put(String name, String value); JsonWrapper put(String name, Integer value); JsonWrapper put(String name, Float value); JsonWrapper put(String name, Boolean value); JsonWrapper put(String value); JsonWrapper put(Integer value); JsonWrapper put(Float value); JsonWrapper put(Boolean value); JsonWrapper put(JsonWrapper value); JsonWrapper put(String name, JsonWrapper value); JsonWrapper putDate(String name, String value); JsonWrapper putDate(String value); JsonWrapper putInteger(String name, String value); JsonWrapper putInteger(String value); JsonWrapper putFloat(String name, String value); JsonWrapper putFloat(String value); JsonWrapper putBoolean(String name, String value); JsonWrapper putBoolean(String value); JsonWrapper remove(String name); String getString(String name); Integer getInteger(String name); Float getFloat(String name); @SuppressFBWarnings(value = "NP_BOOLEAN_RETURN_NULL", justification = "Null is desired when not found.") Boolean getBoolean(String name); boolean isDuplicateEntry(JsonWrapper wrapper); boolean isMap(); boolean isList(); boolean isValue(); boolean isMetadata(); boolean hasMetadata(); Stream<JsonWrapper> stream(); @Override String toString(); String toStringWithMetadata(); Object toObject(); Object stripWrapper(Object value); Source toSource(); JsonWrapper getMetadata(); JsonWrapper addMetadata(JsonWrapper newMetadata); JsonWrapper putMetadata(String name, String value); int size(); JsonWrapper getByJsonPath(String jsonPath); JsonWrapper get(JsonPath jsonPath); JsonWrapper get(String name); JsonWrapper get(int index); static final String METADATA_HOLDER; static final String ENCODING_KEY; static final ObjectMapper jsonMapper; }
@Test void testToString_integerParseExcpetion() { assertThrows(EncodeException.class, () -> objectStrWrapper.putInteger("name2", "nope")); } @Test void testToString_integerParseExcpetion2() { assertThrows(EncodeException.class, () -> objectStrWrapper.putInteger("nope")); } @Test void putInteger() { JsonWrapper wrap = new JsonWrapper().put("int",1); assertWithMessage("Should return entered integer") .that(wrap.getInteger("int")) .isEqualTo(1); wrap = new JsonWrapper().put(1); assertWithMessage("Should return entered integer") .that(wrap.get(0).toObject()) .isEqualTo("1"); }
JsonWrapper { public JsonWrapper putFloat(String name, String value) { try { put(name, validFloat(value), Type.FLOAT); } catch (EncodeException e) { put(name, value, Type.FLOAT); throw e; } return this; } JsonWrapper(); JsonWrapper(Kind kind); JsonWrapper(String value); JsonWrapper(Boolean value); JsonWrapper(Integer value); JsonWrapper(Float value); JsonWrapper(JsonWrapper wrapper); private JsonWrapper(JsonWrapper wrapper, boolean withMetadata); Type getType(); boolean isType(Type type); Kind getKind(); boolean isKind(Kind kind); String getKey(); JsonWrapper copyWithoutMetadata(); JsonWrapper clear(); JsonWrapper put(String name, String value); JsonWrapper put(String name, Integer value); JsonWrapper put(String name, Float value); JsonWrapper put(String name, Boolean value); JsonWrapper put(String value); JsonWrapper put(Integer value); JsonWrapper put(Float value); JsonWrapper put(Boolean value); JsonWrapper put(JsonWrapper value); JsonWrapper put(String name, JsonWrapper value); JsonWrapper putDate(String name, String value); JsonWrapper putDate(String value); JsonWrapper putInteger(String name, String value); JsonWrapper putInteger(String value); JsonWrapper putFloat(String name, String value); JsonWrapper putFloat(String value); JsonWrapper putBoolean(String name, String value); JsonWrapper putBoolean(String value); JsonWrapper remove(String name); String getString(String name); Integer getInteger(String name); Float getFloat(String name); @SuppressFBWarnings(value = "NP_BOOLEAN_RETURN_NULL", justification = "Null is desired when not found.") Boolean getBoolean(String name); boolean isDuplicateEntry(JsonWrapper wrapper); boolean isMap(); boolean isList(); boolean isValue(); boolean isMetadata(); boolean hasMetadata(); Stream<JsonWrapper> stream(); @Override String toString(); String toStringWithMetadata(); Object toObject(); Object stripWrapper(Object value); Source toSource(); JsonWrapper getMetadata(); JsonWrapper addMetadata(JsonWrapper newMetadata); JsonWrapper putMetadata(String name, String value); int size(); JsonWrapper getByJsonPath(String jsonPath); JsonWrapper get(JsonPath jsonPath); JsonWrapper get(String name); JsonWrapper get(int index); static final String METADATA_HOLDER; static final String ENCODING_KEY; static final ObjectMapper jsonMapper; }
@Test void testToString_floatParseExcpetion() { assertThrows(EncodeException.class, () -> objectStrWrapper.putFloat("nope")); } @Test void testToString_floatParseExcpetion2() { assertThrows(EncodeException.class, () -> objectStrWrapper.putFloat("name","nope")); } @Test void putFloat() { JsonWrapper wrap = new JsonWrapper().put("float",1.1f); assertWithMessage("Should return entered float") .that(wrap.getFloat("float")) .isEqualTo(1.1f); wrap = new JsonWrapper().put(1.1f); assertWithMessage("Should return entered float") .that(wrap.get(0).toObject()) .isEqualTo("1.1"); }
JsonWrapper { public JsonWrapper putBoolean(String name, String value) { try { put(name, Boolean.toString(validBoolean(value)), Type.BOOLEAN); } catch (EncodeException e) { put(name, value, Type.BOOLEAN); throw e; } return this; } JsonWrapper(); JsonWrapper(Kind kind); JsonWrapper(String value); JsonWrapper(Boolean value); JsonWrapper(Integer value); JsonWrapper(Float value); JsonWrapper(JsonWrapper wrapper); private JsonWrapper(JsonWrapper wrapper, boolean withMetadata); Type getType(); boolean isType(Type type); Kind getKind(); boolean isKind(Kind kind); String getKey(); JsonWrapper copyWithoutMetadata(); JsonWrapper clear(); JsonWrapper put(String name, String value); JsonWrapper put(String name, Integer value); JsonWrapper put(String name, Float value); JsonWrapper put(String name, Boolean value); JsonWrapper put(String value); JsonWrapper put(Integer value); JsonWrapper put(Float value); JsonWrapper put(Boolean value); JsonWrapper put(JsonWrapper value); JsonWrapper put(String name, JsonWrapper value); JsonWrapper putDate(String name, String value); JsonWrapper putDate(String value); JsonWrapper putInteger(String name, String value); JsonWrapper putInteger(String value); JsonWrapper putFloat(String name, String value); JsonWrapper putFloat(String value); JsonWrapper putBoolean(String name, String value); JsonWrapper putBoolean(String value); JsonWrapper remove(String name); String getString(String name); Integer getInteger(String name); Float getFloat(String name); @SuppressFBWarnings(value = "NP_BOOLEAN_RETURN_NULL", justification = "Null is desired when not found.") Boolean getBoolean(String name); boolean isDuplicateEntry(JsonWrapper wrapper); boolean isMap(); boolean isList(); boolean isValue(); boolean isMetadata(); boolean hasMetadata(); Stream<JsonWrapper> stream(); @Override String toString(); String toStringWithMetadata(); Object toObject(); Object stripWrapper(Object value); Source toSource(); JsonWrapper getMetadata(); JsonWrapper addMetadata(JsonWrapper newMetadata); JsonWrapper putMetadata(String name, String value); int size(); JsonWrapper getByJsonPath(String jsonPath); JsonWrapper get(JsonPath jsonPath); JsonWrapper get(String name); JsonWrapper get(int index); static final String METADATA_HOLDER; static final String ENCODING_KEY; static final ObjectMapper jsonMapper; }
@Test void testToString_booleanParseExcpetion() { assertThrows(EncodeException.class, () -> objectStrWrapper.putBoolean("nope")); } @Test void testToString_booleanParseExcpetion2() { assertThrows(EncodeException.class, () -> objectStrWrapper.putBoolean("name","nope")); } @Test void putBoolean() { JsonWrapper wrap = new JsonWrapper().put("bool", true); assertWithMessage("Should return entered boolean") .that(wrap.getBoolean("bool")) .isEqualTo(true); wrap = new JsonWrapper().put(true); assertWithMessage("Should return entered boolean") .that(wrap.get(0).toObject()) .isEqualTo("true"); }
JsonWrapper { protected boolean validBoolean(String value) { String cleanValue = FormatHelper.cleanString(value); if ("true".equals(cleanValue) || "yes".equals(cleanValue) || "y".equals(cleanValue)) { return true; } if ("false".equals(cleanValue) || "no".equals(cleanValue) || "n".equals(cleanValue)) { return false; } throw new EncodeException(cleanValue + " is not a boolean."); } JsonWrapper(); JsonWrapper(Kind kind); JsonWrapper(String value); JsonWrapper(Boolean value); JsonWrapper(Integer value); JsonWrapper(Float value); JsonWrapper(JsonWrapper wrapper); private JsonWrapper(JsonWrapper wrapper, boolean withMetadata); Type getType(); boolean isType(Type type); Kind getKind(); boolean isKind(Kind kind); String getKey(); JsonWrapper copyWithoutMetadata(); JsonWrapper clear(); JsonWrapper put(String name, String value); JsonWrapper put(String name, Integer value); JsonWrapper put(String name, Float value); JsonWrapper put(String name, Boolean value); JsonWrapper put(String value); JsonWrapper put(Integer value); JsonWrapper put(Float value); JsonWrapper put(Boolean value); JsonWrapper put(JsonWrapper value); JsonWrapper put(String name, JsonWrapper value); JsonWrapper putDate(String name, String value); JsonWrapper putDate(String value); JsonWrapper putInteger(String name, String value); JsonWrapper putInteger(String value); JsonWrapper putFloat(String name, String value); JsonWrapper putFloat(String value); JsonWrapper putBoolean(String name, String value); JsonWrapper putBoolean(String value); JsonWrapper remove(String name); String getString(String name); Integer getInteger(String name); Float getFloat(String name); @SuppressFBWarnings(value = "NP_BOOLEAN_RETURN_NULL", justification = "Null is desired when not found.") Boolean getBoolean(String name); boolean isDuplicateEntry(JsonWrapper wrapper); boolean isMap(); boolean isList(); boolean isValue(); boolean isMetadata(); boolean hasMetadata(); Stream<JsonWrapper> stream(); @Override String toString(); String toStringWithMetadata(); Object toObject(); Object stripWrapper(Object value); Source toSource(); JsonWrapper getMetadata(); JsonWrapper addMetadata(JsonWrapper newMetadata); JsonWrapper putMetadata(String name, String value); int size(); JsonWrapper getByJsonPath(String jsonPath); JsonWrapper get(JsonPath jsonPath); JsonWrapper get(String name); JsonWrapper get(int index); static final String METADATA_HOLDER; static final String ENCODING_KEY; static final ObjectMapper jsonMapper; }
@Test void testValidBoolean() throws Exception { assertThat(objectStrWrapper.validBoolean("True")).isTrue(); assertThat(objectStrWrapper.validBoolean("Yes")).isTrue(); assertThat(objectStrWrapper.validBoolean("Y")).isTrue(); assertThat(objectStrWrapper.validBoolean("false")).isFalse(); assertThat(objectStrWrapper.validBoolean("no")).isFalse(); assertThat(objectStrWrapper.validBoolean("N")).isFalse(); }
JsonWrapper { public Stream<JsonWrapper> stream() { Stream<JsonWrapper> stream; if (isValue() && value != null) { stream = Stream.of(this); } else if (isList()) { stream = childrenList.stream(); } else { stream = childrenMap.entrySet() .stream() .map(entry -> { return entry.getValue(); }); } return stream; } JsonWrapper(); JsonWrapper(Kind kind); JsonWrapper(String value); JsonWrapper(Boolean value); JsonWrapper(Integer value); JsonWrapper(Float value); JsonWrapper(JsonWrapper wrapper); private JsonWrapper(JsonWrapper wrapper, boolean withMetadata); Type getType(); boolean isType(Type type); Kind getKind(); boolean isKind(Kind kind); String getKey(); JsonWrapper copyWithoutMetadata(); JsonWrapper clear(); JsonWrapper put(String name, String value); JsonWrapper put(String name, Integer value); JsonWrapper put(String name, Float value); JsonWrapper put(String name, Boolean value); JsonWrapper put(String value); JsonWrapper put(Integer value); JsonWrapper put(Float value); JsonWrapper put(Boolean value); JsonWrapper put(JsonWrapper value); JsonWrapper put(String name, JsonWrapper value); JsonWrapper putDate(String name, String value); JsonWrapper putDate(String value); JsonWrapper putInteger(String name, String value); JsonWrapper putInteger(String value); JsonWrapper putFloat(String name, String value); JsonWrapper putFloat(String value); JsonWrapper putBoolean(String name, String value); JsonWrapper putBoolean(String value); JsonWrapper remove(String name); String getString(String name); Integer getInteger(String name); Float getFloat(String name); @SuppressFBWarnings(value = "NP_BOOLEAN_RETURN_NULL", justification = "Null is desired when not found.") Boolean getBoolean(String name); boolean isDuplicateEntry(JsonWrapper wrapper); boolean isMap(); boolean isList(); boolean isValue(); boolean isMetadata(); boolean hasMetadata(); Stream<JsonWrapper> stream(); @Override String toString(); String toStringWithMetadata(); Object toObject(); Object stripWrapper(Object value); Source toSource(); JsonWrapper getMetadata(); JsonWrapper addMetadata(JsonWrapper newMetadata); JsonWrapper putMetadata(String name, String value); int size(); JsonWrapper getByJsonPath(String jsonPath); JsonWrapper get(JsonPath jsonPath); JsonWrapper get(String name); JsonWrapper get(int index); static final String METADATA_HOLDER; static final String ENCODING_KEY; static final ObjectMapper jsonMapper; }
@Test void testValueStream_count() { listStrWrapper = new JsonWrapper("value"); assertThat(listStrWrapper.stream().count()).isEqualTo(1); }
StorageServiceImpl extends AnyOrderActionService<Supplier<PutObjectRequest>, String> implements StorageService { @Override public InputStream getCpcPlusValidationFile() { String bucketName = environment.getProperty(Constants.CPC_PLUS_BUCKET_NAME_VARIABLE); String key = environment.getProperty(Constants.CPC_PLUS_FILENAME_VARIABLE); if (StringUtils.isEmpty(bucketName) || StringUtils.isEmpty(key)) { API_LOG.warn("No CPC+ bucket name and/or CPC+ key specified"); return null; } API_LOG.info("Retrieving CPC+ validation file from bucket {}", bucketName); GetObjectRequest getObjectRequest = new GetObjectRequest(bucketName, key); S3Object s3Object = amazonS3.getObject(getObjectRequest); return s3Object.getObjectContent(); } StorageServiceImpl(TaskExecutor taskExecutor, TransferManager s3TransferManager, Environment environment, AmazonS3 amazonS3); @Override CompletableFuture<String> store(String keyName, Supplier<InputStream> inStream, long size); @Override InputStream getFileByLocationId(String fileLocationId); @Override InputStream getCpcPlusValidationFile(); @Override InputStream getApmValidationFile(); }
@Test void test_getCpcPlusValidationFile_noBucket() { Mockito.when(environment.getProperty(Constants.CPC_PLUS_BUCKET_NAME_VARIABLE)).thenReturn(null); InputStream ins = underTest.getCpcPlusValidationFile(); assertThat(ins).isNull(); Mockito.when(environment.getProperty(Constants.CPC_PLUS_BUCKET_NAME_VARIABLE)).thenReturn(""); ins = underTest.getCpcPlusValidationFile(); assertThat(ins).isNull(); Mockito.when(environment.getProperty(Constants.CPC_PLUS_BUCKET_NAME_VARIABLE)).thenReturn(" "); ins = underTest.getCpcPlusValidationFile(); assertThat(ins).isNull(); } @Test void test_getCpcPlusValidationFile_noFileKey() { Mockito.when(environment.getProperty(Constants.CPC_PLUS_BUCKET_NAME_VARIABLE)).thenReturn("Mock_Bucket"); Mockito.when(environment.getProperty(Constants.CPC_PLUS_FILENAME_VARIABLE)).thenReturn(null); InputStream ins = underTest.getCpcPlusValidationFile(); assertThat(ins).isNull(); Mockito.when(environment.getProperty(Constants.CPC_PLUS_FILENAME_VARIABLE)).thenReturn(""); ins = underTest.getCpcPlusValidationFile(); assertThat(ins).isNull(); } @Test void test_getCpcPlusValidationFile() { S3ObjectInputStream expected = new S3ObjectInputStream(null, null); S3Object mockS3Obj = mock(S3Object.class); Mockito.when(mockS3Obj.getObjectContent()).thenReturn(expected); Mockito.when(environment.getProperty(Constants.CPC_PLUS_BUCKET_NAME_VARIABLE)).thenReturn("Mock_Bucket"); Mockito.when(environment.getProperty(Constants.CPC_PLUS_FILENAME_VARIABLE)).thenReturn("Mock_Filename"); Mockito.when(amazonS3Client.getObject( any(GetObjectRequest.class) )).thenReturn(mockS3Obj); InputStream actual = underTest.getCpcPlusValidationFile(); assertThat(actual).isEqualTo(expected); }
JsonWrapper { protected boolean checkState(JsonWrapper wrapper) { if (wrapper == null) { return false; } try { isDuplicateEntry(wrapper); } catch (Exception e) { return false; } if (wrapper.value == null && wrapper.isKind(Kind.VALUE)) { return false; } else if (wrapper.isType(Type.UNKNOWN)) { return false; } else if (wrapper.isKind(Kind.METADATA) && this.isKind(Kind.METADATA)) { return wrapper.size() > 0; } return true; } JsonWrapper(); JsonWrapper(Kind kind); JsonWrapper(String value); JsonWrapper(Boolean value); JsonWrapper(Integer value); JsonWrapper(Float value); JsonWrapper(JsonWrapper wrapper); private JsonWrapper(JsonWrapper wrapper, boolean withMetadata); Type getType(); boolean isType(Type type); Kind getKind(); boolean isKind(Kind kind); String getKey(); JsonWrapper copyWithoutMetadata(); JsonWrapper clear(); JsonWrapper put(String name, String value); JsonWrapper put(String name, Integer value); JsonWrapper put(String name, Float value); JsonWrapper put(String name, Boolean value); JsonWrapper put(String value); JsonWrapper put(Integer value); JsonWrapper put(Float value); JsonWrapper put(Boolean value); JsonWrapper put(JsonWrapper value); JsonWrapper put(String name, JsonWrapper value); JsonWrapper putDate(String name, String value); JsonWrapper putDate(String value); JsonWrapper putInteger(String name, String value); JsonWrapper putInteger(String value); JsonWrapper putFloat(String name, String value); JsonWrapper putFloat(String value); JsonWrapper putBoolean(String name, String value); JsonWrapper putBoolean(String value); JsonWrapper remove(String name); String getString(String name); Integer getInteger(String name); Float getFloat(String name); @SuppressFBWarnings(value = "NP_BOOLEAN_RETURN_NULL", justification = "Null is desired when not found.") Boolean getBoolean(String name); boolean isDuplicateEntry(JsonWrapper wrapper); boolean isMap(); boolean isList(); boolean isValue(); boolean isMetadata(); boolean hasMetadata(); Stream<JsonWrapper> stream(); @Override String toString(); String toStringWithMetadata(); Object toObject(); Object stripWrapper(Object value); Source toSource(); JsonWrapper getMetadata(); JsonWrapper addMetadata(JsonWrapper newMetadata); JsonWrapper putMetadata(String name, String value); int size(); JsonWrapper getByJsonPath(String jsonPath); JsonWrapper get(JsonPath jsonPath); JsonWrapper get(String name); JsonWrapper get(int index); static final String METADATA_HOLDER; static final String ENCODING_KEY; static final ObjectMapper jsonMapper; }
@Test void checkState_value() { JsonWrapper wrapper = new JsonWrapper(); JsonWrapper child = new JsonWrapper("value"); boolean actual = wrapper.checkState(child); assertWithMessage("checkState should accept the child that has value") .that(actual).isTrue(); } @Test void checkState_nullValue() { JsonWrapper wrapper = new JsonWrapper(); JsonWrapper child = new JsonWrapper(); boolean actual = wrapper.checkState(child); assertWithMessage("checkState should not accept the child that has no value") .that(actual).isFalse(); } @Test void checkState_nullInstance() { JsonWrapper wrapper = new JsonWrapper(); boolean actual = wrapper.checkState(null); assertWithMessage("checkState should not accept the child that has null wrapper") .that(actual).isFalse(); } @Test void checkState_addSelf() { JsonWrapper wrapper = new JsonWrapper(); boolean actual = wrapper.checkState(wrapper); assertWithMessage("Expected warning when checking state of adding self instance to a wrapper.") .that(actual).isFalse(); } @Test void checkState_addMetadata_empty() { JsonWrapper wrapper = new JsonWrapper(); JsonWrapper metadata = new JsonWrapper(Kind.METADATA); boolean actual = wrapper.checkState(metadata); assertWithMessage("checkState should not accept empty metadata") .that(actual).isFalse(); } @Test void checkState_addUnknown() { JsonWrapper wrapper = new JsonWrapper(); JsonWrapper unknown = new JsonWrapper(Kind.CONTAINER); boolean actual = wrapper.checkState(unknown); assertWithMessage("checkState should not accept unknown wrappers") .that(actual).isFalse(); }
JsonWrapper { public Kind getKind() { return kind; } JsonWrapper(); JsonWrapper(Kind kind); JsonWrapper(String value); JsonWrapper(Boolean value); JsonWrapper(Integer value); JsonWrapper(Float value); JsonWrapper(JsonWrapper wrapper); private JsonWrapper(JsonWrapper wrapper, boolean withMetadata); Type getType(); boolean isType(Type type); Kind getKind(); boolean isKind(Kind kind); String getKey(); JsonWrapper copyWithoutMetadata(); JsonWrapper clear(); JsonWrapper put(String name, String value); JsonWrapper put(String name, Integer value); JsonWrapper put(String name, Float value); JsonWrapper put(String name, Boolean value); JsonWrapper put(String value); JsonWrapper put(Integer value); JsonWrapper put(Float value); JsonWrapper put(Boolean value); JsonWrapper put(JsonWrapper value); JsonWrapper put(String name, JsonWrapper value); JsonWrapper putDate(String name, String value); JsonWrapper putDate(String value); JsonWrapper putInteger(String name, String value); JsonWrapper putInteger(String value); JsonWrapper putFloat(String name, String value); JsonWrapper putFloat(String value); JsonWrapper putBoolean(String name, String value); JsonWrapper putBoolean(String value); JsonWrapper remove(String name); String getString(String name); Integer getInteger(String name); Float getFloat(String name); @SuppressFBWarnings(value = "NP_BOOLEAN_RETURN_NULL", justification = "Null is desired when not found.") Boolean getBoolean(String name); boolean isDuplicateEntry(JsonWrapper wrapper); boolean isMap(); boolean isList(); boolean isValue(); boolean isMetadata(); boolean hasMetadata(); Stream<JsonWrapper> stream(); @Override String toString(); String toStringWithMetadata(); Object toObject(); Object stripWrapper(Object value); Source toSource(); JsonWrapper getMetadata(); JsonWrapper addMetadata(JsonWrapper newMetadata); JsonWrapper putMetadata(String name, String value); int size(); JsonWrapper getByJsonPath(String jsonPath); JsonWrapper get(JsonPath jsonPath); JsonWrapper get(String name); JsonWrapper get(int index); static final String METADATA_HOLDER; static final String ENCODING_KEY; static final ObjectMapper jsonMapper; }
@Test void getKind() throws Exception { assertWithMessage("getKind should return the wrapper Kind") .that(new JsonWrapper().getKind()) .isEqualTo(Kind.CONTAINER); }
JsonWrapper { public String toStringWithMetadata() { try { return withMetadataWriter.writeValueAsString(this); } catch (JsonProcessingException e) { throw new EncodeException("Issue rendering JSON from JsonWrapper Map", e); } } JsonWrapper(); JsonWrapper(Kind kind); JsonWrapper(String value); JsonWrapper(Boolean value); JsonWrapper(Integer value); JsonWrapper(Float value); JsonWrapper(JsonWrapper wrapper); private JsonWrapper(JsonWrapper wrapper, boolean withMetadata); Type getType(); boolean isType(Type type); Kind getKind(); boolean isKind(Kind kind); String getKey(); JsonWrapper copyWithoutMetadata(); JsonWrapper clear(); JsonWrapper put(String name, String value); JsonWrapper put(String name, Integer value); JsonWrapper put(String name, Float value); JsonWrapper put(String name, Boolean value); JsonWrapper put(String value); JsonWrapper put(Integer value); JsonWrapper put(Float value); JsonWrapper put(Boolean value); JsonWrapper put(JsonWrapper value); JsonWrapper put(String name, JsonWrapper value); JsonWrapper putDate(String name, String value); JsonWrapper putDate(String value); JsonWrapper putInteger(String name, String value); JsonWrapper putInteger(String value); JsonWrapper putFloat(String name, String value); JsonWrapper putFloat(String value); JsonWrapper putBoolean(String name, String value); JsonWrapper putBoolean(String value); JsonWrapper remove(String name); String getString(String name); Integer getInteger(String name); Float getFloat(String name); @SuppressFBWarnings(value = "NP_BOOLEAN_RETURN_NULL", justification = "Null is desired when not found.") Boolean getBoolean(String name); boolean isDuplicateEntry(JsonWrapper wrapper); boolean isMap(); boolean isList(); boolean isValue(); boolean isMetadata(); boolean hasMetadata(); Stream<JsonWrapper> stream(); @Override String toString(); String toStringWithMetadata(); Object toObject(); Object stripWrapper(Object value); Source toSource(); JsonWrapper getMetadata(); JsonWrapper addMetadata(JsonWrapper newMetadata); JsonWrapper putMetadata(String name, String value); int size(); JsonWrapper getByJsonPath(String jsonPath); JsonWrapper get(JsonPath jsonPath); JsonWrapper get(String name); JsonWrapper get(int index); static final String METADATA_HOLDER; static final String ENCODING_KEY; static final ObjectMapper jsonMapper; }
@Test void toStringWithMetadata() throws Exception { JsonWrapper map = new JsonWrapper().put("name", "value"); map.putMetadata("meta", "data"); String json = map.toStringWithMetadata(); String expect = "{\n \"metadata_holder\" : {\n \"meta\" : \"data\"\n },\n \"name\" : \"value\"\n}"; assertWithMessage("expect a simple object of JSON") .that(json) .isEqualTo(expect); }
JsonWrapper { public Object stripWrapper(Object value) { Object internalValue = value; if (value instanceof JsonWrapper) { JsonWrapper wrapper = (JsonWrapper) value; internalValue = wrapper.toObject(); } return internalValue; } JsonWrapper(); JsonWrapper(Kind kind); JsonWrapper(String value); JsonWrapper(Boolean value); JsonWrapper(Integer value); JsonWrapper(Float value); JsonWrapper(JsonWrapper wrapper); private JsonWrapper(JsonWrapper wrapper, boolean withMetadata); Type getType(); boolean isType(Type type); Kind getKind(); boolean isKind(Kind kind); String getKey(); JsonWrapper copyWithoutMetadata(); JsonWrapper clear(); JsonWrapper put(String name, String value); JsonWrapper put(String name, Integer value); JsonWrapper put(String name, Float value); JsonWrapper put(String name, Boolean value); JsonWrapper put(String value); JsonWrapper put(Integer value); JsonWrapper put(Float value); JsonWrapper put(Boolean value); JsonWrapper put(JsonWrapper value); JsonWrapper put(String name, JsonWrapper value); JsonWrapper putDate(String name, String value); JsonWrapper putDate(String value); JsonWrapper putInteger(String name, String value); JsonWrapper putInteger(String value); JsonWrapper putFloat(String name, String value); JsonWrapper putFloat(String value); JsonWrapper putBoolean(String name, String value); JsonWrapper putBoolean(String value); JsonWrapper remove(String name); String getString(String name); Integer getInteger(String name); Float getFloat(String name); @SuppressFBWarnings(value = "NP_BOOLEAN_RETURN_NULL", justification = "Null is desired when not found.") Boolean getBoolean(String name); boolean isDuplicateEntry(JsonWrapper wrapper); boolean isMap(); boolean isList(); boolean isValue(); boolean isMetadata(); boolean hasMetadata(); Stream<JsonWrapper> stream(); @Override String toString(); String toStringWithMetadata(); Object toObject(); Object stripWrapper(Object value); Source toSource(); JsonWrapper getMetadata(); JsonWrapper addMetadata(JsonWrapper newMetadata); JsonWrapper putMetadata(String name, String value); int size(); JsonWrapper getByJsonPath(String jsonPath); JsonWrapper get(JsonPath jsonPath); JsonWrapper get(String name); JsonWrapper get(int index); static final String METADATA_HOLDER; static final String ENCODING_KEY; static final ObjectMapper jsonMapper; }
@Test void stripWrapper_nonWrapper() { String internal = "value"; Object actual = new JsonWrapper().stripWrapper(internal); assertWithMessage("Internal Value of a nonWrapper is self") .that(actual) .isEqualTo(internal); }
JsonWrapper { public JsonWrapper addMetadata(JsonWrapper newMetadata) { if (newMetadata != null) { JsonWrapper localMetadata = getMetadata(); if (localMetadata.isMap()) { JsonWrapper wrappedMetadata = new JsonWrapper(localMetadata); localMetadata.clear(); localMetadata.put(wrappedMetadata); } localMetadata.put(newMetadata.getMetadata()); } return this; } JsonWrapper(); JsonWrapper(Kind kind); JsonWrapper(String value); JsonWrapper(Boolean value); JsonWrapper(Integer value); JsonWrapper(Float value); JsonWrapper(JsonWrapper wrapper); private JsonWrapper(JsonWrapper wrapper, boolean withMetadata); Type getType(); boolean isType(Type type); Kind getKind(); boolean isKind(Kind kind); String getKey(); JsonWrapper copyWithoutMetadata(); JsonWrapper clear(); JsonWrapper put(String name, String value); JsonWrapper put(String name, Integer value); JsonWrapper put(String name, Float value); JsonWrapper put(String name, Boolean value); JsonWrapper put(String value); JsonWrapper put(Integer value); JsonWrapper put(Float value); JsonWrapper put(Boolean value); JsonWrapper put(JsonWrapper value); JsonWrapper put(String name, JsonWrapper value); JsonWrapper putDate(String name, String value); JsonWrapper putDate(String value); JsonWrapper putInteger(String name, String value); JsonWrapper putInteger(String value); JsonWrapper putFloat(String name, String value); JsonWrapper putFloat(String value); JsonWrapper putBoolean(String name, String value); JsonWrapper putBoolean(String value); JsonWrapper remove(String name); String getString(String name); Integer getInteger(String name); Float getFloat(String name); @SuppressFBWarnings(value = "NP_BOOLEAN_RETURN_NULL", justification = "Null is desired when not found.") Boolean getBoolean(String name); boolean isDuplicateEntry(JsonWrapper wrapper); boolean isMap(); boolean isList(); boolean isValue(); boolean isMetadata(); boolean hasMetadata(); Stream<JsonWrapper> stream(); @Override String toString(); String toStringWithMetadata(); Object toObject(); Object stripWrapper(Object value); Source toSource(); JsonWrapper getMetadata(); JsonWrapper addMetadata(JsonWrapper newMetadata); JsonWrapper putMetadata(String name, String value); int size(); JsonWrapper getByJsonPath(String jsonPath); JsonWrapper get(JsonPath jsonPath); JsonWrapper get(String name); JsonWrapper get(int index); static final String METADATA_HOLDER; static final String ENCODING_KEY; static final ObjectMapper jsonMapper; }
@Test void addMetadata() { JsonWrapper data = new JsonWrapper().put("name", "value").putMetadata("meta1", "data1"); JsonWrapper metadata = new JsonWrapper().putMetadata("meta2", "data2"); assertWithMessage("expect metadata size to be 1") .that(data.getMetadata().size()).isEqualTo(1); data.addMetadata(metadata); assertWithMessage("expect metadata size to be 2") .that(data.getMetadata().size()).isEqualTo(2); }
JsonWrapper { void mergeMetadata(JsonWrapper otherWrapper, String encodeLabel) { JsonWrapper metadata = otherWrapper.getMetadata(); if (metadata.isList()) { metadata.stream().forEach(other -> { other.put(ENCODING_KEY, encodeLabel); addMetadata(other); }); } else { metadata.put(ENCODING_KEY, encodeLabel); addMetadata(metadata); } } JsonWrapper(); JsonWrapper(Kind kind); JsonWrapper(String value); JsonWrapper(Boolean value); JsonWrapper(Integer value); JsonWrapper(Float value); JsonWrapper(JsonWrapper wrapper); private JsonWrapper(JsonWrapper wrapper, boolean withMetadata); Type getType(); boolean isType(Type type); Kind getKind(); boolean isKind(Kind kind); String getKey(); JsonWrapper copyWithoutMetadata(); JsonWrapper clear(); JsonWrapper put(String name, String value); JsonWrapper put(String name, Integer value); JsonWrapper put(String name, Float value); JsonWrapper put(String name, Boolean value); JsonWrapper put(String value); JsonWrapper put(Integer value); JsonWrapper put(Float value); JsonWrapper put(Boolean value); JsonWrapper put(JsonWrapper value); JsonWrapper put(String name, JsonWrapper value); JsonWrapper putDate(String name, String value); JsonWrapper putDate(String value); JsonWrapper putInteger(String name, String value); JsonWrapper putInteger(String value); JsonWrapper putFloat(String name, String value); JsonWrapper putFloat(String value); JsonWrapper putBoolean(String name, String value); JsonWrapper putBoolean(String value); JsonWrapper remove(String name); String getString(String name); Integer getInteger(String name); Float getFloat(String name); @SuppressFBWarnings(value = "NP_BOOLEAN_RETURN_NULL", justification = "Null is desired when not found.") Boolean getBoolean(String name); boolean isDuplicateEntry(JsonWrapper wrapper); boolean isMap(); boolean isList(); boolean isValue(); boolean isMetadata(); boolean hasMetadata(); Stream<JsonWrapper> stream(); @Override String toString(); String toStringWithMetadata(); Object toObject(); Object stripWrapper(Object value); Source toSource(); JsonWrapper getMetadata(); JsonWrapper addMetadata(JsonWrapper newMetadata); JsonWrapper putMetadata(String name, String value); int size(); JsonWrapper getByJsonPath(String jsonPath); JsonWrapper get(JsonPath jsonPath); JsonWrapper get(String name); JsonWrapper get(int index); static final String METADATA_HOLDER; static final String ENCODING_KEY; static final ObjectMapper jsonMapper; }
@Test void mergeMetadata() { JsonWrapper data = new JsonWrapper().put("name", "value").putMetadata("meta1", "data1"); JsonWrapper metadata = new JsonWrapper().putMetadata("meta2", "data2"); assertWithMessage("expect metadata size to be 1") .that(data.getMetadata().size()).isEqualTo(1); data.mergeMetadata(metadata, "merge label"); int mergeSize = data.getMetadata().size(); assertWithMessage("expect metadata size to be 2") .that(mergeSize).isEqualTo(2); String mergeLabel = data.getMetadata().get(1).getString(JsonWrapper.ENCODING_KEY); assertWithMessage("expect encodeLabel to be set") .that(mergeLabel).isEqualTo("merge label"); }
JsonWrapper { public int size() { if (isType(Type.UNKNOWN)) { return 0; } if (isValue()) { return (value == null) ? 0 : 1; } if (isList()) { return childrenList.size(); } return childrenMap.size(); } JsonWrapper(); JsonWrapper(Kind kind); JsonWrapper(String value); JsonWrapper(Boolean value); JsonWrapper(Integer value); JsonWrapper(Float value); JsonWrapper(JsonWrapper wrapper); private JsonWrapper(JsonWrapper wrapper, boolean withMetadata); Type getType(); boolean isType(Type type); Kind getKind(); boolean isKind(Kind kind); String getKey(); JsonWrapper copyWithoutMetadata(); JsonWrapper clear(); JsonWrapper put(String name, String value); JsonWrapper put(String name, Integer value); JsonWrapper put(String name, Float value); JsonWrapper put(String name, Boolean value); JsonWrapper put(String value); JsonWrapper put(Integer value); JsonWrapper put(Float value); JsonWrapper put(Boolean value); JsonWrapper put(JsonWrapper value); JsonWrapper put(String name, JsonWrapper value); JsonWrapper putDate(String name, String value); JsonWrapper putDate(String value); JsonWrapper putInteger(String name, String value); JsonWrapper putInteger(String value); JsonWrapper putFloat(String name, String value); JsonWrapper putFloat(String value); JsonWrapper putBoolean(String name, String value); JsonWrapper putBoolean(String value); JsonWrapper remove(String name); String getString(String name); Integer getInteger(String name); Float getFloat(String name); @SuppressFBWarnings(value = "NP_BOOLEAN_RETURN_NULL", justification = "Null is desired when not found.") Boolean getBoolean(String name); boolean isDuplicateEntry(JsonWrapper wrapper); boolean isMap(); boolean isList(); boolean isValue(); boolean isMetadata(); boolean hasMetadata(); Stream<JsonWrapper> stream(); @Override String toString(); String toStringWithMetadata(); Object toObject(); Object stripWrapper(Object value); Source toSource(); JsonWrapper getMetadata(); JsonWrapper addMetadata(JsonWrapper newMetadata); JsonWrapper putMetadata(String name, String value); int size(); JsonWrapper getByJsonPath(String jsonPath); JsonWrapper get(JsonPath jsonPath); JsonWrapper get(String name); JsonWrapper get(int index); static final String METADATA_HOLDER; static final String ENCODING_KEY; static final ObjectMapper jsonMapper; }
@Test void size() { JsonWrapper nullValue = new JsonWrapper((String)null); JsonWrapper value = new JsonWrapper("value"); JsonWrapper map = new JsonWrapper().put("name", "value").put("name1", "value1"); JsonWrapper list = new JsonWrapper().put("value1").put("value2").put("value3"); assertWithMessage("expect metadata size to be 0") .that(nullValue.size()).isEqualTo(0); assertWithMessage("expect metadata size to be 1") .that(value.size()).isEqualTo(1); assertWithMessage("expect metadata size to be 2") .that(map.size()).isEqualTo(2); assertWithMessage("expect metadata size to be 3") .that(list.size()).isEqualTo(3); }
JsonWrapper { public JsonWrapper get(JsonPath jsonPath) { if (jsonPath == null) { return null; } if (!jsonPath.isDefinite()) { throw new UnsupportedOperationException("Only definite paths are supported at this time."); } return getByJsonPath(jsonPath.getPath()); } JsonWrapper(); JsonWrapper(Kind kind); JsonWrapper(String value); JsonWrapper(Boolean value); JsonWrapper(Integer value); JsonWrapper(Float value); JsonWrapper(JsonWrapper wrapper); private JsonWrapper(JsonWrapper wrapper, boolean withMetadata); Type getType(); boolean isType(Type type); Kind getKind(); boolean isKind(Kind kind); String getKey(); JsonWrapper copyWithoutMetadata(); JsonWrapper clear(); JsonWrapper put(String name, String value); JsonWrapper put(String name, Integer value); JsonWrapper put(String name, Float value); JsonWrapper put(String name, Boolean value); JsonWrapper put(String value); JsonWrapper put(Integer value); JsonWrapper put(Float value); JsonWrapper put(Boolean value); JsonWrapper put(JsonWrapper value); JsonWrapper put(String name, JsonWrapper value); JsonWrapper putDate(String name, String value); JsonWrapper putDate(String value); JsonWrapper putInteger(String name, String value); JsonWrapper putInteger(String value); JsonWrapper putFloat(String name, String value); JsonWrapper putFloat(String value); JsonWrapper putBoolean(String name, String value); JsonWrapper putBoolean(String value); JsonWrapper remove(String name); String getString(String name); Integer getInteger(String name); Float getFloat(String name); @SuppressFBWarnings(value = "NP_BOOLEAN_RETURN_NULL", justification = "Null is desired when not found.") Boolean getBoolean(String name); boolean isDuplicateEntry(JsonWrapper wrapper); boolean isMap(); boolean isList(); boolean isValue(); boolean isMetadata(); boolean hasMetadata(); Stream<JsonWrapper> stream(); @Override String toString(); String toStringWithMetadata(); Object toObject(); Object stripWrapper(Object value); Source toSource(); JsonWrapper getMetadata(); JsonWrapper addMetadata(JsonWrapper newMetadata); JsonWrapper putMetadata(String name, String value); int size(); JsonWrapper getByJsonPath(String jsonPath); JsonWrapper get(JsonPath jsonPath); JsonWrapper get(String name); JsonWrapper get(int index); static final String METADATA_HOLDER; static final String ENCODING_KEY; static final ObjectMapper jsonMapper; }
@Test @SuppressWarnings("unchecked") void getByJsonPath_JsonPath() { String testPath = "$.a.b[0].c"; JsonPath jsonPath = JsonPath.compile(testPath); List<String>[] paths = new List[1]; JsonWrapper mockWrapper = new JsonWrapper() { @Override public JsonWrapper getByJsonPath(List<String> jsonPath) { paths[0] = jsonPath; return null; } }; mockWrapper.get(jsonPath); Truth.assertThat(paths[0].get(0)).isEqualTo("a"); Truth.assertThat(paths[0].get(1)).isEqualTo("b"); Truth.assertThat(paths[0].get(2)).isEqualTo("[0"); Truth.assertThat(paths[0].get(3)).isEqualTo("c"); } @Test void getByJsonPath_wildcard() { JsonWrapper actual = listStrWrapper.get((JsonPath)null); Truth.assertThat(actual).isNull(); Truth.assertThat( assertThrows(UnsupportedOperationException.class, ()->{ listStrWrapper.get(JsonPath.compile("$.a.b[*]")); }).getMessage() ) .contains("Only definite"); }
ReportingParametersActEncoder extends QppOutputEncoder { @Override protected void internalEncode(JsonWrapper wrapper, Node node) { encodeDate(wrapper, node, PERFORMANCE_START); encodeDate(wrapper, node, PERFORMANCE_END); } ReportingParametersActEncoder(Context context); static final String PERFORMANCE_START; static final String PERFORMANCE_END; }
@Test void internalEncode() throws Exception { Node reportingParametersActNode = new Node(TemplateId.REPORTING_PARAMETERS_ACT); reportingParametersActNode.putValue(ReportingParametersActEncoder.PERFORMANCE_START,"20170101"); reportingParametersActNode.putValue(ReportingParametersActEncoder.PERFORMANCE_END,"20171231"); JsonWrapper outputWrapper = new JsonWrapper(); ReportingParametersActEncoder encoder = new ReportingParametersActEncoder(new Context()); encoder.internalEncode(outputWrapper, reportingParametersActNode); String performanceStart = outputWrapper.getString(ReportingParametersActEncoder.PERFORMANCE_START); String performanceEnd = outputWrapper.getString(ReportingParametersActEncoder.PERFORMANCE_END); assertThat(performanceStart).isEqualTo("2017-01-01"); assertThat(performanceEnd).isEqualTo("2017-12-31"); } @Test void missingValuesTest() throws Exception { Node reportingParametersActNode = new Node(TemplateId.REPORTING_PARAMETERS_ACT); JsonWrapper outputWrapper = new JsonWrapper(); ReportingParametersActEncoder encoder = new ReportingParametersActEncoder(new Context()); encoder.internalEncode(outputWrapper, reportingParametersActNode); String performanceStart = outputWrapper.getString(ReportingParametersActEncoder.PERFORMANCE_START); String performanceEnd = outputWrapper.getString(ReportingParametersActEncoder.PERFORMANCE_END); assertThat(performanceStart).isNull(); assertThat(performanceEnd).isNull(); }
ClinicalDocumentEncoder extends QppOutputEncoder { @Override public void internalEncode(JsonWrapper wrapper, Node thisNode) { encodeToplevel(wrapper, thisNode); Map<TemplateId, Node> childMapByTemplateId = thisNode.getChildNodes().stream().collect( Collectors.toMap(Node::getType, Function.identity(), (v1, v2) -> v1, LinkedHashMap::new)); JsonWrapper measurementSets = encodeMeasurementSets(childMapByTemplateId, thisNode); wrapper.put(MEASUREMENT_SETS, measurementSets); } ClinicalDocumentEncoder(Context context); @Override void internalEncode(JsonWrapper wrapper, Node thisNode); }
@Test void testPerformanceYear() { JsonWrapper testJsonWrapper = new JsonWrapper(); ClinicalDocumentEncoder clinicalDocumentEncoder = new ClinicalDocumentEncoder(new Context()); clinicalDocumentEncoder.internalEncode(testJsonWrapper, clinicalDocumentNode); Object performanceYear = testJsonWrapper.getInteger(ReportingParametersActDecoder.PERFORMANCE_YEAR); assertThat(performanceYear).isEqualTo(2017); } @Test void testInternalEncode() throws EncodeException { JsonWrapper testJsonWrapper = new JsonWrapper(); ClinicalDocumentEncoder clinicalDocumentEncoder = new ClinicalDocumentEncoder(new Context()); clinicalDocumentEncoder.internalEncode(testJsonWrapper, clinicalDocumentNode); assertThat(testJsonWrapper.getString(ClinicalDocumentDecoder.ENTITY_TYPE)) .isEqualTo("individual"); assertThat(testJsonWrapper.getString(ClinicalDocumentDecoder.TAX_PAYER_IDENTIFICATION_NUMBER)) .isEqualTo("123456789"); assertThat(testJsonWrapper.getString(ClinicalDocumentDecoder.NATIONAL_PROVIDER_IDENTIFIER)) .isEqualTo("2567891421"); } @Test void testInternalEncodeWithoutMeasures() throws EncodeException { clinicalDocumentNode.getChildNodes().remove(aciSectionNode); JsonWrapper testJsonWrapper = new JsonWrapper(); ClinicalDocumentEncoder clinicalDocumentEncoder = new ClinicalDocumentEncoder(new Context()); clinicalDocumentEncoder.internalEncode(testJsonWrapper, clinicalDocumentNode); Map<?, ?> clinicalDocMap = ((Map<?, ?>) testJsonWrapper.toObject()); assertThat(clinicalDocMap.get(MEASUREMENT_SETS)) .isNull(); } @Test void testInternalEncodeEmptyEntityId() throws EncodeException { clinicalDocumentNode.getChildNodes().remove(aciSectionNode); clinicalDocumentNode.putValue(ClinicalDocumentDecoder.PRACTICE_ID,""); JsonWrapper testJsonWrapper = new JsonWrapper(); ClinicalDocumentEncoder clinicalDocumentEncoder = new ClinicalDocumentEncoder(new Context()); clinicalDocumentEncoder.internalEncode(testJsonWrapper, clinicalDocumentNode); Map<?, ?> clinicalDocMap = ((Map<?, ?>) testJsonWrapper.toObject()); assertThat(clinicalDocMap.get(ClinicalDocumentDecoder.PRACTICE_ID)) .isNull(); } @Test void testInternalEncodeNullEntityId() throws EncodeException { clinicalDocumentNode.getChildNodes().remove(aciSectionNode); clinicalDocumentNode.putValue(ClinicalDocumentDecoder.PRACTICE_ID,null); JsonWrapper testJsonWrapper = new JsonWrapper(); ClinicalDocumentEncoder clinicalDocumentEncoder = new ClinicalDocumentEncoder(new Context()); clinicalDocumentEncoder.internalEncode(testJsonWrapper, clinicalDocumentNode); Map<?, ?> clinicalDocMap = ((Map<?, ?>) testJsonWrapper.toObject()); assertThat(clinicalDocMap.get(ClinicalDocumentDecoder.PRACTICE_ID)) .isNull(); } @Test void testClinicalDocumentEncoderIgnoresInvalidMeasurementSection() { Node reportingParamNode = new Node(TemplateId.REPORTING_PARAMETERS_ACT, clinicalDocumentNode); reportingParamNode.putValue(ReportingParametersActEncoder.PERFORMANCE_START,"20170101"); reportingParamNode.putValue(ReportingParametersActEncoder.PERFORMANCE_END,"20171231"); JsonWrapper testJsonWrapper = new JsonWrapper(); String expectedSection = "aci"; ClinicalDocumentEncoder clinicalDocumentEncoder = new ClinicalDocumentEncoder(new Context()); clinicalDocumentEncoder.internalEncode(testJsonWrapper, clinicalDocumentNode); JsonWrapper measurementSets = getMeasurementSets(testJsonWrapper); String value = measurementSets.get(0).getString("category"); assertThat(measurementSets.size()).isEqualTo(1); assertThat(value).isEqualTo(expectedSection); } @Test void testVirtualGroupIdEncode() { clinicalDocumentNode.putValue(ClinicalDocumentDecoder.ENTITY_TYPE, ClinicalDocumentDecoder.ENTITY_VIRTUAL_GROUP); JsonWrapper testJsonWrapper = new JsonWrapper(); ClinicalDocumentEncoder clinicalDocumentEncoder = new ClinicalDocumentEncoder(new Context()); clinicalDocumentEncoder.internalEncode(testJsonWrapper, clinicalDocumentNode); assertThat(testJsonWrapper.getString(ClinicalDocumentDecoder.ENTITY_ID)) .isEqualTo("x12345"); } @Test void testApmExcludeNpiEncoding() throws EncodeException { JsonWrapper testJsonWrapper = new JsonWrapper(); clinicalDocumentNode.putValue(ClinicalDocumentDecoder.ENTITY_TYPE, "apm"); ClinicalDocumentEncoder clinicalDocumentEncoder = new ClinicalDocumentEncoder(new Context()); clinicalDocumentEncoder.internalEncode(testJsonWrapper, clinicalDocumentNode); Map<?, ?> clinicalDocMap = ((Map<?, ?>) testJsonWrapper.toObject()); assertThat(clinicalDocMap.get(ClinicalDocumentDecoder.NATIONAL_PROVIDER_IDENTIFIER)) .isNull(); } @Test void testMeasurementSetIncludesSource() throws EncodeException { JsonWrapper testJsonWrapper = new JsonWrapper(); ClinicalDocumentEncoder clinicalDocumentEncoder = new ClinicalDocumentEncoder(new Context()); clinicalDocumentEncoder.internalEncode(testJsonWrapper, clinicalDocumentNode); @SuppressWarnings("unchecked") List<JsonWrapper> measurementSets = (List<JsonWrapper>) testJsonWrapper.get("measurementSets").toObject(); assertThat(measurementSets).isNotEmpty(); for (JsonWrapper measurement : measurementSets) { assertThat(measurement.get("source")).isNotNull(); } }
StorageServiceImpl extends AnyOrderActionService<Supplier<PutObjectRequest>, String> implements StorageService { @Override public InputStream getApmValidationFile() { String bucketName = environment.getProperty(Constants.BUCKET_NAME_ENV_VARIABLE); if (StringUtils.isEmpty(bucketName)) { API_LOG.warn("No bucket name and/or key specified"); return null; } API_LOG.info("Retrieving APM validation file from bucket {}", bucketName); GetObjectRequest getObjectRequest = new GetObjectRequest(bucketName, Constants.APM_FILE_NAME_KEY); S3Object s3Object = amazonS3.getObject(getObjectRequest); return s3Object.getObjectContent(); } StorageServiceImpl(TaskExecutor taskExecutor, TransferManager s3TransferManager, Environment environment, AmazonS3 amazonS3); @Override CompletableFuture<String> store(String keyName, Supplier<InputStream> inStream, long size); @Override InputStream getFileByLocationId(String fileLocationId); @Override InputStream getCpcPlusValidationFile(); @Override InputStream getApmValidationFile(); }
@Test void test_getApmValidationFile() { S3ObjectInputStream expected = new S3ObjectInputStream(null, null); S3Object mockS3Obj = mock(S3Object.class); Mockito.when(mockS3Obj.getObjectContent()).thenReturn(expected); Mockito.when(environment.getProperty(Constants.BUCKET_NAME_ENV_VARIABLE)).thenReturn("Mock_Bucket"); Mockito.when(amazonS3Client.getObject( any(GetObjectRequest.class) )).thenReturn(mockS3Obj); InputStream actual = underTest.getApmValidationFile(); assertThat(actual).isEqualTo(expected); }
EnvironmentHelper { public static String get(String variable) { String value = getIfPresent(variable); if (value == null) { LOG.warn( String.format(NOT_FOUND, variable)); } return value; } private EnvironmentHelper(); static boolean isPresent(String variable); static String get(String variable); static String getOrDefault(String variable, String defaultValue); }
@Test void testLogEntryForFailures() { String random = UUID.randomUUID().toString(); String message = String.format(EnvironmentHelper.NOT_FOUND, random); EnvironmentHelper.get(random); assertThat(getLogs()).contains(message); }
PiProportionNumeratorEncoder extends QppOutputEncoder { @Override protected void internalEncode(JsonWrapper wrapper, Node node) { Node piNumeratorNode = node.findFirstNode(TemplateId.PI_AGGREGATE_COUNT); if (piNumeratorNode != null) { JsonWrapper numerator = encodeChild(piNumeratorNode); if (null != numerator.getInteger(VALUE)) { wrapper.put(ENCODE_LABEL, numerator.getInteger(VALUE)); wrapper.mergeMetadata(numerator, ENCODE_LABEL); } } } PiProportionNumeratorEncoder(Context context); }
@Test void testInternalEncode() throws EncodeException { PiProportionNumeratorEncoder piProportionNumeratorEncoder = new PiProportionNumeratorEncoder(new Context()); piProportionNumeratorEncoder.internalEncode(jsonWrapper, piProportionNumeratorNode); assertThat(jsonWrapper.getInteger("numerator")) .isEqualTo(600); } @Test void testEncoderWithoutChild() throws EncodeException { piProportionNumeratorNode.getChildNodes().remove(numeratorDenominatorValueNode); PiProportionNumeratorEncoder piProportionNumeratorEncoder = new PiProportionNumeratorEncoder(new Context()); piProportionNumeratorEncoder.internalEncode(jsonWrapper, piProportionNumeratorNode); assertThat(jsonWrapper.getInteger("numerator")) .isNull(); } @Test void testEncoderWithoutValue() throws EncodeException { numeratorDenominatorValueNode.putValue("aggregateCount", null); PiProportionNumeratorEncoder piProportionNumeratorEncoder = new PiProportionNumeratorEncoder(new Context()); piProportionNumeratorEncoder.internalEncode(jsonWrapper, piProportionNumeratorNode); assertThat(jsonWrapper.getInteger("numerator")) .isNull(); }
PiSectionEncoder extends QppOutputEncoder { @Override public void internalEncode(JsonWrapper wrapper, Node node) { encodeTopLevelValues(wrapper, node); List<Node> children = node.getChildNodes(); JsonWrapper measurementsWrapper = new JsonWrapper(); encodeChildren(children, measurementsWrapper); wrapper.put("measurements", measurementsWrapper); Optional.ofNullable(node.getParent()).ifPresent(parent -> pilferParent(wrapper, parent)); encodeReportingParameter(wrapper, node); } PiSectionEncoder(Context context); @Override void internalEncode(JsonWrapper wrapper, Node node); static final String SUBMISSION_METHOD; }
@Test void testInternalEncode() { JsonWrapper jsonWrapper = new JsonWrapper(); PiSectionEncoder piSectionEncoder = new PiSectionEncoder(new Context()); piSectionEncoder.internalEncode(jsonWrapper, piSectionNode); assertWithMessage("Must have a child node").that(jsonWrapper).isNotNull(); assertWithMessage("Must be category PI").that(jsonWrapper.getString(CATEGORY)).isEqualTo(PI); assertWithMessage("Must have measurements").that(jsonWrapper.get(MEASUREMENTS)).isNotNull(); assertThat(jsonWrapper.getString(ClinicalDocumentDecoder.CEHRT)).isNotNull(); assertWithMessage("Must have submissionMethod") .that(jsonWrapper.getString(SUBMISSION_METHOD)).isEqualTo(ELECTRONIC_HEALTH_RECORD); } @Test void aboutMetadataHolder() { JsonWrapper jsonWrapper = new JsonWrapper(); PiSectionEncoder piSectionEncoder = new PiSectionEncoder(new Context()); piSectionEncoder.internalEncode(jsonWrapper, piSectionNode); Stream<JsonWrapper> failed = jsonWrapper.getMetadata().stream() .filter(entry -> entry.getString("template").equals(TemplateId.REPORTING_PARAMETERS_ACT.name())) .filter(entry -> entry.getString(JsonWrapper.ENCODING_KEY).equals("")); assertThat(failed.count()).isEqualTo(0); } @Test void testInternalEncodeWithNoChildren() { JsonWrapper testWrapper = new JsonWrapper(); Node invalidAciNumeratorDenominatorNode = new Node(); piSectionNode = new Node(TemplateId.PI_SECTION_V2); piSectionNode.putValue(CATEGORY, PI); piSectionNode.addChildNode(invalidAciNumeratorDenominatorNode); piSectionNode.addChildNode(reportingParametersNode); piSectionNode.setParent(clinicalDocumentNode); PiSectionEncoder piSectionEncoder = new PiSectionEncoder(new Context()); piSectionEncoder.internalEncode(testWrapper, piSectionNode); assertThat(piSectionEncoder.getErrors()).isNotNull(); assertThat(piSectionEncoder.getErrors().get(0).getMessage()) .isEqualTo(ProblemCode.CT_LABEL + "Failed to find an encoder"); } @Test void internalEncodeNegativeWithNoReportingParameters() throws EncodeException { piSectionNode.getChildNodes().remove(reportingParametersNode); PiSectionEncoder encoder = spy(new PiSectionEncoder(new Context())); JsonWrapper jsonWrapper = new JsonWrapper(); encoder.internalEncode(jsonWrapper, piSectionNode); verify(encoder, Mockito.times(1)).maintainContinuity(any(JsonWrapper.class), any(Node.class), anyString()); }
DbServiceImpl extends AnyOrderActionService<Metadata, Metadata> implements DbService { public List<Metadata> getUnprocessedCpcPlusMetaData(String orgAttribute) { if (mapper.isPresent()) { API_LOG.info("Getting list of unprocessed CPC+ metadata..."); String cpcConversionStartDate = Optional.ofNullable( environment.getProperty(Constants.CPC_PLUS_UNPROCESSED_FILE_SEARCH_DATE_VARIABLE)).orElse(""); String year = cpcConversionStartDate.substring(0, 4); String indexName = Constants.DYNAMO_CPC_ATTRIBUTE + "-" + orgAttribute + "-index"; return IntStream.range(0, Constants.CPC_DYNAMO_PARTITIONS).mapToObj(partition -> { Map<String, AttributeValue> valueMap = new HashMap<>(); valueMap.put(":cpcValue", new AttributeValue().withS(Constants.CPC_DYNAMO_PARTITION_START + partition)); valueMap.put(":cpcProcessedValue", new AttributeValue().withS("false#"+year)); valueMap.put(":createDate", new AttributeValue().withS(cpcConversionStartDate)); DynamoDBQueryExpression<Metadata> metadataQuery = new DynamoDBQueryExpression<Metadata>() .withIndexName(indexName) .withKeyConditionExpression(Constants.DYNAMO_CPC_ATTRIBUTE + " = :cpcValue and begins_with(" + orgAttribute + ", :cpcProcessedValue)") .withFilterExpression(Constants.DYNAMO_CREATE_DATE_ATTRIBUTE + " > :createDate") .withExpressionAttributeValues(valueMap) .withConsistentRead(false); return mapper.get().query(Metadata.class, metadataQuery).stream(); }).flatMap(Function.identity()).collect(Collectors.toList()); } else { API_LOG.warn("Could not get unprocessed CPC+ metadata because the dynamodb mapper is absent"); return Collections.emptyList(); } } DbServiceImpl(TaskExecutor taskExecutor, Optional<DynamoDBMapper> mapper, Environment environment); @Override CompletableFuture<Metadata> write(Metadata meta); List<Metadata> getUnprocessedCpcPlusMetaData(String orgAttribute); Metadata getMetadataById(String uuid); }
@Test void testGetUnprocessedCpcPlusMetaDataWithMissingDynamoDbMapper() { underTest = new DbServiceImpl(taskExecutor, Optional.empty(), environment); assertThat(underTest.getUnprocessedCpcPlusMetaData(Constants.CPC_ORG)).isEmpty(); } @Test @SuppressWarnings("unchecked") void testGetUnprocessedCpcPlusMetaData() { when(environment.getProperty(Constants.CPC_PLUS_UNPROCESSED_FILE_SEARCH_DATE_VARIABLE)).thenReturn("2020-01-01"); int itemsPerPartition = 2; PaginatedQueryList<Metadata> mockMetadataPage = mock(PaginatedQueryList.class); Answer<Stream<Metadata>> answer = (InvocationOnMock invocation) -> Stream.generate(Metadata::new).limit(itemsPerPartition); when(mockMetadataPage.stream()).thenAnswer(answer); when(dbMapper.query(eq(Metadata.class), any(DynamoDBQueryExpression.class))) .thenReturn(mockMetadataPage); List<Metadata> metaDataList = underTest.getUnprocessedCpcPlusMetaData(Constants.CPC_ORG); verify(dbMapper, times(Constants.CPC_DYNAMO_PARTITIONS)).query(eq(Metadata.class), any(DynamoDBQueryExpression.class)); assertThat(metaDataList).hasSize(itemsPerPartition * Constants.CPC_DYNAMO_PARTITIONS); }
PiNumeratorDenominatorEncoder extends QppOutputEncoder { @Override protected void internalEncode(JsonWrapper wrapper, Node node) { Map<TemplateId, Node> childMapByTemplateId = node.getChildNodes().stream().collect( Collectors.toMap(Node::getType, Function.identity(), (v1, v2) -> v1, LinkedHashMap::new)); JsonWrapper childWrapper = encodeChildren(childMapByTemplateId); wrapper.put("measureId", node.getValue("measureId")); wrapper.put(VALUE, childWrapper); } PiNumeratorDenominatorEncoder(Context context); }
@Test void testInternalEncode() throws EncodeException { JsonWrapper jsonWrapper = new JsonWrapper(); PiNumeratorDenominatorEncoder objectUnderTest = new PiNumeratorDenominatorEncoder(new Context()); objectUnderTest.internalEncode(jsonWrapper, piProportionMeasureNode); assertThat(jsonWrapper.getString("measureId")) .isEqualTo(MEASURE_ID); assertThat(jsonWrapper.toObject()) .isNotNull(); assertThat(jsonWrapper.toObject()) .isInstanceOf(Map.class); assertThat(((Map<?, ?>)jsonWrapper.toObject()).get("value")) .isNotNull(); } @Test void testNoChildEncoder() throws EncodeException { JsonWrapper jsonWrapper = new JsonWrapper(); PiNumeratorDenominatorEncoder objectUnderTest = new PiNumeratorDenominatorEncoder(new Context()); Node unknownNode = new Node(); piProportionMeasureNode.addChildNode(unknownNode); objectUnderTest.internalEncode(jsonWrapper, piProportionMeasureNode); assertThat(objectUnderTest.getErrors()) .hasSize(1); assertWithMessage("The validation error must be the inability to find an encoder") .that(objectUnderTest.getErrors().get(0).getMessage()) .isEqualTo(ProblemCode.CT_LABEL + "Failed to find an encoder"); }
PiMeasurePerformedRnREncoder extends QppOutputEncoder { @Override protected void internalEncode(JsonWrapper wrapper, Node node) { wrapper.put("measureId", node.getValue("measureId")); encodeChild(wrapper, node); } PiMeasurePerformedRnREncoder(Context context); }
@Test void testInternalEncode() { JsonWrapper jsonWrapper = new JsonWrapper(); PiMeasurePerformedRnREncoder objectUnderTest = new PiMeasurePerformedRnREncoder(new Context()); objectUnderTest.internalEncode(jsonWrapper, piMeasurePerformedRnR); assertThat(jsonWrapper.getString("measureId")) .isEqualTo(MEASURE_ID); assertThat(jsonWrapper.getBoolean("value")) .isEqualTo(true); } @Test void testInternalEncodeNoChildNoValue(){ JsonWrapper jsonWrapper = new JsonWrapper(); PiMeasurePerformedRnREncoder objectUnderTest = new PiMeasurePerformedRnREncoder(new Context()); piMeasurePerformedRnR.setChildNodes(); objectUnderTest.internalEncode(jsonWrapper, piMeasurePerformedRnR); assertThat(jsonWrapper.getString("measureId")) .isEqualTo(MEASURE_ID); assertThat(jsonWrapper.getBoolean("value")) .isNull(); } @Test void testInternalEncodeBooleanTrueValue() { JsonWrapper jsonWrapper = new JsonWrapper(); PiMeasurePerformedRnREncoder objectUnderTest = new PiMeasurePerformedRnREncoder(new Context()); piMeasurePerformedRnR.getChildNodes().get(0).putValue("measurePerformed", "Y"); objectUnderTest.internalEncode(jsonWrapper, piMeasurePerformedRnR); assertThat(jsonWrapper.getString("measureId")) .isEqualTo(MEASURE_ID); assertThat(jsonWrapper.getBoolean("value")) .isEqualTo(true); } @Test void testInternalEncodeBooleanFalseValue() { JsonWrapper jsonWrapper = new JsonWrapper(); PiMeasurePerformedRnREncoder objectUnderTest = new PiMeasurePerformedRnREncoder(new Context()); piMeasurePerformedRnR.getChildNodes().get(0).putValue("measurePerformed","N"); objectUnderTest.internalEncode(jsonWrapper, piMeasurePerformedRnR); assertThat(jsonWrapper.getString("measureId")) .isEqualTo(MEASURE_ID); assertThat(jsonWrapper.getBoolean("value")) .isEqualTo(false); } @Test void testInternalEncodeBooleanStringValue() { JsonWrapper jsonWrapper = new JsonWrapper(); PiMeasurePerformedRnREncoder objectUnderTest = new PiMeasurePerformedRnREncoder(new Context()); String unknownValue = "Some unknown value"; piMeasurePerformedRnR.getChildNodes().get(0).putValue("measurePerformed",unknownValue); objectUnderTest.internalEncode(jsonWrapper, piMeasurePerformedRnR); assertThat(jsonWrapper.getString("measureId")) .isEqualTo(MEASURE_ID); assertThat(jsonWrapper.getString("value")) .isEqualTo(unknownValue); }
MeasurePerformedEncoder extends QppOutputEncoder { @Override protected void internalEncode(JsonWrapper wrapper, Node node) { wrapper.putBoolean(VALUE, node.getValue("measurePerformed")); } MeasurePerformedEncoder(Context context); }
@Test void testMeasurePerformedEncodesIntoWrapper() throws EncodeException { Node measurePerformedNode = new Node(TemplateId.MEASURE_PERFORMED); measurePerformedNode.putValue("measurePerformed", "Y"); JsonWrapper jsonWrapper = new JsonWrapper(); QppOutputEncoder qppOutputEncoder = new QppOutputEncoder(new Context()); qppOutputEncoder.internalEncode(jsonWrapper, measurePerformedNode); assertThat(jsonWrapper.getBoolean("value")).isTrue(); }
DefaultEncoder extends JsonOutputEncoder { @Override protected void internalEncode(JsonWrapper wrapper, Node node) { DEV_LOG.debug("Default JSON encoder {} is handling templateId {} and is described as '{}' ", getClass(), node.getType().name(), description); JsonWrapper childWrapper = new JsonWrapper(); for (Node child : node.getChildNodes()) { encode(childWrapper, child); } for (String name : node.getKeys()) { String nameForEncode = name.replace("Decoder", "Encoder"); childWrapper.put(nameForEncode, node.getValue(name)); } wrapper.put(node.getType().name(), childWrapper); } DefaultEncoder(String description); }
@Test void encodeDefaultNode() throws EncodeException { Node root = new Node(TemplateId.DEFAULT); Node placeHolder = new Node(TemplateId.PLACEHOLDER, root); root.addChildNode(placeHolder); JsonWrapper wrapper = new JsonWrapper(); new DefaultEncoder("Default Encode test").internalEncode(wrapper, root); assertThat(wrapper.toString()).hasLength(3); } @Test void encodeNodes() throws EncodeException { Node root = new Node(TemplateId.DEFAULT); Node placeHolder = new Node(TemplateId.PLACEHOLDER, root); root.addChildNode(placeHolder); placeHolder.putValue("name1", "value1"); Node qed = new Node(TemplateId.QED, root); root.addChildNode(qed); qed.putValue("name2", "value2"); JsonWrapper wrapper = new JsonWrapper(); new DefaultEncoder("Default Encode test").internalEncode(wrapper, root); String json = wrapper.toString(); String acutal = json.replaceAll("\\s", ""); String expect = "{\"DEFAULT\":{\"PLACEHOLDER\":{\"name1\":\"value1\"},\"QED\":{\"name2\":\"value2\"}}}"; assertThat(acutal).isEqualTo(expect); }
DbServiceImpl extends AnyOrderActionService<Metadata, Metadata> implements DbService { public Metadata getMetadataById(String uuid) { if (mapper.isPresent()) { API_LOG.info("Read item {} from DynamoDB", uuid); return mapper.get().load(Metadata.class, uuid); } else { API_LOG.warn("Skipping reading of item from DynamoDB with UUID {} because the dynamodb mapper is absent", uuid); return null; } } DbServiceImpl(TaskExecutor taskExecutor, Optional<DynamoDBMapper> mapper, Environment environment); @Override CompletableFuture<Metadata> write(Metadata meta); List<Metadata> getUnprocessedCpcPlusMetaData(String orgAttribute); Metadata getMetadataById(String uuid); }
@Test void testGetMetadataByIdWithMissingDynamoDbMapper() { underTest = new DbServiceImpl(taskExecutor, Optional.empty(), environment); assertThat(underTest.getMetadataById(null)).isNull(); } @Test void testGetMetadataById() { String fakeUuid = "1337-f4ke-uuid"; when(dbMapper.load(eq(Metadata.class), anyString())).thenReturn(Metadata.create()); Metadata fakeMetadata = underTest.getMetadataById(fakeUuid); verify(dbMapper, times(1)).load(eq(Metadata.class), anyString()); assertThat(fakeMetadata).isNotNull(); }
PlaceholderEncoder extends QppOutputEncoder { @Override protected void internalEncode(JsonWrapper wrapper, Node node) { for (Node child : node.getChildNodes()) { JsonOutputEncoder encoder = encoders.get(child.getType()); if (encoder != null) { encoder.encode(wrapper, child); } else { addValidationError(Detail.forProblemAndNode(ProblemCode.ENCODER_MISSING, child)); } } } PlaceholderEncoder(Context context); }
@Test void encodePlaceholderNodeNegative() throws EncodeException { Node placeHolder = new Node(TemplateId.PLACEHOLDER); placeHolder.addChildNode(new Node()); JsonWrapper wrapper = new JsonWrapper(); PlaceholderEncoder encoder = new PlaceholderEncoder(new Context()); encoder.internalEncode(wrapper, placeHolder); assertThat(encoder.getErrors()).hasSize(1); }
AggregateCountEncoder extends QppOutputEncoder { @Override protected void internalEncode(JsonWrapper wrapper, Node node) { wrapper.putInteger(VALUE, node.getValue(AggregateCountDecoder.AGGREGATE_COUNT)); } AggregateCountEncoder(Context context); }
@Test void testEncoder() { AggregateCountEncoder encoder = new AggregateCountEncoder(new Context()); encoder.setNodes(nodes); JsonWrapper json = new JsonWrapper(); try { encoder.internalEncode(json, numeratorDenominatorNode); } catch (EncodeException e) { Assertions.fail("Failure to encode: " + e.getMessage()); } assertThat(json.getInteger("value")) .isEqualTo(600); }
EncodeException extends RuntimeException { public String getTemplateId() { return templateId; } EncodeException(String message); EncodeException(String message, Exception cause); EncodeException(String message, String templateId); EncodeException(String message, Exception cause, String templateId); String getTemplateId(); }
@Test void getTemplateId() throws Exception { EncodeException e = new EncodeException("ErrorMessage", "templateId"); String value = e.getTemplateId(); assertThat(value) .isEqualTo("templateId"); }
Context { public boolean isDoValidation() { return doValidation; } Context(); Context(ApmEntityIds apmEntityIds); Program getProgram(); void setProgram(Program program); boolean isHistorical(); void setHistorical(boolean historical); boolean isDoValidation(); void setDoValidation(boolean doValidation); PiiValidator getPiiValidator(); void setPiiValidator(PiiValidator piiValidator); ApmEntityIds getApmEntityIds(); void setApmEntityIds(final ApmEntityIds apmEntityIds); @SuppressWarnings("unchecked") Registry<R> getRegistry(Class<A> annotation); static final String REPORTING_YEAR; }
@Test void testDoesValidationByDefault() { assertThat(new Context().isDoValidation()).isTrue(); }
Context { public boolean isHistorical() { return historical; } Context(); Context(ApmEntityIds apmEntityIds); Program getProgram(); void setProgram(Program program); boolean isHistorical(); void setHistorical(boolean historical); boolean isDoValidation(); void setDoValidation(boolean doValidation); PiiValidator getPiiValidator(); void setPiiValidator(PiiValidator piiValidator); ApmEntityIds getApmEntityIds(); void setApmEntityIds(final ApmEntityIds apmEntityIds); @SuppressWarnings("unchecked") Registry<R> getRegistry(Class<A> annotation); static final String REPORTING_YEAR; }
@Test void testIsNotHistoricalByDefault() { assertThat(new Context().isHistorical()).isFalse(); }
Context { public Program getProgram() { return program; } Context(); Context(ApmEntityIds apmEntityIds); Program getProgram(); void setProgram(Program program); boolean isHistorical(); void setHistorical(boolean historical); boolean isDoValidation(); void setDoValidation(boolean doValidation); PiiValidator getPiiValidator(); void setPiiValidator(PiiValidator piiValidator); ApmEntityIds getApmEntityIds(); void setApmEntityIds(final ApmEntityIds apmEntityIds); @SuppressWarnings("unchecked") Registry<R> getRegistry(Class<A> annotation); static final String REPORTING_YEAR; }
@Test void testProgramIsAllByDefault() { assertThat(new Context().getProgram()) .isSameInstanceAs(Program.ALL); }
Context { @SuppressWarnings("unchecked") public <A extends Annotation, R> Registry<R> getRegistry(Class<A> annotation) { return (Registry<R>) registries.computeIfAbsent(annotation, key -> new Registry<>(this, key)); } Context(); Context(ApmEntityIds apmEntityIds); Program getProgram(); void setProgram(Program program); boolean isHistorical(); void setHistorical(boolean historical); boolean isDoValidation(); void setDoValidation(boolean doValidation); PiiValidator getPiiValidator(); void setPiiValidator(PiiValidator piiValidator); ApmEntityIds getApmEntityIds(); void setApmEntityIds(final ApmEntityIds apmEntityIds); @SuppressWarnings("unchecked") Registry<R> getRegistry(Class<A> annotation); static final String REPORTING_YEAR; }
@Test void testGetRegistryReturnsValid() { assertThat(new Context().getRegistry(Decoder.class)).isNotNull(); } @Test void testGetRegistryIdentity() { Context context = new Context(); assertThat(context.getRegistry(Decoder.class)) .isSameInstanceAs(context.getRegistry(Decoder.class)); }
ApmEntityIds { public boolean idExists(String apmEntityId) { return validApmEntityIds.contains(apmEntityId); } ApmEntityIds(InputStream fileStream); ApmEntityIds(String fileName); ApmEntityIds(); boolean idExists(String apmEntityId); static final String DEFAULT_APM_ENTITY_FILE_NAME; }
@Test void testIdExists() { assertThat(apmEntityIds.idExists(APM_ID_THAT_EXISTS)).isTrue(); } @Test void testIdDoesNotExistDueToCapitalization() { assertThat(apmEntityIds.idExists(APM_ID_THAT_EXISTS.toUpperCase(Locale.ENGLISH))).isFalse(); } @Test void testIdDoesNotExists() { assertThat(apmEntityIds.idExists("PropertyTaxes")).isFalse(); }
Node { @Override public String toString() { return MoreObjects.toStringHelper(this) .add("type", type) .add("data", data) .add("childNodesSize", childNodes.size()) .add("parent", parent == null ? "null" : "not null") .add("validated", validated) .add("defaultNsUri", defaultNsUri) .add("path", path) .add("elementForLocation", elementForLocation) .add("line", line) .add("column", column) .toString(); } Node(); Node(TemplateId type, Node parent); Node(TemplateId templateId); String getValue(String name); String getValueOrDefault(String name, String defaultValue); List<String> getDuplicateValues(String name); void putValue(String name, String value); void putValue(String name, String value, boolean replace); void removeValue(String name); boolean hasValue(String name); List<Node> getChildNodes(); Stream<Node> getChildNodes(TemplateId... templateIds); Stream<Node> getChildNodes(Predicate<Node> filter); Node findChildNode(Predicate<Node> filter); void setChildNodes(Node... childNodes); void addChildNodes(Node... childNodes); void addChildNode(Node childNode); boolean removeChildNode(Node childNode); Set<String> getKeys(); Node getParent(); void setParent(Node parent); void setType(TemplateId type); TemplateId getType(); void setLine(int line); int getLine(); void setColumn(int column); int getColumn(); String getOrComputePath(); Element getElementForLocation(); void setElementForLocation(Element elementForLocation); String getDefaultNsUri(); void setDefaultNsUri(String newDefaultNsUri); List<Node> findNode(TemplateId templateId); Node findFirstNode(TemplateId templateId); void setValidated(boolean validated); boolean isNotValidated(); Node findParentNodeWithHumanReadableTemplateId(); @Override String toString(); @Override final boolean equals(final Object o); @Override final int hashCode(); static final int DEFAULT_LOCATION_NUMBER; }
@Test void testToString() { Node node = new Node(TemplateId.PLACEHOLDER); node.putValue("DEF", "GHI"); String toString = node.toString(); assertThat(toString).contains(TemplateId.PLACEHOLDER.name()); assertThat(toString).contains("GHI"); }
Node { public boolean isNotValidated() { return !isValidated(); } Node(); Node(TemplateId type, Node parent); Node(TemplateId templateId); String getValue(String name); String getValueOrDefault(String name, String defaultValue); List<String> getDuplicateValues(String name); void putValue(String name, String value); void putValue(String name, String value, boolean replace); void removeValue(String name); boolean hasValue(String name); List<Node> getChildNodes(); Stream<Node> getChildNodes(TemplateId... templateIds); Stream<Node> getChildNodes(Predicate<Node> filter); Node findChildNode(Predicate<Node> filter); void setChildNodes(Node... childNodes); void addChildNodes(Node... childNodes); void addChildNode(Node childNode); boolean removeChildNode(Node childNode); Set<String> getKeys(); Node getParent(); void setParent(Node parent); void setType(TemplateId type); TemplateId getType(); void setLine(int line); int getLine(); void setColumn(int column); int getColumn(); String getOrComputePath(); Element getElementForLocation(); void setElementForLocation(Element elementForLocation); String getDefaultNsUri(); void setDefaultNsUri(String newDefaultNsUri); List<Node> findNode(TemplateId templateId); Node findFirstNode(TemplateId templateId); void setValidated(boolean validated); boolean isNotValidated(); Node findParentNodeWithHumanReadableTemplateId(); @Override String toString(); @Override final boolean equals(final Object o); @Override final int hashCode(); static final int DEFAULT_LOCATION_NUMBER; }
@Test void testNotValidatedMember() { Node node = new Node(); assertThat(node.isNotValidated()).isTrue(); }
Node { public List<Node> findNode(TemplateId templateId) { return findNode(templateId, null); } Node(); Node(TemplateId type, Node parent); Node(TemplateId templateId); String getValue(String name); String getValueOrDefault(String name, String defaultValue); List<String> getDuplicateValues(String name); void putValue(String name, String value); void putValue(String name, String value, boolean replace); void removeValue(String name); boolean hasValue(String name); List<Node> getChildNodes(); Stream<Node> getChildNodes(TemplateId... templateIds); Stream<Node> getChildNodes(Predicate<Node> filter); Node findChildNode(Predicate<Node> filter); void setChildNodes(Node... childNodes); void addChildNodes(Node... childNodes); void addChildNode(Node childNode); boolean removeChildNode(Node childNode); Set<String> getKeys(); Node getParent(); void setParent(Node parent); void setType(TemplateId type); TemplateId getType(); void setLine(int line); int getLine(); void setColumn(int column); int getColumn(); String getOrComputePath(); Element getElementForLocation(); void setElementForLocation(Element elementForLocation); String getDefaultNsUri(); void setDefaultNsUri(String newDefaultNsUri); List<Node> findNode(TemplateId templateId); Node findFirstNode(TemplateId templateId); void setValidated(boolean validated); boolean isNotValidated(); Node findParentNodeWithHumanReadableTemplateId(); @Override String toString(); @Override final boolean equals(final Object o); @Override final int hashCode(); static final int DEFAULT_LOCATION_NUMBER; }
@Test void testFindNode() { Node parent = new Node(); Node childOne = new Node(); Node childTwo = new Node(); Node childThree = new Node(TemplateId.PLACEHOLDER); parent.addChildNodes(childOne, childTwo, childThree); List<Node> results = parent.findNode(TemplateId.PLACEHOLDER); assertWithMessage("should find first child that has the searched id") .that(results).hasSize(1); }
Node { public void removeValue(String name) { data.remove(name); } Node(); Node(TemplateId type, Node parent); Node(TemplateId templateId); String getValue(String name); String getValueOrDefault(String name, String defaultValue); List<String> getDuplicateValues(String name); void putValue(String name, String value); void putValue(String name, String value, boolean replace); void removeValue(String name); boolean hasValue(String name); List<Node> getChildNodes(); Stream<Node> getChildNodes(TemplateId... templateIds); Stream<Node> getChildNodes(Predicate<Node> filter); Node findChildNode(Predicate<Node> filter); void setChildNodes(Node... childNodes); void addChildNodes(Node... childNodes); void addChildNode(Node childNode); boolean removeChildNode(Node childNode); Set<String> getKeys(); Node getParent(); void setParent(Node parent); void setType(TemplateId type); TemplateId getType(); void setLine(int line); int getLine(); void setColumn(int column); int getColumn(); String getOrComputePath(); Element getElementForLocation(); void setElementForLocation(Element elementForLocation); String getDefaultNsUri(); void setDefaultNsUri(String newDefaultNsUri); List<Node> findNode(TemplateId templateId); Node findFirstNode(TemplateId templateId); void setValidated(boolean validated); boolean isNotValidated(); Node findParentNodeWithHumanReadableTemplateId(); @Override String toString(); @Override final boolean equals(final Object o); @Override final int hashCode(); static final int DEFAULT_LOCATION_NUMBER; }
@Test void testRemoveValue() { Node node = new Node(); node.putValue("test", "hello"); node.removeValue("test"); assertThat(node.hasValue("test")).isFalse(); }
Node { public boolean removeChildNode(Node childNode) { return this.childNodes.remove(childNode); } Node(); Node(TemplateId type, Node parent); Node(TemplateId templateId); String getValue(String name); String getValueOrDefault(String name, String defaultValue); List<String> getDuplicateValues(String name); void putValue(String name, String value); void putValue(String name, String value, boolean replace); void removeValue(String name); boolean hasValue(String name); List<Node> getChildNodes(); Stream<Node> getChildNodes(TemplateId... templateIds); Stream<Node> getChildNodes(Predicate<Node> filter); Node findChildNode(Predicate<Node> filter); void setChildNodes(Node... childNodes); void addChildNodes(Node... childNodes); void addChildNode(Node childNode); boolean removeChildNode(Node childNode); Set<String> getKeys(); Node getParent(); void setParent(Node parent); void setType(TemplateId type); TemplateId getType(); void setLine(int line); int getLine(); void setColumn(int column); int getColumn(); String getOrComputePath(); Element getElementForLocation(); void setElementForLocation(Element elementForLocation); String getDefaultNsUri(); void setDefaultNsUri(String newDefaultNsUri); List<Node> findNode(TemplateId templateId); Node findFirstNode(TemplateId templateId); void setValidated(boolean validated); boolean isNotValidated(); Node findParentNodeWithHumanReadableTemplateId(); @Override String toString(); @Override final boolean equals(final Object o); @Override final int hashCode(); static final int DEFAULT_LOCATION_NUMBER; }
@Test void testRemoveChildNodeNull() { Node node = new Node(); assertThat(node.removeChildNode(null)).isFalse(); } @Test void testRemoveChildNodeSelf() { Node node = new Node(); assertThat(node.removeChildNode(node)).isFalse(); }
Node { public Node findParentNodeWithHumanReadableTemplateId() { return findParentNodeWithHumanReadableTemplateId(this); } Node(); Node(TemplateId type, Node parent); Node(TemplateId templateId); String getValue(String name); String getValueOrDefault(String name, String defaultValue); List<String> getDuplicateValues(String name); void putValue(String name, String value); void putValue(String name, String value, boolean replace); void removeValue(String name); boolean hasValue(String name); List<Node> getChildNodes(); Stream<Node> getChildNodes(TemplateId... templateIds); Stream<Node> getChildNodes(Predicate<Node> filter); Node findChildNode(Predicate<Node> filter); void setChildNodes(Node... childNodes); void addChildNodes(Node... childNodes); void addChildNode(Node childNode); boolean removeChildNode(Node childNode); Set<String> getKeys(); Node getParent(); void setParent(Node parent); void setType(TemplateId type); TemplateId getType(); void setLine(int line); int getLine(); void setColumn(int column); int getColumn(); String getOrComputePath(); Element getElementForLocation(); void setElementForLocation(Element elementForLocation); String getDefaultNsUri(); void setDefaultNsUri(String newDefaultNsUri); List<Node> findNode(TemplateId templateId); Node findFirstNode(TemplateId templateId); void setValidated(boolean validated); boolean isNotValidated(); Node findParentNodeWithHumanReadableTemplateId(); @Override String toString(); @Override final boolean equals(final Object o); @Override final int hashCode(); static final int DEFAULT_LOCATION_NUMBER; }
@Test void testFindParentNodeWithHumanReadableTemplateIdTraverse() { Node topLevelNode = new Node(TemplateId.IA_MEASURE); Node middleLevelNode = new Node(TemplateId.PI_SECTION_V2, topLevelNode); Node bottomLevelNode = new Node(TemplateId.PI_AGGREGATE_COUNT, middleLevelNode); Node humanReadableNode = bottomLevelNode.findParentNodeWithHumanReadableTemplateId(); assertThat(humanReadableNode).isSameInstanceAs(middleLevelNode); assertThat(humanReadableNode).isNotSameInstanceAs(topLevelNode); } @Test void testFindParentNodeWithHumanReadableTemplateIdSame() { Node node = new Node(TemplateId.IA_MEASURE); Node humanReadableNode = node.findParentNodeWithHumanReadableTemplateId(); assertThat(humanReadableNode).isSameInstanceAs(node); } @Test void testFindParentNodeWithHumanReadableTemplateIdNull() { Node node = new Node(TemplateId.PI_AGGREGATE_COUNT); Node humanReadableNode = node.findParentNodeWithHumanReadableTemplateId(); assertThat(humanReadableNode).isNull(); }
Node { @Override public final boolean equals(final Object o) { if (this == o) { return true; } if (!(o instanceof Node)) { return false; } final Node node = (Node) o; return new EqualsBuilder().append(isValidated(), node.isValidated()) .append(getChildNodes(), node.getChildNodes()) .append(data, node.data) .append(duplicateData, node.duplicateData) .append(getType(), node.getType()) .append(getDefaultNsUri(), node.getDefaultNsUri()) .append(path, node.path) .append(getElementForLocation(), node.getElementForLocation()) .append(getLine(), node.getLine()) .append(getColumn(), node.getColumn()) .isEquals(); } Node(); Node(TemplateId type, Node parent); Node(TemplateId templateId); String getValue(String name); String getValueOrDefault(String name, String defaultValue); List<String> getDuplicateValues(String name); void putValue(String name, String value); void putValue(String name, String value, boolean replace); void removeValue(String name); boolean hasValue(String name); List<Node> getChildNodes(); Stream<Node> getChildNodes(TemplateId... templateIds); Stream<Node> getChildNodes(Predicate<Node> filter); Node findChildNode(Predicate<Node> filter); void setChildNodes(Node... childNodes); void addChildNodes(Node... childNodes); void addChildNode(Node childNode); boolean removeChildNode(Node childNode); Set<String> getKeys(); Node getParent(); void setParent(Node parent); void setType(TemplateId type); TemplateId getType(); void setLine(int line); int getLine(); void setColumn(int column); int getColumn(); String getOrComputePath(); Element getElementForLocation(); void setElementForLocation(Element elementForLocation); String getDefaultNsUri(); void setDefaultNsUri(String newDefaultNsUri); List<Node> findNode(TemplateId templateId); Node findFirstNode(TemplateId templateId); void setValidated(boolean validated); boolean isNotValidated(); Node findParentNodeWithHumanReadableTemplateId(); @Override String toString(); @Override final boolean equals(final Object o); @Override final int hashCode(); static final int DEFAULT_LOCATION_NUMBER; }
@Test void testEquals() { Node parent = new Node(TemplateId.CLINICAL_DOCUMENT); Node child1 = new Node(TemplateId.IA_SECTION); child1.setParent(parent); Node child2 = new Node(TemplateId.PI_SECTION_V2); child2.setParent(parent); parent.setChildNodes(child1, child2); EqualsVerifier.forClass(Node.class) .withPrefabValues(List.class, Lists.newArrayList(new Node()), Lists.newArrayList(new Node(TemplateId.CLINICAL_DOCUMENT), new Node(TemplateId.PI_NUMERATOR))) .withPrefabValues(Node.class, new Node(TemplateId.PI_DENOMINATOR), parent) .withPrefabValues(Element.class, new Element("mock-one"), new Element("mock-two")) .withIgnoredFields("parent") .suppress(Warning.NONFINAL_FIELDS) .verify(); }
Error implements Serializable { @JsonProperty("details") public List<Detail> getDetails() { return details; } Error(); Error(String sourceIdentifier, List<Detail> details); String getSourceIdentifier(); void setSourceIdentifier(final String sourceIdentifier); String getType(); void setType(final String type); String getMessage(); void setMessage(final String message); @JsonProperty("details") List<Detail> getDetails(); @JsonProperty("details") void setDetails(final List<Detail> details); void addValidationError(final Detail detail); @Override String toString(); }
@Test void testValidationErrorInit() { Error objectUnderTest = new Error(); assertWithMessage("The validation errors should have been empty at first") .that(objectUnderTest.getDetails()).isEmpty(); }
Error implements Serializable { public void addValidationError(final Detail detail) { if (null == details) { details = new ArrayList<>(); } details.add(detail); } Error(); Error(String sourceIdentifier, List<Detail> details); String getSourceIdentifier(); void setSourceIdentifier(final String sourceIdentifier); String getType(); void setType(final String type); String getMessage(); void setMessage(final String message); @JsonProperty("details") List<Detail> getDetails(); @JsonProperty("details") void setDetails(final List<Detail> details); void addValidationError(final Detail detail); @Override String toString(); }
@Test void testAddValidationError() { Error objectUnderTest = new Error(); objectUnderTest.addValidationError(new Detail()); objectUnderTest.addValidationError(new Detail()); assertWithMessage("The list should have two items") .that(objectUnderTest.getDetails()).hasSize(2); }
Error implements Serializable { @Override public String toString() { return MoreObjects.toStringHelper(this) .add("sourceIdentifier", sourceIdentifier) .add("type", type) .add("message", message) .add("details", details) .toString(); } Error(); Error(String sourceIdentifier, List<Detail> details); String getSourceIdentifier(); void setSourceIdentifier(final String sourceIdentifier); String getType(); void setType(final String type); String getMessage(); void setMessage(final String message); @JsonProperty("details") List<Detail> getDetails(); @JsonProperty("details") void setDetails(final List<Detail> details); void addValidationError(final Detail detail); @Override String toString(); }
@Test void testToString() { Error objectUnderTest = new Error(); objectUnderTest.setSourceIdentifier("sourceID"); objectUnderTest.setDetails(Collections.singletonList(Detail.forProblemCode(ProblemCode.UNEXPECTED_ERROR))); objectUnderTest.setType("aType"); objectUnderTest.setMessage("coolMessage"); StringSubject subject = assertWithMessage("Must contain formatted string") .that(objectUnderTest.toString()); subject.contains(String.valueOf(objectUnderTest.getSourceIdentifier())); subject.contains(String.valueOf(objectUnderTest.getDetails())); subject.contains(String.valueOf(objectUnderTest.getType())); subject.contains(String.valueOf(objectUnderTest.getMessage())); }
Detail implements Serializable { private static String computeLocation(Node node) { StringBuilder location = new StringBuilder(); Node importantParentNode = node.findParentNodeWithHumanReadableTemplateId(); if (importantParentNode != null) { String importantParentTitle = importantParentNode.getType().getHumanReadableTitle(); String possibleMeasureId = importantParentNode.getValue("measureId"); location.append(importantParentTitle); if (!StringUtils.isEmpty(possibleMeasureId)) { location.append(" "); location.append(possibleMeasureId); String possibleElectronicMeasureId = MeasureConfigHelper.getMeasureConfigIdByUuidOrDefault(possibleMeasureId); if (!StringUtils.isEmpty(possibleElectronicMeasureId)) { location.append(" ("); location.append(possibleElectronicMeasureId); location.append(")"); } } } return location.toString(); } Detail(); Detail(Detail copy); static Detail forProblemAndNode(LocalizedProblem problem, Node node); static Detail forProblemCode(LocalizedProblem problem); Integer getErrorCode(); void setErrorCode(Integer errorCode); String getMessage(); void setMessage(String message); String getValue(); void setValue(String value); String getType(); void setType(String type); Location getLocation(); void setLocation(Location location); @Override String toString(); @Override boolean equals(Object o); @Override int hashCode(); }
@Test void testComputeLocation() { Node node = new Node(TemplateId.CLINICAL_DOCUMENT); Detail detail = Detail.forProblemAndNode(ProblemCode.UNEXPECTED_ERROR, node); assertThat(detail.getLocation().getLocation()).isEqualTo(node.getType().getHumanReadableTitle()); }
AllErrors implements Serializable { public List<Error> getErrors() { return errors; } AllErrors(); AllErrors(List<Error> errors); List<Error> getErrors(); void setErrors(final List<Error> errors); void addError(Error error); @Override String toString(); }
@Test void testErrorSourceInit() { AllErrors objectUnderTest = new AllErrors(); assertWithMessage("The error sources should have been null at first") .that(objectUnderTest.getErrors()) .isNull(); } @Test void testArgConstructor() { List<Error> errors = new ArrayList<>(); errors.add(new Error()); new AllErrors(errors); assertThat(new AllErrors(errors).getErrors()) .containsAtLeastElementsIn(errors); }
AllErrors implements Serializable { @Override public String toString() { return MoreObjects.toStringHelper(this) .add("errors", errors) .toString(); } AllErrors(); AllErrors(List<Error> errors); List<Error> getErrors(); void setErrors(final List<Error> errors); void addError(Error error); @Override String toString(); }
@Test void testToString() { AllErrors objectUnderTest = new AllErrors(); Error error = new Error(); objectUnderTest.addError(error); assertWithMessage("Must contain formatted string") .that(objectUnderTest.toString()).contains(error.toString()); }
Registry { public void register(ComponentKey registryKey, Class<? extends R> handler) { DEV_LOG.debug("Registering " + handler.getName() + " to '" + registryKey + "' for " + annotationClass.getSimpleName() + "."); if (registryMap.containsKey(registryKey)) { DEV_LOG.error("Duplicate registered handler for " + registryKey + " both " + registryMap.get(registryKey).getName() + " and " + handler.getName()); } registryMap.put(registryKey, handler); } Registry(Context context, Class<? extends Annotation> annotationClass); R get(TemplateId registryKey); Set<R> inclusiveGet(TemplateId registryKey); void register(ComponentKey registryKey, Class<? extends R> handler); int size(); }
@Test void testRegistryExistsByDefault() { try { registry.register(new ComponentKey(TemplateId.PLACEHOLDER, Program.ALL), Placeholder.class); } catch (NullPointerException e) { Assertions.fail("Registry should always exist."); } }
QrdaServiceImpl implements QrdaService { @Override public ConversionReport convertQrda3ToQpp(Source source) { Converter converter = initConverter(source); API_LOG.info("Performing QRDA3 to QPP conversion"); converter.transform(); return converter.getReport(); } QrdaServiceImpl(StorageService storageService); @PostConstruct void preloadMeasureConfigs(); @PostConstruct void loadCpcValidationData(); @PostConstruct void loadApmData(); @Override ConversionReport convertQrda3ToQpp(Source source); @Override InputStream retrieveCpcPlusValidationFile(); }
@Test void testConvertQrda3ToQppSuccess() { JsonWrapper qpp = objectUnderTest.convertQrda3ToQpp(MOCK_SUCCESS_QRDA_SOURCE).getEncodedWithMetadata(); assertThat(qpp.getString(KEY)).isSameInstanceAs(MOCK_SUCCESS_QPP_STRING); } @Test void testConvertQrda3ToQppError() { TransformException exception = assertThrows(TransformException.class, () -> objectUnderTest.convertQrda3ToQpp(MOCK_ERROR_QRDA_SOURCE)); AllErrors allErrors = exception.getDetails(); assertThat(allErrors.getErrors().get(0).getSourceIdentifier()).isSameInstanceAs(MOCK_ERROR_SOURCE_IDENTIFIER); }
Registry { Set<ComponentKey> getComponentKeys(Class<?> annotatedClass) { Annotation annotation = annotatedClass.getAnnotation(annotationClass); Set<ComponentKey> values = new HashSet<>(); if (annotation instanceof Decoder) { Decoder decoder = (Decoder) annotation; values.add(new ComponentKey(decoder.value(), decoder.program())); } if (annotation instanceof Encoder) { Encoder encoder = (Encoder) annotation; values.add(new ComponentKey(encoder.value(), encoder.program())); } if (annotation instanceof Validator) { Validator validator = (Validator) annotation; values.add(new ComponentKey(validator.value(), validator.program())); } return values; } Registry(Context context, Class<? extends Annotation> annotationClass); R get(TemplateId registryKey); Set<R> inclusiveGet(TemplateId registryKey); void register(ComponentKey registryKey, Class<? extends R> handler); int size(); }
@Test void testRegistry_getTemplateIds() { Set<ComponentKey> componentKeys = registry.getComponentKeys(AggregateCountDecoder.class); assertWithMessage("A componentKey is expected") .that(componentKeys).hasSize(1); for (ComponentKey componentKey : componentKeys) { assertWithMessage("The templateId should be") .that(componentKey.getTemplate()).isSameInstanceAs(TemplateId.PI_AGGREGATE_COUNT); } componentKeys = context.getRegistry(Encoder.class).getComponentKeys(AggregateCountEncoder.class); assertWithMessage("A componentKey is expected") .that(componentKeys).hasSize(1); for (ComponentKey componentKey : componentKeys) { assertWithMessage("The templateId should be") .that(componentKey.getTemplate()).isSameInstanceAs(TemplateId.PI_AGGREGATE_COUNT); } } @Test void testRegistry_getTemplateIds_NullReturn() { Set<ComponentKey> componentKeys = context.getRegistry(SuppressWarnings.class).getComponentKeys(Placeholder.class); assertWithMessage("A componentKey is not expected") .that(componentKeys).isEmpty(); }
Registry { public int size() { return registryMap.size(); } Registry(Context context, Class<? extends Annotation> annotationClass); R get(TemplateId registryKey); Set<R> inclusiveGet(TemplateId registryKey); void register(ComponentKey registryKey, Class<? extends R> handler); int size(); }
@Test void testSize() { assertThat(registry.size()).isGreaterThan(0); }
PathSource extends SkeletalSource { @Override public InputStream toInputStream() { try { return Files.newInputStream(path); } catch (IOException exception) { throw new UncheckedIOException(exception); } } PathSource(Path path); @Override InputStream toInputStream(); @Override long getSize(); @Override String getPurpose(); }
@Test void testInputStream() throws IOException { String content = IOUtils.toString(source.toInputStream(), StandardCharsets.UTF_8); assertWithMessage("stream content was not as expected") .that(content).isEqualTo("hello, world"); }
PathSource extends SkeletalSource { @Override public String getPurpose() { return null; } PathSource(Path path); @Override InputStream toInputStream(); @Override long getSize(); @Override String getPurpose(); }
@Test void testIsTest() { assertThat(source.getPurpose()).isNull(); }
QualityMeasureIdDecoder extends QrdaDecoder { @Override protected DecodeResult decode(Element element, Node thisNode) { List<String> measureGuids = getMeasureGuid(element); measureGuids.forEach(measureGuid -> thisNode.putValue(MEASURE_ID, measureGuid.toLowerCase(Locale.ENGLISH), false)); return DecodeResult.TREE_CONTINUE; } QualityMeasureIdDecoder(Context context); static final String MEASURE_ID; }
@Test void internalDecodeValid() throws XmlException { Node qualityMeasureIdNode = new Node(); Element qualityMeasureIdElement = XmlUtils.stringToDom(getXmlFragmentWithMeasureGuid("Measurement Id Value")); objectUnderTest.setNamespace(qualityMeasureIdElement.getNamespace()); objectUnderTest.decode(qualityMeasureIdElement, qualityMeasureIdNode); String value = qualityMeasureIdNode.getValue("measureId"); assertThat(value).isEqualTo("measurement id value"); } @Test void internalDecodeMissingId() throws XmlException { String xmlFragment = getXmlFragmentWithMeasureGuid("Measurement Id Value").replace("<id ", "<noid "); Node qualityMeasureIdNode = new Node(); Element qualityMeasureIdElement = XmlUtils.stringToDom(xmlFragment); objectUnderTest.setNamespace(qualityMeasureIdElement.getNamespace()); DecodeResult decodeResult = objectUnderTest.decode(qualityMeasureIdElement, qualityMeasureIdNode); assertThat(decodeResult).isEquivalentAccordingToCompareTo(DecodeResult.TREE_CONTINUE); String value = qualityMeasureIdNode.getValue("measureId"); assertThat(value).isNull(); } @Test void incorrectRoot() throws XmlException { Element qualityMeasureIdElement = XmlUtils.stringToDom(getBadXmlFragmentWithIncorrectRoot()); Node qualityMeasureIdNode = new Node(); objectUnderTest.setNamespace(qualityMeasureIdElement.getNamespace()); DecodeResult decodeResult = objectUnderTest.decode(qualityMeasureIdElement, qualityMeasureIdNode); assertThat(decodeResult).isEqualTo(DecodeResult.TREE_CONTINUE); assertThat(qualityMeasureIdNode.getValue("measureId")).isNull(); } @Test void dontIgnoreStratumMeasure() throws XmlException { String nonIgnorableGuid = "40280381-528a-60ff-0152-8e089ed20376"; Element qualityMeasureIdElement = XmlUtils.stringToDom(getXmlFragmentWithMeasureGuid(nonIgnorableGuid)); Node qualityMeasureIdNode = new Node(); objectUnderTest.setNamespace(qualityMeasureIdElement.getNamespace()); DecodeResult decodeResult = objectUnderTest.decode(qualityMeasureIdElement, qualityMeasureIdNode); assertThat(decodeResult) .isEqualTo(DecodeResult.TREE_CONTINUE); String value = qualityMeasureIdNode.getValue("measureId"); assertThat(value) .isEqualTo(nonIgnorableGuid); }
QrdaDecoderEngine extends XmlDecoderEngine { @Override public Node decode(Element xmlDoc) { Node rootNode = new Node(); Element rootElement = xmlDoc.getDocument().getRootElement(); defaultNs = rootElement.getNamespace(); rootNode.setType(TemplateId.PLACEHOLDER); rootNode.setElementForLocation(rootElement); addLineAndColumnToNode(rootElement, rootNode); QrdaDecoder rootDecoder = null; for (Element element : rootElement.getChildren(TEMPLATE_ID, rootElement.getNamespace())) { rootDecoder = getDecoder(getTemplateId(element)); if (rootDecoder != null) { break; } } if (rootDecoder != null) { rootNode = this.decodeTree(rootElement, rootNode).getNode().getChildNodes().get(0); } else { rootNode = this.decodeTree(rootElement, rootNode).getNode(); } return rootNode; } QrdaDecoderEngine(Context context); @Override Node decode(Element xmlDoc); }
@Test void topLevelNodeHasTemplateId() { Document document = new Document(); Element testElement = createGenericElement(); document.addContent(testElement); addChildToParent(testElement, createFinishElement()); QrdaDecoderEngine objectUnderTest = new QrdaDecoderEngine(context); Node node = objectUnderTest.decode(testElement); assertThat(node.getType()).isEqualTo(TemplateId.IA_SECTION); } @Test void topLevelNodeDoesntHaveTemplateId() { Document document = new Document(); Element testElement = createGenericElement(); document.addContent(testElement); Element secondLevelElement = createGenericElement(); addChildToParent(testElement, secondLevelElement); addChildToParent(secondLevelElement, createFinishElement()); QrdaDecoderEngine objectUnderTest = new QrdaDecoderEngine(context); Node node = objectUnderTest.decode(testElement); assertThat(node.getType()).isEqualTo(TemplateId.PLACEHOLDER); assertThat(node.getChildNodes().get(0).getType()).isEqualTo(TemplateId.IA_SECTION); } @Test void continueThenContinueThenFinish() { Element rootElement = createRootElement(); Element secondLevelElement = createContinueElement(); Element middleElement = createGenericElement(); Element thirdLevelElement = createContinueElement(); Element fourthLevelElement = createFinishElement(); addChildToParent(rootElement, secondLevelElement); addChildToParent(secondLevelElement, middleElement); addChildToParent(middleElement, thirdLevelElement); addChildToParent(thirdLevelElement, fourthLevelElement); QrdaDecoderEngine objectUnderTest = new QrdaDecoderEngine(context); Node node = objectUnderTest.decode(rootElement); assertDecodeResultCount(2, 1, 0); assertNodeCount(node, 2, 1, 0); } @Test void continueThenContinueAndEscapeAndContinueWhichStopsDecodingSiblings() { Element rootElement = createRootElement(); Element secondLevelElement = createContinueElement(); Element middleElement = createGenericElement(); Element thirdLevelOneElement = createContinueElement(); Element thirdLevelTwoElement = createEscapeElement(); Element thirdLevelThreeElement = createContinueElement(); addChildToParent(rootElement, secondLevelElement); addChildToParent(secondLevelElement, middleElement); addChildToParent(middleElement, thirdLevelOneElement); addChildToParent(middleElement, thirdLevelTwoElement); addChildToParent(middleElement, thirdLevelThreeElement); QrdaDecoderEngine objectUnderTest = new QrdaDecoderEngine(context); Node node = objectUnderTest.decode(rootElement); assertDecodeResultCount(2, 0, 1); assertNodeCount(node, 2, 0, 0); } @Test void continueThenContinueAndFinishAndContinueWhichStopsDecodingSiblings() { Element rootElement = createRootElement(); Element secondLevelElement = createContinueElement(); Element middleElement = createGenericElement(); Element thirdLevelOneElement = createContinueElement(); Element thirdLevelTwoElement = createFinishElement(); Element thirdLevelThreeElement = createContinueElement(); addChildToParent(rootElement, secondLevelElement); addChildToParent(secondLevelElement, middleElement); addChildToParent(middleElement, thirdLevelOneElement); addChildToParent(middleElement, thirdLevelTwoElement); addChildToParent(middleElement, thirdLevelThreeElement); QrdaDecoderEngine objectUnderTest = new QrdaDecoderEngine(context); Node node = objectUnderTest.decode(rootElement); assertDecodeResultCount(2, 1, 0); assertNodeCount(node, 2, 1, 0); } @Test void continueThenContinueAndEscapeThenFinishWhichStopsDecodingChildren() { Element rootElement = createRootElement(); Element secondLevelElement = createContinueElement(); Element middleElement = createGenericElement(); Element thirdLevelOneElement = createContinueElement(); Element thirdLevelTwoElement = createEscapeElement(); Element fourthLevelElement = createFinishElement(); addChildToParent(rootElement, secondLevelElement); addChildToParent(secondLevelElement, middleElement); addChildToParent(middleElement, thirdLevelOneElement); addChildToParent(middleElement, thirdLevelTwoElement); addChildToParent(thirdLevelTwoElement, fourthLevelElement); QrdaDecoderEngine objectUnderTest = new QrdaDecoderEngine(context); Node node = objectUnderTest.decode(rootElement); assertDecodeResultCount(2, 0, 1); assertNodeCount(node, 2, 0, 0); } @Test void continueThenContinueAndFinishThenFinishWhichStopsDecodingChildren() { Element rootElement = createRootElement(); Element secondLevelElement = createContinueElement(); Element middleElement = createGenericElement(); Element thirdLevelOneElement = createContinueElement(); Element thirdLevelTwoElement = createFinishElement(); Element fourthLevelElement = createFinishElement(); addChildToParent(rootElement, secondLevelElement); addChildToParent(secondLevelElement, middleElement); addChildToParent(middleElement, thirdLevelOneElement); addChildToParent(middleElement, thirdLevelTwoElement); addChildToParent(thirdLevelTwoElement, fourthLevelElement); QrdaDecoderEngine objectUnderTest = new QrdaDecoderEngine(context); Node node = objectUnderTest.decode(rootElement); assertDecodeResultCount(2, 1, 0); assertNodeCount(node, 2, 1, 0); } @Test void noDecoderWhichActsAsContinue() { Element rootElement = createRootElement(); Element secondLevelElement = createContinueElement(); Element middleElement = createGenericElement(); Element thirdLevelOneElement = createNoDecoderElement(); Element thirdLevelTwoElement = createFinishElement(); addChildToParent(rootElement, secondLevelElement); addChildToParent(secondLevelElement, middleElement); addChildToParent(middleElement, thirdLevelOneElement); addChildToParent(middleElement, thirdLevelTwoElement); QrdaDecoderEngine objectUnderTest = new QrdaDecoderEngine(context); Node node = objectUnderTest.decode(rootElement); assertDecodeResultCount(1, 1, 0); assertNodeCount(node, 1, 1, 0); }
QrdaDecoderEngine extends XmlDecoderEngine { @Override protected boolean accepts(Element xmlDoc) { final Element rootElement = xmlDoc.getDocument().getRootElement(); boolean isValidQrdaFile = containsClinicalDocumentElement(rootElement) && containsClinicalDocumentTemplateId(rootElement); if (!isValidQrdaFile) { DEV_LOG.error(NOT_VALID_QRDA_III_FORMAT); } return isValidQrdaFile; } QrdaDecoderEngine(Context context); @Override Node decode(Element xmlDoc); }
@Test void testAcceptsFailureDueToNoTemplateId() { Element rootElement = createRootElement(); QrdaDecoderEngine objectUnderTest = new QrdaDecoderEngine(context); assertThat(objectUnderTest.accepts(rootElement)).isFalse(); } @Test void testAcceptsFailureDueToIncorrectTemplateId() { Element rootElement = createRootElement(); rootElement.getParentElement().getChildren().add(createContinueElement()); QrdaDecoderEngine objectUnderTest = new QrdaDecoderEngine(context); assertThat(objectUnderTest.accepts(rootElement)).isFalse(); } @Test void testAcceptsFailureDueToNoClinicalDocumentElement() { Element rootElement = createRootElement(); Element clinicalDocumentTemplateIdElement = new Element(TEMPLATE_ID); clinicalDocumentTemplateIdElement.setAttribute(ROOT, TemplateId.CLINICAL_DOCUMENT.getRoot()); rootElement.getParentElement().getChildren().add(clinicalDocumentTemplateIdElement); rootElement.getParentElement().setName("somethingElse"); QrdaDecoderEngine objectUnderTest = new QrdaDecoderEngine(context); assertThat(objectUnderTest.accepts(rootElement)).isFalse(); } @Test void testAcceptsSuccess() { Element rootElement = createRootElement(); Element clinicalDocumentTemplateIdElement = new Element(TEMPLATE_ID); clinicalDocumentTemplateIdElement.setAttribute(ROOT, TemplateId.CLINICAL_DOCUMENT.getRoot()); clinicalDocumentTemplateIdElement.setAttribute(EXTENSION, TemplateId.CLINICAL_DOCUMENT.getExtension()); rootElement.getParentElement().getChildren().add(clinicalDocumentTemplateIdElement); QrdaDecoderEngine objectUnderTest = new QrdaDecoderEngine(context); assertThat(objectUnderTest.accepts(rootElement)).isTrue(); }
QrdaServiceImpl implements QrdaService { @PostConstruct public void preloadMeasureConfigs() { MeasureConfigs.init(); } QrdaServiceImpl(StorageService storageService); @PostConstruct void preloadMeasureConfigs(); @PostConstruct void loadCpcValidationData(); @PostConstruct void loadApmData(); @Override ConversionReport convertQrda3ToQpp(Source source); @Override InputStream retrieveCpcPlusValidationFile(); }
@Test void testPostConstructForCoverage() { objectUnderTest.preloadMeasureConfigs(); }
QrdaDecoderEngine extends XmlDecoderEngine { private List<Element> getUniqueTemplateIdElements(final List<Element> childElements) { Set<TemplateId> uniqueTemplates = EnumSet.noneOf(TemplateId.class); List<Element> children = childElements.stream() .filter(filterElement -> { boolean isTemplateId = TEMPLATE_ID.equals(filterElement.getName()); TemplateId filterTemplateId = getTemplateId(filterElement); boolean elementWillStay = true; if (isTemplateId) { if (getDecoder(filterTemplateId) == null || uniqueTemplates.contains(filterTemplateId)) { elementWillStay = false; } uniqueTemplates.add(filterTemplateId); } return elementWillStay; }) .collect(Collectors.toList()); return (uniqueTemplates.isEmpty() || uniqueTemplates.stream().anyMatch(template -> TemplateId.UNIMPLEMENTED != template)) ? children : new ArrayList<>(); } QrdaDecoderEngine(Context context); @Override Node decode(Element xmlDoc); }
@Test void testGetUniqueTemplateIdElements() { Element rootElement = createRootElement(); Element middleElement = createGenericElement(); Element initialTemplateIdElement = createContinueElement(); Element duplicateTemplateIdElement = createContinueElement(); Element fourthLevelElement = createGenericElement(); Element fifthLevelElement = createFinishElement(); addChildToParent(rootElement, middleElement); addChildToParent(middleElement, initialTemplateIdElement); addChildToParent(middleElement, duplicateTemplateIdElement); addChildToParent(middleElement, fourthLevelElement); addChildToParent(fourthLevelElement, fifthLevelElement); QrdaDecoderEngine objectUnderTest = new QrdaDecoderEngine(context); Node decodedNodes = objectUnderTest.decode(rootElement); assertNodeCount(decodedNodes, 1, 1, 0); }
PiMeasurePerformedRnRDecoder extends QrdaDecoder { @Override protected DecodeResult decode(Element element, Node thisNode) { setMeasureIdOnNode(element, thisNode); return DecodeResult.TREE_CONTINUE; } PiMeasurePerformedRnRDecoder(Context context); static final String MEASURE_ID; }
@Test void internalDecodeReturnsTreeContinue() { PiMeasurePerformedRnRDecoder objectUnderTest = new PiMeasurePerformedRnRDecoder(new Context()); Namespace rootns = Namespace.getNamespace("urn:hl7-org:v3"); Namespace ns = Namespace.getNamespace("xsi", "http: Element element = new Element("organizer", rootns); Element templateIdElement = new Element("templateId", rootns).setAttribute("root","2.16.840.1.113883.10.20.27.3.28"); Element referenceElement = new Element("reference", rootns); Element externalDocumentElement = new Element("externalDocument", rootns); Element idElement = new Element("id", rootns).setAttribute("extension", MEASURE_ID); externalDocumentElement.addContent(idElement); referenceElement.addContent(externalDocumentElement); element.addContent(templateIdElement); element.addContent(referenceElement); element.addNamespaceDeclaration(ns); Node piMeasurePerformedNode = new Node(); objectUnderTest.setNamespace(element.getNamespace()); DecodeResult decodeResult = objectUnderTest.decode(element, piMeasurePerformedNode); assertThat(decodeResult) .isEqualTo(DecodeResult.TREE_CONTINUE); String actualMeasureId = piMeasurePerformedNode.getValue("measureId"); assertThat(actualMeasureId) .isEqualTo(MEASURE_ID); } @Test void testUpperLevel() throws XmlException, IOException { String needsFormattingXml = TestHelper.getFixture("AciMeasurePerformedIsolated.xml"); String xml = String.format(needsFormattingXml, MEASURE_ID); Node wrapperNode = new QrdaDecoderEngine(new Context()).decode(XmlUtils.stringToDom(xml)); Node piMeasurePerformedNode = wrapperNode.getChildNodes().get(0); String actualMeasureId = piMeasurePerformedNode.getValue("measureId"); assertThat(actualMeasureId).isEqualTo(MEASURE_ID); long measurePerformedCount = piMeasurePerformedNode.getChildNodes( node -> node.getType() == TemplateId.MEASURE_PERFORMED).count(); assertThat(measurePerformedCount) .isEqualTo(1L); }
ClinicalDocumentDecoder extends QrdaDecoder { @Override protected DecodeResult decode(Element element, Node thisNode) { setProgramNameOnNode(element, thisNode); setEntityIdOnNode(element, thisNode); setPracticeSiteAddress(element, thisNode); setCehrtOnNode(element, thisNode); String entityType = thisNode.getValue(ENTITY_TYPE); if (ENTITY_APM.equalsIgnoreCase(entityType)){ setMultipleNationalProviderIdsOnNode(element, thisNode); setMultipleTaxProviderTaxIdsOnNode(element, thisNode); } else { setTaxProviderTaxIdOnNode(element, thisNode); if (ENTITY_INDIVIDUAL.equals(entityType)) { setNationalProviderIdOnNode(element, thisNode); } if (ENTITY_VIRTUAL_GROUP.equals(entityType)) { setVirtualGroupOnNode(element, thisNode); } } return DecodeResult.TREE_CONTINUE; } ClinicalDocumentDecoder(Context context); static final String NATIONAL_PROVIDER_IDENTIFIER; static final String TAX_PAYER_IDENTIFICATION_NUMBER; static final String PROGRAM_NAME; static final String RAW_PROGRAM_NAME; static final String ENTITY_TYPE; static final String MIPS_PROGRAM_NAME; static final String CPCPLUS_PROGRAM_NAME; static final String PRACTICE_ID; static final String PRACTICE_SITE_ADDR; static final String CEHRT; static final String MIPS; static final String MIPS_VIRTUAL_GROUP; static final String MIPS_APM; static final String ENTITY_APM; static final String ENTITY_VIRTUAL_GROUP; static final String ENTITY_ID; static final String CPCPLUS; }
@Test void testClinicalDocumentIgnoresGarbage() throws IOException, XmlException { InputStream stream = ClasspathHelper.contextClassLoader().getResourceAsStream("QRDA-III-with-extra-elements.xml"); String xmlWithGarbage = IOUtils.toString(stream, StandardCharsets.UTF_8); Node root = new QrdaDecoderEngine(new Context()).decode(XmlUtils.stringToDom(xmlWithGarbage)); clinicalDocument = root.findFirstNode(TemplateId.CLINICAL_DOCUMENT); assertThat(clinicalDocument.getValue(ClinicalDocumentDecoder.PROGRAM_NAME)) .isEqualTo(ClinicalDocumentDecoder.MIPS_PROGRAM_NAME); assertThat(clinicalDocument.getValue(ClinicalDocumentDecoder.TAX_PAYER_IDENTIFICATION_NUMBER)) .isEqualTo("123456789"); } @Test void decodeClinicalDocumentInternalDecode() { Element clinicalDocument = makeClinicalDocument("MIPS"); Node testParentNode = new Node(); ClinicalDocumentDecoder objectUnderTest = new ClinicalDocumentDecoder(new Context()); objectUnderTest.setNamespace(clinicalDocument.getNamespace()); objectUnderTest.decode(clinicalDocument, testParentNode); assertWithMessage("Clinical Document doesn't contain program name") .that(testParentNode.getValue(ClinicalDocumentDecoder.PROGRAM_NAME)) .isEqualTo(ClinicalDocumentDecoder.MIPS_PROGRAM_NAME); assertWithMessage("Clinical Document doesn't contain entity type") .that(testParentNode.getValue(ClinicalDocumentDecoder.ENTITY_TYPE)) .isEqualTo(ClinicalDocumentDecoder.ENTITY_INDIVIDUAL); assertWithMessage("Clinical Document doesn't contain national provider") .that(testParentNode.getValue(ClinicalDocumentDecoder.NATIONAL_PROVIDER_IDENTIFIER)) .isEqualTo("2567891421"); assertWithMessage("Clinical Document doesn't contain taxpayer id number") .that(testParentNode.getValue(ClinicalDocumentDecoder.TAX_PAYER_IDENTIFICATION_NUMBER)) .isEqualTo("123456789"); } @Test void decodeClinicalDocumentInternalDecodeMIPSIndividual() { Element clinicalDocument = makeClinicalDocument("MIPS_INDIV"); Node testParentNode = new Node(); ClinicalDocumentDecoder objectUnderTest = new ClinicalDocumentDecoder(new Context()); objectUnderTest.setNamespace(clinicalDocument.getNamespace()); objectUnderTest.decode(clinicalDocument, testParentNode); assertWithMessage("Clinical Document doesn't contain program name") .that(testParentNode.getValue(ClinicalDocumentDecoder.PROGRAM_NAME)) .isEqualTo(ClinicalDocumentDecoder.MIPS_PROGRAM_NAME); assertWithMessage("Clinical Document doesn't contain entity type") .that(testParentNode.getValue(ClinicalDocumentDecoder.ENTITY_TYPE)) .isEqualTo(ClinicalDocumentDecoder.ENTITY_INDIVIDUAL); assertWithMessage("Clinical Document doesn't contain national provider") .that(testParentNode.getValue(ClinicalDocumentDecoder.NATIONAL_PROVIDER_IDENTIFIER)) .isEqualTo("2567891421"); assertWithMessage("Clinical Document doesn't contain taxpayer id number") .that(testParentNode.getValue(ClinicalDocumentDecoder.TAX_PAYER_IDENTIFICATION_NUMBER)) .isEqualTo("123456789"); } @Test void decodeClinicalDocumentInternalDecodeMIPSGroup() { Element clinicalDocument = makeClinicalDocument("MIPS_GROUP"); Node testParentNode = new Node(); ClinicalDocumentDecoder objectUnderTest = new ClinicalDocumentDecoder(new Context()); objectUnderTest.setNamespace(clinicalDocument.getNamespace()); objectUnderTest.decode(clinicalDocument, testParentNode); assertWithMessage("Clinical Document doesn't contain program name") .that(testParentNode.getValue(ClinicalDocumentDecoder.PROGRAM_NAME)) .isEqualTo(ClinicalDocumentDecoder.MIPS_PROGRAM_NAME); assertWithMessage("Clinical Document doesn't contain entity type") .that(testParentNode.getValue(ClinicalDocumentDecoder.ENTITY_TYPE)) .isEqualTo(ClinicalDocumentDecoder.ENTITY_GROUP); assertWithMessage("Clinical Document doesn't contain national provider") .that(testParentNode.getValue(ClinicalDocumentDecoder.NATIONAL_PROVIDER_IDENTIFIER)) .isNull(); assertWithMessage("Clinical Document doesn't contain taxpayer id number") .that(testParentNode.getValue(ClinicalDocumentDecoder.TAX_PAYER_IDENTIFICATION_NUMBER)) .isEqualTo("123456789"); } @Test void decodeClinicalDocumentInternalDecodeCPCPlus() { Element clinicalDocument = makeClinicalDocument(ClinicalDocumentDecoder.CPCPLUS); Node testParentNode = new Node(); ClinicalDocumentDecoder objectUnderTest = new ClinicalDocumentDecoder(new Context()); objectUnderTest.setNamespace(clinicalDocument.getNamespace()); objectUnderTest.decode(clinicalDocument, testParentNode); assertWithMessage("Clinical Document doesn't contain program name") .that(testParentNode.getValue(ClinicalDocumentDecoder.PROGRAM_NAME)) .isEqualTo(ClinicalDocumentDecoder.CPCPLUS_PROGRAM_NAME); assertWithMessage("Clinical Document doesn't contain entity type") .that(testParentNode.getValue(ClinicalDocumentDecoder.ENTITY_TYPE)) .isEqualTo(ClinicalDocumentDecoder.ENTITY_APM); } @Test void decodeClinicalDocumentInternalDecodeUnknown() { Element clinicalDocument = makeClinicalDocument("Unknown"); Node testParentNode = new Node(); ClinicalDocumentDecoder objectUnderTest = new ClinicalDocumentDecoder(new Context()); objectUnderTest.setNamespace(clinicalDocument.getNamespace()); objectUnderTest.decode(clinicalDocument, testParentNode); assertWithMessage("Clinical Document doesn't contain program name") .that(testParentNode.getValue(ClinicalDocumentDecoder.PROGRAM_NAME)) .isEqualTo("unknown"); assertWithMessage("Clinical Document doesn't contain entity type") .that(testParentNode.getValue(ClinicalDocumentDecoder.ENTITY_TYPE)) .isEqualTo("individual"); assertWithMessage("Clinical Document doesn't contain national provider") .that(testParentNode.getValue(ClinicalDocumentDecoder.NATIONAL_PROVIDER_IDENTIFIER)) .isEqualTo("2567891421"); assertWithMessage("Clinical Document doesn't contain taxpayer id number") .that(testParentNode.getValue(ClinicalDocumentDecoder.TAX_PAYER_IDENTIFICATION_NUMBER)) .isEqualTo("123456789"); } @Test void decodeCpcPlusEntityIdTest() { Element clinicalDocument = makeClinicalDocument(ClinicalDocumentDecoder.CPCPLUS_PROGRAM_NAME); clinicalDocument.addContent(prepareParticipant(clinicalDocument.getNamespace())); Node testParentNode = new Node(); ClinicalDocumentDecoder objectUnderTest = new ClinicalDocumentDecoder(new Context()); objectUnderTest.setNamespace(clinicalDocument.getNamespace()); objectUnderTest.decode(clinicalDocument, testParentNode); assertWithMessage("Clinical Document contains the Entity Id") .that(testParentNode.getValue(ClinicalDocumentDecoder.PRACTICE_ID)) .isEqualTo(ENTITY_ID_VALUE); } @Test void decodeCpcPracticeSiteAddressTest() { Element clinicalDocument = makeClinicalDocument(ClinicalDocumentDecoder.CPCPLUS_PROGRAM_NAME); clinicalDocument.addContent( prepareParticipant( clinicalDocument.getNamespace()) ); Node testParentNode = new Node(); ClinicalDocumentDecoder objectUnderTest = new ClinicalDocumentDecoder(new Context()); objectUnderTest.setNamespace(clinicalDocument.getNamespace()); objectUnderTest.decode(clinicalDocument, testParentNode); assertWithMessage("Clinical Document contains the Entity Id") .that(testParentNode.getValue(ClinicalDocumentDecoder.PRACTICE_SITE_ADDR)) .isEqualTo("testing123"); } @Test void decodeCpcTinTest() { Element clinicalDocument = makeClinicalDocument(ClinicalDocumentDecoder.CPCPLUS_PROGRAM_NAME); clinicalDocument.addContent( prepareParticipant(clinicalDocument.getNamespace()) ); Node testParentNode = new Node(); ClinicalDocumentDecoder objectUnderTest = new ClinicalDocumentDecoder(new Context()); objectUnderTest.setNamespace(clinicalDocument.getNamespace()); objectUnderTest.decode(clinicalDocument, testParentNode); List<String> tinNumbers = Arrays.asList(testParentNode.getValue(ClinicalDocumentDecoder.TAX_PAYER_IDENTIFICATION_NUMBER).split(",")); tinNumbers.forEach(tinNumber -> assertThat(tinNumber).isNotEmpty()); } @Test void decodeCpcNpiTest() { Element clinicalDocument = makeClinicalDocument(ClinicalDocumentDecoder.CPCPLUS_PROGRAM_NAME); clinicalDocument.addContent( prepareParticipant( clinicalDocument.getNamespace()) ); Node testParentNode = new Node(); ClinicalDocumentDecoder objectUnderTest = new ClinicalDocumentDecoder(new Context()); objectUnderTest.setNamespace(clinicalDocument.getNamespace()); objectUnderTest.decode(clinicalDocument, testParentNode); List<String> npiNumbers = Arrays.asList(testParentNode.getValue(ClinicalDocumentDecoder.NATIONAL_PROVIDER_IDENTIFIER).split(",")); npiNumbers.forEach(npiNumber -> assertThat(npiNumber).isNotEmpty()); } @Test void decodeMipsVirtualGroup() { Element clinicalDocument = makeClinicalDocument(ClinicalDocumentDecoder.MIPS_VIRTUAL_GROUP); Node testParentNode = new Node(); ClinicalDocumentDecoder objectUnderTest = new ClinicalDocumentDecoder(new Context()); objectUnderTest.setNamespace(clinicalDocument.getNamespace()); objectUnderTest.decode(clinicalDocument, testParentNode); assertThat(testParentNode.getValue(ClinicalDocumentDecoder.ENTITY_TYPE)) .isEqualTo(ClinicalDocumentDecoder.ENTITY_VIRTUAL_GROUP); assertThat(testParentNode.getValue(ClinicalDocumentDecoder.ENTITY_ID)) .isEqualTo("x12345"); }
ValidationServiceImpl implements ValidationService { @Override public void validateQpp(ConversionReport conversionReport) { String validationUrl = environment.getProperty(Constants.VALIDATION_URL_ENV_VARIABLE); if (StringUtils.isEmpty(validationUrl)) { return; } JsonWrapper wrapper = conversionReport.getEncodedWithMetadata(); ResponseEntity<String> validationResponse = callValidationEndpoint(validationUrl, wrapper.copyWithoutMetadata()); if (HttpStatus.UNPROCESSABLE_ENTITY == validationResponse.getStatusCode()) { API_LOG.warn("Failed QPP validation"); AllErrors convertedErrors = convertQppValidationErrorsToQrda(validationResponse.getBody(), wrapper); conversionReport.setRawValidationDetails(validationResponse.getBody()); conversionReport.setReportDetails(convertedErrors); throw new QppValidationException("Converted QPP failed validation", null, conversionReport); } } ValidationServiceImpl(final Environment environment); @PostConstruct void checkForValidationUrlVariable(); @Override void validateQpp(ConversionReport conversionReport); static final String SV_LABEL; }
@Test void testNullValidationUrl() { when(environment.getProperty(eq(Constants.VALIDATION_URL_ENV_VARIABLE))).thenReturn(null); objectUnderTest.validateQpp(null); verifyNoInteractions(restTemplate); } @Test void testEmptyValidationUrl() { when(environment.getProperty(eq(Constants.VALIDATION_URL_ENV_VARIABLE))).thenReturn(""); objectUnderTest.validateQpp(null); verifyNoInteractions(restTemplate); } @Test void testValidationPass() { String validationUrl = "https: when(environment.getProperty(eq(Constants.VALIDATION_URL_ENV_VARIABLE))).thenReturn(validationUrl); ResponseEntity<String> spiedResponseEntity = spy(new ResponseEntity<>(HttpStatus.OK)); when(restTemplate.postForEntity(eq(validationUrl), any(HttpEntity.class), eq(String.class))).thenReturn(spiedResponseEntity); objectUnderTest.validateQpp(converter.getReport()); verify(spiedResponseEntity, never()).getBody(); } @Test void testValidationFail() throws IOException { String validationUrl = "https: when(environment.getProperty(eq(Constants.VALIDATION_URL_ENV_VARIABLE))).thenReturn(validationUrl); ResponseEntity<String> spiedResponseEntity = spy(new ResponseEntity<>(FileUtils.readFileToString(pathToSubmissionError.toFile(), "UTF-8") ,HttpStatus.UNPROCESSABLE_ENTITY)); when(restTemplate.postForEntity(eq(validationUrl), any(HttpEntity.class), eq(String.class))).thenReturn(spiedResponseEntity); TransformException thrown = assertThrows(TransformException.class, () -> objectUnderTest.validateQpp(converter.getReport())); assertThat(thrown).hasMessageThat().isEqualTo("Converted QPP failed validation"); }
AggregateCountDecoder extends QrdaDecoder { @Override protected DecodeResult decode(Element element, Node thisnode) { setSciNumeratorDenominatorOnNode(element, thisnode); return DecodeResult.TREE_FINISHED; } AggregateCountDecoder(Context context); static final String AGGREGATE_COUNT; }
@Test void testInternalDecode() { Namespace rootNs = Namespace.getNamespace("urn:hl7-org:v3"); Namespace ns = Namespace.getNamespace("xsi", "http: Context context = new Context(); Element element = new Element("observation", rootNs); element.addContent(new Element("templateId", rootNs).setAttribute("root", TemplateId.PI_AGGREGATE_COUNT.getTemplateId(context))); element.addContent(new Element("value", rootNs).setAttribute("value", "450").setAttribute("type", "INT", ns)); element.addNamespaceDeclaration(ns); Node thisNode = new Node(); AggregateCountDecoder instance = new AggregateCountDecoder(context); instance.setNamespace(element.getNamespace()); instance.decode(element, thisNode); assertThat(thisNode.getValue("aggregateCount")) .isEqualTo("450"); } @Test void testAggregateCountDecoderIgnoresInvalidElements() throws XmlException { Node root = new QrdaDecoderEngine(new Context()).decode(XmlUtils.stringToDom(XML_FRAGMENT)); Node node = root.getChildNodes().get(0); assertThat(node.getChildNodes()).hasSize(1); assertThat(node.getChildNodes().get(0).getValue("aggregateCount")) .isEqualTo("400"); assertWithMessage("Should have template id") .that(node.getChildNodes().get(0).getType()) .isEqualTo(TemplateId.PI_AGGREGATE_COUNT); } @Test void testAggregateCountDecoderIgnoresInvalidElementsPartTwo() throws XmlException { Node root = new QrdaDecoderEngine(new Context()).decode(XmlUtils.stringToDom(ANOTHER_XML_FRAGMENT)); assertWithMessage("Node has aggregate count") .that(root.getValue("aggregateCount")) .isEqualTo("400"); assertWithMessage("Should have template id") .that(root.getType()).isEqualTo(TemplateId.PI_AGGREGATE_COUNT); } @Test void testDuplicateAggregateCountDecodesToDuplicateAggregateCount() throws XmlException { Node root = new QrdaDecoderEngine(new Context()).decode(XmlUtils.stringToDom(DUPLICATE_AGGREGATE_COUNT)); assertThat(root.getChildNodes().get(0).getChildNodes(TemplateId.PI_AGGREGATE_COUNT).count()).isEqualTo(2); }
IaMeasureDecoder extends QrdaDecoder { @Override protected DecodeResult decode(Element element, Node thisNode) { String expressionStr = getXpath("measureId"); Consumer<? super Attribute> consumer = p -> thisNode.putValue("measureId", p.getValue()); setOnNode(element, expressionStr, consumer, Filters.attribute(), true); return DecodeResult.TREE_CONTINUE; } IaMeasureDecoder(Context context); }
@Test void internalDecode() throws Exception { QrdaDecoderEngine engine = new QrdaDecoderEngine(new Context()); Node root = engine.decode(XmlUtils.stringToDom(xmlFragment)); Node iaMeasure = root.findFirstNode(TemplateId.IA_MEASURE); Node measurePerformed = root.findFirstNode(TemplateId.MEASURE_PERFORMED); String value = measurePerformed.getValue("measurePerformed"); assertThat(iaMeasure.getValue("measureId")) .isEqualTo("IA_EPA_1"); assertThat(measurePerformed.getType()) .isEqualTo(TemplateId.MEASURE_PERFORMED); assertThat(value) .isEqualTo("Y"); } @Test void missingChildTest() throws Exception { xmlFragment = removeChildFragment(xmlFragment); QrdaDecoderEngine engine = new QrdaDecoderEngine(new Context()); Node root = engine.decode(XmlUtils.stringToDom(xmlFragment)); Node iaMeasure = root.findFirstNode(TemplateId.IA_MEASURE); assertThat(iaMeasure.getType()) .isEquivalentAccordingToCompareTo(TemplateId.IA_MEASURE); assertThat(iaMeasure.getChildNodes()) .hasSize(0); } @Test void internalDecodeWithExtraXmlPasses() throws Exception { QrdaDecoderEngine engine = new QrdaDecoderEngine(new Context()); xmlFragment = addExtraXml(xmlFragment); Node root = engine.decode(XmlUtils.stringToDom(xmlFragment)); Node iaMeasure = root.findFirstNode(TemplateId.IA_MEASURE); Node measurePerformed = root.findFirstNode(TemplateId.MEASURE_PERFORMED); String value = measurePerformed.getValue("measurePerformed"); assertThat(iaMeasure.getValue("measureId")) .isEqualTo("IA_EPA_1"); assertThat(measurePerformed.getType()) .isEqualTo(TemplateId.MEASURE_PERFORMED); assertThat(value) .isEqualTo("Y"); }
PiNumeratorDenominatorDecoder extends QrdaDecoder { @Override protected DecodeResult decode(Element element, Node thisNode) { setMeasureIdOnNode(element, thisNode); return DecodeResult.TREE_CONTINUE; } PiNumeratorDenominatorDecoder(Context context); }
@Test void decodeAggregateCountAsNode() throws Exception { String xmlFragment = XmlUtils.buildString( "<root xmlns:xsi=\"http: " <observation classCode=\"OBS\" moodCode=\"EVN\">", " <templateId root=\"2.16.840.1.113883.10.20.27.3.3\"/>", " <code code=\"MSRAGG\" codeSystem=\"2.16.840.1.113883.5.4\" codeSystemName=\"ActCode\" displayName=\"rate aggregation\"/>", " <statusCode code=\"completed\"/>", " <value xsi:type=\"INT\" value=\"600\"/>", " <methodCode code=\"COUNT\" codeSystem=\"2.16.840.1.113883.5.84\" codeSystemName=\"ObservationMethod\" displayName=\"Count\"/>", " </observation>", "</root>"); Node aggregateCountNode = new QrdaDecoderEngine(new Context()).decode(XmlUtils.stringToDom(xmlFragment)); assertThat(aggregateCountNode.getChildNodes().get(0).getValue("aggregateCount")) .isEqualTo("600"); } @Test void decodePiNumeratorDenominatorNullValueAsNode() throws Exception { String xmlFragment = XmlUtils.buildString( "<root xmlns:xsi=\"http: " <observation classCode=\"OBS\" moodCode=\"EVN\">", " <templateId root=\"2.16.840.1.113883.10.20.27.3.3\"/>", " <value xsi:type=\"INT\"/>", " </observation>", "</root>"); Node numDenomNode = new QrdaDecoderEngine(new Context()).decode(XmlUtils.stringToDom(xmlFragment)); assertWithMessage("pi numerator/denominator value should be null") .that(numDenomNode.getChildNodes().get(0).getValue("aggregateCount")).isNull(); } @Test void decodeAciNumeratorDenominatorNullElementAsNode() throws Exception { String xmlFragment = XmlUtils.buildString( "<root xmlns:xsi=\"http: " <observation classCode=\"OBS\" moodCode=\"EVN\">", " <templateId root=\"2.16.840.1.113883.10.20.27.3.3\"/>", " </observation>", "</root>"); Node numDenomNode = new QrdaDecoderEngine(new Context()).decode(XmlUtils.stringToDom(xmlFragment)); assertWithMessage("po numerator/denominator value should be null") .that(numDenomNode.getChildNodes().get(0).getValue("aggregateCount")).isNull(); } @Test void decodeValidAciNumeratorDenominatorTest() throws XmlException { Node piMeasureNode = new QrdaDecoderEngine(new Context()).decode(XmlUtils.stringToDom(getValidXmlFragment())); Node numeratorDenominatorNode = piMeasureNode.getChildNodes().get(0); int numberNodes = countNodes(piMeasureNode); List<Node> nodeList = piMeasureNode.findNode(TemplateId.PI_NUMERATOR); assertThat(numeratorDenominatorNode.getValue("measureId")) .isEqualTo(MEASURE_ID); assertThat(numeratorDenominatorNode.getChildNodes().get(0).getType()) .isEqualTo(TemplateId.PI_NUMERATOR); assertThat(numeratorDenominatorNode.getChildNodes().get(1).getType()) .isEqualTo(TemplateId.PI_DENOMINATOR); nodeList = nodeList.get(0).findNode(TemplateId.PI_AGGREGATE_COUNT); assertWithMessage("Decoded xml fragment %s should contain %s", TemplateId.PI_NUMERATOR.name(), TemplateId.PI_AGGREGATE_COUNT.name()) .that(nodeList).hasSize(1); nodeList = piMeasureNode.findNode(TemplateId.PI_DENOMINATOR); assertWithMessage("Decoded xml fragment should contain %s", TemplateId.PI_DENOMINATOR.name()) .that(nodeList).hasSize(1); nodeList = nodeList.get(0).findNode(TemplateId.PI_AGGREGATE_COUNT); assertWithMessage("Decoded xml fragment %s should contain %s", TemplateId.PI_NUMERATOR.name(), TemplateId.PI_AGGREGATE_COUNT.name()) .that(nodeList).hasSize(1); assertWithMessage("Decoded xml fragment %s should contain 6 nodes", piMeasureNode.getType().name()) .that(numberNodes).isEqualTo(6); assertWithMessage("measureId should be %s", MEASURE_ID) .that(numeratorDenominatorNode.getValue("measureId")) .isEqualTo(MEASURE_ID); } @Test void decodePiNumeratorDenominatorExtraneousXMLTest() throws XmlException { String xmlFragment = getValidXmlFragment(); xmlFragment = xmlFragment.replaceAll("<statusCode ", "\n<Stuff arbitrary=\"123\"><newnode>Some extra stuff</newnode></Stuff>Unexpected stuff appears here\n\n<statusCode "); Node piMeasureNode = new QrdaDecoderEngine(new Context()).decode(XmlUtils.stringToDom(xmlFragment)); assertWithMessage("Decoded xml fragment should contain one child node") .that(piMeasureNode.getChildNodes()) .hasSize(1); List<Node> nodeList = piMeasureNode.findNode(TemplateId.PI_NUMERATOR); assertWithMessage("Decoded xml fragment should contain %s", TemplateId.PI_NUMERATOR.name()) .that(nodeList).hasSize(1); nodeList = nodeList.get(0).findNode(TemplateId.PI_AGGREGATE_COUNT); assertWithMessage("Decoded xml fragment %s should contain %s", TemplateId.PI_NUMERATOR.name(), TemplateId.PI_AGGREGATE_COUNT.name()) .that(nodeList).hasSize(1); nodeList = piMeasureNode.findNode(TemplateId.PI_DENOMINATOR); assertWithMessage("Decoded xml fragment should contain %s", TemplateId.PI_DENOMINATOR.name()) .that(nodeList).hasSize(1); nodeList = nodeList.get(0).findNode(TemplateId.PI_AGGREGATE_COUNT); assertWithMessage("Decoded xml fragment %s should contain %s", TemplateId.PI_NUMERATOR.name(), TemplateId.PI_AGGREGATE_COUNT.name()) .that(nodeList).hasSize(1); int numberNodes = countNodes(piMeasureNode); assertWithMessage("Decoded xml fragment %s should contain 6 nodes", piMeasureNode.getType().name()) .that(numberNodes).isEqualTo(6); } @Test void testInternalDecode() { Namespace rootns = Namespace.getNamespace("urn:hl7-org:v3"); Namespace ns = Namespace.getNamespace("xsi", "http: Element element = new Element("organizer", rootns); Element templateIdElement = new Element("templateId", rootns) .setAttribute("root","2.16.840.1.113883.10.20.27.3.28"); Element referenceElement = new Element("reference", rootns); Element externalDocumentElement = new Element("externalDocument", rootns); Element idElement = new Element("id", rootns).setAttribute("extension", MEASURE_ID); externalDocumentElement.addContent(idElement); referenceElement.addContent(externalDocumentElement); element.addContent(templateIdElement); element.addContent(referenceElement); element.addNamespaceDeclaration(ns); Node thisNode = new Node(); PiNumeratorDenominatorDecoder objectUnderTest = new PiNumeratorDenominatorDecoder(new Context()); objectUnderTest.setNamespace(element.getNamespace()); objectUnderTest.decode(element, thisNode); assertThat(thisNode.getValue("measureId")) .isEqualTo(MEASURE_ID); }
ConversionReport { public Node getDecoded() { return CloneHelper.deepClone(decoded); } ConversionReport(Source source, List<Detail> errors, List<Detail> warnings, Node decoded, JsonWrapper encodedWithMetadata); Node getDecoded(); JsonWrapper getEncodedWithMetadata(); AllErrors getReportDetails(); void setReportDetails(AllErrors details); void setRawValidationDetails(String details); Source getQrdaSource(); Source getQppSource(); Source getValidationErrorsSource(); List<Detail> getWarnings(); void setWarnings(List<Detail> warnings); Source getRawValidationErrorsOrEmptySource(); String getPurpose(); }
@Test void testGetDecoded() { assertThat(report.getDecoded()).isNotNull(); }
ConversionReport { public JsonWrapper getEncodedWithMetadata() { return CloneHelper.deepClone(encodedWithMetadata); } ConversionReport(Source source, List<Detail> errors, List<Detail> warnings, Node decoded, JsonWrapper encodedWithMetadata); Node getDecoded(); JsonWrapper getEncodedWithMetadata(); AllErrors getReportDetails(); void setReportDetails(AllErrors details); void setRawValidationDetails(String details); Source getQrdaSource(); Source getQppSource(); Source getValidationErrorsSource(); List<Detail> getWarnings(); void setWarnings(List<Detail> warnings); Source getRawValidationErrorsOrEmptySource(); String getPurpose(); }
@Test void testGetEncoded() { assertThat(report.getEncodedWithMetadata().toString()) .isEqualTo(wrapper.toString()); }
ConversionReport { public AllErrors getReportDetails() { return reportDetails; } ConversionReport(Source source, List<Detail> errors, List<Detail> warnings, Node decoded, JsonWrapper encodedWithMetadata); Node getDecoded(); JsonWrapper getEncodedWithMetadata(); AllErrors getReportDetails(); void setReportDetails(AllErrors details); void setRawValidationDetails(String details); Source getQrdaSource(); Source getQppSource(); Source getValidationErrorsSource(); List<Detail> getWarnings(); void setWarnings(List<Detail> warnings); Source getRawValidationErrorsOrEmptySource(); String getPurpose(); }
@Test void getReportDetails() { assertThat(errorReport.getReportDetails()).isNotNull(); }
ConversionReport { public Source getQrdaSource() { return source; } ConversionReport(Source source, List<Detail> errors, List<Detail> warnings, Node decoded, JsonWrapper encodedWithMetadata); Node getDecoded(); JsonWrapper getEncodedWithMetadata(); AllErrors getReportDetails(); void setReportDetails(AllErrors details); void setRawValidationDetails(String details); Source getQrdaSource(); Source getQppSource(); Source getValidationErrorsSource(); List<Detail> getWarnings(); void setWarnings(List<Detail> warnings); Source getRawValidationErrorsOrEmptySource(); String getPurpose(); }
@Test void testGetQrdaSource() { assertThat(report.getQrdaSource()).isEqualTo(inputSource); }
ConversionReport { public Source getQppSource() { return getEncodedWithMetadata().toSource(); } ConversionReport(Source source, List<Detail> errors, List<Detail> warnings, Node decoded, JsonWrapper encodedWithMetadata); Node getDecoded(); JsonWrapper getEncodedWithMetadata(); AllErrors getReportDetails(); void setReportDetails(AllErrors details); void setRawValidationDetails(String details); Source getQrdaSource(); Source getQppSource(); Source getValidationErrorsSource(); List<Detail> getWarnings(); void setWarnings(List<Detail> warnings); Source getRawValidationErrorsOrEmptySource(); String getPurpose(); }
@Test void testGetQppSource() throws IOException { assertThat(IOUtils.toString(report.getQppSource().toInputStream(), StandardCharsets.UTF_8)) .isEqualTo(IOUtils.toString(wrapper.toSource().toInputStream(), StandardCharsets.UTF_8)); }
ConversionReport { public Source getValidationErrorsSource() { try { byte[] validationErrorBytes = mapper.writeValueAsBytes(reportDetails); return new InputStreamSupplierSource("ValidationErrors", new ByteArrayInputStream(validationErrorBytes)); } catch (JsonProcessingException e) { throw new EncodeException("Issue serializing error report details", e); } } ConversionReport(Source source, List<Detail> errors, List<Detail> warnings, Node decoded, JsonWrapper encodedWithMetadata); Node getDecoded(); JsonWrapper getEncodedWithMetadata(); AllErrors getReportDetails(); void setReportDetails(AllErrors details); void setRawValidationDetails(String details); Source getQrdaSource(); Source getQppSource(); Source getValidationErrorsSource(); List<Detail> getWarnings(); void setWarnings(List<Detail> warnings); Source getRawValidationErrorsOrEmptySource(); String getPurpose(); }
@Test void getGoodReportDetails() { assertThat(errorReport.getValidationErrorsSource().toInputStream()).isNotNull(); }
ConversionReport { public Source getRawValidationErrorsOrEmptySource() { String raw = (qppValidationDetails != null) ? qppValidationDetails : ""; byte[] rawValidationErrorBytes = raw.getBytes(StandardCharsets.UTF_8); return new InputStreamSupplierSource("RawValidationErrors", new ByteArrayInputStream(rawValidationErrorBytes)); } ConversionReport(Source source, List<Detail> errors, List<Detail> warnings, Node decoded, JsonWrapper encodedWithMetadata); Node getDecoded(); JsonWrapper getEncodedWithMetadata(); AllErrors getReportDetails(); void setReportDetails(AllErrors details); void setRawValidationDetails(String details); Source getQrdaSource(); Source getQppSource(); Source getValidationErrorsSource(); List<Detail> getWarnings(); void setWarnings(List<Detail> warnings); Source getRawValidationErrorsOrEmptySource(); String getPurpose(); }
@Test void emptyRawValidationErrors() throws IOException { String details = IOUtils.toString(errorReport.getRawValidationErrorsOrEmptySource().toInputStream(), "UTF-8"); assertThat(details).isEmpty(); }
PathCorrelator { public static String getXpath(String base, String attribute, String uri) { String key = PathCorrelator.getKey(base, attribute); Goods goods = pathCorrelationMap.get(key); return (goods == null) ? null : goods.getRelativeXPath().replace(uriSubstitution, uri); } private PathCorrelator(); static String getXpath(String base, String attribute, String uri); static String prepPath(String jsonPath, JsonWrapper wrapper); static final String KEY_DELIMITER; }
@Test void pathCorrelatorInitilization() { String xpath = PathCorrelator.getXpath(TemplateId.CLINICAL_DOCUMENT.name(), ClinicalDocumentDecoder.PROGRAM_NAME, "meep"); assertThat(xpath).isNotNull(); }
PathCorrelator { public static String prepPath(String jsonPath, JsonWrapper wrapper) { String base = "$"; String leaf = jsonPath; int lastIndex = jsonPath.lastIndexOf('.'); if (lastIndex > 0) { base = jsonPath.substring(0, lastIndex); leaf = jsonPath.substring(lastIndex + 1); } JsonPath compiledPath = JsonPath.compile(base); String json = wrapper.toStringWithMetadata(); Map<String, Object> jsonMap = compiledPath.read(json); Map<String, String> metaMap = getMetaMap(jsonMap, leaf); String preparedPath = ""; if (metaMap != null) { preparedPath = makePath(metaMap, leaf); } return preparedPath; } private PathCorrelator(); static String getXpath(String base, String attribute, String uri); static String prepPath(String jsonPath, JsonWrapper wrapper); static final String KEY_DELIMITER; }
@Test void unacknowledgedEncodedLabel() { JsonWrapper metadata = new JsonWrapper(); metadata.putMetadata("meep", "meep"); metadata.putMetadata(JsonWrapper.ENCODING_KEY, "mawp"); JsonWrapper wrapper = new JsonWrapper(); wrapper.addMetadata(metadata); wrapper.put("mop","mop"); String actual = PathCorrelator.prepPath("$.mawp", wrapper); assertThat(actual).isEmpty(); } @Test void unacknowledgedEncodedLabel_multipleMetadata() { JsonWrapper metadata = new JsonWrapper(); metadata.putMetadata("meep", "meep"); metadata.putMetadata(JsonWrapper.ENCODING_KEY, "mawp"); JsonWrapper metadata2 = new JsonWrapper(); metadata2.putMetadata("template", "mip"); metadata2.putMetadata("nsuri", "mip"); metadata2.putMetadata(JsonWrapper.ENCODING_KEY, "mip"); JsonWrapper wrapper = new JsonWrapper(); wrapper.addMetadata(metadata); wrapper.addMetadata(metadata2); wrapper.put("mop","mop"); String actual = PathCorrelator.prepPath("$.mawp", wrapper); assertThat(actual).isEmpty(); }
Converter { public JsonWrapper transform() { DEV_LOG.info("Transform invoked"); try { encoded = transform(source.toInputStream()); } catch (XmlInputFileException | XmlException xe) { DEV_LOG.error(ProblemCode.NOT_VALID_XML_DOCUMENT.getMessage(), xe); Detail detail = Detail.forProblemCode(ProblemCode.NOT_VALID_XML_DOCUMENT); errors.add(detail); } catch (RuntimeException exception) { DEV_LOG.error(ProblemCode.UNEXPECTED_ERROR.getMessage(), exception); Detail detail = Detail.forProblemCode(ProblemCode.UNEXPECTED_ERROR); errors.add(detail); } if (!errors.isEmpty()) { throw new TransformException("Validation errors exist", null, getReport()); } return encoded; } Converter(Source source); Converter(Source source, Context context); Context getContext(); JsonWrapper transform(); ConversionReport getReport(); }
@Test(expected = org.junit.Test.None.class) public void testValidQppFile() { MeasureConfigs.initMeasureConfigs(MeasureConfigs.DEFAULT_MEASURE_DATA_FILE_NAME); Path path = Paths.get(VALID_FILE); Converter converter = new Converter(new PathSource(path)); converter.transform(); } @Test(expected = org.junit.Test.None.class) public void testValidQppStream() { MeasureConfigs.initMeasureConfigs(MeasureConfigs.DEFAULT_MEASURE_DATA_FILE_NAME); Path path = Paths.get(VALID_FILE); Converter converter = new Converter( new InputStreamSupplierSource(path.toString(), NioHelper.fileToStream(path))); converter.transform(); } @Test @PrepareForTest({Converter.class, QrdaValidator.class}) public void testValidationErrors() throws Exception { Context context = new Context(); TestHelper.mockDecoder(context, JennyDecoder.class, new ComponentKey(TemplateId.IA_SECTION, Program.ALL)); QrdaValidator mockQrdaValidator = TestHelper.mockValidator(context, TestDefaultValidator.class, new ComponentKey(TemplateId.IA_SECTION, Program.ALL), true); PowerMockito.whenNew(QrdaValidator.class) .withAnyArguments() .thenReturn(mockQrdaValidator); Path path = Paths.get(ERROR_FILE); Converter converter = new Converter(new PathSource(path), context); try { converter.transform(); fail("The converter should not create valid QPP JSON"); } catch (TransformException exception) { AllErrors allErrors = exception.getDetails(); List<Error> errors = allErrors.getErrors(); assertWithMessage("There must only be one error source.") .that(errors).hasSize(1); List<Detail> details = errors.get(0).getDetails(); assertWithMessage("The expected validation error was missing") .that(details) .comparingElementsUsing(DetailsErrorEquals.INSTANCE) .contains(new FormattedProblemCode(ProblemCode.UNEXPECTED_ERROR, "Test validation error for Jenny")); } } @Test public void testInvalidXml() { Path path = Paths.get(INVALID_XML); Converter converter = new Converter(new PathSource(path)); try { converter.transform(); fail(); } catch (TransformException exception) { checkup(exception, ProblemCode.NOT_VALID_XML_DOCUMENT); } } @Test public void testInvalidXmlFile() { Converter converter = new Converter(new PathSource(Paths.get("src/test/resources/not-a-QRDA-III-file.xml"))); try { converter.transform(); fail(); } catch (TransformException exception) { checkup(exception, ProblemCode.NOT_VALID_QRDA_DOCUMENT.format(Context.REPORTING_YEAR, DocumentationReference.CLINICAL_DOCUMENT)); } } @Test public void testUnexpectedError() { Source source = mock(Source.class); when(source.toInputStream()).thenThrow(RuntimeException.class); Converter converter = new Converter(source); try { converter.transform(); fail(); } catch (TransformException exception) { checkup(exception, ProblemCode.UNEXPECTED_ERROR); } source = mock(Source.class); when(source.toInputStream()).thenThrow(TextParsingException.class); converter = new Converter(source); try { converter.transform(); fail(); } catch (TransformException exception) { checkup(exception, ProblemCode.UNEXPECTED_ERROR); } } @Test public void testTooManyErrorsInQrdaIIIFile() { LocalizedProblem expectedError = ProblemCode.TOO_MANY_ERRORS.format(108); Path path = Paths.get(TOO_MANY_ERRORS); Converter converter = new Converter(new PathSource(path)); try { converter.transform(); fail(); } catch (TransformException exception) { AllErrors allErrors = exception.getDetails(); List<Error> errors = allErrors.getErrors(); assertWithMessage("The validation error was incorrect") .that(errors.get(0).getDetails()) .comparingElementsUsing(DetailsErrorEquals.INSTANCE) .contains(expectedError); } }
Converter { public ConversionReport getReport() { return new ConversionReport(source, errors, warnings, decoded, encoded); } Converter(Source source); Converter(Source source, Context context); Context getContext(); JsonWrapper transform(); ConversionReport getReport(); }
@Test public void testTestSourceCreatesTestReport() { Source source = mock(Source.class); when(source.getPurpose()).thenReturn("Test"); Truth.assertThat(new Converter(source).getReport().getPurpose()).isEqualTo("Test"); } @Test public void testNormalSourceCreatesNormalReport() { Source source = mock(Source.class); when(source.getPurpose()).thenReturn(null); Truth.assertThat(new Converter(source).getReport().getPurpose()).isNull(); }
InputStreamSupplierSource extends SkeletalSource { @Override public InputStream toInputStream() { return stream.get(); } InputStreamSupplierSource(String name, InputStream source); InputStreamSupplierSource(String name, InputStream source, String purpose); @Override InputStream toInputStream(); @Override long getSize(); @Override String getPurpose(); }
@Test void testInputStream() throws IOException { String actual = IOUtils.toString(stream("src/test/resources/arbitrary.txt"), StandardCharsets.UTF_8); String content = IOUtils.toString(source.toInputStream(), StandardCharsets.UTF_8); assertThat(actual).isEqualTo(content); }
InputStreamSupplierSource extends SkeletalSource { @Override public long getSize() { return stream.size(); } InputStreamSupplierSource(String name, InputStream source); InputStreamSupplierSource(String name, InputStream source, String purpose); @Override InputStream toInputStream(); @Override long getSize(); @Override String getPurpose(); }
@Test void testSpecificSize() { String text = "mock"; InputStreamSupplierSource source = new InputStreamSupplierSource("DogCow name", new ByteArrayInputStream(text.getBytes())); assertThat(source.getSize()).isEqualTo(text.length()); } @Test void testUnspecifiedSize() { byte [] bytes = "Moof".getBytes(); InputStreamSupplierSource source = new InputStreamSupplierSource("DogCow name", new ByteArrayInputStream(bytes)); assertThat(source.getSize()).isEqualTo(bytes.length); }
ValidationServiceImpl implements ValidationService { HttpHeaders getHeaders() { HttpHeaders headers = new HttpHeaders(); headers.add(HttpHeaders.CONTENT_TYPE, CONTENT_TYPE); headers.add(HttpHeaders.ACCEPT, CONTENT_TYPE); String submissionToken = environment.getProperty(Constants.SUBMISSION_API_TOKEN_ENV_VARIABLE); if (submissionToken != null && !submissionToken.isEmpty()) { headers.add(HttpHeaders.AUTHORIZATION, "Bearer " + submissionToken); } return headers; } ValidationServiceImpl(final Environment environment); @PostConstruct void checkForValidationUrlVariable(); @Override void validateQpp(ConversionReport conversionReport); static final String SV_LABEL; }
@Test void testHeaderCreation() { HttpHeaders headers = objectUnderTest.getHeaders(); assertThat(headers.getFirst(HttpHeaders.CONTENT_TYPE)).isEqualTo(ValidationServiceImpl.CONTENT_TYPE); assertThat(headers.getFirst(HttpHeaders.ACCEPT)).isEqualTo(ValidationServiceImpl.CONTENT_TYPE); } @Test void testHeaderCreationNoAuth() { when(environment.getProperty(eq(Constants.SUBMISSION_API_TOKEN_ENV_VARIABLE))).thenReturn(null); HttpHeaders headers = objectUnderTest.getHeaders(); assertThat(headers.get(HttpHeaders.AUTHORIZATION)).isNull(); } @Test void testHeaderCreationNoAuthEmpty() { when(environment.getProperty(eq(Constants.SUBMISSION_API_TOKEN_ENV_VARIABLE))).thenReturn(""); HttpHeaders headers = objectUnderTest.getHeaders(); assertThat(headers.get(HttpHeaders.AUTHORIZATION)).isNull(); } @Test void testHeaderCreationAuth() { when(environment.getProperty(eq(Constants.SUBMISSION_API_TOKEN_ENV_VARIABLE))).thenReturn("meep"); HttpHeaders headers = objectUnderTest.getHeaders(); assertThat(headers.getFirst(HttpHeaders.AUTHORIZATION)).contains("meep"); }
InputStreamSupplierSource extends SkeletalSource { @Override public String getPurpose() { return purpose; } InputStreamSupplierSource(String name, InputStream source); InputStreamSupplierSource(String name, InputStream source, String purpose); @Override InputStream toInputStream(); @Override long getSize(); @Override String getPurpose(); }
@Test void testTestIsTest() { String text = "mock"; InputStreamSupplierSource source = new InputStreamSupplierSource("DogCow name", new ByteArrayInputStream(text.getBytes()), "Test"); Truth.assertThat(source.getPurpose()).isEqualTo("Test"); } @Test void testNormalIsNotTest() { String text = "mock"; InputStreamSupplierSource source = new InputStreamSupplierSource("DogCow name", new ByteArrayInputStream(text.getBytes()), null); Truth.assertThat(source.getPurpose()).isNull(); } @Test void testDefaultIsNotTest() { String text = "mock"; InputStreamSupplierSource source = new InputStreamSupplierSource("DogCow name", new ByteArrayInputStream(text.getBytes())); Truth.assertThat(source.getPurpose()).isNull(); }
CpcClinicalDocumentValidator extends NodeValidator { private ZonedDateTime now() { ZoneId zone = ZoneId.of("US/Eastern"); return ZonedDateTime.now(zone); } CpcClinicalDocumentValidator(Context context); }
@Test void testCpcPlusSubmissionBeforeEndDate() { System.setProperty(CpcClinicalDocumentValidator.END_DATE_VARIABLE, ZonedDateTime.now(CpcClinicalDocumentValidator.EASTERN_TIME_ZONE).plusYears(3) .format(CpcClinicalDocumentValidator.INPUT_END_DATE_FORMAT)); Node clinicalDocument = createValidCpcPlusClinicalDocument(); List<Detail> errors = cpcValidator.validateSingleNode(clinicalDocument).getErrors(); assertThat(errors) .isEmpty(); }