From 9120d5c4ca77cfbca15efa553db688b1761ede53 Mon Sep 17 00:00:00 2001 From: bouclyma Date: Sat, 28 Dec 2024 02:16:25 +0100 Subject: [PATCH] feat(Event): Ajout classe Event --- chat/src/main/java/rtgre/modeles/Event.java | 52 ++++ .../test/java/rtgre/modeles/EventTest.java | 223 ++++++++++++++++++ 2 files changed, 275 insertions(+) create mode 100644 chat/src/main/java/rtgre/modeles/Event.java create mode 100644 chat/src/test/java/rtgre/modeles/EventTest.java diff --git a/chat/src/main/java/rtgre/modeles/Event.java b/chat/src/main/java/rtgre/modeles/Event.java new file mode 100644 index 0000000..9198f5e --- /dev/null +++ b/chat/src/main/java/rtgre/modeles/Event.java @@ -0,0 +1,52 @@ +package rtgre.modeles; + +import org.json.JSONException; +import org.json.JSONObject; + +public class Event { + public static final String AUTH = "AUTH"; + public static final String QUIT = "QUIT"; + public static final String MESG = "MESG"; + public static final String JOIN = "JOIN"; + public static final String POST = "POST"; + public static final String CONT = "CONT"; + public static final String LIST_CONTACTS = "LSTC"; + public static final String LIST_POSTS = "LSTP"; + public static final String SYSTEM = "SYST"; + private final String type; + private final JSONObject content; + + public String getType() { + return type; + } + + public JSONObject getContent() { + return content; + } + + public Event(String type, JSONObject content) { + this.type = type; + this.content = content; + } + + @Override + public String toString() { + return "Event{type=" + type + ", content=" + content.toString() + "}"; + } + + public JSONObject toJsonObject() { + return new JSONObject().put("type", type).put("content", content); + } + + public String toJson() { + return toJsonObject().toString(); + } + + public static Event fromJson(String json) throws JSONException { + JSONObject jsonObject = new JSONObject(json); + String type = jsonObject.getString("type"); + JSONObject content = jsonObject.getJSONObject("content"); + return new Event(type, content); + } +} + diff --git a/chat/src/test/java/rtgre/modeles/EventTest.java b/chat/src/test/java/rtgre/modeles/EventTest.java new file mode 100644 index 0000000..18c9795 --- /dev/null +++ b/chat/src/test/java/rtgre/modeles/EventTest.java @@ -0,0 +1,223 @@ +package rtgre.modeles; + +import org.json.JSONException; +import org.json.JSONObject; +import org.junit.jupiter.api.*; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; + +import java.lang.reflect.Constructor; +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.lang.reflect.Modifier; +import java.util.Arrays; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +import static org.junit.jupiter.api.Assertions.*; +import static org.junit.jupiter.params.provider.Arguments.arguments; + +class EventTest { + + static Class classe = Event.class; + static String module = "rtgre.modeles"; + + // @Tag("01-mise_en_place_contact") + @DisplayName("01-Structure de Event") + @Nested + class StructureTest { + + static List constructeursSignatures; + static List methodesSignatures; + + @BeforeAll + static void init() { + Constructor[] constructeurs = classe.getConstructors(); + constructeursSignatures = Arrays.stream(constructeurs).map(Constructor::toString).collect(Collectors.toList()); + Method[] methodes = classe.getDeclaredMethods(); + methodesSignatures = Arrays.stream(methodes).map(Method::toString).collect(Collectors.toList()); + } + + static Stream constantesProvider() { + return Stream.of( + arguments("AUTH", "AUTH"), + arguments("QUIT", "QUIT"), + arguments("MESG", "MESG"), + arguments("JOIN", "JOIN"), + arguments("POST", "POST"), + arguments("CONT", "CONT"), + arguments("LIST_POSTS", "LSTP"), + arguments("LIST_CONTACTS", "LSTC"), + arguments("SYSTEM", "SYST") + ); + } + + @DisplayName("Déclaration des constantes") + @ParameterizedTest + @MethodSource("constantesProvider") + void testDeclarationConstantes(String constante, String value) throws NoSuchFieldException, IllegalAccessException { + Field field = classe.getField(constante); + Assertions.assertEquals(Modifier.PUBLIC | Modifier.FINAL | Modifier.STATIC, field.getModifiers(), + "Visibilité " + constante + " erronée"); + Assertions.assertEquals("java.lang.String", field.getType().getName(), + "Type " + constante + " erroné"); + Assertions.assertEquals(value, field.get(null), "Valeur " + constante + " erronée"); + } + + + static Stream attributsProvider() { + return Stream.of( + arguments("type", "java.lang.String", Modifier.PRIVATE | Modifier.FINAL), + arguments("content", "org.json.JSONObject", Modifier.PRIVATE | Modifier.FINAL) + ); + } + + @DisplayName("Déclaration des attributs") + @ParameterizedTest + @MethodSource("attributsProvider") + void testDeclarationAttributs(String nom, String type, int modifier) throws NoSuchFieldException { + Field field = classe.getDeclaredField(nom); + Assertions.assertEquals(type, field.getType().getName(), + "Type " + nom + " erroné : doit être " + type); + Assertions.assertEquals(modifier, field.getModifiers(), + "Visibilité " + nom + " erronée : doit être " + modifier); + + } + + static Stream constructeursProvider() { + return Stream.of( + arguments("public %s.Event(java.lang.String,org.json.JSONObject)") + ); + } + + @DisplayName("Déclaration des constructeurs") + @ParameterizedTest + @MethodSource("constructeursProvider") + void testConstructeurs1(String signature) { + Assertions.assertTrue(constructeursSignatures.contains(String.format(signature, module)), + String.format("Constructeur non déclaré : doit être %s\nalors que sont déclarés %s", + signature, constructeursSignatures)); + + } + + static Stream methodesProvider() { + return Stream.of( + arguments("getType", "public java.lang.String %s.Event.getType()"), + arguments("getContent", "public org.json.JSONObject %s.Event.getContent()"), + arguments("toString", "public java.lang.String %s.Event.toString()"), + arguments("toJsonObject", "public org.json.JSONObject %s.Event.toJsonObject()"), + arguments("toJson", "public java.lang.String %s.Event.toJson()"), + arguments("fromJson", "public static %s.Event %s.Event.fromJson(java.lang.String) throws org.json.JSONException") + ); + } + + @DisplayName("Déclaration des méthodes") + @ParameterizedTest + @MethodSource("methodesProvider") + void testDeclarationMethodes1(String nom, String signature) { + Assertions.assertTrue(methodesSignatures.contains(String.format(signature, module, module)), + String.format("Méthode non déclarée : doit être %s\nalors que sont déclarés %s", + signature, methodesSignatures)); + } + } + + @DisplayName("02-Instanciation d'un évènement") + @Nested + class InstanciationTest { + + @Test + @DisplayName("Constructeur par défaut") + void TestContructeurParDefaut() { + JSONObject json = new JSONObject("{\"login\":\"riri\"}"); + Event event = new Event("AUTH", json); + Assertions.assertEquals("AUTH", event.getType(), "Type erroné"); + Assertions.assertEquals(json, event.getContent(), "Content erroné"); + } + + + + } + + @DisplayName("03-Instanciation fromJSON") + @Nested + class fromJSONTest { + + static Stream contentProvides() { + return Stream.of( + arguments("AUTH", "{\"type\":\"AUTH\",\"content\":{\"login\":\"riri\"}}"), + arguments("QUIT", "{\"type\": \"QUIT\",\"content\": {}}"), + arguments("MESG", "{\"type\": \"MESG\",\"content\": {\"to\":\"DEST\",\"body\":\"BODY\"}}") + ); + } + @DisplayName("Récupération du type") + @ParameterizedTest + @MethodSource("contentProvides") + void TestContructeurType(String type, String json) { + Event event = Event.fromJson(json); + Assertions.assertEquals(type, event.getType(), "Type erroné"); + } + + static Stream keyProvides() { + return Stream.of( + arguments("login", "riri", "{\"type\":\"AUTH\",\"content\":{\"login\":\"riri\"}}"), + arguments("to", "DEST", "{\"type\": \"MESG\",\"content\": {\"to\":\"DEST\",\"body\":\"BODY\"}}"), + arguments("body", "BODY", "{\"type\": \"MESG\",\"content\": {\"to\":\"DEST\",\"body\":\"BODY\"}}") + ); + } + + @DisplayName("Récupération du contenu") + @ParameterizedTest + @MethodSource("keyProvides") + void TestContructeurContenu(String key, String value, String json) { + Event event = Event.fromJson(json); + Assertions.assertTrue(event.getContent().has(key), "Contenu erroné"); + Assertions.assertEquals(value, event.getContent().get(key), "Contenu erroné"); + } + + @DisplayName("Levée d'exception") + @Test + void TestFromJsonException() { + assertThrows(JSONException.class, () -> Event.fromJson("bonjour")); + } + } + + @Nested + @DisplayName("04-Méthodes") + + class TestMethodes { + @Test + @DisplayName("Méthode toString") + void TestToString() { + Event event = Event.fromJson("{\"type\":\"AUTH\",\"content\":{\"login\":\"riri\"}}"); + String repr = event.toString(); + Assertions.assertEquals("Event{type=AUTH, content={\"login\":\"riri\"}}", repr, "Représentation textuelle erronée"); + } + + @Test + @DisplayName("Méthode toJsonObject") + void TestToJsonObject() { + Event event = Event.fromJson("{\"type\":\"AUTH\",\"content\":{\"login\":\"riri\"}}"); + JSONObject json = event.toJsonObject(); + Assertions.assertTrue(json.has("type"), "Représentation JSON erronée"); + Assertions.assertEquals("AUTH", json.get("type"), "Représentation JSON erronée"); + Assertions.assertTrue(json.has("content"), "Représentation JSON erronée"); + Assertions.assertTrue(json.getJSONObject("content").has("login"), "Représentation JSON erronée"); + Assertions.assertEquals("riri", json.getJSONObject("content").get("login"), "Représentation JSON erronée"); + } + + @Test + @DisplayName("Méthode toJson") + void TestToJson() { + Event event = Event.fromJson("{\"type\":\"AUTH\",\"content\":{\"login\":\"riri\"}}"); + String json = event.toJson(); + Assertions.assertEquals("{\"type\":\"AUTH\",\"content\":{\"login\":\"riri\"}}", + json, "Sérialisation JSON erronée"); + } + + + } + + +} \ No newline at end of file