integrate into master changes

Author: rtschu

amd/build/initialize.min.js.map

@@ -152,7 +152,7 @@ public function get_content() {
             $end = $record->get('enddate');
             $recordhasstandardtime = $record->get('usestandardtime');
         } else {
-            if (!$ismodeautomated && $categoryhasstandardtime) {
+            if ($categoryhasstandardtime) {
                 $start = $categoryhasstandardtime['start'];
                 $end = $categoryhasstandardtime['end'];
                 $recordhasstandardtime = true;
@@ -232,7 +232,7 @@ public function get_content() {
             // Append this course.
             $courses[] = $course;
         }
-        $standardttimemode = (!$ismodeautomated && $recordhasstandardtime && !$record);
+        $standardttimemode = ($recordhasstandardtime && !$wasstarted);
         // Create the data object for the mustache table.
         $data = array(
             'href' => $href,
@@ -243,7 +243,7 @@ public function get_content() {
             * In case of the automated workflow, we require surveys
             * in order to be able to automatically trigger the evaluation. */
             'showcontrols' => ($hassurveys || !$ismodeautomated) && count($evasyscourses) > 0 && !$invalidcourses,
-            'usestandardtimelayout' => (!$ismodeautomated && $recordhasstandardtime && !$wasstarted && !$record),
+            'usestandardtimelayout' => $standardttimemode,
             // Choose mode.
             'direct' => $ismodeautomated,
             'startdisabled' => $startdisabled || $standardttimemode,

block_evasys_sync.php

@@ -331,6 +331,27 @@ public function the_internal_state_of_course_is($shortname, $mode) {
         $record->save();
     }
 
+    /**
+     * @Given the recordstandardtimemode for course :shortname is set to :value
+     */
+    public function the_recorstandardtime_for_course_is_set($shortname, $mode) {
+        global $DB;
+        $id = $this->get_courseid_by_shortname($shortname);
+        $record = \block_evasys_sync\course_evaluation_allocation::get_record_by_course($id, false);
+        if (!$record) {
+            $record = new \block_evasys_sync\course_evaluation_allocation(0);
+            $record->set('course', $id);
+        }
+        $record->set('usestandardtime', $mode == "true");
+        $record->save();
+    }
+
+    /**
+     * @Given the recordstandardtimemode for course :shortname is not set
+     */
+    public function the_recordstandardtimemode_for_course_is_not_set($shortname) {
+        return;
+    }
 
     /**
      * @Given no courses are mapped to course :shortname

tests/behat/behat_block_evasys_sync.php

@@ -15,20 +15,44 @@
     "idnumber": ["none", "invalid", "one"],
     "mapped": ["none", "invalid", "one", "multi"],
     "internalstate": ["notopened", "opened", "closed", "manual", "none"],
-    "actualstate": ["open", "closed", "mixed"]
+    "actualstate": ["open", "closed", "mixed"],
+    "recordstandardtime": ["recordstandardtimemode", "recordnonstandardtimemode", "norecordstandardtimemode"]
 }
 
+ILLEGALSTATES = [
+    {"recordstandardtime": "recordstandardtimemode", "internalstate": "none"},
+    {"recordstandardtime": "recordnonstandardtimemode", "internalstate": "none"},
+    {"recordstandardtime": "norecordstandardtimemode", "internalstate": "notopened"},
+    {"recordstandardtime": "norecordstandardtimemode", "internalstate": "opened"},
+    {"recordstandardtime": "norecordstandardtimemode", "internalstate": "closed"},
+    {"recordstandardtime": "norecordstandardtimemode", "internalstate": "manual"},
+]
+
+
+def illegal_state(scenario):
+    for fullillegalstate in ILLEGALSTATES:
+        illegal = True
+        for illegalstate in fullillegalstate.keys():
+            if scenario[list(OPTIONS.keys()).index(illegalstate)] != fullillegalstate[illegalstate]:
+                illegal = False
+                break
+        if illegal:
+            return True
+    if scenario[5] == "none" and scenario[7] != "norecordstandardtimemode":
+        print(scenario)
+    return False
+
 
-def get_checks(mode, standardtime, students_state, idnumber_state, mapped_state, internal_state, actual_state):
+def get_checks(mode, standardtime, students_state, idnumber_state, mapped_state, internal_state, actual_state, recordstandardtimemode):
     """
     This Function will take the scenario parameters and construct the resulting checks.
     :return: The combined checks for the parameters.
     """
-    checks = ""
     # If there are no mapped courses the Block not offer the option to "Show surveys"
     if (idnumber_state == "none") and (mapped_state == "none"):
         return "Then I should see \"Change mapping\"\n    And I should not see \"Name:\"\n    "
 
+    checks = ""
     # In all other cases (even if there are only invalid entries) we need to click the button to start code execution
     checks += "And I load the evasys block\n"
 
@@ -62,7 +86,7 @@ def get_checks(mode, standardtime, students_state, idnumber_state, mapped_state,
             checks += "And I should see \"There are some closed surveys, but all surveys should be open.\"" + "\n"
 
     # if the standardtimemodecheckbox should be present from the start we also want to check that
-    checks += checks_standardtimemode(standardtime, mode, internal_state, actual_state) + "\n"
+    checks += checks_standardtimemode(standardtime, mode, internal_state,  recordstandardtimemode) + "\n"
     # if there are no students that are eligible to evaluate we want to output a warning
     checks += student_checks[students_state]
     checks = checks.replace("\n", "\n    ")
@@ -110,13 +134,15 @@ def get_combi_sentence(set, dictionary, param_name):
 
 
 def get_combi_description(mode, standardtime, students_state, idnumber_state, mapped_state, internal_state,
-                          actual_state):
+                          actual_state, recordstandardtimemode):
     """
     This will construct the description for a scenario that covers multiple states.
     :return: String the description of the scenario.
     """
     if "none" in mapped_state and "none" in idnumber_state:
         return "If there are no related evasys-courses I should not see any.\n    "
+    if not recordstandardtimemode == "norecordstandardtimemode":
+        standardtime = {1} if recordstandardtimemode == "recordstandardtimemode" else {0}
     description = ""
     description += get_combi_sentence(standardtime, standardtimemode_descriptions, "standardtime")
     description += get_combi_sentence(students_state, students_descriptions, "number of students")
@@ -127,7 +153,7 @@ def get_combi_description(mode, standardtime, students_state, idnumber_state, ma
     return description
 
 
-def get_scenario(mode, standardtime, students_state, idnumber_state, mapped_state, internal_state, actual_state):
+def get_scenario(mode, standardtime, students_state, idnumber_state, mapped_state, internal_state, actual_state, recordstandardtimemode):
     """
     This constructs the actual scenario by building all courses, states etc.
     :return: string the combined enviroment specifiing string for a scenario
@@ -138,6 +164,7 @@ def get_scenario(mode, standardtime, students_state, idnumber_state, mapped_stat
     behat_scenario += step_idnumberstate(idnumber_state, actual_state)
     behat_scenario += step_mappedstate(mapped_state, actual_state)
     behat_scenario += step_internal_state[internal_state].replace("{{course}}", str(coursename)) + "\n"
+    behat_scenario += step_record_standardtimemode[recordstandardtimemode].replace("{{course}}", str(coursename)) + "\n"
     behat_scenario += "And I turn editing mode on\n"
     behat_scenario += "And I add the \"EvaSys Sync\" block\n"
     behat_scenario += "And I turn editing mode off\n"
@@ -220,6 +247,7 @@ def condense_keep_options(fullarray):
             if changed:
                 break
         fullarray = new_array
+
     return fullarray
 
 
@@ -252,17 +280,20 @@ def main():
     # get the checks for all options to be able to condense options with the same expected outcome
     uncondensed_dict = {}
     for scenario in cartesianoptions:
-        check = get_checks(scenario[0], scenario[1], scenario[2], scenario[3], scenario[4], scenario[5], scenario[6])
+        check = get_checks(scenario[0], scenario[1], scenario[2], scenario[3], scenario[4], scenario[5], scenario[6], scenario[7])
         if not check in uncondensed_dict.keys():
             uncondensed_dict[check] = []
         uncondensed_dict[check].append(scenario)
 
     # condense those scenarios
     condensed_dict = {}
     if CONDENSE_TESTS:
+        i = 0
         for check in uncondensed_dict.keys():
             scenarios = uncondensed_dict[check]
             condensed_dict[check] = condense_keep_options(scenarios)
+            i += 1
+            print("Condensed " + str(i) + " of " + str(len(uncondensed_dict.keys())))
     else:
         for check in uncondensed_dict.keys():
             fullarray = uncondensed_dict[check]
@@ -284,18 +315,42 @@ def main():
             # do a deep-copy of the scenario because sets can only be accessed by pop which alters the set itself
             scenario_copy = copy.deepcopy(scenario)
             desc = get_combi_description(scenario[0], scenario[1], scenario[2], scenario[3], scenario[4], scenario[5],
-                                         scenario[6])
+                                         scenario[6], scenario[7])
             mode = scenario_copy[0].pop()
             standardtime = scenario_copy[1].pop()
             students_state = scenario_copy[2].pop()
             idnumber_state = scenario_copy[3].pop()
             mapped_state = scenario_copy[4].pop()
             internal_state = scenario_copy[5].pop()
             actual_state = scenario_copy[6].pop()
+            recordstandardtime = scenario_copy[7].pop()
             if actual_state == "mixed" and len(scenario_copy[6]) > 0:
                 actual_state = scenario_copy[6].pop()
+
+            corrected = True
+            illegal = False
+            illegals = []
+            while corrected:
+                corrected = False
+                if illegal_state([mode, standardtime, students_state, idnumber_state, mapped_state, internal_state,
+                                     actual_state, recordstandardtime]):
+                    corrected = True
+                    illegals.append([mode, standardtime, students_state, idnumber_state, mapped_state, internal_state,
+                                     actual_state, recordstandardtime])
+                    if len(scenario_copy[5]) >= 1:
+                        internal_state = scenario_copy[5].pop()
+                    elif len(scenario_copy[7]) >= 1:
+                        recordstandardtime = scenario_copy[7].pop()
+                    else:
+                        if len(illegals) > 1:
+                            print("Illegal multiscenario")
+                            print(illegals)
+                        illegal = True
+                        corrected = False
+            if illegal:
+                continue
             scen_text = get_scenario(mode, standardtime, students_state, idnumber_state, mapped_state, internal_state,
-                                     actual_state)
+                                     actual_state, recordstandardtime)
             if not scen_text:
                 print("Warning impossible scenario!!!")
                 continue

tests/behat/fulltest.feature

@@ -63,6 +63,12 @@
     "none": "And there is no internal record of course {{course}}"
 }
 
+step_record_standardtimemode = {
+    "norecordstandardtimemode": "And the recordstandardtimemode for course {{course}} is not set",
+    "recordstandardtimemode": "And the recordstandardtimemode for course {{course}} is set to true",
+    "recordnonstandardtimemode": "And the recordstandardtimemode for course {{course}} is set to false",
+}
+
 step_students_state = {
     "none": "And no students enrolled in course " + coursename,
     "onlytutors": "And only tutors enrolled in course " + coursename,
@@ -154,14 +160,16 @@ def step_mappedstate(state, openstate):
         return x
 
 
-def checks_standardtimemode(standardtime, auto_mode, internal_state, actual_state):
+def checks_standardtimemode(standardtime, auto_mode, internal_state, recordstandardtimemode):
     """
     The standardtimemode check is a little tricky since the checkbox showing is dependent on 3 states
     :param standardtime: standardtimemode
-    :param auto_mode: auto or manual mode
+    :param recordstandardtimemode: the recordstandardtimemode may overwrite the standardtimemode for the category
     :param internal_state: internal state
     :return: A string checking for the presence or absence of the standardtime checkbox
     """
+    if not recordstandardtimemode == "norecordstandardtimemode":
+        standardtime = 1 if recordstandardtimemode == "recordstandardtimemode" else 0
     if standardtime == 1 and auto_mode == "manual" and (internal_state == "none" or internal_state == "notopened"):
         return standardtimemode_checks[1]
     return standardtimemode_checks[0]

tests/behat/generator/generator.py

@@ -18,7 +18,7 @@
 defined('MOODLE_INTERNAL') || die();
 
 $plugin->component = 'block_evasys_sync';
-$plugin->version = 2019203100;  // YYYYMMDDHH (year, month, day, 24-hr time).
+$plugin->version = 2020230410;  // YYYYMMDDHH (year, month, day, 24-hr time).
 $plugin->requires = 2017111300; // YYYmoYMMDDHH (This is the release version for Moodle 2.0).
 $plugin->maturity = MATURITY_RC;