diff --git a/src/yui/js/yui-log.js b/src/yui/js/yui-log.js
index cf21014ec4f..39f05f35ea6 100644
--- a/src/yui/js/yui-log.js
+++ b/src/yui/js/yui-log.js
@@ -47,12 +47,27 @@ INSTANCE.log = function(msg, cat, src, silent) {
if (typeof src !== "undefined") {
excl = c.logExclude;
incl = c.logInclude;
- if (incl && !(src in incl)) {
- bail = 1;
- } else if (incl && (src in incl)) {
- bail = !incl[src];
- } else if (excl && (src in excl)) {
- bail = excl[src];
+ if (incl) {
+ if (src in incl) {
+ // Exact match found -g rab the log level and bail setting.
+ bail = !incl[src];
+ minlevel = incl[src];
+ } else if (incl['*']) {
+ // Allow specification of differential logging.
+ bail = !incl['*'];
+ minlevel = incl['*'];
+ } else {
+ // No matching log categories, bail
+ bail = 1;
+ }
+ } else if (excl) {
+ if (src in excl) {
+ // Exact match found - grab the log level and bail setting.
+ bail = excl[src];
+ } else if (excl['*']) {
+ // Allow specification of differential logging.
+ bail = excl['*'];
+ }
}
// Set a default category of info if the category was not defined or was not
@@ -62,8 +77,10 @@ INSTANCE.log = function(msg, cat, src, silent) {
}
// Determine the current minlevel as defined in configuration
- Y.config.logLevel = Y.config.logLevel || 'debug';
- minlevel = LEVELS[Y.config.logLevel.toLowerCase()];
+ if (typeof minlevel !== 'string') {
+ minlevel = Y.config.logLevel || 'debug';
+ }
+ minlevel = LEVELS[minlevel.toLowerCase()];
if (cat in LEVELS && LEVELS[cat] < minlevel) {
// Skip this message if the we don't meet the defined minlevel
diff --git a/src/yui/js/yui.js b/src/yui/js/yui.js
index c7c1c322182..b4eb6d0adc5 100644
--- a/src/yui/js/yui.js
+++ b/src/yui/js/yui.js
@@ -1673,6 +1673,47 @@ supported console.
A hash of log sources that should be logged. If specified, only messages from
these sources will be logged. Others will be discarded.
+The object key consists of:
+
+- An exact match for the `src` specified when calling Y.log; or
+- The `*` source - to indicate a logLevel for all other sources.
+
+
+Each object value in the hash can take either:
+
+- `true` - in which case, the log threshold defined in Y.config.logLevel is used;
+- `false` - in which case, that source is excluded; or
+- a valid logLevel.
+
+
+See Y.config.logLevel for details of the full list of log levels.
+
+If logExclude has also been specified, then this logInclude setting
+will take precedent and logExclude will be ignored entirely.
+
+An example configuration is shown below:
+
+ YUI_config = {
+ // The default logLevel will be warn:
+ logLevel: 'warn',
+ logInclude: {
+ // Reduce the logging threshold to debug for event-delegate:
+ 'event-delegate': 'debug',
+
+ // Reduce the logging threshold to info for event-logged-at-info:
+ 'event-logged-at-info': 'info',
+
+ // Reduce the logging threshold to Y.config.logLevel for event-logged-at-true:
+ 'event-logged-at-true': true,
+
+ // Do not log anything for 'event-not-logged':
+ 'event-not-logged': false,
+
+ // Do not log anything for everything else:
+ '*': false
+ }
+ };
+
@property {Object} logInclude
@type object
**/
@@ -1681,6 +1722,33 @@ these sources will be logged. Others will be discarded.
A hash of log sources that should be not be logged. If specified, all sources
will be logged *except* those on this list.
+The object key consists of:
+
+- An exact match for the `src` specified when calling Y.log; or
+- The `*` source - to indicate a setting for all other sources.
+
+
+The object value must be a boolean, unlike in logInclude.
+
+If logInclude has been specified, then it will take precedent and
+logExclude setting will be ignored entirely.
+
+An example configuration which filters out all sources with the exception of event-delegate.
+
+ YUI_config = {
+ // The default logLevel will be warn:
+ logLevel: 'warn',
+ logExclude: {
+ // Do not exclude event-delegate:
+ 'event-delegate': false,
+
+ // Exclude everything else:
+ '*': true,
+ }
+ };
+
+Note: The above example can be more better achieved using logInclude, but is displayed for completeness.
+
@property {Object} logExclude
**/
diff --git a/src/yui/tests/unit/assets/core-tests.js b/src/yui/tests/unit/assets/core-tests.js
index 7568efa65e5..47a1320d3ad 100644
--- a/src/yui/tests/unit/assets/core-tests.js
+++ b/src/yui/tests/unit/assets/core-tests.js
@@ -53,8 +53,6 @@ YUI.add('core-tests', function(Y) {
ignore: {
'getLocation() should return the location object': (Y.UA.nodejs ? true : false),
'getLocation() should return `null` when executing in node.js': (!Y.UA.nodejs || (Y.UA.nodejs && Y.config.win)), //If there is a window object, ignore too
- test_log_params: (typeof console == "undefined" || !console.info || Y.UA.nodejs),
- test_log_default_category: (typeof console == "undefined" || !console.info || Y.UA.nodejs),
'test: domready delay': !Y.config.win,
'test: window.onload delay': !Y.config.win,
'test: contentready delay': !Y.config.win,
@@ -267,242 +265,6 @@ YUI.add('core-tests', function(Y) {
//Assert.areSame(info.filter, core_urls[i].filter, 'Filters do not match (' + core_urls[i].path + ')');
}
},
- test_log_params: function() {
- if (typeof console == "undefined" || !console.info) {
- return;
- }
- var l = console.info,
- Assert = Y.Assert,
- last;
-
- // Override all of the console functions so that we can check
- // their return values.
- console.error = console.log = console.warn = console.debug = console.info = function(str) {
- last = str.split(':')[0];
- };
-
- YUI().use(function (Y) {
- Y.applyConfig({
- logInclude: {
- logMe: true,
- butNotMe: false
- }
- });
-
- Y.log('test logInclude logMe','info','logMe');
- Assert.areEqual(last, 'logMe', 'logInclude (true) Failed');
- last = undefined;
-
- Y.log('test logInclude butNotMe','info','butNotMe');
- Assert.isUndefined(last, 'logInclude (false) Failed');
-
- Y.applyConfig({
- logInclude: '',
- logExclude: {
- excludeMe: true,
- butDontExcludeMe: false
- }
- });
- Y.log('test logExclude excludeMe','info','excludeMe');
- Assert.isUndefined(last, 'excludeInclude (true) Failed');
- Y.log('test logExclude butDontExcludeMe','info','butDontExcludeMe');
- Assert.areEqual(last, 'butDontExcludeMe', 'logExclue (false) Failed');
-
- Y.applyConfig({
- logInclude: {
- davglass: true
- },
- logExclude: {
- '': true
- }
- });
- last = undefined;
- Y.log('This should be ignored', 'info');
- Assert.isUndefined(last, 'Failed to exclude log param with empty string');
- Y.log('This should NOT be ignored', 'info', 'davglass');
- Assert.areEqual(last, 'davglass', 'Failed to include log param');
-
- // Default logLevel is debug
- Y.applyConfig({
- logInclude: {
- 'logleveltest': true
- }
- });
- last = undefined;
- Y.log('This should be logged', 'debug', 'logleveltest');
- Assert.areEqual(last, 'logleveltest', 'Failed to include log param');
- last = undefined;
- Y.log('This should be logged', 'info', 'logleveltest');
- Assert.areEqual(last, 'logleveltest', 'Failed to include log param');
- last = undefined;
- Y.log('This should be logged', 'warn', 'logleveltest');
- Assert.areEqual(last, 'logleveltest', 'Failed to include log param');
- last = undefined;
- Y.log('This should be logged', 'error', 'logleveltest');
- Assert.areEqual(last, 'logleveltest', 'Failed to include log param');
-
- // Debug should also take effect when actively specified
- Y.applyConfig({
- logLevel: 'debug'
- });
- last = undefined;
- Y.log('This should be logged', 'debug', 'logleveltest');
- Assert.areEqual(last, 'logleveltest', 'Failed to include log param');
- last = undefined;
- Y.log('This should be logged', 'info', 'logleveltest');
- Assert.areEqual(last, 'logleveltest', 'Failed to include log param');
- last = undefined;
- Y.log('This should be logged', 'warn', 'logleveltest');
- Assert.areEqual(last, 'logleveltest', 'Failed to include log param');
- last = undefined;
- Y.log('This should be logged', 'error', 'logleveltest');
- Assert.areEqual(last, 'logleveltest', 'Failed to include log param');
-
- // An invalid log level has the same effect as 'debug'
- Y.applyConfig({
- logLevel: 'invalidloglevel'
- });
- last = undefined;
- Y.log('This should be logged', 'debug', 'logleveltest');
- Assert.areEqual(last, 'logleveltest', 'Failed to include log param');
- last = undefined;
- Y.log('This should be logged', 'info', 'logleveltest');
- Assert.areEqual(last, 'logleveltest', 'Failed to include log param');
- last = undefined;
- Y.log('This should be logged', 'warn', 'logleveltest');
- Assert.areEqual(last, 'logleveltest', 'Failed to include log param');
- last = undefined;
- Y.log('This should be logged', 'error', 'logleveltest');
- Assert.areEqual(last, 'logleveltest', 'Failed to include log param');
-
- Y.applyConfig({
- logLevel: 'info'
- });
- last = undefined;
- Y.log('This should NOT be logged', 'debug', 'logleveltest');
- Assert.isUndefined(last, 'Failed to exclude log level below threshold');
- last = undefined;
- Y.log('This should be logged', 'info', 'logleveltest');
- Assert.areEqual(last, 'logleveltest', 'Failed to include log param');
- last = undefined;
- Y.log('This should be logged', 'warn', 'logleveltest');
- Assert.areEqual(last, 'logleveltest', 'Failed to include log param');
- last = undefined;
- Y.log('This should be logged', 'error', 'logleveltest');
- Assert.areEqual(last, 'logleveltest', 'Failed to include log param');
-
- Y.applyConfig({
- logLevel: 'warn'
- });
- last = undefined;
- Y.log('This should NOT be logged', 'debug', 'logleveltest');
- Assert.isUndefined(last, 'Failed to exclude log level below threshold');
- last = undefined;
- Y.log('This should NOT be logged', 'info', 'logleveltest');
- Assert.isUndefined(last, 'Failed to exclude log level below threshold');
- last = undefined;
- Y.log('This should be logged', 'warn', 'logleveltest');
- Assert.areEqual(last, 'logleveltest', 'Failed to include log param');
- last = undefined;
- Y.log('This should be logged', 'error', 'logleveltest');
- Assert.areEqual(last, 'logleveltest', 'Failed to include log param');
-
- Y.applyConfig({
- logLevel: 'error'
- });
- last = undefined;
- Y.log('This should NOT be logged', 'debug', 'logleveltest');
- Assert.isUndefined(last, 'Failed to exclude log level below threshold');
- last = undefined;
- Y.log('This should NOT be logged', 'info', 'logleveltest');
- Assert.isUndefined(last, 'Failed to exclude log level below threshold');
- last = undefined;
- Y.log('This should NOT be ignored', 'warn', 'logleveltest');
- Assert.isUndefined(last, 'Failed to exclude log level below threshold');
- last = undefined;
- Y.log('This should NOT be ignored', 'error', 'logleveltest');
- Assert.areEqual(last, 'logleveltest', 'Failed to include log param');
-
- Y.applyConfig({
- logLevel: 'ERROR'
- });
- last = undefined;
- Y.log('This should NOT be logged', 'debug', 'logleveltest');
- Assert.isUndefined(last, 'Failed to exclude log level below threshold - case insensitivty possibly ignored');
- last = undefined;
- Y.log('This should NOT be logged', 'info', 'logleveltest');
- Assert.isUndefined(last, 'Failed to exclude log level below threshold - case insensitivty possibly ignored');
- last = undefined;
- Y.log('This should NOT be ignored', 'warn', 'logleveltest');
- Assert.isUndefined(last, 'Failed to exclude log level below threshold - case insensitivty possibly ignored');
- last = undefined;
- Y.log('This should NOT be ignored', 'error', 'logleveltest');
- Assert.areEqual(last, 'logleveltest', 'Failed to include log param');
- });
-
- console.info = l;
- },
- test_log_default_category: function() {
- if (typeof console == "undefined" || !console.info) {
- return;
- }
- var l = console.info,
- Assert = Y.Assert,
- consoleFn,
- last, lastCategory;
-
- // Override all of the console functions so that we can check
- // their return values.
- consoleFn = function(str) {
- last = str.split(':')[0];
- };
- console.error = function(str) {
- lastCategory = 'error';
- consoleFn(str);
- };
- console.log = function(str) {
- lastCategory = 'log';
- consoleFn(str);
- };
- console.warn = function(str) {
- lastCategory = 'warn';
- consoleFn(str);
- };
- console.debug = function(str) {
- lastCategory = 'debug';
- consoleFn(str);
- };
- console.info = function(str) {
- lastCategory = 'info';
- consoleFn(str);
- };
-
- YUI().use(function (Y) {
- Y.applyConfig({
- logLevel: 'debug'
- });
- lastCategory = undefined;
- Y.log('This has a valid log level', 'debug');
- Assert.areEqual(lastCategory, 'debug', 'Failed to log at debug log category');
- lastCategory = undefined;
- Y.log('This has a valid log level', 'info');
- Assert.areEqual(lastCategory, 'info', 'Failed to log at info log category');
- lastCategory = undefined;
- Y.log('This has a valid log level', 'warn');
- Assert.areEqual(lastCategory, 'warn', 'Failed to log at warn log category');
- lastCategory = undefined;
- Y.log('This has a valid log level', 'error');
- Assert.areEqual(lastCategory, 'error', 'Failed to log at error log category');
- lastCategory = undefined;
- Y.log('This has no log level and should use the default');
- Assert.areEqual(lastCategory, 'info', 'Failed to log at default log category of info');
- lastCategory = undefined;
- Y.log('This has an invalid log level and should use the default', 'notice');
- Assert.areEqual(lastCategory, 'info', 'Failed to log at default info log category');
- });
-
- console.info = l;
- },
test_global_apply_config: function() {
var Assert = Y.Assert,
test = this;
diff --git a/src/yui/tests/unit/assets/logging-test.js b/src/yui/tests/unit/assets/logging-test.js
new file mode 100644
index 00000000000..33c1fb6a5ed
--- /dev/null
+++ b/src/yui/tests/unit/assets/logging-test.js
@@ -0,0 +1,650 @@
+YUI.add('logging-test', function(Y) {
+
+ YUI.GlobalConfig = YUI.GlobalConfig || {};
+
+ var lastSource, lastCategory, lastMessage,
+ stockFunctions = {
+ log: console.log,
+ debug: console.debug,
+ info: console.info,
+ warn: console.warn,
+ error: console.error
+ };
+
+ var hasWorkingConsole = function() {
+ return !(typeof console === "undefined" || !console.info || Y.UA.nodejs);
+ };
+
+ var testLogging = new Y.Test.Case({
+
+ name: "Logging tests",
+ _should: {
+ ignore: {
+ test_log_params: !hasWorkingConsole(),
+ test_log_default_category: !hasWorkingConsole(),
+ test_log_filter: !hasWorkingConsole(),
+ 'logInclude: glob override': !hasWorkingConsole(),
+ 'logInclude: minLevel override - matching': !hasWorkingConsole(),
+ 'logInclude: minLevel override - not matching': !hasWorkingConsole(),
+ 'logInclude: truthful boolean - matching': !hasWorkingConsole(),
+ 'logInclude: truthful boolean - mismatching': !hasWorkingConsole(),
+ 'logInclude: falsey boolean': !hasWorkingConsole(),
+ 'logExclude: glob override': !hasWorkingConsole(),
+ 'logExclude: overridden glob': !hasWorkingConsole()
+ }
+ },
+
+ setUp: function() {
+ // Override all of the console functions so that we can check
+ // their return values.
+ var fnName,
+ // Note, this uses partial function binding so the level is first.
+ consoleFn = function(level, str) {
+ var splitString = str.split(':');
+ lastCategory = level;
+ lastSource = splitString && splitString[0] || undefined;
+ lastMessage = splitString && splitString[1] || str;
+ };
+ for (fnName in stockFunctions) {
+ console[fnName] = consoleFn.bind(undefined, fnName);
+ }
+ },
+
+ tearDown: function() {
+ var fnName;
+ for (fnName in stockFunctions) {
+ console[fnName] = stockFunctions[fnName];
+ }
+ },
+
+ test_log_params: function() {
+ var Assert = Y.Assert;
+
+ YUI().use(function (Y) {
+ Y.applyConfig({
+ logInclude: {
+ logMe: true,
+ butNotMe: false
+ }
+ });
+
+ lastSource = undefined;
+ Y.log('test logInclude logMe','info','logMe');
+ Assert.areEqual(lastSource, 'logMe', 'logInclude (true) Failed');
+
+ lastSource = undefined;
+ Y.log('test logInclude butNotMe','info','butNotMe');
+ Assert.isUndefined(lastSource, 'logInclude (false) Failed');
+
+ Y.applyConfig({
+ logInclude: '',
+ logExclude: {
+ excludeMe: true,
+ butDontExcludeMe: false
+ }
+ });
+
+ lastSource = undefined;
+ Y.log('test logExclude excludeMe','info','excludeMe');
+ Assert.isUndefined(lastSource, 'excludeInclude (true) Failed');
+
+ lastSource = undefined;
+ Y.log('test logExclude butDontExcludeMe','info','butDontExcludeMe');
+ Assert.areEqual(lastSource, 'butDontExcludeMe', 'logExclue (false) Failed');
+
+ Y.applyConfig({
+ logInclude: {
+ davglass: true
+ },
+ logExclude: {
+ '': true
+ }
+ });
+
+ lastSource = undefined;
+ Y.log('This should be ignored', 'info');
+ Assert.isUndefined(lastSource, 'Failed to exclude log param with empty string');
+
+ lastSource = undefined;
+ Y.log('This should NOT be ignored', 'info', 'davglass');
+ Assert.areEqual(lastSource, 'davglass', 'Failed to include log param');
+
+ // Default logLevel is debug
+ Y.applyConfig({
+ logInclude: {
+ 'logleveltest': true
+ }
+ });
+
+ lastSource = undefined;
+ Y.log('This should be logged', 'debug', 'logleveltest');
+ Assert.areEqual(lastSource, 'logleveltest', 'Failed to include log param');
+
+ lastSource = undefined;
+ Y.log('This should be logged', 'info', 'logleveltest');
+ Assert.areEqual(lastSource, 'logleveltest', 'Failed to include log param');
+
+ lastSource = undefined;
+ Y.log('This should be logged', 'warn', 'logleveltest');
+ Assert.areEqual(lastSource, 'logleveltest', 'Failed to include log param');
+
+ lastSource = undefined;
+ Y.log('This should be logged', 'error', 'logleveltest');
+ Assert.areEqual(lastSource, 'logleveltest', 'Failed to include log param');
+
+ // Debug should also take effect when actively specified
+ Y.applyConfig({
+ logLevel: 'debug'
+ });
+ lastSource = undefined;
+ Y.log('This should be logged', 'debug', 'logleveltest');
+ Assert.areEqual(lastSource, 'logleveltest', 'Failed to include log param');
+
+ lastSource = undefined;
+ Y.log('This should be logged', 'info', 'logleveltest');
+ Assert.areEqual(lastSource, 'logleveltest', 'Failed to include log param');
+
+ lastSource = undefined;
+ Y.log('This should be logged', 'warn', 'logleveltest');
+ Assert.areEqual(lastSource, 'logleveltest', 'Failed to include log param');
+
+ lastSource = undefined;
+ Y.log('This should be logged', 'error', 'logleveltest');
+ Assert.areEqual(lastSource, 'logleveltest', 'Failed to include log param');
+
+ // An invalid log level has the same effect as 'debug'
+ Y.applyConfig({
+ logLevel: 'invalidloglevel'
+ });
+
+ lastSource = undefined;
+ Y.log('This should be logged', 'debug', 'logleveltest');
+ Assert.areEqual(lastSource, 'logleveltest', 'Failed to include log param');
+
+ lastSource = undefined;
+ Y.log('This should be logged', 'info', 'logleveltest');
+ Assert.areEqual(lastSource, 'logleveltest', 'Failed to include log param');
+
+ lastSource = undefined;
+ Y.log('This should be logged', 'warn', 'logleveltest');
+ Assert.areEqual(lastSource, 'logleveltest', 'Failed to include log param');
+
+ lastSource = undefined;
+ Y.log('This should be logged', 'error', 'logleveltest');
+ Assert.areEqual(lastSource, 'logleveltest', 'Failed to include log param');
+
+ Y.applyConfig({
+ logLevel: 'info'
+ });
+ lastSource = undefined;
+ Y.log('This should NOT be logged', 'debug', 'logleveltest');
+ Assert.isUndefined(lastSource, 'Failed to exclude log level below threshold');
+ lastSource = undefined;
+ Y.log('This should be logged', 'info', 'logleveltest');
+ Assert.areEqual(lastSource, 'logleveltest', 'Failed to include log param');
+ lastSource = undefined;
+ Y.log('This should be logged', 'warn', 'logleveltest');
+ Assert.areEqual(lastSource, 'logleveltest', 'Failed to include log param');
+ lastSource = undefined;
+ Y.log('This should be logged', 'error', 'logleveltest');
+ Assert.areEqual(lastSource, 'logleveltest', 'Failed to include log param');
+
+ Y.applyConfig({
+ logLevel: 'warn'
+ });
+ lastSource = undefined;
+ Y.log('This should NOT be logged', 'debug', 'logleveltest');
+ Assert.isUndefined(lastSource, 'Failed to exclude log level below threshold');
+ lastSource = undefined;
+ Y.log('This should NOT be logged', 'info', 'logleveltest');
+ Assert.isUndefined(lastSource, 'Failed to exclude log level below threshold');
+ lastSource = undefined;
+ Y.log('This should be logged', 'warn', 'logleveltest');
+ Assert.areEqual(lastSource, 'logleveltest', 'Failed to include log param');
+ lastSource = undefined;
+ Y.log('This should be logged', 'error', 'logleveltest');
+ Assert.areEqual(lastSource, 'logleveltest', 'Failed to include log param');
+
+ Y.applyConfig({
+ logLevel: 'error'
+ });
+ lastSource = undefined;
+ Y.log('This should NOT be logged', 'debug', 'logleveltest');
+ Assert.isUndefined(lastSource, 'Failed to exclude log level below threshold');
+ lastSource = undefined;
+ Y.log('This should NOT be logged', 'info', 'logleveltest');
+ Assert.isUndefined(lastSource, 'Failed to exclude log level below threshold');
+ lastSource = undefined;
+ Y.log('This should NOT be ignored', 'warn', 'logleveltest');
+ Assert.isUndefined(lastSource, 'Failed to exclude log level below threshold');
+ lastSource = undefined;
+ Y.log('This should NOT be ignored', 'error', 'logleveltest');
+ Assert.areEqual(lastSource, 'logleveltest', 'Failed to include log param');
+
+ Y.applyConfig({
+ logLevel: 'ERROR'
+ });
+ lastSource = undefined;
+ Y.log('This should NOT be logged', 'debug', 'logleveltest');
+ Assert.isUndefined(lastSource, 'Failed to exclude log level below threshold - case insensitivty possibly ignored');
+ lastSource = undefined;
+ Y.log('This should NOT be logged', 'info', 'logleveltest');
+ Assert.isUndefined(lastSource, 'Failed to exclude log level below threshold - case insensitivty possibly ignored');
+ lastSource = undefined;
+ Y.log('This should NOT be ignored', 'warn', 'logleveltest');
+ Assert.isUndefined(lastSource, 'Failed to exclude log level below threshold - case insensitivty possibly ignored');
+ lastSource = undefined;
+ Y.log('This should NOT be ignored', 'error', 'logleveltest');
+ Assert.areEqual(lastSource, 'logleveltest', 'Failed to include log param');
+ });
+ },
+ test_log_default_category: function() {
+ var Assert = Y.Assert;
+
+ YUI().use(function (Y) {
+ Y.applyConfig({
+ logLevel: 'debug'
+ });
+ lastCategory = undefined;
+ Y.log('This has a valid log level', 'debug');
+ Assert.areEqual(lastCategory, 'debug', 'Failed to log at debug log category');
+ lastCategory = undefined;
+ Y.log('This has a valid log level', 'info');
+ Assert.areEqual(lastCategory, 'info', 'Failed to log at info log category');
+ lastCategory = undefined;
+ Y.log('This has a valid log level', 'warn');
+ Assert.areEqual(lastCategory, 'warn', 'Failed to log at warn log category');
+ lastCategory = undefined;
+ Y.log('This has a valid log level', 'error');
+ Assert.areEqual(lastCategory, 'error', 'Failed to log at error log category');
+ lastCategory = undefined;
+ Y.log('This has no log level and should use the default');
+ Assert.areEqual(lastCategory, 'info', 'Failed to log at default log category of info');
+ lastCategory = undefined;
+ Y.log('This has an invalid log level and should use the default', 'notice');
+ Assert.areEqual(lastCategory, 'info', 'Failed to log at default info log category');
+ });
+ },
+ test_log_filter: function() {
+ var Assert = Y.Assert;
+
+ // Test the default log category override.
+ YUI().use(function (Y) {
+ Y.applyConfig({
+ logLevel: 'error',
+ logInclude: {
+ '*': 'debug'
+ }
+ });
+
+ // Debug is the default level defined in logIncludes and will override the default logLevel:
+ lastCategory = undefined;
+ Y.log('This has a valid log level', 'debug');
+ Assert.areEqual(lastCategory, 'debug', 'Failed to log at debug log category');
+ });
+
+ // Test overrides for a specific source:
+ YUI().use(function (Y) {
+ Y.applyConfig({
+ logLevel: 'error',
+ logInclude: {
+ a: 'info'
+ }
+ });
+
+ // Anything with a source of 'a' should log if it's at 'info' or above:
+ lastCategory = undefined;
+ Y.log('This has a valid log level', 'debug', 'a');
+ Assert.areEqual(lastCategory, undefined, 'Failed to filter out a debug level when the logInclude level was higher.');
+
+ lastCategory = undefined;
+ Y.log('This has a valid log level', 'info', 'a');
+ Assert.areEqual(lastCategory, 'info', 'Failed to log at info log category');
+
+ lastCategory = undefined;
+ Y.log('This has a valid log level', 'warn', 'a');
+ Assert.areEqual(lastCategory, 'warn', 'Failed to log at warn log category');
+
+ lastCategory = undefined;
+ Y.log('This has a valid log level', 'error', 'a');
+ Assert.areEqual(lastCategory, 'error', 'Failed to log at error log category');
+ });
+
+ // Test not overriding for a specific source:
+ YUI().use(function (Y) {
+ Y.applyConfig({
+ logLevel: 'error',
+ logInclude: {
+ a: 'debug'
+ }
+ });
+
+ // Anything with a source of 'a' should log if it's at 'info' or above:
+ lastCategory = undefined;
+ Y.log('This has a valid log level', 'debug', 'b');
+ Assert.areEqual(lastCategory, undefined, 'Failed to filter out a debug level when the logInclude level was higher.');
+
+ lastCategory = undefined;
+ Y.log('This has a valid log level', 'info', 'b');
+ Assert.areEqual(lastCategory, undefined, 'Failed to filter out a debug level when the logInclude level was higher.');
+ lastCategory = undefined;
+ Y.log('This has a valid log level', 'warn', 'b');
+ Assert.areEqual(lastCategory, undefined, 'Failed to filter out a debug level when the logInclude level was higher.');
+
+ lastCategory = undefined;
+ Y.log('This has a valid log level', 'error', 'b');
+ Assert.areEqual(lastCategory, undefined, 'Failed to filter out a debug level when the logInclude level was higher.');
+ });
+
+ // Test true boolean state for logIncludes
+ YUI().use(function (Y) {
+ Y.applyConfig({
+ logLevel: 'error',
+ logInclude: {
+ a: true
+ }
+ });
+
+ // Anything with a source of 'a' should log if it's at 'info' or above:
+ lastCategory = undefined;
+ Y.log('This has a valid log level', 'debug', 'b');
+ Assert.areEqual(lastCategory, undefined, 'Failed to filter out a debug level when the logInclude level was higher.');
+
+ lastCategory = undefined;
+ Y.log('This has a valid log level', 'info', 'b');
+ Assert.areEqual(lastCategory, undefined, 'Failed to filter out a debug level when the logInclude level was higher.');
+
+ lastCategory = undefined;
+ Y.log('This has a valid log level', 'warn', 'b');
+ Assert.areEqual(lastCategory, undefined, 'Failed to filter out a debug level when the logInclude level was higher.');
+
+ lastCategory = undefined;
+ Y.log('This has a valid log level', 'error', 'b');
+ Assert.areEqual(lastCategory, undefined, 'Failed to filter out a debug level when the logInclude level was higher.');
+ });
+
+ // Test false boolean state for logIncludes
+ YUI().use(function (Y) {
+ Y.applyConfig({
+ logLevel: 'error',
+ logInclude: {
+ a: false
+ }
+ });
+
+ // Anything with a source of 'a' should log if it's at 'info' or above:
+ lastCategory = undefined;
+ Y.log('This has a valid log level', 'debug', 'a');
+ Assert.areEqual(lastCategory, undefined, 'Failed to filter out a debug level when the logInclude level was false.');
+
+ lastCategory = undefined;
+ Y.log('This has a valid log level', 'info', 'a');
+ Assert.areEqual(lastCategory, undefined, 'Failed to filter out a debug info when the logInclude level was false.');
+
+ lastCategory = undefined;
+ Y.log('This has a valid log level', 'warn', 'a');
+ Assert.areEqual(lastCategory, undefined, 'Failed to filter out a debug warn when the logInclude level was false.');
+
+ lastCategory = undefined;
+ Y.log('This has a valid log level', 'error', 'a');
+ Assert.areEqual(lastCategory, undefined, 'Failed to filter out a debug error when the logInclude level was false.');
+ });
+ },
+
+ 'logInclude: glob override': function() {
+ var Assert = Y.Assert;
+
+ // Test the default log category override.
+ YUI().use(function (Y) {
+ Y.applyConfig({
+ logLevel: 'error',
+ logInclude: {
+ '*': 'debug'
+ }
+ });
+
+ // Debug is the default level defined in logIncludes and will override the default logLevel:
+ lastCategory = undefined;
+ Y.log('This has a valid log level', 'debug');
+ Assert.areEqual(lastCategory, 'debug', 'Failed to log at \'debug\' log category');
+ });
+ },
+
+ 'logInclude: minLevel override - matching': function() {
+ var Assert = Y.Assert;
+
+ // Test overrides for a specific source:
+ YUI().use(function (Y) {
+ Y.applyConfig({
+ logLevel: 'error',
+ logInclude: {
+ a: 'info'
+ }
+ });
+
+ // Anything with a source of 'a' should log if it's at 'info' or above:
+ lastCategory = undefined;
+ Y.log('Some message', 'debug', 'a');
+ Assert.isUndefined(lastCategory, 'Failed to filter out \'debug\' log message.');
+
+ lastCategory = undefined;
+ Y.log('Some message', 'info', 'a');
+ Assert.areEqual(lastCategory, 'info', 'Failed to log at \'info\' log category');
+
+ lastCategory = undefined;
+ Y.log('Some message', 'warn', 'a');
+ Assert.areEqual(lastCategory, 'warn', 'Failed to log at \'warn\' log category');
+
+ lastCategory = undefined;
+ Y.log('Some message', 'error', 'a');
+ Assert.areEqual(lastCategory, 'error', 'Failed to log at \'error\' log category');
+ });
+ },
+
+ 'logInclude: minLevel override - not matching': function() {
+ var Assert = Y.Assert;
+
+ // Test not overriding for a specific source:
+ YUI().use(function (Y) {
+ Y.applyConfig({
+ logLevel: 'error',
+ logInclude: {
+ a: 'debug'
+ }
+ });
+
+ // Anything with a source of 'a' should log if it's at 'info' or above:
+ lastCategory = undefined;
+ Y.log('Some message', 'debug', 'b');
+ Assert.isUndefined(lastCategory, 'Failed to filter out \'debug\' log message.');
+
+ lastCategory = undefined;
+ Y.log('Some message', 'info', 'b');
+ Assert.isUndefined(lastCategory, 'Failed to filter out \'info\' log message.');
+
+ lastCategory = undefined;
+ Y.log('Some message', 'warn', 'b');
+ Assert.isUndefined(lastCategory, 'Failed to filter out \'warn\' log message.');
+
+ lastCategory = undefined;
+ Y.log('Some message', 'error', 'b');
+ Assert.isUndefined(lastCategory, 'Failed to filter out \'error\' log message.');
+ });
+
+ },
+
+ 'logInclude: truthful boolean - matching': function() {
+ var Assert = Y.Assert;
+
+ // Test true boolean state for logIncludes
+ YUI().use(function (Y) {
+ Y.applyConfig({
+ logLevel: 'error',
+ logInclude: {
+ a: true
+ }
+ });
+
+ // Anything with a source of 'a' should log if it's at 'info' or above:
+ lastCategory = undefined;
+ Y.log('Some message', 'debug', 'a');
+ Assert.isUndefined(lastCategory, "Failed to filter out 'debug' log message.");
+
+ lastCategory = undefined;
+ Y.log('Some message', 'info', 'a');
+ Assert.isUndefined(lastCategory, "Failed to filter out 'info' log message.");
+
+ lastCategory = undefined;
+ Y.log('Some message', 'warn', 'a');
+ Assert.isUndefined(lastCategory, "Failed to filter out 'warn' log message.");
+
+ lastCategory = undefined;
+ Y.log('Some message', 'error', 'a');
+ Assert.areEqual('error', lastCategory, "Failed to log at 'error' log message.");
+
+ });
+ },
+
+ 'logInclude: truthful boolean - mismatching': function() {
+ var Assert = Y.Assert;
+ YUI().use(function (Y) {
+ Y.applyConfig({
+ logLevel: 'error',
+ logInclude: {
+ a: true
+ }
+ });
+
+ // Anything with a source of 'b' should not log if it's at 'info' or below:
+ lastCategory = undefined;
+ Y.log('Some message', 'debug', 'b');
+ Assert.isUndefined(lastCategory, "Failed to filter out 'debug' log message.");
+
+ lastCategory = undefined;
+ Y.log('Some message', 'info', 'b');
+ Assert.isUndefined(lastCategory, "Failed to filter out 'info' log message.");
+
+ lastCategory = undefined;
+ Y.log('Some message', 'warn', 'b');
+ Assert.isUndefined(lastCategory, "Failed to filter out 'warn' log message.");
+
+ lastCategory = undefined;
+ Y.log('Some message', 'error', 'b');
+ Assert.isUndefined(lastCategory, "Failed to filter out 'error' log message.");
+ });
+ },
+
+ 'logInclude: falsey boolean': function() {
+ var Assert = Y.Assert;
+
+ // Test false boolean state for logIncludes
+ YUI().use(function (Y) {
+ Y.applyConfig({
+ logLevel: 'error',
+ logInclude: {
+ a: false
+ }
+ });
+
+ // Anything with a source of 'a' should log if it's at 'info' or above:
+ lastCategory = undefined;
+ Y.log('Some message', 'debug', 'a');
+ Assert.isUndefined(lastCategory, "Failed to filter out 'debug' log message.");
+
+ lastCategory = undefined;
+ Y.log('Some message', 'info', 'a');
+ Assert.isUndefined(lastCategory, "Failed to filter out 'info' log message.");
+
+ lastCategory = undefined;
+ Y.log('Some message', 'warn', 'a');
+ Assert.isUndefined(lastCategory, "Failed to filter out 'warn' log message.");
+
+ lastCategory = undefined;
+ Y.log('Some message', 'error', 'a');
+ Assert.isUndefined(lastCategory, "Failed to filter out 'error' log message.");
+ });
+ },
+
+ 'logExclude: glob override': function() {
+ var Assert = Y.Assert;
+
+ // Test the default log category override.
+ YUI().use(function (Y) {
+ Y.applyConfig({
+ logLevel: 'error',
+ logExclude: {
+ '*': true
+ }
+ });
+
+ // Debug is the default level defined in logExcludes and will override the default logLevel:
+ lastCategory = undefined;
+ Y.log('Some message', 'debug');
+ Assert.isUndefined(lastCategory, "Failed to filter out 'debug' log message.");
+
+ lastCategory = undefined;
+ Y.log('Some message', 'info');
+ Assert.isUndefined(lastCategory, "Failed to filter out 'info' log message.");
+
+ lastCategory = undefined;
+ Y.log('Some message', 'warn');
+ Assert.isUndefined(lastCategory, "Failed to filter out 'warn' log message.");
+
+ lastCategory = undefined;
+ Y.log('Some message', 'error');
+ Assert.isUndefined(lastCategory, "Failed to filter out 'error' log message.");
+ });
+ },
+
+ 'logExclude: overridden glob': function() {
+ var Assert = Y.Assert;
+
+ // Test true boolean state for logExcludes
+ YUI().use(function (Y) {
+ Y.applyConfig({
+ logLevel: 'error',
+ logExclude: {
+ '*': true,
+ a: false
+ }
+ });
+
+ // Anything matching 'a' should log when at error, or above.
+ lastCategory = undefined;
+ Y.log('Some message', 'debug', 'a');
+ Assert.isUndefined(lastCategory, "Failed to filter out 'debug' log message.");
+
+ lastCategory = undefined;
+ Y.log('Some message', 'info', 'a');
+ Assert.isUndefined(lastCategory, "Failed to filter out 'info' log message.");
+
+ lastCategory = undefined;
+ Y.log('Some message', 'warn', 'a');
+ Assert.isUndefined(lastCategory, "Failed to filter out 'warn' log message.");
+
+ lastCategory = undefined;
+ Y.log('Some message', 'error', 'a');
+ Assert.areEqual('error', lastCategory, "Failed to log 'error' log message at a non-excluded category");
+
+
+ lastCategory = undefined;
+ Y.log('Some message', 'debug', 'b');
+ Assert.isUndefined(lastCategory, "Failed to filter out 'debug' log message.");
+
+ lastCategory = undefined;
+ Y.log('Some message', 'info', 'b');
+ Assert.isUndefined(lastCategory, "Failed to filter out 'info' log message.");
+
+ lastCategory = undefined;
+ Y.log('Some message', 'warn', 'b');
+ Assert.isUndefined(lastCategory, "Failed to filter out 'warn' log message.");
+
+ lastCategory = undefined;
+ Y.log('Some message', 'error', 'b');
+ Assert.isUndefined(lastCategory, "Failed to filter out 'error' log message.");
+ });
+ }
+ });
+
+ Y.SeedTests.add(testLogging);
+});
diff --git a/src/yui/tests/unit/index-full.html b/src/yui/tests/unit/index-full.html
index e1614172907..73689ae24d9 100644
--- a/src/yui/tests/unit/index-full.html
+++ b/src/yui/tests/unit/index-full.html
@@ -46,6 +46,11 @@
requires: ['classnamemanager', 'node']
},
+ 'logging-test': {
+ fullpath: './assets/logging-test.js',
+ requires: [ 'test' ]
+ },
+
'config-test': {
fullpath: './assets/config-test.js'
},
@@ -59,7 +64,7 @@
}
}
-}).use('seed-tests', 'core-tests', 'config-test', 'later-test', 'namespace-test', 'test-console', 'test', function(Y) {
+}).use('seed-tests', 'core-tests', 'logging-test', 'test-console', 'test', function(Y) {
new Y.Test.Console().render('#log');
//This is a YUITest hack to rename this test for reporting
diff --git a/src/yui/tests/unit/index-logging.html b/src/yui/tests/unit/index-logging.html
new file mode 100644
index 00000000000..2d6b17b670a
--- /dev/null
+++ b/src/yui/tests/unit/index-logging.html
@@ -0,0 +1,68 @@
+
+
+
+YUI Logging Tests
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/yui/tests/unit/index-static.html b/src/yui/tests/unit/index-static.html
index af290f397d2..e4ebe18ecc2 100644
--- a/src/yui/tests/unit/index-static.html
+++ b/src/yui/tests/unit/index-static.html
@@ -94,9 +94,14 @@
requires: ['classnamemanager', 'node']
},
+ 'logging-test': {
+ fullpath: './assets/logging-test.js',
+ requires: [ 'test' ]
+ },
+
'config-test': {
fullpath: './assets/config-test.js'
- },
+ }
'later-test': {
fullpath: './assets/later-test.js'
@@ -121,7 +126,7 @@
}
}
-}).use('ua-tests', 'seed-tests', 'core-tests', 'config-test', 'later-test', 'namespace-test', 'array-test', 'object-test', 'lang-test', 'test-console', 'test', function(Y) {
+}).use('ua-tests', 'seed-tests', 'core-tests', 'logging-test', 'config-test', 'later-test', 'namespace-test', 'array-test', 'object-test', 'lang-test', 'test-console', 'test', function(Y) {
new Y.Test.Console().render('#log');
Y.Test.Runner.setName(TestName);
Y.Test.Runner.run();
diff --git a/src/yui/tests/unit/index.html b/src/yui/tests/unit/index.html
index 9fb93b4a603..b1b8b94102c 100644
--- a/src/yui/tests/unit/index.html
+++ b/src/yui/tests/unit/index.html
@@ -57,6 +57,11 @@
requires: ['classnamemanager', 'node']
},
+ 'logging-test': {
+ fullpath: './assets/logging-test.js',
+ requires: [ 'test' ]
+ },
+
'config-test': {
fullpath: './assets/config-test.js'
},
@@ -75,7 +80,7 @@
fullpath: './assets/es-modules-test.js'
}
}
-}).use('seed-tests', 'core-tests', 'config-test', 'later-test', 'namespace-test', 'es-modules-test', 'test-console', 'test', function(Y) {
+}).use('seed-tests', 'core-tests', 'logging-test', 'config-test', 'later-test', 'namespace-test', 'es-modules-test', 'test-console', 'test', function(Y) {
new Y.Test.Console().render('#log');
Y.Test.Runner.run();