Package software.amazon.smithy.diff.testrunner

Class SmithyDiffTestSuite

  • public final class SmithyDiffTestSuite
extends java.lang.Object
    Runs diff test cases against corresponding model `a`, model `b`, and validation `events` files.

    • Method Detail

      • runner

        public static SmithyDiffTestSuite runner()
        Creates a new Smithy diff test suite.
        Returns:
        Returns the created test suite.

      • defaultParameterizedTestSource

        public static java.util.stream.Stream<java.lang.Object[]> defaultParameterizedTestSource​(java.lang.Class<?> contextClass)
        Factory method used to easily create a JUnit 5 ParameterizedTest MethodSource based on the given Class.

        This method assumes that there is a resource named diffs relative to the given class that contains test cases. It also assumes validators and traits should be loaded using the ClassLoader of the given contextClass, and that model discovery should be used using the given contextClass.

        Each returned Object[] contains the filename of the test as the first argument, followed by a Callable<SmithyDiffTestCase.Result> as the second argument. All a parameterized test needs to do is call call on the provided Callable to execute the test and fail if the test case is invalid.

        For example, the following can be used as a unit test: 

        
 import java.util.concurrent.Callable;
 import java.util.stream.Stream;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
 import software.amazon.smithy.diff.testrunner.SmithyDiffTestCase;
 import software.amazon.smithy.diff.testrunner.SmithyDiffTestSuite;

 public class TestRunnerTest {
     \@ParameterizedTest(name = "\{0\}")
     \@MethodSource("source")
     public void testRunner(String filename, Callable&lt;SmithyDiffTestCase.Result&gt; callable)
         throws Exception {
         callable.call();
     }

     public static Stream&lt;?&gt; source() {
         return SmithyDiffTestSuite.defaultParameterizedTestSource(TestRunnerTest.class);
     }
 }
        Parameters:
        contextClass - The class to use for loading diffs and model discovery.
        Returns:
        Returns the Stream that should be used as a JUnit 5 MethodSource return value.

      • parameterizedTestSource

        public java.util.stream.Stream<java.lang.Object[]> parameterizedTestSource()
        Factory method used to create a JUnit 5 ParameterizedTest MethodSource.

        Test cases need to be added to the test suite before calling this, for example by using addTestCasesFromDirectory(Path).

        Each returned Object[] contains the name of the test as the first argument, followed by a Callable<SmithyDiffTestCase.Result> as the second argument. All a parameterized test needs to do is call call on the provided Callable to execute the test and fail if the test case is invalid.

        For example, the following can be used as a unit test: 

        
 import java.util.concurrent.Callable;
 import java.util.stream.Stream;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
 import software.amazon.smithy.diff.testrunner.SmithyDiffTestCase;
 import software.amazon.smithy.diff.testrunner.SmithyDiffTestSuite;

 public class TestRunnerTest {
     \@ParameterizedTest(name = "\{0\}")
     \@MethodSource("source")
     public void testRunner(String filename, Callable&lt;SmithyDiffTestCase.Result&gt; callable)
         throws Exception {
         callable.call();
     }

     public static Stream&lt;?&gt; source() {
         ModelAssembler assembler = Model.assembler(TestRunnerTest.class.getClassLoader());
         return SmithyDiffTestSuite.runner()
                 .setModelAssemblerFactory(assembler::copy)
                 .addTestCasesFromUrl(TestRunnerTest.class.getResource("errorfiles"))
                 .parameterizedTestSource();
     }
 }
        Returns:
        Returns the Stream that should be used as a JUnit 5 MethodSource return value.

      • addTestCase

        public SmithyDiffTestSuite addTestCase​(SmithyDiffTestCase testCase)
        Adds a test case to the test suite.
        Parameters:
        testCase - Test case to add.
        Returns:
        Returns the test suite.

      • addTestCasesFromUrl

        public SmithyDiffTestSuite addTestCasesFromUrl​(java.net.URL url)
        Convenience method for supplying a directory using a class loader.
        Parameters:
        url - URL that contains diff models.
        Returns:
        Returns the test suite.
        Throws:
        java.lang.IllegalArgumentException - if a non-file scheme URL is provided.
        See Also:
        addTestCasesFromDirectory(java.nio.file.Path)

      • setModelAssemblerFactory

        public SmithyDiffTestSuite setModelAssemblerFactory​(java.util.function.Supplier<ModelAssembler> modelAssemblerFactory)
        Sets a custom ModelAssembler factory to use to create a ModelAssembler for each test case.

        The supplier must return a new instance of a Model assembler each time it is called. Model assemblers are mutated and execute in parallel.

        Parameters:
        modelAssemblerFactory - Model assembler factory to use.
        Returns:
        Returns the test suite.

      • testCaseCallables

        public java.util.stream.Stream<java.util.concurrent.Callable<SmithyDiffTestCase.Result>> testCaseCallables()
        Creates a Stream of Callable objects that can be used to execute each test case.

        The SmithyDiffTestCase.Result.unwrap() method must be called on the result of each callable in order to actually assert that the test case result is OK.

        Returns:
        Returns a stream of test case callables.

      • run

        public SmithyDiffTestSuite.Result run​(java.util.concurrent.ExecutorService executorService)
        Executes the test runner with a specific ExecutorService.

        Tests ideally should use JUnit 5's ParameterizedTest as described in parameterizedTestSource(). However, this method can be used to run tests in parallel in other scenarios (like if you aren't using JUnit, or not running tests cases during unit tests).

        Parameters:
        executorService - Executor service to execute tests with.
        Returns:
        Returns the test case result object on success.
        Throws:
        SmithyDiffTestSuite.Error - if the validation events do not match expectations.