[Summary view]

Differences Between: [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   * Tests for class \core_customfield\field_controller.
  19   *
  20   * @package    core_customfield
  21   * @category   test
  22   * @copyright  2018 Ruslan Kabalin
  23   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  24   */
  25  
  26  defined('MOODLE_INTERNAL') || die();
  27  
  28  use \core_customfield\category_controller;
  29  use \core_customfield\field_controller;
  30  
  31  /**
  32   * Functional test for class \core_customfield\field_controller.
  33   *
  34   * @package    core_customfield
  35   * @category   test
  36   * @copyright  2018 Ruslan Kabalin
  37   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  38   */
  39  class core_customfield_field_controller_testcase extends advanced_testcase {
  40  
  41      /**
  42       * Get generator.
  43       *
  44       * @return core_customfield_generator
  45       */
  46      protected function get_generator(): core_customfield_generator {
  47          return $this->getDataGenerator()->get_plugin_generator('core_customfield');
  48      }
  49  
  50      /**
  51       * Test for function \core_customfield\field_controller::create()
  52       */
  53      public function test_constructor() {
  54          global $DB;
  55          $this->resetAfterTest();
  56  
  57          // Create the category.
  58          $category0 = $this->get_generator()->create_category();
  59  
  60          // Initiate objects without id, try with the category object or with category id or with both.
  61          $field0 = field_controller::create(0, (object)['type' => 'checkbox'], $category0);
  62          $this->assertInstanceOf(customfield_checkbox\field_controller::class, $field0);
  63          $field1 = field_controller::create(0, (object)['type' => 'date', 'categoryid' => $category0->get('id')]);
  64          $this->assertInstanceOf(customfield_date\field_controller::class, $field1);
  65          $field2 = field_controller::create(0, (object)['type' => 'select', 'categoryid' => $category0->get('id')], $category0);
  66          $this->assertInstanceOf(customfield_select\field_controller::class, $field2);
  67          $field3 = field_controller::create(0, (object)['type' => 'text'], $category0);
  68          $this->assertInstanceOf(customfield_text\field_controller::class, $field3);
  69          $field4 = field_controller::create(0, (object)['type' => 'textarea'], $category0);
  70          $this->assertInstanceOf(customfield_textarea\field_controller::class, $field4);
  71  
  72          // Save fields to the db so we have ids.
  73          \core_customfield\api::save_field_configuration($field0, (object)['name' => 'a', 'shortname' => 'a']);
  74          \core_customfield\api::save_field_configuration($field1, (object)['name' => 'b', 'shortname' => 'b']);
  75          \core_customfield\api::save_field_configuration($field2, (object)['name' => 'c', 'shortname' => 'c']);
  76          \core_customfield\api::save_field_configuration($field3, (object)['name' => 'd', 'shortname' => 'd']);
  77          \core_customfield\api::save_field_configuration($field4, (object)['name' => 'e', 'shortname' => 'e']);
  78  
  79          // Retrieve fields by id.
  80          $this->assertInstanceOf(customfield_checkbox\field_controller::class, field_controller::create($field0->get('id')));
  81          $this->assertInstanceOf(customfield_date\field_controller::class, field_controller::create($field1->get('id')));
  82  
  83          // Retrieve field by id and category.
  84          $this->assertInstanceOf(customfield_select\field_controller::class,
  85              field_controller::create($field2->get('id'), null, $category0));
  86  
  87          // Retrieve fields by record without category.
  88          $fieldrecord = $DB->get_record(\core_customfield\field::TABLE, ['id' => $field3->get('id')], '*', MUST_EXIST);
  89          $this->assertInstanceOf(customfield_text\field_controller::class, field_controller::create(0, $fieldrecord));
  90  
  91          // Retrieve fields by record with category.
  92          $fieldrecord = $DB->get_record(\core_customfield\field::TABLE, ['id' => $field4->get('id')], '*', MUST_EXIST);
  93          $this->assertInstanceOf(customfield_textarea\field_controller::class,
  94              field_controller::create(0, $fieldrecord, $category0));
  95      }
  96  
  97      /**
  98       * Test for function \core_customfield\field_controller::create() in case of wrong parameters
  99       */
 100      public function test_constructor_errors() {
 101          global $DB;
 102          $this->resetAfterTest();
 103  
 104          // Create a category and a field.
 105          $category = $this->get_generator()->create_category();
 106          $field = $this->get_generator()->create_field(['categoryid' => $category->get('id')]);
 107  
 108          $fieldrecord = $DB->get_record(\core_customfield\field::TABLE, ['id' => $field->get('id')], '*', MUST_EXIST);
 109  
 110          // Both id and record give warning.
 111          $field = field_controller::create($fieldrecord->id, $fieldrecord);
 112          $debugging = $this->getDebuggingMessages();
 113          $this->assertEquals(1, count($debugging));
 114          $this->assertEquals('Too many parameters, either id need to be specified or a record, but not both.',
 115              $debugging[0]->message);
 116          $this->resetDebugging();
 117          $this->assertInstanceOf(customfield_text\field_controller::class, $field);
 118  
 119          // Retrieve non-existing field.
 120          try {
 121              field_controller::create($fieldrecord->id + 1);
 122              $this->fail('Expected exception');
 123          } catch (moodle_exception $e) {
 124              $this->assertEquals('Field not found', $e->getMessage());
 125              $this->assertEquals(moodle_exception::class, get_class($e));
 126          }
 127  
 128          // Retrieve without id and without type.
 129          try {
 130              field_controller::create(0, (object)['name' => 'a'], $category);
 131              $this->fail('Expected exception');
 132          } catch (coding_exception $e) {
 133              $this->assertEquals('Coding error detected, it must be fixed by a programmer: Not enough parameters to ' .
 134                  'initialise field_controller - unknown field type', $e->getMessage());
 135              $this->assertEquals(coding_exception::class, get_class($e));
 136          }
 137  
 138          // Missing category id.
 139          try {
 140              field_controller::create(0, (object)['type' => 'text']);
 141              $this->fail('Expected exception');
 142          } catch (coding_exception $e) {
 143              $this->assertEquals('Coding error detected, it must be fixed by a programmer: Not enough parameters ' .
 144                  'to initialise field_controller - unknown category', $e->getMessage());
 145              $this->assertEquals(coding_exception::class, get_class($e));
 146          }
 147  
 148          // Mismatching category id.
 149          try {
 150              field_controller::create(0, (object)['type' => 'text', 'categoryid' => $category->get('id') + 1], $category);
 151              $this->fail('Expected exception');
 152          } catch (coding_exception $e) {
 153              $this->assertEquals('Coding error detected, it must be fixed by a programmer: Category of the field ' .
 154                  'does not match category from the parameter', $e->getMessage());
 155              $this->assertEquals(coding_exception::class, get_class($e));
 156          }
 157  
 158          // Non-existing type.
 159          try {
 160              field_controller::create(0, (object)['type' => 'nonexisting'], $category);
 161              $this->fail('Expected exception');
 162          } catch (moodle_exception $e) {
 163              $this->assertEquals('Field type nonexisting not found', $e->getMessage());
 164              $this->assertEquals(moodle_exception::class, get_class($e));
 165          }
 166      }
 167  
 168      /**
 169       * Tests for behaviour of:
 170       * \core_customfield\field_controller::save()
 171       * \core_customfield\field_controller::get()
 172       * \core_customfield\field_controller::get_category()
 173       */
 174      public function test_create_field() {
 175          global $DB;
 176          $this->resetAfterTest();
 177  
 178          $lpg = $this->get_generator();
 179          $category = $lpg->create_category();
 180          $fields = $DB->get_records(\core_customfield\field::TABLE, ['categoryid' => $category->get('id')]);
 181          $this->assertCount(0, $fields);
 182  
 183          // Create field.
 184          $fielddata = new stdClass();
 185          $fielddata->name = 'Field';
 186          $fielddata->shortname = 'field';
 187          $fielddata->type = 'text';
 188          $fielddata->categoryid = $category->get('id');
 189          $field = field_controller::create(0, $fielddata);
 190          $field->save();
 191  
 192          $fields = $DB->get_records(\core_customfield\field::TABLE, ['categoryid' => $category->get('id')]);
 193          $this->assertCount(1, $fields);
 194          $this->assertTrue(\core_customfield\field::record_exists($field->get('id')));
 195          $this->assertInstanceOf(\customfield_text\field_controller::class, $field);
 196          $this->assertSame($field->get('name'), $fielddata->name);
 197          $this->assertSame($field->get('type'), $fielddata->type);
 198          $this->assertEquals($field->get_category()->get('id'), $category->get('id'));
 199      }
 200  
 201      /**
 202       * Tests for \core_customfield\field_controller::delete() behaviour.
 203       */
 204      public function test_delete_field() {
 205          global $DB;
 206          $this->resetAfterTest();
 207  
 208          $lpg = $this->get_generator();
 209          $category = $lpg->create_category();
 210          $fields = $DB->get_records(\core_customfield\field::TABLE, ['categoryid' => $category->get('id')]);
 211          $this->assertCount(0, $fields);
 212  
 213          // Create field using generator.
 214          $field1 = $lpg->create_field(array('categoryid' => $category->get('id')));
 215          $field2 = $lpg->create_field(array('categoryid' => $category->get('id')));
 216          $fields = $DB->get_records(\core_customfield\field::TABLE, ['categoryid' => $category->get('id')]);
 217          $this->assertCount(2, $fields);
 218  
 219          // Delete fields.
 220          $this->assertTrue($field1->delete());
 221          $this->assertTrue($field2->delete());
 222  
 223          // Check that the fields have been deleted.
 224          $fields = $DB->get_records(\core_customfield\field::TABLE, ['categoryid' => $category->get('id')]);
 225          $this->assertCount(0, $fields);
 226          $this->assertFalse(\core_customfield\field::record_exists($field1->get('id')));
 227          $this->assertFalse(\core_customfield\field::record_exists($field2->get('id')));
 228      }
 229  
 230      /**
 231       * Tests for \core_customfield\field_controller::get_configdata_property() behaviour.
 232       */
 233      public function test_get_configdata_property() {
 234          $this->resetAfterTest();
 235  
 236          $lpg = $this->get_generator();
 237          $category = $lpg->create_category();
 238          $configdata = ['a' => 'b', 'c' => ['d', 'e']];
 239          $field = field_controller::create(0, (object)['type' => 'text',
 240              'configdata' => json_encode($configdata), 'shortname' => 'a', 'name' => 'a'], $category);
 241          $field->save();
 242  
 243          // Retrieve field and check configdata.
 244          $field = field_controller::create($field->get('id'));
 245          $this->assertEquals($configdata, $field->get('configdata'));
 246          $this->assertEquals('b', $field->get_configdata_property('a'));
 247          $this->assertEquals(['d', 'e'], $field->get_configdata_property('c'));
 248          $this->assertEquals(null, $field->get_configdata_property('x'));
 249      }
 250  }