Add loading via as property

Author: ashleyfrieze

README.md

@@ -141,6 +141,19 @@ void someTest() {
 
 > Note: for asserting JSON responses, maybe consider [Model Assert](https://github.com/webcompere/model-assert)
 
+We may prefer to load the file using a different loader than is suggested by its file extension. For example,
+we may have a JSON file and wish to load it into a String as text, rather than serialize `"some value"` into `String`
+from the file using JSON deserialization.
+
+For this, we can use the `as` property of the `@TestData` annotation:
+
+```java
+// will get `src/test/resources/somejson.json` loaded as a string
+// rather than deserialized as though it's a JSON string literal
+@TestData(value = "somejson.json", as = ".txt")
+private String jsonContents;
+```
+
 ### Customising the Loader
 
 We can customise the loader by setting its root directory, default immutability, default file extension (for when

test-gadgets-core/src/main/java/uk/org/webcompere/testgadgets/testdatafactory/TestData.java

@@ -19,4 +19,10 @@
      * Is this test data to be treated as immutable and thus cached and served from the cache.
      */
     Immutable immutable() default Immutable.DEFAULT;
+
+    /**
+     * If non blank, use the loader for this alternative file extension (including the .) to load
+     * the file into the target object
+     */
+    String as() default "";
 }

test-gadgets-core/src/main/java/uk/org/webcompere/testgadgets/testdatafactory/TestDataLoader.java

@@ -72,13 +72,28 @@ public TestDataLoader addLoader(String extension, ObjectLoader objectLoader) {
      * @param <T> the type of object to load
      * @throws IOException on any error
      */
-    @SuppressWarnings("unchecked")
     public <T> T load(Path pathToFile, Type type, boolean useCache) throws IOException {
+        return load(pathToFile, type, useCache, null);
+    }
+
+    /**
+     * Load a file into an object
+     * @param pathToFile the path to the file relative to the paths in the engine
+     * @param type the type to hydrate
+     * @param useCache whether to use the cache at all
+     * @param overrideExtension can be null or blank, but if present, it's the file extension that defines which
+     *                     loader to use, in place of the native file extension
+     * @return the object required
+     * @param <T> the type of object to load
+     * @throws IOException on any error
+     */
+    @SuppressWarnings("unchecked")
+    public <T> T load(Path pathToFile, Type type, boolean useCache, String overrideExtension) throws IOException {
         if (isImmutable(type) || useCache) {
             try {
                 return (T) cache.computeIfAbsent(pathToFile, (path) -> {
                     try {
-                        return loadWithLoaders(pathToFile, type);
+                        return loadWithLoaders(pathToFile, type, overrideExtension);
                     } catch (IOException e) {
                         throw new RuntimeException("Error loading " + pathToFile + " " + e.getMessage(), e);
                     }
@@ -88,11 +103,11 @@ public <T> T load(Path pathToFile, Type type, boolean useCache) throws IOExcepti
             }
         }
 
-        return loadWithLoaders(pathToFile, type);
+        return loadWithLoaders(pathToFile, type, overrideExtension);
     }
 
     @SuppressFBWarnings("NP_NULL_ON_SOME_PATH_FROM_RETURN_VALUE")
-    private <T> T loadWithLoaders(Path pathToFile, Type type) throws IOException {
+    private <T> T loadWithLoaders(Path pathToFile, Type type, String overrideExtension) throws IOException {
         Path resolved = root.resolve(pathToFile);
 
         var fileExtension = getExtension(resolved);
@@ -101,6 +116,10 @@ private <T> T loadWithLoaders(Path pathToFile, Type type) throws IOException {
                 ? resolved
                 : resolved.getParent().resolve(pathToFile.getFileName() + extensionToUse);
 
+        if (overrideExtension != null && !overrideExtension.isBlank()) {
+            extensionToUse = overrideExtension;
+        }
+
         if (!loaders.containsKey(extensionToUse.toLowerCase(Locale.getDefault()))) {
             throw new IOException("No loader present for extension " + extensionToUse);
         }

test-gadgets-core/src/main/java/uk/org/webcompere/testgadgets/testdatafactory/TestDataLoaderAnnotations.java

@@ -124,7 +124,7 @@ public static Object load(TestDataLoader loaderInstance, String name, Type type,
             cache = loaderInstance.getImmutableMode() == Immutable.IMMUTABLE;
         }
 
-        return loaderInstance.load(path, type, cache);
+        return loaderInstance.load(path, type, cache, testDataAnnotation.as());
     }
 
     private static void setup(TestDataLoader loaderInstance, Field field, Object testInstance) throws Exception {

test-gadgets-core/src/test/java/uk/org/webcompere/testgadgets/testdatafactory/TestDataLoaderAnnotationsTest.java

@@ -114,6 +114,25 @@ void whenFilePathInAnnotationWithSlashesThenLoadsIt() throws Exception {
         assertThat(bound.getCatchPhrase().getName()).isEqualTo("Gadget");
     }
 
+    @Test
+    void canLoadWithOverrideType() throws Exception {
+        var loader = new TestDataLoader();
+
+        class BoundClass {
+            @TestData(
+                    value = {"loader", "somejson.json"},
+                    as = ".txt")
+            String somejson;
+        }
+
+        var bound = new BoundClass();
+        bindAnnotatedFields(loader, bound);
+
+        // has loaded as string
+        assertThat(bound.somejson)
+                .isEqualTo("{\n" + "    \"name\": \"Gadget\",\n" + "    \"catchPhrase\": \"GadgetGadget\"\n" + "}");
+    }
+
     @Test
     void whenTheLoaderIsSetToImmutableSubsequentLoadsAreCached() throws Exception {
         var loader = new TestDataLoader();
@@ -191,8 +210,6 @@ static class ReceiveStaticLoader {
     void canInjectLoaderIntoStaticField() throws Exception {
         var loader = new TestDataLoader();
 
-        var testObject = new ReceiveStaticLoader();
-
         bindAnnotatedStaticFields(loader, ReceiveStaticLoader.class);
 
         assertThat(ReceiveStaticLoader.testDataLoader).isSameAs(loader);
@@ -202,7 +219,6 @@ void canInjectLoaderIntoStaticField() throws Exception {
     void canReadTestDataLoaderFromTestObjectStatic() throws Exception {
         var loader = new TestDataLoader();
 
-        var testObject = new ReceiveStaticLoader();
         ReceiveStaticLoader.testDataLoader = loader;
 
         assertThat(TestDataLoaderAnnotations.getLoaderFromTestClassOrObject(ReceiveStaticLoader.class, null)