@testomatio/reporter 2.3.6-beta.2-fix-beforesuite → 2.3.7-beta.1-xml-import

package/README.md

@@ -13,7 +13,7 @@ Testomat.io Reporter (this npm package) supports:
 - 🔎 [Stack traces](./docs/stacktrace.md) and error messages
 - 🐙 [GitHub](./docs/pipes/github.md), [GitLab](./docs/pipes/gitlab.md) & [Bitbucket](./docs/pipes/bitbucket.md) integration
 - 🚅 Realtime reports
-- 🗃️ Other test frameworks supported via [JUNit XML](./docs/junit.md)
+- 🗃️ Other test frameworks supported via [JUnit XML](./docs/junit.md) with [XML import configuration](./docs/xml-imports.md)
 - 🚶‍♀️ Steps _(work in progress)_
 - 📄 [Logger](./docs/logger.md) _(work in progress, supports Jest for now)_
 - ☁️ Custom properties and metadata _(work in progress)_

package/lib/bin/reportXml.js

@@ -37,7 +37,10 @@ program
     lang = lang?.toLowerCase();
     if (javaTests === true || (lang === 'java' && !javaTests))
         javaTests = 'src/test/java';
-    const runReader = new xmlReader_js_1.default({ javaTests, lang });
+    const runReader = new xmlReader_js_1.default({
+        javaTests,
+        lang,
+    });
     const files = glob_1.glob.sync(pattern, { cwd: opts.dir || process.cwd() });
     if (!files.length) {
         console.log(constants_js_1.APP_PREFIX, `Report can't be created. No XML files found 😥`);

package/lib/junit-adapter/csharp.d.ts

@@ -1,5 +1,4 @@
 export default CSharpAdapter;
 declare class CSharpAdapter extends Adapter {
-    getFilePath(t: any): string;
 }
 import Adapter from './adapter.js';

package/lib/junit-adapter/csharp.js

@@ -7,24 +7,53 @@ const path_1 = __importDefault(require("path"));
 const adapter_js_1 = __importDefault(require("./adapter.js"));
 class CSharpAdapter extends adapter_js_1.default {
     formatTest(t) {
-        const title = t.title.replace(/\(.*?\)/, '').trim();
-        const example = t.title.match(/\((.*?)\)/);
-        if (example)
-            t.example = { ...example[1].split(',') };
+        // Don't override example if it already exists from NUnit XML processing
+        // The xmlReader.js already extracts parameters correctly from <arguments>
+        if (!t.example) {
+            const title = t.title.replace(/\(.*?\)/, '').trim();
+            const exampleMatch = t.title.match(/\((.*?)\)/);
+            if (exampleMatch) {
+                // Keep as array for consistency with NUnit XML processing
+                t.example = exampleMatch[1].split(',').map(param => param.trim());
+            }
+            t.title = title.trim();
+        }
         const suite = t.suite_title.split('.');
         t.suite_title = suite.pop();
         t.file = namespaceToFileName(t.file);
-        t.title = title.trim();
         return t;
     }
     getFilePath(t) {
-        const fileName = namespaceToFileName(t.file);
+        if (!t.file)
+            return null;
+        // Normalize path separators for cross-platform compatibility
+        let filePath = t.file.replace(/\\/g, '/');
+        // If file already has .cs extension, use it directly
+        if (filePath.endsWith('.cs')) {
+            // Make relative path if it's absolute
+            if (path_1.default.isAbsolute(filePath)) {
+                // Try to find project-relative path
+                const cwd = process.cwd().replace(/\\/g, '/');
+                if (filePath.startsWith(cwd)) {
+                    filePath = path_1.default.relative(cwd, filePath).replace(/\\/g, '/');
+                }
+            }
+            return filePath;
+        }
+        // Convert namespace path to file path
+        const fileName = namespaceToFileName(filePath);
         return fileName;
     }
 }
 module.exports = CSharpAdapter;
 function namespaceToFileName(fileName) {
+    if (!fileName)
+        return '';
+    // If already a .cs file path, clean it up
+    if (fileName.endsWith('.cs')) {
+        return fileName.replace(/\\/g, '/');
+    }
     const fileParts = fileName.split('.');
     fileParts[fileParts.length - 1] = fileParts[fileParts.length - 1]?.replace(/\$.*/, '');
-    return `${fileParts.join(path_1.default.sep)}.cs`;
+    return `${fileParts.join('/')}.cs`;
 }

package/lib/junit-adapter/nunit-parser.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Enhanced NUnit XML Parser that properly handles test-suite hierarchy
+ * and parameterized tests
+ */
+export class NUnitXmlParser {
+    constructor(options?: {});
+    options: {};
+    tests: any[];
+    stats: {
+        total: number;
+        passed: number;
+        failed: number;
+        skipped: number;
+        inconclusive: number;
+    };
+    /**
+     * Parse NUnit XML test-run structure
+     * @param {Object} testRun - Parsed XML test-run object
+     * @returns {Object} - Parsed test results
+     */
+    parseTestRun(testRun: any): any;
+    /**
+     * Recursively parse test-suite elements based on their type
+     * @param {Object|Array} testSuite - Test suite object or array
+     * @param {Array} parentPath - Current path in the hierarchy
+     */
+    parseTestSuite(testSuite: any | any[], parentPath?: any[]): void;
+    /**
+     * Process child elements of a test suite
+     * @param {Object} testSuite - Test suite object
+     * @param {Array} currentPath - Current path in hierarchy
+     */
+    processChildren(testSuite: any, currentPath: any[]): void;
+    /**
+     * Parse test-case elements (actual tests)
+     * @param {Object|Array} testCases - Test case object or array
+     * @param {Array} suitePath - Path to the test suite
+     * @param {Object} parentSuite - Parent test suite for context
+     */
+    parseTestCases(testCases: any | any[], suitePath: any[], parentSuite: any): void;
+    /**
+     * Parse individual test case
+     * @param {Object} testCase - Test case object
+     * @param {Array} suitePath - Path to the test suite
+     * @param {Object} parentSuite - Parent test suite for context
+     * @returns {Object|null} - Parsed test object
+     */
+    parseTestCase(testCase: any, suitePath: any[], parentSuite: any): any | null;
+    /**
+     * Extract method name and parameters from test name
+     * @param {string} testName - Full test name
+     * @returns {Object} - Extracted information
+     */
+    extractParameters(testName: string): any;
+    /**
+     * Parse parameter string into array of parameters
+     * @param {string} paramString - Parameter string
+     * @returns {Array} - Array of parameters
+     */
+    parseParameterString(paramString: string): any[];
+    /**
+     * Extract method name from test name (fallback)
+     * @param {string} testName - Test name
+     * @returns {string} - Method name
+     */
+    extractMethodName(testName: string): string;
+    /**
+     * Build file path from suite path and class name
+     * @param {Array} suitePath - Suite path array
+     * @param {string} className - Class name
+     * @param {Object} parentSuite - Parent suite for context
+     * @returns {string} - File path
+     */
+    buildFilePath(suitePath: any[], className: string, parentSuite: any): string;
+    /**
+     * Group parameterized tests by base method name
+     * @param {Array} tests - Array of parsed tests
+     * @returns {Object} - Grouped tests
+     */
+    groupParameterizedTests(tests: any[]): any;
+}
+export default NUnitXmlParser;

package/lib/junit-adapter/nunit-parser.js

@@ -0,0 +1,357 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NUnitXmlParser = void 0;
+const debug_1 = __importDefault(require("debug"));
+const constants_js_1 = require("../constants.js");
+const debug = (0, debug_1.default)('@testomatio/reporter:nunit-parser');
+/**
+ * Enhanced NUnit XML Parser that properly handles test-suite hierarchy
+ * and parameterized tests
+ */
+class NUnitXmlParser {
+    constructor(options = {}) {
+        this.options = options;
+        this.tests = [];
+        this.stats = {
+            total: 0,
+            passed: 0,
+            failed: 0,
+            skipped: 0,
+            inconclusive: 0,
+        };
+    }
+    /**
+     * Parse NUnit XML test-run structure
+     * @param {Object} testRun - Parsed XML test-run object
+     * @returns {Object} - Parsed test results
+     */
+    parseTestRun(testRun) {
+        debug('Parsing NUnit test-run');
+        // Extract run-level statistics
+        this.stats = {
+            total: parseInt(testRun.total || 0, 10),
+            passed: parseInt(testRun.passed || 0, 10),
+            failed: parseInt(testRun.failed || 0, 10),
+            skipped: parseInt(testRun.skipped || 0, 10),
+            inconclusive: parseInt(testRun.inconclusive || 0, 10),
+        };
+        // Process the root test-suite
+        if (testRun['test-suite']) {
+            this.parseTestSuite(testRun['test-suite'], []);
+        }
+        debug(`Parsed ${this.tests.length} tests from NUnit XML`);
+        return {
+            status: testRun.result?.toLowerCase() || 'unknown',
+            create_tests: true,
+            tests_count: this.tests.length,
+            passed_count: this.tests.filter(t => t.status === constants_js_1.STATUS.PASSED).length,
+            failed_count: this.tests.filter(t => t.status === constants_js_1.STATUS.FAILED).length,
+            skipped_count: this.tests.filter(t => t.status === constants_js_1.STATUS.SKIPPED).length,
+            tests: this.tests,
+        };
+    }
+    /**
+     * Recursively parse test-suite elements based on their type
+     * @param {Object|Array} testSuite - Test suite object or array
+     * @param {Array} parentPath - Current path in the hierarchy
+     */
+    parseTestSuite(testSuite, parentPath = []) {
+        if (!testSuite)
+            return;
+        // Handle arrays of test suites
+        if (Array.isArray(testSuite)) {
+            testSuite.forEach(suite => this.parseTestSuite(suite, parentPath));
+            return;
+        }
+        const suiteType = testSuite.type;
+        const suiteName = testSuite.name;
+        const fullName = testSuite.fullname;
+        debug(`Processing test-suite: type=${suiteType}, name=${suiteName}`);
+        switch (suiteType) {
+            case 'Assembly':
+                // Assembly level - ignore the name, just process children
+                debug('Processing Assembly level - ignoring name, processing children');
+                this.processChildren(testSuite, parentPath);
+                break;
+            case 'TestSuite':
+                // Namespace/grouping level - add to path but don't create test
+                debug(`Processing TestSuite level - adding '${suiteName}' to path`);
+                const newPath = [...parentPath, suiteName];
+                this.processChildren(testSuite, newPath);
+                break;
+            case 'TestFixture':
+                // Test class level - add to path and process test cases
+                debug(`Processing TestFixture level - test class '${suiteName}'`);
+                const testFixturePath = [...parentPath, suiteName];
+                this.processChildren(testSuite, testFixturePath);
+                break;
+            default:
+                debug(`Unknown test-suite type: ${suiteType}, treating as TestSuite`);
+                const unknownPath = [...parentPath, suiteName];
+                this.processChildren(testSuite, unknownPath);
+                break;
+        }
+    }
+    /**
+     * Process child elements of a test suite
+     * @param {Object} testSuite - Test suite object
+     * @param {Array} currentPath - Current path in hierarchy
+     */
+    processChildren(testSuite, currentPath) {
+        // Process nested test-suites
+        if (testSuite['test-suite']) {
+            this.parseTestSuite(testSuite['test-suite'], currentPath);
+        }
+        // Process test-cases
+        if (testSuite['test-case']) {
+            this.parseTestCases(testSuite['test-case'], currentPath, testSuite);
+        }
+    }
+    /**
+     * Parse test-case elements (actual tests)
+     * @param {Object|Array} testCases - Test case object or array
+     * @param {Array} suitePath - Path to the test suite
+     * @param {Object} parentSuite - Parent test suite for context
+     */
+    parseTestCases(testCases, suitePath, parentSuite) {
+        if (!testCases)
+            return;
+        // Handle arrays of test cases
+        if (!Array.isArray(testCases)) {
+            testCases = [testCases];
+        }
+        testCases.forEach(testCase => {
+            const parsedTest = this.parseTestCase(testCase, suitePath, parentSuite);
+            if (parsedTest) {
+                this.tests.push(parsedTest);
+            }
+        });
+    }
+    /**
+     * Parse individual test case
+     * @param {Object} testCase - Test case object
+     * @param {Array} suitePath - Path to the test suite
+     * @param {Object} parentSuite - Parent test suite for context
+     * @returns {Object|null} - Parsed test object
+     */
+    parseTestCase(testCase, suitePath, parentSuite) {
+        if (!testCase || !testCase.name) {
+            debug('Skipping test case without name');
+            return null;
+        }
+        const testName = testCase.name;
+        const fullName = testCase.fullname;
+        const methodName = testCase.methodname || this.extractMethodName(testName);
+        const className = testCase.classname || parentSuite?.name;
+        debug(`Parsing test case: ${testName}`);
+        // Extract parameters if this is a parameterized test
+        const { baseMethodName, parameters, isParameterized } = this.extractParameters(testName);
+        // Determine test status
+        let status = constants_js_1.STATUS.PASSED;
+        if (testCase.result) {
+            switch (testCase.result.toLowerCase()) {
+                case 'passed':
+                    status = constants_js_1.STATUS.PASSED;
+                    break;
+                case 'failed':
+                    status = constants_js_1.STATUS.FAILED;
+                    break;
+                case 'skipped':
+                case 'ignored':
+                    status = constants_js_1.STATUS.SKIPPED;
+                    break;
+                case 'inconclusive':
+                    status = constants_js_1.STATUS.SKIPPED; // Treat inconclusive as skipped
+                    break;
+                default:
+                    status = constants_js_1.STATUS.PASSED;
+            }
+        }
+        // Extract error information
+        let message = '';
+        let stack = '';
+        if (testCase.failure) {
+            message = testCase.failure.message || '';
+            stack = testCase.failure['stack-trace'] || testCase.failure['#text'] || '';
+        }
+        if (testCase.output && testCase.output['#text']) {
+            stack = `${stack}\n\n${testCase.output['#text']}`.trim();
+        }
+        // Extract test ID from properties
+        let testId = null;
+        if (testCase.properties && testCase.properties.property) {
+            const properties = Array.isArray(testCase.properties.property)
+                ? testCase.properties.property
+                : [testCase.properties.property];
+            const idProperty = properties.find(p => p.name === 'ID');
+            if (idProperty) {
+                testId = idProperty.value;
+                // Remove @ and T prefixes if present
+                if (testId.startsWith('@'))
+                    testId = testId.slice(1);
+                if (testId.startsWith('T'))
+                    testId = testId.slice(1);
+            }
+        }
+        // Build file path from suite path and class name
+        const filePath = this.buildFilePath(suitePath, className, parentSuite);
+        return {
+            title: isParameterized ? testName : methodName || testName,
+            methodName: baseMethodName || methodName || testName,
+            fullName: fullName,
+            suitePath: suitePath,
+            suite_title: className || suitePath[suitePath.length - 1] || 'Unknown',
+            file: filePath,
+            status: status,
+            message: message,
+            stack: stack,
+            run_time: parseFloat(testCase.duration || testCase.time || 0) * 1000,
+            test_id: testId,
+            create: true,
+            retry: false,
+            // Parameterized test metadata
+            isParameterized: isParameterized,
+            parameters: parameters,
+            baseMethodName: baseMethodName,
+        };
+    }
+    /**
+     * Extract method name and parameters from test name
+     * @param {string} testName - Full test name
+     * @returns {Object} - Extracted information
+     */
+    extractParameters(testName) {
+        const paramMatch = testName.match(/^(.+?)\((.+)\)$/);
+        if (paramMatch) {
+            const baseMethodName = paramMatch[1].trim();
+            const paramString = paramMatch[2];
+            // Parse parameters - handle quoted strings and nested structures
+            const parameters = this.parseParameterString(paramString);
+            return {
+                baseMethodName: baseMethodName,
+                parameters: parameters,
+                isParameterized: true,
+            };
+        }
+        return {
+            baseMethodName: testName,
+            parameters: [],
+            isParameterized: false,
+        };
+    }
+    /**
+     * Parse parameter string into array of parameters
+     * @param {string} paramString - Parameter string
+     * @returns {Array} - Array of parameters
+     */
+    parseParameterString(paramString) {
+        const parameters = [];
+        let current = '';
+        let inQuotes = false;
+        let quoteChar = null;
+        let depth = 0;
+        for (let i = 0; i < paramString.length; i++) {
+            const char = paramString[i];
+            if (!inQuotes && (char === '"' || char === "'")) {
+                inQuotes = true;
+                quoteChar = char;
+                current += char;
+            }
+            else if (inQuotes && char === quoteChar) {
+                inQuotes = false;
+                quoteChar = null;
+                current += char;
+            }
+            else if (!inQuotes && char === '(') {
+                depth++;
+                current += char;
+            }
+            else if (!inQuotes && char === ')') {
+                depth--;
+                current += char;
+            }
+            else if (!inQuotes && char === ',' && depth === 0) {
+                parameters.push(current.trim());
+                current = '';
+            }
+            else {
+                current += char;
+            }
+        }
+        if (current.trim()) {
+            parameters.push(current.trim());
+        }
+        // Clean up parameters - remove quotes if they wrap the entire parameter
+        return parameters.map(param => {
+            param = param.trim();
+            if ((param.startsWith('"') && param.endsWith('"')) || (param.startsWith("'") && param.endsWith("'"))) {
+                return param.slice(1, -1);
+            }
+            return param;
+        });
+    }
+    /**
+     * Extract method name from test name (fallback)
+     * @param {string} testName - Test name
+     * @returns {string} - Method name
+     */
+    extractMethodName(testName) {
+        // Remove parameters if present
+        const paramMatch = testName.match(/^(.+?)\(/);
+        return paramMatch ? paramMatch[1].trim() : testName;
+    }
+    /**
+     * Build file path from suite path and class name
+     * @param {Array} suitePath - Suite path array
+     * @param {string} className - Class name
+     * @param {Object} parentSuite - Parent suite for context
+     * @returns {string} - File path
+     */
+    buildFilePath(suitePath, className, parentSuite) {
+        // Try to get file path from parent suite
+        if (parentSuite && parentSuite.filepath) {
+            return parentSuite.filepath;
+        }
+        // Build path from suite hierarchy
+        const pathParts = [...suitePath];
+        if (className && !pathParts.includes(className)) {
+            pathParts.push(className);
+        }
+        // Convert to file path format
+        return pathParts.join('/') + '.cs'; // Assume C# for NUnit
+    }
+    /**
+     * Group parameterized tests by base method name
+     * @param {Array} tests - Array of parsed tests
+     * @returns {Object} - Grouped tests
+     */
+    groupParameterizedTests(tests) {
+        const grouped = {};
+        tests.forEach(test => {
+            const key = test.isParameterized
+                ? `${test.suitePath.join('.')}.${test.baseMethodName}`
+                : `${test.suitePath.join('.')}.${test.title}`;
+            if (!grouped[key]) {
+                grouped[key] = {
+                    baseTest: {
+                        name: test.baseMethodName || test.title,
+                        suitePath: test.suitePath,
+                        suite_title: test.suite_title,
+                        file: test.file,
+                        isParameterized: test.isParameterized,
+                    },
+                    variations: [],
+                };
+            }
+            grouped[key].variations.push(test);
+        });
+        return grouped;
+    }
+}
+exports.NUnitXmlParser = NUnitXmlParser;
+module.exports = NUnitXmlParser;
+
+module.exports.NUnitXmlParser = NUnitXmlParser;

package/lib/pipe/debug.js

@@ -18,7 +18,7 @@ class DebugPipe {
         this.isEnabled = !!process.env.TESTOMATIO_DEBUG || !!process.env.DEBUG;
         if (this.isEnabled) {
             this.batch = {
-                isEnabled: this.params.isBatchEnabled ?? !process.env.TESTOMATIO_DISABLE_BATCH_UPLOAD ?? true,
+                isEnabled: this.params.isBatchEnabled ?? (process.env.TESTOMATIO_DISABLE_BATCH_UPLOAD ? false : true),
                 intervalFunction: null,
                 intervalTime: 5000,
                 tests: [],

package/lib/pipe/testomatio.js

@@ -23,7 +23,7 @@ if (process.env.TESTOMATIO_RUN)
 class TestomatioPipe {
     constructor(params, store) {
         this.batch = {
-            isEnabled: params?.isBatchEnabled ?? !process.env.TESTOMATIO_DISABLE_BATCH_UPLOAD ?? true,
+            isEnabled: params?.isBatchEnabled ?? (process.env.TESTOMATIO_DISABLE_BATCH_UPLOAD ? false : true),
             intervalFunction: null, // will be created in createRun by setInterval function
             intervalTime: 5000, // how often tests are sent
             tests: [], // array of tests in batch
@@ -60,7 +60,7 @@ class TestomatioPipe {
                 retry: constants_js_1.REPORTER_REQUEST_RETRIES.retriesPerRequest,
                 retryDelay: constants_js_1.REPORTER_REQUEST_RETRIES.retryTimeout,
                 httpMethodsToRetry: ['GET', 'PUT', 'HEAD', 'OPTIONS', 'DELETE', 'POST'],
-                shouldRetry: (error) => {
+                shouldRetry: error => {
                     if (!error.response)
                         return false;
                     switch (error.response?.status) {
@@ -73,8 +73,8 @@ class TestomatioPipe {
                             break;
                     }
                     return error.response?.status >= 401; // Retry on 401+ and 5xx
-                }
-            }
+                },
+            },
         });
         this.isEnabled = true;
         // do not finish this run (for parallel testing)
@@ -193,7 +193,7 @@ class TestomatioPipe {
                 method: 'PUT',
                 url: `/api/reporter/${this.runId}`,
                 data: runParams,
-                responseType: 'json'
+                responseType: 'json',
             });
             if (resp.data.artifacts)
                 (0, pipe_utils_js_1.setS3Credentials)(resp.data.artifacts);
@@ -206,7 +206,7 @@ class TestomatioPipe {
                 url: '/api/reporter',
                 data: runParams,
                 maxContentLength: Infinity,
-                responseType: 'json'
+                responseType: 'json',
             });
             this.runId = resp.data.uid;
             this.runUrl = `${this.url}/${resp.data.url.split('/').splice(3).join('/')}`;
@@ -259,15 +259,17 @@ class TestomatioPipe {
         this.#formatData(data);
         const json = json_cycle_1.default.stringify(data);
         debug('Adding test', json);
-        return this.client.request({
+        return this.client
+            .request({
             method: 'POST',
             url: `/api/reporter/${this.runId}/testrun`,
             data: json,
             headers: {
                 'Content-Type': 'application/json',
             },
-            maxContentLength: Infinity
-        }).catch(err => {
+            maxContentLength: Infinity,
+        })
+            .catch(err => {
             this.requestFailures++;
             this.notReportedTestsCount++;
             if (err.response) {
@@ -312,19 +314,21 @@ class TestomatioPipe {
         // get tests from batch and clear batch
         const testsToSend = this.batch.tests.splice(0);
         debug('📨 Batch upload', testsToSend.length, 'tests');
-        return this.client.request({
+        return this.client
+            .request({
             method: 'POST',
             url: `/api/reporter/${this.runId}/testrun`,
             data: {
                 api_key: this.apiKey,
                 tests: testsToSend,
-                batch_index: this.batch.batchIndex
+                batch_index: this.batch.batchIndex,
             },
             headers: {
                 'Content-Type': 'application/json',
             },
-            maxContentLength: Infinity
-        }).catch(err => {
+            maxContentLength: Infinity,
+        })
+            .catch(err => {
             this.requestFailures++;
             this.notReportedTestsCount += testsToSend.length;
             if (err.response) {
@@ -408,9 +412,9 @@ class TestomatioPipe {
                         status_event,
                         detach: params.detach,
                         tests: params.tests,
-                    }
+                    },
                 });
-                console.log(constants_js_1.APP_PREFIX, '✅ Testrun finished');
+                debug(constants_js_1.APP_PREFIX, '✅ Testrun finished');
                 if (this.runUrl) {
                     console.log(constants_js_1.APP_PREFIX, '📊 Report Saved. Report URL:', picocolors_1.default.magenta(this.runUrl));
                 }

package/lib/uploader.js

@@ -170,6 +170,10 @@ class S3Uploader {
         if (typeof filePath === 'string' && !path_1.default.isAbsolute(filePath)) {
             filePath = path_1.default.join(process.cwd(), filePath);
         }
+        // Normalize path separators for cross-platform compatibility
+        if (typeof filePath === 'string') {
+            filePath = filePath.replace(/\\/g, '/');
+        }
         const data = { rid, file: filePath, uploaded };
         const jsonLine = `${JSON.stringify(data)}\n`;
         fs_1.default.appendFileSync(tempFilePath, jsonLine);