code.angularjs.org/1.2.1/angular-mocks.js at master · angular/code.angularjs.org · GitHub

This repository was archived by the owner on Apr 17, 2025. It is now read-only.

History

2115 lines (1882 loc) · 66.1 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

581

582

583

584

585

586

587

588

589

590

591

592

593

594

595

596

597

598

599

600

601

602

603

604

605

606

607

608

609

610

611

612

613

614

615

616

617

618

619

620

621

622

623

624

625

626

627

628

629

630

631

632

633

634

635

636

637

638

639

640

641

642

643

644

645

646

647

648

649

650

651

652

653

654

655

656

657

658

659

660

661

662

663

664

665

666

667

668

669

670

671

672

673

674

675

676

677

678

679

680

681

682

683

684

685

686

687

688

689

690

691

692

693

694

695

696

697

698

699

700

701

702

703

704

705

706

707

708

709

710

711

712

713

714

715

716

717

718

719

720

721

722

723

724

725

726

727

728

729

730

731

732

733

734

735

736

737

738

739

740

741

742

743

744

745

746

747

748

749

750

751

752

753

754

755

756

757

758

759

760

761

762

763

764

765

766

767

768

769

770

771

772

773

774

775

776

777

778

779

780

781

782

783

784

785

786

787

788

789

790

791

792

793

794

795

796

797

798

799

800

801

802

803

804

805

806

807

808

809

810

811

812

813

814

815

816

817

818

819

820

821

822

823

824

825

826

827

828

829

830

831

832

833

834

835

836

837

838

839

840

841

842

843

844

845

846

847

848

849

850

851

852

853

854

855

856

857

858

859

860

861

862

863

864

865

866

867

868

869

870

871

872

873

874

875

876

877

878

879

880

881

882

883

884

885

886

887

888

889

890

891

892

893

894

895

896

897

898

899

900

901

902

903

904

905

906

907

908

909

910

911

912

913

914

915

916

917

918

919

920

921

922

923

924

925

926

927

928

929

930

931

932

933

934

935

936

937

938

939

940

941

942

943

944

945

946

947

948

949

950

951

952

953

954

955

956

957

958

959

960

961

962

963

964

965

966

967

968

969

970

971

972

973

974

975

976

977

978

979

980

981

982

983

984

985

986

987

988

989

990

991

992

993

994

995

996

997

998

999

1000

'use strict';

/**

* @license AngularJS v1.2.1

* License: MIT

* TODO(vojta): wrap whole file into closure during build

/**

* @ngdoc overview

* @name angular.mock

* @description

* Namespace from 'angular-mocks.js' which contains testing related code.

angular.mock = {};

/**

* ! This is a private undocumented service !

* @name ngMock.$browser

* @description

* This service is a mock implementation of {@link ng.$browser}. It provides fake

* implementation for commonly used browser apis that are hard to test, e.g. setTimeout, xhr,

* cookies, etc...

* The api of this service is the same as that of the real {@link ng.$browser $browser}, except

* that there are several helper methods available which can be used in tests.

angular.mock.$BrowserProvider = function() {

this.$get = function() {

return new angular.mock.$Browser();

};

angular.mock.$Browser = function() {

var self = this;

this.isMock = true;

self.$$url = "http://server/";

self.$$lastUrl = self.$$url; // used by url polling fn

self.pollFns = [];

// TODO(vojta): remove this temporary api

self.$$completeOutstandingRequest = angular.noop;

self.$$incOutstandingRequestCount = angular.noop;

// register url polling fn

self.onUrlChange = function(listener) {

self.pollFns.push(

function() {

if (self.$$lastUrl != self.$$url) {

self.$$lastUrl = self.$$url;

listener(self.$$url);

}

);

return listener;

};

self.cookieHash = {};

self.lastCookieHash = {};

self.deferredFns = [];

self.deferredNextId = 0;

self.defer = function(fn, delay) {

delay = delay || 0;

self.deferredFns.push({time:(self.defer.now + delay), fn:fn, id: self.deferredNextId});

self.deferredFns.sort(function(a,b){ return a.time - b.time;});

return self.deferredNextId++;

};

/**

* @name ngMock.$browser#defer.now

* @propertyOf ngMock.$browser

* @description

* Current milliseconds mock time.

self.defer.now = 0;

self.defer.cancel = function(deferId) {

var fnIndex;

angular.forEach(self.deferredFns, function(fn, index) {

if (fn.id === deferId) fnIndex = index;

});

if (fnIndex !== undefined) {

self.deferredFns.splice(fnIndex, 1);

return true;

}

return false;

};

/**

* @name ngMock.$browser#defer.flush

* @methodOf ngMock.$browser

* @description

* Flushes all pending requests and executes the defer callbacks.

* @param {number=} number of milliseconds to flush. See {@link #defer.now}

self.defer.flush = function(delay) {

if (angular.isDefined(delay)) {

self.defer.now += delay;

} else {

if (self.deferredFns.length) {

self.defer.now = self.deferredFns[self.deferredFns.length-1].time;

} else {

throw new Error('No deferred tasks to be flushed');

}

while (self.deferredFns.length && self.deferredFns[0].time <= self.defer.now) {

self.deferredFns.shift().fn();

}

};

self.$$baseHref = '';

self.baseHref = function() {

return this.$$baseHref;

};

angular.mock.$Browser.prototype = {

/**

* @name ngMock.$browser#poll

* @methodOf ngMock.$browser

* @description

* run all fns in pollFns

poll: function poll() {

angular.forEach(this.pollFns, function(pollFn){

pollFn();

});

addPollFn: function(pollFn) {

this.pollFns.push(pollFn);

return pollFn;

url: function(url, replace) {

if (url) {

this.$$url = url;

return this;

}

return this.$$url;

cookies: function(name, value) {

if (name) {

if (angular.isUndefined(value)) {

delete this.cookieHash[name];

} else {

if (angular.isString(value) && //strings only

value.length <= 4096) { //strict cookie storage limits

this.cookieHash[name] = value;

}

} else {

if (!angular.equals(this.cookieHash, this.lastCookieHash)) {

this.lastCookieHash = angular.copy(this.cookieHash);

this.cookieHash = angular.copy(this.cookieHash);

}

return this.cookieHash;

}

notifyWhenNoOutstandingRequests: function(fn) {

fn();

}

};

/**

* @ngdoc object

* @name ngMock.$exceptionHandlerProvider

* @description

* Configures the mock implementation of {@link ng.$exceptionHandler} to rethrow or to log errors

* passed into the `$exceptionHandler`.

/**

* @ngdoc object

* @name ngMock.$exceptionHandler

* @description

* Mock implementation of {@link ng.$exceptionHandler} that rethrows or logs errors passed

* into it. See {@link ngMock.$exceptionHandlerProvider $exceptionHandlerProvider} for configuration

* information.

* <pre>

* describe('$exceptionHandlerProvider', function() {

* it('should capture log messages and exceptions', function() {

* module(function($exceptionHandlerProvider) {

* $exceptionHandlerProvider.mode('log');

* });

* inject(function($log, $exceptionHandler, $timeout) {

* $timeout(function() { $log.log(1); });

* $timeout(function() { $log.log(2); throw 'banana peel'; });

* $timeout(function() { $log.log(3); });

* expect($exceptionHandler.errors).toEqual([]);

* expect($log.assertEmpty());

* $timeout.flush();

* expect($exceptionHandler.errors).toEqual(['banana peel']);

* expect($log.log.logs).toEqual([[1], [2], [3]]);

* });

* </pre>

angular.mock.$ExceptionHandlerProvider = function() {

var handler;

/**

* @ngdoc method

* @name ngMock.$exceptionHandlerProvider#mode

* @methodOf ngMock.$exceptionHandlerProvider

* @description

* Sets the logging mode.

* @param {string} mode Mode of operation, defaults to `rethrow`.

* - `rethrow`: If any errors are passed into the handler in tests, it typically

* means that there is a bug in the application or test, so this mock will

* make these tests fail.

* - `log`: Sometimes it is desirable to test that an error is thrown, for this case the `log`

* mode stores an array of errors in `$exceptionHandler.errors`, to allow later

* assertion of them. See {@link ngMock.$log#assertEmpty assertEmpty()} and

* {@link ngMock.$log#reset reset()}

this.mode = function(mode) {

switch(mode) {

case 'rethrow':

handler = function(e) {

throw e;

};

break;

case 'log':

var errors = [];

handler = function(e) {

if (arguments.length == 1) {

errors.push(e);

} else {

errors.push([].slice.call(arguments, 0));

}

};

handler.errors = errors;

break;

default:

throw new Error("Unknown mode '" + mode + "', only 'log'/'rethrow' modes are allowed!");

}

};

this.$get = function() {

return handler;

};

this.mode('rethrow');

};

/**

* @ngdoc service

* @name ngMock.$log

* @description

* Mock implementation of {@link ng.$log} that gathers all logged messages in arrays

* (one array per logging level). These arrays are exposed as `logs` property of each of the

* level-specific log function, e.g. for level `error` the array is exposed as `$log.error.logs`.

angular.mock.$LogProvider = function() {

var debug = true;

function concat(array1, array2, index) {

return array1.concat(Array.prototype.slice.call(array2, index));

}

this.debugEnabled = function(flag) {

if (angular.isDefined(flag)) {

debug = flag;

return this;

} else {

return debug;

}

};

this.$get = function () {

var $log = {

log: function() { $log.log.logs.push(concat([], arguments, 0)); },

warn: function() { $log.warn.logs.push(concat([], arguments, 0)); },

info: function() { $log.info.logs.push(concat([], arguments, 0)); },

error: function() { $log.error.logs.push(concat([], arguments, 0)); },

debug: function() {

if (debug) {

$log.debug.logs.push(concat([], arguments, 0));

}

};

/**

* @ngdoc method

* @name ngMock.$log#reset

* @methodOf ngMock.$log

* @description

* Reset all of the logging arrays to empty.

$log.reset = function () {

/**

* @ngdoc property

* @name ngMock.$log#log.logs

* @propertyOf ngMock.$log

* @description

* Array of messages logged using {@link ngMock.$log#log}.

* @example

* <pre>

* $log.log('Some Log');

* var first = $log.log.logs.unshift();

* </pre>

$log.log.logs = [];

/**

* @ngdoc property

* @name ngMock.$log#info.logs

* @propertyOf ngMock.$log

* @description

* Array of messages logged using {@link ngMock.$log#info}.

* @example

* <pre>

* $log.info('Some Info');

* var first = $log.info.logs.unshift();

* </pre>

$log.info.logs = [];

/**

* @ngdoc property

* @name ngMock.$log#warn.logs

* @propertyOf ngMock.$log

* @description

* Array of messages logged using {@link ngMock.$log#warn}.

* @example

* <pre>

* $log.warn('Some Warning');

* var first = $log.warn.logs.unshift();

* </pre>

$log.warn.logs = [];

/**

* @ngdoc property

* @name ngMock.$log#error.logs

* @propertyOf ngMock.$log

* @description

* Array of messages logged using {@link ngMock.$log#error}.

* @example

* <pre>

* $log.log('Some Error');

* var first = $log.error.logs.unshift();

* </pre>

$log.error.logs = [];

/**

* @ngdoc property

* @name ngMock.$log#debug.logs

* @propertyOf ngMock.$log

* @description

* Array of messages logged using {@link ngMock.$log#debug}.

* @example

* <pre>

* $log.debug('Some Error');

* var first = $log.debug.logs.unshift();

* </pre>

$log.debug.logs = [];

};

/**

* @ngdoc method

* @name ngMock.$log#assertEmpty

* @methodOf ngMock.$log

* @description

* Assert that the all of the logging methods have no logged messages. If messages present, an

* exception is thrown.

$log.assertEmpty = function() {

var errors = [];

angular.forEach(['error', 'warn', 'info', 'log', 'debug'], function(logLevel) {

angular.forEach($log[logLevel].logs, function(log) {

angular.forEach(log, function (logItem) {

errors.push('MOCK $log (' + logLevel + '): ' + String(logItem) + '\n' +

(logItem.stack || ''));

});

if (errors.length) {

errors.unshift("Expected $log to be empty! Either a message was logged unexpectedly, or "+

"an expected log message was not checked and removed:");

errors.push('');

throw new Error(errors.join('\n---------\n'));

}

};

$log.reset();

return $log;

};

/**

* @ngdoc service

* @name ngMock.$interval

* @description

* Mock implementation of the $interval service.

* Use {@link ngMock.$interval#methods_flush `$interval.flush(millis)`} to

* move forward by `millis` milliseconds and trigger any functions scheduled to run in that

* time.

* @param {function()} fn A function that should be called repeatedly.

* @param {number} delay Number of milliseconds between each function call.

* @param {number=} [count=0] Number of times to repeat. If not set, or 0, will repeat

* indefinitely.

* @param {boolean=} [invokeApply=true] If set to `false` skips model dirty checking, otherwise

* will invoke `fn` within the {@link ng.$rootScope.Scope#methods_$apply $apply} block.

* @returns {promise} A promise which will be notified on each iteration.

angular.mock.$IntervalProvider = function() {

this.$get = ['$rootScope', '$q',

function($rootScope, $q) {

var repeatFns = [],

nextRepeatId = 0,

now = 0;

var $interval = function(fn, delay, count, invokeApply) {

var deferred = $q.defer(),

promise = deferred.promise,

iteration = 0,

skipApply = (angular.isDefined(invokeApply) && !invokeApply);

count = (angular.isDefined(count)) ? count : 0,

promise.then(null, null, fn);

promise.$$intervalId = nextRepeatId;

function tick() {

deferred.notify(iteration++);

if (count > 0 && iteration >= count) {

var fnIndex;

deferred.resolve(iteration);

angular.forEach(repeatFns, function(fn, index) {

if (fn.id === promise.$$intervalId) fnIndex = index;

});

if (fnIndex !== undefined) {

repeatFns.splice(fnIndex, 1);

}

if (!skipApply) $rootScope.$apply();

}

repeatFns.push({

nextTime:(now + delay),

delay: delay,

fn: tick,

id: nextRepeatId,

deferred: deferred

});

repeatFns.sort(function(a,b){ return a.nextTime - b.nextTime;});

nextRepeatId++;

return promise;

};

$interval.cancel = function(promise) {

var fnIndex;

angular.forEach(repeatFns, function(fn, index) {

if (fn.id === promise.$$intervalId) fnIndex = index;

});

if (fnIndex !== undefined) {

repeatFns[fnIndex].deferred.reject('canceled');

repeatFns.splice(fnIndex, 1);

return true;

}

return false;

};

/**

* @ngdoc method

* @name ngMock.$interval#flush

* @methodOf ngMock.$interval

* @description

* Runs interval tasks scheduled to be run in the next `millis` milliseconds.

* @param {number=} millis maximum timeout amount to flush up until.

* @return {number} The amount of time moved forward.

$interval.flush = function(millis) {

now += millis;

while (repeatFns.length && repeatFns[0].nextTime <= now) {

var task = repeatFns[0];

task.fn();

task.nextTime += task.delay;

repeatFns.sort(function(a,b){ return a.nextTime - b.nextTime;});

}

return millis;

};

return $interval;

}];

};

/* jshint -W101 */

/* The R_ISO8061_STR regex is never going to fit into the 100 char limit!

* This directive should go inside the anonymous function but a bug in JSHint means that it would

* not be enacted early enough to prevent the warning.

(function() {

var R_ISO8061_STR = /^(\d{4})-?(\d\d)-?(\d\d)(?:T(\d\d)(?:\:?(\d\d)(?:\:?(\d\d)(?:\.(\d{3}))?)?)?(Z|([+-])(\d\d):?(\d\d)))?$/;

function jsonStringToDate(string) {

var match;

if (match = string.match(R_ISO8061_STR)) {

var date = new Date(0),

tzHour = 0,

tzMin = 0;

if (match[9]) {

tzHour = int(match[9] + match[10]);

tzMin = int(match[9] + match[11]);

}

date.setUTCFullYear(int(match[1]), int(match[2]) - 1, int(match[3]));

date.setUTCHours(int(match[4]||0) - tzHour,

int(match[5]||0) - tzMin,

int(match[6]||0),

int(match[7]||0));

return date;

}

return string;

}

function int(str) {

return parseInt(str, 10);

}

function padNumber(num, digits, trim) {

var neg = '';

if (num < 0) {

neg = '-';

num = -num;

}

num = '' + num;

while(num.length < digits) num = '0' + num;

if (trim)

num = num.substr(num.length - digits);

return neg + num;

}

/**

* @ngdoc object

* @name angular.mock.TzDate

* @description

* *NOTE*: this is not an injectable instance, just a globally available mock class of `Date`.

* Mock of the Date type which has its timezone specified via constructor arg.

* The main purpose is to create Date-like instances with timezone fixed to the specified timezone

* offset, so that we can test code that depends on local timezone settings without dependency on

* the time zone settings of the machine where the code is running.

* @param {number} offset Offset of the *desired* timezone in hours (fractions will be honored)

* @param {(number|string)} timestamp Timestamp representing the desired time in *UTC*

* @example

* !!!! WARNING !!!!!

* This is not a complete Date object so only methods that were implemented can be called safely.

* To make matters worse, TzDate instances inherit stuff from Date via a prototype.

* We do our best to intercept calls to "unimplemented" methods, but since the list of methods is

* incomplete we might be missing some non-standard methods. This can result in errors like:

* "Date.prototype.foo called on incompatible Object".

* <pre>

* var newYearInBratislava = new TzDate(-1, '2009-12-31T23:00:00Z');

* newYearInBratislava.getTimezoneOffset() => -60;

* newYearInBratislava.getFullYear() => 2010;

* newYearInBratislava.getMonth() => 0;

* newYearInBratislava.getDate() => 1;

* newYearInBratislava.getHours() => 0;

* newYearInBratislava.getMinutes() => 0;

* newYearInBratislava.getSeconds() => 0;

* </pre>

angular.mock.TzDate = function (offset, timestamp) {

var self = new Date(0);

if (angular.isString(timestamp)) {

var tsStr = timestamp;

self.origDate = jsonStringToDate(timestamp);

timestamp = self.origDate.getTime();

if (isNaN(timestamp))

throw {

name: "Illegal Argument",

message: "Arg '" + tsStr + "' passed into TzDate constructor is not a valid date string"

};

} else {

self.origDate = new Date(timestamp);

}

var localOffset = new Date(timestamp).getTimezoneOffset();

self.offsetDiff = localOffset*60*1000 - offset*1000*60*60;

self.date = new Date(timestamp + self.offsetDiff);

self.getTime = function() {

return self.date.getTime() - self.offsetDiff;

};

self.toLocaleDateString = function() {

return self.date.toLocaleDateString();

};

self.getFullYear = function() {

return self.date.getFullYear();

};

self.getMonth = function() {

return self.date.getMonth();

};

self.getDate = function() {

return self.date.getDate();

};

self.getHours = function() {

return self.date.getHours();

};

self.getMinutes = function() {

return self.date.getMinutes();

};

self.getSeconds = function() {

return self.date.getSeconds();

};

self.getMilliseconds = function() {

return self.date.getMilliseconds();

};

self.getTimezoneOffset = function() {

return offset * 60;

};

self.getUTCFullYear = function() {

return self.origDate.getUTCFullYear();

};

self.getUTCMonth = function() {

return self.origDate.getUTCMonth();

};

self.getUTCDate = function() {

return self.origDate.getUTCDate();

};

self.getUTCHours = function() {

return self.origDate.getUTCHours();

};

self.getUTCMinutes = function() {

return self.origDate.getUTCMinutes();

};

self.getUTCSeconds = function() {

return self.origDate.getUTCSeconds();

};

self.getUTCMilliseconds = function() {

return self.origDate.getUTCMilliseconds();

};

self.getDay = function() {

return self.date.getDay();

};

// provide this method only on browsers that already have it

if (self.toISOString) {

self.toISOString = function() {

return padNumber(self.origDate.getUTCFullYear(), 4) + '-' +

padNumber(self.origDate.getUTCMonth() + 1, 2) + '-' +

padNumber(self.origDate.getUTCDate(), 2) + 'T' +

padNumber(self.origDate.getUTCHours(), 2) + ':' +

padNumber(self.origDate.getUTCMinutes(), 2) + ':' +

padNumber(self.origDate.getUTCSeconds(), 2) + '.' +

padNumber(self.origDate.getUTCMilliseconds(), 3) + 'Z';

};

}

//hide all methods not implemented in this mock that the Date prototype exposes

var unimplementedMethods = ['getUTCDay',

'getYear', 'setDate', 'setFullYear', 'setHours', 'setMilliseconds',

'setMinutes', 'setMonth', 'setSeconds', 'setTime', 'setUTCDate', 'setUTCFullYear',

'setUTCHours', 'setUTCMilliseconds', 'setUTCMinutes', 'setUTCMonth', 'setUTCSeconds',

'setYear', 'toDateString', 'toGMTString', 'toJSON', 'toLocaleFormat', 'toLocaleString',

'toLocaleTimeString', 'toSource', 'toString', 'toTimeString', 'toUTCString', 'valueOf'];

angular.forEach(unimplementedMethods, function(methodName) {

self[methodName] = function() {

throw new Error("Method '" + methodName + "' is not implemented in the TzDate mock");

};

});

return self;

};

//make "tzDateInstance instanceof Date" return true

angular.mock.TzDate.prototype = Date.prototype;

})();

/* jshint +W101 */

angular.mock.animate = angular.module('mock.animate', ['ng'])

.config(['$provide', function($provide) {

$provide.decorator('$animate', function($delegate) {

var animate = {

queue : [],

enabled : $delegate.enabled,

flushNext : function(name) {

var tick = animate.queue.shift();

if (!tick) throw new Error('No animation to be flushed');

if(tick.method !== name) {

throw new Error('The next animation is not "' + name +

'", but is "' + tick.method + '"');

}

tick.fn();

return tick;

}

};

angular.forEach(['enter','leave','move','addClass','removeClass'], function(method) {

animate[method] = function() {

var params = arguments;

animate.queue.push({

method : method,

params : params,

element : angular.isElement(params[0]) && params[0],

parent : angular.isElement(params[1]) && params[1],

after : angular.isElement(params[2]) && params[2],

fn : function() {

$delegate[method].apply($delegate, params);

}

});

};

});

return animate;

});

}]);

/**

* @ngdoc function

* @name angular.mock.dump

* @description

* *NOTE*: this is not an injectable instance, just a globally available function.

* Method for serializing common angular objects (scope, elements, etc..) into strings, useful for

* debugging.

* This method is also available on window, where it can be used to display objects on debug

* console.

* @param {*} object - any object to turn into string.

* @return {string} a serialized string of the argument

angular.mock.dump = function(object) {

return serialize(object);

function serialize(object) {

var out;

if (angular.isElement(object)) {

object = angular.element(object);

out = angular.element('<div></div>');

angular.forEach(object, function(element) {

out.append(angular.element(element).clone());

});

out = out.html();

} else if (angular.isArray(object)) {

out = [];

angular.forEach(object, function(o) {

out.push(serialize(o));

});

out = '[ ' + out.join(', ') + ' ]';

} else if (angular.isObject(object)) {

if (angular.isFunction(object.$eval) && angular.isFunction(object.$apply)) {

out = serializeScope(object);

} else if (object instanceof Error) {

out = object.stack || ('' + object.name + ': ' + object.message);

} else {

// TODO(i): this prevents methods being logged,

// we should have a better way to serialize objects

out = angular.toJson(object, true);

}

} else {

out = String(object);

}

return out;

}

function serializeScope(scope, offset) {

offset = offset || ' ';

var log = [offset + 'Scope(' + scope.$id + '): {'];

for ( var key in scope ) {

if (Object.prototype.hasOwnProperty.call(scope, key) && !key.match(/^(\$|this)/)) {

log.push(' ' + key + ': ' + angular.toJson(scope[key]));

}

var child = scope.$$childHead;

while(child) {

log.push(serializeScope(child, offset + ' '));

child = child.$$nextSibling;

}

log.push('}');

return log.join('\n' + offset);

}

};

/**

* @ngdoc object

* @name ngMock.$httpBackend

* @description

* Fake HTTP backend implementation suitable for unit testing applications that use the

* {@link ng.$http $http service}.

* *Note*: For fake HTTP backend implementation suitable for end-to-end testing or backend-less

* development please see {@link ngMockE2E.$httpBackend e2e $httpBackend mock}.

* During unit testing, we want our unit tests to run quickly and have no external dependencies so

* we don’t want to send {@link https://developer.mozilla.org/en/xmlhttprequest XHR} or

* {@link http://en.wikipedia.org/wiki/JSONP JSONP} requests to a real server. All we really need is

* to verify whether a certain request has been sent or not, or alternatively just let the

* application make requests, respond with pre-trained responses and assert that the end result is

* what we expect it to be.

* This mock implementation can be used to respond with static or dynamic responses via the

* `expect` and `when` apis and their shortcuts (`expectGET`, `whenPOST`, etc).

* When an Angular application needs some data from a server, it calls the $http service, which

* sends the request to a real server using $httpBackend service. With dependency injection, it is

* easy to inject $httpBackend mock (which has the same API as $httpBackend) and use it to verify

* the requests and respond with some testing data without sending a request to real server.

* There are two ways to specify what test data should be returned as http responses by the mock

* backend when the code under test makes http requests:

* - `$httpBackend.expect` - specifies a request expectation

* - `$httpBackend.when` - specifies a backend definition

* # Request Expectations vs Backend Definitions

* Request expectations provide a way to make assertions about requests made by the application and

* to define responses for those requests. The test will fail if the expected requests are not made

* or they are made in the wrong order.

* Backend definitions allow you to define a fake backend for your application which doesn't assert

* if a particular request was made or not, it just returns a trained response if a request is made.

* The test will pass whether or not the request gets made during testing.

* <table class="table">

* <tr><th width="220px"></th><th>Request expectations</th><th>Backend definitions</th></tr>

* <tr>

* <th>Syntax</th>

* <td>.expect(...).respond(...)</td>

* <td>.when(...).respond(...)</td>

* </tr>

* <tr>

* <th>Typical usage</th>

* <td>strict unit tests</td>

* <td>loose (black-box) unit testing</td>

* </tr>

* <tr>

* <th>Fulfills multiple requests</th>

* <td>NO</td>

* <td>YES</td>

* </tr>

* <tr>

* <th>Order of requests matters</th>

* <td>YES</td>

* <td>NO</td>

* </tr>

* <tr>

* <th>Request required</th>

* <td>YES</td>

* <td>NO</td>

* </tr>

* <tr>

* <th>Response required</th>

* <td>optional (see below)</td>

* <td>YES</td>

* </tr>

* </table>

* In cases where both backend definitions and request expectations are specified during unit

* testing, the request expectations are evaluated first.

* If a request expectation has no response specified, the algorithm will search your backend

* definitions for an appropriate response.

* If a request didn't match any expectation or if the expectation doesn't have the response

* defined, the backend definitions are evaluated in sequential order to see if any of them match

* the request. The response from the first matched definition is returned.

* # Flushing HTTP requests

* The $httpBackend used in production, always responds to requests with responses asynchronously.

* If we preserved this behavior in unit testing, we'd have to create async unit tests, which are

* hard to write, follow and maintain. At the same time the testing mock, can't respond

* synchronously because that would change the execution of the code under test. For this reason the

* mock $httpBackend has a `flush()` method, which allows the test to explicitly flush pending

* requests and thus preserving the async api of the backend, while allowing the test to execute

* synchronously.

* # Unit testing with mock $httpBackend

* The following code shows how to setup and use the mock backend in unit testing a controller.

* First we create the controller under test

<pre>

// The controller code

function MyController($scope, $http) {

var authToken;

$http.get('/auth.py').success(function(data, status, headers) {

authToken = headers('A-Token');

$scope.user = data;

});

$scope.saveMessage = function(message) {

var headers = { 'Authorization': authToken };

$scope.status = 'Saving...';

$http.post('/add-msg.py', message, { headers: headers } ).success(function(response) {

$scope.status = '';

View remainder of file in raw view

code.angularjs.org/1.2.1/angular-mocks.js at master · angular/code.angularjs.org · GitHub

Uh oh!

Expand file tree

Breadcrumbs

angular-mocks.js

Latest commit

History

Breadcrumbs

angular-mocks.js

File metadata and controls