Amqp.outboundAdapter(amqpTemplate).routingKey(PROCESS.toQueue()), e -> e.id(PROCESS_OUTBOUND_ENDPOINT)

and then:

@SpringIntegrationTest(noAutoStartup = PreprocessFlowConfiguration.PROCESS_OUTBOUND_ENDPOINT)

That's not correct.
The Amqp.outboundAdapter is an outbound endpoint.
This one is passive, it does something only when the message is sent to its input channel.
What I'm talking about is this one:

Amqp.inboundAdapter(this.rabbitConnectionFactory, PRE_PROCESS.toQueue())
                        .id("preProcessFlowInput")

This is an active endpoint and it consumes RabbitMQ when it is started. And it is started when application context is ready.
And that's when your flow is starting doing something.
So, what I mean is this:

@SpringIntegrationTest(noAutoStartup = "preProcessFlowInput")
...
@Autowired
    @Qualifier("preProcessFlowInput")
    AbstractEndpoint endpoint;

and you start exactly this one when you done with mocking.

That still fails with the same type of output in the logs.

The mock is supposed to be injected here

.handle(Amqp.outboundAdapter(amqpTemplate).routingKey(PROCESS.toQueue()), e -> e.id(PROCESS_OUTBOUND_ENDPOINT)).get();

Am I going about testing this improperly? In my mind I should be able to insert a message on the actual rabbit queue to start the flow, it would go through the normal process defined in the flow and would be published to my mock channel instead of the rabbit outbound queue. Is that not what I should be doing?

Something indeed is off in your case.

So, here is a simple Spring Boot application to consume from AMQP and send to AMQP:

@SpringBootApplication
public class SpringIntegrationTestingApplication {

	public static void main(String[] args) {
		SpringApplication.run(SpringIntegrationTestingApplication.class, args);
	}

	@Bean
	Queue testQueue() {
		return new Queue("testQueue");
	}

	@Bean
	public IntegrationFlow preProcessFlow(ConnectionFactory connectionFactory, AmqpTemplate amqpTemplate) {
		return IntegrationFlows
				.from(Amqp.inboundAdapter(connectionFactory, testQueue()).id("preProcessFlowInput"))
				.handle(Amqp.outboundAdapter(amqpTemplate).routingKey("otherQueue"), e -> e.id("outboundEndpoint"))
				.get();
	}

}

And here is an Integration Mock test:

@SpringBootTest
@SpringIntegrationTest(noAutoStartup = "preProcessFlowInput")
class SpringIntegrationTestingApplicationTests {

	@Autowired
	AmqpTemplate amqpTemplate;

	@Autowired
	@Qualifier("preProcessFlowInput")
	AbstractEndpoint inboundEndpoint;

	@Autowired
	MockIntegrationContext mockIntegrationContext;

	@Test
	void testIntegrationMocks() {
		assertThat(this.inboundEndpoint.isRunning()).isFalse();

		ArgumentCaptor<Message<?>> captor = MockIntegration.messageArgumentCaptor();
		MessageHandler messageHandler = MockIntegration.mockMessageHandler(captor).handleNext(m ->{});
		this.mockIntegrationContext.substituteMessageHandlerFor("outboundEndpoint", messageHandler);

		this.amqpTemplate.convertAndSend("testQueue", "test");
		this.inboundEndpoint.start();

		verify(messageHandler, timeout(5000)).handleMessage(captor.capture());

		Message<?> m = captor.getValue();
		assertThat(m.getPayload()).isEqualTo("test");
	}

}

Please, investigate this one and see what is a difference for you.

The only differences between your example and mine is yours starts the endpoint after you've published a message to the amqp queue and the way the ArgumentCaptor is constructed, MockIntegration.messageArgumentCaptor vs ArgumentCaptor.forClass(). I changed those and the test still fails at the same point. Also, this.mockIntegrationContext.substituteMessageHandlerFor("outboundEndpoint", messageHandler); this line seems to actually start the endpoint once it attaches the handler making this.inboundEndpoint.start(); superfluous.

Another difference is that your flow doesn't do anything in the middle, it just takes the input and sends it to the output. I modified my flow under test to remove the intermediate steps and just route from one queue to the next and it still fails in the same manner. It's behaving as if the mock that's meant to replace the actual outbound message handler isn't actually getting replaced regardless of what the console output says is happening.

To reiterate; my tests all have always worked when run in isolation and only fail when run with other tests. I don't believe the way my project is set up would be all that uncommon

the handler making this.inboundEndpoint.start(); superfluous.

That's not correct.
Even if substituteMessageHandlerFor() starts the endpoint (service activator, an outbound one), the consuming part still need to be started. That one which consumes from RabbitMQ - the beginning of your flow.
All what you say is only feels like you don't have an inbound endpoint stopped before mocking.