From 8f7770254220135618911542106b96ca7c6fde39 Mon Sep 17 00:00:00 2001 From: Julien Biezemans Date: Wed, 8 Jun 2011 12:31:22 +0200 Subject: [PATCH] Rename Message to Event --- lib/cucumber.js | 123 +++++---- spec/cucumber/ast/tree_walker_spec.js | 377 +++++++++++++------------- 2 files changed, 256 insertions(+), 244 deletions(-) diff --git a/lib/cucumber.js b/lib/cucumber.js index 266314a0d..5f91a1498 100644 --- a/lib/cucumber.js +++ b/lib/cucumber.js @@ -237,16 +237,17 @@ Cucumber.Ast.TreeWalker = function(features, supportCodeLibrary, listeners) { }, visitFeatures: function visitFeatures(features, callback) { - self.broadcastUserFunction( - Cucumber.Ast.TreeWalker.FEATURES_EVENT, + var event = Cucumber.Ast.TreeWalker.Event(Cucumber.Ast.TreeWalker.FEATURES_EVENT_NAME); + self.broadcastEventAroundUserFunction( + event, function(callback) { features.acceptVisitor(self, callback); }, callback ); }, visitFeature: function visitFeature(feature, callback) { - self.broadcastUserFunction( - Cucumber.Ast.TreeWalker.FEATURE_EVENT, + self.broadcastEventAroundUserFunction( + Cucumber.Ast.TreeWalker.FEATURE_EVENT_NAME, feature, function(callback) { feature.acceptVisitor(self, callback); }, callback @@ -254,8 +255,8 @@ Cucumber.Ast.TreeWalker = function(features, supportCodeLibrary, listeners) { }, visitScenario: function visitScenario(scenario, callback) { - self.broadcastUserFunction( - Cucumber.Ast.TreeWalker.SCENARIO_EVENT, + self.broadcastEventAroundUserFunction( + Cucumber.Ast.TreeWalker.SCENARIO_EVENT_NAME, scenario, function(callback) { scenario.acceptVisitor(self, callback); }, callback @@ -263,8 +264,8 @@ Cucumber.Ast.TreeWalker = function(features, supportCodeLibrary, listeners) { }, visitStep: function visitStep(step, callback) { - self.broadcastUserFunction( - Cucumber.Ast.TreeWalker.STEP_EVENT, + self.broadcastEventAroundUserFunction( + Cucumber.Ast.TreeWalker.STEP_EVENT_NAME, step, function(callback) { step.acceptVisitor(self, callback); }, callback @@ -272,23 +273,23 @@ Cucumber.Ast.TreeWalker = function(features, supportCodeLibrary, listeners) { }, visitStepResult: function visitStepResult(stepResult, callback) { - self.broadcastMessage( - Cucumber.Ast.TreeWalker.STEP_RESULT_EVENT, + self.broadcastEvent( + Cucumber.Ast.TreeWalker.STEP_RESULT_EVENT_NAME, stepResult, callback ); }, - // broadcastUserFunction(event[, param1[, param2[, ...]]], userFunction, callback) - // message = event + payload (payload is all parameters) - broadcastUserFunction: function broadcastUserFunction() { - var message = self.extractMessageFromArguments(arguments); + // broadcastEventAroundUserFunction(event[, param1[, param2[, ...]]], userFunction, callback) + // event = event + payload (payload is all parameters) + broadcastEventAroundUserFunction: function broadcastEventAroundUserFunction() { + var event = self.extractEventFromArguments(arguments); var userFunction = self.extractUserFunctionFromArguments(arguments); var callback = self.extractCallbackFromArguments(arguments); - var callUserFunction = self.wrapUserFunctionAndAfterMessageBroadcast(userFunction, message, callback); - self.broadcastBeforeMessage(message, callUserFunction); + var callUserFunction = self.wrapUserFunctionAndAfterEventBroadcast(userFunction, event, callback); + self.broadcastBeforeEvent(event, callUserFunction); - // var message = arguments[0]; + // var event = arguments[0]; // var parameters = []; // if (arguments.length > 3) { // for(var i = 1; i < arguments.length - 2; i++) { @@ -297,72 +298,72 @@ Cucumber.Ast.TreeWalker = function(features, supportCodeLibrary, listeners) { // }; // var userFunction = arguments[arguments.length - 2]; // var callback = arguments[arguments.length - 1]; - // var beforeMessage = Cucumber.Ast.TreeWalker.BEFORE_MESSAGE_PREFIX + message; - // var afterMessage = Cucumber.Ast.TreeWalker.AFTER_MESSAGE_PREFIX + message; - // var afterParameters = [afterMessage].concat(parameters); + // var beforeEvent = Cucumber.Ast.TreeWalker.BEFORE_EVENT_NAME_PREFIX + event; + // var afterEvent = Cucumber.Ast.TreeWalker.AFTER_EVENT_NAME_PREFIX + event; + // var afterParameters = [afterEvent].concat(parameters); // afterParameters.push(callback); - // var beforeParameters = [beforeMessage].concat(parameters); + // var beforeParameters = [beforeEvent].concat(parameters); // beforeParameters.push(userFunctionCaller); // function userFunctionCaller(callback) { - // userFunction(afterMessageBroadcastCaller); + // userFunction(afterEventBroadcastCaller); // } - // function afterMessageBroadcastCaller(callback) { - // self.broadcastMessage.apply(this, afterParameters); + // function afterEventBroadcastCaller(callback) { + // self.broadcastEvent.apply(this, afterParameters); // }; - // self.broadcastMessage.apply(this, beforeParameters); + // self.broadcastEvent.apply(this, beforeParameters); }, - extractMessageFromArguments: function extractMessageFromArguments(argumentsObject) { + extractEventFromArguments: function extractEventFromArguments(argumentsObject) { var argumentsArray = Cucumber.Util.Arguments(argumentsObject); - var message = argumentsArray.slice( - Cucumber.Ast.TreeWalker.NON_MESSAGE_LEADING_PARAMETERS_COUNT, - -Cucumber.Ast.TreeWalker.NON_MESSAGE_TRAILING_PARAMETERS_COUNT + var event = argumentsArray.slice( + Cucumber.Ast.TreeWalker.NON_EVENT_LEADING_PARAMETERS_COUNT, + -Cucumber.Ast.TreeWalker.NON_EVENT_TRAILING_PARAMETERS_COUNT ); - return message; + return event; }, extractUserFunctionFromArguments: function extractUserFunctionFromArguments(argumentsObject) { - var nonMessageArguments = self.extractNonMessageArgumentsFromArguments(argumentsObject); - var userFunction = nonMessageArguments.unshift(); + var nonEventArguments = self.extractNonEventArgumentsFromArguments(argumentsObject); + var userFunction = nonEventArguments.unshift(); return userFunction; }, extractCallbackFromArguments: function extractCallbackFromArguments(argumentsObject) { - var nonMessageArguments = self.extractNonMessageArgumentsFromArguments(argumentsObject); - var callback = nonMessageArguments.pop(); + var nonEventArguments = self.extractNonEventArgumentsFromArguments(argumentsObject); + var callback = nonEventArguments.pop(); return callback; }, - extractNonMessageArgumentsFromArguments: function extractNonMessageArgumentsFromArguments(argumentsObject) { - var argumentsArray = Cucumber.Util.Arguments(argumentsObject); - var nonMessageArguments = argumentsArray.slice(-Cucumber.Ast.TreeWalker.NON_MESSAGE_TRAILING_PARAMETERS_COUNT); - return nonMessageArguments; + extractNonEventArgumentsFromArguments: function extractNonEventArgumentsFromArguments(argumentsObject) { + var argumentsArray = Cucumber.Util.Arguments(argumentsObject); + var nonEventArguments = argumentsArray.slice(-Cucumber.Ast.TreeWalker.NON_EVENT_TRAILING_PARAMETERS_COUNT); + return nonEventArguments; }, - wrapUserFunctionAndAfterMessageBroadcast: function wrapUserFunctionAndAfterMessageBroadcast(userFunction, message, callback) { - var callAfterMessageBroadcast = self.wrapAfterMessageBroadcast(message, callback); - return function callUserFunctionAndBroadcastAfterMessage() { - userFunction(callAfterMessageBroadcast); + wrapUserFunctionAndAfterEventBroadcast: function wrapUserFunctionAndAfterEventBroadcast(userFunction, event, callback) { + var callAfterEventBroadcast = self.wrapAfterEventBroadcast(event, callback); + return function callUserFunctionAndBroadcastAfterEvent() { + userFunction(callAfterEventBroadcast); }; }, - wrapAfterMessageBroadcast: function wrapAfterMessageBroadcast(message, callback) { - return function() { self.broadcastAfterMessage(message, callback); }; + wrapAfterEventBroadcast: function wrapAfterEventBroadcast(event, callback) { + return function() { self.broadcastAfterEvent(event, callback); }; }, - broadcastBeforeMessage: TODO("broadcastBeforeMessage()"), + broadcastBeforeEvent: TODO("broadcastBeforeEvent()"), - broadcastAfterMessage: TODO("broadcastAfterMessage()"), + broadcastAfterEvent: TODO("broadcastAfterEvent()"), - broadcastMessage: function broadcastMessage() { - var message = arguments[0]; + broadcastEvent: function broadcastEvent() { + var event = arguments[0]; var parameters = []; for(var i = 1; i < arguments.length; i++) { parameters.push(arguments[i]); }; listeners.syncForEach(function(listener) { - var hearMethodName = Cucumber.Ast.TreeWalker.HEAR_METHOD_PREFIX + message; + var hearMethodName = Cucumber.Ast.TreeWalker.HEAR_METHOD_PREFIX + event; listener[hearMethodName].apply(this, parameters); }); }, @@ -374,16 +375,20 @@ Cucumber.Ast.TreeWalker = function(features, supportCodeLibrary, listeners) { return self; }; -Cucumber.Ast.TreeWalker.FEATURES_MESSAGE = 'Features'; -Cucumber.Ast.TreeWalker.FEATURE_MESSAGE = 'Feature'; -Cucumber.Ast.TreeWalker.SCENARIO_MESSAGE = 'Scenario'; -Cucumber.Ast.TreeWalker.STEP_MESSAGE = 'Step'; -Cucumber.Ast.TreeWalker.STEP_RESULT_MESSAGE = 'StepResult'; -Cucumber.Ast.TreeWalker.BEFORE_MESSAGE_PREFIX = 'Before'; -Cucumber.Ast.TreeWalker.AFTER_MESSAGE_PREFIX = 'After'; -Cucumber.Ast.TreeWalker.HEAR_METHOD_PREFIX = 'hear'; -Cucumber.Ast.TreeWalker.NON_MESSAGE_LEADING_PARAMETERS_COUNT = 0; -Cucumber.Ast.TreeWalker.NON_MESSAGE_TRAILING_PARAMETERS_COUNT = 2; +Cucumber.Ast.TreeWalker.FEATURES_EVENT_NAME = 'Features'; +Cucumber.Ast.TreeWalker.FEATURE_EVENT_NAME = 'Feature'; +Cucumber.Ast.TreeWalker.SCENARIO_EVENT_NAME = 'Scenario'; +Cucumber.Ast.TreeWalker.STEP_EVENT_NAME = 'Step'; +Cucumber.Ast.TreeWalker.STEP_RESULT_EVENT_NAME = 'StepResult'; +Cucumber.Ast.TreeWalker.BEFORE_EVENT_NAME_PREFIX = 'Before'; +Cucumber.Ast.TreeWalker.AFTER_EVENT_NAME_PREFIX = 'After'; +Cucumber.Ast.TreeWalker.HEAR_METHOD_PREFIX = 'hear'; +Cucumber.Ast.TreeWalker.NON_EVENT_LEADING_PARAMETERS_COUNT = 0; +Cucumber.Ast.TreeWalker.NON_EVENT_TRAILING_PARAMETERS_COUNT = 2; + +Cucumber.Ast.TreeWalker.Event = function(event, payload) { + throw("TODO: Event"); +}; Cucumber.SupportCode = {}; diff --git a/spec/cucumber/ast/tree_walker_spec.js b/spec/cucumber/ast/tree_walker_spec.js index 66d7d1213..9efa0b7f4 100644 --- a/spec/cucumber/ast/tree_walker_spec.js +++ b/spec/cucumber/ast/tree_walker_spec.js @@ -30,21 +30,28 @@ describe("Cucumber.Ast.TreeWalker", function() { }); describe("visitFeatures()", function() { - var callback; + var callback, event; beforeEach(function() { callback = createSpy("Callback"); - spyOn(treeWalker, 'broadcastUserFunction'); + event = createSpy("Event"); + spyOn(treeWalker, 'broadcastEventAroundUserFunction'); + spyOn(Cucumber.Ast.TreeWalker, 'Event').andReturn(event); + }); + + it("creates a new event about the features' visit", function() { + treeWalker.visitFeatures(features, callback); + expect(Cucumber.Ast.TreeWalker.Event).toHaveBeenCalledWith(Cucumber.Ast.TreeWalker.FEATURES_EVENT_NAME); }); it("broadcasts the features' visit", function() { treeWalker.visitFeatures(features, callback); - expect(treeWalker.broadcastUserFunction).toHaveBeenCalled(); - expect(treeWalker.broadcastUserFunction). - toHaveBeenCalledWithValueAsNthParameter(Cucumber.Ast.TreeWalker.FEATURES_EVENT, 1); - expect(treeWalker.broadcastUserFunction). + expect(treeWalker.broadcastEventAroundUserFunction).toHaveBeenCalled(); + expect(treeWalker.broadcastEventAroundUserFunction). + toHaveBeenCalledWithValueAsNthParameter(event, 1); + expect(treeWalker.broadcastEventAroundUserFunction). toHaveBeenCalledWithAFunctionAsNthParameter(2); - expect(treeWalker.broadcastUserFunction). + expect(treeWalker.broadcastEventAroundUserFunction). toHaveBeenCalledWithValueAsNthParameter(callback, 3); }); @@ -54,7 +61,7 @@ describe("Cucumber.Ast.TreeWalker", function() { beforeEach(function() { userFunctionCallback = createSpy("User function callback"); treeWalker.visitFeatures(features, callback); - userFunction = treeWalker.broadcastUserFunction.mostRecentCall.args[1]; + userFunction = treeWalker.broadcastEventAroundUserFunction.mostRecentCall.args[1]; }); @@ -71,19 +78,19 @@ describe("Cucumber.Ast.TreeWalker", function() { beforeEach(function() { feature = createSpyWithStubs("Feature AST element", {acceptVisitor: null}); callback = createSpy("Callback"); - spyOn(treeWalker, 'broadcastUserFunction'); + spyOn(treeWalker, 'broadcastEventAroundUserFunction'); }); it("broadcasts the feature's visit", function() { treeWalker.visitFeature(feature, callback); - expect(treeWalker.broadcastUserFunction).toHaveBeenCalled(); - expect(treeWalker.broadcastUserFunction). - toHaveBeenCalledWithValueAsNthParameter(Cucumber.Ast.TreeWalker.FEATURE_EVENT, 1); - expect(treeWalker.broadcastUserFunction). + expect(treeWalker.broadcastEventAroundUserFunction).toHaveBeenCalled(); + expect(treeWalker.broadcastEventAroundUserFunction). + toHaveBeenCalledWithValueAsNthParameter(Cucumber.Ast.TreeWalker.FEATURE_EVENT_NAME, 1); + expect(treeWalker.broadcastEventAroundUserFunction). toHaveBeenCalledWithValueAsNthParameter(feature, 2); - expect(treeWalker.broadcastUserFunction). + expect(treeWalker.broadcastEventAroundUserFunction). toHaveBeenCalledWithAFunctionAsNthParameter(3); - expect(treeWalker.broadcastUserFunction). + expect(treeWalker.broadcastEventAroundUserFunction). toHaveBeenCalledWithValueAsNthParameter(callback, 4); }); @@ -93,7 +100,7 @@ describe("Cucumber.Ast.TreeWalker", function() { beforeEach(function() { userFunctionCallback = createSpy("User function callback"); treeWalker.visitFeature(feature, callback); - userFunction = treeWalker.broadcastUserFunction.mostRecentCall.args[2]; + userFunction = treeWalker.broadcastEventAroundUserFunction.mostRecentCall.args[2]; }); it("visits the feature, passing it the received callback", function() { @@ -109,19 +116,19 @@ describe("Cucumber.Ast.TreeWalker", function() { beforeEach(function() { scenario = createSpyWithStubs("Scenario AST element", {acceptVisitor: null}); callback = createSpy("Callback"); - spyOn(treeWalker, 'broadcastUserFunction'); + spyOn(treeWalker, 'broadcastEventAroundUserFunction'); }); it("broadcasts the scenario's visit", function() { treeWalker.visitScenario(scenario, callback); - expect(treeWalker.broadcastUserFunction).toHaveBeenCalled(); - expect(treeWalker.broadcastUserFunction). - toHaveBeenCalledWithValueAsNthParameter(Cucumber.Ast.TreeWalker.SCENARIO_EVENT, 1); - expect(treeWalker.broadcastUserFunction). + expect(treeWalker.broadcastEventAroundUserFunction).toHaveBeenCalled(); + expect(treeWalker.broadcastEventAroundUserFunction). + toHaveBeenCalledWithValueAsNthParameter(Cucumber.Ast.TreeWalker.SCENARIO_EVENT_NAME, 1); + expect(treeWalker.broadcastEventAroundUserFunction). toHaveBeenCalledWithValueAsNthParameter(scenario, 2); - expect(treeWalker.broadcastUserFunction). + expect(treeWalker.broadcastEventAroundUserFunction). toHaveBeenCalledWithAFunctionAsNthParameter(3); - expect(treeWalker.broadcastUserFunction). + expect(treeWalker.broadcastEventAroundUserFunction). toHaveBeenCalledWithValueAsNthParameter(callback, 4); }); @@ -131,7 +138,7 @@ describe("Cucumber.Ast.TreeWalker", function() { beforeEach(function() { userFunctionCallback = createSpy("User function callback"); treeWalker.visitScenario(scenario, callback); - userFunction = treeWalker.broadcastUserFunction.mostRecentCall.args[2]; + userFunction = treeWalker.broadcastEventAroundUserFunction.mostRecentCall.args[2]; }); it("visits the scenario, passing it the received callback", function() { @@ -147,19 +154,19 @@ describe("Cucumber.Ast.TreeWalker", function() { beforeEach(function() { step = createSpyWithStubs("Step", {acceptVisitor: null}); callback = createSpy("Callback"); - spyOn(treeWalker, 'broadcastUserFunction'); + spyOn(treeWalker, 'broadcastEventAroundUserFunction'); }); it("broadcasts the step's visit", function() { treeWalker.visitStep(step, callback); - expect(treeWalker.broadcastUserFunction).toHaveBeenCalled(); - expect(treeWalker.broadcastUserFunction). - toHaveBeenCalledWithValueAsNthParameter(Cucumber.Ast.TreeWalker.STEP_EVENT, 1); - expect(treeWalker.broadcastUserFunction). + expect(treeWalker.broadcastEventAroundUserFunction).toHaveBeenCalled(); + expect(treeWalker.broadcastEventAroundUserFunction). + toHaveBeenCalledWithValueAsNthParameter(Cucumber.Ast.TreeWalker.STEP_EVENT_NAME, 1); + expect(treeWalker.broadcastEventAroundUserFunction). toHaveBeenCalledWithValueAsNthParameter(step, 2); - expect(treeWalker.broadcastUserFunction). + expect(treeWalker.broadcastEventAroundUserFunction). toHaveBeenCalledWithAFunctionAsNthParameter(3); - expect(treeWalker.broadcastUserFunction). + expect(treeWalker.broadcastEventAroundUserFunction). toHaveBeenCalledWithValueAsNthParameter(callback, 4); }); @@ -169,7 +176,7 @@ describe("Cucumber.Ast.TreeWalker", function() { beforeEach(function() { userFunctionCallback = createSpy("User function callback"); treeWalker.visitStep(step, callback); - userFunction = treeWalker.broadcastUserFunction.mostRecentCall.args[2]; + userFunction = treeWalker.broadcastEventAroundUserFunction.mostRecentCall.args[2]; }); it("visits the step, passing it the received callback", function() { @@ -185,12 +192,12 @@ describe("Cucumber.Ast.TreeWalker", function() { beforeEach(function() { stepResult = createSpy("Step result"); callback = createSpy("Callback"); - spyOn(treeWalker, 'broadcastMessage'); + spyOn(treeWalker, 'broadcastEvent'); }); it("broadcasts the step result visit and the step result itself", function() { treeWalker.visitStepResult(stepResult, callback); - expect(treeWalker.broadcastMessage).toHaveBeenCalledWith(Cucumber.Ast.TreeWalker.STEP_RESULT_EVENT, stepResult, callback); + expect(treeWalker.broadcastEvent).toHaveBeenCalledWith(Cucumber.Ast.TreeWalker.STEP_RESULT_EVENT_NAME, stepResult, callback); }); it("does not call back by itself", function() { @@ -199,127 +206,127 @@ describe("Cucumber.Ast.TreeWalker", function() { }); }); - describe("broadcastUserFunction()", function() { - var event, userFunction, callback, argumentList; - var message, userFunctionWrapper; + describe("broadcastEventAroundUserFunction()", function() { + var eventName, userFunction, callback, argumentList; + var event, userFunctionWrapper; beforeEach(function() { - event = "SomeEvent"; + eventName = "SomeEvent"; userFunction = createSpy("User function"); callback = createSpy("Main callback"); - message = createSpy("Message"); + event = createSpy("Event"); userFunctionWrapper = createSpy("User function wrapper"); argumentList = [event, userFunction, callback]; - spyOn(treeWalker, 'extractMessageFromArguments').andReturn(message); + spyOn(treeWalker, 'extractEventFromArguments').andReturn(event); spyOn(treeWalker, 'extractUserFunctionFromArguments').andReturn(userFunction); spyOn(treeWalker, 'extractCallbackFromArguments').andReturn(callback); - spyOn(treeWalker, 'wrapUserFunctionAndAfterMessageBroadcast').andReturn(userFunctionWrapper); - spyOn(treeWalker, 'broadcastBeforeMessage'); + spyOn(treeWalker, 'wrapUserFunctionAndAfterEventBroadcast').andReturn(userFunctionWrapper); + spyOn(treeWalker, 'broadcastBeforeEvent'); }); - it("extracts the message from its variable argument list", function() { - treeWalker.broadcastUserFunction(event, userFunction, callback); - expect(treeWalker.extractMessageFromArguments).toHaveBeenCalledWith(argumentList); + it("extracts the event from its variable argument list", function() { + treeWalker.broadcastEventAroundUserFunction(event, userFunction, callback); + expect(treeWalker.extractEventFromArguments).toHaveBeenCalledWith(argumentList); }); it("extracts the user function from its variable argument list", function() { - treeWalker.broadcastUserFunction(event, userFunction, callback); + treeWalker.broadcastEventAroundUserFunction(event, userFunction, callback); expect(treeWalker.extractUserFunctionFromArguments).toHaveBeenCalledWith(argumentList); }); it("extracts the callback from its variable argument list", function() { - treeWalker.broadcastUserFunction(event, userFunction, callback); + treeWalker.broadcastEventAroundUserFunction(event, userFunction, callback); expect(treeWalker.extractCallbackFromArguments).toHaveBeenCalledWith(argumentList); }); - it("wraps the user function and after message broadcast together", function() { - treeWalker.broadcastUserFunction(event, userFunction, callback); - expect(treeWalker.wrapUserFunctionAndAfterMessageBroadcast).toHaveBeenCalledWith(userFunction, message, callback); + it("wraps the user function and after event broadcast together", function() { + treeWalker.broadcastEventAroundUserFunction(event, userFunction, callback); + expect(treeWalker.wrapUserFunctionAndAfterEventBroadcast).toHaveBeenCalledWith(userFunction, event, callback); }); - it("broadcasts a before message with the user function and after message broadcast wrapper as callback", function() { - treeWalker.broadcastUserFunction(event, userFunction, callback); - expect(treeWalker.broadcastBeforeMessage).toHaveBeenCalledWith(message, userFunctionWrapper); + it("broadcasts a before event with the user function and after event broadcast wrapper as callback", function() { + treeWalker.broadcastEventAroundUserFunction(event, userFunction, callback); + expect(treeWalker.broadcastBeforeEvent).toHaveBeenCalledWith(event, userFunctionWrapper); }); }); - describe("extractMessageFromArguments()", function() { - var argumentsObject, argumentsArray, message; + describe("extractEventFromArguments()", function() { + var argumentsObject, argumentsArray, event; beforeEach(function() { - message = createSpy("Message"); + event = createSpy("Event"); argumentsObject = createSpy("Arguments object"); - argumentsArray = createSpyWithStubs("Cucumber util arguments array", {slice: message}); + argumentsArray = createSpyWithStubs("Cucumber util arguments array", {slice: event}); spyOn(Cucumber.Util, 'Arguments').andReturn(argumentsArray); }); it("transforms the arguments object into an array", function() { - treeWalker.extractMessageFromArguments(argumentsObject); + treeWalker.extractEventFromArguments(argumentsObject); expect(Cucumber.Util.Arguments).toHaveBeenCalledWith(argumentsObject); }); - it("slices the non-message arguments off", function() { - treeWalker.extractMessageFromArguments(argumentsObject); + it("slices the non-event arguments off", function() { + treeWalker.extractEventFromArguments(argumentsObject); expect(argumentsArray.slice).toHaveBeenCalledWith( - Cucumber.Ast.TreeWalker.NON_MESSAGE_LEADING_PARAMETERS_COUNT, - -Cucumber.Ast.TreeWalker.NON_MESSAGE_TRAILING_PARAMETERS_COUNT + Cucumber.Ast.TreeWalker.NON_EVENT_LEADING_PARAMETERS_COUNT, + -Cucumber.Ast.TreeWalker.NON_EVENT_TRAILING_PARAMETERS_COUNT ); }); it("returns the array slice", function() { - expect(treeWalker.extractMessageFromArguments(argumentsObject)). - toBe(message); + expect(treeWalker.extractEventFromArguments(argumentsObject)). + toBe(event); }); }); - describe("extractNonMessageArgumentsFromArguments()", function() { - var argumentsObject, argumentsArray, nonMessageArguments; + describe("extractNonEventArgumentsFromArguments()", function() { + var argumentsObject, argumentsArray, nonEventArguments; beforeEach(function() { - nonMessageArguments = createSpy("Non message arguments"); + nonEventArguments = createSpy("Non event arguments"); argumentsObject = createSpy("Arguments object"); argumentsArray = createSpyWithStubs("Cucumber util arguments array", - {slice: nonMessageArguments}); + {slice: nonEventArguments}); spyOn(Cucumber.Util, 'Arguments').andReturn(argumentsArray); }); it("transforms the arguments object into an array", function() { - treeWalker.extractNonMessageArgumentsFromArguments(argumentsObject); + treeWalker.extractNonEventArgumentsFromArguments(argumentsObject); expect(Cucumber.Util.Arguments).toHaveBeenCalledWith(argumentsObject); }); - it("slices the message parameters off", function() { - treeWalker.extractNonMessageArgumentsFromArguments(argumentsObject); + it("slices the event parameters off", function() { + treeWalker.extractNonEventArgumentsFromArguments(argumentsObject); expect(argumentsArray.slice).toHaveBeenCalledWith( - -Cucumber.Ast.TreeWalker.NON_MESSAGE_TRAILING_PARAMETERS_COUNT + -Cucumber.Ast.TreeWalker.NON_EVENT_TRAILING_PARAMETERS_COUNT ); }); it("returns the array slice", function() { - var returned = treeWalker.extractNonMessageArgumentsFromArguments(argumentsObject); - expect(returned).toBe(nonMessageArguments); + var returned = treeWalker.extractNonEventArgumentsFromArguments(argumentsObject); + expect(returned).toBe(nonEventArguments); }); }); describe("extractUserFunctionFromArguments()", function() { - var argumentsObject, userFunction, nonMessageArguments; + var argumentsObject, userFunction, nonEventArguments; beforeEach(function() { - userFunction = createSpy("User function"); - argumentsObject = createSpy("Arguments object"); - nonMessageArguments = createSpyWithStubs("Non message arguments", {unshift: userFunction}); - spyOn(treeWalker, 'extractNonMessageArgumentsFromArguments'). - andReturn(nonMessageArguments); + userFunction = createSpy("User function"); + argumentsObject = createSpy("Arguments object"); + nonEventArguments = createSpyWithStubs("Non event arguments", {unshift: userFunction}); + spyOn(treeWalker, 'extractNonEventArgumentsFromArguments'). + andReturn(nonEventArguments); }); - it("extracts the non-message arguments from the arguments object", function() { + it("extracts the non-event arguments from the arguments object", function() { treeWalker.extractUserFunctionFromArguments(argumentsObject); - expect(treeWalker.extractNonMessageArgumentsFromArguments).toHaveBeenCalledWith(argumentsObject); + expect(treeWalker.extractNonEventArgumentsFromArguments).toHaveBeenCalledWith(argumentsObject); }); - it("shifts the first argument from the non-message arguments", function() { + it("shifts the first argument from the non-event arguments", function() { treeWalker.extractUserFunctionFromArguments(argumentsObject); - expect(nonMessageArguments.unshift).toHaveBeenCalled(); + expect(nonEventArguments.unshift).toHaveBeenCalled(); }); it("returns the unshifted argument", function() { @@ -329,24 +336,24 @@ describe("Cucumber.Ast.TreeWalker", function() { }); describe("extractCallbackFromArguments()", function() { - var argumentsObject, callback, nonMessageArguments; + var argumentsObject, callback, nonEventArguments; beforeEach(function() { - callback = createSpy("User function"); - argumentsObject = createSpy("Arguments object"); - nonMessageArguments = createSpyWithStubs("Non message arguments", {pop: callback}); - spyOn(treeWalker, 'extractNonMessageArgumentsFromArguments'). - andReturn(nonMessageArguments); + callback = createSpy("User function"); + argumentsObject = createSpy("Arguments object"); + nonEventArguments = createSpyWithStubs("Non event arguments", {pop: callback}); + spyOn(treeWalker, 'extractNonEventArgumentsFromArguments'). + andReturn(nonEventArguments); }); - it("extracts the non-message arguments from the arguments object", function() { + it("extracts the non-event arguments from the arguments object", function() { treeWalker.extractCallbackFromArguments(argumentsObject); - expect(treeWalker.extractNonMessageArgumentsFromArguments).toHaveBeenCalledWith(argumentsObject); + expect(treeWalker.extractNonEventArgumentsFromArguments).toHaveBeenCalledWith(argumentsObject); }); - it("pops the last argument out of the non-message arguments", function() { + it("pops the last argument out of the non-event arguments", function() { treeWalker.extractCallbackFromArguments(argumentsObject); - expect(nonMessageArguments.pop).toHaveBeenCalled(); + expect(nonEventArguments.pop).toHaveBeenCalled(); }); it("returns the unshifted argument", function() { @@ -355,25 +362,25 @@ describe("Cucumber.Ast.TreeWalker", function() { }); }); - describe("wrapUserFunctionAndAfterMessageBroadcast()", function() { - var userFunction, message, callback; - var broadcastAfterMessageWrapper; + describe("wrapUserFunctionAndAfterEventBroadcast()", function() { + var userFunction, event, callback; + var broadcastAfterEventWrapper; beforeEach(function() { - userFunction = createSpy("User function"); - message = createSpy("Message"); - callback = createSpy("Callback"); - broadcastAfterMessageWrapper = createSpy("After message broadcast wrapper"); - spyOn(treeWalker, 'wrapAfterMessageBroadcast').andReturn(broadcastAfterMessageWrapper); + userFunction = createSpy("User function"); + event = createSpy("Event"); + callback = createSpy("Callback"); + broadcastAfterEventWrapper = createSpy("After event broadcast wrapper"); + spyOn(treeWalker, 'wrapAfterEventBroadcast').andReturn(broadcastAfterEventWrapper); }); - it("wraps the after message broadcast to use as a callback", function() { - treeWalker.wrapUserFunctionAndAfterMessageBroadcast(userFunction, message, callback); - expect(treeWalker.wrapAfterMessageBroadcast).toHaveBeenCalledWith(message, callback); + it("wraps the after event broadcast to use as a callback", function() { + treeWalker.wrapUserFunctionAndAfterEventBroadcast(userFunction, event, callback); + expect(treeWalker.wrapAfterEventBroadcast).toHaveBeenCalledWith(event, callback); }); it("returns a wrapper function", function() { - var returned = treeWalker.wrapUserFunctionAndAfterMessageBroadcast(userFunction, message, callback); + var returned = treeWalker.wrapUserFunctionAndAfterEventBroadcast(userFunction, event, callback); expect(returned).toBeAFunction(); }); @@ -381,26 +388,26 @@ describe("Cucumber.Ast.TreeWalker", function() { var wrapper; beforeEach(function() { - wrapper = treeWalker.wrapUserFunctionAndAfterMessageBroadcast(userFunction, message, callback); + wrapper = treeWalker.wrapUserFunctionAndAfterEventBroadcast(userFunction, event, callback); }); - it("calls the user function with the after message broadcast wrapper", function() { + it("calls the user function with the after event broadcast wrapper", function() { wrapper(); - expect(userFunction).toHaveBeenCalledWith(broadcastAfterMessageWrapper); + expect(userFunction).toHaveBeenCalledWith(broadcastAfterEventWrapper); }); }); }); - describe("wrapAfterMessageBroadcast()", function() { - var message, callback; + describe("wrapAfterEventBroadcast()", function() { + var event, callback; beforeEach(function() { - message = createSpy("Message"); + event = createSpy("Event"); callback = createSpy("Callback"); }); it("returns a function", function() { - var returned = treeWalker.wrapAfterMessageBroadcast(message, callback); + var returned = treeWalker.wrapAfterEventBroadcast(event, callback); expect(returned).toBeAFunction(); }); @@ -408,105 +415,105 @@ describe("Cucumber.Ast.TreeWalker", function() { var wrapper; beforeEach(function() { - wrapper = treeWalker.wrapAfterMessageBroadcast(message, callback); - spyOn(treeWalker, 'broadcastAfterMessage');; + wrapper = treeWalker.wrapAfterEventBroadcast(event, callback); + spyOn(treeWalker, 'broadcastAfterEvent');; }); - it("broadcasts an after message with the received callback as callback", function() { + it("broadcasts an after event with the received callback as callback", function() { wrapper(); - expect(treeWalker.broadcastAfterMessage).toHaveBeenCalledWith(message, callback); + expect(treeWalker.broadcastAfterEvent).toHaveBeenCalledWith(event, callback); }); }); }); /* - describe("broadcastUserFunction()", function() { - var message, userFunction, callback; - var beforeMessage, afterMessage; - var beforeMessageBroadcasted, afterMessageBrodcasted; + describe("broadcastEventAroundUserFunction()", function() { + var event, userFunction, callback; + var beforeEvent, afterEvent; + var beforeEventBroadcasted, afterEventBrodcasted; beforeEach(function() { - message = "EventMessage"; + event = "EventEvent"; userFunction = createSpy("User function"); callback = createSpy("Callback"); - beforeMessage = Cucumber.Ast.TreeWalker.BEFORE_MESSAGE_PREFIX + message; - afterMessage = Cucumber.Ast.TreeWalker.AFTER_MESSAGE_PREFIX + message; - beforeMessageBroadcasted = false; - afterMessageBroadcasted = false; - spyOn(treeWalker, 'broadcastMessage').andCallFake(function(message) { - if (message == beforeMessage) - beforeMessageBroadcasted = true; - if (message == afterMessage) - afterMessageBroadcasted = true; + beforeEvent = Cucumber.Ast.TreeWalker.BEFORE_EVENT_NAME_PREFIX + event; + afterEvent = Cucumber.Ast.TreeWalker.AFTER_EVENT_NAME_PREFIX + event; + beforeEventBroadcasted = false; + afterEventBroadcasted = false; + spyOn(treeWalker, 'broadcastEvent').andCallFake(function(event) { + if (event == beforeEvent) + beforeEventBroadcasted = true; + if (event == afterEvent) + afterEventBroadcasted = true; }); }); - it("sends a 'before event' message with a caller to the user function as callback", function() { - treeWalker.broadcastUserFunction(message, userFunction, callback); - expect(treeWalker.broadcastMessage).toHaveBeenCalled(); - expect(treeWalker.broadcastMessage). - toHaveBeenCalledWithValueAsNthParameter(beforeMessage, 1); - expect(treeWalker.broadcastMessage). + it("sends a 'before event' event with a caller to the user function as callback", function() { + treeWalker.broadcastEventAroundUserFunction(event, userFunction, callback); + expect(treeWalker.broadcastEvent).toHaveBeenCalled(); + expect(treeWalker.broadcastEvent). + toHaveBeenCalledWithValueAsNthParameter(beforeEvent, 1); + expect(treeWalker.broadcastEvent). toHaveBeenCalledWithAFunctionAsNthParameter(2); }); - it("sends a 'before event' message with additional parameters and the caller to the user function as callback", function() { + it("sends a 'before event' event with additional parameters and the caller to the user function as callback", function() { var parameter1 = createSpy("First additional parameter"); var parameter2 = createSpy("Second additional parameter"); - treeWalker.broadcastUserFunction(message, parameter1, parameter2, userFunction, callback); - expect(treeWalker.broadcastMessage). - toHaveBeenCalledWithValueAsNthParameter(beforeMessage, 1); - expect(treeWalker.broadcastMessage). + treeWalker.broadcastEventAroundUserFunction(event, parameter1, parameter2, userFunction, callback); + expect(treeWalker.broadcastEvent). + toHaveBeenCalledWithValueAsNthParameter(beforeEvent, 1); + expect(treeWalker.broadcastEvent). toHaveBeenCalledWithValueAsNthParameter(parameter1, 2); - expect(treeWalker.broadcastMessage). + expect(treeWalker.broadcastEvent). toHaveBeenCalledWithValueAsNthParameter(parameter2, 3); - expect(treeWalker.broadcastMessage). + expect(treeWalker.broadcastEvent). toHaveBeenCalledWithAFunctionAsNthParameter(4); }); - describe("user function caller (before message broadcast callback)", function() { + describe("user function caller (before event broadcast callback)", function() { var userFunctionCaller, userFunctionCallerCallback; - var afterMessagebroadcastCaller, afterMessagebroadcastCallerCallback; + var afterEventbroadcastCaller, afterEventbroadcastCallerCallback; beforeEach(function() { - treeWalker.broadcastUserFunction(message, userFunction, callback); - userFunctionCaller = treeWalker.broadcastMessage.mostRecentCall.args[1]; + treeWalker.broadcastEventAroundUserFunction(event, userFunction, callback); + userFunctionCaller = treeWalker.broadcastEvent.mostRecentCall.args[1]; userFunctionCallerCallback = createSpy("User function caller callback"); }); - it("calls the user function with a caller to an after message broadcast as callback", function() { + it("calls the user function with a caller to an after event broadcast as callback", function() { userFunctionCaller(userFunctionCallerCallback); expect(userFunction). toHaveBeenCalledWithAFunctionAsNthParameter(1); }); - describe("caller to after message broadcast (user function callback)", function() { + describe("caller to after event broadcast (user function callback)", function() { beforeEach(function() { userFunctionCaller(userFunctionCallerCallback); - afterMessageBroadcastCaller = userFunction.mostRecentCall.args[0]; - afterMessageBroadcastCallerCallback = createSpy("After message broadcast caller callback"); + afterEventBroadcastCaller = userFunction.mostRecentCall.args[0]; + afterEventBroadcastCallerCallback = createSpy("After event broadcast caller callback"); }); - it("sends an 'after' event message with a callback", function() { - afterMessageBroadcastCaller(afterMessageBroadcastCallerCallback); - expect(treeWalker.broadcastMessage).toHaveBeenCalled(); - expect(treeWalker.broadcastMessage). - toHaveBeenCalledWithValueAsNthParameter(afterMessage, 1); - expect(treeWalker.broadcastMessage). + it("sends an 'after' event event with a callback", function() { + afterEventBroadcastCaller(afterEventBroadcastCallerCallback); + expect(treeWalker.broadcastEvent).toHaveBeenCalled(); + expect(treeWalker.broadcastEvent). + toHaveBeenCalledWithValueAsNthParameter(afterEvent, 1); + expect(treeWalker.broadcastEvent). toHaveBeenCalledWithAFunctionAsNthParameter(2); }); - it("sends an 'after event' message with additional parameters and a callback", function() { + it("sends an 'after event' event with additional parameters and a callback", function() { var parameter1 = createSpy("First additional parameter"); var parameter2 = createSpy("Second additional parameter"); - treeWalker.broadcastUserFunction(message, parameter1, parameter2, userFunction, callback); - expect(treeWalker.broadcastMessage). - toHaveBeenCalledWithValueAsNthParameter(beforeMessage, 1); - expect(treeWalker.broadcastMessage). + treeWalker.broadcastEventAroundUserFunction(event, parameter1, parameter2, userFunction, callback); + expect(treeWalker.broadcastEvent). + toHaveBeenCalledWithValueAsNthParameter(beforeEvent, 1); + expect(treeWalker.broadcastEvent). toHaveBeenCalledWithValueAsNthParameter(parameter1, 2); - expect(treeWalker.broadcastMessage). + expect(treeWalker.broadcastEvent). toHaveBeenCalledWithValueAsNthParameter(parameter2, 3); - expect(treeWalker.broadcastMessage). + expect(treeWalker.broadcastEvent). toHaveBeenCalledWithAFunctionAsNthParameter(4); }); @@ -516,15 +523,15 @@ describe("Cucumber.Ast.TreeWalker", function() { /* it("broadcasts an optional parameter in both before and after events", function() { var parameter = createSpy("Additional parameter"); - treeWalker.broadcastUserFunction(message, parameter, userFunction, callback); - var beforeMessageBroadcastCall = treeWalker.broadcastMessage.calls[0]; - expect(beforeMessageBroadcastCall.args[0]).toBe(beforeMessage); - expect(beforeMessageBroadcastCall.args[1]).toBe(parameter); - expect(beforeMessageBroadcastCall.args[2]).toBeAFunction(); - var afterMessageBroadcastCall = treeWalker.broadcastMessage.calls[1]; - expect(afterMessageBroadcastCall.args[0]).toBe(afterMessage); - expect(afterMessageBroadcastCall.args[1]).toBe(parameter); - expect(afterMessageBroadcastCall.args[2]).toBeAFunction(); + treeWalker.broadcastEventAroundUserFunction(event, parameter, userFunction, callback); + var beforeEventBroadcastCall = treeWalker.broadcastEvent.calls[0]; + expect(beforeEventBroadcastCall.args[0]).toBe(beforeEvent); + expect(beforeEventBroadcastCall.args[1]).toBe(parameter); + expect(beforeEventBroadcastCall.args[2]).toBeAFunction(); + var afterEventBroadcastCall = treeWalker.broadcastEvent.calls[1]; + expect(afterEventBroadcastCall.args[0]).toBe(afterEvent); + expect(afterEventBroadcastCall.args[1]).toBe(parameter); + expect(afterEventBroadcastCall.args[2]).toBeAFunction(); }); */ /* @@ -532,26 +539,26 @@ describe("Cucumber.Ast.TreeWalker", function() { var parameter1 = createSpy("Additional parameter 1"); var parameter2 = createSpy("Additional parameter 2"); var parameter3 = createSpy("Additional parameter 3"); - treeWalker.broadcastUserFunction(message, parameter1, parameter2, parameter3, callback); - expect(treeWalker.broadcastMessage).toHaveBeenCalledWith(beforeMessage, parameter1, parameter2, parameter3); - expect(treeWalker.broadcastMessage).toHaveBeenCalledWith(afterMessage, parameter1, parameter2, parameter3); + treeWalker.broadcastEventAroundUserFunction(event, parameter1, parameter2, parameter3, callback); + expect(treeWalker.broadcastEvent).toHaveBeenCalledWith(beforeEvent, parameter1, parameter2, parameter3); + expect(treeWalker.broadcastEvent).toHaveBeenCalledWith(afterEvent, parameter1, parameter2, parameter3); }); }); */ - describe("broadcastMessage()", function() { - var message, hearMethod; + describe("broadcastEvent()", function() { + var eventName, hearMethod; beforeEach(function() { - message = "Message"; - hearMethod = Cucumber.Ast.TreeWalker.HEAR_METHOD_PREFIX + message; + eventName = "Event name"; + hearMethod = Cucumber.Ast.TreeWalker.HEAR_METHOD_PREFIX + eventName; listeners.forEach(function(listener) { spyOnStub(listener, hearMethod); }); }); - it("tells every listener about the message", function() { - treeWalker.broadcastMessage(message); + it("tells every listener about the event", function() { + treeWalker.broadcastEvent(eventName); listeners.forEach(function(listener) { expect(listener[hearMethod]).toHaveBeenCalled(); }); @@ -559,7 +566,7 @@ describe("Cucumber.Ast.TreeWalker", function() { it("passes an optional additional parameter to the listeners", function() { var parameter = createSpy("Additional parameter"); - treeWalker.broadcastMessage(message, parameter); + treeWalker.broadcastEvent(eventName, parameter); listeners.forEach(function(listener) { expect(listener[hearMethod]).toHaveBeenCalledWith(parameter); }); @@ -569,7 +576,7 @@ describe("Cucumber.Ast.TreeWalker", function() { var parameter1 = createSpy("Additional parameter 1"); var parameter2 = createSpy("Additional parameter 2"); var parameter3 = createSpy("Additional parameter 3"); - treeWalker.broadcastMessage(message, parameter1, parameter2, parameter3); + treeWalker.broadcastEvent(eventName, parameter1, parameter2, parameter3); listeners.forEach(function(listener) { expect(listener[hearMethod]).toHaveBeenCalledWith(parameter1, parameter2, parameter3); });