Search moodle.org's
Developer Documentation

  • Bug fixes for general core bugs in 3.7.x will end 11 May 2020 (12 months).
  • Bug fixes for security issues in 3.7.x will end 9 November 2020 (18 months) - Support has ended.
  • minimum PHP 7.1.0 Note: minimum PHP version has increased since Moodle 3.6. PHP 7.2.x and 7.3.x are supported too. PHP 7.x could have some engine limitations.
  • Differences Between: [Versions 37 and 310] [Versions 37 and 311]

       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() {
      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  }