Sinon 9.1

lib/referee-sinon.js

@@ -336,6 +336,19 @@ referee.add("calledWithMatch", {
     values: spyAndCalls
 });
 
+referee.add("calledOnceWithMatch", {
+    assert: function(spy) {
+        verifyFakes.call(this, spy);
+        return spy.calledOnceWithMatch.apply(spy, slice(arguments, 1));
+    },
+    assertMessage:
+        "Expected ${spyObj} to be called once with matching arguments ${expected}${actual}",
+    refuteMessage:
+        "Expected ${spyObj} not to be called once with matching arguments ${expected}${actual}",
+    expectation: "toHaveBeenCalledOnceWithMatch",
+    values: spyAndCalls
+});
+
 referee.add("alwaysCalledWithMatch", {
     assert: function(spy) {
         verifyFakes.call(this, spy);

lib/referee-sinon.test.js

@@ -240,6 +240,76 @@ describe("referee-sinon", function() {
             });
         });
 
+        describe("calledOnceWithMatch", function() {
+            it(
+                "fails when not called with spy",
+                requiresSpy("calledOnceWithMatch")
+            );
+
+            it("passes when spy is passed matching object", function() {
+                var spy = sinon.spy();
+                spy({
+                    check: 123,
+                    color: "#fff"
+                });
+
+                assert.calledOnceWithMatch(spy, { check: 123 });
+            });
+
+            it("fails when spy is passes non-matching object", function() {
+                var spy = sinon.spy();
+                spy({
+                    check: 123,
+                    color: "#fff"
+                });
+
+                refute.calledOnceWithMatch(spy, { check: 321 });
+            });
+
+            it("fails when spy was called more than once", function() {
+                var spy = sinon.spy();
+                spy({
+                    check: 123,
+                    color: "#fff"
+                });
+                spy({
+                    check: 321,
+                    color: "#eee"
+                });
+
+                refute.calledOnceWithMatch(spy, { check: 123 });
+            });
+
+            context(
+                "when called more than once with same arguments",
+                function() {
+                    it("fails", function() {
+                        var spy = sinon.spy();
+                        spy("hello", "Hey");
+                        spy("hello", "Hey");
+
+                        refute.calledOnceWithMatch(spy, "hello", "Hey");
+                    });
+                }
+            );
+
+            it("formats message nicely", function() {
+                var spy = sinon.spy();
+                spy(null, 1, 2);
+
+                try {
+                    assert.calledOnceWithMatch(spy, null, 2, 2);
+                    throw new Error("Exception expected");
+                } catch (e) {
+                    var message =
+                        "[assert.calledOnceWithMatch] Expected " +
+                        "function spy() {} to be called once with matching arguments " +
+                        "null, 2, 2\n    spy(null, 1, 2)";
+                    assert.match(e.message, message);
+                }
+            });
+        });
+
         describe("alwaysCalledWithMatch", function() {
             it(
                 "fails when not called with spy",