Validation Null aber nicht Blank und muss Email sein

Schuriko

Bekanntes Mitglied
Ich möchte in einer Entity ein Password Feld so kennzeichnen, dass es zwar null sein darf, aber nicht Blank. Wie kann ich soetwas realisieren?

Ich habe im Netz zwar etwas gefunden
Code:
@ConstraintComposition(CompositionType.OR)
@Constraint(validatedBy = {})
@Null
@NotBlank
@Target({ ElementType.FIELD, ElementType.PARAMETER })
@Retention(RetentionPolicy.RUNTIME)
public @interface NullOrNotBlank {

    String message() default "Must be null or not blank";

    Class<?>[] groups() default {};

    Class<? extends Payload>[] payload() default {};

}

Meine konkrete Entity sieht wie folgt aus
Code:
Entity(name="persons")
@Table(indexes = { @Index(name = "IDX_EMAIL_PASSWORD", columnList = "email, password") })
public class Person {
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private Long id;
   
        @CreationTimestamp
        private Date    created_at;
   
        @Null
        @OneToOne(cascade = CascadeType.REMOVE, fetch=FetchType.EAGER)
        @JoinColumn(name="created_by")      
        private Person    created_by;
   
        @UpdateTimestamp
        private Date    updated_at;
       
        @Null
        @OneToOne(cascade = CascadeType.REMOVE, fetch=FetchType.EAGER)  
        @JoinColumn(name="updated_by")      
        private Person    updated_by;  
           
        @NotNull
        @NotBlank
        @Length(min=3, max=255)
        private String firstname;  
           
        @NotNull
        @NotBlank
        @Length(min=3, max=255)
        private String lastname;  
           
        @NotNull
        @NotBlank
        @Length(min=3, max=255)
        @Email(message = "Email should be valid")
        private String email;  
           
        @NullOrNotBlank      
        @Length(min=6, max=255)
        private String password;  

        public Person() {
        }

        public Long getId() {
            return id;
        }

        public void setId(Long id) {
            this.id = id;
        }

        public Date getCreatedAt() {
            return created_at;
        }

        public void setCreatedAt(Date created_at) {
            this.created_at = created_at;
        }

        public Person getCreatedBy() {
            return created_by;
        }

        public void setCreatedBy(Person created_by) {
            this.created_by = created_by;
        }

        public Date getUpdatedAt() {
            return updated_at;
        }

        public void setUpdatedAt(Date updated_at) {
            this.updated_at = updated_at;
        }
       
        public Person getUpdatedBy() {
            return updated_by;
        }

        public void setUpdatedBy(Person updated_by) {
            this.updated_by = updated_by;
        }

        public String getFirstname() {
            return firstname;
        }

        public void setFirstname(String firstname) {
            this.firstname = firstname;
        }

        public String getLastname() {
            return lastname;
        }

        public void setLastname(String lastname) {
            this.lastname = lastname;
        }

        public String getEmail() {
            return email;
        }

        public void setEmail(String email) {
            this.email = email;
        }

        public String getPassword() {
            return password;
        }

        public void setPassword(String password) {
            this.password = password;
        }

        @Override
        public String toString() {
            return "Person [id=" + id + ", created_at=" + created_at + ", created_by=" + created_by + ", updated_at="
                    + updated_at + ", updated_by=" + updated_by + ", firstname=" + firstname + ", lastname=" + lastname
                    + ", email=" + email + ", password=" + password + "]";
        }
}

meine Testklasse scheint nicht zu greifen
Code:
import static org.junit.Assert.*;

import java.util.Date;
import java.util.Optional;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import com.project.entities.Person;

@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonRepositoryTest {
   
        @Autowired
        PersonRepository personRepository;

        @Before
        public void setUp() throws Exception {
        }
       
        /**
         * test a correct person class password with null
         *
         * @return void
         */
        @Test
        public void testPasswordWithNull() {
            Date dateValue = new Date();
            String firstnameValue = "firstname";
            String lastnameValue = "lastname";
            String emailValue = "email@email.de";
            String passwordValue = null; // "a pasword";
            Person person = new Person();
           
            person.setFirstname(firstnameValue);
            person.setLastname(lastnameValue);
            person.setEmail(emailValue);
            person.setPassword(passwordValue);
           
            Boolean exception = false;
           
            try {
                personRepository.save(person);
            } catch (Exception e) { // password is null
                exception = true;
            }
           
            assertFalse(exception);
        }
       
        /**
         * test a correct person class passwword with blank
         *
         * @return void
         */
        @Test
        public void testPasswordWithBlank() {
            Date dateValue = new Date();
            String firstnameValue = "firstname";
            String lastnameValue = "lastname";
            String emailValue = "email@email.de";
            String passwordValue = ""; // "a pasword";
            Person person = new Person();
           
            person.setFirstname(firstnameValue);
            person.setLastname(lastnameValue);
            person.setEmail(emailValue);
            person.setPassword(passwordValue);
           
            Boolean exception = false;
           
            try {
                personRepository.save(person);
            } catch (Exception e) { // password is blank
                exception = true;
            }
           
            assertTrue(exception);
        }
       
        /**
         * test a correct person class passwword with empty String
         *
         * @return void
         */
        @Test
        public void testPasswordWithEmptyString() {
            Date dateValue = new Date();
            String firstnameValue = "firstname";
            String lastnameValue = "lastname";
            String emailValue = "email@email.de";
            String passwordValue = "          "; // "a pasword";
            Person person = new Person();
           
            person.setFirstname(firstnameValue);
            person.setLastname(lastnameValue);
            person.setEmail(emailValue);
            person.setPassword(passwordValue);
           
            Boolean exception = false;
           
            try {
                personRepository.save(person);
            } catch (Exception e) { // password has a empty string
                exception = true;
            }
           
            assertTrue(exception);
        }
       
}

Die Test Funktion testPasswordWithNull liefert Test-Fehler.
 
".+", wenn du die Länge da auch noch unterbringen willst ".{6,255}"

Als ganzes dann so:
Java:
@javax.validation.constraints.Pattern(regexp = ".{6,255}")
private String password;

🙄🙄
 
Ich habe es mal getestet
Code:
        @javax.validation.constraints.Pattern(regexp = ".{6,255}")
        // @Length(min=3, max=255)
        private String password;
für Person Entity

die Testfunktion
Code:
        @Test
        public void testPasswordWithNull() {
            Date dateValue = new Date();
            String firstnameValue = "firstname";
            String lastnameValue = "lastname";
            String emailValue = "email@email.de";
            String passwordValue = null; // "a pasword";
            Person person = new Person();
            
            person.setFirstname(firstnameValue);
            person.setLastname(lastnameValue);
            person.setEmail(emailValue);
            person.setPassword(passwordValue);
            
            Boolean exception = false;
            
            try {
                personRepository.save(person);
            } catch (Exception e) { // password is null
                exception = true;
            }
            
            assertFalse(exception);
        }

liefert mir für die assertFalse

java.lang.AssertionError
at org.junit.Assert.fail(Assert.java:86)
at org.junit.Assert.assertTrue(Assert.java:41)
at org.junit.Assert.assertFalse(Assert.java:64)
at org.junit.Assert.assertFalse(Assert.java:74)
at com.project.repositories.PersonRepositoryTest.testPasswordWithNull(PersonRepositoryTest.java:374)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
at java.lang.reflect.Method.invoke(Unknown Source)
at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)
at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:47)
at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)
at org.springframework.test.context.junit4.statements.RunBeforeTestExecutionCallbacks.evaluate(RunBeforeTestExecutionCallbacks.java:74)
at org.springframework.test.context.junit4.statements.RunAfterTestExecutionCallbacks.evaluate(RunAfterTestExecutionCallbacks.java:84)
at org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:26)
at org.springframework.test.context.junit4.statements.RunBeforeTestMethodCallbacks.evaluate(RunBeforeTestMethodCallbacks.java:75)
at org.springframework.test.context.junit4.statements.RunAfterTestMethodCallbacks.evaluate(RunAfterTestMethodCallbacks.java:86)
at org.springframework.test.context.junit4.statements.SpringRepeat.evaluate(SpringRepeat.java:84)
at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)
at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:251)
at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:97)
at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
at org.springframework.test.context.junit4.statements.RunBeforeTestClassCallbacks.evaluate(RunBeforeTestClassCallbacks.java:61)
at org.springframework.test.context.junit4.statements.RunAfterTestClassCallbacks.evaluate(RunAfterTestClassCallbacks.java:70)
at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.run(SpringJUnit4ClassRunner.java:190)
at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:89)
at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:41)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:541)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:763)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:463)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:209)
 
Lass dir mal die Exception loggen, du kannst gleich das ganze try-catch-Konstrukt weg nehmen, dann failed der Test vernünftig wegen der Exception. (Und wenn du doch auf Exceptions reagieren musst, nutz ein anderes Assertion-Framework, damit man nicht diesen try-catch-Hack nutzen muss 😉 )

Laufen alle erfolgreich durch:

Java:
public class ValidatorTest {

    private static Validator validator;

    @BeforeClass
    public static void setUp() {
        ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
        validator = factory.getValidator();
    }

    @Test
    public void personWithNullPasswordShouldBeValid() {
        Person person = new Person();
        person.password = null;

        Set<ConstraintViolation<Person>> constraintViolations = validator.validate(person);

        assertTrue(constraintViolations.isEmpty());
    }

    @Test
    public void personWith5CharPasswordShouldBeInvalid() {
        Person person = new Person();
        person.password = "a".repeat(5);

        Set<ConstraintViolation<Person>> constraintViolations = validator.validate(person);

        assertEquals(1, constraintViolations.size());
    }

    @Test
    public void personWith6CharPasswordShouldBeValid() {
        Person person = new Person();
        person.password = "a".repeat(6);

        Set<ConstraintViolation<Person>> constraintViolations = validator.validate(person);

        assertTrue(constraintViolations.isEmpty());
    }

    @Test
    public void personWith255CharPasswordShouldBeValid() {
        Person person = new Person();
        person.password = "a".repeat(255);

        Set<ConstraintViolation<Person>> constraintViolations = validator.validate(person);

        assertTrue(constraintViolations.isEmpty());
    }
    @Test
    public void personWith256CharPasswordShouldBeInvalid() {
        Person person = new Person();
        person.password = "a".repeat(256);

        Set<ConstraintViolation<Person>> constraintViolations = validator.validate(person);

        assertEquals(1, constraintViolations.size());
    }

    @Test
    public void personWithBlankPasswordShouldBeInvalid() {
        Person person = new Person();
        person.password = "";

        Set<ConstraintViolation<Person>> constraintViolations = validator.validate(person);

        assertEquals(1, constraintViolations.size());
    }

}



BTW: du speicherst nicht wirklich Klartext-Passwörter in der DB?
 
Lass dir mal die Exception loggen, du kannst gleich das ganze try-catch-Konstrukt weg nehmen, dann failed der Test vernünftig wegen der Exception. (Und wenn du doch auf Exceptions reagieren musst, nutz ein anderes Assertion-Framework, damit man nicht diesen try-catch-Hack nutzen muss 😉 )

Laufen alle erfolgreich durch:

Java:
public class ValidatorTest {

    private static Validator validator;

    @BeforeClass
    public static void setUp() {
        ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
        validator = factory.getValidator();
    }

    @Test
    public void personWithNullPasswordShouldBeValid() {
        Person person = new Person();
        person.password = null;

        Set<ConstraintViolation<Person>> constraintViolations = validator.validate(person);

        assertTrue(constraintViolations.isEmpty());
    }

    @Test
    public void personWith5CharPasswordShouldBeInvalid() {
        Person person = new Person();
        person.password = "a".repeat(5);

        Set<ConstraintViolation<Person>> constraintViolations = validator.validate(person);

        assertEquals(1, constraintViolations.size());
    }

    @Test
    public void personWith6CharPasswordShouldBeValid() {
        Person person = new Person();
        person.password = "a".repeat(6);

        Set<ConstraintViolation<Person>> constraintViolations = validator.validate(person);

        assertTrue(constraintViolations.isEmpty());
    }

    @Test
    public void personWith255CharPasswordShouldBeValid() {
        Person person = new Person();
        person.password = "a".repeat(255);

        Set<ConstraintViolation<Person>> constraintViolations = validator.validate(person);

        assertTrue(constraintViolations.isEmpty());
    }
    @Test
    public void personWith256CharPasswordShouldBeInvalid() {
        Person person = new Person();
        person.password = "a".repeat(256);

        Set<ConstraintViolation<Person>> constraintViolations = validator.validate(person);

        assertEquals(1, constraintViolations.size());
    }

    @Test
    public void personWithBlankPasswordShouldBeInvalid() {
        Person person = new Person();
        person.password = "";

        Set<ConstraintViolation<Person>> constraintViolations = validator.validate(person);

        assertEquals(1, constraintViolations.size());
    }

}



BTW: du speicherst nicht wirklich Klartext-Passwörter in der DB?
Nein natürlich nicht die Passwörter werden alle verschlüsselt
 
Ich habe es mal ausgetestet:
Code:
import java.util.Set;

import static org.junit.Assert.*;

import javax.validation.ConstraintViolation;
import javax.validation.Validation;
import javax.validation.Validator;
import javax.validation.ValidatorFactory;

import org.junit.Before;
import org.junit.Test;

public class ValidatorTest {
    private static Validator validator;

    @Before
    public void setUp() throws Exception {
        ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
        validator = factory.getValidator();
    }

    @Test
    public void personWithNullPasswordShouldBeValid() {
        Person person = new Person();
        person.setPassword(null);

        Set<ConstraintViolation<Person>> constraintViolations = validator.validate(person);

        assertTrue(constraintViolations.isEmpty());
    }

    @Test
    public void personWith5CharPasswordShouldBeInvalid() {
        Person person = new Person();
        person.setPassword(new String(new char[5]).replace("\0", "a"));

        Set<ConstraintViolation<Person>> constraintViolations = validator.validate(person);

        assertEquals(1, constraintViolations.size());
    }

    @Test
    public void personWith6CharPasswordShouldBeValid() {
        Person person = new Person();
        person.setPassword(new String(new char[6]).replace("\0", "a"));
        
        Set<ConstraintViolation<Person>> constraintViolations = validator.validate(person);

        assertTrue(constraintViolations.isEmpty());
    }

    @Test
    public void personWith255CharPasswordShouldBeValid() {
        Person person = new Person();
        person.setPassword(new String(new char[255]).replace("\0", "a"));

        Set<ConstraintViolation<Person>> constraintViolations = validator.validate(person);

        assertTrue(constraintViolations.isEmpty());
    }
    @Test
    public void personWith256CharPasswordShouldBeInvalid() {
        Person person = new Person();
        person.setPassword(new String(new char[256]).replace("\0", "a"));

        Set<ConstraintViolation<Person>> constraintViolations = validator.validate(person);

        assertEquals(1, constraintViolations.size());
    }

    @Test
    public void personWithBlankPasswordShouldBeInvalid() {
        Person person = new Person();
        person.setPassword("");
        
        Set<ConstraintViolation<Person>> constraintViolations = validator.validate(person);

        assertEquals(1, constraintViolations.size());
    }

}

Ich habe es an Java 8 entsprechend angepasst, da repeat Funktion erst ab Java 11+ zur Verfügung steht.

Ich erhalte allerdings beim Ausführen des Test:
java.lang.AssertionError
at org.junit.Assert.fail(Assert.java:86)
at org.junit.Assert.assertTrue(Assert.java:41)
at org.junit.Assert.assertTrue(Assert.java:52)
at com.abado.project.entities.ValidatorTest.personWithNullPasswordShouldBeValid(ValidatorTest.java:31)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
at java.lang.reflect.Method.invoke(Unknown Source)
at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)
at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:47)
at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)
at org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:26)
at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)
at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78)
at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57)
at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:89)
at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:41)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:541)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:763)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:463)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:209)

für jede Funktion eine assert Error.
 
Deine Person-Klasse enthält vermutlich noch mehr Constraints, als nur das Pattern? Ich hatte das für die Tests gekürzt...


Aber wie gesagt: nimm aus deinem Obigen Test mal das try-catch raus und lass die Exception fliegen, da wird vermutlich ein Grund drin stehen
 
Meine Person Class sieht momentan wie folgt aus:
Code:
import java.util.Date;

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Index;
import javax.persistence.JoinColumn;
import javax.persistence.OneToOne;
import javax.persistence.Table;
import javax.validation.constraints.Email;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Null;

import org.hibernate.annotations.CreationTimestamp;
import org.hibernate.annotations.UpdateTimestamp;
import org.hibernate.validator.constraints.Length;

@Entity(name="persons")
@Table(indexes = { @Index(name = "IDX_EMAIL_PASSWORD", columnList = "email, password") })
public class Person {
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private Long id;
    
        @CreationTimestamp
        private Date    created_at;
    
        @Null
        @OneToOne(cascade = CascadeType.REMOVE, fetch=FetchType.EAGER)
        @JoinColumn(name="created_by")       
        private Person    created_by;
    
        @UpdateTimestamp
        private Date    updated_at;
        
        @Null
        @OneToOne(cascade = CascadeType.REMOVE, fetch=FetchType.EAGER)   
        @JoinColumn(name="updated_by")       
        private Person    updated_by;   
            
        @NotNull
        @NotBlank
        @Length(min=3, max=255)
        private String firstname;   
            
        @NotNull
        @NotBlank
        @Length(min=3, max=255)
        private String lastname;   
            
        @NotNull
        @NotBlank
        @Length(min=3, max=255)
        @Email(message = "Email should be valid")
        private String email;   
            
        @javax.validation.constraints.Pattern(regexp = ".{6,255}")
        // @Length(min=3, max=255)
        private String password;   

        public Person() {
        }

        public Long getId() {
            return id;
        }

        public void setId(Long id) {
            this.id = id;
        }

        public Date getCreatedAt() {
            return created_at;
        }

        public void setCreatedAt(Date created_at) {
            this.created_at = created_at;
        }

        public Person getCreatedBy() {
            return created_by;
        }

        public void setCreatedBy(Person created_by) {
            this.created_by = created_by;
        }

        public Date getUpdatedAt() {
            return updated_at;
        }

        public void setUpdatedAt(Date updated_at) {
            this.updated_at = updated_at;
        }
        
        public Person getUpdatedBy() {
            return updated_by;
        }

        public void setUpdatedBy(Person updated_by) {
            this.updated_by = updated_by;
        }

        public String getFirstname() {
            return firstname;
        }

        public void setFirstname(String firstname) {
            this.firstname = firstname;
        }

        public String getLastname() {
            return lastname;
        }

        public void setLastname(String lastname) {
            this.lastname = lastname;
        }

        public String getEmail() {
            return email;
        }

        public void setEmail(String email) {
            this.email = email;
        }

        public String getPassword() {
            return password;
        }

        public void setPassword(String password) {
            this.password = password;
        }

        @Override
        public String toString() {
            return "Person [id=" + id + ", created_at=" + created_at + ", created_by=" + created_by + ", updated_at="
                    + updated_at + ", updated_by=" + updated_by + ", firstname=" + firstname + ", lastname=" + lastname
                    + ", email=" + email + ", password=" + password + "]";
        }
}
 
Wie gesagt: die Exception aus deinem Test oben wäre interessant.


Btw, Date solltest du mit einer Klasse aus der neuen Time-Api ersetzen 😉
 
Gestern war es schon zu spät, so dass ich vergessen hatte die anderen Felder zu setzen.

Ich habe mal einen Blank String Test geschrieben. Eine Bedingung an die Validation sollte auch sein, dass der folgende Test:
Code:
        @Test
        public void personWithBlankPasswordShouldBeInvalid() {
            String firstnameValue = "firstname";
            String lastnameValue = "lastname";
            String emailValue = "email@email.de";
            String passwordValue = new String(new char[25]).replace("\0", " ");           
            
            Person person = new Person();
            person.setFirstname(firstnameValue);
            person.setLastname(lastnameValue);
            person.setEmail(emailValue);
            person.setPassword(passwordValue);
            
            Set<ConstraintViolation<Person>> constraintViolations = validator.validate(person);

            assertEquals(1, constraintViolations.size());
        }
erfolgreich durchgeführt wird, sprich die Eingabe keine leeren Strings enthalten darf. Wie müsste ich den obigen RegEx abändern, damit dieser Test erfolgreich ist.
 
Supi, danke euch beiden es klappt. Habt ihr eine gute Seite wo genau RegEx, genauer gesagt den Pattern, erklärt wird? Ich tue mich da noch schwer mit.
 
Da bist Du nicht der einzige, vor allem, wenn es um komplexere Dinge geht. Reguläre Ausdrücke als solche sind relativ einfach und schön rekursiv definiert: Syntax und Semantik. Hier gibt es noch eine Zusammenfassung möglicher Konstrukte in Java: https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html#sum
Ich versuche gerad deinen angegebenes Pattern zu verstehen, um es auf mein Email Feld anzuwenden. Das Email Feld sollen nur gültige Emails oder NULL enthalten. Ich verstehe es nur noch so ganz. Könntest du dein Pattern etwas näher erklären, bitte?
 
(?=X) ist ein positiver look-ahead. Dabei wird - vorausblickend - geprüft, ob die Zeichenkette ab der aktuellen Position auf das angegebene Pattern X passt.

X ist in dem Fall .*\S.* (das dritte .* im Pattern aus Kommentar #16 ist überflüssig, weiß nicht, wo das herkam). Dabei ist .* eine beliebige Anzahl beliebiger Zeichen und \S ein Zeichen, das kein Whitespace ist.

Folglich matcht das Pattern .*\S.* beliebige Zeichenketten, die wenigstens ein Zeichen enthalten, das kein Whitespace ist. Sprich: nicht leere Strings.

Da das Pattern X nur vorausblickend geprüft wurde, wird nun die Zeichenkette anhand des restlichen Patterns überprüft. Dieses besteht aus .{6,255}, also 6 bis 255 Wiederholungen beliebiger Zeichen.
 

Neue Themen


Zurück
Oben