add

Author: Bascy6

app/src/test/java/hexlet/code/MapSchemaTest.java

@@ -4,10 +4,8 @@
 import hexlet.code.schemas.BaseSchema;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-
 import java.util.HashMap;
 import java.util.Map;
-
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
@@ -41,73 +39,63 @@ void testRequired() {
     void testSizeof() {
         schema.sizeof(2);
         assertTrue(schema.isValid(null));
-
         Map<String, String> data = new HashMap<>();
         data.put("key1", "value1");
         assertFalse(schema.isValid(data));
-
         data.put("key2", "value2");
         assertTrue(schema.isValid(data));
     }
 
     @Test
     void testMultipleConstraints() {
         schema.required().sizeof(2);
-
         Map<String, String> data = new HashMap<>();
         assertFalse(schema.isValid(null));
         assertFalse(schema.isValid(data));
-
         data.put("key1", "value1");
         assertFalse(schema.isValid(data));
-
         data.put("key2", "value2");
         assertTrue(schema.isValid(data));
-
         data.put("key3", "value3");
         assertFalse(schema.isValid(data));
     }
 
     @Test
     void testOverridingConstraints() {
         schema.sizeof(3).sizeof(2);
-
         Map<String, String> data = new HashMap<>();
         data.put("key1", "value1");
         data.put("key2", "value2");
-
         assertTrue(schema.isValid(data));
-
         data.put("key3", "value3");
         assertFalse(schema.isValid(data));
     }
 
     @Test
     void testShape() {
         Map<String, BaseSchema<?>> schemas = new HashMap<>();
-        schemas.put("firstName", validator.string().required());
-        schemas.put("lastName", validator.string().required().minLength(2));
-
+        schemas.put("firstName", validator.string().required().minLength(3));
+        schemas.put("lastName", validator.string().required().contains("ov"));
         schema.shape(schemas);
 
         Map<String, String> human1 = new HashMap<>();
         human1.put("firstName", "John");
-        human1.put("lastName", "Smith");
+        human1.put("lastName", "Smithov");
         assertTrue(schema.isValid(human1));
 
         Map<String, String> human2 = new HashMap<>();
-        human2.put("firstName", "John");
-        human2.put("lastName", null);
+        human2.put("firstName", "Jo");
+        human2.put("lastName", "Smithov");
         assertFalse(schema.isValid(human2));
 
         Map<String, String> human3 = new HashMap<>();
         human3.put("firstName", "Anna");
-        human3.put("lastName", "B");
+        human3.put("lastName", "Brown");
         assertFalse(schema.isValid(human3));
 
         Map<String, String> human4 = new HashMap<>();
         human4.put("firstName", "Anna");
-        human4.put("lastName", "Brown");
+        human4.put("lastName", "Petrov");
         assertTrue(schema.isValid(human4));
     }
 
@@ -116,15 +104,14 @@ void testShapeWithOptionalFields() {
         Map<String, BaseSchema<?>> schemas = new HashMap<>();
         schemas.put("firstName", validator.string().required());
         schemas.put("lastName", validator.string().minLength(2));
-
         schema.shape(schemas);
 
         Map<String, String> human1 = new HashMap<>();
         human1.put("firstName", "John");
         assertTrue(schema.isValid(human1));
 
         Map<String, String> human2 = new HashMap<>();
-        human2.put("firstName", "John");
+        human2.put("firstName", "Jo");
         human2.put("lastName", "B");
         assertFalse(schema.isValid(human2));
 
@@ -139,7 +126,6 @@ void testShapeWithDifferentTypes() {
         Map<String, BaseSchema<?>> schemas = new HashMap<>();
         schemas.put("name", validator.string().required());
         schemas.put("age", validator.number().required().positive());
-
         schema.shape(schemas);
 
         Map<String, Object> person1 = new HashMap<>();
@@ -154,17 +140,12 @@ void testShapeWithDifferentTypes() {
 
         Map<String, Object> person3 = new HashMap<>();
         person3.put("name", "John");
-        person3.put("age", 0);
+        person3.put("age", null);
         assertFalse(schema.isValid(person3));
 
         Map<String, Object> person4 = new HashMap<>();
-        person4.put("name", "John");
-        person4.put("age", null);
+        person4.put("name", null);
+        person4.put("age", 30);
         assertFalse(schema.isValid(person4));
-
-        Map<String, Object> person5 = new HashMap<>();
-        person5.put("name", null);
-        person5.put("age", 30);
-        assertFalse(schema.isValid(person5));
     }
 }

app/src/test/java/hexlet/code/ValidatorTest.java

@@ -54,7 +54,13 @@ void testContains() {
     @Test
     void testMultipleConstraints() {
         stringSchema.required().minLength(5).contains("hex");
+        assertFalse(stringSchema.isValid(null));
+        assertFalse(stringSchema.isValid(""));
+        assertFalse(stringSchema.isValid("test"));
         assertTrue(stringSchema.isValid("hexagon"));
+        assertTrue(stringSchema.isValid("hexlet"));
+        assertFalse(stringSchema.isValid("hex"));
+        assertTrue(stringSchema.isValid("hexagonhex"));
     }
 
     @Test
@@ -75,9 +81,24 @@ void testShape() {
         person1.put("lastName", "Petrov");
         assertTrue(mapSchema.isValid(person1));
 
+        Map<String, String> person2 = new HashMap<>();
+        person2.put("firstName", "Yan");
+        person2.put("lastName", "Ivanov");
+        assertFalse(mapSchema.isValid(person2));
+
+        Map<String, String> person3 = new HashMap<>();
+        person3.put("firstName", "Ya");
+        person3.put("lastName", "Petrov");
+        assertFalse(mapSchema.isValid(person3));
+
+        Map<String, String> person4 = new HashMap<>();
+        person4.put("firstName", "yana");
+        person4.put("lastName", "Petro");
+        assertFalse(mapSchema.isValid(person4));
+
         Map<String, String> person5 = new HashMap<>();
-        person5.put("firstName", "yana");
+        person5.put("firstName", "Yan");
         person5.put("lastName", "Petrov");
-        assertTrue(mapSchema.isValid(person5));
+        assertFalse(mapSchema.isValid(person5));
     }
 }