[Summary view]

Differences Between: [Versions 310 and 311] [Versions 310 and 400] [Versions 310 and 401] [Versions 310 and 402] [Versions 310 and 403] [Versions 39 and 310]

   1  <?php
   2  // This file is part of Moodle - http://moodle.org/
   3  //
   4  // Moodle is free software: you can redistribute it and/or modify
   5  // it under the terms of the GNU General Public License as published by
   6  // the Free Software Foundation, either version 3 of the License, or
   7  // (at your option) any later version.
   8  //
   9  // Moodle is distributed in the hope that it will be useful,
  10  // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  // GNU General Public License for more details.
  13  //
  14  // You should have received a copy of the GNU General Public License
  15  // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
  16  
  17  /**
  18   * This file contains the class that handles testing the calendar type system.
  19   *
  20   * @package core_calendar
  21   * @copyright 2013 Mark Nelson <markn@moodle.com>
  22   * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  23   */
  24  
  25  defined('MOODLE_INTERNAL') || die();
  26  
  27  global $CFG;
  28  
  29  // The test calendar type.
  30  require_once($CFG->dirroot . '/calendar/tests/calendartype_test_example.php');
  31  
  32  // Used to test the dateselector elements.
  33  require_once($CFG->libdir . '/form/dateselector.php');
  34  require_once($CFG->libdir . '/form/datetimeselector.php');
  35  
  36  // Used to test the user datetime profile field.
  37  require_once($CFG->dirroot . '/user/profile/lib.php');
  38  require_once($CFG->dirroot . '/user/profile/definelib.php');
  39  require_once($CFG->dirroot . '/user/profile/index_field_form.php');
  40  
  41  /**
  42   * Unit tests for the calendar type system.
  43   *
  44   * @package core_calendar
  45   * @copyright 2013 Mark Nelson <markn@moodle.com>
  46   * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  47   * @since Moodle 2.6
  48   */
  49  class core_calendar_type_testcase extends advanced_testcase {
  50      /** @var MoodleQuickForm Keeps reference of dummy form object */
  51      private $mform;
  52  
  53      /**
  54       * The test user.
  55       */
  56      private $user;
  57  
  58      /**
  59       * Test set up.
  60       */
  61      protected function setUp(): void {
  62          // The user we are going to test this on.
  63          $this->user = self::getDataGenerator()->create_user();
  64          self::setUser($this->user);
  65  
  66          // Get form data.
  67          $form = new temp_form_calendartype();
  68          $this->mform = $form->getform();
  69      }
  70  
  71      /**
  72       * Test that setting the calendar type works.
  73       */
  74      public function test_calendar_type_set() {
  75          // We want to reset the test data after this run.
  76          $this->resetAfterTest();
  77  
  78          // Test setting it as the 'Test' calendar type.
  79          $this->set_calendar_type('test_example');
  80          $this->assertEquals('test_example', \core_calendar\type_factory::get_calendar_type());
  81  
  82          // Test setting it as the 'Gregorian' calendar type.
  83          $this->set_calendar_type('gregorian');
  84          $this->assertEquals('gregorian', \core_calendar\type_factory::get_calendar_type());
  85      }
  86  
  87      /**
  88       * Test that calling core Moodle functions responsible for displaying the date
  89       * have the same results as directly calling the same function in the calendar type.
  90       */
  91      public function test_calendar_type_core_functions() {
  92          // We want to reset the test data after this run.
  93          $this->resetAfterTest();
  94  
  95          // Test that the core functions reproduce the same results as the Gregorian calendar.
  96          $this->core_functions_test('gregorian');
  97  
  98          // Test that the core functions reproduce the same results as the test calendar.
  99          $this->core_functions_test('test_example');
 100      }
 101  
 102      /**
 103       * Test that dates selected using the date selector elements are being saved as unixtime, and that the
 104       * unixtime is being converted back to a valid date to display in the date selector elements for
 105       * different calendar types.
 106       */
 107      public function test_calendar_type_dateselector_elements() {
 108          // We want to reset the test data after this run.
 109          $this->resetAfterTest();
 110  
 111          $this->setTimezone('UTC');
 112  
 113          // Note: this test is pretty useless because it does not test current user timezones.
 114  
 115          // Check converting dates to Gregorian when submitting a date selector element works. Note: the test
 116          // calendar is 2 years, 2 months, 2 days, 2 hours and 2 minutes ahead of the Gregorian calendar.
 117          $date1 = array();
 118          $date1['day'] = 4;
 119          $date1['month'] = 7;
 120          $date1['year'] = 2013;
 121          $date1['hour'] = 0;
 122          $date1['minute'] = 0;
 123          $date1['timestamp'] = 1372896000;
 124          $this->convert_dateselector_to_unixtime_test('dateselector', 'gregorian', $date1);
 125  
 126          $date2 = array();
 127          $date2['day'] = 7;
 128          $date2['month'] = 9;
 129          $date2['year'] = 2015;
 130          $date2['hour'] = 0; // The dateselector element does not have hours.
 131          $date2['minute'] = 0; // The dateselector element does not have minutes.
 132          $date2['timestamp'] = 1372896000;
 133          $this->convert_dateselector_to_unixtime_test('dateselector', 'test_example', $date2);
 134  
 135          $date3 = array();
 136          $date3['day'] = 4;
 137          $date3['month'] = 7;
 138          $date3['year'] = 2013;
 139          $date3['hour'] = 23;
 140          $date3['minute'] = 15;
 141          $date3['timestamp'] = 1372979700;
 142          $this->convert_dateselector_to_unixtime_test('datetimeselector', 'gregorian', $date3);
 143  
 144          $date4 = array();
 145          $date4['day'] = 7;
 146          $date4['month'] = 9;
 147          $date4['year'] = 2015;
 148          $date4['hour'] = 1;
 149          $date4['minute'] = 17;
 150          $date4['timestamp'] = 1372979700;
 151          $this->convert_dateselector_to_unixtime_test('datetimeselector', 'test_example', $date4);
 152  
 153          // The date selector element values are set by using the function usergetdate, here we want to check that
 154          // the unixtime passed is being successfully converted to the correct values for the calendar type.
 155          $this->convert_unixtime_to_dateselector_test('gregorian', $date3);
 156          $this->convert_unixtime_to_dateselector_test('test_example', $date4);
 157      }
 158  
 159      /**
 160       * Test that the user profile field datetime minimum and maximum year settings are saved as the
 161       * equivalent Gregorian years.
 162       */
 163      public function test_calendar_type_datetime_field_submission() {
 164          // We want to reset the test data after this run.
 165          $this->resetAfterTest();
 166  
 167          // Create an array with the input values and expected values once submitted.
 168          $date = array();
 169          $date['inputminyear'] = '1970';
 170          $date['inputmaxyear'] = '2013';
 171          $date['expectedminyear'] = '1970';
 172          $date['expectedmaxyear'] = '2013';
 173          $this->datetime_field_submission_test('gregorian', $date);
 174  
 175          // The test calendar is 2 years, 2 months, 2 days in the future, so when the year 1970 is submitted,
 176          // the year 1967 should be saved in the DB, as 1/1/1970 converts to 30/10/1967 in Gregorian.
 177          $date['expectedminyear'] = '1967';
 178          $date['expectedmaxyear'] = '2010';
 179          $this->datetime_field_submission_test('test_example', $date);
 180      }
 181  
 182      /**
 183       * Test all the core functions that use the calendar type system.
 184       *
 185       * @param string $type the calendar type we want to test
 186       */
 187      private function core_functions_test($type) {
 188          $this->set_calendar_type($type);
 189  
 190          // Get the calendar.
 191          $calendar = \core_calendar\type_factory::get_calendar_instance();
 192  
 193          // Test the userdate function.
 194          $this->assertEquals($calendar->timestamp_to_date_string($this->user->timecreated, '', 99, true, true),
 195              userdate($this->user->timecreated));
 196  
 197          // Test the calendar/lib.php functions.
 198          $this->assertEquals($calendar->get_weekdays(), calendar_get_days());
 199          $this->assertEquals($calendar->get_starting_weekday(), calendar_get_starting_weekday());
 200          $this->assertEquals($calendar->get_num_days_in_month('1986', '9'), calendar_days_in_month('9', '1986'));
 201          $this->assertEquals($calendar->get_next_month('1986', '9'), calendar_add_month('9', '1986'));
 202          $this->assertEquals($calendar->get_prev_month('1986', '9'), calendar_sub_month('9', '1986'));
 203  
 204          // Test the lib/moodle.php functions.
 205          $this->assertEquals($calendar->get_num_days_in_month('1986', '9'), days_in_month('9', '1986'));
 206          $this->assertEquals($calendar->get_weekday('1986', '9', '16'), dayofweek('16', '9', '1986'));
 207      }
 208  
 209      /**
 210       * Simulates submitting a form with a date selector element and tests that the chosen dates
 211       * are converted into unixtime before being saved in DB.
 212       *
 213       * @param string $element the form element we are testing
 214       * @param string $type the calendar type we want to test
 215       * @param array $date the date variables
 216       */
 217      private function convert_dateselector_to_unixtime_test($element, $type, $date) {
 218          $this->set_calendar_type($type);
 219  
 220          static $counter = 0;
 221          $counter++;
 222  
 223          if ($element == 'dateselector') {
 224              $el = $this->mform->addElement('date_selector',
 225                      'dateselector' . $counter, null, array('timezone' => 0.0));
 226          } else {
 227              $el = $this->mform->addElement('date_time_selector',
 228                      'dateselector' . $counter, null, array('timezone' => 0.0, 'optional' => false));
 229          }
 230          $submitvalues = array('dateselector' . $counter => $date);
 231  
 232          $this->assertSame(array('dateselector' . $counter => $date['timestamp']), $el->exportValue($submitvalues, true));
 233      }
 234  
 235      /**
 236       * Test converting dates from unixtime to a date for the calendar type specified.
 237       *
 238       * @param string $type the calendar type we want to test
 239       * @param array $date the date variables
 240       */
 241      private function convert_unixtime_to_dateselector_test($type, $date) {
 242          $this->set_calendar_type($type);
 243  
 244          // Get the calendar.
 245          $calendar = \core_calendar\type_factory::get_calendar_instance();
 246  
 247          $usergetdate = $calendar->timestamp_to_date_array($date['timestamp'], 0.0);
 248          $comparedate = array(
 249              'minute' => $usergetdate['minutes'],
 250              'hour' => $usergetdate['hours'],
 251              'day' => $usergetdate['mday'],
 252              'month' => $usergetdate['mon'],
 253              'year' => $usergetdate['year'],
 254              'timestamp' => $date['timestamp']
 255          );
 256  
 257          $this->assertEquals($comparedate, $date);
 258      }
 259  
 260      /**
 261       * Test saving the minimum and max year settings for the user datetime field.
 262       *
 263       * @param string $type the calendar type we want to test
 264       * @param array $date the date variables
 265       */
 266      private function datetime_field_submission_test($type, $date) {
 267          $this->set_calendar_type($type);
 268  
 269          // Get the data we are submitting for the form.
 270          $formdata = array();
 271          $formdata['id'] = 0;
 272          $formdata['shortname'] = 'Shortname';
 273          $formdata['name'] = 'Name';
 274          $formdata['param1'] = $date['inputminyear'];
 275          $formdata['param2'] = $date['inputmaxyear'];
 276  
 277          // Mock submitting this.
 278          field_form::mock_submit($formdata);
 279  
 280          // Create the user datetime form.
 281          $form = new field_form(null, 'datetime');
 282  
 283          // Get the data from the submission.
 284          $submissiondata = $form->get_data();
 285          // On the user profile field page after get_data, the function define_save is called
 286          // in the field base class, which then calls the field's function define_save_preprocess.
 287          $field = new profile_define_datetime();
 288          $submissiondata = $field->define_save_preprocess($submissiondata);
 289  
 290          // Create an array we want to compare with the date passed.
 291          $comparedate = $date;
 292          $comparedate['expectedminyear'] = $submissiondata->param1;
 293          $comparedate['expectedmaxyear'] = $submissiondata->param2;
 294  
 295          $this->assertEquals($comparedate, $date);
 296      }
 297  
 298      /**
 299       * Set the calendar type for this user.
 300       *
 301       * @param string $type the calendar type we want to set
 302       */
 303      private function set_calendar_type($type) {
 304          $this->user->calendartype = $type;
 305          \core\session\manager::set_user($this->user);
 306      }
 307  }
 308  
 309  /**
 310   * Form object to be used in test case.
 311   */
 312  class temp_form_calendartype extends moodleform {
 313      /**
 314       * Form definition.
 315       */
 316      public function definition() {
 317          // No definition required.
 318      }
 319      /**
 320       * Returns form reference
 321       * @return MoodleQuickForm
 322       */
 323      public function getform() {
 324          $mform = $this->_form;
 325          // Set submitted flag, to simulate submission.
 326          $mform->_flagSubmitted = true;
 327          return $mform;
 328      }
 329  }