1
00:00:00,210 --> 00:00:07,250
Bien, comencemos con un ejemplo bien simple de Test Driven de valo mento TDD orientado a proas unitaria.

2
00:00:07,370 --> 00:00:13,710
Bueno, la idea crear una nueva prueba, pero comparando los dos objetos cuenta que tengan los mismos

3
00:00:13,770 --> 00:00:19,740
input, es decir, mismos datos de ejemplo 2 objeto y comparar si realmente estas referencias son iguales,

4
00:00:19,800 --> 00:00:25,470
porque por defecto, cuando se comparan dos objetos con el método equals, compara por referencia,

5
00:00:25,710 --> 00:00:32,520
es decir, que sean diferentes instancias, diferente objeto, cada uno en distintos punteros o direcciones

6
00:00:32,610 --> 00:00:35,160
en la memoria que no sea la misma referencia.

7
00:00:35,280 --> 00:00:40,740
Pero podría modificar este comportamiento y comparar por valor en vez de por referencia y comparar,

8
00:00:40,740 --> 00:00:48,270
por ejemplo, por los atributos que si el atributo persona sean iguales o del salios en iguales, entonces

9
00:00:48,330 --> 00:00:54,750
los objetos sean iguales o sean considerados como iguales, pero van a ser objeto distinto almacenado

10
00:00:54,840 --> 00:00:57,510
en diferentes direcciones de la memoria.

11
00:00:57,610 --> 00:01:02,730
Bien, comencemos entonces vamos a crear otro método, pero esta vez, en vez de hacerlo manual, vamos

12
00:01:02,730 --> 00:01:09,300
a hacer con Alt Insert Test Método, lo seleccionamos y lo creamos.

13
00:01:09,360 --> 00:01:09,750
Cierto?

14
00:01:09,900 --> 00:01:13,590
Lo vamos a renombrar, vamos a colocar text referencia de Quanta.

15
00:01:17,900 --> 00:01:21,410
Bajamos y vamos a crear dos instancias idénticas.

16
00:01:22,310 --> 00:01:23,120
Cuenta.

17
00:01:23,300 --> 00:01:26,240
Bueno, de hecho, para simplificar New Cuenta.

18
00:01:27,570 --> 00:01:38,550
Creamos el objeto, pasamos, por ejemplo, a John John Doe como persona Goma New Birth Décima le pasamos

19
00:01:38,550 --> 00:01:45,420
a Salto, por ejemplo ocho mil novecientos coma nueve nueve nueve siete por proponer algo de esto.

20
00:01:45,630 --> 00:01:47,520
Ahí tenemos, vamos a crear el objeto.

21
00:01:47,880 --> 00:01:55,690
Entonces por acá sobre cuenta control alt recortà hoy tenemos cuenta Johnno en.

22
00:01:56,160 --> 00:01:56,790
Bajamos.

23
00:01:57,030 --> 00:02:02,970
Bueno, de hecho la vamos a replicar simplemente con Controlde en cualquier parte de la línea de cuenta

24
00:02:03,150 --> 00:02:04,890
controlde y la replicamos.

25
00:02:05,160 --> 00:02:07,500
Y acá colocamos cuenta dos y tenemos dos.

26
00:02:07,500 --> 00:02:09,990
Cuenta que en teoría son exactamente iguales.

27
00:02:10,320 --> 00:02:12,150
Eso es lo que tienen que probar en un principio.

28
00:02:12,180 --> 00:02:14,280
Quizás nuestra lógica negocio sea correcto.

29
00:02:14,580 --> 00:02:16,530
Si no son iguales, pasa la prueba.

30
00:02:16,680 --> 00:02:21,330
Entonces vamos a colocar assert, pero en vez de equals vamos a colocar потом.

31
00:02:21,480 --> 00:02:23,600
Y cual es perfecto?

32
00:02:23,910 --> 00:02:25,290
Y cuál cuenta?

33
00:02:25,470 --> 00:02:33,150
Acá pasamos dos valores que si compramos dos referencia, cuenta y cuenta dos, es decir, cuenta o

34
00:02:33,150 --> 00:02:33,870
cuenta dos.

35
00:02:34,230 --> 00:02:37,500
Vamos, a lo mejor cuenta acá y acá, cuenta donde cuenta.

36
00:02:37,500 --> 00:02:43,920
Sería nuestro valor real o actual este objeto y esto sería nuestro valor esperado.

37
00:02:44,550 --> 00:02:51,330
Entonces queremos comprar que todos sean distintos en diferentes instancias y por defecto debería ser

38
00:02:51,330 --> 00:02:51,630
así.

39
00:02:51,750 --> 00:02:53,190
No son iguales de RS.

40
00:02:53,190 --> 00:02:53,790
Correcto.

41
00:02:53,970 --> 00:02:59,940
Se debiese afirmar entonces vamos a ejecutar como siempre con control Schiff F10.

42
00:03:02,740 --> 00:03:04,540
Y tenemos los tres métodos correcto.

43
00:03:04,640 --> 00:03:08,460
Se fijan a que tenemos test, referencia, cuenta y paso la prueba.

44
00:03:09,070 --> 00:03:09,730
No hay ningún problema.

45
00:03:10,090 --> 00:03:12,430
Pero qué pasa si cambia la regla negocio ahora?

46
00:03:12,460 --> 00:03:13,480
Ahora quiere comparar.

47
00:03:13,630 --> 00:03:14,680
No por referencia.

48
00:03:14,860 --> 00:03:17,500
Es decir, no por instancia, porque son dos ajito distinto.

49
00:03:17,920 --> 00:03:19,280
Quiero comparar por valor.

50
00:03:19,460 --> 00:03:20,910
Entonces tendré que cambiar acá.

51
00:03:21,040 --> 00:03:21,700
Está acá.

52
00:03:21,790 --> 00:03:23,740
Lo podríamos comentar o lo duplicamos?

53
00:03:23,740 --> 00:03:25,930
Mejor control de lo duplicamos.

54
00:03:26,410 --> 00:03:27,990
Acá lo comentamos para que lo tengamos.

55
00:03:28,000 --> 00:03:29,970
Control diagonal o se large.

56
00:03:30,100 --> 00:03:31,810
Comentamos y acá cambiamos.

57
00:03:32,140 --> 00:03:35,680
En vez de Nott colocamos y cuando llega cambia un poco.

58
00:03:35,800 --> 00:03:36,660
Cambia nuestro test.

59
00:03:37,250 --> 00:03:43,330
Entonces deberían ser iguales ahora, pero como estamos desarrollando orientado pruebas unitaria, va

60
00:03:43,330 --> 00:03:43,720
a fallar.

61
00:03:43,900 --> 00:03:51,350
Después lo tenemos que implementar o refactorizar nuestro código para que esto sea correcto, sea válido.

62
00:03:51,730 --> 00:03:52,720
Entonces vamos a probar.

63
00:03:54,010 --> 00:03:54,550
Va a fallar.

64
00:03:55,650 --> 00:03:57,210
Se fijan, falla este método?

65
00:03:57,270 --> 00:03:57,750
Por qué?

66
00:03:57,780 --> 00:03:59,110
Claro, porque son dos instancias.

67
00:03:59,130 --> 00:04:03,540
Tinta Este apunta a un puntero en la memoria distinto que el de acá.

68
00:04:03,570 --> 00:04:05,250
Son dos objetos diferentes.

69
00:04:05,310 --> 00:04:09,120
A pesar de que tienen el mismo valor en sus atributos, pero actualmente son distintos.

70
00:04:09,240 --> 00:04:10,740
Y eso es lo que tenemos que refactorizar.

71
00:04:10,980 --> 00:04:12,690
La idea de que sean iguales.

72
00:04:12,960 --> 00:04:14,760
Compare por valor cómo lo podemos hacer.

73
00:04:14,820 --> 00:04:16,680
Bueno, vamos a cerrar acá.

74
00:04:16,710 --> 00:04:17,460
Cerramos.

75
00:04:17,550 --> 00:04:19,020
Nos vamos a ir a la clase.

76
00:04:19,020 --> 00:04:23,630
Cuenta con control y acá tengo que implementar el método equals.

77
00:04:24,000 --> 00:04:25,410
Sobrescribir el y cuál?

78
00:04:25,770 --> 00:04:26,880
Pero intelige.

79
00:04:26,940 --> 00:04:33,750
Bueno, lo podemos hacer manualmente comparando estos atributos en persona y salto al insert.

80
00:04:33,960 --> 00:04:40,450
Acá sobrescribir método se fijan una forma sobreescribir el método y cual es perfecto.

81
00:04:40,950 --> 00:04:44,100
Acá compara por defecto, por objeto, por instancias.

82
00:04:44,490 --> 00:04:47,970
Pero la idea de comparar por atributos persona y salto.

83
00:04:48,330 --> 00:04:53,550
Entonces podríamos hacer lo siguiente lo primero hacer un cast a este objeto que se esta pasando, que

84
00:04:53,550 --> 00:04:55,320
es el cual con el que comparamos.

85
00:04:55,560 --> 00:04:57,490
Entonces lo primero acá hacer el cast.

86
00:04:57,840 --> 00:05:06,990
Ahora si el tipo cuenta le vamos a llamar se de cuenta igual objeto punto y coma bien, pero marca error

87
00:05:07,050 --> 00:05:08,190
porque tenemos que hacer el cast.

88
00:05:08,370 --> 00:05:14,910
Entonces acá con los paréntesis cerramos paréntesis y dentro cuenta se fijan, tenemos cuenta.

89
00:05:14,970 --> 00:05:19,500
Ahora comparamos a qué tengo que validar primero validar por ejemplo, que personas sea distinto null

90
00:05:19,560 --> 00:05:22,530
y que el saldo también sea distinto, nulo y luego compare con el.

91
00:05:23,250 --> 00:05:32,760
Entonces, por ejemplo, if this punto persona si es igual a null si es igual a null or colocábamos

92
00:05:32,880 --> 00:05:35,220
double pay saldo es igual a null.

93
00:05:38,010 --> 00:05:41,890
Entonces te devolvemos fols proton olds.

94
00:05:42,750 --> 00:05:43,530
No son iguales.

95
00:05:43,620 --> 00:05:47,010
Tenemos que comprar siempre que los atributos primero si son null.

96
00:05:47,190 --> 00:05:48,000
Devolvemos fors.

97
00:05:48,060 --> 00:05:49,140
Por lo tanto no son iguales.

98
00:05:49,500 --> 00:05:54,810
Ah, y también tenemos que comparar que tu objeto acá, que se pasa por referencia en el método por

99
00:05:54,810 --> 00:05:55,470
argumento.

100
00:05:55,530 --> 00:06:00,390
También tengo que comparar porque teme pudiera ser nulo y podríamos tener algún tipo de problema entonces.

101
00:06:00,480 --> 00:06:00,780
If.

102
00:06:01,920 --> 00:06:08,090
Objeto si es igual a Anul, bajamos, también devolvemos fols.

103
00:06:09,930 --> 00:06:10,450
Fols.

104
00:06:11,370 --> 00:06:14,130
Eso es primero validar que el objeto sea igual a null.

105
00:06:14,250 --> 00:06:18,520
Devolvemos fours, luego los atributos, pero de la misma clase en cuestión.

106
00:06:18,540 --> 00:06:20,370
Persona y lo que vamos a comparar.

107
00:06:20,750 --> 00:06:24,800
Bueno, hacemos el caso y ahora comparamos, ya que tenemos todo validado.

108
00:06:24,870 --> 00:06:30,780
Comparamos esto, lo quitamos, lo quitamos y lo vamos a cambiar por lo siguiente una prisión booleana

109
00:06:30,900 --> 00:06:33,870
no es cierto si persona o persona.

110
00:06:34,110 --> 00:06:36,300
Luego acabo con dispen que esté un poco más explícito.

111
00:06:36,630 --> 00:06:37,350
Persona.

112
00:06:37,630 --> 00:06:38,450
Punto igual.

113
00:06:39,600 --> 00:06:45,570
Si es igual al atributo del objeto con el cuerpo, vamos a comparar en el equals objeto o C en realidad.

114
00:06:45,600 --> 00:06:46,890
Porque en realidad es cuenta.

115
00:06:47,020 --> 00:06:52,380
Acá decimos el cast cuenta c punto quiete persona.

116
00:06:52,500 --> 00:06:58,530
Entonces compráramos persona con persona y el atributo persona de la clase con el atributo persona del

117
00:06:58,530 --> 00:07:00,240
otro objeto de la instancia.

118
00:07:00,600 --> 00:07:05,190
No sé si es igual esto perfecto, pero te temo que comparar con el saldo.

119
00:07:05,220 --> 00:07:06,300
Si ambos son iguales.

120
00:07:06,730 --> 00:07:08,160
Pensando lo mismo.

121
00:07:08,160 --> 00:07:09,900
Diez diez.

122
00:07:10,140 --> 00:07:11,610
Punto saldo.

123
00:07:12,060 --> 00:07:14,940
El atributo saldo del objeto en cuestión.

124
00:07:15,210 --> 00:07:15,660
Punto.

125
00:07:15,720 --> 00:07:17,760
Y con el saldo del otro objeto.

126
00:07:17,880 --> 00:07:19,440
C Punto.

127
00:07:19,710 --> 00:07:20,450
Get saldo.

128
00:07:20,880 --> 00:07:21,450
Get saldo.

129
00:07:21,600 --> 00:07:24,650
Entonces, si todo esto se cumple, perfecto, devolvemos true.

130
00:07:24,900 --> 00:07:29,700
Pero si llega a fallar cualquiera de estas validaciones va a devolver fols.

131
00:07:29,940 --> 00:07:30,750
Y no va a ser igual.

132
00:07:31,230 --> 00:07:35,730
Incluso también podríamos hacer otra validación que el objeto que se está pasando por instancia acá,

133
00:07:35,820 --> 00:07:39,360
sea del tipo cuenta y no de otro tipo de clase.

134
00:07:39,610 --> 00:07:42,390
Eso también lo podríamos hacer acá con un OR, por ejemplo.

135
00:07:42,480 --> 00:07:46,920
Bueno, si es igual a null or y si es distinto, así que lo voy a negar.

136
00:07:47,220 --> 00:07:56,940
Es decir, si no es tipo de paréntesis y acá objeto instanceof de cuenta en cuenta y listo.

137
00:07:57,190 --> 00:07:59,560
Esto de acá también valida que se anule.

138
00:07:59,730 --> 00:08:06,500
De hecho, calidá lo dice condición objeto igual a null también está cubierto o validado por esta condición.

139
00:08:06,810 --> 00:08:08,370
Entonces, de hecho, esto acá estaría.

140
00:08:08,370 --> 00:08:11,550
Además, lo podemos dejar, sí, pero también está demás.

141
00:08:11,940 --> 00:08:16,220
Entonces valíamos que el objeto se instancia aguanta no solamente un objeto nulo.

142
00:08:16,830 --> 00:08:21,780
Validar, por ejemplo, que no nos pasen un string, por ejemplo, o qué tipo de otra clase.

143
00:08:22,230 --> 00:08:27,660
Listo, ya tenemos el método equals y estamos comparando con salto y con personas que sean iguales.

144
00:08:27,870 --> 00:08:28,740
Bien, volvemos.

145
00:08:28,980 --> 00:08:30,720
Control dado cuenta test.

146
00:08:30,900 --> 00:08:31,590
Se acuerdan?

147
00:08:31,710 --> 00:08:34,350
Este fallaba porque no eran iguales.

148
00:08:34,380 --> 00:08:40,110
Pero ahora como modificamos nuestro código, hicimos una refactorización implementando el método equals.

149
00:08:40,410 --> 00:08:42,510
Ahora debería pasar la prueba.

150
00:08:42,780 --> 00:08:43,260
Veamos.

151
00:08:46,170 --> 00:08:48,250
La pausa de Vigen te correcto.

152
00:08:48,780 --> 00:08:50,190
Vamos a ejecutar todos los métodos.

153
00:08:52,280 --> 00:08:53,180
Pasan los Methos.

154
00:08:53,660 --> 00:09:01,340
Ahora, qué pasa si acá es John Doh, acá es John hГroe, en vez de té colocamos Rohe, pasará la prueba.

155
00:09:01,520 --> 00:09:02,270
Tenemos que probar.

156
00:09:05,160 --> 00:09:05,850
Falla la prueba?

157
00:09:06,780 --> 00:09:08,220
Claro, no son iguales.

158
00:09:09,000 --> 00:09:10,680
Por qué cambió acá el nombre?

159
00:09:11,040 --> 00:09:14,690
Incluso lo dejamos como estaba y probamos acá.

160
00:09:15,030 --> 00:09:17,940
9 9, 9 9 en vez de 7.

161
00:09:18,090 --> 00:09:21,390
Campear más acá debería ser distinto, quizá muy similar.

162
00:09:25,770 --> 00:09:30,480
Se fijan, pasan todo menos test, referencia, lo mismo porque cambiamos acá.

163
00:09:31,800 --> 00:09:36,540
2 Está bien, nuestro código ahora está valiendo bien afirmando mediante la instancia.

164
00:09:38,950 --> 00:09:40,870
Volvemos a ejecutar y debería pasar.

165
00:09:41,820 --> 00:09:43,860
Está bien con hacer y cuál es?

166
00:09:44,060 --> 00:09:45,570
Ahora, si comentamos este.

167
00:09:45,630 --> 00:09:49,000
Por supuesto que va a fallar porque va a esperar que no sean iguales.

168
00:09:49,110 --> 00:09:50,670
Y como son iguales, va a fallar.

169
00:09:50,850 --> 00:09:55,080
Pero lo dejamos así y continuamos en la siguiente clase con otro ejemplo.

170
00:09:55,170 --> 00:09:58,560
Pero ya vamos a empezar a ver el tema de transferencia.

171
00:09:58,650 --> 00:10:04,740
Vamos a implementar dos métodos el débito y crédito y ver qué pasa cuando nos transfieren un monto o

172
00:10:04,740 --> 00:10:10,680
cuando nuestra cuenta transfiere un monto a otra cuenta y hacer el test, probar ese código.

173
00:10:10,770 --> 00:10:12,320
Nos vemos en la siguiente clase.