QRunIO/qqq
2
0
Fork 0
mirror of https://github.com/Kingsrook/qqq.git synced 2025-07-18 13:10:44 +00:00
Code Issues Packages Projects Releases Wiki Activity

CE-936 add post-actions on scheduledJobParams table, to reschedule jobs

Browse Source
This commit is contained in:
darin.kelkhoff
2024-03-19 20:04:43 -05:00
parent 2545d03f20
commit c9f921c148
4 changed files with 639 additions and 10 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/scheduledjobs/ScheduledJobsMetaDataProvider.java
View File

@ -45,6 +45,7 @@ import com.kingsrook.qqq.backend.core.model.metadata.tables.ExposedJoin;
import com.kingsrook.qqq.backend.core.model.metadata.tables.QFieldSection;
import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
import com.kingsrook.qqq.backend.core.model.metadata.tables.Tier;
import com.kingsrook.qqq.backend.core.model.scheduledjobs.customizers.ScheduledJobParameterTableCustomizer;
import com.kingsrook.qqq.backend.core.model.scheduledjobs.customizers.ScheduledJobTableCustomizer;
@ -205,6 +206,12 @@ public class ScheduledJobsMetaDataProvider
.withSection(new QFieldSection("identity", new QIcon().withName("badge"), Tier.T1, List.of("id", "scheduledJobId", "key", "value")))
.withSection(new QFieldSection("dates", new QIcon().withName("calendar_month"), Tier.T3, List.of("createDate", "modifyDate")));
QCodeReference customizerReference = new QCodeReference(ScheduledJobParameterTableCustomizer.class);
tableMetaData.withCustomizer(TableCustomizers.POST_INSERT_RECORD, customizerReference);
tableMetaData.withCustomizer(TableCustomizers.POST_UPDATE_RECORD, customizerReference);
tableMetaData.withCustomizer(TableCustomizers.POST_DELETE_RECORD, customizerReference);
tableMetaData.withExposedJoin(new ExposedJoin()
.withJoinTable(ScheduledJob.TABLE_NAME)
.withJoinPath(List.of(JOB_PARAMETER_JOIN_NAME))

215
qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/scheduledjobs/customizers/ScheduledJobParameterTableCustomizer.java Normal file
View File

@ -0,0 +1,215 @@
/*
* QQQ - Low-code Application Framework for Engineers.
* Copyright (C) 2021-2024. Kingsrook, LLC
* 651 N Broad St Ste 205 # 6917 | Middletown DE 19709 | United States
* contact@kingsrook.com
* https://github.com/Kingsrook/
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package com.kingsrook.qqq.backend.core.model.scheduledjobs.customizers;
import java.time.Instant;
import java.util.HashSet;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import com.kingsrook.qqq.backend.core.actions.customizers.TableCustomizerInterface;
import com.kingsrook.qqq.backend.core.actions.tables.UpdateAction;
import com.kingsrook.qqq.backend.core.context.QContext;
import com.kingsrook.qqq.backend.core.exceptions.QException;
import com.kingsrook.qqq.backend.core.model.actions.AbstractActionInput;
import com.kingsrook.qqq.backend.core.model.actions.AbstractTableActionInput;
import com.kingsrook.qqq.backend.core.model.actions.tables.delete.DeleteInput;
import com.kingsrook.qqq.backend.core.model.actions.tables.insert.InsertInput;
import com.kingsrook.qqq.backend.core.model.actions.tables.update.UpdateInput;
import com.kingsrook.qqq.backend.core.model.actions.tables.update.UpdateOutput;
import com.kingsrook.qqq.backend.core.model.data.QRecord;
import com.kingsrook.qqq.backend.core.model.scheduledjobs.ScheduledJob;
import com.kingsrook.qqq.backend.core.model.scheduledjobs.ScheduledJobParameter;
import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
import com.kingsrook.qqq.backend.core.utils.ListingHash;
/*******************************************************************************
**
*******************************************************************************/
public class ScheduledJobParameterTableCustomizer implements TableCustomizerInterface
{
/*******************************************************************************
**
*******************************************************************************/
@Override
public List<QRecord> postInsert(InsertInput insertInput, List<QRecord> records) throws QException
{
///////////////////////////////////////////////////////////////////////////////////////
// if we're in this insert as a result of an insert (or update) on a different table //
// (e.g., under a manageAssociations call), then return with noop - assume that the //
// parent table's customizer will do what needed to be done. //
///////////////////////////////////////////////////////////////////////////////////////
if(!isThisAnActionDirectlyOnThisTable())
{
return (records);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// else - this was an action directly on this table - so bump all of the parent records, to get them rescheduled //
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bumpParentRecords(records, Optional.empty());
return (records);
}
/*******************************************************************************
**
*******************************************************************************/
private void bumpParentRecords(List<QRecord> records, Optional<List<QRecord>> oldRecordList) throws QException
{
try
{
///////////////////////////////////////////////////////////////////////////////////////////
// (listing) hash up the records by scheduledJobId - we'll use this to have a set of the //
// job ids, and in case we need to add warnings to them later //
///////////////////////////////////////////////////////////////////////////////////////////
ListingHash<Integer, QRecord> recordsByJobId = new ListingHash<>();
for(QRecord record : records)
{
recordsByJobId.add(record.getValueInteger("scheduledJobId"), record);
}
Set<Integer> scheduledJobIds = new HashSet<>(recordsByJobId.keySet());
////////////////////////////////////////////////////////////////////////////////
// if we have an old record list (e.g., is an edit), add any job ids that are //
// in those too, e.g., in case moving a param from one job to another... //
// note, we won't line these up for doing a proper warning on these... //
////////////////////////////////////////////////////////////////////////////////
if(oldRecordList.isPresent())
{
for(QRecord oldRecord : oldRecordList.get())
{
scheduledJobIds.add(oldRecord.getValueInteger("scheduledJobId"));
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////
// update the modify date on the scheduled jobs - to get their post-actions to run, to reschedule //
////////////////////////////////////////////////////////////////////////////////////////////////////
UpdateInput updateInput = new UpdateInput();
updateInput.setTableName(ScheduledJob.TABLE_NAME);
updateInput.setRecords(scheduledJobIds.stream()
.map(id -> new QRecord().withValue("id", id).withValue("modifyDate", Instant.now()))
.toList());
UpdateOutput updateOutput = new UpdateAction().execute(updateInput);
////////////////////////////////////////////////////////////////////////////////////////
// look for warnings on those jobs - and propagate them to the params we just stored. //
////////////////////////////////////////////////////////////////////////////////////////
for(QRecord updatedScheduledJob : updateOutput.getRecords())
{
if(CollectionUtils.nullSafeHasContents(updatedScheduledJob.getWarnings()))
{
for(QRecord paramToWarn : CollectionUtils.nonNullList(recordsByJobId.get(updatedScheduledJob.getValueInteger("id"))))
{
paramToWarn.setWarnings(updatedScheduledJob.getWarnings());
}
}
}
}
catch(Exception e)
{
LOG.warn("Error in scheduledJobParameter post-crud", e);
}
}
/*******************************************************************************
**
*******************************************************************************/
@Override
public List<QRecord> postUpdate(UpdateInput updateInput, List<QRecord> records, Optional<List<QRecord>> oldRecordList) throws QException
{
/////////////////////////////////////////////////////////////////////////////
// if we're in this update as a result of an update on a different table //
// (e.g., under a manageAssociations call), then return with noop - assume //
// that the parent table's customizer will do what needed to be done. //
/////////////////////////////////////////////////////////////////////////////
if(!isThisAnActionDirectlyOnThisTable())
{
return (records);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// else - this was an action directly on this table - so bump all of the parent records, to get them rescheduled //
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bumpParentRecords(records, oldRecordList);
return (records);
}
/*******************************************************************************
**
*******************************************************************************/
@Override
public List<QRecord> postDelete(DeleteInput deleteInput, List<QRecord> records) throws QException
{
/////////////////////////////////////////////////////////////////////////////
// if we're in this update as a result of an update on a different table //
// (e.g., under a manageAssociations call), then return with noop - assume //
// that the parent table's customizer will do what needed to be done. //
/////////////////////////////////////////////////////////////////////////////
if(!isThisAnActionDirectlyOnThisTable())
{
return (records);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// else - this was an action directly on this table - so bump all of the parent records, to get them rescheduled //
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bumpParentRecords(records, Optional.empty());
return (records);
}
/*******************************************************************************
**
*******************************************************************************/
private static boolean isThisAnActionDirectlyOnThisTable()
{
Optional<AbstractActionInput> firstActionInStack = QContext.getFirstActionInStack();
if(firstActionInStack.isPresent())
{
if(firstActionInStack.get() instanceof AbstractTableActionInput tableActionInput)
{
if(!ScheduledJobParameter.TABLE_NAME.equals(tableActionInput.getTableName()))
{
return (false);
}
}
}
return (true);
}
}

44
qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/scheduledjobs/customizers/ScheduledJobTableCustomizer.java
View File

@ -22,10 +22,12 @@
package com.kingsrook.qqq.backend.core.model.scheduledjobs.customizers;
import java.io.Serializable;
import java.text.ParseException;
import java.util.Collections;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.function.Predicate;
@ -47,6 +49,7 @@ import com.kingsrook.qqq.backend.core.model.statusmessages.QWarningMessage;
import com.kingsrook.qqq.backend.core.scheduler.QScheduleManager;
import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
import com.kingsrook.qqq.backend.core.utils.StringUtils;
import org.quartz.CronScheduleBuilder;
import static com.kingsrook.qqq.backend.core.logging.LogUtils.logPair;
@ -62,7 +65,7 @@ public class ScheduledJobTableCustomizer implements TableCustomizerInterface
@Override
public List<QRecord> preInsert(InsertInput insertInput, List<QRecord> records, boolean isPreview) throws QException
{
validateConditionalFields(records);
validateConditionalFields(records, Collections.emptyMap());
return (records);
}
@ -86,7 +89,9 @@ public class ScheduledJobTableCustomizer implements TableCustomizerInterface
@Override
public List<QRecord> preUpdate(UpdateInput updateInput, List<QRecord> records, boolean isPreview, Optional<List<QRecord>> oldRecordList) throws QException
{
validateConditionalFields(records);
Map<Integer, QRecord> freshOldRecordsWithAssociationsMap = CollectionUtils.recordsToMap(freshlyQueryForRecordsWithAssociations(oldRecordList.get()), "id", Integer.class);
validateConditionalFields(records, freshOldRecordsWithAssociationsMap);
if(isPreview || oldRecordList.isEmpty())
{
@ -96,8 +101,7 @@ public class ScheduledJobTableCustomizer implements TableCustomizerInterface
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// refresh the old-records w/ versions that have associations - so we can use those in the post-update to property unschedule things //
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Map<Serializable, QRecord> freshOldRecordsWithAssociationsMap = CollectionUtils.recordsToMap(freshlyQueryForRecordsWithAssociations(oldRecordList.get()), "id");
ListIterator<QRecord> iterator = oldRecordList.get().listIterator();
ListIterator<QRecord> iterator = oldRecordList.get().listIterator();
while(iterator.hasNext())
{
QRecord record = iterator.next();
@ -116,20 +120,40 @@ public class ScheduledJobTableCustomizer implements TableCustomizerInterface
/*******************************************************************************
**
*******************************************************************************/
private static void validateConditionalFields(List<QRecord> records)
private static void validateConditionalFields(List<QRecord> records, Map<Integer, QRecord> freshOldRecordsWithAssociationsMap)
{
QRecord blankRecord = new QRecord();
for(QRecord record : records)
{
if(StringUtils.hasContent(record.getValueString("cronExpression")))
QRecord oldRecord = Objects.requireNonNullElse(freshOldRecordsWithAssociationsMap.get(record.getValueInteger("id")), blankRecord);
String cronExpression = record.getValues().containsKey("cronExpression") ? record.getValueString("cronExpression") : oldRecord.getValueString("cronExpression");
String cronTimeZoneId = record.getValues().containsKey("cronTimeZoneId") ? record.getValueString("cronTimeZoneId") : oldRecord.getValueString("cronTimeZoneId");
String repeatSeconds = record.getValues().containsKey("repeatSeconds") ? record.getValueString("repeatSeconds") : oldRecord.getValueString("repeatSeconds");
if(StringUtils.hasContent(cronExpression))
{
if(!StringUtils.hasContent(record.getValueString("cronTimeZoneId")))
if(StringUtils.hasContent(repeatSeconds))
{
record.addError(new BadInputStatusMessage("If a Cron Expression is given, then a Cron Time Zone Id is required."));
record.addError(new BadInputStatusMessage("Cron Expression and Repeat Seconds may not both be given."));
}
try
{
CronScheduleBuilder.cronScheduleNonvalidatedExpression(cronExpression);
}
catch(ParseException e)
{
record.addError(new BadInputStatusMessage("Cron Expression [" + cronExpression + "] is not valid: " + e.getMessage()));
}
if(!StringUtils.hasContent(cronTimeZoneId))
{
record.addError(new BadInputStatusMessage("If a Cron Expression is given, then a Cron Time Zone is required."));
}
}
else
{
if(!StringUtils.hasContent(record.getValueString("repeatSeconds")))
if(!StringUtils.hasContent(repeatSeconds))
{
record.addError(new BadInputStatusMessage("Either Cron Expression or Repeat Seconds must be given."));
}

383
qqq-backend-core/src/test/java/com/kingsrook/qqq/backend/core/model/scheduledjobs/customizers/ScheduledJobTableCustomizerTest.java Normal file
View File

@ -0,0 +1,383 @@
/*
* QQQ - Low-code Application Framework for Engineers.
* Copyright (C) 2021-2024. Kingsrook, LLC
* 651 N Broad St Ste 205 # 6917 | Middletown DE 19709 | United States
* contact@kingsrook.com
* https://github.com/Kingsrook/
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package com.kingsrook.qqq.backend.core.model.scheduledjobs.customizers;
import java.time.Instant;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
import com.kingsrook.qqq.backend.core.BaseTest;
import com.kingsrook.qqq.backend.core.actions.tables.DeleteAction;
import com.kingsrook.qqq.backend.core.actions.tables.InsertAction;
import com.kingsrook.qqq.backend.core.actions.tables.UpdateAction;
import com.kingsrook.qqq.backend.core.context.QContext;
import com.kingsrook.qqq.backend.core.exceptions.QException;
import com.kingsrook.qqq.backend.core.model.actions.tables.delete.DeleteInput;
import com.kingsrook.qqq.backend.core.model.actions.tables.insert.InsertInput;
import com.kingsrook.qqq.backend.core.model.actions.tables.insert.InsertOutput;
import com.kingsrook.qqq.backend.core.model.actions.tables.update.UpdateInput;
import com.kingsrook.qqq.backend.core.model.actions.tables.update.UpdateOutput;
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.scheduledjobs.ScheduledJob;
import com.kingsrook.qqq.backend.core.model.scheduledjobs.ScheduledJobParameter;
import com.kingsrook.qqq.backend.core.model.scheduledjobs.ScheduledJobType;
import com.kingsrook.qqq.backend.core.model.scheduledjobs.ScheduledJobsMetaDataProvider;
import com.kingsrook.qqq.backend.core.model.session.QSession;
import com.kingsrook.qqq.backend.core.scheduler.QScheduleManager;
import com.kingsrook.qqq.backend.core.scheduler.quartz.QuartzJobAndTriggerWrapper;
import com.kingsrook.qqq.backend.core.scheduler.quartz.QuartzTestUtils;
import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
import com.kingsrook.qqq.backend.core.utils.TestUtils;
import com.kingsrook.qqq.backend.core.utils.lambdas.UnsafeFunction;
import org.assertj.core.api.AbstractStringAssert;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.quartz.CronTrigger;
import org.quartz.SchedulerException;
import org.quartz.SimpleTrigger;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
/*******************************************************************************
** Unit test for ScheduledJobTableCustomizer
*******************************************************************************/
class ScheduledJobTableCustomizerTest extends BaseTest
{
private static final String GOOD_CRON = "0 * * * * ?";
private static final String GOOD_CRON_2 = "* * * * * ?";
private static final String BAD_CRON = "* * * * * *";
/*******************************************************************************
**
*******************************************************************************/
@BeforeEach
void beforeEach() throws QException
{
QInstance qInstance = QContext.getQInstance();
QuartzTestUtils.setupInstanceForQuartzTests();
QSession qSession = QContext.getQSession();
QScheduleManager qScheduleManager = QScheduleManager.initInstance(qInstance, () -> qSession);
qScheduleManager.start();
new ScheduledJobsMetaDataProvider().defineAll(qInstance, TestUtils.MEMORY_BACKEND_NAME, null);
}
/*******************************************************************************
**
*******************************************************************************/
@AfterEach
void afterEach()
{
QuartzTestUtils.afterEach();
}
/*******************************************************************************
**
*******************************************************************************/
@Test
void testPreInsertAssertValidationErrors() throws QException
{
UnsafeFunction<Consumer<ScheduledJob>, QRecord, QException> tryToInsert = consumer ->
{
ScheduledJob scheduledJob = new ScheduledJob()
.withLabel("Test")
.withSchedulerName(QuartzTestUtils.QUARTZ_SCHEDULER_NAME)
.withType(ScheduledJobType.PROCESS.name())
.withIsActive(true);
consumer.accept(scheduledJob);
InsertOutput insertOutput = new InsertAction().execute(new InsertInput(ScheduledJob.TABLE_NAME).withRecordEntity(scheduledJob));
return (insertOutput.getRecords().get(0));
};
/////////////////////////////////////////////////////////
// lambdas to run a test and assert about no of errors //
/////////////////////////////////////////////////////////
Function<QRecord, AbstractStringAssert<?>> assertOneErrorExtractingMessage = qRecord -> assertThat(qRecord.getErrors()).hasSize(1).first().extracting("message").asString();
Consumer<QRecord> assertNoErrors = qRecord -> assertThat(qRecord.getErrors()).hasSize(0);
assertOneErrorExtractingMessage.apply(tryToInsert.apply(sj -> sj.setId(null)))
.contains("Either Cron Expression or Repeat Seconds must be given");
assertOneErrorExtractingMessage.apply(tryToInsert.apply(sj -> sj.withRepeatSeconds(1).withCronExpression(GOOD_CRON).withCronTimeZoneId("UTC")))
.contains("Cron Expression and Repeat Seconds may not both be given");
assertOneErrorExtractingMessage.apply(tryToInsert.apply(sj -> sj.withRepeatSeconds(null).withCronExpression(GOOD_CRON)))
.contains("If a Cron Expression is given, then a Cron Time Zone is required");
assertOneErrorExtractingMessage.apply(tryToInsert.apply(sj -> sj.withRepeatSeconds(null).withCronExpression(BAD_CRON).withCronTimeZoneId("UTC")))
.contains("Support for specifying both a day-of-week AND a day-of-month parameter is not implemented");
///////////////////
// success cases //
///////////////////
assertNoErrors.accept(tryToInsert.apply(sj -> sj.withCronExpression(GOOD_CRON).withCronTimeZoneId("UTC")));
assertNoErrors.accept(tryToInsert.apply(sj -> sj.withRepeatSeconds(1)));
}
/*******************************************************************************
**
*******************************************************************************/
@Test
void testPostInsertActionSchedulesJob() throws QException, SchedulerException
{
List<QuartzJobAndTriggerWrapper> wrappers = QuartzTestUtils.queryQuartz();
assertEquals(0, wrappers.size());
InsertOutput insertOutput = new InsertAction().execute(new InsertInput(ScheduledJob.TABLE_NAME).withRecordEntity(new ScheduledJob()
.withLabel("Test")
.withSchedulerName(QuartzTestUtils.QUARTZ_SCHEDULER_NAME)
.withType(ScheduledJobType.PROCESS.name())
.withIsActive(true)
.withRepeatSeconds(1)
.withJobParameters(List.of(
new ScheduledJobParameter().withKey("processName").withValue(TestUtils.PROCESS_NAME_BASEPULL)))));
assertTrue(CollectionUtils.nullSafeIsEmpty(insertOutput.getRecords().get(0).getErrors()));
assertTrue(CollectionUtils.nullSafeIsEmpty(insertOutput.getRecords().get(0).getWarnings()));
wrappers = QuartzTestUtils.queryQuartz();
assertEquals(1, wrappers.size());
}
/*******************************************************************************
**
*******************************************************************************/
@Test
void testPostInsertActionIssuesWarnings() throws QException, SchedulerException
{
List<QuartzJobAndTriggerWrapper> wrappers = QuartzTestUtils.queryQuartz();
assertEquals(0, wrappers.size());
InsertOutput insertOutput = new InsertAction().execute(new InsertInput(ScheduledJob.TABLE_NAME).withRecordEntity(new ScheduledJob()
.withLabel("Test")
.withSchedulerName(QuartzTestUtils.QUARTZ_SCHEDULER_NAME)
.withType(ScheduledJobType.PROCESS.name())
.withIsActive(true)
.withRepeatSeconds(1)
.withJobParameters(List.of(
new ScheduledJobParameter().withKey("processName").withValue("notAProcess")))));
assertTrue(CollectionUtils.nullSafeIsEmpty(insertOutput.getRecords().get(0).getErrors()));
assertThat(insertOutput.getRecords().get(0).getWarnings())
.hasSize(1).first().extracting("message").asString()
.contains("Error scheduling job: Unrecognized processName");
wrappers = QuartzTestUtils.queryQuartz();
assertEquals(0, wrappers.size());
}
/*******************************************************************************
**
*******************************************************************************/
@Test
void testPreUpdateAssertValidationErrors() throws QException
{
new InsertAction().execute(new InsertInput(ScheduledJob.TABLE_NAME).withRecordEntity(new ScheduledJob()
.withLabel("Test")
.withSchedulerName(QuartzTestUtils.QUARTZ_SCHEDULER_NAME)
.withType(ScheduledJobType.PROCESS.name())
.withIsActive(true)
.withRepeatSeconds(1)));
UnsafeFunction<Consumer<QRecord>, QRecord, QException> tryToUpdate = consumer ->
{
QRecord record = new QRecord().withValue("id", 1);
consumer.accept(record);
UpdateOutput updateOutput = new UpdateAction().execute(new UpdateInput(ScheduledJob.TABLE_NAME).withRecord(record));
return (updateOutput.getRecords().get(0));
};
/////////////////////////////////////////////////////////
// lambdas to run a test and assert about no of errors //
/////////////////////////////////////////////////////////
Function<QRecord, AbstractStringAssert<?>> assertOneErrorExtractingMessage = qRecord -> assertThat(qRecord.getErrors()).hasSize(1).first().extracting("message").asString();
Consumer<QRecord> assertNoErrors = qRecord -> assertThat(qRecord.getErrors()).hasSize(0);
assertOneErrorExtractingMessage.apply(tryToUpdate.apply(r -> r.withValue("repeatSeconds", null)))
.contains("Either Cron Expression or Repeat Seconds must be given");
assertOneErrorExtractingMessage.apply(tryToUpdate.apply(r -> r.withValue("cronExpression", GOOD_CRON).withValue("cronTimeZoneId", "UTC")))
.contains("Cron Expression and Repeat Seconds may not both be given");
assertOneErrorExtractingMessage.apply(tryToUpdate.apply(r -> r.withValue("repeatSeconds", null).withValue("cronExpression", GOOD_CRON)))
.contains("If a Cron Expression is given, then a Cron Time Zone is required");
assertOneErrorExtractingMessage.apply(tryToUpdate.apply(r -> r.withValue("repeatSeconds", null).withValue("cronExpression", BAD_CRON).withValue("cronTimeZoneId", "UTC")))
.contains("Support for specifying both a day-of-week AND a day-of-month parameter is not implemented");
///////////////////
// success cases //
///////////////////
assertNoErrors.accept(tryToUpdate.apply(r -> r.withValue("modifyDate", Instant.now())));
assertNoErrors.accept(tryToUpdate.apply(r -> r.withValue("repeatSeconds", null).withValue("cronExpression", GOOD_CRON).withValue("cronTimeZoneId", "UTC")));
assertNoErrors.accept(tryToUpdate.apply(r -> r.withValue("repeatSeconds", null).withValue("cronExpression", GOOD_CRON_2).withValue("cronTimeZoneId", "UTC")));
assertNoErrors.accept(tryToUpdate.apply(r -> r.withValue("repeatSeconds", null).withValue("cronExpression", GOOD_CRON).withValue("cronTimeZoneId", "America/Chicago")));
assertNoErrors.accept(tryToUpdate.apply(r -> r.withValue("repeatSeconds", 1).withValue("cronExpression", null).withValue("cronTimeZoneId", null)));
assertNoErrors.accept(tryToUpdate.apply(r -> r.withValue("repeatSeconds", 2)));
}
/*******************************************************************************
**
*******************************************************************************/
@Test
void testPostUpdateActionReSchedulesJob() throws QException, SchedulerException
{
List<QuartzJobAndTriggerWrapper> wrappers = QuartzTestUtils.queryQuartz();
assertEquals(0, wrappers.size());
//////////////////////////////////////////////////
// do an insert - this will originally schedule //
//////////////////////////////////////////////////
new InsertAction().execute(new InsertInput(ScheduledJob.TABLE_NAME).withRecordEntity(new ScheduledJob()
.withLabel("Test")
.withSchedulerName(QuartzTestUtils.QUARTZ_SCHEDULER_NAME)
.withType(ScheduledJobType.PROCESS.name())
.withIsActive(true)
.withRepeatSeconds(1)
.withJobParameters(List.of(new ScheduledJobParameter().withKey("processName").withValue(TestUtils.PROCESS_NAME_BASEPULL)))));
wrappers = QuartzTestUtils.queryQuartz();
assertEquals(1, wrappers.size());
assertThat(wrappers.get(0).trigger()).isInstanceOf(SimpleTrigger.class);
//////////////////////////////////////
// now do an update, to re-schedule //
//////////////////////////////////////
new UpdateAction().execute(new UpdateInput(ScheduledJob.TABLE_NAME).withRecordEntity(new ScheduledJob()
.withId(1)
.withLabel("Test")
.withSchedulerName(QuartzTestUtils.QUARTZ_SCHEDULER_NAME)
.withType(ScheduledJobType.PROCESS.name())
.withIsActive(true)
.withRepeatSeconds(null)
.withCronExpression(GOOD_CRON)
.withCronTimeZoneId("UTC")));
wrappers = QuartzTestUtils.queryQuartz();
assertEquals(1, wrappers.size());
assertThat(wrappers.get(0).trigger()).isInstanceOf(CronTrigger.class);
}
/*******************************************************************************
**
*******************************************************************************/
@Test
void testPostUpdateActionIssuesWarnings() throws QException, SchedulerException
{
List<QuartzJobAndTriggerWrapper> wrappers = QuartzTestUtils.queryQuartz();
assertEquals(0, wrappers.size());
//////////////////////////////////////////////////
// do an insert - this will originally schedule //
//////////////////////////////////////////////////
new InsertAction().execute(new InsertInput(ScheduledJob.TABLE_NAME).withRecordEntity(new ScheduledJob()
.withLabel("Test")
.withSchedulerName(QuartzTestUtils.QUARTZ_SCHEDULER_NAME)
.withType(ScheduledJobType.PROCESS.name())
.withIsActive(true)
.withRepeatSeconds(1)
.withJobParameters(List.of(new ScheduledJobParameter().withKey("processName").withValue(TestUtils.PROCESS_NAME_BASEPULL)))));
wrappers = QuartzTestUtils.queryQuartz();
assertEquals(1, wrappers.size());
assertThat(wrappers.get(0).trigger()).isInstanceOf(SimpleTrigger.class);
//////////////////////////////////////
// now do an update, to re-schedule //
//////////////////////////////////////
UpdateOutput updateOutput = new UpdateAction().execute(new UpdateInput(ScheduledJob.TABLE_NAME).withRecordEntity(new ScheduledJob()
.withId(1)
.withLabel("Test")
.withSchedulerName(QuartzTestUtils.QUARTZ_SCHEDULER_NAME)
.withType(ScheduledJobType.PROCESS.name())
.withIsActive(true)
.withRepeatSeconds(null)
.withCronExpression(GOOD_CRON)
.withCronTimeZoneId("UTC")
.withJobParameters(List.of(new ScheduledJobParameter().withKey("process").withValue("not")))));
assertTrue(CollectionUtils.nullSafeIsEmpty(updateOutput.getRecords().get(0).getErrors()));
assertThat(updateOutput.getRecords().get(0).getWarnings())
.hasSize(1).first().extracting("message").asString()
.contains("Missing scheduledJobParameter with key [processName]");
wrappers = QuartzTestUtils.queryQuartz();
assertEquals(0, wrappers.size());
}
/*******************************************************************************
**
*******************************************************************************/
@Test
void testPostDeleteUnschedules() throws QException, SchedulerException
{
List<QuartzJobAndTriggerWrapper> wrappers = QuartzTestUtils.queryQuartz();
assertEquals(0, wrappers.size());
//////////////////////////////////////////////////
// do an insert - this will originally schedule //
//////////////////////////////////////////////////
new InsertAction().execute(new InsertInput(ScheduledJob.TABLE_NAME).withRecordEntity(new ScheduledJob()
.withLabel("Test")
.withSchedulerName(QuartzTestUtils.QUARTZ_SCHEDULER_NAME)
.withType(ScheduledJobType.PROCESS.name())
.withIsActive(true)
.withRepeatSeconds(1)
.withJobParameters(List.of(new ScheduledJobParameter().withKey("processName").withValue(TestUtils.PROCESS_NAME_BASEPULL)))));
wrappers = QuartzTestUtils.queryQuartz();
assertEquals(1, wrappers.size());
////////////////////////////////////
// now do a delete, to unschedule //
////////////////////////////////////
new DeleteAction().execute(new DeleteInput(ScheduledJob.TABLE_NAME).withPrimaryKeys(List.of(1)));
wrappers = QuartzTestUtils.queryQuartz();
assertEquals(0, wrappers.size());
}
}