[Summary view]

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

   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   * lock unit tests
  19   *
  20   * @package    core
  21   * @category   test
  22   * @copyright  2013 Damyon Wiese
  23   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  24   */
  25  
  26  defined('MOODLE_INTERNAL') || die();
  27  
  28  
  29  /**
  30   * Unit tests for our locking implementations.
  31   *
  32   * @package    core
  33   * @category   test
  34   * @copyright  2013 Damyon Wiese
  35   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  36   */
  37  class lock_testcase extends advanced_testcase {
  38  
  39      /**
  40       * Some lock types will store data in the database.
  41       */
  42      protected function setUp() {
  43          $this->resetAfterTest(true);
  44      }
  45  
  46      /**
  47       * Run a suite of tests on a lock factory class.
  48       *
  49       * @param class $lockfactoryclass - A lock factory class to test
  50       */
  51      protected function run_on_lock_factory($lockfactoryclass) {
  52  
  53          $modassignfactory = new $lockfactoryclass('mod_assign');
  54          $tooltaskfactory = new $lockfactoryclass('tool_task');
  55  
  56          // Test for lock clashes between lock stores.
  57          $assignlock = $modassignfactory->get_lock('abc', 0);
  58          $this->assertNotEmpty($assignlock, 'Get a lock "abc" from store "mod_assign"');
  59  
  60          $tasklock = $tooltaskfactory->get_lock('abc', 0);
  61          $this->assertNotEmpty($tasklock, 'Get a lock "abc" from store "tool_task"');
  62  
  63          $assignlock->release();
  64          $tasklock->release();
  65  
  66          $lockfactory = new $lockfactoryclass('default');
  67          if ($lockfactory->is_available()) {
  68              // This should work.
  69              $lock1 = $lockfactory->get_lock('abc', 2);
  70              $this->assertNotEmpty($lock1, 'Get a lock');
  71  
  72              if ($lockfactory->supports_timeout()) {
  73                  if ($lockfactory->supports_recursion()) {
  74                      $lock2 = $lockfactory->get_lock('abc', 2);
  75                      $this->assertNotEmpty($lock2, 'Get a stacked lock');
  76                      $this->assertTrue($lock2->release(), 'Release a stacked lock');
  77  
  78                      // This stacked lock should be gained almost instantly.
  79                      $duration = -microtime(true);
  80                      $lock3 = $lockfactory->get_lock('abc', 0);
  81                      $duration += microtime(true);
  82                      $lock3->release();
  83                      $this->assertTrue($duration < 0.100, 'Lock should be gained almost instantly');
  84  
  85                      // We should also assert that locks fail instantly if locked
  86                      // from another process but this is hard to unit test.
  87  
  88                  } else {
  89                      // This should timeout after 2 seconds.
  90                      $duration = -microtime(true);
  91                      $lock2 = $lockfactory->get_lock('abc', 2);
  92                      $duration += microtime(true);
  93                      $this->assertFalse($lock2, 'Cannot get a stacked lock');
  94                      $this->assertTrue($duration < 2.5, 'Lock should timeout after no more than 2 seconds');
  95  
  96                      // This should timeout almost instantly.
  97                      $duration = -microtime(true);
  98                      $lock2 = $lockfactory->get_lock('abc', 0);
  99                      $duration += microtime(true);
 100                      $this->assertFalse($lock2, 'Cannot get a stacked lock');
 101                      $this->assertTrue($duration < 0.100, 'Lock should timeout almost instantly < 100ms');
 102                  }
 103              }
 104              // Release the lock.
 105              $this->assertTrue($lock1->release(), 'Release a lock');
 106              // Get it again.
 107              $lock3 = $lockfactory->get_lock('abc', 2);
 108  
 109              $this->assertNotEmpty($lock3, 'Get a lock again');
 110              // Release the lock again.
 111              $this->assertTrue($lock3->release(), 'Release a lock again');
 112              // Release the lock again (shouldn't hurt).
 113              $this->assertFalse($lock3->release(), 'Release a lock that is not held');
 114              if (!$lockfactory->supports_auto_release()) {
 115                  // Test that a lock can be claimed after the timeout period.
 116                  $lock4 = $lockfactory->get_lock('abc', 2, 2);
 117                  $this->assertNotEmpty($lock4, 'Get a lock');
 118                  sleep(3);
 119  
 120                  $lock5 = $lockfactory->get_lock('abc', 2, 2);
 121                  $this->assertNotEmpty($lock5, 'Get another lock after a timeout');
 122                  $this->assertTrue($lock5->release(), 'Release the lock');
 123                  $this->assertTrue($lock4->release(), 'Release the lock');
 124              }
 125          }
 126      }
 127  
 128      /**
 129       * Tests the testable lock factories classes.
 130       * @return void
 131       */
 132      public function test_locks() {
 133          // Run the suite on the current configured default (may be non-core).
 134          $this->run_on_lock_factory(\core\lock\lock_config::get_lock_factory_class());
 135  
 136          // Manually create the core no-configuration factories.
 137          $this->run_on_lock_factory(\core\lock\db_record_lock_factory::class);
 138          $this->run_on_lock_factory(\core\lock\file_lock_factory::class);
 139  
 140      }
 141  
 142  }
 143