From e2897ce619538537ce148552358fc5898b242376 Mon Sep 17 00:00:00 2001
From: Steve Gravrock <sdg@panix.com>
Date: Mon, 14 May 2018 21:18:55 -0700
Subject: [PATCH] Added expect().withContext() to provide additional
 information in failure messages

---
 spec/core/ExpectationSpec.js | 83 ++++++++++++++++++++++++++++++++++++
 src/core/Expectation.js      | 42 ++++++++++++++----
 2 files changed, 116 insertions(+), 9 deletions(-)

diff --git a/spec/core/ExpectationSpec.js b/spec/core/ExpectationSpec.js
index 0b87c875..66e60e7d 100644
--- a/spec/core/ExpectationSpec.js
+++ b/spec/core/ExpectationSpec.js
@@ -488,5 +488,88 @@ describe("Expectation", function() {
       error: customError
     });
   });
+
+  describe("#withContext", function() {
+    it("prepends the context to the generated failure message", function() {
+      var matchers = {
+          toFoo: function() {
+            return {
+              compare: function() { return { pass: false }; }
+            };
+          }
+        },
+        util = {
+          buildFailureMessage: function() { return "failure message"; }
+        },
+        addExpectationResult = jasmine.createSpy("addExpectationResult"),
+        expectation = jasmineUnderTest.Expectation.Factory({
+          customMatchers: matchers,
+          util: util,
+          actual: "an actual",
+          addExpectationResult: addExpectationResult
+        });
+  
+      expectation.withContext("Some context").toFoo("hello");
+  
+      expect(addExpectationResult).toHaveBeenCalledWith(false,
+        jasmine.objectContaining({
+          message: "Some context: failure message"
+        })
+      );
+    });
+
+    it("prepends the context to a custom failure message", function() {
+      var matchers = {
+          toFoo: function() {
+            return {
+              compare: function() { return { pass: false, message: "msg" }; }
+            };
+          }
+        },
+        addExpectationResult = jasmine.createSpy("addExpectationResult"),
+        expectation = jasmineUnderTest.Expectation.Factory({
+          customMatchers: matchers,
+          actual: "an actual",
+          addExpectationResult: addExpectationResult
+        });
+  
+      expectation.withContext("Some context").toFoo("hello");
+  
+      expect(addExpectationResult).toHaveBeenCalledWith(false,
+        jasmine.objectContaining({
+          message: "Some context: msg"
+        })
+      );
+    });
+
+    it("prepends the context to a custom failure message from a function", function() {
+      var matchers = {
+          toFoo: function() {
+            return {
+              compare: function() {
+                return {
+                  pass: false,
+                  message: function() { return "msg"; }
+                };
+              }
+            };
+          }
+        },
+        addExpectationResult = jasmine.createSpy("addExpectationResult"),
+        expectation = jasmineUnderTest.Expectation.Factory({
+          customMatchers: matchers,
+          actual: "an actual",
+          addExpectationResult: addExpectationResult
+        });
+  
+      expectation.withContext("Some context").toFoo("hello");
+  
+      expect(addExpectationResult).toHaveBeenCalledWith(false,
+        jasmine.objectContaining({
+          message: "Some context: msg"
+        })
+      );
+    });
+  });
 });
 
diff --git a/src/core/Expectation.js b/src/core/Expectation.js
index 7527c1ee..c8d09a02 100644
--- a/src/core/Expectation.js
+++ b/src/core/Expectation.js
@@ -62,19 +62,27 @@ getJasmineRequireObj().Expectation = function(j$) {
   };
 
   Expectation.prototype.buildMessage = function(result, name, args) {
+    var util = this.util;
+
     if (result.pass) {
       return '';
     } else if (this.filter && this.filter.buildFailureMessage) {
-      return this.filter.buildFailureMessage(result, name, args, this.util);
-    } else if (!result.message) {
-      args = args.slice();
-      args.unshift(false);
-      args.unshift(name);
-      return this.util.buildFailureMessage.apply(null, args);
-    } else if (j$.isFunction_(result.message)) {
-      return result.message();
+      return this.filter.buildFailureMessage(result, name, args, util, defaultMessage);
     } else {
-      return result.message;
+      return defaultMessage();
+    }
+
+    function defaultMessage() {
+      if (!result.message) {
+        args = args.slice();
+        args.unshift(false);
+        args.unshift(name);
+        return util.buildFailureMessage.apply(null, args);
+      } else if (j$.isFunction_(result.message)) {
+        return result.message();
+      } else {
+        return result.message;
+      }
     }
   };
 
@@ -91,9 +99,16 @@ getJasmineRequireObj().Expectation = function(j$) {
     expect.not = Object.create(expect);
     expect.not.filter = negatingFilter;
 
+    expect.withContext = function(message) {
+      var filteredExpect = Object.create(expect);
+      filteredExpect.filter = new ContextAddingFilter(message);
+      return filteredExpect;
+    };
+
     return expect;
   };
 
+
   var negatingFilter = {
     selectComparisonFunc: function(matcher) {
       function defaultNegativeCompare() {
@@ -120,5 +135,14 @@ getJasmineRequireObj().Expectation = function(j$) {
     }
   };
 
+
+  function ContextAddingFilter(message) {
+    this.message = message;
+  }
+
+  ContextAddingFilter.prototype.buildFailureMessage = function(result, matcherName, args, util, getDefaultMessage) {
+    return this.message + ': ' + getDefaultMessage();
+  };
+
   return Expectation;
 };