cargdev/angular
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

build: upgrade jasmine (and related typings) to latest version (#19904)

Browse Source 
With these changes, the types are a little stricter now and also not
compatible with Protractor's jasmine-like syntax. So, we have to also
use `@types/jasminewd2` for e2e tests (but not for non-e2e tests).

I also had to "augment" `@types/jasminewd2`, because the latest
typings from [DefinitelyTyped][1] do not reflect the fact that the
`jasminewd2` version (v2.1.0) currently used by Protractor supports
passing a `done` callback to a spec.

[1]: 566e039485/types/jasminewd2/index.d.ts (L9-L15)

Fixes #23952
Closes #24733

PR Close #19904
This commit is contained in:
George Kalpakas
2017-10-24 14:54:08 +03:00
committed by Miško Hevery
parent 1e74ea9e60
commit 00c110b055
59 changed files with 332 additions and 283 deletions
Download Patch File Download Diff File Expand all files Collapse all files

143
packages/compiler/test/core_spec.ts
View File

@ -103,83 +103,86 @@ import * as core from '@angular/core';
});
it('const enums should be equal', () => {
expect(compilerCore.NodeFlags.None).toBe(core.ɵNodeFlags.None);
expect(compilerCore.NodeFlags.TypeElement).toBe(core.ɵNodeFlags.TypeElement);
expect(compilerCore.NodeFlags.TypeText).toBe(core.ɵNodeFlags.TypeText);
expect(compilerCore.NodeFlags.ProjectedTemplate).toBe(core.ɵNodeFlags.ProjectedTemplate);
expect(compilerCore.NodeFlags.CatRenderNode).toBe(core.ɵNodeFlags.CatRenderNode);
expect(compilerCore.NodeFlags.TypeNgContent).toBe(core.ɵNodeFlags.TypeNgContent);
expect(compilerCore.NodeFlags.TypePipe).toBe(core.ɵNodeFlags.TypePipe);
expect(compilerCore.NodeFlags.TypePureArray).toBe(core.ɵNodeFlags.TypePureArray);
expect(compilerCore.NodeFlags.TypePureObject).toBe(core.ɵNodeFlags.TypePureObject);
expect(compilerCore.NodeFlags.TypePurePipe).toBe(core.ɵNodeFlags.TypePurePipe);
expect(compilerCore.NodeFlags.CatPureExpression).toBe(core.ɵNodeFlags.CatPureExpression);
expect(compilerCore.NodeFlags.TypeValueProvider).toBe(core.ɵNodeFlags.TypeValueProvider);
expect(compilerCore.NodeFlags.TypeClassProvider).toBe(core.ɵNodeFlags.TypeClassProvider);
expect(compilerCore.NodeFlags.TypeFactoryProvider).toBe(core.ɵNodeFlags.TypeFactoryProvider);
expect(compilerCore.NodeFlags.TypeUseExistingProvider)
.toBe(core.ɵNodeFlags.TypeUseExistingProvider);
expect(compilerCore.NodeFlags.LazyProvider).toBe(core.ɵNodeFlags.LazyProvider);
expect(compilerCore.NodeFlags.PrivateProvider).toBe(core.ɵNodeFlags.PrivateProvider);
expect(compilerCore.NodeFlags.TypeDirective).toBe(core.ɵNodeFlags.TypeDirective);
expect(compilerCore.NodeFlags.Component).toBe(core.ɵNodeFlags.Component);
expect(compilerCore.NodeFlags.CatProviderNoDirective)
.toBe(core.ɵNodeFlags.CatProviderNoDirective);
expect(compilerCore.NodeFlags.CatProvider).toBe(core.ɵNodeFlags.CatProvider);
expect(compilerCore.NodeFlags.OnInit).toBe(core.ɵNodeFlags.OnInit);
expect(compilerCore.NodeFlags.OnDestroy).toBe(core.ɵNodeFlags.OnDestroy);
expect(compilerCore.NodeFlags.DoCheck).toBe(core.ɵNodeFlags.DoCheck);
expect(compilerCore.NodeFlags.OnChanges).toBe(core.ɵNodeFlags.OnChanges);
expect(compilerCore.NodeFlags.AfterContentInit).toBe(core.ɵNodeFlags.AfterContentInit);
expect(compilerCore.NodeFlags.AfterContentChecked).toBe(core.ɵNodeFlags.AfterContentChecked);
expect(compilerCore.NodeFlags.AfterViewInit).toBe(core.ɵNodeFlags.AfterViewInit);
expect(compilerCore.NodeFlags.AfterViewChecked).toBe(core.ɵNodeFlags.AfterViewChecked);
expect(compilerCore.NodeFlags.EmbeddedViews).toBe(core.ɵNodeFlags.EmbeddedViews);
expect(compilerCore.NodeFlags.ComponentView).toBe(core.ɵNodeFlags.ComponentView);
expect(compilerCore.NodeFlags.TypeContentQuery).toBe(core.ɵNodeFlags.TypeContentQuery);
expect(compilerCore.NodeFlags.TypeViewQuery).toBe(core.ɵNodeFlags.TypeViewQuery);
expect(compilerCore.NodeFlags.StaticQuery).toBe(core.ɵNodeFlags.StaticQuery);
expect(compilerCore.NodeFlags.DynamicQuery).toBe(core.ɵNodeFlags.DynamicQuery);
expect(compilerCore.NodeFlags.CatQuery).toBe(core.ɵNodeFlags.CatQuery);
expect(compilerCore.NodeFlags.Types).toBe(core.ɵNodeFlags.Types);
const expectToBe = (val1: any, val2: any) => expect(val1).toBe(val2);
expect(compilerCore.DepFlags.None).toBe(core.ɵDepFlags.None);
expect(compilerCore.DepFlags.SkipSelf).toBe(core.ɵDepFlags.SkipSelf);
expect(compilerCore.DepFlags.Optional).toBe(core.ɵDepFlags.Optional);
expect(compilerCore.DepFlags.Value).toBe(core.ɵDepFlags.Value);
expectToBe(compilerCore.NodeFlags.None, core.ɵNodeFlags.None);
expectToBe(compilerCore.NodeFlags.TypeElement, core.ɵNodeFlags.TypeElement);
expectToBe(compilerCore.NodeFlags.TypeText, core.ɵNodeFlags.TypeText);
expectToBe(compilerCore.NodeFlags.ProjectedTemplate, core.ɵNodeFlags.ProjectedTemplate);
expectToBe(compilerCore.NodeFlags.CatRenderNode, core.ɵNodeFlags.CatRenderNode);
expectToBe(compilerCore.NodeFlags.TypeNgContent, core.ɵNodeFlags.TypeNgContent);
expectToBe(compilerCore.NodeFlags.TypePipe, core.ɵNodeFlags.TypePipe);
expectToBe(compilerCore.NodeFlags.TypePureArray, core.ɵNodeFlags.TypePureArray);
expectToBe(compilerCore.NodeFlags.TypePureObject, core.ɵNodeFlags.TypePureObject);
expectToBe(compilerCore.NodeFlags.TypePurePipe, core.ɵNodeFlags.TypePurePipe);
expectToBe(compilerCore.NodeFlags.CatPureExpression, core.ɵNodeFlags.CatPureExpression);
expectToBe(compilerCore.NodeFlags.TypeValueProvider, core.ɵNodeFlags.TypeValueProvider);
expectToBe(compilerCore.NodeFlags.TypeClassProvider, core.ɵNodeFlags.TypeClassProvider);
expectToBe(compilerCore.NodeFlags.TypeFactoryProvider, core.ɵNodeFlags.TypeFactoryProvider);
expectToBe(
compilerCore.NodeFlags.TypeUseExistingProvider, core.ɵNodeFlags.TypeUseExistingProvider);
expectToBe(compilerCore.NodeFlags.LazyProvider, core.ɵNodeFlags.LazyProvider);
expectToBe(compilerCore.NodeFlags.PrivateProvider, core.ɵNodeFlags.PrivateProvider);
expectToBe(compilerCore.NodeFlags.TypeDirective, core.ɵNodeFlags.TypeDirective);
expectToBe(compilerCore.NodeFlags.Component, core.ɵNodeFlags.Component);
expectToBe(
compilerCore.NodeFlags.CatProviderNoDirective, core.ɵNodeFlags.CatProviderNoDirective);
expectToBe(compilerCore.NodeFlags.CatProvider, core.ɵNodeFlags.CatProvider);
expectToBe(compilerCore.NodeFlags.OnInit, core.ɵNodeFlags.OnInit);
expectToBe(compilerCore.NodeFlags.OnDestroy, core.ɵNodeFlags.OnDestroy);
expectToBe(compilerCore.NodeFlags.DoCheck, core.ɵNodeFlags.DoCheck);
expectToBe(compilerCore.NodeFlags.OnChanges, core.ɵNodeFlags.OnChanges);
expectToBe(compilerCore.NodeFlags.AfterContentInit, core.ɵNodeFlags.AfterContentInit);
expectToBe(compilerCore.NodeFlags.AfterContentChecked, core.ɵNodeFlags.AfterContentChecked);
expectToBe(compilerCore.NodeFlags.AfterViewInit, core.ɵNodeFlags.AfterViewInit);
expectToBe(compilerCore.NodeFlags.AfterViewChecked, core.ɵNodeFlags.AfterViewChecked);
expectToBe(compilerCore.NodeFlags.EmbeddedViews, core.ɵNodeFlags.EmbeddedViews);
expectToBe(compilerCore.NodeFlags.ComponentView, core.ɵNodeFlags.ComponentView);
expectToBe(compilerCore.NodeFlags.TypeContentQuery, core.ɵNodeFlags.TypeContentQuery);
expectToBe(compilerCore.NodeFlags.TypeViewQuery, core.ɵNodeFlags.TypeViewQuery);
expectToBe(compilerCore.NodeFlags.StaticQuery, core.ɵNodeFlags.StaticQuery);
expectToBe(compilerCore.NodeFlags.DynamicQuery, core.ɵNodeFlags.DynamicQuery);
expectToBe(compilerCore.NodeFlags.CatQuery, core.ɵNodeFlags.CatQuery);
expectToBe(compilerCore.NodeFlags.Types, core.ɵNodeFlags.Types);
expect(compilerCore.InjectFlags.Default).toBe(core.InjectFlags.Default);
expect(compilerCore.InjectFlags.SkipSelf).toBe(core.InjectFlags.SkipSelf);
expect(compilerCore.InjectFlags.Self).toBe(core.InjectFlags.Self);
expectToBe(compilerCore.DepFlags.None, core.ɵDepFlags.None);
expectToBe(compilerCore.DepFlags.SkipSelf, core.ɵDepFlags.SkipSelf);
expectToBe(compilerCore.DepFlags.Optional, core.ɵDepFlags.Optional);
expectToBe(compilerCore.DepFlags.Value, core.ɵDepFlags.Value);
expect(compilerCore.ArgumentType.Inline).toBe(core.ɵArgumentType.Inline);
expect(compilerCore.ArgumentType.Dynamic).toBe(core.ɵArgumentType.Dynamic);
expectToBe(compilerCore.InjectFlags.Default, core.InjectFlags.Default);
expectToBe(compilerCore.InjectFlags.SkipSelf, core.InjectFlags.SkipSelf);
expectToBe(compilerCore.InjectFlags.Self, core.InjectFlags.Self);
expect(compilerCore.BindingFlags.TypeElementAttribute)
.toBe(core.ɵBindingFlags.TypeElementAttribute);
expect(compilerCore.BindingFlags.TypeElementClass).toBe(core.ɵBindingFlags.TypeElementClass);
expect(compilerCore.BindingFlags.TypeElementStyle).toBe(core.ɵBindingFlags.TypeElementStyle);
expect(compilerCore.BindingFlags.TypeProperty).toBe(core.ɵBindingFlags.TypeProperty);
expect(compilerCore.BindingFlags.SyntheticProperty)
.toBe(core.ɵBindingFlags.SyntheticProperty);
expect(compilerCore.BindingFlags.SyntheticHostProperty)
.toBe(core.ɵBindingFlags.SyntheticHostProperty);
expect(compilerCore.BindingFlags.CatSyntheticProperty)
.toBe(core.ɵBindingFlags.CatSyntheticProperty);
expect(compilerCore.BindingFlags.Types).toBe(core.ɵBindingFlags.Types);
expect(compilerCore.QueryBindingType.First).toBe(core.ɵQueryBindingType.First);
expect(compilerCore.QueryBindingType.All).toBe(core.ɵQueryBindingType.All);
expectToBe(compilerCore.ArgumentType.Inline, core.ɵArgumentType.Inline);
expectToBe(compilerCore.ArgumentType.Dynamic, core.ɵArgumentType.Dynamic);
expect(compilerCore.QueryValueType.ElementRef).toBe(core.ɵQueryValueType.ElementRef);
expect(compilerCore.QueryValueType.RenderElement).toBe(core.ɵQueryValueType.RenderElement);
expect(compilerCore.QueryValueType.TemplateRef).toBe(core.ɵQueryValueType.TemplateRef);
expect(compilerCore.QueryValueType.ViewContainerRef)
.toBe(core.ɵQueryValueType.ViewContainerRef);
expect(compilerCore.QueryValueType.Provider).toBe(core.ɵQueryValueType.Provider);
expectToBe(
compilerCore.BindingFlags.TypeElementAttribute, core.ɵBindingFlags.TypeElementAttribute);
expectToBe(compilerCore.BindingFlags.TypeElementClass, core.ɵBindingFlags.TypeElementClass);
expectToBe(compilerCore.BindingFlags.TypeElementStyle, core.ɵBindingFlags.TypeElementStyle);
expectToBe(compilerCore.BindingFlags.TypeProperty, core.ɵBindingFlags.TypeProperty);
expectToBe(compilerCore.BindingFlags.SyntheticProperty, core.ɵBindingFlags.SyntheticProperty);
expectToBe(
compilerCore.BindingFlags.SyntheticHostProperty,
core.ɵBindingFlags.SyntheticHostProperty);
expectToBe(
compilerCore.BindingFlags.CatSyntheticProperty, core.ɵBindingFlags.CatSyntheticProperty);
expectToBe(compilerCore.BindingFlags.Types, core.ɵBindingFlags.Types);
expect(compilerCore.ViewFlags.None).toBe(core.ɵViewFlags.None);
expect(compilerCore.ViewFlags.OnPush).toBe(core.ɵViewFlags.OnPush);
expectToBe(compilerCore.QueryBindingType.First, core.ɵQueryBindingType.First);
expectToBe(compilerCore.QueryBindingType.All, core.ɵQueryBindingType.All);
expectToBe(compilerCore.QueryValueType.ElementRef, core.ɵQueryValueType.ElementRef);
expectToBe(compilerCore.QueryValueType.RenderElement, core.ɵQueryValueType.RenderElement);
expectToBe(compilerCore.QueryValueType.TemplateRef, core.ɵQueryValueType.TemplateRef);
expectToBe(
compilerCore.QueryValueType.ViewContainerRef, core.ɵQueryValueType.ViewContainerRef);
expectToBe(compilerCore.QueryValueType.Provider, core.ɵQueryValueType.Provider);
expectToBe(compilerCore.ViewFlags.None, core.ɵViewFlags.None);
expectToBe(compilerCore.ViewFlags.OnPush, core.ɵViewFlags.OnPush);
});
});
}

4
packages/compiler/test/css_parser/css_lexer_spec.ts
View File

@ -274,7 +274,7 @@ import {CssLexer, CssLexerMode, CssToken, CssTokenType, cssScannerError, getRawM
it('should throw an error if a selector is being parsed while in the wrong mode', () => {
const cssCode = '.class > tag';
let capturedMessage: string = undefined !;
let capturedMessage: string|null = null;
try {
tokenize(cssCode, false, CssLexerMode.STYLE_BLOCK);
} catch (e) {
@ -282,8 +282,8 @@ import {CssLexer, CssLexerMode, CssToken, CssTokenType, cssScannerError, getRawM
}
expect(capturedMessage).toMatch(/Unexpected character \[\>\] at column 0:7 in expression/g);
capturedMessage = null !;
capturedMessage = null;
try {
tokenize(cssCode, false, CssLexerMode.SELECTOR);
} catch (e) {

7
packages/compiler/test/css_parser/css_visitor_spec.ts
View File

@ -170,21 +170,22 @@ function _getCaptureAst(capture: any[], index = 0): CssAst {
expect(captures.length).toEqual(3);
const rule1 = <CssSelectorRuleAst>_getCaptureAst(captures, 0);
expect(rule1).toEqual(ast.rules[0]);
expect(rule1).toEqual(ast.rules[0] as CssSelectorRuleAst);
const firstSelector = rule1.selectors[0];
const firstSimpleSelector = firstSelector.selectorParts[0];
_assertTokens(firstSimpleSelector.tokens, ['.', 'rule1']);
const rule2 = <CssSelectorRuleAst>_getCaptureAst(captures, 1);
expect(rule2).toEqual(ast.rules[1]);
expect(rule2).toEqual(ast.rules[1] as CssSelectorRuleAst);
const secondSelector = rule2.selectors[0];
const secondSimpleSelector = secondSelector.selectorParts[0];
_assertTokens(secondSimpleSelector.tokens, ['.', 'rule2']);
const rule3 = <CssSelectorRuleAst>_getCaptureAst(captures, 2);
expect(rule3).toEqual((<CssMediaQueryRuleAst>ast.rules[2]).block.entries[0]);
expect(rule3).toEqual(
(ast.rules[2] as CssSelectorRuleAst).block.entries[0] as CssSelectorRuleAst);
const thirdSelector = rule3.selectors[0];
const thirdSimpleSelector = thirdSelector.selectorParts[0];

4
packages/compiler/test/i18n/extractor_merger_spec.ts
View File

@ -547,7 +547,7 @@ function fakeNoTranslate(
function extract(
html: string, implicitTags: string[] = [],
implicitAttrs: {[k: string]: string[]} = {}): [string[], string, string][] {
implicitAttrs: {[k: string]: string[]} = {}): [string[], string, string, string][] {
const result =
extractMessages(parseHtml(html), DEFAULT_INTERPOLATION_CONFIG, implicitTags, implicitAttrs);
@ -558,7 +558,7 @@ function extract(
// clang-format off
// https://github.com/angular/clang-format/issues/35
return result.messages.map(
message => [serializeI18nNodes(message.nodes), message.meaning, message.description, message.id]) as [string[], string, string][];
message => [serializeI18nNodes(message.nodes), message.meaning, message.description, message.id]) as [string[], string, string, string][];
// clang-format on
}

7
packages/compiler/test/output/abstract_emitter_node_only_spec.ts
View File

@ -116,9 +116,10 @@ function expectMap(
const sm = ctx.toSourceMapGenerator('o.ts').toJSON() !;
const genPosition = {line: genLine + 1, column: genCol};
const origPosition = originalPositionFor(sm, genPosition);
expect(origPosition.source).toEqual(source);
expect(origPosition.line).toEqual(srcLine === null ? null : srcLine + 1);
expect(origPosition.column).toEqual(srcCol);
// TODO: Review use of `any` here (#19904)
expect(origPosition.source as any).toEqual(source);
expect(origPosition.line as any).toEqual(srcLine === null ? null : srcLine + 1);
expect(origPosition.column as any).toEqual(srcCol);
}
// returns the number of segments per line

2
packages/compiler/testing/src/output/source_map_util.ts
View File

@ -36,4 +36,4 @@ export function extractSourceMap(source: string): SourceMap|null {
function decodeB64String(s: string): string {
return b64.toByteArray(s).reduce((s: string, c: number) => s + String.fromCharCode(c), '');
}
}