Files
qbit-printing/src/test/java/com/kingsrook/qbits/printing/PrintingProcessesTest.java
T
james.maesandClaude Sonnet 5.5 e4639e3cca chore: integrate printing standards and strict Java compiler checks
Preserve current rendering, operator and retained-source behavior while integrating script quality, meaningful headers and strict Error Prone/NullAway contracts. Production and test compilation and the 189-case verification gate pass with zero failures and one intentional workload skip.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Signed-off-by: James Maes <james@kof22.com>
2026-11-01 16:51:18 -06:00

553 lines
35 KiB
Java

/*
* QQQ - Low-code Application Framework for Engineers.
* Copyright (C) 2021-2025. Kingsrook, LLC
* 651 N Broad St Ste 205 # 6917 | Middletown DE 19709 | United States
* contact@kingsrook.com
* https://github.com/Kingsrook/
*
* Licensed 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
*
* https://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 com.kingsrook.qbits.printing;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import com.kingsrook.qqq.backend.core.actions.processes.RunProcessAction;
import com.kingsrook.qqq.backend.core.actions.tables.QueryAction;
import com.kingsrook.qqq.backend.core.actions.values.SearchPossibleValueSourceAction;
import com.kingsrook.qqq.backend.core.context.QContext;
import com.kingsrook.qqq.backend.core.exceptions.QException;
import com.kingsrook.qqq.backend.core.model.actions.processes.RunBackendStepInput;
import com.kingsrook.qqq.backend.core.model.actions.processes.RunBackendStepOutput;
import com.kingsrook.qqq.backend.core.model.actions.processes.RunProcessInput;
import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryInput;
import com.kingsrook.qqq.backend.core.model.actions.values.SearchPossibleValueSourceInput;
import com.kingsrook.qqq.backend.core.model.data.QRecord;
import com.kingsrook.qqq.backend.core.model.metadata.QInstance;
import com.kingsrook.qqq.backend.core.model.metadata.authentication.QAuthenticationMetaData;
import com.kingsrook.qqq.backend.core.model.metadata.fields.QFieldMetaData;
import com.kingsrook.qqq.backend.core.model.metadata.possiblevalues.PossibleValueSearchFilterUseCase;
import com.kingsrook.qqq.backend.core.model.metadata.processes.QFrontendStepMetaData;
import com.kingsrook.qqq.backend.core.model.session.QSession;
import com.kingsrook.qqq.backend.core.model.session.QUser;
import com.kingsrook.qqq.backend.module.rdbms.model.metadata.RDBMSBackendMetaData;
import org.json.JSONArray;
import org.json.JSONObject;
import org.jspecify.annotations.Nullable;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
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;
/*******************************************************************************
** Real RDBMS selectors and native table/record process boundaries.
*******************************************************************************/
class PrintingProcessesTest
{
/***************************************************************************
** Standalone enrollment has a named default instead of accepting arbitrary raw IDs.
***************************************************************************/
@Test
void standaloneFacilitySelectorRejectsForgedValues() throws Exception
{
Fixture fixture = fixture();
QFieldMetaData field = ((QFrontendStepMetaData) fixture.instance().getProcess("printingEnrollDevice").getStep("details")).getFormField("facilityId");
assertEquals("printing_facility", field.getPossibleValueSourceName());
assertEquals("default", field.getDefaultValue());
assertEquals(field.getPossibleValueSourceName(), fixture.instance().getTable(PrintingTables.DEVICE).getField("facility_id").getPossibleValueSourceName());
var choices = new SearchPossibleValueSourceAction().execute(new SearchPossibleValueSourceInput().withPossibleValueSourceName(field.getPossibleValueSourceName()));
assertEquals(1, choices.getResults().size());
assertEquals("Default facility", choices.getResults().getFirst().getLabel());
assertEquals("default", PrintingFacilities.validate("default"));
RunBackendStepInput forged = new RunBackendStepInput().withProcessName("printingEnrollDevice")
.addValue("facilityId", "invented-id").addValue("deviceName", "station");
assertThrows(QException.class, () -> new PrintingProcesses().run(forged, new RunBackendStepOutput()));
assertThrows(QException.class, () -> PrintingFacilities.validate(null));
assertThrows(QException.class, () -> PrintingFacilities.validate(""));
assertThrows(QException.class, () -> PrintingFacilities.register(fixture.instance(), new PrintingQBitConfig().withFacilityPossibleValueSourceName("missing_source")));
}
/***************************************************************************
** A forged selection cannot bypass the host source's real tenant record lock.
***************************************************************************/
@Test
void configuredFacilitySelectorHonorsRecordSecurityAtEnrollment() throws Exception
{
Fixture fixture = fixture("host_facilities");
assertEquals("host_facilities", PrintingFacilities.field(fixture.instance()).getPossibleValueSourceName());
assertEquals("host_facilities", fixture.instance().getTable(PrintingTables.DEVICE).getField("facility_id").getPossibleValueSourceName());
assertEquals(fixture.device(), PrintingFacilities.validate(fixture.device()));
RunBackendStepInput input = new RunBackendStepInput().withProcessName("printingEnrollDevice")
.addValue("facilityId", fixture.foreignDevice()).addValue("deviceName", "station");
RunBackendStepOutput prepared = new RunBackendStepOutput();
new PrintingProcesses.PrepareEnrollment().run(input, prepared);
input.addValue("printingEnrollmentCode", prepared.getValueString("printingEnrollmentCode"))
.addValue("printingEnrollmentExpires", prepared.getValueString("printingEnrollmentExpires"));
assertThrows(QException.class, () -> new PrintingProcesses().run(input, new RunBackendStepOutput()));
input.addValue("facilityId", fixture.device());
RunBackendStepOutput accepted = new RunBackendStepOutput();
new PrintingProcesses().run(input, accepted);
assertTrue(accepted.getValueString("result").startsWith("Enrollment code:"));
}
/***************************************************************************
** The production QQQ host extension point mounts routes with host auth.
***************************************************************************/
@Test
void productionApplicationHostRegistersPrintingRoutesAndPreservesAdminGate() throws Exception
{
Fixture fixture = fixture();
var application = new com.kingsrook.qqq.backend.core.instances.AbstractQQQApplication()
{
@Override
public QInstance defineQInstance()
{
return fixture.instance();
}
};
var javalin = new java.util.concurrent.atomic.AtomicReference<io.javalin.Javalin>();
var server = new com.kingsrook.qqq.middleware.javalin.QApplicationJavalinServer(application)
.withPort(0).withServeFrontendNext(false).withServeFrontendMaterialDashboard(false)
.withJavalinConfigCustomizer(config -> config.jetty.host = "127.0.0.1")
.withJavalinConfigurationCustomizer(javalin::set)
.withAdditionalRouteProviders(List.of(new PrintingRoutes(fixture.service(), context -> "allowed".equals(context.header("X-Test-Admin")))));
try(java.net.http.HttpClient client = java.net.http.HttpClient.newHttpClient())
{
server.start();
java.net.URI url = java.net.URI.create("http://127.0.0.1:" + java.util.Objects.requireNonNull(javalin.get(), "Test HTTP server was not started").port() + "/printing/v1/admin/devices");
assertEquals(403, client.send(java.net.http.HttpRequest.newBuilder(url).GET().build(), java.net.http.HttpResponse.BodyHandlers.discarding()).statusCode());
var response = client.send(java.net.http.HttpRequest.newBuilder(url).header("X-Test-Admin", "allowed").GET().build(), java.net.http.HttpResponse.BodyHandlers.ofString());
assertEquals(200, response.statusCode());
assertEquals(2, new JSONObject(response.body()).getJSONArray("devices").length());
assertFalse(response.body().contains("token_hash"));
}
finally
{
server.stop();
}
}
/***************************************************************************
** Real QQQ pause/resume phases review selections before any job is queued.
***************************************************************************/
@Test
void selectedTestPausesForProfileAndReviewThenSubmitsOnce() throws Exception
{
Fixture fixture = fixture();
String process = "printingTestSelectedPdf";
var profile = new RunProcessAction().execute(new RunProcessInput().withProcessName(process).withValue("recordIds", fixture.printerId()));
assertFalse(profile.getException().isPresent(), () -> profile.getException().toString());
assertEquals("testProfile", profile.getProcessState().getNextStepName().orElseThrow());
assertEquals(0, fixture.service().jobs().length());
var review = new RunProcessAction().execute(new RunProcessInput().withProcessName(process).withProcessUUID(profile.getProcessUUID())
.withStartAfterStep("testProfile").withValue("testProfile", "LETTER"));
assertFalse(review.getException().isPresent(), () -> review.getException().toString());
assertTrue(review.getProcessState().getNextStepName().isPresent());
assertEquals(0, fixture.service().jobs().length());
var submitted = new RunProcessAction().execute(new RunProcessInput().withProcessName(process).withProcessUUID(review.getProcessUUID())
.withStartAfterStep(review.getProcessState().getNextStepName().orElseThrow()).withFrontendStepBehavior(RunProcessInput.FrontendStepBehavior.SKIP));
assertFalse(submitted.getException().isPresent(), () -> submitted.getException().toString());
assertEquals(1, fixture.service().jobs().length());
}
/***************************************************************************
** Enrollment replay cannot issue extra codes or reactivate consumed ones.
***************************************************************************/
@Test
void nativeEnrollmentReplayRetainsCodeAndNeverReactivatesConsumedReceipt() throws Exception
{
Fixture fixture = fixture();
RunBackendStepInput input = new RunBackendStepInput().withProcessName("printingEnrollDevice")
.addValue("facilityId", "default").addValue("deviceName", "station");
RunBackendStepOutput prepared = new RunBackendStepOutput();
new PrintingProcesses.PrepareEnrollment().run(input, prepared);
input.addValue("printingEnrollmentCode", prepared.getValueString("printingEnrollmentCode"))
.addValue("printingEnrollmentExpires", prepared.getValueString("printingEnrollmentExpires"));
RunBackendStepOutput first = new RunBackendStepOutput();
RunBackendStepOutput second = new RunBackendStepOutput();
new PrintingProcesses().run(input, first);
new PrintingProcesses().run(input, second);
assertEquals(first.getValueString("result"), second.getValueString("result"));
JSONObject enrollment = new JSONObject().put("enrollmentCode", prepared.getValueString("printingEnrollmentCode")).put("deviceName", "station").put("agentVersion", "test");
fixture.service().enroll(enrollment);
assertThrows(QException.class, () -> new PrintingProcesses().run(input, new RunBackendStepOutput()));
assertThrows(PrintingException.class, () -> fixture.service().enroll(enrollment));
input.addValue("printingEnrollmentExpires", java.time.Instant.now().minusSeconds(1).toString());
assertThrows(QException.class, () -> new PrintingProcesses().run(input, new RunBackendStepOutput()));
}
/***************************************************************************
** A lost load response must not duplicate a physical test on process replay.
***************************************************************************/
@Test
void testActionsDeduplicateSingleAndSelectedLoadReplay() throws Exception
{
Fixture fixture = fixture();
RunBackendStepInput single = new RunBackendStepInput().withProcessName("printingTestPdf")
.addValue("deviceId", fixture.device()).addValue("printerId", fixture.printerId()).addValue("printingTestRequestId", "single-replay");
for(int attempt = 0; attempt < 2; attempt++)
{
new PrintingProcesses().run(single, new RunBackendStepOutput());
}
assertEquals(1, fixture.service().jobs().length());
RunBackendStepInput selected = new RunBackendStepInput().withProcessName("printingTestSelectedPdf")
.withRecords(List.of(new QRecord().withValue("id", fixture.printerId()), new QRecord().withValue("id", fixture.otherPrinterId())))
.addValue("printingTestRequestId", "selected-replay");
for(int attempt = 0; attempt < 2; attempt++)
{
new PrintingProcesses.SelectedLoad().runOnePage(selected, new RunBackendStepOutput());
}
assertEquals(3, fixture.service().jobs().length());
}
/***************************************************************************
** Native actions and device requests use identical bundled label documents.
***************************************************************************/
@Test
void builtInTestEntryPointsShareProfilesAndRejectChangedIdempotentRequests() throws Exception
{
Fixture fixture = fixture();
fixture.service().inventory(fixture.device(), new JSONArray().put(new JSONObject().put("printerId", "laser")
.put("name", "Packing test printer").put("formats", new JSONArray(List.of("PDF", "ZPL")))));
QRecord printer = PrintingProcesses.resolvePrinter(fixture.printerId(), fixture.device());
String nativeJob = PrintingProcesses.submitTest(printer, false, "LABEL_4X6_300");
JSONObject request = new JSONObject().put("printerId", "laser").put("format", "ZPL").put("testProfile", "LABEL_4X6_300").put("requestId", "label-profile-test");
String deviceJob = fixture.service().testPrint(fixture.device(), request).getString("jobId");
assertEquals(fixture.service().getJob(nativeJob).getString("contentSha256"), fixture.service().getJob(deviceJob).getString("contentSha256"));
assertEquals(deviceJob, fixture.service().testPrint(fixture.device(), request).getString("jobId"));
assertEquals(409, assertThrows(PrintingException.class, () -> fixture.service().testPrint(fixture.device(), request.put("testProfile", "LABEL_4X6_203"))).getStatus());
assertEquals(nativeJob, fixture.service().claim(fixture.device()).getJSONObject("job").getString("jobId"));
assertArrayEquals(PrintingTestDocuments.zpl(300), fixture.service().content(fixture.device(), nativeJob));
assertEquals(400, assertThrows(PrintingException.class, () -> fixture.service().testPrint(fixture.device(), request.put("testProfile", "LETTER"))).getStatus());
assertThrows(PrintingException.class, () -> fixture.service().testPrint(fixture.device(), request.put("testProfile", JSONObject.NULL)));
assertThrows(PrintingException.class, () -> fixture.service().testPrint(fixture.device(), request.put("format", "RAW")));
assertThrows(QException.class, () -> PrintingProcesses.submitTest(printer, false, "A4"));
assertEquals(1, fixture.service().queuedJobs(fixture.device()).length());
}
/***************************************************************************
** Stock/resolution choices are present before both native review flows.
***************************************************************************/
@Test
void nativeFormsOfferStockAndResolutionBeforeSelectedPrinterReview() throws Exception
{
Fixture fixture = fixture();
QFrontendStepMetaData single = (QFrontendStepMetaData) fixture.instance().getProcess("printingTestZpl").getStep("details");
assertEquals("printing_testProfileZpl", single.getFormField("testProfile").getPossibleValueSourceName());
var selected = fixture.instance().getProcess("printingTestSelectedPdf");
assertEquals("prepareTest", selected.getStepList().getFirst().getName());
assertEquals("testProfile", selected.getStepList().get(1).getName());
QFrontendStepMetaData form = (QFrontendStepMetaData) selected.getStep("testProfile");
assertEquals("printing_testProfilePdf", form.getFormField("testProfile").getPossibleValueSourceName());
assertEquals(3, fixture.instance().getPossibleValueSource("printing_testProfileZpl").getEnumValues().size());
assertEquals(5, fixture.instance().getPossibleValueSource("printing_testProfilePdf").getEnumValues().size());
}
/***************************************************************************
** Native record selection requires duplicate consent and preserves the source.
***************************************************************************/
@Test
void selectedJobRetryReviewsRiskRequiresConsentAndDeduplicatesReplay() throws Exception
{
Fixture fixture = fixture();
String original = PrintingProcesses.submitTest(PrintingProcesses.resolvePrinter(fixture.printerId(), fixture.device()), true);
fixture.service().claim(fixture.device());
for(String status : List.of("RECEIVED", "SUBMITTING", "SPOOLED"))
{
fixture.service().event(fixture.device(), original, new JSONObject().put("eventId", UUID.randomUUID().toString()).put("status", status));
}
var process = fixture.instance().getProcess(PrintingJobProcesses.RETRY);
assertEquals(PrintingTables.JOB, process.getTableName());
assertEquals(1, process.getMinInputRecords());
assertTrue(process.getStep("confirmDuplicateRisk") instanceof QFrontendStepMetaData);
RunBackendStepInput selection = new RunBackendStepInput().withProcessName(PrintingJobProcesses.RETRY)
.withRecords(List.of(new QRecord().withValue("id", original))).addValue("printingRetryRequestId", "process-retry");
RunBackendStepOutput preview = new RunBackendStepOutput();
new PrintingJobProcesses.Transform().runOnePage(selection, preview);
assertEquals("QQQ print test", preview.getRecords().getFirst().getValueString("title"));
assertTrue(fixture.service().claim(fixture.device()).isNull("job"));
assertThrows(QException.class, () -> new PrintingJobProcesses.Load().runOnePage(selection, new RunBackendStepOutput()));
for(int replay = 0; replay < 2; replay++)
{
var result = new RunProcessAction().execute(new RunProcessInput().withProcessName(PrintingJobProcesses.RETRY)
.withValue("recordIds", original).withValue("printingRetryRequestId", "process-retry").withValue("confirmDuplicateRisk", true)
.withFrontendStepBehavior(RunProcessInput.FrontendStepBehavior.SKIP));
assertFalse(result.getException().isPresent(), () -> result.getException().toString());
}
QueryInput query = new QueryInput();
query.setTableName(PrintingTables.JOB);
List<QRecord> jobs = new QueryAction().execute(query).getRecords();
assertEquals(2, jobs.size());
assertEquals("SPOOLED", jobs.stream().filter(job -> original.equals(job.getValueString("id"))).findFirst().orElseThrow().getValueString("status"));
}
/***************************************************************************
** Cancel supports table selections but cannot cancel work already claimed.
***************************************************************************/
@Test
void selectedJobCancellationRechecksStateAndTenant() throws Exception
{
Fixture fixture = fixture();
String first = PrintingProcesses.submitTest(PrintingProcesses.resolvePrinter(fixture.printerId(), fixture.device()), true);
String second = PrintingProcesses.submitTest(PrintingProcesses.resolvePrinter(fixture.otherPrinterId(), fixture.otherDevice()), true);
var result = new RunProcessAction().execute(new RunProcessInput().withProcessName(PrintingJobProcesses.CANCEL)
.withValue("recordIds", first + "," + second).withFrontendStepBehavior(RunProcessInput.FrontendStepBehavior.SKIP));
assertFalse(result.getException().isPresent(), () -> result.getException().toString());
assertTrue(fixture.service().claim(fixture.device()).isNull("job"));
assertTrue(fixture.service().claim(fixture.otherDevice()).isNull("job"));
var replay = new RunProcessAction().execute(new RunProcessInput().withProcessName(PrintingJobProcesses.CANCEL)
.withValue("recordIds", first + "," + second).withFrontendStepBehavior(RunProcessInput.FrontendStepBehavior.SKIP));
assertFalse(replay.getException().isPresent(), () -> replay.getException().toString());
String claimed = PrintingProcesses.submitTest(PrintingProcesses.resolvePrinter(fixture.printerId(), fixture.device()), true);
fixture.service().claim(fixture.device());
RunBackendStepInput selection = new RunBackendStepInput().withProcessName(PrintingJobProcesses.CANCEL)
.withRecords(List.of(new QRecord().withValue("id", claimed).withValue("status", "QUEUED")));
assertThrows(QException.class, () -> new PrintingJobProcesses.Load().runOnePage(selection, new RunBackendStepOutput()));
QContext.getQSession().setSecurityKeyValues(Map.of("printing_tenant", List.of("tenant-b")));
assertThrows(QException.class, () -> new PrintingJobProcesses.Transform().runOnePage(selection, new RunBackendStepOutput()));
QContext.getQSession().setSecurityKeyValues(Map.of("printing_tenant", List.of("tenant-a")));
QContext.getQSession().setPermissions(java.util.Set.of());
assertThrows(QException.class, () -> new PrintingJobProcesses.Load().runOnePage(selection, new RunBackendStepOutput()));
}
/***************************************************************************
** Do not carry identity into another test.
***************************************************************************/
@AfterEach
void clearContext()
{
QContext.clear();
}
/***************************************************************************
** Device filtering and tenant security both apply to named printer choices.
***************************************************************************/
@Test
void selectorsAreNamedDependentAndTenantScoped() throws Exception
{
Fixture fixture = fixture();
QFieldMetaData field = ((QFrontendStepMetaData) fixture.instance().getProcess("printingTestPdf").getStep("details")).getFormField("printerId");
assertEquals(PrintingTables.PRINTER, field.getPossibleValueSourceName());
assertEquals(List.of("deviceId"), field.getPossibleValueSourceDependsOn());
var filter = field.getPossibleValueSourceFilter().clone();
filter.interpretValues(Map.of("input", Map.of("deviceId", fixture.device())), PossibleValueSearchFilterUseCase.FORM);
var choices = new SearchPossibleValueSourceAction().execute(new SearchPossibleValueSourceInput()
.withPossibleValueSourceName(PrintingTables.PRINTER).withDefaultQueryFilter(filter)).getResults();
assertEquals(1, choices.size());
assertEquals("Packing laser", choices.getFirst().getLabel());
assertEquals(fixture.printerId(), choices.getFirst().getId());
var devices = new SearchPossibleValueSourceAction().execute(new SearchPossibleValueSourceInput().withPossibleValueSourceName(PrintingTables.DEVICE)).getResults();
assertEquals(2, devices.size());
assertTrue(devices.stream().noneMatch(value -> value.getLabel().contains("Other tenant")));
assertThrows(QException.class, () -> PrintingProcesses.resolvePrinter(fixture.printerId(), fixture.otherDevice()));
assertThrows(QException.class, () -> PrintingProcesses.resolvePrinter(fixture.foreignPrinterId(), null));
assertTrue(fixture.instance().getTables().keySet().stream().allMatch(name -> name.startsWith("printing_")));
assertTrue(fixture.instance().getProcesses().keySet().stream().allMatch(name -> name.startsWith("printing")));
assertTrue(fixture.instance().getPossibleValueSources().keySet().containsAll(List.of(PrintingTables.DEVICE, PrintingTables.PRINTER, "printing_enabled", "printing_approved", "printing_available", "printing_format", "printing_jobStatus", "printing_printerStatus")));
assertEquals(PrintingTables.DEVICE, fixture.instance().getProcess("printingEnrollDevice").getTableName());
var columns = (PrintingQBitProducer.DefaultColumns) fixture.instance().getTable(PrintingTables.PRINTER).getSupplementalMetaData("nextUi");
assertTrue(columns.getDefaultColumns().containsAll(List.of("status", "enabled", "available")));
assertTrue(columns.getDefaultColumns().contains("location"));
assertFalse(columns.getDefaultColumns().contains("description"));
assertEquals(4096, fixture.instance().getTable(PrintingTables.PRINTER).getField("description").getMaxLength());
assertEquals(1024, fixture.instance().getTable(PrintingTables.PRINTER).getField("queue_name").getMaxLength());
fixture.service().inventory(fixture.device(), new JSONArray().put(new JSONObject().put("printerId", "laser").put("name", "Packing laser").put("displayName", "Shipping desk").put("description", "Shared dispatch printer").put("location", "Dock 2").put("formats", new JSONArray(List.of("PDF")))));
var labeledChoices = new SearchPossibleValueSourceAction().execute(new SearchPossibleValueSourceInput()
.withPossibleValueSourceName(PrintingTables.PRINTER).withDefaultQueryFilter(filter)).getResults();
assertTrue(labeledChoices.stream().anyMatch(value -> value.getLabel().equals("Shipping desk")));
assertTrue(fixture.instance().getTable(PrintingTables.PRINTER).getDisabledCapabilities().containsAll(com.kingsrook.qqq.backend.core.model.metadata.tables.Capability.allWriteCapabilities()));
assertTrue(fixture.instance().getTable(PrintingTables.PRINTER).getField("tenant_id").getIsHidden());
}
/***************************************************************************
** Real record IDs enter through QQQ extraction; preview has no side effects.
***************************************************************************/
@Test
void selectedPrinterActionsPreviewThenQueueAndDisable() throws Exception
{
Fixture fixture = fixture();
var process = fixture.instance().getProcess("printingTestSelectedPdf");
assertEquals(PrintingTables.PRINTER, process.getTableName());
assertEquals(1, process.getMinInputRecords());
RunBackendStepOutput preview = new RunBackendStepOutput();
new PrintingProcesses.SelectedTransform().runOnePage(new RunBackendStepInput().withProcessName(process.getName())
.withRecords(List.of(new QRecord().withValue("id", fixture.printerId()))), preview);
assertEquals(1, preview.getRecords().size());
assertTrue(fixture.service().claim(fixture.device()).isNull("job"));
var result = new RunProcessAction().execute(new RunProcessInput().withProcessName(process.getName())
.withValue("recordIds", fixture.printerId() + "," + fixture.otherPrinterId()).withFrontendStepBehavior(RunProcessInput.FrontendStepBehavior.SKIP));
assertFalse(result.getException().isPresent(), () -> result.getException().toString());
JSONObject job = fixture.service().claim(fixture.device()).getJSONObject("job");
assertEquals("PDF", job.getString("format"));
assertEquals("laser", job.getString("printerId"));
assertEquals("PDF", fixture.service().claim(fixture.otherDevice()).getJSONObject("job").getString("format"));
var disabled = new RunProcessAction().execute(new RunProcessInput().withProcessName("printingDisableSelectedPrinters")
.withValue("recordIds", fixture.printerId()).withFrontendStepBehavior(RunProcessInput.FrontendStepBehavior.SKIP));
assertFalse(disabled.getException().isPresent(), () -> disabled.getException().toString());
assertFalse(fixture.service().printers(fixture.device()).getJSONObject(0).getBoolean("enabled"));
assertThrows(QException.class, () -> new PrintingProcesses.SelectedTransform().runOnePage(new RunBackendStepInput().withProcessName(process.getName())
.withRecords(List.of(new QRecord().withValue("id", fixture.printerId()))), new RunBackendStepOutput()));
}
/***************************************************************************
** An altered record payload cannot select another tenant's queue.
***************************************************************************/
@Test
void selectedLoadRechecksPermissionsAndRecordOwnership() throws Exception
{
Fixture fixture = fixture();
RunBackendStepInput forged = new RunBackendStepInput().withProcessName("printingTestSelectedPdf")
.withRecords(List.of(new QRecord().withValue("id", fixture.foreignPrinterId()).withValue("device_id", fixture.device()).withValue("printer_id", "laser")));
assertThrows(QException.class, () -> new PrintingProcesses.SelectedLoad().runOnePage(forged, new RunBackendStepOutput()));
QContext.getQSession().setPermissions(java.util.Set.of());
assertThrows(QException.class, () -> new PrintingProcesses.SelectedLoad().runOnePage(new RunBackendStepInput().withProcessName("printingTestSelectedPdf")
.withRecords(List.of(new QRecord().withValue("id", fixture.printerId()))), new RunBackendStepOutput()));
}
/***************************************************************************
** Enrollment has no input record, so it must bind session scope explicitly.
***************************************************************************/
@Test
void enrollmentRejectsMissingAndWrongTenantDespiteAdminPermission() throws Exception
{
fixture();
RunBackendStepInput input = new RunBackendStepInput().withProcessName("printingEnrollDevice").addValue("facilityId", "default").addValue("deviceName", "station");
QContext.getQSession().setSecurityKeyValues(Map.of("printing_tenant", List.of("tenant-b")));
assertThrows(com.kingsrook.qqq.backend.core.exceptions.QPermissionDeniedException.class, () -> new PrintingProcesses().run(input, new RunBackendStepOutput()));
QContext.getQSession().setSecurityKeyValues(Map.of());
assertThrows(com.kingsrook.qqq.backend.core.exceptions.QPermissionDeniedException.class, () -> new PrintingProcesses().run(input, new RunBackendStepOutput()));
}
/***************************************************************************
** One database, two tenants and multiple devices exercise real query scoping.
***************************************************************************/
static Fixture fixture() throws Exception
{
return fixture(null);
}
/***************************************************************************
** An optional host facility source reuses real tenant-scoped device rows as fixtures.
***************************************************************************/
private static Fixture fixture(@Nullable String facilitySource) throws Exception
{
String database = "printing_process_" + UUID.randomUUID();
String jdbc = "jdbc:h2:mem:" + database + ";DB_CLOSE_DELAY=-1;DATABASE_TO_UPPER=FALSE";
DriverDataSource source = new DriverDataSource(jdbc, "sa", "");
PrintingService service = new PrintingService(source, "tenant-a");
service.initialize();
String device = enroll(service, "Packing station");
String otherDevice = enroll(service, "Other station");
configure(service, device, "Packing laser");
configure(service, otherDevice, "Other laser");
PrintingService otherTenant = new PrintingService(source, "tenant-b");
String foreign = enroll(otherTenant, "Other tenant station");
configure(otherTenant, foreign, "Other tenant laser");
String backendName = "printing-db-" + UUID.randomUUID();
QInstance instance = new QInstance();
instance.addBackend(new RDBMSBackendMetaData().withName(backendName).withVendor("h2").withHostName("mem").withDatabaseName(database).withJdbcUrl(jdbc).withUsername("sa").withPassword(""));
instance.withInstanceDefaultAuthentication(new QAuthenticationMetaData().withName("mock").withType(com.kingsrook.qqq.backend.core.model.metadata.QAuthenticationType.MOCK));
if(facilitySource != null)
{
instance.addPossibleValueSource(com.kingsrook.qqq.backend.core.model.metadata.possiblevalues.QPossibleValueSource.newForTable(PrintingTables.DEVICE).withName(facilitySource));
}
new PrintingQBitProducer().withConfig(new PrintingQBitConfig().withBackendName(backendName).withService(service)
.withFacilityPossibleValueSourceName(facilitySource)).produce(instance, "printing");
QContext.init(instance, new QSession().withUser(new QUser().withIdReference("operator")).withPermissions("printing_admin").withSecurityKeyValue("printing_tenant", "tenant-a"));
QueryInput query = new QueryInput();
query.setTableName(PrintingTables.PRINTER);
List<QRecord> rows = new QueryAction().execute(query).getRecords();
String printerId = rows.stream().filter(row -> device.equals(row.getValueString("device_id"))).findFirst().orElseThrow().getValueString("id");
String otherPrinterId = rows.stream().filter(row -> otherDevice.equals(row.getValueString("device_id"))).findFirst().orElseThrow().getValueString("id");
String foreignId;
try(var connection = source.getConnection(); var statement = connection.prepareStatement("SELECT id FROM printing_printer WHERE device_id=?"))
{
statement.setString(1, foreign);
try(var result = statement.executeQuery())
{
result.next();
foreignId = result.getString(1);
}
}
return new Fixture(instance, service, device, otherDevice, printerId, otherPrinterId, foreignId, foreign);
}
/***************************************************************************
** Single-use enrollment helper.
***************************************************************************/
private static String enroll(PrintingService service, String name) throws Exception
{
return service.enroll(service.createEnrollment("warehouse", name).put("deviceName", name).put("agentVersion", "test")).getString("deviceId");
}
/***************************************************************************
** Synthetic printer only; tests never contact Windows or real hardware.
***************************************************************************/
private static void configure(PrintingService service, String device, String name) throws Exception
{
service.inventory(device, new JSONArray().put(new JSONObject().put("printerId", "laser").put("name", name).put("formats", new JSONArray(List.of("PDF")))));
service.enablePrinter(device, "laser", true);
}
/***************************************************************************
** Per-test handles, without exposed device tokens.
***************************************************************************/
record Fixture(QInstance instance, PrintingService service, String device, String otherDevice, String printerId, String otherPrinterId, String foreignPrinterId, String foreignDevice)
{
}
}