cleanup , add tests , add 'return to start' button

backend/src/main/java/Application.java

 
     public static void main(String [] args)
     {
-        Trait vExtrovertTrait = new Trait("Extrovert", "You're an extrovert");
-        Trait vIntrovertTrait = new Trait("Introvert", "You're an introvert");
-        Trait vDogTrait = new Trait("Dog", "You're a dog");
+
+        Questionnaire vQuestionnaire = getQuestionnaire();
+        //------------------------------------
+        // Start server
+        //------------------------------------
+        try {
+            HttpServer vServer = HttpServer.create(new InetSocketAddress(8080), 0);
+            vServer.createContext("/", new ResponseHandler());
+            vServer.setExecutor(null);
+            vServer.start();
+        }
+        catch(Exception ve)
+        {
+            ve.printStackTrace();
+        }
+    }
+
+    public static Questionnaire getQuestionnaire()
+    {
+        Trait vExtrovertTrait = new Trait("Extrovert", "You're an extrovert.");
+        Trait vIntrovertTrait = new Trait("Introvert", "You're an introvert.");
+        Trait vDogTrait = new Trait("Dog", "You're a dog that appears to know how to read.");
 
         //------------------------------------
         // Define questionnaire
         //------------------------------------
-        Questionnaire vQuestionnaire = new Questionnaire(
+        return new Questionnaire(
                 "Introvert or extrovert ?",
                 Arrays.asList(
                         //------------------------------------
                         // First question
                         //------------------------------------
                         new Question(
-                                "You're really busy at work and a colleague is telling you their life story and personal woes.",
+                                "You're really busy at work and a colleague is telling you their life story and personal woes, you :",
                                 Arrays.asList(
                                         new Answer("Don't dare to interrupt them", vIntrovertTrait, 0.5f),
-                                        new Answer("Think it's more important to give them some of your time; work can wait", vIntrovertTrait, 0.2f),
-                                        new Answer("Listen, but with only with half an ear ", vIntrovertTrait, 0.1f),
+                                        new Answer("Think it's more important to give them some of your time; work can wait", vExtrovertTrait, 0.2f),
+                                        new Answer("Listen, but with only with half an ear ", vIntrovertTrait, 0.2f),
                                         new Answer("Try to show interest despite being busy chasing your tail", vDogTrait, 0.8f),
                                         new Answer("Interrupt and explain that you are really busy at the moment", vExtrovertTrait, 0.5f)
                                 )
                         // Second question
                         //------------------------------------
                         new Question(
-                                "You've been sitting in the doctor's waiting room for more than 25 minutes.",
+                                "You've been sitting in the doctor's waiting room for more than 25 minutes, you :",
                                 Arrays.asList(
                                         new Answer("Look at your watch every two minutes", vIntrovertTrait, 0.2f),
                                         new Answer("Bubble with inner anger, but keep quiet ", vIntrovertTrait, 0.5f),
                                         new Answer("Explain to other equally impatient people in the room that the doctor is always running late ", vExtrovertTrait, 0.3f),
                                         new Answer("Complain in a loud voice, while tapping your foot impatiently", vExtrovertTrait, 0.7f),
-                                        new Answer("Befriend the teckel sitting next to you", vExtrovertTrait, 0.7f)
+                                        new Answer("Befriend the teckel sitting next to you", vDogTrait, 0.7f)
                                 )
                         ),
                         //------------------------------------
                         // Third question
                         //------------------------------------
                         new Question(
-                                "Blah blah blah ? Blah.",
+                                "How do you usually answer affirmatively ?",
                                 Arrays.asList(
                                         new Answer("Yes.", vIntrovertTrait, 0.2f),
                                         new Answer("Woof", vDogTrait, 0.7f),
-                                        new Answer("Sure", vExtrovertTrait, 0.3f),
-                                        new Answer("Meh", vExtrovertTrait, 0.7f)
-
+                                        new Answer("Absolutely !", vExtrovertTrait, 0.3f)
                                 )
                         ),
                         //------------------------------------
                         // Fourth question
                         //------------------------------------
                         new Question(
-                                "Blah blah blah ? Blah.",
+                                "When receiving guests, you don't appreciate :",
                                 Arrays.asList(
-                                        new Answer("Yes.", vIntrovertTrait, 0.2f),
-                                        new Answer("Woof", vDogTrait, 0.7f),
-                                        new Answer("Sure", vExtrovertTrait, 0.3f),
-                                        new Answer("Meh", vExtrovertTrait, 0.7f)
-
+                                        new Answer("People that don't feed the conversation.", vExtrovertTrait, 0.2f),
+                                        new Answer("Cats.", vDogTrait, 0.7f),
+                                        new Answer("Being the center of attention.", vIntrovertTrait, 0.3f)
                                 )
                         ),
                         //------------------------------------
                         // Fifth question
                         //------------------------------------
                         new Question(
-                                "Blah blah blah ? Blah.",
+                                "You can't find the keys to your car.",
                                 Arrays.asList(
-                                        new Answer("Yes.", vIntrovertTrait, 0.2f),
-                                        new Answer("Woof", vDogTrait, 0.7f),
-                                        new Answer("Sure", vExtrovertTrait, 0.3f),
-                                        new Answer("Meh", vExtrovertTrait, 0.7f)
+                                        new Answer("You search desperately without asking for help", vIntrovertTrait, 0.2f),
+                                        new Answer("You get everyone here to look with you.", vExtrovertTrait, 0.2f),
+                                        new Answer("You don't need to worry about car keys because you can't drive a car with your paws.", vDogTrait, 0.7f)
 
                                 )
                         )
                 )
         );
-
-        //------------------------------------
-        // Start server
-        //------------------------------------
-        try {
-            HttpServer vServer = HttpServer.create(new InetSocketAddress(8080), 0);
-            vServer.createContext("/", new ResponseHandler());
-            vServer.setExecutor(null);
-            vServer.start();
-        }
-        catch(Exception ve)
-        {
-            ve.printStackTrace();
-        }
     }
 
 }

backend/src/main/java/controller/SessionController.java

 package controller;
 
-import com.github.cliftonlabs.json_simple.JsonKey;
 import com.github.cliftonlabs.json_simple.JsonObject;
 import model.questionnaire.Answer;
 import model.questionnaire.Question;
         return vSession.asJsonObject();
     }
 
+    /**
+     *  For a specific question in a session, sets the given answer according to data in the json request body
+     * @param iID the session UUID
+     * @param iBody JSON Body containing tag 'question' and 'answer' with their respective UUIDs
+     * @return an empty JsonObject
+     * @throws Exception if the session, question or answer can't be found
+     */
     public JsonObject updateEntry(String iID, JsonObject iBody) throws Exception{
         Session vSession = Session.getSessionForUUID(UUID.fromString(iID));
         if(null == vSession)
 
         String vQuestionId = iBody.getString(KEY_QUESTION);
         String vAnswerId   = iBody.getString(KEY_ANSWER);
+        if(null == vQuestionId || null == vAnswerId )
+            throw new Exception(String.format("Tags '%s' & '%s' expected in request body",KEY_QUESTION.getKey(), KEY_ANSWER.getKey()));
         Question vQuestion = Question.getForUUID(UUID.fromString(vQuestionId));
         if(null == vQuestion)
             throw new Exception(String.format("No question for UUID %s",vQuestionId));
         Answer vAnswer = vQuestion.getAnswerForUUID(UUID.fromString(vAnswerId));
         if(null == vAnswer)
-            throw new Exception(String.format("No answer at index %d", vAnswerId));
+            throw new Exception(String.format("No answer for UUID %s", vAnswerId));
 
         vSession.getSessionAnswers().setAnswer(vQuestion, vAnswer);
         System.out.println(vSession.asJsonObject().toString());

backend/src/main/java/model/personnality/Personality.java

-package model.personnality;
-
-import java.util.HashMap;
-
-public class Personality {
-
-    private HashMap<Trait, Float> fTraits;
-
-    public Personality()
-    {
-        fTraits = new HashMap<>();
-    }
-}

backend/src/main/java/model/personnality/Trait.java

 
 public class Trait implements Jsonable {
 
-    private String fName;
-    private String fDescription;
+    private final String fName;
+    private final String fDescription;
 
     public Trait(String iName, String iDescription){
         fName           = iName;

backend/src/main/java/model/questionnaire/Answer.java

 
 public class Answer implements Jsonable {
 
-    private UUID fId;
-    private float   fWeight;
-    private Trait   fTrait;
-    private String  fDescription;
+    private final UUID fId;
+    private final float   fWeight;
+    private final Trait   fTrait;
+    private final String  fDescription;
 
 
     public Answer(String iDescription, Trait iTrait, float iWeight)

backend/src/main/java/model/questionnaire/Question.java

 public class Question implements Jsonable {
 
     private static final HashMap<UUID, Question> sQuestions = new HashMap<>();
-    private UUID fId;
-    private List<Answer> fAnswers;
-    private String fName;
+    private final UUID fId;
+    private final List<Answer> fAnswers;
+    private final String fName;
 
     public Question(String iName, List<Answer> iAnswers)
     {

backend/src/main/java/model/questionnaire/Questionnaire.java

 
 public class Questionnaire{
 
-    private static List<Questionnaire> sQuestionnaires = new ArrayList<>();
-    private List<Question> fQuestions;
-    private String fName;
+    private static final List<Questionnaire> sQuestionnaires = new ArrayList<>();
+    private final List<Question> fQuestions;
+    private final String fName;
 
     public Questionnaire(String iName, List<Question> iQuestions)
     {
         sQuestionnaires.add(this);
     }
 
+    // quick and dirty for now
     public static Questionnaire getTheOnlyExistingQuestionnaire(){
         return sQuestionnaires.stream().findFirst().get();
     }

backend/src/main/java/model/questionnaire/Session.java

 
 import com.github.cliftonlabs.json_simple.JsonObject;
 import com.github.cliftonlabs.json_simple.Jsonable;
-import model.personnality.Personality;
 
 import java.io.IOException;
 import java.io.StringWriter;
 
 public class Session implements Jsonable {
 
-    private static HashMap<UUID, Session> sSessions = new HashMap<UUID, Session>();
-    private UUID fId;
-    private SessionAnswers fAnswers;
-    private Personality    fPersonality;
+    private static final HashMap<UUID, Session> sSessions = new HashMap<>();
+    private final UUID fId;
+    private final SessionAnswers fAnswers;
 
     public Session(){
         fId = UUID.randomUUID();
         fAnswers = new SessionAnswers();
-        fPersonality = new Personality();
         sSessions.put(fId, this);
     }
 

backend/src/main/java/model/questionnaire/SessionAnswers.java

 import com.github.cliftonlabs.json_simple.JsonArray;
 import com.github.cliftonlabs.json_simple.JsonObject;
 import com.github.cliftonlabs.json_simple.Jsonable;
-import model.personnality.Personality;
 import model.personnality.Trait;
 
 import java.io.IOException;
 import java.io.StringWriter;
 import java.io.Writer;
 import java.nio.charset.StandardCharsets;
-import java.util.ArrayList;
 import java.util.HashMap;
 
 import static api.JsonKeys.*;
  */
 public class SessionAnswers implements Jsonable {
 
-    private HashMap<Question, Answer> fAnswers;
-    private HashMap<Trait, Float> fTraits;
+    private final HashMap<Question, Answer> fAnswers;
+    private final HashMap<Trait, Float> fTraits;
 
     public SessionAnswers() {
         fTraits = new HashMap<>();
     {
         JsonObject vResult = new JsonObject();
         JsonArray vAnswers = new JsonArray();
-        fAnswers.forEach( (question, answer) -> {
-            vAnswers.add(answer.asJsonObject().putChain(KEY_QUESTION, question.asJsonObject()));
-        });
+        fAnswers.forEach( (question, answer) -> vAnswers.add(answer.asJsonObject().putChain(KEY_QUESTION, question.asJsonObject())));
         vResult.put(KEY_ANSWERS, vAnswers);
         JsonArray vTraits = new JsonArray();
-        fTraits.forEach( (trait, weight) -> {
-            vTraits.add(trait.asJsonObject().putChain(KEY_WEIGHT, weight));
-        });
+        fTraits.forEach( (trait, weight) -> vTraits.add(trait.asJsonObject().putChain(KEY_WEIGHT, weight)));
         vResult.put(KEY_TRAITS, vTraits);
         return vResult;
     }

backend/src/test/java/api/ResponseHandlerTest.java

 package api;
 
 import com.github.cliftonlabs.json_simple.JsonObject;
+import controller.ModelController;
+import controller.SessionController;
 import org.junit.jupiter.api.Test;
 
 import static org.junit.jupiter.api.Assertions.*;
         vErrorObject.put("error", "DELETE with 2 subdirectories not implemented");
         assertEquals(vErrorObject, vResponseHandler.getResponse("DELETE", vPath, "Yo", null));
 
+        //Get a valid session id
+        SessionController vSessionController = new SessionController();
+        JsonObject vSessionObject = vResponseHandler.getResponse("GET",new String[]{},"", vSessionController);
+        assertTrue(vSessionObject.containsKey("id"));
+        String vSessionId = (String) vSessionObject.get("id");
+
+        //Verify error management in various cases
+        String[] vPathSession = new String[]{vSessionId};
+        JsonObject vResponseObject;
+        Object[][] vTestCases = new Object[][]{
+                {"PUT", vPathSession, "Yo", vSessionController},
+                {"PUT", new String[]{"a"}, "{}", vSessionController},
+                {"PUT", new String[]{"ff95a8b5-736a-4198-acaa-1fecdaa94c14"}, "{}", vSessionController},
+                {"PUT", vPathSession, "{\"question\":\"a\",\"answer\":\"a\"}", vSessionController},
+                {"PUT", vPathSession, "{\"question\":\"ff95a8b5-736a-4198-acaa-1fecdaa94c14\",\"answer\":\"ff95a8b5-736a-4198-acaa-1fecdaa94c14\"}", vSessionController},
+        };
+        for(Object [] vTestCase : vTestCases)
+        {
+            vResponseObject = vResponseHandler.getResponse((String) vTestCase[0],(String[]) vTestCase[1],(String) vTestCase[2],(ModelController) vTestCase[3]);
+            assertTrue(vResponseObject.containsKey("error"));
+            assertNotEquals(null, vResponseObject.get("error"));
+        }
+
+
     }
 }

frontend/public/index.html

     <meta name="theme-color" content="#000000" />
     <meta
       name="description"
-      content="Web site created using create-react-app"
+      content="Totally legit personnality test built as a test to join Teamway"
     />
     <link rel="apple-touch-icon" href="%PUBLIC_URL%/logo192.png" />
     <!--
       work correctly both with client-side routing and a non-root public URL.
       Learn how to configure a non-root public URL by running `npm run build`.
     -->
-    <title>React App</title>
+    <title>Elias Sebbar - Personnality Test</title>
   </head>
   <body>
     <noscript>You need to enable JavaScript to run this app.</noscript>

frontend/src/App.js

         </div>
       }
       { questionnaireStarted &&
-        <Questionnaire sessionId={sessionIdReceived}/>}
+        <Questionnaire sessionId={sessionIdReceived} onStartQuestionnaire={onStartQuestionnaire}/>}
     </div>
   );
 }

frontend/src/component/questionnaire.js

     )
     else
     return(
-        <QuestionnaireResult sessionId={props.sessionId}/>
+        <QuestionnaireResult onStartQuestionnaire={props.onStartQuestionnaire} sessionId={props.sessionId}/>
     )
 }
 

frontend/src/component/questionnaire_result.js

             Approximately {dominant_weight.toFixed(1)}% : 🎉{dominant.description} 
         </div>
         }
+        <div onClick={() => props.onStartQuestionnaire(false)} className="interactible">
+            Restart
+        </div>
         </React.Fragment>
     )
 }