robo-automation-test-kit 1.0.0__py3-none-any.whl

robo_automation_test_kit/templates/html_report/components/category-chart.html

@@ -0,0 +1,148 @@
+<!-- Status by Request Category Chart Component -->
+<div class="chart-container">
+    <canvas id="statusByCategoryChart" width="360" height="288"></canvas>
+</div>
+<script>
+function initializeCategoryChart() {
+    const ctx = document.getElementById('statusByCategoryChart');
+    if (!ctx) {
+        setTimeout(initializeCategoryChart, 100);
+        return;
+    }
+    
+    if (typeof window.statusColors === 'undefined' || typeof window.add3DEffect === 'undefined' || typeof Chart === 'undefined') {
+        setTimeout(initializeCategoryChart, 100);
+        return;
+    }
+
+    const categoryStatusData = [
+        {% for result in report_rows %}
+        {
+            category: `{{ result['Request Category']|e }}`,
+            status: `{{ result.test_status|e }}`
+        }{% if not loop.last %},{% endif %}
+        {% endfor %}
+    ];
+    
+    const statusTypes = window.statusTypes || ['PASSED', 'FAILED', 'SKIPPED'];
+    const statusColors = window.statusColors;
+    const add3DEffect = window.add3DEffect;
+
+    const categorySet = new Set();
+    categoryStatusData.forEach(r => {
+        if (r.category && r.category !== '-') categorySet.add(r.category);
+    });
+    const categoryLabels = Array.from(categorySet);
+
+    const statusByCategory = {};
+    categoryStatusData.forEach(r => {
+        const category = r.category;
+        let status = (r.status || '').toUpperCase();
+        if (status === 'ERROR') status = 'FAILED';
+        if (!category || category === '-' || !statusTypes.includes(status)) return;
+        if (!statusByCategory[category]) statusByCategory[category] = { PASSED: 0, FAILED: 0, SKIPPED: 0 };
+        if (statusByCategory[category][status] !== undefined) statusByCategory[category][status]++;
+        if (statusByCategory[category][status] !== undefined) statusByCategory[category][status]++;
+    });
+
+    const categoryDatasets = statusTypes.map(st => ({
+        label: st.charAt(0) + st.slice(1).toLowerCase(),
+        data: categoryLabels.map(c => (statusByCategory[c] ? statusByCategory[c][st] : 0)),
+        backgroundColor: statusColors[st],
+        borderWidth: 1
+    }));
+
+    const ctxObj = ctx.getContext('2d');
+    const cat3dDatasets = categoryDatasets.map(ds => ({
+        ...ds,
+        backgroundColor: add3DEffect(ctxObj, 'bar', [statusColors[ds.label.toUpperCase()]])
+    }));
+
+    // Destroy existing chart instance if it exists
+    const existingChart = Chart.getChart('statusByCategoryChart');
+    if (existingChart) {
+        existingChart.destroy();
+    }
+
+    new Chart(ctxObj, {
+        type: 'bar',
+        data: {
+            labels: categoryLabels,
+            datasets: cat3dDatasets
+        },
+        options: {
+            indexAxis: 'y',
+            responsive: false,
+            plugins: {
+                legend: {
+                    display: true,
+                    position: 'top',
+                    align: 'center',
+                    margin: 0,
+                    labels: {
+                        font: { size: 10 },
+                        usePointStyle: true,
+                        boxHeight: 12,
+                        pointStyle: 'rect',
+                        generateLabels: function(chart) {
+                            return chart.data.datasets.map((ds, i) => {
+                                const label = ds.label;
+                                const color = statusColors[label.toUpperCase()] || '#888';
+                                return {
+                                    text: label,
+                                    fillStyle: color,
+                                    strokeStyle: color,
+                                    lineWidth: 1,
+                                    pointStyle: 'rect',
+                                    hidden: false,
+                                    index: i
+                                };
+                            });
+                        }
+                    }
+                },
+                title: { display: true, text: 'Status by Request Category', font: { size: 18 }, padding: { top: 0, bottom: 4 } }
+            },
+            scales: {
+                x: {
+                    stacked: true,
+                    title: {
+                        display: true,
+                        text: 'Test Cases',
+                        font: { size: 12, weight: 'bold' },
+                        color: '#212121'
+                    },
+                    ticks: {
+                        font: { size: 10, weight: 'bold' },
+                        color: '#212121',
+                        stepSize: 1,
+                        callback: function(value) {
+                            if (Number.isInteger(value)) return value;
+                            return '';
+                        }
+                    }
+                },
+                y: {
+                    stacked: true,
+                    title: { display: false },
+                    ticks: {
+                        font: { size: 10, weight: 'bold' },
+                        color: '#212121',
+                        stepSize: 1,
+                        callback: function(value, index, ticks) {
+                            return categoryLabels && categoryLabels[index] ? categoryLabels[index] : value;
+                        }
+                    }
+                }
+            }
+        }
+    });
+}
+(function() {
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', initializeCategoryChart);
+    } else {
+        initializeCategoryChart();
+    }
+})();
+</script>

robo_automation_test_kit/templates/html_report/components/center-chart.html

@@ -0,0 +1,97 @@
+<!-- Distribution by Center Chart Component -->
+<div class="chart-container">
+    <canvas id="centerChart" width="360" height="288"></canvas>
+</div>
+<script>
+function initializeCenterChart() {
+    const ctx = document.getElementById('centerChart');
+    if (!ctx) {
+        setTimeout(initializeCenterChart, 100);
+        return;
+    }
+    
+    if (typeof window.centerPalette === 'undefined' || typeof window.add3DEffect === 'undefined' || typeof Chart === 'undefined') {
+        setTimeout(initializeCenterChart, 100);
+        return;
+    }
+    
+    const centerData = [
+        {% for result in report_rows %}
+        `{{ result.Center|e }}`{% if not loop.last %},{% endif %}
+        {% endfor %}
+    ];
+    
+    const centerCounts = {};
+    centerData.forEach(c => {
+        if (c && c !== '-') {
+            centerCounts[c] = (centerCounts[c] || 0) + 1;
+        }
+    });
+    const centerLabels = Object.keys(centerCounts);
+    const centerValues = centerLabels.map(c => centerCounts[c]);
+    
+    // Destroy existing chart instance if it exists
+    const existingChart = Chart.getChart('centerChart');
+    if (existingChart) {
+        existingChart.destroy();
+    }
+    
+    const ctxObj = ctx.getContext('2d');
+    const centerColors = window.centerPalette.slice(0, centerLabels.length);
+    const center3dDatasets = [{
+        data: centerValues,
+        backgroundColor: window.add3DEffect(ctxObj, 'doughnut', centerColors),
+        borderWidth: 1
+    }];
+    
+    new Chart(ctxObj, {
+        type: 'doughnut',
+        data: {
+            labels: centerLabels,
+            datasets: center3dDatasets
+        },
+        options: {
+            responsive: false,
+            plugins: {
+                title: {
+                    display: true,
+                    text: 'Distribution by Center',
+                    font: { size: 16, weight: 'bold' },
+                    color: '#212121',
+                    padding: { top: 0, bottom: 12 }
+                },
+                legend: {
+                    display: true,
+                    position: 'right',
+                    align: 'center',
+                    labels: {
+                        font: { size: 14 },
+                        usePointStyle: true,
+                        pointStyle: 'circle',
+                        generateLabels: function(chart) {
+                            const data = chart.data;
+                            return data.labels.map((label, i) => {
+                                return {
+                                    text: label,
+                                    fillStyle: centerColors[i],
+                                    strokeStyle: centerColors[i],
+                                    lineWidth: 1,
+                                    hidden: false,
+                                    index: i
+                                };
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    });
+}
+(function() {
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', initializeCenterChart);
+    } else {
+        initializeCenterChart();
+    }
+})();
+</script>

robo_automation_test_kit/templates/html_report/components/phase-chart.html

@@ -0,0 +1,148 @@
+<!-- Status by Phase Chart Component -->
+<div class="chart-container">
+    <canvas id="statusByPhaseChart" width="360" height="288"></canvas>
+</div>
+<script>
+function initializePhaseChart() {
+    const ctx = document.getElementById('statusByPhaseChart');
+    if (!ctx) {
+        setTimeout(initializePhaseChart, 100);
+        return;
+    }
+    
+    if (typeof window.statusColors === 'undefined' || typeof window.add3DEffect === 'undefined' || typeof Chart === 'undefined') {
+        setTimeout(initializePhaseChart, 100);
+        return;
+    }
+
+    const phaseStatusData = [
+        {% for result in report_rows %}
+        {
+            phase: `{{ result.Phase|e }}`,
+            status: `{{ result.test_status|e }}`
+        }{% if not loop.last %},{% endif %}
+        {% endfor %}
+    ];
+    
+    const statusTypes = window.statusTypes || ['PASSED', 'FAILED', 'SKIPPED'];
+    const statusColors = window.statusColors;
+    const add3DEffect = window.add3DEffect;
+
+    const phaseSet = new Set();
+    phaseStatusData.forEach(r => {
+        if (r.phase && r.phase !== '-') phaseSet.add(r.phase);
+    });
+    const phaseLabels = Array.from(phaseSet);
+
+    const statusByPhase = {};
+    phaseStatusData.forEach(r => {
+        const phase = r.phase;
+        let status = (r.status || '').toUpperCase();
+        if (status === 'ERROR') status = 'FAILED';
+        if (!phase || phase === '-' || !statusTypes.includes(status)) return;
+        if (!statusByPhase[phase]) statusByPhase[phase] = { PASSED: 0, FAILED: 0, SKIPPED: 0 };
+        if (statusByPhase[phase][status] !== undefined) statusByPhase[phase][status]++;
+        if (statusByPhase[phase][status] !== undefined) statusByPhase[phase][status]++;
+    });
+
+    const phaseDatasets = statusTypes.map(st => ({
+        label: st.charAt(0) + st.slice(1).toLowerCase(),
+        data: phaseLabels.map(p => (statusByPhase[p] ? statusByPhase[p][st] : 0)),
+        backgroundColor: statusColors[st],
+        borderWidth: 1
+    }));
+
+    const ctxObj = ctx.getContext('2d');
+    const phase3dDatasets = phaseDatasets.map(ds => ({
+        ...ds,
+        backgroundColor: add3DEffect(ctxObj, 'bar', [statusColors[ds.label.toUpperCase()]])
+    }));
+
+    // Destroy existing chart instance if it exists
+    const existingChart = Chart.getChart('statusByPhaseChart');
+    if (existingChart) {
+        existingChart.destroy();
+    }
+
+    new Chart(ctxObj, {
+        type: 'bar',
+        data: {
+            labels: phaseLabels,
+            datasets: phase3dDatasets
+        },
+        options: {
+            responsive: false,
+            plugins: {
+                legend: {
+                    display: true,
+                    position: 'top',
+                    align: 'center',
+                    margin: 0,
+                    labels: {
+                        font: { size: 10 },
+                        usePointStyle: true,
+                        boxHeight: 12,
+                        pointStyle: 'rect',
+                        generateLabels: function(chart) {
+                            return chart.data.datasets.map((ds, i) => {
+                                const label = ds.label;
+                                const color = statusColors[label.toUpperCase()] || '#888';
+                                return {
+                                    text: label,
+                                    fillStyle: color,
+                                    strokeStyle: color,
+                                    lineWidth: 1,
+                                    pointStyle: 'rect',
+                                    hidden: false,
+                                    index: i
+                                };
+                            });
+                        }
+                    }
+                },
+                title: { display: true, text: 'Status by Phase', font: { size: 18 }, padding: { top: 0, bottom: 4 } }
+            },
+            scales: {
+                x: {
+                    stacked: true,
+                    title: { display: false },
+                    ticks: {
+                        font: { size: 10, weight: 'bold' },
+                        color: '#212121',
+                        stepSize: 1,
+                        callback: function(value, index) {
+                            return phaseLabels && phaseLabels[index] ? phaseLabels[index] : value;
+                        }
+                    }
+                },
+                y: {
+                    stacked: true,
+                    beginAtZero: true,
+                    title: {
+                        display: true,
+                        text: 'Test Cases',
+                        font: { size: 12, weight: 'bold' },
+                        color: '#212121'
+                    },
+                    ticks: {
+                        font: { size: 10, weight: 'bold' },
+                        color: '#212121',
+                        stepSize: 1,
+                        callback: function(value) {
+                            if (Number.isInteger(value)) return value;
+                            return '';
+                        }
+                    }
+                }
+            }
+        }
+    });
+}
+(function() {
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', initializePhaseChart);
+    } else {
+        initializePhaseChart();
+    }
+})();
+</script>

robo_automation_test_kit/templates/html_report/components/results-table.html

@@ -0,0 +1,240 @@
+<!-- Results Table Component -->
+<div class="execution-summary">
+    {% set has_passed = report_rows|selectattr('test_status', 'equalto', 'PASSED')|list|length > 0 %}
+    {% set has_failed = report_rows|selectattr('test_status', 'equalto', 'FAILED')|list|length > 0 %}
+    {% set has_skipped = report_rows|selectattr('test_status', 'equalto', 'SKIPPED')|list|length > 0 %}
+    <span class="execution-label">
+        {% if has_passed %}
+        <input type="checkbox" class="status-filter" value="PASSED" checked>
+        <label for="status-passed" class="passed">PASSED</label>
+        {% endif %}
+        {% if has_failed %}
+        <input type="checkbox" class="status-filter" value="FAILED" checked>
+        <label for="status-failed" class="failed">FAILED</label>
+        {% endif %}
+        {% if has_skipped %}
+        <input type="checkbox" class="status-filter" value="SKIPPED" checked>
+        <label for="status-skipped" class="skipped">SKIPPED</label>
+        {% endif %}
+    </span>
+    <input type="text" class="filter-input" id="resultsTableFilter" placeholder="Filter results...">
+    <span class="execution-details">
+        Executed <span class="execution-count">{{ summary.total }}</span> test cases in <span class="execution-count">{{
+            summary.duration }}</span> (HH:MM:SS)
+    </span>
+</div>
+
+<table class="results-table" id="resultsTable">
+    <thead>
+        <tr>
+            <th class="row_number" data-column-type="row_number">#</th>
+            <th class="sortable test_status" data-column-type="test_status">Status</th>
+            <th class="sortable test_case_name" data-column-type="test_case_name">Test Case Name</th>
+            <th class="sortable phase" data-column-type="phase">Phase</th>
+            <th class="sortable request_category" data-column-type="request_category">Request Category</th>
+            <th class="sortable request_sub_category" data-column-type="request_sub_category">Request Sub-Category</th>
+            <th class="sortable center" data-column-type="center">Center</th>
+            <th class="sortable duration" data-column-type="duration">Duration</th>
+        </tr>
+    </thead>
+    <tbody>
+        {% for row in report_rows %}
+        <tr data-test-name="{{ row.test_case_name|e }}" data-outcome="{{ row.test_status|e }}"
+            data-error="{{ row.error_log|e }}">
+            <td>{{ loop.index }}</td>
+            <td class="status-{{ row.test_status|lower }}">
+                {{ row.test_status }}
+            </td>
+            <td>{{ row.test_case_name or '' }}</td>
+            <td>{{ row['Phase'] or '' }}</td>
+            <td>{{ row['Request Category'] or '' }}</td>
+            <td>{{ row['Request Sub-Category'] or '' }}</td>
+            <td>{{ row['Center'] or '' }}</td>
+            <td data-value="{{ row['duration']|default(0, true)|int }}">{{ format_duration(row['duration'])|default('',
+                true) }}</td>
+        </tr>
+        {% endfor %}
+    </tbody>
+</table>
+
+<!-- Error Modal Markup -->
+<div id="errorModal" class="error-modal">
+    <div id="errorModalContent" class="error-modal-content">
+        <div class="error-modal-header">
+            <span id="errorModalTitle" class="error-modal-title"></span>
+            <div class="error-modal-controls">
+                <!-- Material Icons Expand/Minimize Buttons -->
+                <span id="expandIcon" class="modal-header-icon material-icons" title="Maximize"
+                    onclick="toggleFullscreen()">open_in_full</span>
+                <span id="minimizeIcon" class="modal-header-icon material-icons" title="Minimize" style="display:none;"
+                    onclick="toggleFullscreen()">minimize</span>
+                <button class="modal-header-icon error-modal-btn" title="Close"
+                    onclick="closeErrorModal()">&times;</button>
+            </div>
+        </div>
+        <div id="errorModalBody">
+            <div id="errorMessage" class="error-message"></div>
+        </div>
+    </div>
+</div>
+
+<script>
+    // Results Table: Filtering and Error Modal Logic
+
+    // Reindex the row numbers based on visible rows
+    function reindexVisibleRows(table) {
+        if (!table) {
+            return;
+        }
+
+        const tbody = table.querySelector('tbody');
+        if (!tbody) {
+            return;
+        }
+
+        const rows = tbody.querySelectorAll('tr');
+        let visibleIndex = 1;
+
+        rows.forEach((row, i) => {
+            // Check if row is visible (display is not 'none')
+            const computedStyle = window.getComputedStyle(row);
+            const isVisible = computedStyle.display !== 'none';
+
+            if (isVisible && row.cells && row.cells[0]) {
+                const oldValue = row.cells[0].textContent;
+                row.cells[0].textContent = visibleIndex;
+                visibleIndex++;
+            }
+        });
+    }
+
+    // Filter table based on status checkboxes and search input
+    function setupTableFilters() {
+        const statusFilters = document.querySelectorAll('.status-filter');
+        const searchInput = document.getElementById('resultsTableFilter');
+        const table = document.getElementById('resultsTable');
+
+        if (!table || statusFilters.length === 0) return;
+
+        function filterTable() {
+            const selectedStatuses = Array.from(statusFilters)
+                .filter(f => f.checked)
+                .map(f => f.value.toUpperCase());
+
+            const searchTerm = searchInput ? searchInput.value.toLowerCase() : '';
+            const rows = table.querySelectorAll('tbody tr');
+
+            rows.forEach((row, index) => {
+                const statusCell = row.cells[1];
+                if (!statusCell) return;
+
+                const status = statusCell.textContent.trim().toUpperCase();
+
+                // Only show rows that match CHECKED statuses (if any are checked)
+                // If no statuses are checked, hide all rows
+                const matchesStatus = selectedStatuses.length > 0 && selectedStatuses.includes(status);
+
+                // Check if row text matches search term
+                const rowText = Array.from(row.cells).map(c => c.textContent.toLowerCase()).join(' ');
+                const matchesSearch = searchTerm === '' || rowText.includes(searchTerm);
+
+                const shouldShow = matchesStatus && matchesSearch;
+                row.style.display = shouldShow ? '' : 'none';
+            });
+
+            // Reindex visible rows after filtering
+            reindexVisibleRows(table);
+        }
+
+        // Attach change listeners to checkboxes
+        statusFilters.forEach(filter => {
+            filter.addEventListener('change', filterTable);
+        });
+
+        // Attach input listener to search box
+        if (searchInput) {
+            searchInput.addEventListener('input', filterTable);
+        }
+
+        // Apply filter on initial load
+        filterTable();
+    }
+
+    // Set up filters when DOM is ready
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', setupTableFilters);
+    } else {
+        setupTableFilters();
+    }
+
+    // Ensure reindexing happens after page fully loads and filters are applied
+    window.addEventListener('load', function () {
+        const table = document.getElementById('resultsTable');
+        if (table) {
+            // Delay to ensure filters have been applied
+            setTimeout(function () {
+                reindexVisibleRows(table);
+            }, 200);
+        }
+    });
+
+    // Error modal logic
+    window.showErrorDetails = function (row) {
+        document.querySelectorAll('.results-table tr.selected').forEach(tr => tr.classList.remove('selected'));
+        row.classList.add('selected');
+        const testName = row.getAttribute('data-test-name') || 'Unknown Test';
+        const outcome = row.getAttribute('data-outcome') || 'Unknown';
+        const error = row.getAttribute('data-error') || 'No error details available';
+        document.getElementById('errorModalTitle').textContent = `${testName} - ${outcome.toUpperCase()}`;
+        document.getElementById('errorMessage').textContent = error;
+        document.getElementById('errorModal').style.display = 'block';
+        document.getElementById('expandIcon').style.display = '';
+        document.getElementById('minimizeIcon').style.display = 'none';
+    };
+
+    window.closeErrorModal = function () {
+        document.getElementById('errorModal').style.display = 'none';
+        document.getElementById('errorModalContent').classList.remove('fullscreen');
+        document.querySelectorAll('.results-table tr.selected').forEach(tr => tr.classList.remove('selected'));
+    };
+
+    window.toggleFullscreen = function () {
+        const modalContent = document.getElementById('errorModalContent');
+        const expandIcon = document.getElementById('expandIcon');
+        const minimizeIcon = document.getElementById('minimizeIcon');
+        const isFullscreen = modalContent.classList.toggle('fullscreen');
+        if (isFullscreen) {
+            expandIcon.style.display = 'none';
+            minimizeIcon.style.display = '';
+        } else {
+            expandIcon.style.display = '';
+            minimizeIcon.style.display = 'none';
+        }
+    };
+
+    window.onclick = function (event) {
+        const modal = document.getElementById('errorModal');
+        if (event.target === modal) {
+            window.closeErrorModal();
+        }
+    };
+
+    document.addEventListener('keydown', function (event) {
+        if (event.key === 'Escape') {
+            const modal = document.getElementById('errorModal');
+            if (modal && modal.style.display === 'block') {
+                window.closeErrorModal();
+            }
+        }
+    });
+
+    // Attach click event to table rows for error popup
+    var table = document.getElementById('resultsTable');
+    if (table) {
+        table.querySelectorAll('tbody tr').forEach(function (row) {
+            row.addEventListener('click', function () {
+                showErrorDetails(row);
+            });
+        });
+    }
+</script>