覆盖 Console.log

Question

Sup guys, big wall of code incoming

function assertObjectsEqual(actual, expected, testName) {
  actual = JSON.stringify(actual);
  expected = JSON.stringify(expected);
  if ( actual === expected ) {
    console.log('PASSED [' + testName + ']');
  } else {
    console.log('FAILED [' + testName + '], expected "' + expected + '", but got "' + actual + '"')
  }
}

/////////////////////////////////
// Tests for "assertObjectsEqual"
/////////////////////////////////

// Note: testing assertion functions is a bit of "Inception"...
// You have to use an assert to test your other assert.
// And since the output is console-logged, you have to trap that too.
// Hence I don't think it's reasonable to expect students to do the negative test on these.
// I think it's sufficient for students to just console log what these assertions do in the failure cases
// and move on...
// But just for illustration, here it is:
function assert(actual, testName) {
  if ( actual !== true ) {
    console.log('FAILED [' + testName + '] Expected "' + expected + '" to be true.');
  } else {
    console.log('PASSED [' + testName + ']');
  }
}

function testFailureCaseAssertObjectsEqual() {
  var objectA = {a: 1};
  var objectB = {b: 2};
  var originalConsoleLog = console.log; // we're going to override console logger to be able to trap messages.

  var trappedMsg;
  console.log = function(msg) {
    trappedMsg = msg; // trap the message via a closure
  }
  assertObjectsEqual(objectA, objectB);

  console.log = originalConsoleLog; // restore the mocked logger before doing our real assertion
  assert(trappedMsg.includes('FAILED'), 'should fail when given two different objects');
}
testFailureCaseAssertObjectsEqual();

So I'm studying to take the Hack Reactor entrance exam and I'm on module 2 right now, which focuses on testing functions. This is a reference solution for applying an assertObjectsEqual testing function. What I'm confused about is in the testFailureCaseAssertObjectsEqual function lines:

var originalConsoleLog = console.log; // we're going to override console logger to be able to trap messages.

  var trappedMsg;
  console.log = function(msg) {
    trappedMsg = msg; // trap the message via a closure
  }
  assertObjectsEqual(objectA, objectB);

  console.log = originalConsoleLog;

I don't really understand what's happening here. What does overriding the console logger to trap messages mean and why do we do it? Also how does the code above accomplish that? Sorry if my post contains a lot of unnecessary info, idk what is and isn't directly relevant to my question so I included all of it. Thank you for taking the time.

Answer 1

They are wanting to intercept the first argument of console.log temporarily for this one use case and not have it printed to console

This is accomplished by storing a reference to original function and assigning a different function to console.log.

Then after they are done - make console.log do what it is normally supposed to do by reassigning the original function to it again

Following simplified demo and comments should help understand process better

 function doLog(msg){ console.log(msg) } function myTest() { // store reference to console.log function var originalConsoleLog = console.log; // temporarily make console.log do something different than logging to console // by assigning new function to it console.log = function(msg) { alert('Intercepted: ' + msg) } // anywhere in here if console.log gets used it will do above alert doLog('First message');/* log gets called inside this function so will alert instead*/ console.log('Second message');/* will also alert and not print in console */ // override finished, return it to do what it normally does // by reassigning it's own original function console.log = originalConsoleLog; // use console.log again and it will do what it normally does doLog('Third message should appear normally in console') } myTest(); // proceed as if nothing was ever different doLog('Forth message - back to normal')