1
00:00:00,330 --> 00:00:01,260
Y qué pasa con el salto?

2
00:00:01,350 --> 00:00:02,310
También lo tenemos que probar.

3
00:00:02,430 --> 00:00:03,330
Igual que el nombre.

4
00:00:03,420 --> 00:00:04,600
Vamos a crear un método.

5
00:00:04,650 --> 00:00:11,670
Pero antes con alguno vamos a ampliar el editor, es decir, vamos a ocultar la pestaña Proyecto y dejamos

6
00:00:11,670 --> 00:00:12,480
pantalla completa.

7
00:00:12,780 --> 00:00:14,020
Bien, lo primero, crear.

8
00:00:14,160 --> 00:00:18,010
Bueno, este método siempre tenemos que notar Context para indicar.

9
00:00:18,090 --> 00:00:21,180
Es cierto que es un método que vamos a ejecutar como una tarea.

10
00:00:21,360 --> 00:00:24,120
Entonces texto bajamos.

11
00:00:24,360 --> 00:00:25,890
Voy yo.

12
00:00:25,920 --> 00:00:28,110
Nombre método test, por ejemplo.

13
00:00:28,230 --> 00:00:29,070
sĂłlo cuenta.

14
00:00:29,960 --> 00:00:38,870
Test saldo cuenta bajamos bien y tenemos que crear la instancia de cuenta con los input, con los datos

15
00:00:38,870 --> 00:00:39,420
de ejemplo.

16
00:00:39,540 --> 00:00:45,470
Bueno, podemos utilizar el mismo la cuenta Andrés con el bit decimal, con el saldo del mismo que tenemos

17
00:00:45,710 --> 00:00:51,740
bienpero utilizando intelige podemos hacer lo siguiente Por ejemplo, en vez de escribir cuenta como

18
00:00:51,740 --> 00:00:54,440
tipo dato cierto y la variable cuenta igual.

19
00:00:54,530 --> 00:00:57,620
New cuenta podemos colocar simplemente new cuenta

20
00:01:00,020 --> 00:01:07,280
con Andrés Coma bit decimal el salto New Princess Liman.

21
00:01:10,180 --> 00:01:14,240
Con el string, con el valor élmismo exactamente igual 1000 koma.

22
00:01:14,350 --> 00:01:19,030
Pero bueno, usamos el punto 1 2 3 4 5 exactamente el mismo.

23
00:01:19,340 --> 00:01:23,300
Bien, entonces sobre cuenta el tipo dato la clase.

24
00:01:23,590 --> 00:01:26,230
Entonces me voy a ir a cuenta por acá.

25
00:01:26,920 --> 00:01:32,920
Acá de vejan sobre cuenta sobre esta clase vamos a colocar control alt corta.

26
00:01:33,400 --> 00:01:35,980
Automáticamente se crea el objeto con el tipo.

27
00:01:36,130 --> 00:01:37,420
Se declara no cierto.

28
00:01:37,420 --> 00:01:41,620
Se define la variable cuenta y colocamos cuenta.

29
00:01:41,780 --> 00:01:42,640
Dirigiéramos cuenta.

30
00:01:42,680 --> 00:01:43,210
Perfecto.

31
00:01:43,330 --> 00:01:44,370
Entelequias tenemos.

32
00:01:44,800 --> 00:01:44,940
Bien.

33
00:01:45,010 --> 00:01:48,820
Ahora tengo que probar utilizando acerto y cuáles

34
00:01:51,550 --> 00:01:54,880
hacer y cuales vamos a afirmar un valor esperado.

35
00:01:55,120 --> 00:02:02,050
El mismo vamos a colocar 1000 pero de la literal double como número, no como string 1000.

36
00:02:02,150 --> 00:02:04,570
Punto 1 2, 3, 4 5.

37
00:02:05,050 --> 00:02:12,780
Ese es el nuestro valor esperado y lo vamos a comparar con el valor convertido a un double del big decimal.

38
00:02:13,060 --> 00:02:14,020
Entonces cuenta.

39
00:02:14,890 --> 00:02:15,550
Punto.

40
00:02:15,690 --> 00:02:18,520
Guet, salto, punto.

41
00:02:18,610 --> 00:02:23,370
Y acá buscamos double valeo doble alío.

42
00:02:23,560 --> 00:02:29,830
Entonces lo que hace bueno salto del tipo bit decimal lo convertimos a un tipo double y lo comparamos

43
00:02:29,830 --> 00:02:31,340
con la literal double.

44
00:02:31,540 --> 00:02:34,270
Por eso colocamos 1000 punto uno, dos, tres, cuatro, cinco.

45
00:02:34,960 --> 00:02:35,740
Veamos, es igual.

46
00:02:36,220 --> 00:02:37,550
Si pasa la prueba, está perfecto.

47
00:02:37,750 --> 00:02:40,390
Entonces, con control Schiff F10 ejecutamos.

48
00:02:42,000 --> 00:02:46,500
Acá están ejecutando solamente el método en cuestión, se fijan saldo, cuenta.

49
00:02:47,190 --> 00:02:53,700
No estamos ejecutando 3 nombre cuenta si no esté acá y es porque cuando ejecutamos tenemos el click,

50
00:02:53,820 --> 00:02:55,500
hicimos click dentro el método.

51
00:02:56,380 --> 00:02:57,550
Bueno, de otra forma pasó.

52
00:02:57,640 --> 00:03:02,440
Ahora, si queremos ejecutar la clase completa, bueno, hacemos un clic en cualquier parte, fuera

53
00:03:02,440 --> 00:03:04,690
del método, dentro de la clase.

54
00:03:04,720 --> 00:03:09,940
Por ejemplo acá y lo mismo cheff control F10 y va ejecutar todo.

55
00:03:10,030 --> 00:03:14,890
Toda la clase cuenta test y acá aparece de sĂłlo cuenta test nombre quanta.

56
00:03:14,980 --> 00:03:18,190
Los dos métodos y los dos se fijan tests.

57
00:03:18,280 --> 00:03:19,710
Han pasado dos de dos.

58
00:03:19,810 --> 00:03:20,580
Está todo correcto.

59
00:03:21,580 --> 00:03:24,550
Acá ejecuta según un orden que determinista.

60
00:03:24,880 --> 00:03:32,950
Pero eso lo determina de forma automática, según un criterio propio que maneja el motor de test de

61
00:03:33,100 --> 00:03:38,770
unit del test en Yeung, no a ejecutar en un orden alfabético, ni tampoco el orden en que se definen

62
00:03:38,770 --> 00:03:42,010
los métodos en la clase no completamente determinista.

63
00:03:42,550 --> 00:03:45,280
Y tampoco tiene ninguna importancia para nuestra prueba.

64
00:03:45,370 --> 00:03:50,470
En realidad, lo que estamos acá probando son piezas de código que están completamente separadas.

65
00:03:50,530 --> 00:03:55,810
Independiente no hay ninguna relación una con otra y es un principio bien importante en pro unitaria.

66
00:03:55,930 --> 00:04:01,180
La idea es que en nuestra pieza de código que vamos a probar, no esté relacionado con el resto.

67
00:04:01,330 --> 00:04:06,580
El resto de nuestro código sea completamente independiente y por eso también el orden no es importante.

68
00:04:06,730 --> 00:04:07,720
Claro, podríamos pensar.

69
00:04:07,810 --> 00:04:08,050
Claro.

70
00:04:08,050 --> 00:04:13,690
Yo quiero primero ejecutar un método test que genere algún atributo, que asigne algún valor, algún

71
00:04:13,690 --> 00:04:15,460
atributo, la clase no cierto.

72
00:04:15,640 --> 00:04:19,900
Y después en otro método que se ejecute más adelante, poder utilizar ese dolor.

73
00:04:20,110 --> 00:04:25,900
Es decir, que la clase test maneje un estado en la instancia de nuestra preguntaria.

74
00:04:26,050 --> 00:04:27,100
Y en realidad no es así.

75
00:04:27,280 --> 00:04:28,870
No debiese manejar estados.

76
00:04:28,960 --> 00:04:30,820
Tiene que ser sin estado.

77
00:04:30,910 --> 00:04:37,090
Staines y los métodos unos con otros que estamos probando no tengan nada que ver que no estén relacionados.

78
00:04:37,330 --> 00:04:43,600
Ahora, de toda forma de hecho kaikki se ejecuta un método de la clase test cuenta test.

79
00:04:43,780 --> 00:04:45,340
En realidad es una instancia distinta.

80
00:04:45,340 --> 00:04:48,760
Se crea una instancia distinta de cuenta test para ejecutar este método.

81
00:04:48,760 --> 00:04:55,530
Después, cuando se ejecuta de saldo por debajo en la plataforma de unit en el test engine también se

82
00:04:55,550 --> 00:04:58,630
a crear una instancia distinta a la primera.

83
00:04:58,720 --> 00:05:04,240
Con este método, entonces se crea otra instancia para ejecutar este otro método y es así como funciona

84
00:05:04,240 --> 00:05:05,140
el ciclo de vida.

85
00:05:05,320 --> 00:05:07,390
Por lo tanto cada instancia se distinta.

86
00:05:07,390 --> 00:05:12,970
Si acá asigno un atributo es atributo de la clase, no va a tener un valor.

87
00:05:13,060 --> 00:05:18,100
Cuando se ejecute este método, no va a tener una referencia de que son instancia diferente.

88
00:05:18,280 --> 00:05:21,070
Bueno, después vamos a ver todo lo que es el ciclo de vida.

89
00:05:21,550 --> 00:05:26,410
Lo importante por ahora, saber y tener claro que el orden era lo mismo de otra forma igual después

90
00:05:26,410 --> 00:05:28,480
vamos a ver cómo ordenar los métodos.

91
00:05:28,600 --> 00:05:35,620
Por ejemplo, si queremos organizar y que se vean visualmente ordenada, ya sea utilizando el nombre

92
00:05:35,620 --> 00:05:43,060
método y que ordene de forma alfabética o utilizando la anotación order, también con un número, le

93
00:05:43,060 --> 00:05:44,170
podemos dar un orden.

94
00:05:44,400 --> 00:05:47,320
En fin, hay diferentes métodos y formas.

95
00:05:47,740 --> 00:05:48,370
Continuamos.

96
00:05:48,560 --> 00:05:51,100
Ahora, qué pasa si quiero tener otra prueba?

97
00:05:51,550 --> 00:05:52,600
Una regla de negocio?

98
00:05:52,810 --> 00:05:54,730
Por ejemplo hacer fours?

99
00:05:55,630 --> 00:05:57,190
Vamos a colocar acerte fols.

100
00:05:58,830 --> 00:06:04,140
Bueno, por supuesto que acá espera una condición booleana, una expresión booleana va a comprar algo.

101
00:06:04,260 --> 00:06:06,660
La idea que es algo, devuelve fols.

102
00:06:06,810 --> 00:06:11,670
Por ejemplo, quiero afirmar y me quiero asegurar de que el saldo nunca sea negativo, puede ser cero

103
00:06:11,670 --> 00:06:14,490
si puede ser cero o mayor que cero, pero jamás negativo.

104
00:06:14,580 --> 00:06:20,190
Si esta condición que vamos a escribir es falsa, estaría perfecto, cuenta.

105
00:06:20,210 --> 00:06:22,110
Punto Getz saldo.

106
00:06:22,860 --> 00:06:23,940
Acá lo tenemos bien.

107
00:06:24,150 --> 00:06:26,250
Saldo es del tipo bit decimal.

108
00:06:26,430 --> 00:06:27,540
Es un objeto de referencia.

109
00:06:27,540 --> 00:06:31,560
No es un entero, no es un punto flotante, un doble, un float.

110
00:06:31,770 --> 00:06:38,760
Por lo tanto, no podemos comparar con esto de acá, es decir, que sea mayor que o que sea menor que

111
00:06:38,910 --> 00:06:39,600
en este caso.

112
00:06:39,840 --> 00:06:45,540
Me gustaría comprar con esto, que no se cumpla, que sea falso, que 0 sea mayor que el salto, se

113
00:06:45,540 --> 00:06:45,930
fijan.

114
00:06:46,260 --> 00:06:49,610
Eso es lo que quiero comparar, pero utilizando bit decimal.

115
00:06:50,310 --> 00:06:51,150
Esto no me sirve.

116
00:06:51,180 --> 00:06:59,040
Entonces punto bit decimal lo comparamos con el comparto, comparto ahora este método compar tu devuelve

117
00:06:59,160 --> 00:07:02,520
un entero no cierto que puede ser menor, cero o uno.

118
00:07:02,610 --> 00:07:03,380
Ahora lo vamos a ver.

119
00:07:03,600 --> 00:07:09,380
Lo comparamos con un cero, pero no es un cero numérico, no es un cero del tipo bit decimal.

120
00:07:09,510 --> 00:07:15,830
Entonces claro, podemos crear la instancia new bit decimal y le pasamos el cero en el constructor de

121
00:07:15,840 --> 00:07:18,150
C del tipo String o el tipo entero.

122
00:07:18,240 --> 00:07:22,930
O bien podemos utilizar la constante Big decimal punto cero.

123
00:07:23,040 --> 00:07:23,670
Ahí la tenemos.

124
00:07:23,720 --> 00:07:30,840
Entonces, esta constante cero de la clase bit decimal devuelve un cero bit decimal y lo comparamos.

125
00:07:31,890 --> 00:07:36,000
Entonces, que sea falso, que cero es mayor que el salto.

126
00:07:36,750 --> 00:07:40,580
Entonces acá colocamos menor que cero, es decir, que cero sea mayor que acá.

127
00:07:40,710 --> 00:07:45,090
Esta expresión ahora, por qué esto es compar tú?

128
00:07:45,420 --> 00:07:48,960
El tú puede volver menos uno, cero o uno.

129
00:07:49,470 --> 00:07:54,120
Cuando es negativo menor que uno, significa que el salto es menor que cero.

130
00:07:54,360 --> 00:07:58,920
O dicho de otra forma, que bit décimas cero es mayor que el salto.

131
00:07:59,140 --> 00:08:00,540
Ahí devuelve menos uno.

132
00:08:00,840 --> 00:08:02,460
Entonces, si fuese así.

133
00:08:02,760 --> 00:08:08,890
Es decir, si cero es mayor que el salto perfecto, devuelve menos uno y lo compran con cero cero en

134
00:08:08,950 --> 00:08:10,200
mallorquin menos uno.

135
00:08:10,350 --> 00:08:12,180
Trum va a devolver un truco.

136
00:08:12,450 --> 00:08:14,700
Por lo tanto, acá esperamos un FOLS.

137
00:08:14,790 --> 00:08:21,240
Y va a fallar nuestra prueba, lo que afirma que el salto en negativo es menor que cero y nuestra prueba

138
00:08:21,240 --> 00:08:21,750
no pasa.

139
00:08:21,990 --> 00:08:24,960
Ahora, si el saldo es mayor, entonces va a devolver uno.

140
00:08:25,080 --> 00:08:27,210
Se fijan un número positivo uno.

141
00:08:27,360 --> 00:08:30,660
Si el saldo es mayor que cero, uno es menor que cero.

142
00:08:30,750 --> 00:08:32,640
No, por supuesto que no es mayor que cero.

143
00:08:32,970 --> 00:08:37,740
Entonces, al ser mayor que cero, esta expresión no se cumple y es falsa al ser falsa.

144
00:08:37,860 --> 00:08:41,610
Afirmamos que sea falsa y se cumple la prueba unitaria.

145
00:08:41,790 --> 00:08:45,030
Por lo tanto, el saldo no sería menor que cero, sería mayor que cero.

146
00:08:45,150 --> 00:08:46,470
Y es justamente lo que queremos probar.

147
00:08:47,130 --> 00:08:47,790
Punto, Ikoma.

148
00:08:48,020 --> 00:08:53,460
Bueno, por supuesto, el saldo que lo tenemos como mil puntos y algo vamos a probar, pero vamos a

149
00:08:53,460 --> 00:08:54,840
probar la clase entera.

150
00:08:55,320 --> 00:08:58,470
Hacemos un clic fuera de la clase y control Cheff F10.

151
00:09:01,030 --> 00:09:01,690
Paso la prueba.

152
00:09:02,090 --> 00:09:05,570
Entonces se cumple esta torre y la de negocio primero.

153
00:09:05,590 --> 00:09:13,870
Un valor esperado con el valor real o actual llega una regla que el saldo tiene que ser mayor que cero.

154
00:09:14,140 --> 00:09:16,690
Ahora, qué pasa si colocamos menor acá Menorca?

155
00:09:16,840 --> 00:09:17,560
Ejecutamos?

156
00:09:20,460 --> 00:09:21,870
Falla, falla esta prueba.

157
00:09:22,090 --> 00:09:23,760
Bueno, Akagi Gutié en el método.

158
00:09:23,850 --> 00:09:26,520
En realidad voy a ejecutar fuera del método.

159
00:09:27,860 --> 00:09:32,930
Pero si pasa el nombre nombre cuéntate correcto, es decir, esta prueba que tenemos acá pasa sin ningún

160
00:09:32,930 --> 00:09:33,920
problema, pero falla.

161
00:09:33,980 --> 00:09:38,150
Esta de acá se fija, entonces falla una y pasa una.

162
00:09:38,270 --> 00:09:41,120
Y acá probamos que el saldo no puede ser negativo.

163
00:09:41,210 --> 00:09:42,460
Entonces cuanto negativo?

164
00:09:42,530 --> 00:09:47,300
Bueno, podríamos hacer algún tipo de decepción, algún error en nuestro código.

165
00:09:47,360 --> 00:09:52,100
Bueno, después vamos a ver manejo decepción utilizando pruebas unitarias también como una regla de

166
00:09:52,100 --> 00:09:54,860
negocio, entonces lo vamos a quitar para que esté bien.

167
00:09:55,130 --> 00:09:57,890
De hecho, esto que tenemos acá sería lo mismo.

168
00:09:58,190 --> 00:10:01,650
Voy a copiar, bajamos y pegamos.

169
00:10:01,790 --> 00:10:07,280
Bueno, sería exactamente igual a colocar en vez de menor, con más mayor.

170
00:10:07,940 --> 00:10:09,800
Es decir, que esto sea mayor que cero.

171
00:10:10,130 --> 00:10:12,230
Cuando el salto sea mayor que cero.

172
00:10:12,350 --> 00:10:15,440
Si salto mayor que cero acá es uno, uno es mayor que cero.

173
00:10:15,470 --> 00:10:16,040
Perfecto.

174
00:10:17,330 --> 00:10:18,710
Acá cambiamos en vez de fols.

175
00:10:18,740 --> 00:10:22,250
True es exactamente lo mismo.

176
00:10:22,530 --> 00:10:23,060
Fols.

177
00:10:23,450 --> 00:10:24,140
Pero cambiamos.

178
00:10:24,140 --> 00:10:28,720
Acá damos vuelta la casilla menor y acá sería mayor, ya casi fols.

179
00:10:28,880 --> 00:10:29,720
Y ya casi teatro.

180
00:10:29,930 --> 00:10:36,440
Pero en el fondo estamos peleando exactamente lo mismo con la lógica inversa si esto lo ejecutamos por

181
00:10:36,440 --> 00:10:37,040
acá afuera.

182
00:10:39,990 --> 00:10:40,680
Pasa la prueba.

183
00:10:40,970 --> 00:10:45,900
Bien, a partir de la siguiente clase vamos a ver un poco desarrollo orientado, pruebas unitarias,

184
00:10:46,020 --> 00:10:49,930
es decir, lo que se le conoce como test driven development.

185
00:10:50,130 --> 00:10:53,130
Bueno, orientado a pruebas o desarrollo.

186
00:10:53,130 --> 00:10:55,470
Guiados a pruebas, que es una técnica.

187
00:10:55,560 --> 00:10:59,340
Desarrollo de aplicaciones de software que involucra dos partes.

188
00:10:59,340 --> 00:11:02,580
Primero, escribir primero las pruebas unitarias, no cierto.

189
00:11:02,610 --> 00:11:06,600
Primero escribimos nuestros test y después implementamos el código.

190
00:11:06,750 --> 00:11:10,770
Después, mediante refactorización, implementamos los METHOS.

191
00:11:10,830 --> 00:11:12,600
Entonces, primero nuestras pruebas.

192
00:11:12,690 --> 00:11:13,740
Bueno, primero el método.

193
00:11:13,830 --> 00:11:16,620
Sin nada, sin ningún tipo de código algoritmo.

194
00:11:16,770 --> 00:11:17,400
Lo probamos.

195
00:11:17,460 --> 00:11:18,480
Obviamente va a fallar.

196
00:11:18,660 --> 00:11:20,700
Y después escribimos el código.

197
00:11:20,820 --> 00:11:26,490
Implementamos la lógica negocio, el algoritmo que necesite, el cálculo o lo que sea, lo que tenga

198
00:11:26,490 --> 00:11:26,880
que hacer.

199
00:11:27,000 --> 00:11:31,920
Y después volvemos a probar hasta que afirme el valor y pase la pro.

200
00:11:32,370 --> 00:11:37,800
Y eso es lo que vamos a empezar a hacer crear métodos, probar y después implementar ese método y volver

201
00:11:37,800 --> 00:11:42,300
a probar que nuestro desarrollo siempre esté orientado a pruebas unitarias.

202
00:11:42,420 --> 00:11:44,220
Continuamos en la siguiente clase.