less 4.4.1 → 4.5.1

package/test/index.js

@@ -1,112 +1,307 @@
-var lessTest = require('./less-test'),
-    lessTester = lessTest(),
-    path = require('path'),
-    stylize = require('../lib/less-node/lessc-helper').stylize,
-    nock = require('nock');
+// Mock needle for HTTP requests BEFORE any other requires
+const Module = require('module');
+const originalRequire = Module.prototype.require;
+Module.prototype.require = function(id) {
+    if (id === 'needle') {
+        return {
+            get: function(url, options, callback) {
+                
+                // Handle CDN requests
+                if (url.includes('cdn.jsdelivr.net')) {
+                    if (url.includes('selectors.less')) {
+                        setTimeout(() => {
+                            callback(null, { statusCode: 200 }, fs.readFileSync(path.join(__dirname, '../../test-data/tests-unit/selectors/selectors.less'), 'utf8'));
+                        }, 10);
+                        return;
+                    }
+                    if (url.includes('media.less')) {
+                        setTimeout(() => {
+                            callback(null, { statusCode: 200 }, fs.readFileSync(path.join(__dirname, '../../test-data/tests-unit/media/media.less'), 'utf8'));
+                        }, 10);
+                        return;
+                    }
+                    if (url.includes('empty.less')) {
+                        setTimeout(() => {
+                            callback(null, { statusCode: 200 }, fs.readFileSync(path.join(__dirname, '../../test-data/tests-unit/empty/empty.less'), 'utf8'));
+                        }, 10);
+                        return;
+                    }
+                }
+                
+                // Handle redirect test - simulate needle's automatic redirect handling
+                if (url.includes('example.com/redirect.less')) {
+                    setTimeout(() => {
+                        // Simulate the final response after needle automatically follows the redirect
+                        callback(null, { statusCode: 200 }, 'h1 { color: blue; }');
+                    }, 10);
+                    return;
+                }
+                
+                if (url.includes('example.com/target.less')) {
+                    setTimeout(() => {
+                        callback(null, { statusCode: 200 }, 'h1 { color: blue; }');
+                    }, 10);
+                    return;
+                }
+                
+                // Default error for unmocked URLs
+                setTimeout(() => {
+                    callback(new Error('Unmocked URL: ' + url), null, null);
+                }, 10);
+            }
+        };
+    }
+    return originalRequire.apply(this, arguments);
+};
+
+// Now load other modules after mocking is set up
+var path = require('path'),
+    fs = require('fs'),
+    lessTest = require('./less-test'),
+    stylize = require('../lib/less-node/lessc-helper').stylize;
+
+// Parse command line arguments for test filtering
+var args = process.argv.slice(2);
+var testFilter = args.length > 0 ? args[0] : null;
+
+// Create the test runner with the filter
+var lessTester = lessTest(testFilter);
+
+// HTTP mocking is now handled by needle mocking above
+
+// Test HTTP redirect functionality
+function testHttpRedirects() {
+    const less = require('../lib/less-node').default;
+    
+    console.log('🧪 Testing HTTP redirect functionality...');
+    
+    const redirectTest = `
+@import "https://example.com/redirect.less";
+
+h1 { color: red; }
+`;
+
+    return less.render(redirectTest, {
+        filename: 'test-redirect.less'
+    }).then(result => {
+        console.log('✅ HTTP redirect test SUCCESS:');
+        console.log(result.css);
+        
+        // Check if both imported and local content are present
+        if (result.css.includes('color: blue') && result.css.includes('color: red')) {
+            console.log('🎉 HTTP redirect test PASSED - both imported and local content found');
+            return true;
+        } else {
+            console.log('❌ HTTP redirect test FAILED - missing expected content');
+            return false;
+        }
+    }).catch(err => {
+        console.log('❌ HTTP redirect test ERROR:');
+        console.log(err.message);
+        return false;
+    });
+}
+
+// Test import-remote functionality
+function testImportRemote() {
+    const less = require('../lib/less-node').default;
+    const fs = require('fs');
+    const path = require('path');
+    
+    console.log('🧪 Testing import-remote functionality...');
+    
+    const testFile = path.join(__dirname, '../../test-data/tests-unit/import/import-remote.less');
+    const expectedFile = path.join(__dirname, '../../test-data/tests-unit/import/import-remote.css');
+    
+    const content = fs.readFileSync(testFile, 'utf8');
+    const expected = fs.readFileSync(expectedFile, 'utf8');
+    
+    return less.render(content, {
+        filename: testFile
+    }).then(result => {
+        console.log('✅ Import-remote test SUCCESS:');
+        console.log('Expected:', expected.trim());
+        console.log('Actual:', result.css.trim());
+        
+        if (result.css.trim() === expected.trim()) {
+            console.log('🎉 Import-remote test PASSED - CDN imports and variable resolution working');
+            return true;
+        } else {
+            console.log('❌ Import-remote test FAILED - output mismatch');
+            return false;
+        }
+    }).catch(err => {
+        console.log('❌ Import-remote test ERROR:');
+        console.log(err.message);
+        return false;
+    });
+}
 
 console.log('\n' + stylize('Less', 'underline') + '\n');
 
+if (testFilter) {
+    console.log('Running tests matching: ' + testFilter + '\n');
+}
+
+// Glob patterns for main test runs (excluding problematic tests that will run separately)
+var globPatterns = [
+    'tests-config/*/*.less',
+    'tests-unit/*/*.less',
+    // Debug tests have nested subdirectories (comments/, mediaquery/, all/)
+    'tests-config/debug/*/linenumbers-*.less',
+    '!tests-config/sourcemaps/**/*.less',   // Exclude sourcemaps (need special handling)
+    '!tests-config/sourcemaps-empty/*',     // Exclude sourcemaps-empty (need special handling)
+    '!tests-config/sourcemaps-disable-annotation/*', // Exclude sourcemaps-disable-annotation (need special handling)
+    '!tests-config/sourcemaps-variable-selector/*',  // Exclude sourcemaps-variable-selector (need special handling)
+    '!tests-config/globalVars/*',           // Exclude globalVars (need JSON config handling)
+    '!tests-config/modifyVars/*',           // Exclude modifyVars (need JSON config handling)
+    '!tests-config/js-type-errors/*',       // Exclude js-type-errors (need special test function)
+    '!tests-config/no-js-errors/*',         // Exclude no-js-errors (need special test function)
+    '!tests-unit/import/import-remote.less', // Exclude import-remote (tested separately in isolation)
+
+    // HTTP import tests are now included since we have needle mocking
+];
+
 var testMap = [
-    [{
-        // TODO: Change this to rewriteUrls: 'all' once the relativeUrls option is removed
-        relativeUrls: true,
-        silent: true,
-        javascriptEnabled: true
-    }, '_main/'],
-    [{}, 'namespacing/'],
-    [{
-        math: 'parens'
-    }, 'math/strict/'],
-    [{
-        math: 'parens-division'
-    }, 'math/parens-division/'],
-    [{
-        math: 'always'
-    }, 'math/always/'],
-    // Use legacy strictMath: true here to demonstrate it still works
-    [{strictMath: true, strictUnits: true, javascriptEnabled: true}, '../errors/eval/',
-        lessTester.testErrors, null],
-    [{strictMath: true, strictUnits: true, javascriptEnabled: true}, '../errors/parse/',
-        lessTester.testErrors, null],
-    [{math: 'strict', strictUnits: true, javascriptEnabled: true}, 'js-type-errors/',
-        lessTester.testTypeErrors, null],
-    [{math: 'strict', strictUnits: true, javascriptEnabled: false}, 'no-js-errors/',
-        lessTester.testErrors, null],
-    [{math: 'strict', dumpLineNumbers: 'comments'}, 'debug/', null,
-        function(name) { return name + '-comments'; }],
-    [{math: 'strict', dumpLineNumbers: 'mediaquery'}, 'debug/', null,
-        function(name) { return name + '-mediaquery'; }],
-    [{math: 'strict', dumpLineNumbers: 'all'}, 'debug/', null,
-        function(name) { return name + '-all'; }],
-    // TODO: Change this to rewriteUrls: false once the relativeUrls option is removed
-    [{math: 'strict', relativeUrls: false, rootpath: 'folder (1)/'}, 'static-urls/'],
-    [{math: 'strict', compress: true}, 'compression/'],
-
-    [{math: 0, strictUnits: true}, 'units/strict/'],
-    [{math: 0, strictUnits: false}, 'units/no-strict/'],
-
-    [{math: 'strict', strictUnits: true, sourceMap: true, globalVars: true }, 'sourcemaps/',
-        lessTester.testSourcemap, null, null,
-        function(filename, type, baseFolder) {
+    // Main test runs using glob patterns (cosmiconfig handles configs)
+    {
+        patterns: globPatterns
+    },
+
+    // Error tests
+    {
+        patterns: ['tests-error/eval/*.less'],
+        verifyFunction: lessTester.testErrors
+    },
+    {
+        patterns: ['tests-error/parse/*.less'],
+        verifyFunction: lessTester.testErrors
+    },
+
+    // Special test cases with specific handling
+    {
+        patterns: ['tests-config/js-type-errors/*.less'],
+        verifyFunction: lessTester.testTypeErrors
+    },
+    {
+        patterns: ['tests-config/no-js-errors/*.less'],
+        verifyFunction: lessTester.testErrors
+    },
+
+    // Sourcemap tests with special handling
+    {
+        patterns: [
+            'tests-config/sourcemaps/**/*.less',
+            'tests-config/sourcemaps-url/**/*.less',
+            'tests-config/sourcemaps-rootpath/**/*.less',
+            'tests-config/sourcemaps-basepath/**/*.less',
+            'tests-config/sourcemaps-include-source/**/*.less'
+        ],
+        verifyFunction: lessTester.testSourcemap,
+        getFilename: function(filename, type, baseFolder) {
             if (type === 'vars') {
                 return path.join(baseFolder, filename) + '.json';
             }
-            return path.join('test/sourcemaps', filename) + '.json';
-        }],
-
-    [{math: 'strict', strictUnits: true, globalVars: true }, '_main/import/json/',
-        lessTester.testImports, null, true,
-        function(filename, type, baseFolder) {
-            return path.join(baseFolder, filename) + '.json';
-        }],
-    [{math: 'strict', strictUnits: true, sourceMap: {sourceMapFileInline: true}},
-        'sourcemaps-empty/', lessTester.testEmptySourcemap],
-    [{math: 'strict', strictUnits: true, sourceMap: {disableSourcemapAnnotation: true}},
-        'sourcemaps-disable-annotation/', lessTester.testSourcemapWithoutUrlAnnotation],
-    [{math: 'strict', strictUnits: true, sourceMap: true},
-        'sourcemaps-variable-selector/', lessTester.testSourcemapWithVariableInSelector],
-    [{globalVars: true, banner: '/**\n  * Test\n  */\n'}, 'globalVars/',
-        null, null, null, function(name, type, baseFolder) { return path.join(baseFolder, name) + '.json'; }],
-    [{modifyVars: true}, 'modifyVars/',
-        null, null, null, function(name, type, baseFolder) { return path.join(baseFolder, name) + '.json'; }],
-    [{urlArgs: '424242'}, 'url-args/'],
-    [{rewriteUrls: 'all'}, 'rewrite-urls-all/'],
-    [{rewriteUrls: 'local'}, 'rewrite-urls-local/'],
-    [{rootpath: 'http://example.com/assets/css/', rewriteUrls: 'all'}, 'rootpath-rewrite-urls-all/'],
-    [{rootpath: 'http://example.com/assets/css/', rewriteUrls: 'local'}, 'rootpath-rewrite-urls-local/'],
-    [{paths: ['data/', '_main/import/']}, 'include-path/'],
-    [{paths: 'data/'}, 'include-path-string/'],
-    [{plugin: 'test/plugins/postprocess/'}, 'postProcessorPlugin/'],
-    [{plugin: 'test/plugins/preprocess/'}, 'preProcessorPlugin/'],
-    [{plugin: 'test/plugins/visitor/'}, 'visitorPlugin/'],
-    [{plugin: 'test/plugins/filemanager/'}, 'filemanagerPlugin/'],
-    [{math: 0}, '3rd-party/'],
-    [{ processImports: false }, 'process-imports/']
+            // Extract just the filename (without directory) for the JSON file
+            var jsonFilename = path.basename(filename);
+            // For sourcemap type, return path relative to test directory
+            if (type === 'sourcemap') {
+                return path.join('test/sourcemaps', jsonFilename) + '.json';
+            }
+            return path.join('test/sourcemaps', jsonFilename) + '.json';
+        }
+    },
+    {
+        patterns: ['tests-config/sourcemaps-empty/*.less'],
+        verifyFunction: lessTester.testEmptySourcemap
+    },
+    {
+        patterns: ['tests-config/sourcemaps-disable-annotation/*.less'],
+        verifyFunction: lessTester.testSourcemapWithoutUrlAnnotation
+    },
+    {
+        patterns: ['tests-config/sourcemaps-variable-selector/*.less'],
+        verifyFunction: lessTester.testSourcemapWithVariableInSelector
+    },
+
+    // Import tests with JSON configs
+    {
+        patterns: ['tests-config/globalVars/*.less'],
+        lessOptions: {
+            globalVars: function(file) {
+                const fs = require('fs');
+                const path = require('path');
+                const basename = path.basename(file, '.less');
+                const jsonPath = path.join(path.dirname(file), basename + '.json');
+                try {
+                    return JSON.parse(fs.readFileSync(jsonPath, 'utf8'));
+                } catch (e) {
+                    return {};
+                }
+            }
+        }
+    },
+    {
+        patterns: ['tests-config/modifyVars/*.less'],
+        lessOptions: {
+            modifyVars: function(file) {
+                const fs = require('fs');
+                const path = require('path');
+                const basename = path.basename(file, '.less');
+                const jsonPath = path.join(path.dirname(file), basename + '.json');
+                try {
+                    return JSON.parse(fs.readFileSync(jsonPath, 'utf8'));
+                } catch (e) {
+                    return {};
+                }
+            }
+        }
+    }
 ];
-testMap.forEach(function(args) {
-    lessTester.runTestSet.apply(lessTester, args)
+
+// Note: needle mocking is set up globally at the top of the file
+
+testMap.forEach(function(testConfig) {
+    // For glob patterns, pass lessOptions as the first parameter and patterns as the second
+    if (testConfig.patterns) {
+        lessTester.runTestSet(
+            testConfig.lessOptions || {},           // First param: options (including lessOptions)
+            testConfig.patterns,                    // Second param: patterns
+            testConfig.verifyFunction || null,      // Third param: verifyFunction
+            testConfig.nameModifier || null,        // Fourth param: nameModifier
+            testConfig.doReplacements || null,      // Fifth param: doReplacements
+            testConfig.getFilename || null          // Sixth param: getFilename
+        );
+    } else {
+        // Legacy format for non-glob tests
+        var args = [
+            testConfig.options || {},               // First param: options
+            testConfig.foldername,                  // Second param: foldername
+            testConfig.verifyFunction || null,      // Third param: verifyFunction
+            testConfig.nameModifier || null,        // Fourth param: nameModifier
+            testConfig.doReplacements || null,      // Fifth param: doReplacements
+            testConfig.getFilename || null          // Sixth param: getFilename
+        ];
+        lessTester.runTestSet.apply(lessTester, args);
+    }
 });
-lessTester.testSyncronous({syncImport: true}, '_main/import');
-lessTester.testSyncronous({syncImport: true}, '_main/plugin');
-lessTester.testSyncronous({syncImport: true}, 'math/strict/css');
+
+// Special synchronous tests
+lessTester.testSyncronous({syncImport: true}, 'tests-unit/import/import');
+lessTester.testSyncronous({syncImport: true}, 'tests-config/math-strict/css');
+
 lessTester.testNoOptions();
 lessTester.testDisablePluginRule();
 lessTester.testJSImport();
 lessTester.finished();
 
-(() => {
-    // Create new tester, since tests are not independent and tests
-    // above modify tester in a way that breaks remote imports.
-    lessTester = lessTest();
-    var scope = nock('https://example.com')
-        .get('/redirect.less').query(true)
-        .reply(301, null, { location: '/target.less' })
-        .get('/target.less').query(true)
-        .reply(200);
-    lessTester.runTestSet(
-        {},
-        'import-redirect/',
-        lessTester.testImportRedirect(scope)
-    );
-    lessTester.finished();
-})();
+
+// Test HTTP redirect functionality
+console.log('\nTesting HTTP redirect functionality...');
+testHttpRedirects();
+console.log('HTTP redirect test completed');
+
+// Test import-remote functionality in isolation
+console.log('\nTesting import-remote functionality...');
+testImportRemote();
+console.log('Import-remote test completed');