org.junit.jupiter.api.DynamicContainer Java Examples

@TestFactory
@DisplayName("Objects")
Stream<DynamicNode> objects() {
	Map<String, Map<String, Object>> supportedTypes = new HashMap<>();
	supportedTypes.put("CypherTypes", CYPHER_TYPES);
	supportedTypes.put("AdditionalTypes", ADDITIONAL_TYPES);
	supportedTypes.put("SpatialTypes", SPATIAL_TYPES);

	return supportedTypes.entrySet().stream()
		.map(types -> {

			DynamicContainer reads = DynamicContainer.dynamicContainer("read", types.getValue().entrySet().stream()
				.map(a -> dynamicTest(a.getKey(),
					() -> Neo4jConversionsIT.assertRead(types.getKey(), a.getKey(), a.getValue()))));

			DynamicContainer writes = DynamicContainer.dynamicContainer("write", types.getValue().entrySet().stream()
				.map(a -> dynamicTest(a.getKey(),
					() -> Neo4jConversionsIT.assertWrite(types.getKey(), a.getKey(), a.getValue()))));

			return DynamicContainer.dynamicContainer(types.getKey(), Arrays.asList(reads, writes));
		});
}
 

@TestFactory
List<DynamicContainer> registeredTests() {
	return asList(
			dynamicContainer(
					"Dynamic Container #1",
					asList(
							dynamicTest(
									"Dynamic Test #1",
									() -> System.out.println("Hi, this is Dynamic Test #1!")),
							dynamicTest(
									"Dynamic Test #2",
									() -> System.out.println("Hi, this is Dynamic Test #2!")))
			),
			dynamicContainer(
					"Dynamic Container #2",
					asList(
							dynamicTest(
									"Dynamic Test #A",
									() -> System.out.println("Hi, this is Dynamic Test #A!")),
							dynamicTest(
									"Dynamic Test #B",
									() -> System.out.println("Hi, this is Dynamic Test #B!")))
			)
	);
}
 

@WithAccessId(user = INSIDE_DYNAMIC_TEST_USER)
@WithAccessId(user = INSIDE_DYNAMIC_TEST_USER)
@TestFactory
Iterator<DynamicContainer>
    should_SetMultipleAccessIdForDynamicContainerInIterator_When_AnnotationsExist() {
  Supplier<DynamicContainer> supplier =
      () ->
          dynamicContainer(
              "dynamic container", Stream.of(NOT_NULL_DYNAMIC_TEST, NOT_NULL_DYNAMIC_TEST));
  return Stream.generate(supplier).limit(2).iterator();
}
 

@TestFactory
Stream<DynamicContainer> checkSemantics() {
	return Stream.of(
			expectUnicast(supplier),
			expectBufferingBeforeFirstSubscriber(supplier, ALL)
	);
}
 

@TestFactory
Iterator<DynamicContainer>
    should_NotSetAccessIdForNestedDynamicContainerInIterator_When_AnnotationIsMissing() {
  Supplier<DynamicContainer> supplier =
      () -> dynamicContainer("inside container", Stream.of(NULL_DYNAMIC_TEST, NULL_DYNAMIC_TEST));
  Supplier<DynamicContainer> outsideSupplier =
      () -> dynamicContainer("outside container", Stream.of(supplier.get(), NULL_DYNAMIC_TEST));
  return Stream.generate(outsideSupplier).limit(2).iterator();
}
 

@WithAccessId(user = INSIDE_DYNAMIC_TEST_USER)
@TestFactory
Iterator<DynamicContainer>
    should_SetAccessIdForNestedDynamicContainerInIterator_When_AnnotationExists() {
  Supplier<DynamicContainer> supplier =
      () ->
          dynamicContainer(
              "inside container",
              Stream.of(DYNAMIC_TEST_USER_DYNAMIC_TEST, DYNAMIC_TEST_USER_DYNAMIC_TEST));
  Supplier<DynamicContainer> outsideSupplier =
      () ->
          dynamicContainer(
              "outside container", Stream.of(supplier.get(), DYNAMIC_TEST_USER_DYNAMIC_TEST));
  return Stream.generate(outsideSupplier).limit(2).iterator();
}
 

@WithAccessId(user = INSIDE_DYNAMIC_TEST_USER)
@WithAccessId(user = INSIDE_DYNAMIC_TEST_USER)
@TestFactory
Iterator<DynamicContainer>
    should_SetMultipleAccessIdForNestedDynamicContainerInIterator_When_AnnotationsExist() {
  Supplier<DynamicContainer> supplier =
      () ->
          dynamicContainer(
              "inside container", Stream.of(NOT_NULL_DYNAMIC_TEST, NOT_NULL_DYNAMIC_TEST));
  Supplier<DynamicContainer> outsideSupplier =
      () ->
          dynamicContainer("outside container", Stream.of(supplier.get(), NOT_NULL_DYNAMIC_TEST));
  return Stream.generate(outsideSupplier).limit(2).iterator();
}
 

@TestFactory
DynamicContainer[] should_NotSetAccessIdForDynamicContainerInArray_When_AnnotationIsMissing() {
  Supplier<DynamicContainer> supplier =
      () ->
          dynamicContainer("dynamic container", Stream.of(NULL_DYNAMIC_TEST, NULL_DYNAMIC_TEST));
  return Stream.generate(supplier).limit(2).toArray(DynamicContainer[]::new);
}
 

@WithAccessId(user = INSIDE_DYNAMIC_TEST_USER)
@TestFactory
DynamicContainer[] should_SetAccessIdForDynamicContainerInArray_When_AnnotationExists() {
  Supplier<DynamicContainer> supplier =
      () ->
          dynamicContainer(
              "dynamic container",
              Stream.of(DYNAMIC_TEST_USER_DYNAMIC_TEST, DYNAMIC_TEST_USER_DYNAMIC_TEST));
  return Stream.generate(supplier).limit(2).toArray(DynamicContainer[]::new);
}
 

@WithAccessId(user = INSIDE_DYNAMIC_TEST_USER)
@WithAccessId(user = INSIDE_DYNAMIC_TEST_USER)
@TestFactory
DynamicContainer[] should_SetMultipleAccessIdForDynamicContainerInArray_When_AnnotationsExist() {
  Supplier<DynamicContainer> supplier =
      () ->
          dynamicContainer(
              "dynamic container", Stream.of(NOT_NULL_DYNAMIC_TEST, NOT_NULL_DYNAMIC_TEST));
  return Stream.generate(supplier).limit(2).toArray(DynamicContainer[]::new);
}
 

@TestFactory
DynamicContainer[]
    should_NotSetAccessIdForNestedDynamicContainerInArray_When_AnnotationIsMissing() {
  Supplier<DynamicContainer> supplier =
      () -> dynamicContainer("inside container", Stream.of(NULL_DYNAMIC_TEST, NULL_DYNAMIC_TEST));
  Supplier<DynamicContainer> outsideSupplier =
      () -> dynamicContainer("outside container", Stream.of(supplier.get(), NULL_DYNAMIC_TEST));
  return Stream.generate(outsideSupplier).limit(2).toArray(DynamicContainer[]::new);
}
 

@WithAccessId(user = INSIDE_DYNAMIC_TEST_USER)
@TestFactory
DynamicContainer[] should_SetAccessIdForNestedDynamicContainerInArray_When_AnnotationExists() {
  Supplier<DynamicContainer> supplier =
      () ->
          dynamicContainer(
              "inside container",
              Stream.of(DYNAMIC_TEST_USER_DYNAMIC_TEST, DYNAMIC_TEST_USER_DYNAMIC_TEST));
  Supplier<DynamicContainer> outsideSupplier =
      () ->
          dynamicContainer(
              "outside container", Stream.of(supplier.get(), DYNAMIC_TEST_USER_DYNAMIC_TEST));
  return Stream.generate(outsideSupplier).limit(2).toArray(DynamicContainer[]::new);
}
 

@WithAccessId(user = INSIDE_DYNAMIC_TEST_USER)
@WithAccessId(user = INSIDE_DYNAMIC_TEST_USER)
@TestFactory
DynamicContainer[]
    should_SetMultipleAccessIdForNestedDynamicContainerInArray_When_AnnotationsExist() {
  Supplier<DynamicContainer> supplier =
      () ->
          dynamicContainer(
              "inside container", Stream.of(NOT_NULL_DYNAMIC_TEST, NOT_NULL_DYNAMIC_TEST));
  Supplier<DynamicContainer> outsideSupplier =
      () ->
          dynamicContainer("outside container", Stream.of(supplier.get(), NOT_NULL_DYNAMIC_TEST));
  return Stream.generate(outsideSupplier).limit(2).toArray(DynamicContainer[]::new);
}
 

private static void persistDynamicContainerChildren(
    Iterable<DynamicNode> nodes, Map<String, List<DynamicNode>> childrenMap) {
  nodes.forEach(
      node -> {
        if (node instanceof DynamicContainer) {
          DynamicContainer container = (DynamicContainer) node;
          List<DynamicNode> children = container.getChildren().collect(Collectors.toList());
          childrenMap.put(container.hashCode() + container.getDisplayName(), children);
          persistDynamicContainerChildren(children, childrenMap);
        }
      });
}
 

private static DynamicNode duplicateDynamicNode(
    DynamicNode node, Map<String, List<DynamicNode>> lookupMap) {
  if (node instanceof DynamicContainer) {
    DynamicContainer container = (DynamicContainer) node;
    Stream<DynamicNode> children =
        lookupMap.get(node.hashCode() + node.getDisplayName()).stream()
            .map(x -> duplicateDynamicNode(x, lookupMap));
    return DynamicContainer.dynamicContainer(container.getDisplayName(), children);
  }
  return node;
}
 

@SuppressWarnings("unchecked")
private <T extends Event> DynamicContainer forListener(final SupportedListener listener) {
    final AbstractTargetHandler p = getHandler();
    final AbstractListener<T> l = (AbstractListener<T>) getListener(listener, p);
    final T e = (T) listener.getSampleEvent();
    return DynamicContainer.dynamicContainer(listener.toString(), Stream.of(
            dynamicTest("is formally correct", () -> testFormal(l, e, listener)),
            dynamicTest("is processed as plain text", () -> testPlainTextProcessing(l, e)),
            dynamicTest("is processed as HTML", () -> testHtmlProcessing(l, e)),
            dynamicTest("triggers the sending code", () -> testTriggered(p, l, e)),
            dynamicTest("has listener enabled", () -> testListenerEnabled(e))));
}
 

@TestFactory
Stream<DynamicContainer> checkSemantics() {
	return Stream.of(
			expectMulticast(supplier),
			expectReplay(supplier, NONE),
			expectBufferingBeforeFirstSubscriber(supplier, NONE)
	);
}
 

@TestFactory
Stream<DynamicContainer> checkSemantics() {
	return Stream.of(
			expectMulticast(supplier),
			expectReplay(supplier, NONE),
			dynamicContainer("buffers all before 1st subscriber, except for errors",
					expectBufferingBeforeFirstSubscriber(supplier, ALL)
							.getChildren().filter(dn -> !dn.getDisplayName().equals("replayAndErrorFirstSubscriber")))
	);
}
 

@TestFactory
Stream<DynamicContainer> checkSemantics() {
	return Stream.of(
			expectMulticast(supplier),
			expectReplay(supplier, ALL),
			expectBufferingBeforeFirstSubscriber(supplier, ALL)
	);
}
 

@TestFactory
Stream<DynamicContainer> checkSemanticsSize5() {
	final int historySize = 5;
	final Supplier<Sinks.StandaloneFluxSink<Integer>> supplier = () -> Sinks.replay(historySize);

	return Stream.of(
			expectMulticast(supplier),
			expectReplay(supplier, historySize),
			expectBufferingBeforeFirstSubscriber(supplier, historySize)
	);
}
 

@TestFactory
Stream<DynamicContainer> checkSemanticsSize0() {
	final int historySize = 0;
	final Supplier<Sinks.StandaloneFluxSink<Integer>> supplier = () -> Sinks.replay(historySize);

	return Stream.of(
			expectMulticast(supplier),
			expectReplay(supplier, historySize),
			expectBufferingBeforeFirstSubscriber(supplier, historySize)
	);
}
 

@TestFactory
Stream<DynamicContainer> checkSemanticsSize100() {
	final int historySize = 100;
	final Supplier<Sinks.StandaloneFluxSink<Integer>> supplier = () -> Sinks.replay(historySize);

	return Stream.of(
			expectMulticast(supplier),
			expectReplay(supplier, historySize),
			expectBufferingBeforeFirstSubscriber(supplier, historySize)
	);
}
 

@TestFactory
Iterator<DynamicContainer>
    should_NotSetAccessIdForDynamicContainerInIterator_When_AnnotationIsMissing() {
  Supplier<DynamicContainer> supplier =
      () ->
          dynamicContainer("dynamic container", Stream.of(NULL_DYNAMIC_TEST, NULL_DYNAMIC_TEST));
  return Stream.generate(supplier).limit(2).iterator();
}
 

@WithAccessId(user = INSIDE_DYNAMIC_TEST_USER)
@TestFactory
DynamicContainer should_SetAccessIdForDynamicContainer_When_AnnotationExists() {
  return dynamicContainer(
      "dynamic container",
      Stream.of(DYNAMIC_TEST_USER_DYNAMIC_TEST, DYNAMIC_TEST_USER_DYNAMIC_TEST));
}
 

@WithAccessId(user = INSIDE_DYNAMIC_TEST_USER)
@WithAccessId(user = INSIDE_DYNAMIC_TEST_USER)
@TestFactory
DynamicContainer should_SetMultipleAccessIdForDynamicContainer_When_AnnotationsExist() {
  return dynamicContainer(
      "dynamic container", Stream.of(NOT_NULL_DYNAMIC_TEST, NOT_NULL_DYNAMIC_TEST));
}
 

@WithAccessId(user = INSIDE_DYNAMIC_TEST_USER)
@TestFactory
DynamicContainer should_SetAccessIdForNestedDynamicContainer_When_AnnotationExists() {
  DynamicContainer container =
      dynamicContainer(
          "nested container",
          Stream.of(DYNAMIC_TEST_USER_DYNAMIC_TEST, DYNAMIC_TEST_USER_DYNAMIC_TEST));
  return dynamicContainer(
      "outside container", Stream.of(container, DYNAMIC_TEST_USER_DYNAMIC_TEST));
}
 

@WithAccessId(user = INSIDE_DYNAMIC_TEST_USER)
@WithAccessId(user = INSIDE_DYNAMIC_TEST_USER)
@TestFactory
DynamicContainer should_SetMultipleAccessIdForNestedDynamicContainer_When_AnnotationsExist() {
  DynamicContainer container =
      dynamicContainer(
          "inside container", Stream.of(NOT_NULL_DYNAMIC_TEST, NOT_NULL_DYNAMIC_TEST));
  return dynamicContainer("outside container", Stream.of(container, NOT_NULL_DYNAMIC_TEST));
}
 

@TestFactory
Stream<DynamicContainer>
    should_NotSetAccessIdForDynamicContainerInStream_When_AnnotationIsMissing() {
  Supplier<DynamicContainer> supplier =
      () ->
          dynamicContainer("dynamic container", Stream.of(NULL_DYNAMIC_TEST, NULL_DYNAMIC_TEST));
  return Stream.generate(supplier).limit(2);
}
 

@WithAccessId(user = INSIDE_DYNAMIC_TEST_USER)
@TestFactory
Stream<DynamicContainer> should_SetAccessIdForDynamicContainerInStream_When_AnnotationExists() {
  Supplier<DynamicContainer> supplier =
      () ->
          dynamicContainer(
              "dynamic container",
              Stream.of(DYNAMIC_TEST_USER_DYNAMIC_TEST, DYNAMIC_TEST_USER_DYNAMIC_TEST));
  return Stream.generate(supplier).limit(2);
}
 

@WithAccessId(user = INSIDE_DYNAMIC_TEST_USER)
@WithAccessId(user = INSIDE_DYNAMIC_TEST_USER)
@TestFactory
Stream<DynamicContainer>
    should_SetMultipleAccessIdForDynamicContainerInStream_When_AnnotationsExist() {
  Supplier<DynamicContainer> supplier =
      () ->
          dynamicContainer(
              "dynamic container", Stream.of(NOT_NULL_DYNAMIC_TEST, NOT_NULL_DYNAMIC_TEST));
  return Stream.generate(supplier).limit(2);
}