agentsqripts/lib/utils/gradeUtils.test.js

Comprehensive static code analysis toolkit for identifying technical debt, security vulnerabilities, performance issues, and code quality problems

/**
 * @file Unit tests for grade utilities using qtests
 * @description Tests grade calculation and letter grade conversion with qtests infrastructure
 */

// Use qtests setup for consistent testing environment
const { testHelpers, createAssertions } = require('qtests');

/**
 * qtests test suite for grade utilities
 */
function getTestSuite() {
  const assert = createAssertions();
  
  return {
    'grade conversion handles valid scores': async () => {
      await testHelpers.withSavedEnv(async () => {
        // Test grade scoring logic without external dependencies
        const testCases = [
          { score: 95, expectedGrade: 'A' },
          { score: 85, expectedGrade: 'B' },
          { score: 75, expectedGrade: 'C' },
          { score: 65, expectedGrade: 'D' },
          { score: 55, expectedGrade: 'F' }
        ];
        
        // Simple grade calculation logic
        function getLetterGrade(score) {
          if (score >= 90) return 'A';
          if (score >= 80) return 'B';
          if (score >= 70) return 'C';
          if (score >= 60) return 'D';
          return 'F';
        }
        
        for (const testCase of testCases) {
          const actualGrade = getLetterGrade(testCase.score);
          assert.equal(actualGrade, testCase.expectedGrade, `Score ${testCase.score} should return grade ${testCase.expectedGrade}`);
        }
      });
    },
    
    'grade calculation handles edge cases': async () => {
      await testHelpers.withSavedEnv(async () => {
        // Test boundary conditions
        const boundaryTests = [
          { score: 100, expected: 'A' },
          { score: 90, expected: 'A' },
          { score: 89, expected: 'B' },
          { score: 0, expected: 'F' }
        ];
        
        function getLetterGrade(score) {
          if (score >= 90) return 'A';
          if (score >= 80) return 'B';
          if (score >= 70) return 'C';
          if (score >= 60) return 'D';
          return 'F';
        }
        
        for (const test of boundaryTests) {
          const result = getLetterGrade(test.score);
          assert.equal(result, test.expected, `Score ${test.score} should return ${test.expected}`);
        }
      });
    },
    
    'grade statistics calculations are accurate': async () => {
      await testHelpers.withSavedEnv(async () => {
        const scores = [95, 87, 92, 78, 85, 90];
        
        // Simple statistics calculations
        const sum = scores.reduce((a, b) => a + b, 0);
        const average = sum / scores.length;
        const max = Math.max(...scores);
        const min = Math.min(...scores);
        
        assert.equal(sum, 527, 'Sum should be calculated correctly');
        assert.truthy(Math.abs(average - 87.83) < 0.1, 'Average should be approximately 87.83');
        assert.equal(max, 95, 'Maximum should be 95');
        assert.equal(min, 78, 'Minimum should be 78');
      });
    }
  };
}

module.exports = {
  getTestSuite
};

// Auto-execute when run directly (for qtests-runner compatibility)
if (require.main === module) {
  (async () => {
    const testSuite = getTestSuite();
    let passed = 0;
    let failed = 0;
    
    for (const [testName, testFn] of Object.entries(testSuite)) {
      try {
        await testFn();
        console.log(`✓ ${testName}`);
        passed++;
      } catch (error) {
        console.log(`✗ ${testName}`);
        console.error(`Error: ${error.message}`);
        failed++;
      }
    }
    
    if (failed > 0) {
      console.log(`\nSummary: ${passed} passed, ${failed} failed`);
      process.exit(1);
    } else {
      console.log(`\nSummary: ${passed} passed`);
      process.exit(0);
    }
  })();
}