TIKA-4809: pin the reviewed behavior contracts with tests

Author: tballison

tika-core/src/test/java/org/apache/tika/sax/BasicContentHandlerFactoryTest.java

@@ -19,6 +19,7 @@
 import static java.nio.charset.StandardCharsets.UTF_8;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.io.ByteArrayOutputStream;
@@ -54,6 +55,38 @@ public static void assertNotContains(String needle, String haystack) {
         assertFalse(haystack.contains(needle), needle + " found in:\n" + haystack);
     }
 
+    @Test
+    public void testParseHandlerTypeNullYieldsDefault() {
+        assertEquals(BasicContentHandlerFactory.HANDLER_TYPE.XML,
+                BasicContentHandlerFactory.parseHandlerType(null,
+                        BasicContentHandlerFactory.HANDLER_TYPE.XML));
+    }
+
+    @Test
+    public void testParseHandlerTypeAliases() {
+        for (String name : new String[]{"text", "txt", "TEXT"}) {
+            assertEquals(BasicContentHandlerFactory.HANDLER_TYPE.TEXT,
+                    BasicContentHandlerFactory.parseHandlerType(name, null), name);
+        }
+        for (String name : new String[]{"markdown", "md", "MD"}) {
+            assertEquals(BasicContentHandlerFactory.HANDLER_TYPE.MARKDOWN,
+                    BasicContentHandlerFactory.parseHandlerType(name, null), name);
+        }
+        assertEquals(BasicContentHandlerFactory.HANDLER_TYPE.IGNORE,
+                BasicContentHandlerFactory.parseHandlerType("ignore", null));
+    }
+
+    /** Unknown names throw with the valid list -- they must not fall back to the default. */
+    @Test
+    public void testParseHandlerTypeUnknownThrows() {
+        IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+                () -> BasicContentHandlerFactory.parseHandlerType("txet",
+                        BasicContentHandlerFactory.HANDLER_TYPE.XML));
+        assertTrue(e.getMessage().contains("txet"), e.getMessage());
+        assertTrue(e.getMessage().contains(BasicContentHandlerFactory.VALID_HANDLER_TYPE_NAMES),
+                e.getMessage());
+    }
+
     public static void assertNotContains(String needle, byte[] hayStack)
             throws UnsupportedEncodingException {
         assertNotContains(needle, new String(hayStack, UTF_8));

tika-pipes/tika-pipes-plugins/tika-pipes-http/src/test/java/org/apache/tika/pipes/fetcher/http/HttpFetcherTest.java

@@ -17,7 +17,9 @@
 package org.apache.tika.pipes.fetcher.http;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
@@ -284,6 +286,28 @@ FetcherManager getFetcherManager(String path) throws Exception {
         return FetcherManager.load(TikaPluginManager.load(tikaJsonConfig), tikaJsonConfig);
     }
 
+    /**
+     * The one-line factory hand-off is what makes verifySsl real: deleting it silently
+     * reverts to the factory's never-verify default this option was added to fix.
+     */
+    @Test
+    public void testVerifySslReachesClientFactory() throws Exception {
+        HttpFetcher fetcher = (HttpFetcher) getFetcherManager("tika-config-http.json")
+                .getFetcher("http-fetcher-1");
+        assertTrue(fetcher.getHttpFetcherConfig().isVerifySsl(), "config default must be verify-on");
+        assertTrue(new HttpFetcherConfig().isVerifySsl(), "bare config default must be verify-on");
+
+        HttpClientFactory factory = new HttpClientFactory();
+        assertFalse(factory.isVerifySsl(), "the bare factory defaults to no-verify");
+        fetcher.setHttpClientFactory(factory);
+        fetcher.initialize();
+        assertTrue(factory.isVerifySsl(), "the config default must reach the factory");
+
+        fetcher.getHttpFetcherConfig().setVerifySsl(false);
+        fetcher.initialize();
+        assertFalse(factory.isVerifySsl(), "the explicit opt-out must reach the factory");
+    }
+
     private void mockClientResponse(final HttpResponse response) throws Exception {
         httpFetcher = (HttpFetcher) getFetcherManager("tika-config-http.json").getFetcher("http-fetcher-1");
 

tika-server/tika-server-core/src/test/java/org/apache/tika/server/core/StackTraceTest.java

@@ -19,17 +19,20 @@
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.stream.Stream;
 
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
@@ -136,6 +139,14 @@ public void testEncrypted() throws Exception {
         assertEquals(UNPROCESSEABLE, response.getStatus(), "unprocessable: /unpack");
         msg = getStringFromInputStream((InputStream) response.getEntity());
         assertContains("org.apache.tika.exception.EncryptedDocumentException", msg);
+
+        // The failed unpack must not orphan its zip in the emitter dir (handedOff cleanup).
+        try (Stream<Path> files = Files.list(unpackTempDir)) {
+            List<Path> zips = files
+                    .filter(p -> p.getFileName().toString().endsWith(".zip"))
+                    .toList();
+            assertTrue(zips.isEmpty(), "orphaned unpack zips: " + zips);
+        }
     }
 
     @Test

tika-server/tika-server-core/src/test/java/org/apache/tika/server/core/TikaPipesTest.java

@@ -336,6 +336,19 @@ private Response postTuple(FetchEmitTuple t) throws Exception {
                 .post(writer.toString());
     }
 
+    /** Wiring pin: the reserved-id guard must actually run on /pipes, not just exist. */
+    @Test
+    public void testReservedFetcherIdIs400() throws Exception {
+        FetchEmitTuple t = new FetchEmitTuple("reserved",
+                new FetchKey(org.apache.tika.server.core.resource.PipesParsingHelper.DEFAULT_FETCHER_ID,
+                        "hello_world.xml"),
+                new EmitKey(EMITTER_JSON_ID, ""), new Metadata());
+        Response response = postTuple(t);
+        assertEquals(400, response.getStatus());
+        assertContains("reserved",
+                getStringFromInputStream((InputStream) response.getEntity()));
+    }
+
     /** The /pipes body carries only status: a passback strategy would silently drop data. */
     @Test
     public void testPassbackStrategyIs400() throws Exception {

tika-server/tika-server-core/src/test/java/org/apache/tika/server/core/TikaResourceTest.java

@@ -252,11 +252,71 @@ private String jsonContent(String path, String doc) throws Exception {
                 .accept("application/json")
                 .put(ClassLoader.getSystemResourceAsStream(doc));
         assertEquals(200, response.getStatus(), path + " should have succeeded");
+        return contentOf(response);
+    }
+
+    private static String contentOf(Response response) throws Exception {
         Metadata metadata = JsonMetadata.fromJson(new InputStreamReader(
                 (InputStream) response.getEntity(), StandardCharsets.UTF_8));
         String content = metadata.get(TikaCoreProperties.TIKA_CONTENT);
         return content == null ? "" : content.trim();
     }
 
+    /** Bare /tika must return markdown -- provably distinct from plain text via the heading. */
+    @Test
+    public void testBareTikaIsMarkdownNotText() throws Exception {
+        assertContains("# Chapter One", putRawContent("", TEST_HELLO_WORLD_HEADING));
+        assertNotFound("# Chapter One", putRawContent("/text", TEST_HELLO_WORLD_HEADING));
+    }
 
+    private String putRawContent(String pathSuffix, String doc) throws Exception {
+        Response response = WebClient
+                .create(endPoint + TIKA_PATH + pathSuffix)
+                .put(ClassLoader.getSystemResourceAsStream(doc));
+        assertEquals(200, response.getStatus(), pathSuffix + " should have succeeded");
+        return getStringFromInputStream((InputStream) response.getEntity());
+    }
+
+    /** POST /tika/config defaults to markdown; /config/text is body-only text. */
+    @Test
+    public void testConfigFamilyDefaults() throws Exception {
+        assertContains("# Chapter One", postFileContent("/config", "text/plain"));
+        assertNotFound("# Chapter One", postFileContent("/config/text", "text/plain"));
+    }
+
+    /** The multipart JSON sibling endpoints, incl. the {handler} variant. */
+    @Test
+    public void testConfigJsonHandlerPlumbs() throws Exception {
+        Response md = postFile("/config/json/md", "application/json");
+        assertEquals(200, md.getStatus());
+        assertContains("# Chapter One", contentOf(md));
+
+        Response text = postFile("/config/json/text", "application/json");
+        assertEquals(200, text.getStatus());
+        assertNotFound("# Chapter One", contentOf(text));
+
+        Response dflt = postFile("/config/json", "application/json");
+        assertEquals(200, dflt.getStatus());
+        assertContains("# Chapter One", contentOf(dflt));
+    }
+
+    private Response postFile(String pathSuffix, String accept) {
+        org.apache.cxf.jaxrs.ext.multipart.ContentDisposition cd =
+                new org.apache.cxf.jaxrs.ext.multipart.ContentDisposition(
+                        "form-data; name=\"file\"; filename=\"hello.xml\"");
+        org.apache.cxf.jaxrs.ext.multipart.Attachment att =
+                new org.apache.cxf.jaxrs.ext.multipart.Attachment("file",
+                        ClassLoader.getSystemResourceAsStream(TEST_HELLO_WORLD_HEADING), cd);
+        return WebClient
+                .create(endPoint + TIKA_PATH + pathSuffix)
+                .type("multipart/form-data")
+                .accept(accept)
+                .post(new org.apache.cxf.jaxrs.ext.multipart.MultipartBody(List.of(att)));
+    }
+
+    private String postFileContent(String pathSuffix, String accept) throws Exception {
+        Response response = postFile(pathSuffix, accept);
+        assertEquals(200, response.getStatus(), pathSuffix + " should have succeeded");
+        return getStringFromInputStream((InputStream) response.getEntity());
+    }
 }

tika-server/tika-server-core/src/test/java/org/apache/tika/server/core/TikaServerConfigTest.java

@@ -60,6 +60,15 @@ public void testSupportedFetchersEmitters() throws Exception {
         assertTrue(config.isAllowPerRequestConfig());
     }
 
+    /** Documented defaults: 1 GiB request cap, 60s /async queue pause. */
+    @Test
+    public void testDocumentedDefaults() {
+        TikaServerConfig config = new TikaServerConfig();
+        assertEquals(1024L * 1024 * 1024, config.getMaxRequestSizeBytes());
+        assertEquals(TikaServerConfig.DEFAULT_MAX_QUEUE_PAUSE_MILLIS, config.getMaxQueuePauseMillis());
+        assertEquals(60000L, TikaServerConfig.DEFAULT_MAX_QUEUE_PAUSE_MILLIS);
+    }
+
     @Test
     public void testPorts() throws Exception {
         CommandLineParser parser = new DefaultParser();

tika-server/tika-server-core/src/test/java/org/apache/tika/server/core/TikaServerIntegrationTest.java

@@ -18,6 +18,7 @@
 
 import static java.nio.charset.StandardCharsets.UTF_8;
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.Assertions.fail;
 
 import java.io.IOException;
@@ -106,6 +107,24 @@ public void testBasicWithPipes() throws Exception {
         testBaseline();
     }
 
+    /**
+     * Production wiring pin: BadRequestExceptionMapper must be registered in the real
+     * server assembly, or 400 bodies are empty -- the CXF tests register it by hand,
+     * so only a forked-server test can catch a dropped registration.
+     */
+    @Test
+    public void testBadRequestBodyReachesClient() throws Exception {
+        startProcess(new String[]{"-config", getConfig("tika-config-server-basic.json")});
+        awaitServerStartup();
+        Response response = WebClient
+                .create(endPoint + RMETA_PATH + "/txet")
+                .accept("application/json")
+                .put(ClassLoader.getSystemResourceAsStream(TEST_HELLO_WORLD));
+        assertEquals(400, response.getStatus());
+        String body = new String(((InputStream) response.getEntity()).readAllBytes(), UTF_8);
+        assertTrue(body.contains("Valid types"), body);
+    }
+
     @Test
     public void testH2c() throws Exception {
         startProcess(new String[]{"-config", getConfig("tika-config-server-basic.json")});

tika-server/tika-server-core/src/test/java/org/apache/tika/server/core/resource/PipesResponseBuilderTest.java

@@ -0,0 +1,90 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.tika.server.core.resource;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+import jakarta.ws.rs.core.HttpHeaders;
+import jakarta.ws.rs.core.Response;
+import org.junit.jupiter.api.Test;
+
+import org.apache.tika.pipes.api.PipesResult;
+
+/**
+ * Pins the documented status-code contract (migration guide, index.adoc) without
+ * needing to saturate a real worker pool over HTTP.
+ */
+public class PipesResponseBuilderTest {
+
+    private static Response build(PipesResult.RESULT_STATUS status, long maxWaitMillis) {
+        return PipesParsingHelper.responseBuilder(status, maxWaitMillis).build();
+    }
+
+    private static String retryAfter(Response response) {
+        return response.getHeaderString(HttpHeaders.RETRY_AFTER);
+    }
+
+    @Test
+    public void testPoolSaturationIs429WithWaitBasedRetryAfter() {
+        Response response = build(PipesResult.RESULT_STATUS.CLIENT_UNAVAILABLE_WITHIN_MS, 30_000);
+        assertEquals(429, response.getStatus());
+        assertEquals("30", retryAfter(response));
+    }
+
+    /** Sub-second waits must clamp to 1, not round down to a meaningless 0. */
+    @Test
+    public void testRetryAfterClampsToOneSecond() {
+        Response response = build(PipesResult.RESULT_STATUS.CLIENT_UNAVAILABLE_WITHIN_MS, 100);
+        assertEquals("1", retryAfter(response));
+    }
+
+    @Test
+    public void testCrashFamilyIs503WithShortRetryAfter() {
+        for (PipesResult.RESULT_STATUS status : new PipesResult.RESULT_STATUS[]{
+                PipesResult.RESULT_STATUS.TIMEOUT,
+                PipesResult.RESULT_STATUS.OOM,
+                PipesResult.RESULT_STATUS.UNSPECIFIED_CRASH}) {
+            Response response = build(status, 30_000);
+            assertEquals(503, response.getStatus(), status.name());
+            assertEquals("5", retryAfter(response), status.name());
+        }
+    }
+
+    @Test
+    public void testCallerErrorsAre400WithoutRetryAfter() {
+        for (PipesResult.RESULT_STATUS status : new PipesResult.RESULT_STATUS[]{
+                PipesResult.RESULT_STATUS.FETCHER_NOT_FOUND,
+                PipesResult.RESULT_STATUS.EMITTER_NOT_FOUND}) {
+            Response response = build(status, 30_000);
+            assertEquals(400, response.getStatus(), status.name());
+            assertNull(retryAfter(response), status.name());
+        }
+    }
+
+    @Test
+    public void testIpcPayloadOverflowIs413() {
+        assertEquals(413, build(PipesResult.RESULT_STATUS.PAYLOAD_LIMIT_EXCEEDED, 30_000).getStatus());
+    }
+
+    @Test
+    public void testSuccessIs200WithoutRetryAfter() {
+        Response response = build(PipesResult.RESULT_STATUS.PARSE_SUCCESS, 30_000);
+        assertEquals(200, response.getStatus());
+        assertNull(retryAfter(response));
+    }
+}