diff --git a/sps/lib/Drupal/sps/Manager.php b/sps/lib/Drupal/sps/Manager.php index e0b6842..086fc72 100644 --- a/sps/lib/Drupal/sps/Manager.php +++ b/sps/lib/Drupal/sps/Manager.php @@ -1,19 +1,365 @@ array( + 'collection' => array( + 'title' => 'Collection', + 'widget' => 'collection_select', + 'override' => 'view_collection_override', + ), + 'date' => array( + 'title' => 'Live Date', + 'widget' => 'live_date', + 'override' => 'view_live_date_override', + ), + ), + ); + return $sps_config; +} +/** + * The Manager is the heart of the SPS system, taking inputs from different + * parts of the system and pushing them to the correct object for processing + * it can be orginized in to a few different sections + * + * Controller Access + * The Manager managest access to drupal systems via different controllers. The + * SPS system use the manger to access there when they need access to Drupal + * .---------------------------------------------------------------. + * | Systems | + * '---------------------------------------------------------------' + * | + * v + * .---------. + * | Manager | + * |---------| + * '---------' + * .---------------------------. | + * | State Controller | | .---------------------------. + * |---------------------------| | | Plugin Controller | + * | Controls the interface | | |---------------------------| + * | to the State cache |<---| | Controls the interface | + * | used to hold the current | '--->| to the plugin system | + * | site state | | | holds method for getting | + * '---------------------------' | | pluign info and objects | + * .---------------------------. | '---------------------------' + * | Config Controller | | + * |---------------------------| | .---------------------------. + * | Controls the interface | | | Override Controller | + * | to the config for sps |<---| |---------------------------| + * | hold the root condition | '--->| Controls the interface | + * | and infomation of plugins | | to the store of the | + * '---------------------------' | current overrides | + * '---------------------------' + * + * Site State + * THe Manager can create a site state object, and uses the State Controller + * to keep it around from page load to page load. When creating site state it + * hand off the Override Controller So that the Site state can Compile the + * override data and store it in the Override Controller + * + * @TODO this part of the system should be reviews when we start needing + * access to the site state + * + * + * + * Preview Form + * The Manager is the interface between the form hooks in the sps module + * and the Root Conditon that does most of the Form creation and processing + * .-----------------------------------------. + * | preview form hooks in sps.module | + * |-----------------------------------------| + * | sps_preview_form() | + * | sps_preview_form_validate() | + * | sps_preview_form_submit() | + * '-----------------------------------------' + * | + * | + * v + * .-----------------------------------------. + * | Manager | + * |-----------------------------------------| + * | getPreviewForm($form, $form_state) | + * | validatePreviewForm($form, $form_state) | + * | submitPreviewForm($form, $form_state) | + * '-----------------------------------------' + * | + * | + * v + * .-----------------------------------------. + * | Condition (Root) | + * |-----------------------------------------| + * | getElement($form, $form_state) | + * | validateElement($form, $form_state) | + * | submitElement($form, $form_state) | + * '-----------------------------------------' + * + * + * Reactions + * The manager is use as an interface for Drupal hooks that need to have a + * reaction react + * .-----------------------. .--------------. + * .--------------. | Manager | | Reaction | + * | Drupal hooks |-->|-----------------------|-->|--------------| + * '--------------' | react($plugin, $data) | | react($data) | + * '-----------------------' '--------------' + * + * Plugins + * The Manager is a passthough to the plugin controller + */ class Manager { + protected $state_controller_site_state_key = 'sps_site_state_key'; + protected $state_controler; + protected $config_controller; + protected $override_controller; + protected $root_condition; + + /** + * Constructor for \Drupal\sps\Manager + * + * @param \Drupal\sps\StorageControllerInterface $state_controler + * The control to use when accessing State info (like site state) + * @param \Drupal\sps\StorageControllerInterface $override_controller + * the control to use when accessing overrides + * @param \Drupal\sps\StorageControllerInterface $config_controller + * the control to be used when accessing config + * @param \Drupal\sps\PluginControllerInterface $plugin_controller + * The control to use when accessing plugins + * + * @return + */ + public function __construct(StorageControllerInterface $state_controler, StorageControllerInterface $override_controller, StorageControllerInterface $config_controller, PluginControllerInterface $plugin_controller) { + $this->setStateController($state_controler); + $this->setOverrideController($override_controller); + $this->setConfigController($config_controller); + $this->setPluginController($plugin_controller); + } + + /** + * store the state controller + * + * @param Drupal\sps\StorageControllerInterface $controller + * The control to use when accessing State info (like site state) + * @return \Drupal\sps\Manager + * Self + */ + protected function setStateController(StorageControllerInterface $controller) { + $this->state_controller = $controller; + return $this; + } + + /** + * store the config controller + * + * @param \Drupal\sps\StorageControllerInterface $config_controller + * the control to be used when accessing config + * @return \Drupal\sps\Manager + * Self + */ + protected function setConfigController(StorageControllerInterface $controller) { + $this->config_controller = $controller; + return $this; + } /** - * Get the active Site State + * store the override controller * - * @return SiteState | NULL + * @param \Drupal\sps\StorageControllerInterface $override_controller + * the control to use when accessing overrides + * @return \Drupal\sps\Manager + * Self + */ + protected function setOverrideController(StorageControllerInterface $controller) { + $this->override_controller = $controller; + return $this; + } + + /** + * store the override controller * + * @param \Drupal\sps\PluginControllerInterface $plugin_controller + * The control to use when accessing plugins + * @return \Drupal\sps\Manager + * Self + */ + protected function setPluginController(PluginControllerInterface $controller) { + $this->plugin_controller = $controller; + return $this; + } + + /** + * Pull the site state from site state controller + * + * Note the state controller is resposible for resonable caching of the site state + * + * @return Vary + * SiteState | NULL + */ public function getSiteState() { - return new SiteState(); + if($this->state_controller->is_set($this->state_controller_site_state_key)) { + return $this->state_controller->get($this->state_controller_site_state_key); + } + } + + /** + * Create A SiteState from an override, and store it. + * + * This might get made private + * + * @param \Drupal\sps\OverrideInterface $override + * the override to use when creating the SiteState + * @return \Drupal\sps\Manager + * Self + */ + public function setSiteState(\Drupal\sps\Plugins\OverrideInterface $override) { + $site_state = new SiteState($this->override_controller, $override); + $this->state_controller->set($this->state_controller_site_state_key, $site_state); + return $this; + } + + /** + * Get what should be a relatively static variable used for storing the site state + * + * This is mostly used for tests + * + * @return String + * the controller key, a string + */ + public function getStateControllerSiteStateKey() { + return $this->state_controller_site_state_key; + } + + + /** + * Passthrough from Drupal form to the correct condition for building the preview form + * + * @param $form + * The form array used in hook_form + * @param $form_state + * The form_state array as used in hook_form + * + * @return + * A drupal form array created but the root condition + */ + public function getPreviewForm(&$form, &$form_state) { + $root_condition = $this->getRootCondition(); + return $root_condition->getElement($form, $form_state); + + } + + /** + * Passthrough fro Drupal form to the correct condition used for validate a preview form + * + * @param $form + * The form array passed to drupal validate functions + * @param $form_state + * The form_state array passed to drupal validate functions + * + * @return + * Self + */ + public function validatePreviewForm($form, &$form_state) { + $root_condition = $this->getRootCondition(); + $root_condition->validateElement($form, $form_state); + return $this; + } + + /** + * Passthrough from Drupal form to the correct condition's submit method. + * + * Also save the correct override after submit. + * + * @param $form + * The form array passed to drupal submit functions + * @param $form_state + * The form_state array passed to drupal submit functions + * + * @return + * Self + */ + public function submitPreviewForm($form, &$form_state) { + $root_condition = $this->getRootCondition(); + $root_condition->submitElement($form, $form_state); + $this->setSiteState($root_condition->getOverride()); + return $this; + } + + /** + * Helper method for getting and causing the root Condition + * + * The Root condition is the use as the basis for the constructing the preview form + * It can be expect that it will be much more comilicated then the other conditions + * + * This method select the condition and its config using the config controller. + * + * @return Drupal\sps\Plugins\ConditionInterface + * the current root condition object + */ + protected function getRootCondition() { + if(!isset($this->root_condition_plugin)) { + $settings = $this->config_controller->get(SPS_CONFIG_ROOT_CONDITION); + $root_condition_plugin = $settings['name']; + $this->root_condition_plugin = $this->getPlugin('condition', $root_condition_plugin); + $this->root_condition_plugin->setConfig($settings['config']); + } + return $this->root_condition_plugin; } /** - * Get a + * call a reaction rect method + * + * @param String $reaction + * the name of a reaction plugin; + * @param Vary $data + * data to be passed to the react method + * @return Vary + * Data used by the item calling raction */ + public function react($reaction, $data) { + return $this->getPlugin("reaction", $reaction)->react($data); + } + + /** + * factory for building a plugin object + * + * @param String $type + * the type of plugin as defined in hook_sps_plugin_types_info + * @param String $name + * the name of the plugin as defined in hook_sps_PLUGIN_TYPE_plugin_info; + * @return \Drupal\sps\PluginInterface + * An instance of the requested Plugin + */ + public function getPlugin($type, $name) { + return $this->plugin_controller->getPlugin($type, $name, $this); + } + + /** + * get meta info on a plugin + * @param String $type + * the type of plugin as defined in hook_sps_plugin_types_info + * @param String | Null $name + * the name of the plugin as defined in hook_sps_PLUGIN_TYPE_plugin_info; + * @return Array + * an array of meta data for the plugin + */ + public function getPluginInfo($type, $name=NULL) { + return $this->plugin_controller->getPluginInfo($type, $name); + } + + /** + * get meta info on a plugin + * + * @param String $type + * the type of plugin as defined in hook_sps_plugin_types_info + * @param String $property + * the meta property to compare to the value + * @param Vary $value + * the value to compare to the meta property + * @return Array + * an array of meta data for the plugins + */ + public function getPluginByMeta($type, $property, $value) { + return $this->plugin_controller->getPluginInfoByMeta($type); + } } diff --git a/sps/lib/Drupal/sps/OverrideInterface.php b/sps/lib/Drupal/sps/OverrideInterface.php deleted file mode 100644 index 6cbf3b0..0000000 --- a/sps/lib/Drupal/sps/OverrideInterface.php +++ /dev/null @@ -1,5 +0,0 @@ -timestamp = 0; + } + + /** + * Returns a list of vid's to override the default vids to load. + * + * @return + * An array of override vids. + */ + public function getOverrides() { + //for right now just load node vids that are set to be published in the future + $results = db_select('node_revision', 'v') + ->fields('v', array('nid, vid')) + ->condition('status', 0) + ->condition('timestamp', $this->timestamp, '>') + ->execute() + ->fetchAllAssoc('nid'); + + return $results; + } + + /** + * Set the data for this override. + * + * This method should be called before get overrides and provides the + * data which the override will use to find the available overrides. + * + * @param $timestamp + * A unix timestamp. + */ + public function setData($variables) { + $this->timestamp = $variables; + } + + /** + * Overrides Override::getDataConsumerApi() + * Provides the data type for this override. + * + * @return + * A string defining the data type + */ + public function getDataConsumerApi() { + return 'unixtimestamp'; + } +} \ No newline at end of file diff --git a/sps/lib/Drupal/sps/Plugins/Override/Override.php b/sps/lib/Drupal/sps/Plugins/Override/Override.php new file mode 100644 index 0000000..f584cd7 --- /dev/null +++ b/sps/lib/Drupal/sps/Plugins/Override/Override.php @@ -0,0 +1,44 @@ +varaiables = $varaiables; + } + + /** + * Report which data api this Override can consume. + * + * This allows overrides and widgets to be matched based on the + * type of data which they consume and provide (respectively). + * + * @return + * A string designating the data api this override accepts + */ + public function getDataConsumerApi() { + return 'generic'; + } +} diff --git a/sps/lib/Drupal/sps/Plugins/OverrideInterface.php b/sps/lib/Drupal/sps/Plugins/OverrideInterface.php new file mode 100644 index 0000000..3b40f55 --- /dev/null +++ b/sps/lib/Drupal/sps/Plugins/OverrideInterface.php @@ -0,0 +1,34 @@ +setCacheController($cache_controller); + * Constructor for SiteState + * + * @param $controller + * The StorageController to use for storing overrides + * @param $override + * The Override to use to generate overrides + */ + public function __construct(StorageControllerInterface $controller, Plugins\OverrideInterface $override) { + $this->setOverrideController($controller); $this->setOverride($override); } /** - * SiteState::setCacheController - * - * @param $controller StorageControllerInterface - * @return SiteState - */ - protected function setCacheController(StorageControllerInterface $controller) { - $this->cache_controller = $controller; + * Set the Controller for storing overrrides + * + * @param $controller + * The StorageController to use for storing Overrides + * + * @return + * Self + */ + protected function setOverrideController(StorageControllerInterface $controller) { + $this->override_controller = $controller; return $this; } /** - * SiteState::setOverride + * Store the Override to use for generating overrides * - * @param $override OverrideInterface - * @return SiteState + * @param $override + * The Override to use to generate overrides + * @return + * Self */ - protected function setOverride(OverrideInterface $override) { + protected function setOverride(Plugins\OverrideInterface $override) { $this->override = $override; return $this; } /** - * SiteState:getOverrides - * - * @param array - * of assoc arrays - */ + * Retrive Stored Overrides + * + * @return + * Array of overrides + */ public function getOverride() { - if(!$this->cache_controller->hasValidCache()) { + if(!$this->override_controller->is_set($this->controller_key)) { $this->cacheOverride(); } - return $this->cache_controller->getMap(); + return $this->override_controller->get($this->controller_key); } /** - * SiteState::cacheOverrides + * Generate overrides from the stored Override and save it to the Override Controller * - * @return SiteState + * @return + * Self */ protected function cacheOverride() { - $this->cache_controller->save($this->override->getOverrides()); + $this->override_controller->set($this->controller_key, $this->override->getOverrides()); return $this; } diff --git a/sps/lib/Drupal/sps/StorageController/CToolsObjectCache.php b/sps/lib/Drupal/sps/StorageController/CToolsObjectCache.php new file mode 100644 index 0000000..f3fd5ab --- /dev/null +++ b/sps/lib/Drupal/sps/StorageController/CToolsObjectCache.php @@ -0,0 +1,39 @@ +obj]['name'] = TRUE; + ctools_object_cache_set($this->obj, $name, $cache); + } + /** + * Test if we have an object cached + * This should be less expensive then using get + * + * @param $name + * A string name use for retrieval + * @return bool + */ + public function is_set($name); + return isset($_SESSION[$this->obj]['name']) && $_SESSION[$this->obj]['name']; + /** + * Retrieve a cached object + * + * @param $name + * A string name use for retrieval + * @return the object that was cached + */ + public function get($name); + return ctools_object_cache_get($this->obj, $name); +} diff --git a/sps/lib/Drupal/sps/StorageControllerInterface.php b/sps/lib/Drupal/sps/StorageControllerInterface.php index 5f9b50a..29de17c 100644 --- a/sps/lib/Drupal/sps/StorageControllerInterface.php +++ b/sps/lib/Drupal/sps/StorageControllerInterface.php @@ -1,10 +1,38 @@ element_form = $settings['element_form']; + $this->validate_fail_message = isset($settings['validate_fail_message']) ? $settings['validate_fail_message'] : NULL; + $this->validate_fail_name = isset($settings['validate_fail_name']) ? $settings['validate_fail_name'] : NULL; + $this->override = $settings['override']; + } + + /** + * Provide the config to allow this Condition to construct itself. + * + * @param $config + * An associative array of configuration, generally provided by the + * manager + * @return + * Self + */ + public function setConfig($config) { + return $this; + } + + /** + * Returns the consolidated Override for this Condition + * + * @return + * An instance of a class which implements OverrideInterface + */ + public function getOverride() { + if ($this->override_set) { + return $this->override; + } + } + + /** + * Returns the consolidated preview form for this Condition. + * + * @param $element + * Either the full form being build, or a subform of the fullform. + * Must have #parent set to designate parent keys which tree. + * + * @param $form_state + * The full form_state for the form which is being built. + * + * @return + * A FAPI array containing the form for this condition. + */ + public function getElement(&$element, &$form_state) { + return $this->element_form; + } + + /** + * Validates this Conditions preview form. + * + * This function should use form_set_error() to mark any fields + * which do not validate. + * + * @param $element + * The form portion (element) which should be validated + * @param $form_state + * The full form_state for the form which is being built. Note + * that values my be treed as described by $elements #parent key + * + * @return + * Self + */ + public function validateElement($element, &$form_state) { + if ($this->validate_fail_message || $this->validate_fail_name) { + form_set_error($this->validate_fail_name, $this->validate_fail_message); + } + return $this; + } + + /** + * Submit this Conditions preview form. + * + * This function should take the values from the widgets and + * hand them off to the respective overrides. + * + * @param $element + * The element (subform) which is being submitted. + * @param $form_state + * The form state containing the submitted values. Note + * that values my be treed as described by $elements #parent key + * + * @return + * Self + */ + public function submitElement($element, &$form_state) { + $this->override_set = TRUE; + return $this; + } +} diff --git a/sps/lib/Drupal/sps/Test/Override.php b/sps/lib/Drupal/sps/Test/Override.php index 1541f54..1b571cd 100644 --- a/sps/lib/Drupal/sps/Test/Override.php +++ b/sps/lib/Drupal/sps/Test/Override.php @@ -1,11 +1,19 @@ table = $table; + public function __construct($settings, $manager) { } + public function getOverrides() { return $this->table; } + + public function setData($table) { + $this->table = $table; + } + + public function getDataConsumerApi() { + return 'test'; + } } diff --git a/sps/lib/Drupal/sps/Test/PluginController.php b/sps/lib/Drupal/sps/Test/PluginController.php new file mode 100644 index 0000000..143f487 --- /dev/null +++ b/sps/lib/Drupal/sps/Test/PluginController.php @@ -0,0 +1,64 @@ +infos = $infos; + } + /** + * factory for building a plugin object + * + * @param $type + * the type of plugin as defined in hook_sps_plugin_types_info + * @param $name + * the name of the plugin as defined in hook_sps_PLUGIN_TYPE_plugin_info; + * @return + * an array of meta data for the plugin + */ + public function getPlugin($type, $name, $manager) { + $info = $this->getPluginInfo($type, $name); + $class = $info['class']; + $r = new \ReflectionClass($info['class']); + return $r->newInstanceArgs(array($info['instance_settings'], $manager)); + + + } + + /** + * get meta info on a plugin + * + * @param $type + * the type of plugin as defined in hook_sps_plugin_types_info + * @param $name + * the name of the plugin as defined in hook_sps_PLUGIN_TYPE_plugin_info; + * @return + * an array of meta data for the plugin or an array of plugin arrays + */ + public function getPluginInfo($type, $name=NULL) { + $type = $this->infos[$type]; + if($name) { + return $type[$name]; + } + else { + return $type; + } + } + + /** + * get meta info on a plugin + * + * @param $type + * the type of plugin as defined in hook_sps_plugin_types_info + * @param $property + * the meta property to compare to the value + * @param $value + * the value to compare to the meta property + * @return + * an array of meta data for the plugins + */ + public function getPluginByMeta($type, $property, $value) { + $plugins = $this->getPluginInfo($type); + return array_filter(function($plugin) use($property, $value) { return (isset($plugin[$property]) && ($plugin[$property] == $value));}, $plugins); + } + +} diff --git a/sps/lib/Drupal/sps/Test/StorageController.php b/sps/lib/Drupal/sps/Test/StorageController.php index ebef4c4..66940e5 100644 --- a/sps/lib/Drupal/sps/Test/StorageController.php +++ b/sps/lib/Drupal/sps/Test/StorageController.php @@ -1,19 +1,44 @@ table = $table; + protected $cache = array(); + /** + * Cache away a object + * + * @param $name + * A string name use for retrieval + * @param $cache + * an object to be cached + * @return NULL + */ + public function set($name, $cache) { + $this->cache[$name] = $cache; } - public function getRevisionId($type, $id) { - return array_reduce($this->table, function($result, $item) use ($type, $id) { - if(($item['id'] == $id) && ($item['type'] == $type)) { - $result = $item['revision_id']; - } - return $result; - }); + +/** + * Test if we have an object cached + * This should be less expensive then using get + * + * @param $name + * A string name use for retrieval + * @return bool + */ + public function is_set($name) { + return isset($this->cache[$name]); } - public function getMap() { return $this->table; } - public function hasValidCache() { return (bool) $this->table ;} + /** + * Retrieve a cached object + * + * @param $name + * A string name use for retrieval + * @return the object that was cached + */ + public function get($name) { + if ($this->is_set($name)) { + return $this->cache[$name]; + } + throw new \Exception("Drupal\\sps\\Test\\PersistentStorageController does not have $name cached"); + } + } diff --git a/sps/sps.module b/sps/sps.module index 71bfb99..3ef6575 100644 --- a/sps/sps.module +++ b/sps/sps.module @@ -1,6 +1,6 @@ 'SPS Manager Unit Tests', + 'description' => 'Test the public interface to the Manager object', + 'group' => 'SPS', + ); + } + + public function testManager_getNullSiteState() { + $controllers = _sps_test_get_basic_controllers(); + $manager = _sps_test_get_new_manager($controllers); + $this->assertNull($manager->getSiteState(), "Manager::getSiteState should return null if there is no state", "SPS"); + } + public function testManager_getPersistentSiteState() { + $controllers = _sps_test_get_basic_controllers(); + $manager = _sps_test_get_new_manager($controllers); + $state_controller = $controllers['state_controller']; + + $table = array(array("id"=> 1, "revision_id" => 2, "type"=>"bob")); + $override = new \Drupal\sps\Test\Override(array(), new stdClass()); + $override->setData($table); + $site_state = new Drupal\sps\SiteState($controllers['override_controller'], $override); + + $state_controller->set($manager->getStateControllerSiteStateKey(), $site_state); + $this->assertEqual($manager->getSiteState(), $site_state, "Manager::getSiteState returns a site_state storred in the persistent data", "SPS"); + } + public function testManager_setSiteState() { + $controllers = _sps_test_get_basic_controllers(); + $manager = _sps_test_get_new_manager($controllers); + $override_controller = $controllers['override_controller']; + $state_controller = $controllers['state_controller']; + + $table = array(array("id"=> 1, "revision_id" => 2, "type"=>"bob")); + $override = new \Drupal\sps\Test\Override(array(), new stdClass()); + $override->setData($table); + $manager->setSiteState($override); + + $site_state = new Drupal\sps\SiteState($override_controller, $override); + $this->assertEqual($state_controller->get($manager->getStateControllerSiteStateKey()), $site_state, "Manager::setSiteState construct the site_state and put it in site_state_controller", "SPS"); + + } + public function testManager_PluginAccess() { + $info = array( + 'widget' => array( + 'test_widget' => array( + 'class' => '\Drupal\sps\Test\Override', + 'instance_settings' => array(), + ), + ), + ); + $controllers = _sps_test_get_basic_controllers(); + $controllers['plugin_controller'] = new Drupal\sps\Test\PluginController($info); + $manager = _sps_test_get_new_manager($controllers); + + $this->assertEqual( + $manager->getPluginInfo('widget'), + $info['widget'], + "TestStorageController::getPluginInfo should get me all of the plugin infos for that type if i only pass it one param", 'SPS' + ); + $this->assertEqual( + $manager->getPluginInfo('widget', 'test_widget'), + $info['widget']['test_widget'], + 'TestStorageController::getPluginInfo should get the plugin info for the plugin when passed two param', 'SPS' + ); + $this->assertEqual( + $manager->getPlugin('widget', 'test_widget'), + new \Drupal\sps\Test\Override(array(), new StdClass()), + 'TestStorageController::getPlugin should build a obj from the plugin info', 'SPS' + ); + + } + public function testManager_previewForm() { + $override = new \Drupal\sps\Test\Override(array(), new stdClass()); + $override->setData(array(array('id'=>1, 'revision_id' =>3, 'type' => 'article'))); + $settings = array( + 'element_form' => array( + 'test' => array( + '#markup' => 'This is Test Markup', + ), + ), + 'validate_fail_message' => "There was an error", + 'validate_fail_name' => "error_item", + 'override' => $override, + ); + + $info = array( + 'condition' => array( + 'testCondition' => array( + 'class' => '\Drupal\sps\Test\Condition', + 'instance_settings' => $settings, + ), + ), + ); + $controllers = _sps_test_get_basic_controllers(); + $controllers['plugin_controller'] = new Drupal\sps\Test\PluginController($info); + $config_controller = $controllers['config_controller']; + $config_controller->set(SPS_CONFIG_ROOT_CONDITION, array("name" => 'testCondition', 'config' => array())); + $manager = _sps_test_get_new_manager($controllers); + $form = array(); + $form_state = array(); + + $this->assertEqual( + $manager->getPreviewForm($form, $form_state), + $settings['element_form'], + "Manager::getPreviewForm should pull the form from the condition from the getElement method of the condition specified as the root condition in the config", 'SPS' + ); + + form_clear_error(); + $manager->validatePreviewForm($form, $form_state); + $this->assertEqual( + form_get_errors(), + array($settings['validate_fail_name'] => $settings['validate_fail_message']), + "Manager::validatePreviewForm should run validateElement on the Root Condition (we are testing that a form_set_error is called)", 'SPS' + ); + + $manager->submitPreviewForm($form, $form_state); + $site_state = $manager->getSiteState(); + $this->assertEqual( + $site_state->getOverride(), + $override->getOverrides(), + "Manager::submitPreviewForm summits the from to the root condition, as the former for the override and builds the site state with that override.", 'SPS' + ); +; + + } +} + +/** +* helper function for getting a Manager +* +* @param $controllers +* array of controller from _sps_test_Get_basic_controllers +* +* @return +* a Manager object +*/ +function _sps_test_get_new_manager($controllers) { + return new Drupal\sps\Manager($controllers['state_controller'], $controllers['override_controller'], $controllers['config_controller'], $controllers['plugin_controller']); +} + +/** +* A array of controllers to be feed to _sos_test_get_new_manager +* +* @return +* A array of controllers to be feed to _sos_test_get_new_manager +*/ +function _sps_test_get_basic_controllers() { + $controllers = array(); + $controllers['state_controller'] = new Drupal\sps\Test\StorageController(); + $controllers['override_controller'] = new Drupal\sps\Test\StorageController(); + $controllers['config_controller'] = new Drupal\sps\Test\StorageController(); + $controllers['plugin_controller'] = new Drupal\sps\Test\PluginController(array()); + return $controllers; +} diff --git a/sps/tests/SPSSiteStateUnitTest.test b/sps/tests/SPSSiteStateUnitTest.test index 00f5176..f16e22b 100644 --- a/sps/tests/SPSSiteStateUnitTest.test +++ b/sps/tests/SPSSiteStateUnitTest.test @@ -24,19 +24,17 @@ class SPSSiteStateUnitTest extends SPSBaseUnitTest { 'revision_id' => 7, ), ); - $control->save($table); - $this->assertEqual($control->getMap(), $table, 'StorageController:: save sould store the array to be retrieved by ::getMap', 'SPS'); - $this->assertEqual( - $control->getRevisionId($table[0]['type'], $table[0]['id']), - $table[0]['revision_id'], - 'StorageController::getRevisionID should search table that was stored by save', 'SPS'); + $key = "test_key"; + $control->set($key, $table); + $this->assertEqual($control->get($key), $table, 'StorageController:: set stores the array to be retrieved by get', 'SPS'); } public function testTestOverride() { $table = array( array('type' => 'thing', 'id' => 1, 'revision_id' => 5), array('type' => 'thing', 'id' => 3, 'revision_id' => 7), ); - $override = new \Drupal\sps\Test\Override($table); + $override = new \Drupal\sps\Test\Override(array(), new stdClass()); + $override->setData($table); $this->assertEqual($override->getOverrides(), $table, 'Override should take in a table and return it for overrides', 'SPS'); } @@ -46,7 +44,8 @@ class SPSSiteStateUnitTest extends SPSBaseUnitTest { array('type' => 'thing', 'id' => 3, 'revision_id' => 7), array('type' => 'thing', 'id' => 2, 'revision_id' => 97), ); - $override_a = new \Drupal\sps\Test\Override($table); + $override_a = new \Drupal\sps\Test\Override(array(), new stdClass()); + $override_a->setData($table); $site_state = new Drupal\sps\SiteState($control, $override_a); $this->assertEqual($site_state->getOverride(), $table, "SiteState::getOverrides should return table given up by controller"); $override_a->table[0]['id'] = 6; diff --git a/sps/tests/SPSTestConditionUnit.test b/sps/tests/SPSTestConditionUnit.test new file mode 100644 index 0000000..24f160c --- /dev/null +++ b/sps/tests/SPSTestConditionUnit.test @@ -0,0 +1,52 @@ + 'SPS Test Condition Unit Tests', + 'description' => 'Test the public interface to the Test Condition object', + 'group' => 'SPS', + ); + } + + public function testTestCondition() { + $manager = new stdClass(); + $settings = array( + 'element_form' => array( + 'test' => array( + '#markup' => 'This is Test Markup', + ), + ), + 'validate_fail_message' => "There was an error", + 'validate_fail_name' => "error_item", + 'override' => new \Drupal\sps\Test\Override(array(), $manager), + ); + $condition = new \Drupal\sps\Test\Condition($settings, $manager); + $form = array(); + $form_state = array(); + $this->assertEqual( + $condition->getElement($form, $form_state), + $settings['element_form'], + "TestCondition::getElement should return the element_form from settings", 'SPS' + ); + $this->assertEqual( + $condition->getOverride(), + NULL, + "TestCondition::getOverride should return NULL if the submit has not yet been called", 'SPS' + ); + + form_clear_error(); + $condition->validateElement($form, $form_state); + $this->assertEqual( + form_get_errors(), + array($settings['validate_fail_name'] => $settings['validate_fail_message']), + "TestCondition::validateElement should log a form error if validate_fail_message or validate_Fail_name are set", 'SPS' + ); + $condition->submitElement($form, $form_state); + $this->assertEqual( + $condition->getOverride(), + $settings['override'], + "TestCondition::getOverride should return the override in settings if submitElement has been called", 'SPS' + ); + } + +} diff --git a/sps/tests/SPSTestPluginControllerUnit.test b/sps/tests/SPSTestPluginControllerUnit.test new file mode 100644 index 0000000..d676796 --- /dev/null +++ b/sps/tests/SPSTestPluginControllerUnit.test @@ -0,0 +1,39 @@ + 'SPS Test Plugin Controller Unit Tests', + 'description' => 'Test the public interface to the TestPluginContrller object', + 'group' => 'SPS', + ); + } + + public function testTestPluginController() { + $info = array( + 'widget' => array( + 'test_widget' => array( + 'class' => '\Drupal\sps\Test\Override', + 'instance_settings' => array(), + ), + ), + ); + $controller = new \Drupal\sps\Test\PluginController($info); + $this->assertEqual( + $controller->getPluginInfo('widget'), + $info['widget'], + "TestStorageController::getPluginInfo should get me all of the plugin infos for that type if i only pass it one param", 'SPS' + ); + $this->assertEqual( + $controller->getPluginInfo('widget', 'test_widget'), + $info['widget']['test_widget'], + 'TestStorageController::getPluginInfo should get the plugin info for the plugin when passed two param', 'SPS' + ); + $this->assertEqual( + $controller->getPlugin('widget', 'test_widget', new StdClass()), + new \Drupal\sps\Test\Override(array(), new StdClass()), + 'TestStorageController::getPlugin should build a obj from the plugin info', 'SPS' + ); + + } + +} diff --git a/sps/tests/SPSTestStorageControllerUnit.test b/sps/tests/SPSTestStorageControllerUnit.test new file mode 100644 index 0000000..5c47120 --- /dev/null +++ b/sps/tests/SPSTestStorageControllerUnit.test @@ -0,0 +1,20 @@ + 'SPS Test StorageController Unit Tests', + 'description' => 'Test the public interface to the Test StorageController object', + 'group' => 'SPS', + ); + } + + public function testTestStorageController() { + $control = new Drupal\sps\Test\StorageController(); + $obj = new stdClass(); + $obj->param = "PARAM"; + $control->set("test", $obj); + $this->assertTrue($control->is_set("test"), "Test StorageController is_set is True when a name has been set", "SPS"); + $this->assertFalse($control->is_set("not set"), "Test StorageController is_set is False when a name has been set", "SPS"); + $this->assertEqual($control->get("test"), $obj, "Test StorageController's set and get should set and retrieve the same obj.", "SPS"); + } +}