src/chrome/third_party/mock4js/mock4js.js

   1 /**\r
   2  * Mock4JS 0.2\r
   3  * http://mock4js.sourceforge.net/\r
   4  */\r
   5 \r
   6 Mock4JS = {\r
   7         _mocksToVerify: [],\r
   8         _convertToConstraint: function(constraintOrValue) {\r
   9                 if(constraintOrValue.argumentMatches) {\r
  10                         return constraintOrValue; // it's already an ArgumentMatcher\r
  11                 } else {\r
  12                         return new MatchExactly(constraintOrValue);     // default to eq(...)\r
  13                 }\r
  14         },\r
  15         addMockSupport: function(object) {\r
  16                 // mock creation\r
  17                 object.mock = function(mockedType) {\r
  18                         if(!mockedType) {\r
  19                                 throw new Mock4JSException("Cannot create mock: type to mock cannot be found or is null");\r
  20                         }\r
  21                         var newMock = new Mock(mockedType);\r
  22                         Mock4JS._mocksToVerify.push(newMock);\r
  23                         return newMock;\r
  24                 }\r
  25 \r
  26                 // syntactic sugar for expects()\r
  27                 object.once = function() {\r
  28                         return new CallCounter(1);\r
  29                 }\r
  30                 object.never = function() {\r
  31                         return new CallCounter(0);\r
  32                 }\r
  33                 object.exactly = function(expectedCallCount) {\r
  34                         return new CallCounter(expectedCallCount);\r
  35                 }\r
  36                 object.atLeastOnce = function() {\r
  37                         return new InvokeAtLeastOnce();\r
  38                 }\r
  39                 \r
  40                 // syntactic sugar for argument expectations\r
  41                 object.ANYTHING = new MatchAnything();\r
  42                 object.NOT_NULL = new MatchAnythingBut(new MatchExactly(null));\r
  43                 object.NOT_UNDEFINED = new MatchAnythingBut(new MatchExactly(undefined));\r
  44                 object.eq = function(expectedValue) {\r
  45                         return new MatchExactly(expectedValue);\r
  46                 }\r
  47                 object.not = function(valueNotExpected) {\r
  48                         var argConstraint = Mock4JS._convertToConstraint(valueNotExpected);\r
  49                         return new MatchAnythingBut(argConstraint);\r
  50                 }\r
  51                 object.and = function() {\r
  52                         var constraints = [];\r
  53                         for(var i=0; i<arguments.length; i++) {\r
  54                                 constraints[i] = Mock4JS._convertToConstraint(arguments[i]);\r
  55                         }\r
  56                         return new MatchAllOf(constraints);\r
  57                 }\r
  58                 object.or = function() {\r
  59                         var constraints = [];\r
  60                         for(var i=0; i<arguments.length; i++) {\r
  61                                 constraints[i] = Mock4JS._convertToConstraint(arguments[i]);\r
  62                         }\r
  63                         return new MatchAnyOf(constraints);\r
  64                 }\r
  65                 object.stringContains = function(substring) {\r
  66                         return new MatchStringContaining(substring);\r
  67                 }\r
  68                 \r
  69                 // syntactic sugar for will()\r
  70                 object.returnValue = function(value) {\r
  71                         return new ReturnValueAction(value);\r
  72                 }\r
  73                 object.throwException = function(exception) {\r
  74                         return new ThrowExceptionAction(exception);\r
  75                 }\r
  76         },\r
  77         clearMocksToVerify: function() {\r
  78                 Mock4JS._mocksToVerify = [];\r
  79         },\r
  80         verifyAllMocks: function() {\r
  81                 for(var i=0; i<Mock4JS._mocksToVerify.length; i++) {\r
  82                         Mock4JS._mocksToVerify[i].verify();\r
  83                 }\r
  84         }\r
  85 }\r
  86 \r
  87 Mock4JSUtil = {\r
  88         hasFunction: function(obj, methodName) {\r
  89                 return typeof obj == 'object' && typeof obj[methodName] == 'function';\r
  90         },\r
  91         join: function(list) {\r
  92                 var result = "";\r
  93                 for(var i=0; i<list.length; i++) {\r
  94                         var item = list[i];\r
  95                         if(Mock4JSUtil.hasFunction(item, "describe")) {\r
  96                                 result += item.describe();\r
  97                         }\r
  98                         else if(typeof list[i] == 'string') {\r
  99                                 result += "\""+list[i]+"\"";\r
 100                         } else {\r
 101                                 result += list[i];\r
 102                         }\r
 103                         \r
 104                         if(i<list.length-1) result += ", ";\r
 105                 }\r
 106                 return result;\r
 107         }       \r
 108 }\r
 109 \r
 110 Mock4JSException = function(message) {\r
 111         this.message = message;\r
 112 }\r
 113 \r
 114 Mock4JSException.prototype = {\r
 115         toString: function() {\r
 116                 return this.message;\r
 117         }\r
 118 }\r
 119 \r
 120 /**\r
 121  * Assert function that makes use of the constraint methods\r
 122  */ \r
 123 assertThat = function(expected, argumentMatcher) {\r
 124         if(!argumentMatcher.argumentMatches(expected)) {\r
 125                 fail("Expected '"+expected+"' to be "+argumentMatcher.describe());\r
 126         }\r
 127 }\r
 128 \r
 129 /**\r
 130  * CallCounter\r
 131  */\r
 132 function CallCounter(expectedCount) {\r
 133         this._expectedCallCount = expectedCount;\r
 134         this._actualCallCount = 0;\r
 135 }\r
 136 \r
 137 CallCounter.prototype = {\r
 138         addActualCall: function() {\r
 139                 this._actualCallCount++;\r
 140                 if(this._actualCallCount > this._expectedCallCount) {\r
 141                         throw new Mock4JSException("unexpected invocation");\r
 142                 }\r
 143         },\r
 144         \r
 145         verify: function() {\r
 146                 if(this._actualCallCount < this._expectedCallCount) {\r
 147                         throw new Mock4JSException("expected method was not invoked the expected number of times");\r
 148                 }\r
 149         },\r
 150         \r
 151         describe: function() {\r
 152                 if(this._expectedCallCount == 0) {\r
 153                         return "not expected";\r
 154                 } else if(this._expectedCallCount == 1) {\r
 155                         var msg = "expected once";\r
 156                         if(this._actualCallCount >= 1) {\r
 157                                 msg += " and has been invoked";\r
 158                         }\r
 159                         return msg;\r
 160                 } else {\r
 161                         var msg = "expected "+this._expectedCallCount+" times";\r
 162                         if(this._actualCallCount > 0) {\r
 163                                 msg += ", invoked "+this._actualCallCount + " times";\r
 164                         }\r
 165                         return msg;\r
 166                 }\r
 167         }\r
 168 }\r
 169 \r
 170 function InvokeAtLeastOnce() {\r
 171         this._hasBeenInvoked = false;\r
 172 }\r
 173 \r
 174 InvokeAtLeastOnce.prototype = {\r
 175         addActualCall: function() {\r
 176                 this._hasBeenInvoked = true;\r
 177         },\r
 178         \r
 179         verify: function() {\r
 180                 if(this._hasBeenInvoked === false) {\r
 181                         throw new Mock4JSException(describe());\r
 182                 }\r
 183         },\r
 184         \r
 185         describe: function() {\r
 186                 var desc = "expected at least once";\r
 187                 if(this._hasBeenInvoked) desc+=" and has been invoked";\r
 188                 return desc;\r
 189         }\r
 190 }\r
 191 \r
 192 /**\r
 193  * ArgumentMatchers\r
 194  */\r
 195 \r
 196 function MatchExactly(expectedValue) {\r
 197         this._expectedValue = expectedValue;\r
 198 }\r
 199 \r
 200 MatchExactly.prototype = {\r
 201         argumentMatches: function(actualArgument) {\r
 202                 if(this._expectedValue instanceof Array) {\r
 203                         if(!(actualArgument instanceof Array)) return false;\r
 204                         if(this._expectedValue.length != actualArgument.length) return false;\r
 205                         for(var i=0; i<this._expectedValue.length; i++) {\r
 206                                 if(this._expectedValue[i] != actualArgument[i]) return false;\r
 207                         }\r
 208                         return true;\r
 209                 } else {\r
 210                         return this._expectedValue == actualArgument;\r
 211                 }\r
 212         },\r
 213         describe: function() {\r
 214                 if(typeof this._expectedValue == "string") {\r
 215                         return "eq(\""+this._expectedValue+"\")";\r
 216                 } else {\r
 217                         return "eq("+this._expectedValue+")";\r
 218                 }\r
 219         }\r
 220 }\r
 221 \r
 222 function MatchAnything() {\r
 223 }\r
 224 \r
 225 MatchAnything.prototype = {\r
 226         argumentMatches: function(actualArgument) {\r
 227                 return true;\r
 228         },\r
 229         describe: function() {\r
 230                 return "ANYTHING";\r
 231         }\r
 232 }\r
 233 \r
 234 function MatchAnythingBut(matcherToNotMatch) {\r
 235         this._matcherToNotMatch = matcherToNotMatch;\r
 236 }\r
 237 \r
 238 MatchAnythingBut.prototype = {\r
 239         argumentMatches: function(actualArgument) {\r
 240                 return !this._matcherToNotMatch.argumentMatches(actualArgument);\r
 241         },\r
 242         describe: function() {\r
 243                 return "not("+this._matcherToNotMatch.describe()+")";\r
 244         }\r
 245 }\r
 246 \r
 247 function MatchAllOf(constraints) {\r
 248         this._constraints = constraints;\r
 249 }\r
 250 \r
 251 \r
 252 MatchAllOf.prototype = {\r
 253         argumentMatches: function(actualArgument) {\r
 254                 for(var i=0; i<this._constraints.length; i++) {\r
 255                         var constraint = this._constraints[i];\r
 256                         if(!constraint.argumentMatches(actualArgument)) return false;\r
 257                 }\r
 258                 return true;\r
 259         },\r
 260         describe: function() {\r
 261                 return "and("+Mock4JSUtil.join(this._constraints)+")";\r
 262         }\r
 263 }\r
 264 \r
 265 function MatchAnyOf(constraints) {\r
 266         this._constraints = constraints;\r
 267 }\r
 268 \r
 269 MatchAnyOf.prototype = {\r
 270         argumentMatches: function(actualArgument) {\r
 271                 for(var i=0; i<this._constraints.length; i++) {\r
 272                         var constraint = this._constraints[i];\r
 273                         if(constraint.argumentMatches(actualArgument)) return true;\r
 274                 }\r
 275                 return false;\r
 276         },\r
 277         describe: function() {\r
 278                 return "or("+Mock4JSUtil.join(this._constraints)+")";\r
 279         }\r
 280 }\r
 281 \r
 282 \r
 283 function MatchStringContaining(stringToLookFor) {\r
 284         this._stringToLookFor = stringToLookFor;\r
 285 }\r
 286 \r
 287 MatchStringContaining.prototype = {\r
 288         argumentMatches: function(actualArgument) {\r
 289                 if(typeof actualArgument != 'string') throw new Mock4JSException("stringContains() must be given a string, actually got a "+(typeof actualArgument));\r
 290                 return (actualArgument.indexOf(this._stringToLookFor) != -1);\r
 291         },\r
 292         describe: function() {\r
 293                 return "a string containing \""+this._stringToLookFor+"\"";\r
 294         }\r
 295 }\r
 296 \r
 297 \r
 298 /**\r
 299  * StubInvocation\r
 300  */\r
 301 function StubInvocation(expectedMethodName, expectedArgs, actionSequence) {\r
 302         this._expectedMethodName = expectedMethodName;\r
 303         this._expectedArgs = expectedArgs;\r
 304         this._actionSequence = actionSequence;\r
 305 }\r
 306 \r
 307 StubInvocation.prototype = {\r
 308         matches: function(invokedMethodName, invokedMethodArgs) {\r
 309                 if (invokedMethodName != this._expectedMethodName) {\r
 310                         return false;\r
 311                 }\r
 312                 \r
 313                 if (invokedMethodArgs.length != this._expectedArgs.length) {\r
 314                         return false;\r
 315                 }\r
 316                 \r
 317                 for(var i=0; i<invokedMethodArgs.length; i++) {\r
 318                         var expectedArg = this._expectedArgs[i];\r
 319                         var invokedArg = invokedMethodArgs[i];\r
 320                         if(!expectedArg.argumentMatches(invokedArg)) {\r
 321                                 return false;\r
 322                         }\r
 323                 }\r
 324                 \r
 325                 return true;\r
 326         },\r
 327         \r
 328         invoked: function() {\r
 329                 try {\r
 330                         return this._actionSequence.invokeNextAction();\r
 331                 } catch(e) {\r
 332                         if(e instanceof Mock4JSException) {\r
 333                                 throw new Mock4JSException(this.describeInvocationNameAndArgs()+" - "+e.message);\r
 334                         } else {\r
 335                                 throw e;\r
 336                         }\r
 337                 }\r
 338         },\r
 339         \r
 340         will: function() {\r
 341                 this._actionSequence.addAll.apply(this._actionSequence, arguments);\r
 342         },\r
 343         \r
 344         describeInvocationNameAndArgs: function() {\r
 345                 return this._expectedMethodName+"("+Mock4JSUtil.join(this._expectedArgs)+")";\r
 346         },\r
 347         \r
 348         describe: function() {\r
 349                 return "stub: "+this.describeInvocationNameAndArgs();\r
 350         },\r
 351         \r
 352         verify: function() {\r
 353         }\r
 354 }\r
 355 \r
 356 /**\r
 357  * ExpectedInvocation\r
 358  */\r
 359 function ExpectedInvocation(expectedMethodName, expectedArgs, expectedCallCounter) {\r
 360         this._stubInvocation = new StubInvocation(expectedMethodName, expectedArgs, new ActionSequence());\r
 361         this._expectedCallCounter = expectedCallCounter;\r
 362 }\r
 363 \r
 364 ExpectedInvocation.prototype = {\r
 365         matches: function(invokedMethodName, invokedMethodArgs) {\r
 366                 try {\r
 367                         return this._stubInvocation.matches(invokedMethodName, invokedMethodArgs);\r
 368                 } catch(e) {\r
 369                         throw new Mock4JSException("method "+this._stubInvocation.describeInvocationNameAndArgs()+": "+e.message);\r
 370                 }\r
 371         },\r
 372         \r
 373         invoked: function() {\r
 374                 try {\r
 375                         this._expectedCallCounter.addActualCall();\r
 376                 } catch(e) {\r
 377                         throw new Mock4JSException(e.message+": "+this._stubInvocation.describeInvocationNameAndArgs());\r
 378                 }\r
 379                 return this._stubInvocation.invoked();\r
 380         },\r
 381         \r
 382         will: function() {\r
 383                 this._stubInvocation.will.apply(this._stubInvocation, arguments);\r
 384         },\r
 385         \r
 386         describe: function() {\r
 387                 return this._expectedCallCounter.describe()+": "+this._stubInvocation.describeInvocationNameAndArgs();\r
 388         },\r
 389         \r
 390         verify: function() {\r
 391                 try {\r
 392                         this._expectedCallCounter.verify();\r
 393                 } catch(e) {\r
 394                         throw new Mock4JSException(e.message+": "+this._stubInvocation.describeInvocationNameAndArgs());\r
 395                 }\r
 396         }\r
 397 }\r
 398 \r
 399 /**\r
 400  * MethodActions\r
 401  */\r
 402 function ReturnValueAction(valueToReturn) {\r
 403         this._valueToReturn = valueToReturn;\r
 404 }\r
 405 \r
 406 ReturnValueAction.prototype = {\r
 407         invoke: function() {\r
 408                 return this._valueToReturn;\r
 409         },\r
 410         describe: function() {\r
 411                 return "returns "+this._valueToReturn;\r
 412         }\r
 413 }\r
 414 \r
 415 function ThrowExceptionAction(exceptionToThrow) {\r
 416         this._exceptionToThrow = exceptionToThrow;\r
 417 }\r
 418 \r
 419 ThrowExceptionAction.prototype = {\r
 420         invoke: function() {\r
 421                 throw this._exceptionToThrow;\r
 422         },\r
 423         describe: function() {\r
 424                 return "throws "+this._exceptionToThrow;\r
 425         }\r
 426 }\r
 427 \r
 428 function ActionSequence() {\r
 429         this._ACTIONS_NOT_SETUP = "_ACTIONS_NOT_SETUP";\r
 430         this._actionSequence = this._ACTIONS_NOT_SETUP;\r
 431         this._indexOfNextAction = 0;\r
 432 }\r
 433 \r
 434 ActionSequence.prototype = {\r
 435         invokeNextAction: function() {\r
 436                 if(this._actionSequence === this._ACTIONS_NOT_SETUP) {\r
 437                         return;\r
 438                 } else {\r
 439                         if(this._indexOfNextAction >= this._actionSequence.length) {\r
 440                                 throw new Mock4JSException("no more values to return");\r
 441                         } else {\r
 442                                 var action = this._actionSequence[this._indexOfNextAction];\r
 443                                 this._indexOfNextAction++;\r
 444                                 return action.invoke();\r
 445                         }\r
 446                 }\r
 447         },\r
 448         \r
 449         addAll: function() {\r
 450                 this._actionSequence = [];\r
 451                 for(var i=0; i<arguments.length; i++) {\r
 452                         if(typeof arguments[i] != 'object' && arguments[i].invoke === undefined) {\r
 453                                 throw new Error("cannot add a method action that does not have an invoke() method");\r
 454                         }\r
 455                         this._actionSequence.push(arguments[i]);\r
 456                 }\r
 457         }\r
 458 }\r
 459 \r
 460 function StubActionSequence() {\r
 461         this._ACTIONS_NOT_SETUP = "_ACTIONS_NOT_SETUP";\r
 462         this._actionSequence = this._ACTIONS_NOT_SETUP;\r
 463         this._indexOfNextAction = 0;\r
 464 } \r
 465 \r
 466 StubActionSequence.prototype = {\r
 467         invokeNextAction: function() {\r
 468                 if(this._actionSequence === this._ACTIONS_NOT_SETUP) {\r
 469                         return;\r
 470                 } else if(this._actionSequence.length == 1) {\r
 471                         // if there is only one method action, keep doing that on every invocation\r
 472                         return this._actionSequence[0].invoke();\r
 473                 } else {\r
 474                         if(this._indexOfNextAction >= this._actionSequence.length) {\r
 475                                 throw new Mock4JSException("no more values to return");\r
 476                         } else {\r
 477                                 var action = this._actionSequence[this._indexOfNextAction];\r
 478                                 this._indexOfNextAction++;\r
 479                                 return action.invoke();\r
 480                         }\r
 481                 }\r
 482         },\r
 483         \r
 484         addAll: function() {\r
 485                 this._actionSequence = [];\r
 486                 for(var i=0; i<arguments.length; i++) {\r
 487                         if(typeof arguments[i] != 'object' && arguments[i].invoke === undefined) {\r
 488                                 throw new Error("cannot add a method action that does not have an invoke() method");\r
 489                         }\r
 490                         this._actionSequence.push(arguments[i]);\r
 491                 }\r
 492         }\r
 493 }\r
 494 \r
 495  \r
 496 /**\r
 497  * Mock\r
 498  */\r
 499 function Mock(mockedType) {\r
 500         if(mockedType === undefined || mockedType.prototype === undefined) {\r
 501                 throw new Mock4JSException("Unable to create Mock: must create Mock using a class not prototype, eg. 'new Mock(TypeToMock)' or using the convenience method 'mock(TypeToMock)'");\r
 502         }\r
 503         this._mockedType = mockedType.prototype;\r
 504         this._expectedCallCount;\r
 505         this._isRecordingExpectations = false;\r
 506         this._expectedInvocations = [];\r
 507 \r
 508         // setup proxy\r
 509         var IntermediateClass = new Function();\r
 510         IntermediateClass.prototype = mockedType.prototype;\r
 511         var ChildClass = new Function();\r
 512         ChildClass.prototype = new IntermediateClass();\r
 513         this._proxy = new ChildClass();\r
 514         this._proxy.mock = this;\r
 515         \r
 516         for(property in mockedType.prototype) {\r
 517                 if(this._isPublicMethod(mockedType.prototype, property)) {\r
 518                         var publicMethodName = property;\r
 519                         this._proxy[publicMethodName] = this._createMockedMethod(publicMethodName);\r
 520                         this[publicMethodName] = this._createExpectationRecordingMethod(publicMethodName);\r
 521                 }\r
 522         }\r
 523 }\r
 524 \r
 525 Mock.prototype = {\r
 526         \r
 527         proxy: function() {\r
 528                 return this._proxy;\r
 529         },\r
 530         \r
 531         expects: function(expectedCallCount) {\r
 532                 this._expectedCallCount = expectedCallCount;\r
 533                 this._isRecordingExpectations = true;\r
 534                 this._isRecordingStubs = false;\r
 535                 return this;\r
 536         },\r
 537         \r
 538         stubs: function() {\r
 539                 this._isRecordingExpectations = false;\r
 540                 this._isRecordingStubs = true;\r
 541                 return this;\r
 542         },\r
 543         \r
 544         verify: function() {\r
 545                 for(var i=0; i<this._expectedInvocations.length; i++) {\r
 546                         var expectedInvocation = this._expectedInvocations[i];\r
 547                         try {\r
 548                                 expectedInvocation.verify();\r
 549                         } catch(e) {\r
 550                                 var failMsg = e.message+this._describeMockSetup();\r
 551                                 throw new Mock4JSException(failMsg);\r
 552                         }\r
 553                 }\r
 554         },\r
 555         \r
 556         _isPublicMethod: function(mockedType, property) {\r
 557                 try {\r
 558                         var isMethod = typeof(mockedType[property]) == 'function';\r
 559                         var isPublic = property.charAt(0) != "_"; \r
 560                         return isMethod && isPublic;\r
 561                 } catch(e) {\r
 562                         return false;\r
 563                 }\r
 564         },\r
 565 \r
 566         _createExpectationRecordingMethod: function(methodName) {\r
 567                 return function() {\r
 568                         // ensure all arguments are instances of ArgumentMatcher\r
 569                         var expectedArgs = [];\r
 570                         for(var i=0; i<arguments.length; i++) {\r
 571                                 if(arguments[i] !== null && arguments[i] !== undefined && arguments[i].argumentMatches) {\r
 572                                         expectedArgs[i] = arguments[i];\r
 573                                 } else {\r
 574                                         expectedArgs[i] = new MatchExactly(arguments[i]);\r
 575                                 }\r
 576                         }\r
 577                         \r
 578                         // create stub or expected invocation\r
 579                         var expectedInvocation;\r
 580                         if(this._isRecordingExpectations) {\r
 581                                 expectedInvocation = new ExpectedInvocation(methodName, expectedArgs, this._expectedCallCount);\r
 582                         } else {\r
 583                                 expectedInvocation = new StubInvocation(methodName, expectedArgs, new StubActionSequence());\r
 584                         }\r
 585                         \r
 586                         this._expectedInvocations.push(expectedInvocation);\r
 587                         \r
 588                         this._isRecordingExpectations = false;\r
 589                         this._isRecordingStubs = false;\r
 590                         return expectedInvocation;\r
 591                 }\r
 592         },\r
 593         \r
 594         _createMockedMethod: function(methodName) {\r
 595                 return function() {\r
 596                         // go through expectation list backwards to ensure later expectations override earlier ones\r
 597                         for(var i=this.mock._expectedInvocations.length-1; i>=0; i--) {\r
 598                                 var expectedInvocation = this.mock._expectedInvocations[i];\r
 599                                 if(expectedInvocation.matches(methodName, arguments)) {\r
 600                                         try {\r
 601                                                 return expectedInvocation.invoked();\r
 602                                         } catch(e) {\r
 603                                                 if(e instanceof Mock4JSException) {\r
 604                                                         throw new Mock4JSException(e.message+this.mock._describeMockSetup());\r
 605                                                 } else {\r
 606                                                         // the user setup the mock to throw a specific error, so don't modify the message\r
 607                                                         throw e;\r
 608                                                 }\r
 609                                         }\r
 610                                 }\r
 611                         }\r
 612                         var failMsg = "unexpected invocation: "+methodName+"("+Mock4JSUtil.join(arguments)+")"+this.mock._describeMockSetup();\r
 613                         throw new Mock4JSException(failMsg);\r
 614                 };\r
 615         },\r
 616         \r
 617         _describeMockSetup: function() {\r
 618                 var msg = "\nAllowed:";\r
 619                 for(var i=0; i<this._expectedInvocations.length; i++) {\r
 620                         var expectedInvocation = this._expectedInvocations[i];\r
 621                         msg += "\n" + expectedInvocation.describe();\r
 622                 }\r
 623                 return msg;\r
 624         }\r
 625 }