Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Revisando nuestro proyecto

7/16
Recursos

Aportes 93

Preguntas 3

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

Validate.php
– le indicamos que permite números, letras mayúsculas y minúsculas, entre 6 y 9 caracteres si, no cumple esa regla, dará falso

    public static function password($value)
    {
        return (bool) preg_match('/^[0-9a-zA-Z]{6,9}$/',$value);
    }

ValidateTest.php

    public function test_password()
    {
        $password  = Validate::password('Abc1234VS');
        $this->assertTrue($password);

        $password  = Validate::password('Abc1w');
        $this->assertFalse($password);
    }

De hecho prácticamente lo que hace PHP Unit es crear pequeños casos de pruebas y dejarlos programados para testearlos siempre, así puedes usar tus clases sin preocupación, literal te está ahorrando el trabajo de ir a navegador y poner los datos de prueba tu mismo para empezar a depurar jaja

Reto cumplido!

La expresión regular /^(?=.\d)(?=.[\u0021-\u002b\u003c-\u0040])(?=.[A-Z])(?=.[a-z])\S{8,16}$/ significa:
La contraseña debe tener al entre 8 y 16 caracteres, al menos un dígito, al menos una minúscula y al menos una mayúscula. Puede tener otros símbolos.
Es importante resaltar que existen 2 tipos de filtros, uno de validación y otro de saneamiento como los podemos ver en https://www.php.net/manual/es/filter.filters.php

Para Password lo que hice fue utilizar el método password_hash() y PASSWORD_BCRYPT. Quedando de la siguiente manera:

Validate.php

public static function password($value){
    return (bool) password_hash($value, PASSWORD_BCRYPT);
  }

ValidateTest.php

public function test_password(){
    $password = Validate::password('1234567');
    $this->assertTrue($password);
  }

Jalando y funcionando 😃

Validar un password con mínimo ocho caracteres, al menos una letra mayúscula, una letra minúscula, un número y un carácter especial:

Validate.php

    public static function password($value)
    {
        return (bool) preg_match('/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\[email protected]$!%*?&]{8,}$/', $value);
    }

ValidateTest.php

    public function test_password()
    {
        $password = Validate::password('Contrasena2020*');
        $this->assertTrue($password);

        $password = Validate::password('Contrasena');
        $this->assertFalse($password);
    }

La pedagogía de Italo y la paciencia con la que explica le da un plus enorme a sus cursos.

Si desean profundizar un poco más les deseo leer sobre TDD (Test Driven Development). Es una metodología que nos permite desarrollar en base a nuestras pruebas.

Podemos crear un alias para no tener que escribir toda la ruta hacia el ejecutable de phpunit:

alias t="vendor/phpunit/phpunit/phpunit"

Se me voló la cabeza 🤯, antes de iniciar esta carrera de php hice un curso básico de php e hice un proyecto con programación estructurada, realmente me costo hacerlo y cree un código espagueti horrible pero viendo como funciona phpunit todo esto cambia, no puedo esperar Laravel.


ValidateTest.php

Creé un test para validar el password y pruebo lo siguiente:

  • números
  • usando números y letras minúsculas
  • números con letras minúsculas y mayúsculas
public function test_password()
    {
        $url = Validate::password('123456');
        $this->assertTrue($url);

        $url = Validate::password('12345');
        $this->assertFalse($url);

        $url = Validate::password('123456789');
        $this->assertTrue($url);

        $url = Validate::password('1234567890');
        $this->assertFalse($url);

        $url = Validate::password('123dsfasd');
        $this->assertTrue($url);

        $url = Validate::password('123dsfasda');
        $this->assertFalse($url);

        $url = Validate::password('123ADfasd');
        $this->assertTrue($url);

        $url = Validate::password('123dsfaADFsda');
        $this->assertFalse($url);
    }

ValidateTest.php

Creé una expresión regular que permita números, letras minúsculas y mayusculas, limitando sus caracteres entre 6 y 9.

public static function password($value)
    {
        return (bool)preg_match('/^[0-9a-zA-Z]{6,9}$/', $value);
    }

Acá mi solución al reto:
En ValidateTest.php:

public function test_password() //probar la url con la clase Validate
    {
        $pass = Validate::password('123456');
        $this-> assertTrue($pass);

        $pass = Validate::password('12345');
        $this-> assertFalse($pass);
        
        $pass = Validate::password('A123456');
        $this-> assertFalse($pass);
    }

en Validate.php:

public static function password($value)
    {
       return (bool) filter_var($value,FILTER_VALIDATE_REGEXP,array(
        "options" => array("regexp"=>"/^[0-9]{6,9}$/")
   ));
    }

En este caso, revisando la documentación de los FILTER_VALIDATE, vi que existe el FILTER_VALIDATE_REGEXP y se debe usar con un array de esa forma.
Por último, en mi index.php:

$VALIDATION_PASS= App\Validate::password('87289a');

if ($VALIDATION_PASS === true){
    echo "Su contraseña es válida <br>";
}
else{
    echo 'Su contraseña no cumple con los requisitos <br>';
}

Reto:
Validate.php:

<?php

namespace App;

class Validate
{
    public static function password($value)
    {
        return (boolean) preg_match('/^[0-9]{3,9}$/',$value);
    }
}

ValidateTest.php:

<?php

use PHPUnit\Framework\TestCase;
use App\Validate;

class ValidateTest extends TestCase
{
    public function test_pass()
    {
        $pass = Validate::password('123456');
        $this->assertTrue($pass);
    }
}

ValidateTest.php

public function test_password()
    {
        $password = Validate::password('asdfas');
        $this->assertTrue($password);
        $password = Validate::password('as2sdf2');
        $this->assertFalse($password);
    }

Validade.php

public static function password($value){
        return (bool) preg_match('/^[a-z]{6,9}$/', $value);
    }

El metodo a validar:

public static function passwd($value)
    {
        return (bool) preg_match('/^[A-Za-z0-9\[email protected]$!%*?&]{6,12}$/', $value);
    }

El metodo que valida:

public function test_passwd()
    {
        $passwd = Validate::passwd('Lerolero78?*');
        $this->assertTrue($passwd);

        $passwd = Validate::passwd('An8=n');
        $this->assertFalse($passwd);
    }

Que saltos cuanticos tan feos da el profe…

Parare mi aprendizaje en este curso hasta aqui vengo en el futuro a retomarlo 😦

Buenas! Comparto mi resolución al reto. Saludos!


ValidateTest.php

<?php

use PHPUnit\Framework\TestCase;
use App\Validate;


class ValidateTest extends TestCase
{   
    //comprobamos si un email es correcto
    public function test_email()
    {
        $email = Validate::email('[email protected]');
        $this->assertTrue($email);
    }
    //comprobamos si existe una url
    public function test_url()
    {
        $url = Validate::url('https://platzi.com');
        $this->assertTrue($url);
    }
    //comprobamos si una password cumple con una expresión
    public function test_password()
    {
        $password = Validate::password('1234567');
        $this->assertTrue($password);
    }
}

Validate.php

<?php

namespace App;

class Validate 
{
    public static function email($value)
    {
        return (bool) filter_var($value, FILTER_VALIDATE_EMAIL);
    }

    public static function url($value)
    {
        return (bool) filter_var($value, FILTER_VALIDATE_URL);
    }

    public static function password($value)
    {
         
        return (bool) preg_match('/^[0-9]{6,9}$/', $value);
    }
    
}

Resultado de la prueba

Ahh, ahora entendí estaba re perdido en la clase anterior

Creo que se podria validar tablas o funciones hacia bases de datos, una funcion para obtener un formulario la verdad es muy util y interesante esto de los test
ValidateTest

public function test_password()
    {
        $password = Validate::password('123456');
        $this->assertTrue($password);
        $password = Validate::password('12s3456');
        $this->assertFalse($password);
    }

Validate

    public static function password($pass)
    {
        return (bool)preg_match('/^[0-9]{6,9}$/',$pass);
    }

ValidateTest.php

    public function test_pass() {
        $email = Validate::pass('123456');
        $this->assertTrue($email);

        $email = Validate::pass('1234567890');
        $this->assertFalse($email);

        $email = Validate::pass('123456a');
        $this->assertFalse($email);
    }

Validate.php

    public static function pass($var) {
        return (bool) preg_match('/^[0-9]{6,9}$/', $var);;
    }


Despues de tanto luchar con la version de php, este es el reto:

public static function password($value)
{
	return (bool) preg_match('/^[0-9]{6,9}$/', $value);
 }
public function test_password()
    {
        $password = Validate::password('123456');
        $this->assertTrue($password);
        $password = Validate::password('123456a');
        $this->assertFalse($password);
    }

RETO

Test

public function test_password(){
        $password = Validate::password('Ax%2090-45');
        $this->assertTrue($password);
        
        
        $password = Validate::password('ax%2090-');
        $this->assertFalse($password);
    }

Function

 public static function password($value){
        return (bool) preg_match("/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\[email protected]$!%*?&-]{8,}$/",$value);
    }

Buen curso

Esta clase esta genial, nunca había usado composer y aquí veo mucha utilidad

Reto cumplido 😄

Escribe en terminal

php .\vendor\phpunit\phpunit\phpunit --testdox

ValidateTest.php

<?php

use PHPUnit\Framework\TestCase;
use App\Validate;

class ValidateTest extends TestCase
{
    public function testEmailHasTheCorrectFormat()
    {
        $this->assertTrue(Validate::email('[email protected]'));

        $this->assertFalse(Validate::email('[email protected]@gmail.com'));
    }

    public function testUrlHasTheCorrectFormat()
    {
        $this->assertTrue(Validate::url('https://sistenet.mx'));

        $this->assertFalse(Validate::url('sistenet.mx'));
    }

    public function testPasswordHasTheCorrectFormat()
    {
        $this->assertTrue(Validate::password('A1B2C3D4E5'));

        $this->assertFalse(Validate::password('@#[email protected]#asda.0a.a0sda.sd'));
    }
}

Lo logré! 😁

En el archivo “Validate.php”, agregué el siguiente método:

    public static function password($value)
    {
        return (bool) preg_match('/^[0-9]{6,9}$/', $value);
    }

Y en el “ValidateTest.php” agregué esta función:

    public function test_password()
    {
        $password = Validate::password('123456');
        $this->assertTrue($password);

        $password = Validate::password('12345e6');
        $this->assertFalse($password);
    }

Funciona! 🔥

  public static function pass($value)
  {
    return (bool) preg_match('/^[0-9a-z]{6,9}$/', $value);
  }

  public function password()
  {
    $pass = Validate::pass('');
    $this->assertIsBool($pass);
  }
var_dump(App\Validate::pass('123456'));

Les comparto el ejercicio de validar contraseña con las siguientes reglas:

  • Debe tener al menos 8 caracteres.
  • Debe tener al menos una mayúscula.
  • Debe tener al menos un número.
  • Debe tener uno de los siguientes símbolos: [email protected]$!%*#?&_
#Validate.php
public static function password($value) {
        return (bool)  preg_match('/^(?=.*[A-Za-z])(?=.*[@$!%*#?&_])[A-Za-z\[email protected]$!%*#?&_]{8,}$/', $value);
    }

#ValidateTest.php
public function test_password() {
        $password = Validate::password('Platzi#2021');
        $this->assertTrue($password);

        $password = Validate::password('platzi');
        $this->assertFalse($password);
    }

Este sería el método en la clase Validación.
Spoiler: Añadí alguna modificación al tipo de password para que aceptara letras en mayusculas y minusculas.

public static function password($value){
        return (bool) preg_match('/^[0-9,a-z,A-Z]{6,9}$/', $value);
    }

Y este sería el método de Test

public function test_password(){
        $pass = Validacion::password('12345670');
        $this->assertTrue($pass);

        $pass = Validacion::password('1P3z45Aj');
        $this->assertTrue($pass);

        $pass = Validacion::password('1234');
        $this->assertFalse($pass);

        $pass = Validacion::password('a124Z');
        $this->assertFalse($pass);

    }

Respuesta al reto
Test del Validate

Este profe deberia hacer mas cursooooooos, estoy tomando PHP porque me lo piden en la uni, me encantaria verlo en cursos de mi interes jasajs

src/validate

    public static function Password(string $value): bool
    {
        $pattern = '/^[0-9]{6,9}$/';
        return ((bool)preg_match($pattern, $value));
    }

tests/ValidateTest

    public function test_pass()
    {
        $pass = Validate::Password('4541457');
        $this->assertTrue($pass);

        $pass = Validate::Password('4541a');
        $this->assertFalse($pass);

        $pass = Validate::Password('744541a');
        $this->assertFalse($pass);


    }

En el reto me surgió una duda de que pasa si coloco espacios en un password y al poner lo simplemente no los tomaba en cuenta alguien podría explicarme a que se debe esto?, a pesar que restringía el uso a solo números el espacio no se tomaba en cuenta.

public function test_pasword()
{
    $password = Validate::password_verify('0123456789','/^[::digit::]$/');
    $this->assertTrue($password);
    $url = Validate::url('[email protected]','/^[::digit::][::upper::][::lower::][::punct::]$/');
    $this->assertTrue($password);
    $url = Validate::url('[email protected]','/^[0-9][Aa-Zz]{6,30}$/');
    $this->assertTrue($password);

}

validar password

<?php

namespace App;

class Validate {

	public static function validateEmail($email) {
		return (bool)filter_var($email, FILTER_VALIDATE_EMAIL);
	}

	public static function validateUrl($url) {
		return (bool)filter_var($url, FILTER_VALIDATE_URL);
	}

	public static function validatePassword($password) {
		return (bool)preg_match('/^[0-9]{6,9}$/', $password);
	}
}

como la exoresion regular hace varias validaciones hago un test para cada una de ellas

class ValidaTest:

public function test_password()
    {

        $password = Validate::password(435876);
        $this->assertTrue($password);

        $password = Validate::password('435876');
        $this->assertTrue($password);

        $password = Validate::password('435876a');
        $this->assertFalse($password);

        $password = Validate::password(987987435876);
        $this->assertFalse($password);

        $password = Validate::password(98798);
        $this->assertFalse($password);
    }

class Validate:

public static function password($value)
    {
        return (bool) preg_match('/^[0-9]{6,9}$/',$value);

    }

Podemos decir que un metodo solo puede tener dos asesriones (verdadero/falso)? O existen otro tipo de asersiones que se puedan implementar?

Para el archivo validate.php

  • Se indica que se va pasar una regexp que permite letras minúsculas, mayúsculas y puntos. además de que debe ser de mínimo 8 y máximo 9 caracteres si cumple la regla devolverá true si entonces será false.
public static function password($value) {
        $regexp = '/^[0-9a-zA-Z.]{8,15}/';
        $options = ['options' => [
		'regexp' => $regexp
	]];
        return (bool) filter_var($value, FILTER_VALIDATE_REGEXP, $options);
    }

Según la documentación https://www.php.net/manual/es/function.filter-var.php si el filtro permite opciones entonces se las pasaremos como un array bidimensional.

Archivo validateTest.php

public function test_password(){

        $password = Validate::password('testpass9.');
        $this->assertTrue($password);

        $password = Validate::password('1234567');
        $this->assertFalse($password);
    }

En el archivo Validate

/**
     * La contraseña debe tener al entre 8 y 16 caracteres, al menos un dígito, 
     * al menos una minúscula y al menos una mayúscula.
     * NO puede tener otros símbolos.
     */
    public static function password($value){
        return (bool) preg_match('/^(?=\w*\d)(?=\w*[A-Z])(?=\w*[a-z])\S{8,16}$/', $value);
    }

En el archivo ValidateTest

public function test_password()
    {
        $pass = Validate::password("Reto1Cumplido");
        $this->assertTrue($pass);
        
        $pass = Validate::password("cumplido");
        $this->assertFalse($pass);
    }

Validate.php

    public static function password($value){
        return (bool) filter_var($value, FILTER_VALIDATE_REGEXP, array("options"=>array("regexp"=>"/^[0-9]{6}[a-z]{2}$/")));
    }

ValidateTest.php

    public function test_password(){
        $url = Validate::password('123456ab');
        $this->assertTrue($url);
        $url = Validate::password('12345678');
        $this->assertFalse($url);
    }```

Siguiendo el ejemplo de la funcion filter_var() y sus banderas:
Validate.php
<code>
public static function password($value){
return (bool) filter_var($value, FILTER_VALIDATE_REGEXP, array(“options”=>array(“regexp”=>"/^[0-9]{6}[a-z]{2}$/")));
}
</code>

y el test:
ValidateTest.php
<code>
public function test_password(){
$url = Validate::password(‘123456ab’);
$this->assertTrue($url);
$url = Validate::password(‘12345678’);
$this->assertFalse($url);
}
</code>

y por qué en lugar de ejecutar vendor/phpunit/phpunit/phpunit, no ejecutar mejor:

vendor/bin/phpunit

El filtro es:

class Validate
{
    public static function password($value)
    {
        return (bool) preg_match('/^[0-9]{6,9}$/',$value);
    }
}

Ahora testeamos:

public function test_password()
    {
        $password = Validate::password('123456855');
        $this->assertTrue($password);
    }
    public static function password($value)
    {
        return (bool)  preg_match('/^[0-9]{6,9}$/', $value);
    }

TEST

public function test_password()
        {
            $password = Validate::password('123221sdaA');
            $this->assertTrue($password);

            $password = Validate::password('123');
            $this->assertFalse($password);
        }

VALIDATE

public static function password($value)
    {
        return (bool) preg_match('/^[0-9a-zA-Z]{8,256}$/',$value);
    }

Me gustan estas buenas practicas.

<h3>Solucion al reto</h3>
    public static function password( $value )
    {
        return (bool) preg_match( '/^[A-Za-z0-9]{8,15}$/', $value );
    }
    public function test_password()
    {
        $password = Validate::password('45353gfgre');
        $this->assertTrue( $password );

        $password = Validate::password('erw434');
        $this->assertFalse( $password );
    }

Se valida el codigo desarrollado respaldado con las pruebas

Excelente

validate.php

<?php

namespace App;

class Validate{
	public static function password($value){
		return (bool) preg_match('/^[0-9]{6,9}$/', $value);
	}
}

validatetest.php

<?php

use PHPUnit\Framework\TestCase;
use App\Validate;

class ValidateTest extends TestCase{
	public function test_password(){
		$password = Validate::password('1234567');
		$this->assertTrue($password);

		$password = Validate::password('1234');
		$this->assertFalse($password);

	}
}

index.php

<?php

require __DIR__ . '/vendor/autoload.php';

var_dump(App\Validate::password('12345'));

Validate.php

  public static function password($value) {
    return (bool) preg_match('/^[0-9]{6,9}$/', $value);
  }

ValidateTest.php

  public function test_password() {
    $password = Validate::password('123456789');
    $this->assertTrue($password);

    $password = Validate::password('123gfdg89');
    $this->assertFalse($password);
  }

Muy buena explicación. Ahora me entero la gran utilidad de hacer pruebas durante la implementación de nuevo código y mantenimiento. Muchas gracias!

Al momento de realizar la prueba de la URL me despliega error ![](
Espero de su apoyo por favor

![](

Validatetest.php

//VALIDA LAS CONTRASENAS
    public function test_contrasenias ()
    {
        //verdadero 
        $contrasenias = Validate::contrasenias('123456789');
        $this->assertTrue($contrasenias);
        //falso
        $contrasenias = Validate::contrasenias('1sas');
        $this->assertFalse($contrasenias);       
    }

Validate.php

public static function contrasenias($value) 
    {
        return(bool) preg_match('/^[0-9]{6,9}$/', $value);
    }

index.php


//para probar las contrasenias
var_dump(App\Validate::contrasenias('12345678')); //verdadero
var_dump(App\Validate::url('sdwew456'));  //falso

Resumen de Clase y Solución al reto

![](

ValidateTest.php
public function test_password()
{
$password = Validate::password(‘Tbcronk123456’);
$this->assertTrue($password);
}

Validate.php
public static function password($value)
{
return (bool) preg_match(’/^[a-zA-Z0-9]{10,35}$/’, $value);
}

Hola comunidad, les recomiendo utilizar expresiones regulares que ya han sido creadas en internet, sólo las llevan después al código y vean si funcionan con phpunit.

Les comparto mi prueba de validación de contraseñas en el archivo Validate.php

public static function password($value)
    {
        return (bool) preg_match('/^(?=.*\d)(?=.*[a-z])(?=.*[A-Z])(?=.*[a-zA-Z]).{8,16}$/', $value);;
    }

El test en ValidateTest.php

public function test_password()
    {
        $password = Validate::password('sTestkj90820');
        $this->assertTrue($password);

        $password = Validate::password('sTestkj9089320821');
        $this->assertFalse($password);
    }

Reto cumplido:
Validate.php
<?php

namespace App;

class Validate{

public static function email($email){
  return (bool) filter_var($email,FILTER_VALIDATE_EMAIL);
}

public static function valpass($pass){
  return (bool) preg_match('/^[0-9]{6,9}$/',$pass); 
  
}	

}

ValidateTest.php
<?php

use PHPUnit\Framework\TestCase;
use App\Validate;

class ValidateTest extends TestCase{
public function test_email(){

$email=Validate::email('[email protected]');  
$this->assertTrue($email);  

$email=Validate::email('[email protected]@gmail.com');  
$this->assertFalse($email); 

$pa=Validate::valpass('12345690');  
$this->assertTrue($pa);  

$pa=Validate::valpass('--sdlfmkasldk');  
$this->assertFalse($pa); 	

}
}

En el archivo Validate.php

La contraseña puede contener:

  • Números.
  • Letras de la ‘a’ a la ‘z’.
  • Letras de la ‘A’ a la ‘Z’.
  • Los caracteres ‘#’ y ‘_’
  • Con un mínimo de 6 caracteres y un máximo indefinido.

No se permiten espacios en blanco.

public static function password($value)
    {
        
        return (bool) preg_match('/^[0-9a-zA-Z_#}]{6,}$/',$value);
    }

En el archivo ValidateTest.php se llama a la función

public function test_password(){
    
        $password = Validate::password('3lon_Musk#1234');
        $this->assertTrue($password);
        $password = Validate::password('3lon _Musk#1234');
        $this->assertFalse($password);
    }

Mi solución al reto:
Validate.php

public static function password($value)
    {
	# Usando la expresion regular del video de expresiones regulares
        return (bool) preg_match('/^[0-9]{6,9}$/', $value);
    }

ValidateTest.php

public function test_password()
    {
	# Usando una contraseña correcta
        $password = Validate::password('0123456');
        $this->assertTrue($password);

        # Usando una contraseña incorrecta
        $password = Validate::password('0123456A');
        $this->assertFalse($password);
    }

Y el resultado seria:

Si el test falso, resultas ser verdadero, les mandara un error de que no puede retornar un faslo cuando es verdadero:

Failed asserting that true is false

vale creo que ya todo el mundo lo hizo peroigualmente lo subo jajaja

<?php

namespace App;

class Validate
{
    public static function email($value){
        return (bool)filter_var($value, FILTER_VALIDATE_EMAIL);
    }
    public static function url($value){
        return (bool)filter_var($value, FILTER_VALIDATE_URL);
    }
    public static function password($value){
        return (bool)preg_match('/^(?=\w*\d)(?=\w*[A-Z])(?=\w*[a-z])\S{8,16}$/',$value); //expresion regular para determinar si la contraseña tiene letra mayuscula, minuscula y caracteres especiales
    }
}
<?php

use PHPUnit\Framework\TestCase;
use App\Validate;

class ValidateTest extends TestCase
{
    public function test_email(){
        $email = Validate::email('[email protected]');
        $this->assertTrue($email);
        $email = Validate::email('[email protected]@rimorsoft.com');
        $this->assertFalse($email);
    }
    public function test_url(){
        $url = Validate::url('https://platzi.com');
        $this->assertTrue($url);
        $url = Validate::url('platzi.com');
        $this->assertFalse($url);
    }

    public function test_password(){
        $password = Validate::password('abcdefg');
        $this->assertFalse($password);
        $password = Validate::password('Adfgg122*');
        $this->assertTrue($password);
    }

}

Dato
Para los que les resulte un poco engorroso colocar el namespace\Clase en una misma línea pueden hacer uso de la palabra use con esto podrán directamente llamar a Validate por ejemplo: use App\Validate y luego al invocar la clase hacerlo con Validate simplemente, el use siempre va ubicado arriba de todo, adjunto un ejemplo:
![](

La magia de composer radica en que podemos cargar clases de manera automatica pero para ello tenemos que configurarlo

Aquí mi reto!

VALIDATE.PHP

    public static function password($value){
        return (bool) preg_match('/^[0-9]{5,9}$/',$value);
    }

TEST

    public function test_password(){
        $password =Validate::password('12345');
        $this->assertTrue($password);

        $password =Validate::password('12344eA');
        $this->assertFalse($password);
    }
public static function password($value)
    {
        //var_dump((bool) preg_match('/^[0-9]{6,9}$/', $password));
        return (bool) preg_match('/^[A-Za-z0-9]{6}$/', $value);
    }```

Desafío Realizado Profesor 🏁

Creación de la función para validar la contraseña

Creación del test para el password dentro de mi archivo ValidateTest

Resultado al correr las pruebas de phpunit

Challenge Complete

Configuración de composer.json

Configuración de phpunit.xml

Archivo de Test de Validación

Archivo de Lógica de Validación

Archivo de Prueba en el Servidor

Mi propuesta, de minimo ocho caracteres y valores alfa numericos

public static function password($value)
    {
        return (bool) preg_match('/\w{8}$/', $value);
    }

ValidateTest.php

    public function test_password()
    {
        $password = Validate::password('aB$1efgh');
        $this->assertTrue($password);

        $password = Validate::password('asbcdFGHI123');
        $this->assertFalse($password);

        $password = Validate::password('asbcdFGHI12*3');
        $this->assertTrue($password);

        $password = Validate::password('aSbcdFGHI123$a$24');
        $this->assertFalse($password);
    }```

Validate.php

public static function password($value)
{
$regex = “/^(?=.[a-z])(?=.[A-Z])(?=.\d)(?=.[[email protected]$!%?&])([A-Za-z\[email protected]$!%?&]|[^ ]){8,15}$/”;
return (bool) filter_var($value, FILTER_VALIDATE_REGEXP, [“options”=>[“regexp”=>$regex]]);
}
}


Mi solución al reto:

// Archivo ValidateTest.php
  public function test_password() {
    $password = Validate::password('12341234');
    $this->assertTrue($password);
  }

// Archivo Validate.php
  public static function password($value) {
    return (bool) preg_match('/^[0-9]{6,9}$/', $value);
  }

// ValidateTest.php

   public function test_password()
    {
        $pass = Validate::password('a23456');
        $this->assertFalse($pass);
    }


// Validate.php

  public static function password($value)
    {
        return (bool) preg_match('/^[0-9]{6,9}$/', $value);
    }

Archivo Validate.php

public static function password($password){
        return (bool) preg_match('/^[A-Za-z0-9]+$/',$password);
    }

Archivo ValidateTest.php

public function test_password(){
        $userPassword = 'pass1234';
        $password = Validate::password($userPassword);
        $this->assertTrue($password);
    }

Reto: Validar la contraseña

Archivo: Validate.php

public static function password($value)
    {
        return (bool)preg_match('/^[0-9]{6,9}$/',$value);
    }

Archivo: ValidateTest.php

public function test_password()
    {
        $password = Validate::password('123456');
        $this->assertTrue($password);
    }

Si desean probarlo en el navegador sería:

Archivo: index.php

var_dump(App\Validate::password('123456')); //Verdadero o True
var_dump(App\Validate::password('1234')); //Falso o False
<?php
///Validate.php
public static function password($value)
    {
    	/**
    	* Minimo 8 caracteres
		* Maximo 15
		* Al menos una letra mayúscula
		* Al menos una letra minucula
		* Al menos un dígito
		* No espacios en blanco
		* Al menos 1 caracter especial
    	*
    	*/
        return (bool) preg_match(' /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[[email protected]$!%*?&])[A-Za-z\[email protected]$!%*?&]{8,15}/',$value);
    }

/// ValidateTest.php
public function test_password()
    {
        $password  = Validate::password('Abc1234VS');
        $this->assertTrue($password);

        $password  = Validate::password('Abc1w');
        $this->assertFalse($password);
    }```
$course ='php';
function cv(&$course = 'laravel') /// cuando usamos & en variables damos acceso
{
    $course = 'arduino';
}
cv($course);
echo "curso = $course";
///devolvera arduino!!! 

Validate.php

public static function password($value)
    {
        $clave = '/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[[email protected]$!%*?&])([A-Za-z\[email protected]$!%*?&]|[^ ]){8,15}$/';
        return (bool) preg_match($clave, $value);
    }
}```

Esta es otra forma de nombrar los test.
Intentando siempre ser lo mas descriptivos posibles, así, si otro programador lee nuestro codigo entra más rapido en contexto de lo que se pretende obtener en el test.

	/**
    	 * @test
     	*/
    	public function it_is_a_valid_email()
	{
	
	}

ValidateTest.php
![](
Validate.php

Index.php

En Validate.php
// De 0 al 9, letras mayúsculas y minúsculas
// De 6 a 12 caracteres

public static function pass($value) {
	return (bool) preg_match('/^[0-9a-zA-Z]{6,12}$/',$value);
}

En ValidateTest.php

public function test_pass() {
	$pass = Validate::pass('Prueba1pass');
	$this->assertTrue($pass);
}

O también podriamos hacerlo así:

public function test_pass() {
	$pass = Validate::pass('Prueba1pass');
	$this->assertTrue($pass);

	$pass = Validate::pass('Prueba*1pass');
	$this->assertFalse($pass);
}
Reto completado con éxito

bueno algo simple

 public static function password($value)
    {
        return (bool) preg_match('/^[0-9]{6,9}$/', $value);
    }

y en el test

public function test_password()
    {
        $password = Validate::password('Libertad123');
        $this->assertFalse($password);

        $password = Validate::password('12345678');
        $this->assertTrue($password);
    }

Aporte

Código utilizado en el terminal

./vendor/bin/phpunit --testdox  tests

Codigo utilizado en las pruebas
ValidateTest.php

<?php

use PHPUnit\Framework\TestCase;
use App\Validate;

class ValidateTest extends TestCase
{
    public function testCorrectEmail() : void
    {
        $email = Validate::email('[email protected]');
        $this->assertTrue($email);

    }
    public function testDoubleArrobaEmail() : void
    {
        $email = Validate::email('[email protected]@rimorsoft.com');
        $this->assertFalse($email);
    }
}
public static function password(string $password) : bool
    {
        return (bool)preg_match(
            '/^(?=(.*[a-z]){3,})(?=(.*[A-Z]){2,})(?=(.*[0-9]){2,})(?=(.*[[email protected]#$%^&*()\-__+.]){1,}).{8,}$/', 
            $password);
    }
public function testPassword()
    {
        $result = Validate::password('PassWord#123');
        $this->assertTrue($result);

        $result = Validate::password('Password123');
        $this->assertFalse($result);
    }

Me encanto trabajar con PHPUnit, el poder testear las funciones o métodos de nuestro sistema de una manera sencilla, es muy bueno 😄


Reto completado.

Sólo me queda la duda frente a como incluir el control de espacios en las contraseñas creadas \S mediante expresiones regulares.
Validate.php

<?php

  namespace App;

  class Validate
  {
    public static function email($value)
  {
      return (bool) filter_var($value, FILTER_VALIDATE_EMAIL);
  }

  public static function url($value)
{
    return (bool) filter_var($value, FILTER_VALIDATE_URL);
}

  public static function password($value)
{
  return (bool) preg_match('/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@#$!%&*?-_])[A-Za-z\[email protected]#$!%&*?-_]{8,16}$/', $value);
}
  }

ValidateTest.php

<?php

  use PHPUnit\Framework\TestCase;
  use App\Validate;

  class ValidateTest extends TestCase
  {
    public function test_email()
    {
      $email = Validate::email('[email protected]');
      $this->assertTrue($email);

      $email = Validate::email('[email protected]@hotmail,com,');
      $this->assertFalse($email);
    }

    public function test_url()
    {
      $url = Validate::url('https://platzi.com');
      $this->assertTrue($url);

      $url = Validate::url('https://platzi.com,com');
      $this->assertFalse($url);
    }

    public function test_password()
    {
      $password = Validate::password('@Crturo123');
      $this->assertTrue($password);

      $password = Validate::password('@Irtur_**');
      $this->assertFalse($password);
    }
  }

Validar:

<class Validate
{
    public static function password($value)
    {
        return (bool) preg_match('/^[0-9]{6,9}$/',$value);
    }
}>

Testear:

<class ValidateTest extends TestCase
{
    public function test_password()
    {
        $pass = Validate::password('123456');
        $this->assertTrue($password);
    }
}>

Interesantes funciones