verteilen-core 1.0.0

package/src/script/webhook_server_manager.ts

@@ -0,0 +1,102 @@
+import * as path from 'path';
+import * as ws from 'ws'
+import * as pem from 'pem'
+import * as https from 'https'
+import * as os from 'os'
+import { DATA_FOLDER, Header, Messager, Messager_log, WebHookPORT } from '../interface'
+import { check } from 'tcp-port-used'
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs'
+
+export class WebhookServerManager {
+
+    private httpss:https.Server<any> | undefined = undefined
+    private server:ws.Server | undefined = undefined
+    private sources:Array<WebSocket> = []
+    private messager:Messager
+    private messager_log:Messager_log
+
+    constructor(_messager:Messager, _messager_log:Messager_log) {
+        this.messager = _messager
+        this.messager_log = _messager_log
+    }
+
+    Init = async () => {
+        let port_result = WebHookPORT
+        let canbeuse = false
+
+        while(!canbeuse){
+            await check(port_result).then(x => {
+                canbeuse = !x
+            }).catch(err => {
+                canbeuse = true
+            })
+            if(!canbeuse) port_result += 1
+        }
+
+        const pems = await this.get_pem()
+        this.httpss = https.createServer({ key: pems[0], cert: pems[1], minVersion: 'TLSv1.2', maxVersion: 'TLSv1.3' }, (req, res) => {
+            res.writeHead(200)
+            res.end('HTTPS server is running');
+        })
+        this.httpss.addListener('upgrade', (req, res, head) => console.log('UPGRADE:', req.url))
+        this.server = new ws.Server({server: this.httpss})
+        this.server.on('listening', () => {
+            this.messager_log('[Server] Listen PORT: ' + port_result.toString())
+        })
+        this.server.on('error', (err) => {
+            this.messager_log(`[Server] Error ${err.name}\n\t${err.message}\n\t${err.stack}`)
+        })
+        this.server.on('close', () => {
+            this.messager_log('[Server] Close !')
+            this.Release()
+        })
+        this.server.on('connection', (ws, request) => {
+            this.messager_log(`[Server] New Connection detected, ${ws.url}`)
+            ws.on('close', (code, reason) => {
+                this.messager_log(`[Source] Close ${code} ${reason}`)
+            })
+            ws.on('error', (err) => {
+                this.messager_log(`[Source] Error ${err.name}\n\t${err.message}\n\t${err.stack}`)
+            })
+            ws.on('open', () => {
+                this.messager_log(`[Source] New source is connected, URL: ${ws?.url}`)
+            })
+            ws.on('message', (data, isBinery) => {
+                const h:Header | undefined = JSON.parse(data.toString());
+            })
+        })
+        this.httpss.listen(port_result, () => {
+            this.messager_log('[Server] Select Port: ' + port_result.toString())
+        })
+    }
+
+    Destroy = () => {
+        if(this.server == undefined) return
+        this.server.close((err) => {
+            this.messager_log(`[Client] Close error ${err}`)
+        })
+        this.Release()
+    }
+
+    Release = () => {
+        
+    }
+
+    private get_pem = ():Promise<[string, string]> => {
+        return new Promise<[string, string]>((resolve) => {
+            const pemFolder = path.join(os.homedir(), DATA_FOLDER, 'pem')
+            if(!existsSync(pemFolder)) mkdirSync(pemFolder)
+            const clientKey = path.join(pemFolder, "cluster_clientkey.pem")
+            const certificate = path.join(pemFolder, "cluster_certificate.pem")
+            if(!existsSync(clientKey) || !existsSync(certificate)){
+                pem.createCertificate({selfSigned: true}, (err, keys) => {
+                    writeFileSync(clientKey, keys.clientKey, { encoding: 'utf8' })
+                    writeFileSync(certificate, keys.certificate, { encoding: 'utf8' })
+                    resolve([keys.clientKey, keys.certificate])
+                })
+            }else{
+                resolve([readFileSync(clientKey, 'utf8').toString(), readFileSync(certificate, 'utf8').toString()])
+            }
+        })
+    }
+}

package/src/util/server/console_handle.ts

@@ -0,0 +1,248 @@
+import { ConditionResult, ExecutePair, ExecuteProxy, ExecuteRecordTask, ExecuteState, FeedBack, Job, JobCategory, MESSAGE_LIMIT, Parameter, Project, Record, Task } from "../../interface"
+
+export class Util_Server_Console { 
+
+    receivedPack = (model:ExecutePair, record:Record) => {
+        const pass = model.manager!.Register()
+        if(pass == -1){
+            model.record!.running = false
+            model.record!.stop = true
+            return false
+        }
+        model.record!.projects = record.projects
+        model.record!.nodes = record.nodes
+        model.record!.project_state = model.record!.projects.map(x => {
+            return {
+                uuid: x.uuid,
+                state: ExecuteState.NONE
+            }
+        })
+        model.record!.project_index = pass
+        model.record!.project = record.projects[pass].uuid
+        model.record!.task_index = 0
+        model.record!.task_state = model.record!.projects[0].task.map(x => {
+            return {
+                uuid: x.uuid,
+                state: ExecuteState.NONE
+            }
+        })
+        model.record!.task_state[0].state = ExecuteState.RUNNING
+        model.record!.task_detail = []
+        const task = model.record!.projects[model.record!.project_index]?.task[model.record!.task_index]
+        const count = task.cronjob ? (task?.jobs.length ?? 0) : 1
+        for(let i = 0; i < count; i++){
+            model.record!.task_detail.push({
+                index: i,
+                node: "",
+                message: [],
+                state: ExecuteState.NONE
+            })
+        }
+        model.manager!.Update()
+        return true
+    }
+}
+
+export class Util_Server_Console_Proxy {
+    model:ExecutePair
+
+    constructor(_model:ExecutePair){
+        this.model = _model
+    }
+
+    public get execute_proxy() : ExecuteProxy {
+        const d:ExecuteProxy = {
+            executeProjectStart: (data:[Project, number]):void => { this.execute_project_start(data) },
+            executeProjectFinish: (data:[Project, number]):void => { this.execute_project_finish(data) },
+            executeTaskStart: (data:[Task, number]):void => { this.execute_task_start(data) },
+            executeTaskFinish: (data:Task):void => { this.execute_task_finish(data) },
+            executeSubtaskStart: (data:[Task, number, string]):void => { this.execute_subtask_start(data) },
+            executeSubtaskUpdate: (data:[Task, number, string, ExecuteState]):void => { this.execute_subtask_update(data) },
+            executeSubtaskFinish: (data:[Task, number, string]):void => { this.execute_subtask_end(data) },
+            executeJobStart: (data:[Job, number, string]):void => { this.execute_job_start(data) },
+            executeJobFinish: (data:[Job, number, string, number]):void => { this.execute_job_finish(data) },
+            feedbackMessage: (data:FeedBack):void => { this.feedback_message(data) },
+            updateParameter: (data:Parameter):void => { this.update_runtime_parameter(data) }
+        }
+        return d
+    }
+
+    execute_project_start = (d:[Project, number]) => {
+        const index = d[1]
+        if(index == -1) return
+        this.model.record!.project = d[0].uuid
+        this.model.record!.project_index = index
+        this.model.record!.project_state[index].state = ExecuteState.RUNNING
+        this.model.record!.task_state = this.model.record!.projects[index].task.map(x => {
+            return {
+                uuid: x.uuid,
+                state: ExecuteState.NONE
+            }
+        })
+        this.model.record!.task_detail = []
+        const task = this.model.record!.projects[this.model.record!.project_index]?.task[this.model.record!.task_index]
+        const count = task.cronjob ? (task?.jobs.length ?? 0) : 1
+        for(let i = 0; i < count; i++){
+            this.model.record!.task_detail.push({
+                index: i,
+                node: "",
+                message: [],
+                state: ExecuteState.NONE
+            })
+        }
+        console.log("project start: ", this.model.record!.projects.length, index)
+    }
+    
+    execute_project_finish = (d:[Project, number]) => {
+        if(this.model.record!.process_type >= 1) {
+            this.model.record!.running = false
+            this.model.record!.stop = true
+        }
+        const index = d[1]
+        const size = this.model.record!.projects.length
+        if(index == -1) return
+        this.model.record!.project = ""
+        this.model.record!.project_state[index].state = ExecuteState.FINISH
+        this.model.record!.para = undefined
+        console.log("project finish: ", this.model.record!.projects.length, index)
+
+        if(index == size - 1){
+            this.model.record!.command.push(['clean'])
+        }
+    }
+    
+    execute_task_start = (d:[Task, number]) => {
+        if (this.model.record!.project_index == -1) return
+        const index = this.model.record!.projects[this.model.record!.project_index].task.findIndex(x => x.uuid == d[0].uuid)
+        if(index == -1) return
+        this.model.record!.useCron = d[0].cronjob
+        this.model.record!.task = d[0].uuid
+        this.model.record!.task_index = index
+        this.model.record!.task_state[index].state = ExecuteState.RUNNING
+        for(let i = 0; i < index; i++) this.model.record!.task_state[i].state =  ExecuteState.FINISH
+        for(let i = index + 1; i < this.model.record!.task_state.length; i++) this.model.record!.task_state[i].state =  ExecuteState.NONE
+        this.model.record!.task_detail = []
+        const p = this.model.record!.projects[this.model.record!.project_index]
+        const t = p.task[this.model.record!.task_index]
+        const count = this.model.manager!.get_task_state_count(t)
+        for(let i = 0; i < count; i++){
+            this.model.record!.task_detail.push({
+                index: i,
+                node: "",
+                message: [],
+                state: ExecuteState.NONE
+            })
+        }
+    }
+
+    execute_task_finish = (d:Task) => {
+        if(this.model.record!.process_type == 2) {
+            this.model.record!.running = false
+            this.model.record!.stop = true
+        }
+        if (this.model.record!.project_index == -1) return
+        const index = this.model.record!.projects[this.model.record!.project_index].task.findIndex(x => x.uuid == d.uuid)
+        if(index == -1) return
+        this.model.record!.useCron = false
+        this.model.record!.task = ""
+        this.model.record!.task_state[index].state = ExecuteState.FINISH
+        if(index + 1 < this.model.record!.task_state.length - 1){
+            this.model.record!.task_state[index + 1].state = ExecuteState.RUNNING
+        }
+    }
+    
+    execute_subtask_start = (d:[Task, number, string]) => {
+        try{
+            this.model.record!.task_detail[d[1]].node = d[2] ?? ''
+            this.model.record!.task_detail[d[1]].state = ExecuteState.RUNNING
+        }catch(error:any) {
+            console.error(`execute_subtask_start`, error.message)
+        }
+    }
+
+    execute_subtask_update = (d:[Task, number, string, ExecuteState]) => {
+        if(this.model.record!.task_detail.length > d[1]){
+            this.model.record!.task_detail[d[1]].node = d[2]
+            this.model.record!.task_detail[d[1]].state = d[3]
+        }else{
+            console.error(`subtask_start ${d[1]} is out of range: ${this.model.record!.task_detail.length}`)
+        }
+    }
+
+    execute_subtask_end = (d:[Task, number, string]) => {
+        try{
+            this.model.record!.task_detail[d[1]].state = ExecuteState.FINISH
+        }catch(error:any) {
+            console.error(`execute_subtask_end`, error.message)
+        }
+    }
+    
+    execute_job_start = (d:[Job, number, string]) => {
+        if (this.model.record!.project_index == -1) return
+        if(!this.model.record!.useCron){
+            this.model.record!.task_detail[0].node = d[2]
+        }
+    }
+    
+    execute_job_finish = (d:[Job, number, string, number]) => {
+        if (d[3] == 1){
+            const task = this.model.record!.projects[this.model.record!.project_index].task[this.model.record!.task_index]
+            const index = task.jobs.findIndex(x => x.uuid == d[0].uuid)
+            if(index != -1 && task.jobs[index].category == JobCategory.Condition){
+                const cr:ConditionResult = task.jobs[index].number_args[0] as ConditionResult
+                if(cr == ConditionResult.None) return
+                
+                this.model.record!.command.push(['stop'])
+                let timer:any
+                timer = setInterval(() => {
+                    if(this.model.record!.running == false){
+                        clearInterval(timer)
+                        const state = (cr == ConditionResult.ThrowTask || cr == ConditionResult.ThrowProject) ? ExecuteState.ERROR : ExecuteState.SKIP
+                        const target: ExecuteRecordTask | undefined = this.model.record!.task_detail[d[1]]
+                        if(target != undefined) {
+                            target.state = state
+                        }
+                        if (cr == ConditionResult.Pause) return
+                        if (cr == ConditionResult.SkipProject || cr == ConditionResult.ThrowProject){
+                            this.model.record!.command.push(['skip', 0, state])
+                            if(this.model.record!.project.length > 0){
+                                if(this.model.record!.process_type == 0){
+                                    this.model.record!.command.push(['execute', this.model.record!.process_type])
+                                }
+                            }
+                        }
+                        else if (cr == ConditionResult.SkipTask || cr == ConditionResult.ThrowTask){
+                            this.model.record!.command.push(['skip', 1, state])
+                            if(this.model.record!.project.length > 0){
+                                if(this.model.record!.process_type == 0){
+                                    this.model.record!.command.push(['execute', this.model.record!.process_type])
+                                }
+                            }
+                        }
+                    }
+                }, 1000);
+            }
+        }
+        //model.value![1].task_detail[index].node = ""
+    }
+
+    feedback_message = (d:FeedBack) => {
+        if(d.index == undefined || d.index == -1) return
+        const container = this.model.record!.task_detail[d.index]
+        if(container != undefined){
+            container.message.push(d.message)
+            if(container.message.length > MESSAGE_LIMIT){
+                container.message.shift()
+            }
+        }
+    }
+
+    /**
+     * When parameter getting change by the process steps\
+     * This get called
+     * @param d The whole container for the parameters
+     */
+    update_runtime_parameter = (d:Parameter, ) => {
+        this.model.record!.para = d
+    }
+}

package/src/util/server/log_handle.ts

@@ -0,0 +1,194 @@
+import { v6 as uuid6 } from 'uuid'
+import { ConditionResult, ExecutePair, ExecuteProxy, ExecuteRecordTask, ExecuteState, ExecutionLog, FeedBack, Job, JobCategory, Log, Parameter, Preference, Project, Task } from "../../interface"
+import * as fs from 'fs'
+
+export class Util_Server_Log_Proxy {
+    model:ExecutePair
+    logs:Log
+    preference:Preference
+
+    private task_index:number = 0
+    private uuid:string = ''
+    private get target_log ():ExecutionLog | undefined {
+        return this.logs.logs.find(x => x.uuid == this.uuid)!
+    }
+
+    constructor(_model:ExecutePair, _log:Log, _preference:Preference){
+        this.model = _model
+        this.logs = _log
+        this.preference = _preference
+    }
+
+    public get execute_proxy() : ExecuteProxy {
+        const d:ExecuteProxy = {
+            executeProjectStart: (data:[Project, number]):void => { this.execute_project_start(data) },
+            executeProjectFinish: (data:[Project, number]):void => { this.execute_project_finish(data) },
+            executeTaskStart: (data:[Task, number]):void => { this.execute_task_start(data) },
+            executeTaskFinish: (data:Task):void => { this.execute_task_finish(data) },
+            executeSubtaskStart: (data:[Task, number, string]):void => { this.execute_subtask_start(data) },
+            executeSubtaskUpdate: (data:[Task, number, string, ExecuteState]):void => { this.execute_subtask_update(data) },
+            executeSubtaskFinish: (data:[Task, number, string]):void => { this.execute_subtask_end(data) },
+            executeJobStart: (data:[Job, number, string]):void => { this.execute_job_start(data) },
+            executeJobFinish: (data:[Job, number, string, number]):void => { this.execute_job_finish(data) },
+            feedbackMessage: (data:FeedBack):void => { this.feedback_message(data) },
+            updateParameter: (data:Parameter):void => { this.update_runtime_parameter(data) }
+        }
+        return d
+    }
+
+    execute_project_start = async (d:[Project, number]) => {
+        const target = this.model.record!.projects[this.model.record!.project_index]
+        const title = await this.getnewname(target.title)
+        this.uuid = uuid6()
+        const newlog:ExecutionLog = {
+            uuid: this.uuid,
+            filename: title,
+            dirty: true,
+            output: this.preference.log,
+            project: target,
+            state: ExecuteState.RUNNING,
+            start_timer: Date.now(),
+            parameter: d[0].parameter!,
+            end_timer: 0,
+            logs: target.task.map(x => {
+                return {
+                    start_timer: 0,
+                    end_timer: 0,
+                    task_state: {
+                        uuid: x.uuid,
+                        state: ExecuteState.NONE
+                    },
+                    task_detail: []
+                }
+            })
+        }
+        this.logs.logs = [newlog].concat(this.logs.logs)
+    }
+
+    execute_project_finish = (d:[Project, number]) => {
+        if(this.target_log == undefined) return
+        this.target_log!.state = ExecuteState.FINISH
+        this.target_log!.end_timer = Date.now()
+        this.target_log!.dirty = true
+    }
+    
+    execute_task_start = (d:[Task, number]) => {
+        if(this.target_log == undefined) return
+        const index = this.target_log!.project.task.findIndex(x => x.uuid == d[0].uuid)
+        if(index == -1) return
+        this.task_index = index
+        this.target_log!.logs[this.task_index].task_detail = []
+    
+        const p = this.model.record!.projects[this.model.record!.project_index]
+        const t = p.task[this.task_index]
+        const count = this.model.manager!.get_task_state_count(t)
+        
+        for(let i = 0; i < count; i++){
+            this.target_log!.logs[this.task_index].task_detail.push({
+                index: i,
+                node: "",
+                message: [],
+                state: ExecuteState.NONE
+            })
+        }
+    
+        if(this.target_log!.logs.length > this.task_index){
+            this.target_log!.logs[this.task_index].task_state.state = ExecuteState.RUNNING
+            this.target_log!.logs[this.task_index].start_timer = Date.now()
+            this.target_log!.dirty = true
+        }
+    }
+    
+    execute_task_finish = (d:Task) => {
+        if(this.target_log == undefined) return
+        if(this.target_log!.logs.length > this.task_index){
+            this.target_log!.logs[this.task_index].task_state.state = ExecuteState.FINISH
+            this.target_log!.logs[this.task_index].end_timer = Date.now()
+            this.target_log!.dirty = true
+        }
+    }
+    
+    execute_subtask_start = (d:[Task, number, string]) => {
+        if(this.target_log == undefined) return
+        if(this.target_log!.logs[this.task_index].task_detail.length > d[1]){
+            this.target_log!.logs[this.task_index].task_detail[d[1]].state = ExecuteState.RUNNING
+            this.target_log!.dirty = true
+        }
+    }
+    
+    execute_subtask_update = (d:[Task, number, string, ExecuteState]) => {
+        if(this.target_log == undefined) return
+        if(this.target_log!.logs[this.task_index].task_detail.length > d[1]){
+            this.target_log!.logs[this.task_index].task_detail[d[1]].state = d[3]
+            this.target_log!.dirty = true
+        }
+    }
+    
+    execute_subtask_end = (d:[Task, number, string]) => {
+        if(this.target_log == undefined) return
+        if(this.target_log!.logs[this.task_index].task_detail.length > d[1]){
+            this.target_log!.logs[this.task_index].task_detail[d[1]].state = ExecuteState.FINISH
+            this.target_log!.dirty = true
+        }
+    }
+    
+    execute_job_start = (d:[Job, number, string]) => {
+    
+    }
+    
+    execute_job_finish = (d:[Job, number, string, number]) => {
+        if(this.target_log == undefined) return
+        if (d[3] == 1){
+            const currentLog = this.target_log!
+            const task = currentLog.project.task[this.task_index]
+            const index = task.jobs.findIndex(x => x.uuid == d[0].uuid)
+            if(index != -1 && task.jobs[index].category == JobCategory.Condition){
+                const cr:ConditionResult = task.jobs[index].number_args[0] as ConditionResult
+                if(cr == ConditionResult.None) return
+                const state = (cr == ConditionResult.ThrowTask || cr == ConditionResult.ThrowProject) ? ExecuteState.ERROR : ExecuteState.SKIP
+                const target: ExecuteRecordTask | undefined = this.model.record!.task_detail[d[1]]
+                if(target != undefined) {
+                    target.state = state
+                }
+
+                currentLog.logs[this.task_index].task_state.state = state
+                if (cr == ConditionResult.Pause) return
+                if (cr == ConditionResult.SkipProject || cr == ConditionResult.ThrowProject){
+                    currentLog.state = state
+                }
+            }
+        }
+    }
+    
+    feedback_message = (d:FeedBack) => {
+        if(this.target_log == undefined) return
+        if(d.index == undefined || d.index == -1) return
+        if(this.target_log == undefined) return
+        if(this.target_log!.logs[this.task_index].task_detail.length > d.index){
+            this.target_log!.logs[this.task_index].task_detail[d.index].message.push(d.message)
+            this.target_log!.dirty = true
+        }else{
+            console.warn("Try access message by index but failed: ", d)
+        }
+    }
+
+    update_runtime_parameter = (d:Parameter) => {
+        if(this.target_log != undefined) {
+            this.target_log!.parameter = d
+            this.target_log!.dirty = true
+        }
+    }
+
+    getnewname = async (name:string) => {
+        const root = "data/log"
+        let count = 0
+        let filename = name
+        let p = `${root}/${filename}`
+        while(fs.existsSync(p + ".json")){
+            count = count + 1
+            filename = `${name} ${count}`
+            p = `${root}/${filename}`
+        }
+        return filename
+    }
+}

package/test/TEST.ts

@@ -0,0 +1,63 @@
+import * as pem from 'pem'
+import * as https from 'https'
+import * as ws from 'ws'
+
+let h:https.Server<any> | undefined = undefined
+let w:ws.Server | undefined = undefined
+
+async function get_pem ():Promise<[string, string]> {
+    return new Promise<[string, string]>(resolve => {
+        pem.createCertificate({ days: 1, selfSigned: true }, (err, keys) => {
+            resolve([keys.clientKey, keys.certificate])
+        })
+    })
+}
+
+
+async function start_server() {
+    const pems = await get_pem()
+    h = https.createServer({ key: pems[0], cert: pems[1], minVersion: 'TLSv1.2', maxVersion: 'TLSv1.3' }, (req, res) => {
+        res.writeHead(200)
+        res.end('HTTPS server is running');
+    })
+    h.addListener('upgrade', (req, res, head) => console.log('UPGRADE:', req.url))
+    w = new ws.Server({ server: h })
+    w.on('listening', (socket) => {
+        console.log("Listen Event")
+    })
+    w.on('error', (err) => {
+        console.log("Error Event")
+    })
+    w.on('connection', (socket) => {
+        socket.on('message', (data) => {
+            console.log("Recevied Data: ", data.toString())
+        })
+    })
+    h.listen(10000, () => {
+        console.log("Listen to 10000")
+    })
+}
+
+
+async function start_client() {
+    return new Promise((resolve) => {
+        const cli = new ws.WebSocket("wss://127.0.0.1:10000", { agent: new https.Agent(), rejectUnauthorized: false })
+        cli.on('error', (err) => {
+            console.log("Socket Error: ", err)
+        })
+        setTimeout(() => {
+            cli.send("Hello World")
+            cli.close()
+            resolve(undefined)
+        }, 1000);
+    })
+}
+
+async function main() {
+    await start_server()
+    await start_client()
+    //w?.close()
+    //h?.close()
+}
+
+main()

package/test/client/execute.test.ts

@@ -0,0 +1,54 @@
+import { ClientJobExecute } from "../../src/client/job_execute"
+import { Job, JobCategory, JobType2 } from "../../src/interface"
+
+
+describe("Client Execute Test", () => {
+    let execute:ClientJobExecute | undefined = undefined
+    let job:Job | undefined = undefined
+    afterAll(() => {
+        execute = undefined
+    })
+
+    test("Testing condition (OS when path not exist)", async () => {
+        job = {
+            index: 0,
+            uuid: "UUID",
+            runtime_uuid: "Runtime",
+            category: JobCategory.Condition,
+            type: JobType2.CHECK_PATH,
+            script: "",
+            string_args: ["Not Exist"],
+            number_args: [],
+            boolean_args: []
+        }
+        execute = new ClientJobExecute(
+            (str) => console.log(str),
+            (str) => console.log(str),
+            job!,
+            undefined,
+            { plugins: [] },
+        )
+        await expect(execute.execute()).rejects.toBeDefined()
+    })
+    test("Testing condition (OS when path exist)", async () => {
+        job = {
+            index: 0,
+            uuid: "UUID",
+            runtime_uuid: "Runtime",
+            category: JobCategory.Condition,
+            type: JobType2.CHECK_PATH,
+            script: "",
+            string_args: [process.cwd()],
+            number_args: [],
+            boolean_args: []
+        }
+        execute = new ClientJobExecute(
+            (str) => console.log(str),
+            (str) => console.log(str),
+            job!,
+            undefined,
+            { plugins: [] }
+        )
+        await expect(execute.execute()).resolves.toBeDefined()
+    })
+})