1
00:00:00,000 --> 00:00:04,307
[MUSIK]

2
00:00:04,307 --> 00:00:09,895
In der vorherigen Vorlesung und Übung, die der Vorlesung folgte,

3
00:00:09,895 --> 00:00:14,330
haben wir die Verwendung von Komponententests in Angular untersucht.

4
00:00:14,330 --> 00:00:18,920
Wir haben gesehen, wie die verschiedenen Teile unserer Angular-Anwendung, die Komponenten,

5
00:00:18,920 --> 00:00:26,420
die Dienste, die Direktiven, die Rohre alle mit Komponententests getestet werden können.

6
00:00:26,420 --> 00:00:27,000
Aber natürlich

7
00:00:27,000 --> 00:00:32,550
zeigen Komponententests nicht alles über die Interaktion zwischen den Komponenten.

8
00:00:32,550 --> 00:00:37,090
Hier können wir die durchgängigen Teststrategien

9
00:00:37,090 --> 00:00:42,480
sehen, wie die gesamte Anwendung als eine Einheit funktioniert.

10
00:00:42,480 --> 00:00:49,200
In dieser Vorlesung werden wir die Verwendung von End-to-End-Tests untersuchen und

11
00:00:49,200 --> 00:00:54,950
welche Rolle sie in der gesamten Teststrategie für unsere Angular-Anwendungen spielen.

12
00:00:54,950 --> 00:01:01,592
In der folgenden Übung werden wir kurz untersuchen, wie wir

13
00:01:01,592 --> 00:01:06,160
End-to-End-Tests für unsere Angular-Anwendung durchführen können, indem wir ein Werkzeug namens Winkelmesser verwenden.

14
00:01:08,110 --> 00:01:13,710
Wie wir bereits in der vorangegangenen Vorlesung erfahren haben,

15
00:01:13,710 --> 00:01:19,650
bieten Unit-Tests uns eine wunderbare Gelegenheit, unsere Einheiten isoliert zu testen. Wir

16
00:01:19,650 --> 00:01:25,105
stellen sicher, dass unsere Einheiten das ausführen, was von ihnen erwartet wird,

17
00:01:25,105 --> 00:01:29,446
ihre Logik korrekt ist und die Interaktion zwischen der Komponente und

18
00:01:29,446 --> 00:01:33,720
ihrer Vorlage gut etabliert ist.

19
00:01:33,720 --> 00:01:38,230
Aber natürlich

20
00:01:38,230 --> 00:01:43,720
vervollständigen Komponententests nicht das gesamte Bild, wie eine typische Angular-Anwendung funktioniert.

21
00:01:43,720 --> 00:01:47,807
Sie haben keine einzelnen Einheiten, die isoliert arbeiten.

22
00:01:47,807 --> 00:01:51,293
Stattdessen interagieren Ihre Komponenten mit Services.

23
00:01:51,293 --> 00:01:53,573
Die Komponenten können Typen verwenden.

24
00:01:53,573 --> 00:01:58,503
Die Dienste wiederum werden mit dem Backend interagieren, um die Daten zu holen.

25
00:01:58,503 --> 00:02:02,300
Und dann ist die Komponente selbst verantwortlich für

26
00:02:02,300 --> 00:02:06,670
das Rendern der Ansichten mit den Vorlagen für die Komponente.

27
00:02:06,670 --> 00:02:13,686
Wie funktioniert dieser ganze Satz von Einheiten zusammen?

28
00:02:13,686 --> 00:02:18,485
Und wie stellen wir sicher, dass die Zusammenarbeit dieser

29
00:02:18,485 --> 00:02:22,202
Einheiten völlig frei von Problemen ist?

30
00:02:22,202 --> 00:02:26,931
Das ist also, wo End-to-End-Tests und auf dem Weg,

31
00:02:26,931 --> 00:02:32,780
Integrationstests hilft uns, diese Art von Szenarien abzudecken.

32
00:02:32,780 --> 00:02:39,190
Selbstverständlich spielen Komponententests eine wichtige Rolle in der gesamten Teststrategie.

33
00:02:39,190 --> 00:02:42,133
Aber ohne End-to-End-Tests

34
00:02:42,133 --> 00:02:47,852
können wir nicht ganz sicher sein, dass unsere Anwendung wie erwartet funktioniert.

35
00:02:47,852 --> 00:02:52,697
Eine Sache, die ich betonen muss, ist, dass Komponententests schnell und

36
00:02:52,697 --> 00:02:56,790
sehr einfach zu wiederholen sind und mehrfach durchgeführt werden können.

37
00:02:56,790 --> 00:03:01,861
Integrationstests und End-to-End-Tests sind langsam und werden daher

38
00:03:01,861 --> 00:03:08,390
nur sparsam verwendet, um zu bestätigen, dass Ihre Anwendung wie erwartet ausgeführt wird.

39
00:03:08,390 --> 00:03:11,830
Wenn wir also unsere allgemeine Teststrategie

40
00:03:11,830 --> 00:03:16,070
betrachten, können wir sie als organisiert in Form einer Pyramide betrachten.

41
00:03:16,070 --> 00:03:19,940
An der Unterseite der Pyramide, die die gesamte Basis besetzt und

42
00:03:19,940 --> 00:03:25,251
das Fundament unserer Gesamtteststrategie bildet, befinden sich Komponententests.

43
00:03:26,710 --> 00:03:31,790
Wie wir gelernt haben, ermöglichen Unit-Tests es uns, die einzelnen Einheiten isoliert zu testen, um

44
00:03:31,790 --> 00:03:35,460
sicherzustellen, dass ihre Logik und

45
00:03:35,460 --> 00:03:39,970
die Art und Weise, wie diese Einheiten funktionieren, korrekt sind.

46
00:03:39,970 --> 00:03:42,890
Und diese Tests können sehr häufig wiederholt werden.

47
00:03:42,890 --> 00:03:48,040
Und in der Tat, sollte häufig wiederholt werden, um sicherzustellen, dass die einzelnen Einheiten

48
00:03:48,040 --> 00:03:49,610
wie erwartet funktionieren.

49
00:03:50,630 --> 00:03:57,850
Natürlich würden auf einer zweiten Ebene dieser Strategie Integrationstests sein.

50
00:03:57,850 --> 00:04:02,600
Wie arbeitet eine kleine Gruppe von Einheiten zusammen, um alles

51
00:04:02,600 --> 00:04:07,680
zu implementieren, was von dieser Gruppe von Einheiten getan werden muss?

52
00:04:07,680 --> 00:04:12,460
Vielleicht könnten wir also eine Komponente zusammen mit

53
00:04:12,460 --> 00:04:17,730
ihren Diensten testen, um zu sehen, wie der Informationsfluss zwischen ihnen geschieht.

54
00:04:17,730 --> 00:04:22,880
Aber an der Spitze dieser Pyramide ist End-to-End-Tests,

55
00:04:22,880 --> 00:04:25,320
bei denen wir uns die Gesamtanwendung ansehen.

56
00:04:25,320 --> 00:04:29,880
Und wie gut die Gesamtanwendung funktioniert und die

57
00:04:29,880 --> 00:04:32,890
erwarteten Anforderungen erfüllt.

58
00:04:32,890 --> 00:04:36,990
Das ist also, wo wir die Verwendung von End-to-End-Tests sehen.

59
00:04:36,990 --> 00:04:42,680
Wie Sie von diesem Diagramm vielleicht bereits erwarten, sind End-to-End-Tests langsam.

60
00:04:42,680 --> 00:04:48,584
Und so führen wir nicht sehr häufig durchgängige Tests durch, stattdessen

61
00:04:48,584 --> 00:04:55,412
bilden Unit-Test die Kernstrategie für unser Testen unserer Angular-Anwendung.

62
00:04:55,412 --> 00:05:02,149
End-to-End-Tests tragen zum Gesamtbild bei, aber sie werden nicht so

63
00:05:02,149 --> 00:05:08,021
häufig durchgeführt, sind aber immer noch ein wesentlicher Bestandteil unserer Teststrategie.

64
00:05:08,021 --> 00:05:10,852
Wie führen wir End-to-End-Tests durch?

65
00:05:10,852 --> 00:05:15,210
Lassen Sie uns kurz über die Tools sprechen, die für uns zur Verfügung stehen.

66
00:05:15,210 --> 00:05:18,199
Die Winkel-Testumgebung für

67
00:05:18,199 --> 00:05:23,740
End-to-End-Tests wird von einem Werkzeug namens Winkelmesser unterstützt.

68
00:05:23,740 --> 00:05:27,930
Wer sagt, dass Geeks keinen Sinn für Humor haben?

69
00:05:27,930 --> 00:05:30,950
Winkelmesser, Angular, da gehst du.

70
00:05:30,950 --> 00:05:33,450
Also, was genau ist Winkelmesser?

71
00:05:33,450 --> 00:05:37,500
Winkelmesser ist, wie Sie vielleicht erwarten, ein Knotenprogramm.

72
00:05:37,500 --> 00:05:40,940
Dies ermöglicht es uns, End-to-End-Tests durchzuführen.

73
00:05:40,940 --> 00:05:45,510
So führt Winkelmesser die Tests gegen Ihre Anwendung aus.

74
00:05:45,510 --> 00:05:49,800
So lädt Protractor Ihre Anwendung in einen Browser und interagiert mit

75
00:05:49,800 --> 00:05:54,570
der Anwendung genau wie ein echter Benutzer mit Ihrer Anwendung interagiert.

76
00:05:54,570 --> 00:05:59,160
Wir betrachten also die Interaktion mit Ihrer Anwendung,

77
00:05:59,160 --> 00:06:03,410
obwohl programmgesteuert, aber die Art von Operationen, die

78
00:06:03,410 --> 00:06:07,500
ein typischer Benutzer ausführen wird, wie Klicken auf Links, Ausfüllen von Formularen.

79
00:06:07,500 --> 00:06:13,110
Absenden von Formularen, Navigieren zu verschiedenen Teilen Ihrer Anwendung und so weiter.

80
00:06:13,110 --> 00:06:18,310
Dies ist, wo Protractor nutzt die Verwendung eines WebDriver, um

81
00:06:18,310 --> 00:06:23,980
Browser zu steuern, auf denen die Tests durchgeführt werden können.

82
00:06:23,980 --> 00:06:27,570
Ein solches App-Framework wird als Selenium Framework bezeichnet,

83
00:06:27,570 --> 00:06:31,720
das für automatisierte Tests in Browsern verwendet wird.

84
00:06:31,720 --> 00:06:36,021
Wenn Sie Chrome als Teil Ihrer Teststrategie oder Firefox

85
00:06:36,021 --> 00:06:39,119
verwenden, können Sie eine sogenannte direkte Verbindung verwenden.

86
00:06:39,119 --> 00:06:43,502
Das ist über einen Winkelmesser verfügbar, um direkt mit diesen Browsern zu verbinden und

87
00:06:43,502 --> 00:06:45,828
Tests in diesen Browsern durchzuführen.

88
00:06:45,828 --> 00:06:50,273
Nun nutzen die Tests selbst den Anpassungsrahmen, um

89
00:06:50,273 --> 00:06:51,790
den Test auszudrücken.

90
00:06:51,790 --> 00:06:55,450
Sie würden also immer noch sehen,

91
00:06:55,450 --> 00:06:58,810
dass der Benutzer einen int beschreibt und vor jedem, den Sie mit Komponententests gesehen haben.

92
00:06:58,810 --> 00:07:04,332
Abgesehen davon, dass wir jetzt die Winkelmesser Unterstützung nutzen,

93
00:07:04,332 --> 00:07:09,119
um echte benutzerähnliche Interaktionen mit unserer

94
00:07:09,119 --> 00:07:11,157
Anwendung mithilfe von Code generieren zu können.

95
00:07:11,157 --> 00:07:15,363
Das ist also, was wir in der Übung lernen werden, die diesem speziellen

96
00:07:15,363 --> 00:07:15,979
Vortrag folgt.

97
00:07:15,979 --> 00:07:21,324
Wir werden Winkelmesser nutzen und unsere End-to-End-Teststrategien schreiben.

98
00:07:21,324 --> 00:07:24,815
Und natürlich nutzen Sie die Angular CLI-Unterstützung für die

99
00:07:24,815 --> 00:07:29,983
Durchführung von End-to-End-Tests in der Übung, die dieser Vorlesung folgt.

100
00:07:29,983 --> 00:07:32,969
( MUSIK)