def test_deshabilitar_caja_abierta(context):
driver_cajero = context.driver_manager.main_driver
caja = context.sucursal.cajas[0]
cajero = context.cajeros[0]
editar_caja_action = EditarCajaAction(context)
apertura = Apertura({moneda: 0 for moneda in caja.monedas_permitidas})
apertura_action = AperturaOperableAction(context)
with allure.step("Usuario A ingresa como Cajero"):
LoginAction(context).verify_state().do(cajero, caja).success("Apertura Caja")
with allure.step("Apertura la caja"):
apertura_action.fast_forward(cajero, caja, apertura)
driver_administrador = context.driver_manager.new_driver()
context.page.set_active_driver(driver_administrador)
with allure.step("Usuario B ingresa como administrador"):
LoginAction(context).verify_state().do(context.administrador).success("Dashboard")
with allure.step("deshabilita la caja"):
IrEdicionSucursalAction(context).do(context.sucursal).success()
editar_caja_action.verify_state(caja)
caja.desactivar()
editar_caja_action.do(caja)
with allure.step("pero no puede porque se encuentra abierta por Usuario B"):
editar_caja_action.failure(caja, "abierta")
caja.activar()
GuardarSucursalAction(context).verify_state(context.sucursal)
logout_action = LogoutAction(context)
for driver, usuario in [[driver_administrador, context.administrador], [driver_cajero, cajero]]:
context.page.set_active_driver(driver)
logout_action.verify_state(usuario).do().success()
def test_solicitar_fondos_boveda_cerrada(context):
cajero = context.cajeros[0]
caja = context.sucursal.cajas[0]
monto_apertura_caja = 0
apertura_caja = Apertura(
{m: monto_apertura_caja
for m in caja.monedas_permitidas})
monedas = caja.monedas_permitidas.intersection(context.boveda.monedas)
solicitud = SolicitudFondo(caja, context.boveda,
{m: choice([20, 50])
for m in monedas})
login_action = LoginAction(context)
logout_action = LogoutAction(context)
apertura_action = AperturaOperableAction(context)
completar_solicitud_action = CompletarSolicitudFondosAction(context)
with allure.step("El cajero apertura su caja"):
login_action.verify_state().do(cajero, caja).success("Apertura Caja")
apertura_action.fast_forward(cajero, caja, apertura_caja)
caja.agregar_operacion(apertura_caja)
with allure.step(
"El cajero genera una solicitud de fondos con montos sugeridos"):
completar_solicitud_action.verify_state(caja).do(
solicitud, cajero.password)
with allure.step(
"El sistema le indica que la boveda se encuentra cerrada"):
completar_solicitud_action.failure(caja)
logout_action.verify_state(cajero).do().success()
def test_deshabilitar_moneda_apertura(context):
caja = context.sucursal.cajas[0]
editar_caja_action = EditarCajaAction(context)
with allure.step("El usuario ingresa como Administrador"):
LoginAction(context).verify_state().do(
context.administrador).success("Dashboard")
moneda_eliminada = choice(tuple(caja.monedas_permitidas))
with allure.step(f"deshabilita la moneda {moneda_eliminada.codigo}"):
IrEdicionSucursalAction(context).verify_state().do(
context.sucursal).success()
editar_caja_action.verify_state(caja)
caja.deshabilitar_moneda_giro("Ambos", moneda_eliminada)
editar_caja_action.do(caja).success()
GuardarSucursalAction(context).verify_state(
context.sucursal).do().success()
LogoutAction(context).verify_state(
context.administrador).do().success()
with allure.step("El cajero asignado ingresa al sistema"):
LoginAction(context).verify_state().do(context.cajeros[0],
caja).success("Apertura Caja")
with allure.step("Solo se muestra una moneda operable"):
AperturaOperableAction(context).verify_state(caja)
LogoutAction(context).verify_state(context.cajeros[0]).do().success()
def test_deshabilitar_caja_con_saldo(context):
caja = context.sucursal.cajas[0]
cajero = context.cajeros[0]
apertura = Apertura({moneda: 100 for moneda in caja.monedas_permitidas})
apertura_action = AperturaOperableAction(context)
cierre = CierreTotal({moneda: 100 for moneda in caja.monedas_permitidas})
cierre_action = CierreTotalCajaAction(context)
editar_caja_action = EditarCajaAction(context)
with allure.step("El usuario cuenta con una caja con saldo"):
apertura_action.fast_forward(cajero, caja, apertura, desbloquear=True, asignar_operador=True,
redireccionar=False)
caja.agregar_operacion(apertura)
cierre_action.fast_forward(cajero, caja, cierre, redirect=False)
caja.agregar_operacion(cierre)
with allure.step("Ingresa como administrador"):
LoginAction(context).verify_state().do(context.administrador).success("Dashboard")
with allure.step("Intenta deshabilita la caja"):
IrEdicionSucursalAction(context).verify_state().do(context.sucursal).success()
editar_caja_action.verify_state(caja)
caja.desactivar()
editar_caja_action.do(caja)
with allure.step("Pero no puede porque su saldo es mayor a 0"):
editar_caja_action.failure(caja, "con saldo")
caja.activar()
GuardarSucursalAction(context).verify_state(context.sucursal)
LogoutAction(context).verify_state(context.administrador).do().success()
def test_cierre_total_con_diferencia(context, diferencia):
caja = context.sucursal.cajas[0]
cajero = context.cajeros[0]
monto = 100
apertura = Apertura({moneda: monto for moneda in caja.monedas_permitidas})
apertura_action = AperturaOperableAction(context)
cierre = CierreTotal(
{moneda: monto + diferencia
for moneda in caja.monedas_permitidas})
cierre_action = CierreTotalCajaAction(context)
with allure.step("Un usuario ingresa como cajero"):
LoginAction(context).verify_state().do(cajero,
caja).success("Apertura Caja")
with allure.step(f"Apertura la caja {caja.codigo}"):
apertura_action.fast_forward(cajero, caja, apertura, desbloquear=True)
with allure.step("Realiza un cierre total con montos dentro del margen"):
cierre_action.verify_state(caja, cierre).do(cajero.password)
with allure.step("La caja se cierra correctamente"):
cierre_action.success()
LogoutAction(context).verify_state(cajero).do().success()
def test_deshabilitar_sucursal(context):
modificar_estado_sucursal_action = ModificarEstadoSucursalAction(context)
ir_edicion_sucursal_action = IrEdicionSucursalAction(context)
crear_caja_action = CrearCajaAction(context)
with allure.step("El usuario ingresa como Administrador"):
LoginAction(context).verify_state().do(
context.administrador).success("Dashboard")
with allure.step("deshabilita la sucursal"):
modificar_estado_sucursal_action.verify_state(context.sucursal)
context.sucursal.desactivar()
modificar_estado_sucursal_action.do(context.sucursal)
with allure.step("Las cajas se deshabilitan"):
modificar_estado_sucursal_action.success()
with allure.step("el usuaro intenta crear una caja"):
ir_edicion_sucursal_action.verify_state().do(
context.sucursal).success()
caja = context.sucursal.cajas[0]
caja.codigo = "FF3343"
crear_caja_action.verify_state(context.sucursal).do(caja)
with allure.step("pero no puede porque la sucursal esta inactiva"):
crear_caja_action.failure("Sucursal desactivada")
LogoutAction(context).verify_state(context.administrador).do().success()
def test_crear_sucursal_repetida(context):
with allure.step("El usuario ingresa como Administrador"):
LoginAction(context).verify_state().do(
context.administrador).success("Dashboard")
# No se si deberia hacer esto, pero es un caso muy especifico ¯\_(ツ)_/¯
sucursal_repetida = Sucursal(context.sucursal.nombre,
context.sucursal.codigo)
with allure.step("crea una sucursal con un codigo y nombre repetido"):
CompletarDatosNuevaSucursalAction(context).verify_state().do(
sucursal_repetida).success()
with allure.step("la sucursal no se crea porque el codigo ya esta en uso"):
GuardarSucursalAction(context).verify_state(
sucursal_repetida).do().failure("Nombre")
with allure.step("el usuario modifica el nombre"):
action = ModificarDatosSucursalAction(context)
action.verify_state(sucursal_repetida)
sucursal_repetida.nombre = "ARPER 123487"
action.do(sucursal_repetida.nombre).success()
with allure.step(
"la sucursal no se crea porque el codigo ya estaba en uso"):
GuardarSucursalAction(context).verify_state(
sucursal_repetida).do().failure("Codigo")
LogoutAction(context).verify_state(
context.administrador).do().success()
def test_aperturar_caja_con_bloqueo_multimoneda(context):
caja = context.sucursal.cajas[0]
cajero = context.cajeros[0]
apertura = Apertura(dict(zip(caja.monedas_permitidas, [0, 100])))
bloqueo = Bloqueo(caja,
cajero,
"Apertura",
logico=caja.balance(),
reales=apertura.montos,
diferencia=apertura.montos)
desbloqueo_action = DesbloquearCajaAction(context)
apertura_action = AperturaOperableAction(context)
with allure.step("Un usuario ingresa como cajero"):
LoginAction(context).verify_state().do(cajero,
caja).success("Apertura Caja")
with allure.step(
f"Apertura la caja {caja.codigo} con una moneda correcta y otra no"
):
apertura_action.verify_state(caja).do(apertura,
deberia_bloquearse=True)
with allure.step("la caja se bloquea"):
apertura_action.failure()
LogoutAction(context).verify_state(cajero).do().success()
with allure.step(
"El area de operaciones puede ver correctamente la razon de bloqueo y desbloquear la caja"
):
desbloqueo_action.fast_forward(context.operaciones, bloqueo,
"Desbloqueo de prueba")
def test_aperturar_cerrar_boveda(context):
boveda = context.boveda
operador = context.operador_remesas
apertura = Apertura({moneda: 0 for moneda in boveda.monedas_permitidas})
apertura_action = AperturaOperableAction(context)
cierre = CierreTotal({moneda: 0 for moneda in boveda.monedas_permitidas})
cierre_action = CierreOperableAction(context)
with allure.step("Un usuario ingresa como operador de boveda"):
LoginAction(context).verify_state().do(
operador, boveda).success("Apertura Boveda")
with allure.step(f"Apertura la caja {boveda.codigo} con montos en 0"):
apertura_action.verify_state(boveda).do(apertura)
with allure.step("la caja se apertura"):
apertura_action.success()
with allure.step("Realiza un cierre total con montos correctos"):
cierre_action.verify_state(boveda, cierre).do(operador.password)
with allure.step("La boveda se cierra totalmente"):
cierre_action.success()
LogoutAction(context).verify_state(operador).do().success()
def test_habilitar_sucursal(context):
modificar_estado_sucursal_action = ModificarEstadoSucursalAction(context)
ir_edicion_sucursal_action = IrEdicionSucursalAction(context)
with allure.step("El usuario ingresa como Administrador"):
LoginAction(context).verify_state().do(
context.administrador).success("Dashboard")
with allure.step("deshabilita la sucursal"):
modificar_estado_sucursal_action.verify_state(context.sucursal)
context.sucursal.desactivar()
modificar_estado_sucursal_action.do(context.sucursal)
with allure.step("Las cajas se deshabilitan"):
modificar_estado_sucursal_action.success()
with allure.step("habilita nuevamente la sucursal"):
modificar_estado_sucursal_action.verify_state(context.sucursal)
context.sucursal.activa = True
modificar_estado_sucursal_action.do(context.sucursal).success()
with allure.step("pero las cajas permanecen deshabilitadas"):
ir_edicion_sucursal_action.verify_state().do(
context.sucursal).success()
LogoutAction(context).verify_state(context.administrador).do().success()
def test_aperturar_caja_con_bloqueo(context, diferencia):
caja = context.sucursal.cajas[0]
cajero = context.cajeros[0]
monto_apertura = 100
apertura1 = Apertura(
{moneda: monto_apertura
for moneda in caja.monedas_permitidas})
apertura2 = Apertura({
moneda: monto_apertura + diferencia
for moneda in caja.monedas_permitidas
})
apertura_action = AperturaOperableAction(context)
bloqueo = Bloqueo(
caja,
cajero,
"Apertura",
logico=apertura1.montos,
reales=apertura2.montos,
diferencia={moneda: diferencia
for moneda in caja.monedas_permitidas})
desbloqueo_action = DesbloquearCajaAction(context)
cierre1 = CierreTotal(
{moneda: monto_apertura
for moneda in caja.monedas_permitidas})
cierre_action = CierreTotalCajaAction(context)
with allure.step("Un usuario ingresa como cajero"):
LoginAction(context).verify_state().do(cajero,
caja).success("Apertura Caja")
# Abro y cierro la caja para inyectarle balance
apertura_action.fast_forward(cajero, caja, apertura1, desbloquear=True)
caja.agregar_operacion(apertura1)
cierre_action.fast_forward(cajero, caja, cierre1)
caja.agregar_operacion(cierre1)
with allure.step(f"Apertura la caja {caja.codigo} con montos incorrectos"):
apertura_action.verify_state(caja).do(apertura2,
deberia_bloquearse=True)
with allure.step("la caja se bloquea"):
apertura_action.failure()
LogoutAction(context).verify_state(cajero).do().success()
with allure.step(
"El area de operaciones puede ver correctamente la razon de bloqueo y desbloquear la caja"
):
desbloqueo_action.fast_forward(context.operaciones, bloqueo,
"Desbloqueo de prueba")
def test_deshabilitar_sucursal_caja_abierta(context):
driver_cajero = context.driver_manager.main_driver
caja = context.sucursal.cajas[0]
cajero = context.cajeros[0]
login_action = LoginAction(context)
apertura = Apertura({moneda: 0 for moneda in caja.monedas_permitidas})
apertura_action = AperturaOperableAction(context)
modificar_estado_action = ModificarEstadoSucursalAction(context)
with allure.step("Usuario A ingresa como Cajero"):
login_action.verify_state().do(cajero, caja).success("Apertura Caja")
with allure.step(f"Apertura la caja #{caja.codigo} con montos en 0"):
apertura_action.fast_forward(cajero, caja, apertura)
driver_administrador = context.driver_manager.new_driver()
context.page.set_active_driver(driver_administrador)
with allure.step("Usuario B ingresa como administrador"):
login_action.verify_state().do(
context.administrador).success("Dashboard")
with allure.step("deshabilita la sucursal"):
modificar_estado_action.verify_state(context.sucursal)
context.sucursal.activa = False
modificar_estado_action.do(context.sucursal)
with allure.step("pero no puede porque Usuario B aperturo una caja"):
modificar_estado_action.failure("abierta", context.sucursal,
context.sucursal.cajas[0])
logout_action = LogoutAction(context)
for driver, usuario in [[driver_administrador, context.administrador],
[driver_cajero, cajero]]:
context.page.set_active_driver(driver)
logout_action.verify_state(usuario).do().success()
def test_deshabilitar_envio_recibo_giros(context):
caja = context.sucursal.cajas[0]
editar_caja_action = EditarCajaAction(context)
operador_sin_operaciones_action = OperadorSinAccionesLoginAction(context)
with allure.step("El usuario ingresa como Administrador"):
LoginAction(context).do(context.administrador).success("Dashboard")
with allure.step("deshabilita el envio de giros de la caja"):
IrEdicionSucursalAction(context).do(context.sucursal).success()
editar_caja_action.verify_state(caja)
caja.envia_giros = False
editar_caja_action.do(caja)
with allure.step("el envio de giros se deshabilita correctamente"):
editar_caja_action.success()
with allure.step("deshabilita el recibo de giros de la caja"):
editar_caja_action.verify_state(caja)
caja.recibe_giros = False
editar_caja_action.do(caja)
with allure.step("el recibo de giros se deshabilita correctamente"):
editar_caja_action.success()
LogoutAction(context).verify_state(
context.administrador).do().success()
with allure.step("El cajero asignado intenta aperturar la caja"):
operador_sin_operaciones_action.verify_state(caja).do(
context.cajeros[0])
with allure.step(
"Pero no puede porque la caja no tiene operaciones activas"):
operador_sin_operaciones_action.success()
LogoutAction(context).verify_state(context.cajeros[0]).do().success()
def test_cierre_total_con_bloqueo(context, diferencia):
caja = context.sucursal.cajas[0]
cajero = context.cajeros[0]
monto_apertura = 100
apertura = Apertura(
{moneda: monto_apertura
for moneda in caja.monedas_permitidas})
apertura_action = AperturaOperableAction(context)
cierre = CierreTotal({
moneda: monto_apertura + diferencia
for moneda in caja.monedas_permitidas
})
cierre_action = CierreTotalCajaAction(context)
bloqueo = Bloqueo(
caja,
cajero,
"Cierre total",
logico=apertura.montos,
reales=cierre.montos,
diferencia={moneda: diferencia
for moneda in caja.monedas_permitidas})
desbloqueo_action = DesbloquearCajaAction(context)
with allure.step("Un usuario ingresa como cajero"):
LoginAction(context).verify_state().do(cajero,
caja).success("Apertura Caja")
with allure.step(f"Apertura la caja {caja.codigo}"):
apertura_action.fast_forward(cajero, caja, apertura, desbloquear=True)
with allure.step(
"Realiza un cierre total con montos fuera del margen de diferencia"
):
cierre_action.verify_state(caja, cierre).do(cajero.password)
with allure.step("la caja se bloquea"):
cierre_action.failure("Bloqueo")
LogoutAction(context).verify_state(cajero).do().success()
with allure.step(
"El area de operaciones puede ver correctamente la razon de bloqueo y desbloquear la caja"
):
desbloqueo_action.fast_forward(context.operaciones, bloqueo,
"Desbloqueo de prueba")
def test_crear_caja_repetida(context):
crear_caja_action = CrearCajaAction(context)
with allure.step("El usuario ingresa como Administrador"):
LoginAction(context).verify_state().do(
context.administrador).success("Dashboard")
with allure.step("Ingresa a editar una sucursal"):
IrEdicionSucursalAction(context).do(context.sucursal).success()
with allure.step("Crea una caja con un codigo repetido"):
crear_caja_action.verify_state(context.sucursal).do(
context.sucursal.cajas[0])
with allure.step("El sistema le indica que el codigo debe ser unico"):
crear_caja_action.failure("Codigo repetido")
LogoutAction(context).verify_state(
context.administrador).do().success()
def test_aperturar_caja(context):
caja = context.sucursal.cajas[0]
cajero = context.cajeros[0]
apertura = Apertura({moneda: 0 for moneda in caja.monedas_permitidas})
apertura_action = AperturaOperableAction(context)
with allure.step("Un usuario ingresa como cajero"):
LoginAction(context).verify_state().do(cajero,
caja).success("Apertura Caja")
with allure.step(f"Apertura la caja #{caja.codigo} con montos en 0"):
apertura_action.verify_state(caja).do(apertura)
with allure.step("la caja se apertura"):
apertura_action.success()
LogoutAction(context).verify_state(cajero).do().success()
def test_crear_sucursal(context):
with allure.step("El usuario ingresa como Administrador"):
LoginAction(context).verify_state().do(
context.administrador).success("Dashboard")
with allure.step("crea una sucursal con una caja"):
CompletarDatosNuevaSucursalAction(context).verify_state().do(
context.sucursal).success()
GuardarSucursalAction(context).verify_state(
context.sucursal).do().success(True)
IrEdicionSucursalAction(context).verify_state().do(context.sucursal)
caja_action = CrearCajaAction(context)
for c in context.cajas[0]:
caja_action.verify_state(context.sucursal).do(c).success()
context.sucursal.agregar_cajas(c)
GuardarSucursalAction(context).verify_state(
context.sucursal).do().success()
LogoutAction(context).verify_state(context.administrador).do().success()
def test_deshabilitar_caja(context):
caja = context.sucursal.cajas[0]
editar_caja_action = EditarCajaAction(context)
guardar_sucursal_action = GuardarSucursalAction(context)
with allure.step("El usuario ingresa como Administrador"):
LoginAction(context).verify_state().do(context.administrador).success("Dashboard")
with allure.step("deshabilita la caja de una sucursal"):
IrEdicionSucursalAction(context).do(context.sucursal).success()
editar_caja_action.verify_state(caja)
caja.desactivar()
editar_caja_action.do(caja)
with allure.step("La caja se deshabilitar correctamente"):
editar_caja_action.success()
guardar_sucursal_action.verify_state(context.sucursal).do().success()
LogoutAction(context).verify_state(context.administrador).do().success()
def test_aperturar_caja_con_margen(context, diferencia):
caja = context.sucursal.cajas[0]
cajero = context.cajeros[0]
monto_apertura = 100
apertura1 = Apertura(
{moneda: monto_apertura
for moneda in caja.monedas_permitidas})
apertura_action = AperturaOperableAction(context)
cierre1 = CierreTotal(
{moneda: monto_apertura
for moneda in caja.monedas_permitidas})
apertura2 = Apertura({
moneda: monto_apertura + diferencia
for moneda in caja.monedas_permitidas
})
with allure.step("Un usuario ingresa como cajero"):
LoginAction(context).verify_state().do(cajero,
caja).success("Apertura Caja")
# Las cajas se crean en 0, Abro y cierro para que tenga 100
apertura_action.fast_forward(cajero, caja, apertura1, desbloquear=True)
caja.agregar_operacion(apertura1)
CierreTotalCajaAction(context).fast_forward(cajero, caja, cierre1)
caja.agregar_operacion(cierre1)
with allure.step(
f"Apertura la caja {caja.codigo} con montos dentro del margen"):
apertura_action.verify_state(caja).do(apertura2)
with allure.step("la caja se apertura"):
apertura_action.success()
LogoutAction(context).verify_state(cajero).do().success()
def test_cierre_total(context):
caja = context.sucursal.cajas[0]
cajero = context.cajeros[0]
apertura = Apertura({moneda: 0 for moneda in caja.monedas_permitidas})
apertura_action = AperturaOperableAction(context)
cierre = CierreTotal({moneda: 0 for moneda in caja.monedas_permitidas})
cierre_action = CierreTotalCajaAction(context)
with allure.step("Un usuario ingresa como cajero"):
LoginAction(context).verify_state().do(cajero,
caja).success("Apertura Caja")
with allure.step(f"Apertura la caja {caja.codigo} con montos en 0"):
apertura_action.fast_forward(cajero, caja, apertura)
with allure.step("Realiza un cierre total con montos correctos"):
cierre_action.verify_state(caja, cierre).do(cierre)
with allure.step("La caja se cierra totalmente"):
cierre_action.success()
LogoutAction(context).verify_state(cajero).do().success()
def test_deshabilitar_sucursal_caja_con_saldo(context):
caja = context.sucursal.cajas[0]
cajero = context.cajeros[0]
login_action = LoginAction(context)
logout_action = LogoutAction(context)
modificar_estado_action = ModificarEstadoSucursalAction(context)
apertura = Apertura({moneda: 100 for moneda in caja.monedas_permitidas})
apertura_action = AperturaOperableAction(context)
cierre = CierreTotal({moneda: 100 for moneda in caja.monedas_permitidas})
cierre_action = CierreTotalCajaAction(context)
with allure.step("Usuario A ingresa como Cajero"):
login_action.verify_state().do(cajero, caja).success("Apertura Caja")
with allure.step(f"Apertura la caja {caja.codigo}"):
apertura_action.fast_forward(cajero, caja, apertura, desbloquear=True)
caja.agregar_operacion(apertura)
with allure.step(f"Cierra totalmente la caja {caja.codigo}"):
cierre_action.verify_state(caja, cierre).do(cajero.password).success()
caja.agregar_operacion(cierre)
logout_action.verify_state(cajero).do().success()
with allure.step("Usuario B ingresa como administrador"):
login_action.verify_state().do(
context.administrador).success("Dashboard")
with allure.step("deshabilita la sucursal"):
modificar_estado_action.verify_state(context.sucursal)
context.sucursal.activa = False
modificar_estado_action.do(context.sucursal)
with allure.step(
f"pero no puede porque la caja {caja.codigo} tiene saldo"):
modificar_estado_action.failure("con saldo", context.sucursal, caja)
logout_action.verify_state(context.administrador).do().success()
def test_operador_sin_boveda(context):
OperadorSinOperableLoginAction(context).verify_state().do(
context.operador_remesas).success()
LogoutAction(context).verify_state(context.operador_remesas).do().success()
def test_cajero_sin_caja(context):
OperadorSinOperableLoginAction(context).verify_state().do(
context.cajeros[0]).success()
LogoutAction(context).verify_state(context.cajeros[0]).do().success()
def test_transferencia_caja_boveda_con_error(context):
operador = context.operador_remesas
boveda = context.boveda
apertura_boveda = Apertura(
{m: 1000
for m in context.boveda.monedas_permitidas})
driver_remesas = context.driver_manager.main_driver
caja = context.sucursal.cajas[0]
cajero = context.cajeros[0]
apertura_caja = Apertura(
{moneda: 1000
for moneda in caja.monedas_permitidas})
monedas_extraccion = caja.monedas_permitidas.intersection(
context.boveda.monedas)
transferencia = Transferencia(
caja, context.boveda, {moneda: 165
for moneda in monedas_extraccion})
login_action = LoginAction(context)
logout_action = LogoutAction(context)
apertura_action = AperturaOperableAction(context)
cierre_caja_action = CierreTotalCajaAction(context)
cierre_boveda_action = CierreOperableAction(context)
completar_transferencia_action = CompletarTransferenciaAction(context)
recibir_transferencia_action = RecibirTransferenciaAction(context)
problema_transferencia_action = ReportarProblemaTranferenciaAction(context)
transferencia_finalizada_action = TransferenciaFinalizadaAction(context)
with allure.step("El operador de remesas apertura la boveda general"):
login_action.verify_state().do(operador,
boveda).success("Apertura Boveda")
apertura_action.fast_forward(operador, boveda, apertura_boveda)
boveda.agregar_operacion(apertura_boveda)
driver_cajero = context.driver_manager.new_driver()
context.page.set_active_driver(driver_cajero)
with allure.step("El cajero apertura su caja"):
login_action.verify_state().do(cajero, caja).success("Apertura Caja")
apertura_action.fast_forward(cajero,
caja,
apertura_caja,
desbloquear=True)
caja.agregar_operacion(apertura_caja)
with allure.step(f"El cajero genera un deposito en la boveda general"):
transferencia.codigo = completar_transferencia_action.fast_forward(
cajero, transferencia)
caja.agregar_operacion(transferencia)
context.page.set_active_driver(driver_remesas)
with allure.step("Boveda general reporta un error en la transferencia"):
recibir_transferencia_action.verify_state(boveda).do(
transferencia).success()
problema_transferencia_action.verify_state(boveda, transferencia).do(
"Reporte de Prueba", operador.password)
problema_transferencia_action.success()
boveda.agregar_operacion(transferencia)
context.page.set_active_driver(driver_cajero)
with allure.step("La transferencia se reporta con problemas"):
transferencia_finalizada_action.verify_state(caja).do(transferencia)
transferencia.estado = transferencia_finalizada_action.success(
"Hubo un Problema")
with allure.step("El cajero realiza un cierre total correctamente"):
cierre_caja = CierreTotal(caja.balance())
cierre_caja_action.fast_forward(cajero, caja, cierre_caja)
caja.agregar_operacion(cierre_caja)
logout_action.verify_state(cajero).do().success()
context.page.set_active_driver(driver_remesas)
with allure.step(
"El operador de remesas realiza un cierre total correctamente"):
cierre_boveda = CierreTotal(boveda.balance())
cierre_boveda_action.fast_forward(operador, boveda, cierre_boveda)
context.boveda.agregar_operacion(cierre_boveda)
logout_action.verify_state(operador).do().success()
def test_cancelar_transferencia_boveda_caja_pendiente_recepcion(context):
driver_caja = context.driver_manager.main_driver
cajero = context.cajeros[0]
caja = context.sucursal.cajas[0]
monto_apertura_caja = 100
apertura_caja = Apertura(
{moneda: monto_apertura_caja
for moneda in caja.monedas_permitidas})
operador = context.operador_remesas
boveda = context.boveda
monto_apertura_boveda = 1000
apertura_boveda = Apertura({
moneda: monto_apertura_boveda
for moneda in boveda.monedas_permitidas
})
monedas = boveda.monedas_permitidas.intersection(caja.monedas_permitidas)
transferencia = Transferencia(
boveda, caja, {moneda: randint(1, 100)
for moneda in monedas})
login_action = LoginAction(context)
logout_action = LogoutAction(context)
apertura_action = AperturaOperableAction(context)
cierre_caja_action = CierreTotalCajaAction(context)
cierre_boveda_action = CierreOperableAction(context)
completar_transferencia_action = CompletarTransferenciaAction(context)
recibir_transferencia_action = RecibirTransferenciaAction(context)
cancelar_transferencia_action = CancelarTransferenciaAction(context)
confirmar_transferencia_action = ConfirmarTransferenciaAction(context)
transferencia_finalizada_action = TransferenciaFinalizadaAction(context)
with allure.step("El cajero de destino apertura su caja"):
login_action.verify_state().do(cajero, caja).success("Apertura Caja")
apertura_action.fast_forward(cajero,
caja,
apertura_caja,
desbloquear=True)
caja.agregar_operacion(apertura_caja)
driver_operador = context.driver_manager.new_driver()
context.page.set_active_driver(driver_operador)
with allure.step("El operador de remesas apertura la boveda general"):
login_action.verify_state().do(operador,
boveda).success("Apertura Boveda")
apertura_action.fast_forward(operador, boveda, apertura_boveda)
boveda.agregar_operacion(apertura_boveda)
with allure.step(
"El operador de remesas genera una transferencia de salida hacia caja destino"
):
transferencia.codigo = completar_transferencia_action.fast_forward(
operador, transferencia)
boveda.agregar_operacion(transferencia)
context.page.set_active_driver(driver_caja)
with allure.step(
"La transferencia se muestra en los depositos pendientes del cajero"
):
recibir_transferencia_action.verify_state(caja).do(
transferencia).success()
context.page.set_active_driver(driver_operador)
with allure.step("El operador cancela la transferencia"):
cancelar_transferencia_action.verify_state(boveda, transferencia).do(
operador.password).success()
context.page.set_active_driver(driver_caja)
with allure.step(
"El cajero no podra realizar ninguna accion con el deposito"):
recibir_transferencia_action.success()
confirmar_transferencia_action.verify_state(caja, transferencia).do(
cajero.password).failure()
with allure.step("y cuando refresque la pantalla ya no vera el deposito"):
transferencia_finalizada_action.verify_state(caja).do(transferencia)
transferencia.estado = transferencia_finalizada_action.success(
"Cancelada")
with allure.step(
"El cajero de destino realiza un cierre total correctamente"):
cierre_caja = CierreTotal(caja.balance())
cierre_caja_action.fast_forward(cajero, caja, cierre_caja)
caja.agregar_operacion(cierre_caja)
logout_action.verify_state(cajero).do().success()
context.page.set_active_driver(driver_operador)
with allure.step(
"El operador de remesas realiza un cierre total correctamente"):
cierre_boveda = CierreTotal(boveda.balance())
cierre_boveda_action.fast_forward(operador, boveda, cierre_boveda)
boveda.agregar_operacion(cierre_boveda)
logout_action.verify_state(operador).do().success()
def test_cierre_boveda_con_depositos_pendiente_recepcion(context):
driver_cajero = context.driver_manager.main_driver
caja = context.sucursal.cajas[0]
monto_apertura_caja = 1000
apertura_caja = Apertura(
{m: monto_apertura_caja
for m in caja.monedas_permitidas})
cajero = context.cajeros[0]
boveda = context.boveda
operador = context.operador_remesas
monto_apertura_boveda = 1000
apertura_boveda = Apertura(
{m: monto_apertura_boveda
for m in boveda.monedas_permitidas})
monedas = caja.monedas_permitidas.intersection(context.boveda.monedas)
transferencia = Transferencia(
caja, context.boveda, {moneda: randint(1, 100)
for moneda in monedas})
login_action = LoginAction(context)
logout_action = LogoutAction(context)
apertura_action = AperturaOperableAction(context)
cierre_caja_action = CierreTotalCajaAction(context)
cierre_boveda_action = CierreOperableAction(context)
completar_transferencia_action = CompletarTransferenciaAction(context)
recibir_transferencia_action = RecibirTransferenciaAction(context)
recepcionar_transferencia_action = RecepcionarTransferenciaAction(context)
with allure.step("El cajero apertura su caja"):
login_action.verify_state().do(cajero, caja).success("Apertura Caja")
apertura_action.fast_forward(cajero,
caja,
apertura_caja,
desbloquear=True)
caja.agregar_operacion(apertura_caja)
driver_remesas = context.driver_manager.new_driver()
context.page.set_active_driver(driver_remesas)
with allure.step("El operador de remesas apertura la boveda general"):
login_action.verify_state().do(operador,
boveda).success("Apertura Boveda")
apertura_action.fast_forward(operador, boveda, apertura_boveda)
boveda.agregar_operacion(apertura_boveda)
context.page.set_active_driver(driver_cajero)
with allure.step(f"El cajero genera un deposito en la boveda general"):
transferencia.codigo = completar_transferencia_action.fast_forward(
cajero, transferencia)
caja.agregar_operacion(transferencia)
context.page.set_active_driver(driver_remesas)
with allure.step(
"Boveda general recibe la transferencia pero no la recepciona"):
recibir_transferencia_action.verify_state(boveda).do(
transferencia).success()
with allure.step("El operador de remesas realiza un cierre total"):
cierre_boveda = CierreTotal(boveda.balance())
cierre_boveda_action.verify_state(boveda, cierre_boveda).do(
operador.password, should_redirect=False)
with allure.step("Pero no puede porque tiene operaciones pendientes"):
cierre_boveda_action.failure("Operaciones Pendientes")
# recepciono la operacion y cierro la boveda para que no quede bloqueada la boveda en los siguientes tests
recibir_transferencia_action.verify_state(boveda).do(transferencia)
recepcionar_transferencia_action.fast_forward(operador, transferencia)
cierre_boveda = CierreTotal(boveda.balance())
cierre_boveda_action.fast_forward(operador, boveda, cierre_boveda)
logout_action.verify_state(operador).do().success()
context.page.set_active_driver(driver_cajero)
with allure.step("El cajero realiza un cierre total correctamente"):
cierre_caja = CierreTotal(caja.balance())
cierre_caja_action.fast_forward(cajero, caja, cierre_caja)
caja.agregar_operacion(cierre_caja)
logout_action.verify_state(cajero).do().success()
def test_cierre_boveda_con_depositos_pendiente_confirmacion(context):
driver_cajero = context.driver_manager.main_driver
caja = context.sucursal.cajas[0]
monto_apretura_caja = 1000
apertura_caja = Apertura(
{m: monto_apretura_caja
for m in caja.monedas_permitidas})
cajero = context.cajeros[0]
apertura_boveda = 1000
apertura_boveda = Apertura(
{m: apertura_boveda
for m in context.boveda.monedas_permitidas})
boveda = context.boveda
operador = context.operador_remesas
monedas = caja.monedas_permitidas.intersection(context.boveda.monedas)
transferencia = Transferencia(
caja, context.boveda, {moneda: randint(1, 100)
for moneda in monedas})
login_action = LoginAction(context)
logout_action = LogoutAction(context)
apertura_action = AperturaOperableAction(context)
cierre_caja_action = CierreTotalCajaAction(context)
cierre_boveda_action = CierreOperableAction(context)
completar_transferencia_action = CompletarTransferenciaAction(context)
recibir_transferencia_action = RecibirTransferenciaAction(context)
recepcionar_transferencia_action = RecepcionarTransferenciaAction(context)
with allure.step("El cajero apertura su caja"):
login_action.verify_state().do(cajero, caja).success("Apertura Caja")
apertura_action.fast_forward(cajero,
caja,
apertura_caja,
desbloquear=True)
caja.agregar_operacion(apertura_caja)
driver_remesas = context.driver_manager.new_driver()
context.page.set_active_driver(driver_remesas)
with allure.step("El operador de remesas apertura la boveda general"):
login_action.verify_state().do(operador,
boveda).success("Apertura Boveda")
apertura_action.fast_forward(operador, boveda, apertura_boveda)
boveda.agregar_operacion(apertura_boveda)
context.page.set_active_driver(driver_cajero)
with allure.step(f"El cajero genera un deposito en la boveda general"):
transferencia.codigo = completar_transferencia_action.fast_forward(
cajero, transferencia)
caja.agregar_operacion(transferencia)
context.page.set_active_driver(driver_remesas)
with allure.step("Boveda general recepciona el deposito"):
transferencia.estado = recepcionar_transferencia_action.fast_forward(
operador, transferencia)
with allure.step(
"El operador de remesas realiza un cierre total correctamente"):
cierre_boveda = CierreTotal(boveda.balance())
cierre_boveda_action.fast_forward(operador, boveda, cierre_boveda)
context.boveda.agregar_operacion(cierre_boveda)
logout_action.verify_state(operador).do().success()
context.page.set_active_driver(driver_cajero)
with allure.step("El cajero realiza un cierre total correctamente"):
cierre_caja = CierreTotal(caja.balance())
cierre_caja_action.fast_forward(cajero, caja, cierre_caja)
caja.agregar_operacion(cierre_caja)
logout_action.verify_state(cajero).do().success()
def test_transferencia_boveda_caja_boveda(context):
driver_cajero = context.driver_manager.main_driver
cajero = context.cajeros[0]
caja = context.sucursal.cajas[0]
monto_apertura_caja = 100
apertura_caja = Apertura(
{moneda: monto_apertura_caja
for moneda in caja.monedas_permitidas})
operador = context.operador_remesas
boveda = context.boveda
monto_apertura_boveda = 1000
apertura_boveda = Apertura(
{m: monto_apertura_boveda
for m in context.boveda.monedas_permitidas})
monedas = boveda.monedas_permitidas.intersection(caja.monedas_permitidas)
transferencia = Transferencia(
boveda, caja, {moneda: randint(1, 100)
for moneda in monedas})
login_action = LoginAction(context)
logout_action = LogoutAction(context)
apertura_action = AperturaOperableAction(context)
cierre_caja_action = CierreTotalCajaAction(context)
cierre_boveda_action = CierreOperableAction(context)
completar_transferencia_action = CompletarTransferenciaAction(context)
recepcionar_transferencia_action = RecepcionarTransferenciaAction(context)
confirmar_transferencia_action = ConfirmarTransferenciaAction(context)
transferencia_finalizada_action = TransferenciaFinalizadaAction(context)
with allure.step("El cajero apertura su caja"):
login_action.verify_state().do(cajero, caja).success("Apertura Caja")
apertura_action.fast_forward(cajero,
caja,
apertura_caja,
desbloquear=True)
caja.agregar_operacion(apertura_caja)
driver_remesas = context.driver_manager.new_driver()
context.page.set_active_driver(driver_remesas)
with allure.step("El operador de remesas apertura la boveda general"):
login_action.verify_state().do(operador,
boveda).success("Apertura Boveda")
apertura_action.fast_forward(operador, boveda, apertura_boveda)
boveda.agregar_operacion(apertura_boveda)
with allure.step(
"El operador de remesas genera una transferencia de salida hacia caja destino"
):
SeleccionarDestinoTransferenciaAction(context).verify_state(boveda).do(
caja).success()
completar_transferencia_action.verify_state(transferencia).do(
operador.password)
transferencia.codigo = completar_transferencia_action.success()
boveda.agregar_operacion(transferencia)
context.page.set_active_driver(driver_cajero)
with allure.step(
"El cajero de destino recibe la transferencia y confirma con montos correctos"
):
transferencia.estado = confirmar_transferencia_action.fast_forward(
cajero, transferencia)
caja.agregar_operacion(transferencia)
context.page.set_active_driver(driver_remesas)
with allure.step("la transferencia se contabiliza y ya no se muestra"):
transferencia_finalizada_action.verify_state(boveda).do(transferencia)
transferencia.estado = transferencia_finalizada_action.success(
"Contabilizada")
context.page.set_active_driver(driver_cajero)
transferencia2 = Transferencia(
caja, boveda, {
moneda: monto + monto_apertura_caja
for moneda, monto in transferencia.montos.items()
})
with allure.step(
"El cajero de destino genera una nueva transferencia hacia la boveda general"
):
transferencia2.codigo = completar_transferencia_action.fast_forward(
cajero, transferencia2)
caja.agregar_operacion(transferencia2)
context.page.set_active_driver(driver_remesas)
with allure.step(
"Boveda general recepciona el deposito y luego lo confirma con montos correctos"
):
transferencia2.estado = recepcionar_transferencia_action.fast_forward(
operador, transferencia2)
confirmar_transferencia_action.fast_forward(operador, transferencia2)
context.page.set_active_driver(driver_cajero)
with allure.step("la transferencia se contabiliza y ya no se muestra"):
transferencia_finalizada_action.verify_state(caja).do(transferencia2)
transferencia2.estado = transferencia_finalizada_action.fast_forward(
transferencia2)
boveda.agregar_operacion(transferencia2)
with allure.step("El cajero realiza un cierre total"):
cierre_caja = CierreTotal(caja.balance())
cierre_caja_action.fast_forward(cajero, caja, cierre_caja)
caja.agregar_operacion(cierre_caja)
logout_action.verify_state(cajero).do().success()
context.page.set_active_driver(driver_remesas)
with allure.step(
"El operador de remesas realiza un cierre total correctamente"):
cierre_boveda = CierreTotal(boveda.balance())
cierre_boveda_action.fast_forward(operador, boveda, cierre_boveda)
context.boveda.agregar_operacion(cierre_boveda)
logout_action.verify_state(operador).do().success()
def test_solicitud_fondos_boveda_sin_fondos(context, monto_apertura_caja):
cajero = context.cajeros[0]
caja = context.sucursal.cajas[0]
apertura_caja = Apertura(
{m: monto_apertura_caja
for m in caja.monedas_permitidas})
driver_operador = context.driver_manager.main_driver
operador = context.operador_remesas
boveda = context.boveda
monto_apertura_boveda = 0
apertura_boveda = Apertura(
{m: monto_apertura_boveda
for m in boveda.monedas_permitidas})
monedas = caja.monedas_permitidas.intersection(context.boveda.monedas)
solicitud = SolicitudFondo(caja, boveda,
{m: choice([20, 50])
for m in monedas})
login_action = LoginAction(context)
logout_action = LogoutAction(context)
apertura_action = AperturaOperableAction(context)
cierre_caja_action = CierreTotalCajaAction(context)
cierre_boveda_action = CierreOperableAction(context)
completar_solicitud_action = CompletarSolicitudFondosAction(context)
recibir_solicitud_action = RecibirSolicitudFondosAction(context)
aceptar_solicitud_action = AceptarSolicitudFondosAction(context)
with allure.step("El operador de remesas apertura la boveda general"):
login_action.verify_state().do(operador,
boveda).success("Apertura Boveda")
apertura_action.fast_forward(operador, boveda, apertura_boveda)
boveda.agregar_operacion(apertura_boveda)
driver_cajero = context.driver_manager.new_driver()
context.page.set_active_driver(driver_cajero)
with allure.step("El cajero apertura su caja"):
login_action.verify_state().do(cajero, caja).success("Apertura Caja")
apertura_action.fast_forward(cajero,
caja,
apertura_caja,
desbloquear=monto_apertura_caja > 0)
caja.agregar_operacion(apertura_caja)
with allure.step(
"El cajero genera una solicitud de fondos con montos sugeridos"):
completar_solicitud_action.verify_state(caja).do(
solicitud, cajero.password)
with allure.step("La solicitud se genera correctamnete"):
solicitud.codigo = completar_solicitud_action.success()
context.page.set_active_driver(driver_operador)
with allure.step(
"Boveda recibe la solicitud y la intenta aceptar pero no cuenta con fondos"
):
recibir_solicitud_action.verify_state(boveda).do(solicitud).success()
aceptar_solicitud_action.verify_state(boveda, solicitud).do(
operador.password).failure()
recibir_solicitud_action.success()
context.page.set_active_driver(driver_cajero)
with allure.step("La solicitud permanece pendiente"):
CancelarSolicitudFondosAction(context).verify_state(caja, solicitud)
context.page.set_active_driver(driver_operador)
with allure.step(
"El operador de remesas realiza un cierre total correctamente"):
cierre_boveda = CierreTotal(boveda.balance())
cierre_boveda_action.fast_forward(operador, boveda, cierre_boveda)
context.boveda.agregar_operacion(cierre_boveda)
logout_action.verify_state(operador).do().success()
context.page.set_active_driver(driver_cajero)
with allure.step("El cajero realiza un cierre total correctamente"):
cierre_caja = CierreTotal(caja.balance())
cierre_caja_action.fast_forward(cajero, caja, cierre_caja)
caja.agregar_operacion(cierre_caja)
logout_action.verify_state(cajero).do().success()
def test_solicitar_fondos_montos_solicitados(context):
cajero = context.cajeros[0]
caja = context.sucursal.cajas[0]
monto_apertura_caja = 0
apertura_caja = Apertura(
{m: monto_apertura_caja
for m in caja.monedas_permitidas})
driver_operador = context.driver_manager.main_driver
operador = context.operador_remesas
boveda = context.boveda
monto_apertura_boveda = 1000
apertura_boveda = Apertura(
{m: monto_apertura_boveda
for m in boveda.monedas_permitidas})
monedas = caja.monedas_permitidas.intersection(context.boveda.monedas)
solicitud = SolicitudFondo(caja, boveda,
{m: choice([20, 50])
for m in monedas})
transferencia = Transferencia(boveda, caja, solicitud.montos,
solicitud.observaciones)
login_action = LoginAction(context)
logout_action = LogoutAction(context)
apertura_action = AperturaOperableAction(context)
cierre_caja_action = CierreTotalCajaAction(context)
cierre_boveda_action = CierreOperableAction(context)
completar_solicitud_action = CompletarSolicitudFondosAction(context)
recibir_solicitud_action = RecibirSolicitudFondosAction(context)
aceptar_solicitud_action = AceptarSolicitudFondosAction(context)
confirmar_transferencia_action = ConfirmarTransferenciaAction(context)
transferencia_finalizada_action = TransferenciaFinalizadaAction(context)
with allure.step("El operador de remesas apertura la boveda general"):
login_action.verify_state().do(operador,
boveda).success("Apertura Boveda")
apertura_action.fast_forward(operador, boveda, apertura_boveda)
boveda.agregar_operacion(apertura_boveda)
driver_cajero = context.driver_manager.new_driver()
context.page.set_active_driver(driver_cajero)
with allure.step("El cajero apertura su caja"):
login_action.verify_state().do(cajero, caja).success("Apertura Caja")
apertura_action.fast_forward(cajero, caja, apertura_caja)
caja.agregar_operacion(apertura_caja)
with allure.step(
"El cajero genera una solicitud de fondos con montos sugeridos"):
completar_solicitud_action.verify_state(caja).do(
solicitud, cajero.password)
with allure.step("La solicitud se genera correctamnete"):
solicitud.codigo = completar_solicitud_action.success()
context.page.set_active_driver(driver_operador)
with allure.step(
"Boveda recibe la solicitud y la acepta con los montos sugeridos"):
recibir_solicitud_action.verify_state(boveda).do(solicitud).success()
aceptar_solicitud_action.verify_state(boveda,
solicitud).do(operador.password)
with allure.step("La solicitud se confirma y se genera la transferencia"):
transferencia.codigo = solicitud.codigo
aceptar_solicitud_action.success(transferencia)
boveda.agregar_operacion(transferencia)
context.page.set_active_driver(driver_cajero)
with allure.step(
"El cajero recibe la transferencia y confirma con montos correctos"
):
SolicitudFinalizadaAction(context).verify_state(caja).do(
solicitud).success("Aceptada")
transferencia.estado = confirmar_transferencia_action.fast_forward(
cajero, transferencia)
context.page.set_active_driver(driver_operador)
with allure.step("la transferencia se contabiliza y ya no se muestra"):
transferencia.estado = transferencia_finalizada_action.fast_forward(
transferencia)
caja.agregar_operacion(transferencia)
with allure.step(
"El operador de remesas realiza un cierre total correctamente"):
cierre_boveda = CierreTotal(boveda.balance())
cierre_boveda_action.fast_forward(operador, boveda, cierre_boveda)
context.boveda.agregar_operacion(cierre_boveda)
logout_action.verify_state(operador).do().success()
context.page.set_active_driver(driver_cajero)
with allure.step("El cajero realiza un cierre total correctamente"):
cierre_caja = CierreTotal(caja.balance())
cierre_caja_action.fast_forward(cajero, caja, cierre_caja)
caja.agregar_operacion(cierre_caja)
logout_action.verify_state(cajero).do().success()