6 files changed, 697 insertions, 23 deletions

diff --git a/engine/tests/api/access_collections.php b/engine/tests/api/access_collections.php
new file mode 100644
index 000000000..1e61c45bb
--- /dev/null
+++ b/engine/tests/api/access_collections.php
@@ -0,0 +1,269 @@
+<?php
+/**
+ * Access Collections tests
+ *
+ * @package Elgg
+ * @subpackage Test
+ */
+class ElggCoreAccessCollectionsTest extends ElggCoreUnitTest {
+
+	/**
+	 * Called before each test object.
+	 */
+	public function __construct() {
+		parent::__construct();
+
+		$this->dbPrefix = get_config("dbprefix");
+
+		$user = new ElggUser();
+		$user->username = 'test_user_' . rand();
+		$user->email = 'fake_email@fake.com' . rand();
+		$user->name = 'fake user';
+		$user->access_id = ACCESS_PUBLIC;
+		$user->salt = generate_random_cleartext_password();
+		$user->password = generate_user_password($user, rand());
+		$user->owner_guid = 0;
+		$user->container_guid = 0;
+		$user->save();
+
+		$this->user = $user;
+	}
+
+	/**
+	 * Called before each test method.
+	 */
+	public function setUp() {
+
+	}
+
+	/**
+	 * Called after each test method.
+	 */
+	public function tearDown() {
+		// do not allow SimpleTest to interpret Elgg notices as exceptions
+		$this->swallowErrors();
+	}
+
+	/**
+	 * Called after each test object.
+	 */
+	public function __destruct() {
+		// all __destruct() code should go above here
+		$this->user->delete();
+		parent::__destruct();
+	}
+
+	public function testCreateGetDeleteACL() {
+		global $DB_QUERY_CACHE;
+		
+		$acl_name = 'test access collection';
+		$acl_id = create_access_collection($acl_name);
+
+		$this->assertTrue(is_int($acl_id));
+
+		$q = "SELECT * FROM {$this->dbPrefix}access_collections WHERE id = $acl_id";
+		$acl = get_data_row($q);
+
+		$this->assertEqual($acl->id, $acl_id);
+
+		if ($acl) {
+			$DB_QUERY_CACHE = array();
+			
+			$this->assertEqual($acl->name, $acl_name);
+
+			$result = delete_access_collection($acl_id);
+			$this->assertTrue($result);
+
+			$q = "SELECT * FROM {$this->dbPrefix}access_collections WHERE id = $acl_id";
+			$data = get_data($q);
+			$this->assertFalse($data);
+		}
+	}
+
+	public function testAddRemoveUserToACL() {
+		$acl_id = create_access_collection('test acl');
+
+		$result = add_user_to_access_collection($this->user->guid, $acl_id);
+		$this->assertTrue($result);
+
+		if ($result) {
+			$result = remove_user_from_access_collection($this->user->guid, $acl_id);
+			$this->assertTrue($result);
+		}
+
+		delete_access_collection($acl_id);
+	}
+
+	public function testUpdateACL() {
+		// another fake user to test with
+		$user = new ElggUser();
+		$user->username = 'test_user_' . rand();
+		$user->email = 'fake_email@fake.com' . rand();
+		$user->name = 'fake user';
+		$user->access_id = ACCESS_PUBLIC;
+		$user->salt = generate_random_cleartext_password();
+		$user->password = generate_user_password($user, rand());
+		$user->owner_guid = 0;
+		$user->container_guid = 0;
+		$user->save();
+
+		$acl_id = create_access_collection('test acl');
+
+		$member_lists = array(
+			// adding
+			array(
+				$this->user->guid,
+				$user->guid
+			),
+			// removing one, keeping one.
+			array(
+				$user->guid
+			),
+			// removing one, adding one
+			array(
+				$this->user->guid,
+			),
+			// removing all.
+			array()
+		);
+
+		foreach ($member_lists as $members) {
+			$result = update_access_collection($acl_id, $members);
+			$this->assertTrue($result);
+
+			if ($result) {
+				$q = "SELECT * FROM {$this->dbPrefix}access_collection_membership
+					WHERE access_collection_id = $acl_id";
+				$data = get_data($q);
+
+				if (count($members) == 0) {
+					$this->assertFalse($data);
+				} else {
+					$this->assertEqual(count($members), count($data));
+				}
+				foreach ($data as $row) {
+					$this->assertTrue(in_array($row->user_guid, $members));
+				}
+			}
+		}
+
+		delete_access_collection($acl_id);
+		$user->delete();
+	}
+
+	public function testCanEditACL() {
+		$acl_id = create_access_collection('test acl', $this->user->guid);
+
+		// should be true since it's the owner
+		$result = can_edit_access_collection($acl_id, $this->user->guid);
+		$this->assertTrue($result);
+
+		// should be true since IA is on.
+		$ia = elgg_set_ignore_access(true);
+		$result = can_edit_access_collection($acl_id);
+		$this->assertTrue($result);
+		elgg_set_ignore_access($ia);
+
+		// should be false since IA is off
+		$ia = elgg_set_ignore_access(false);
+		$result = can_edit_access_collection($acl_id);
+		$this->assertFalse($result);
+		elgg_set_ignore_access($ia);
+
+		delete_access_collection($acl_id);
+	}
+
+	public function testCanEditACLHook() {
+		// if only we supported closures!
+		global $acl_test_info;
+
+		$acl_id = create_access_collection('test acl');
+
+		$acl_test_info = array(
+			'acl_id' => $acl_id,
+			'user' => $this->user
+		);
+		
+		function test_acl_access_hook($hook, $type, $value, $params) {
+			global $acl_test_info;
+			if ($params['user_id'] == $acl_test_info['user']->guid) {
+				$acl = get_access_collection($acl_test_info['acl_id']);
+				$value[$acl->id] = $acl->name;
+			}
+
+			return $value;
+		}
+
+		register_plugin_hook('access:collections:write', 'all', 'test_acl_access_hook');
+
+		// enable security since we usually run as admin
+		$ia = elgg_set_ignore_access(false);
+		$result = can_edit_access_collection($acl_id, $this->user->guid);
+		$this->assertTrue($result);
+		$ia = elgg_set_ignore_access($ia);
+
+		unregister_plugin_hook('access:collections:write', 'all', 'test_acl_access_hook');
+	}
+
+	// groups interface
+	// only runs if the groups plugin is enabled because implementation is split between
+	// core and the plugin.
+	public function testCreateDeleteGroupACL() {
+		if (!is_plugin_enabled('groups')) {
+			return;
+		}
+		
+		$group = new ElggGroup();
+		$group->name = 'Test group';
+		$group->save();
+		$acl = get_access_collection($group->group_acl);
+
+		// ACLs are owned by groups
+		$this->assertEqual($acl->owner_guid, $group->guid);
+
+		// removing group and acl
+		$this->assertTrue($group->delete());
+		
+		$acl = get_access_collection($group->group_acl);
+		$this->assertFalse($acl);
+
+		$group->delete();
+	}
+
+	public function testJoinLeaveGroupACL() {
+		if (!is_plugin_enabled('groups')) {
+			return;
+		}
+
+		$group = new ElggGroup();
+		$group->name = 'Test group';
+		$group->save();
+
+		$result = $group->join($this->user);
+		$this->assertTrue($result);
+
+		// disable security since we run as admin
+		$ia = elgg_set_ignore_access(false);
+
+		// need to set the page owner to emulate being in a group context.
+		// this is kinda hacky.
+		elgg_set_page_owner_guid($group->getGUID());
+
+		if ($result) {
+			$can_edit = can_edit_access_collection($group->group_acl, $this->user->guid);
+			$this->assertTrue($can_edit);
+		}
+
+		$result = $group->leave($this->user);
+		$this->assertTrue($result);
+
+		if ($result) {
+			$can_edit = can_edit_access_collection($group->group_acl, $this->user->guid);
+			$this->assertFalse($can_edit);
+		}
+
+		 elgg_set_ignore_access($ia);
+
+		$group->delete();
+	}
+}
diff --git a/engine/tests/api/entity_getter_functions.php b/engine/tests/api/entity_getter_functions.php
index aef7a991e..59b48999c 100644
--- a/engine/tests/api/entity_getter_functions.php
+++ b/engine/tests/api/entity_getter_functions.php
@@ -2789,4 +2789,13 @@ class ElggCoreEntityGetterFunctionsTest extends ElggCoreUnitTest {
 			$this->assertEqual($a_e_map[$a->id], $a->owner_guid);
 		}
 	}
+
+	public function testElggGetEntitiesBadWheres() {
+		$options = array(
+			'container_guid' => 'abc'
+		);
+
+		$entities = elgg_get_entities($options);
+		$this->assertFalse($entities);
+	}
 }
diff --git a/engine/tests/api/helpers.php b/engine/tests/api/helpers.php
index 461627547..36d680d54 100644
--- a/engine/tests/api/helpers.php
+++ b/engine/tests/api/helpers.php
@@ -31,6 +31,7 @@ class ElggCoreHelpersTest extends ElggCoreUnitTest {
 
 		global $CONFIG;
 		unset($CONFIG->externals);
+		unset($CONFIG->externals_map);
 	}
 
 	/**
@@ -106,7 +107,16 @@ class ElggCoreHelpersTest extends ElggCoreUnitTest {
 		// specify name
 		$result = elgg_register_js('key', 'http://test1.com', 'footer');
 		$this->assertTrue($result);
-		$this->assertIdentical('http://test1.com', $CONFIG->externals['js']['key']->url);
+		$this->assertTrue(isset($CONFIG->externals_map['js']['key']));
+
+		$item = $CONFIG->externals_map['js']['key'];
+		$this->assertTrue($CONFIG->externals['js']->contains($item));
+
+		$priority = $CONFIG->externals['js']->getPriority($item);
+		$this->assertTrue($priority !== false);
+
+		$item = $CONFIG->externals['js']->getElement($priority);
+		$this->assertIdentical('http://test1.com', $item->url);
 
 		// send a bad url
 		$result = @elgg_register_js('bad');
@@ -118,11 +128,20 @@ class ElggCoreHelpersTest extends ElggCoreUnitTest {
 	 */
 	public function testElggRegisterCSS() {
 		global $CONFIG;
-
+		
 		// specify name
 		$result = elgg_register_css('key', 'http://test1.com');
 		$this->assertTrue($result);
-		$this->assertIdentical('http://test1.com', $CONFIG->externals['css']['key']->url);
+		$this->assertTrue(isset($CONFIG->externals_map['css']['key']));
+
+		$item = $CONFIG->externals_map['css']['key'];
+		$this->assertTrue($CONFIG->externals['css']->contains($item));
+
+		$priority = $CONFIG->externals['css']->getPriority($item);
+		$this->assertTrue($priority !== false);
+
+		$item = $CONFIG->externals['css']->getElement($priority);
+		$this->assertIdentical('http://test1.com', $item->url);
 	}
 
 	/**
@@ -134,21 +153,43 @@ class ElggCoreHelpersTest extends ElggCoreUnitTest {
 		$base = trim(elgg_get_site_url(), "/");
 
 		$urls = array('id1' => "$base/urla", 'id2' => "$base/urlb", 'id3' => "$base/urlc");
+		
 		foreach ($urls as $id => $url) {
 			elgg_register_js($id, $url);
 		}
 
 		$result = elgg_unregister_js('id1');
 		$this->assertTrue($result);
-		@$this->assertNULL($CONFIG->externals['js']['head']['id1']);
+
+		$js = $CONFIG->externals['js'];
+		$elements = $js->getElements();
+		$this->assertFalse(isset($CONFIG->externals_map['js']['id1']));
+		
+		foreach ($elements as $element) {
+			$this->assertFalse($element->name == 'id1');
+		}
 
 		$result = elgg_unregister_js('id1');
 		$this->assertFalse($result);
+
 		$result = elgg_unregister_js('', 'does_not_exist');
 		$this->assertFalse($result);
 
 		$result = elgg_unregister_js('id2');
-		$this->assertIdentical($urls['id3'], $CONFIG->externals['js']['id3']->url);
+		$elements = $js->getElements();
+
+		$this->assertFalse(isset($CONFIG->externals_map['js']['id2']));
+		foreach ($elements as $element) {
+			$this->assertFalse($element->name == 'id2');
+		}
+
+		$this->assertTrue(isset($CONFIG->externals_map['js']['id3']));
+
+		$priority = $CONFIG->externals['js']->getPriority($CONFIG->externals_map['js']['id3']);
+		$this->assertTrue($priority !== false);
+
+		$item = $CONFIG->externals['js']->getElement($priority);
+		$this->assertIdentical($urls['id3'], $item->url);
 	}
 
 	/**
@@ -161,8 +202,9 @@ class ElggCoreHelpersTest extends ElggCoreUnitTest {
 		elgg_load_js('key');
 		$result = elgg_register_js('key', 'http://test1.com', 'footer');
 		$this->assertTrue($result);
+		
 		$js_urls = elgg_get_loaded_js('footer');
-		$this->assertIdentical(array('http://test1.com'), $js_urls);
+		$this->assertIdentical(array(500 => 'http://test1.com'), $js_urls);
 	}
 
 	/**
@@ -173,18 +215,295 @@ class ElggCoreHelpersTest extends ElggCoreUnitTest {
 
 		$base = trim(elgg_get_site_url(), "/");
 
-		$urls = array('id1' => "$base/urla", 'id2' => "$base/urlb", 'id3' => "$base/urlc");
+		$urls = array(
+			'id1' => "$base/urla",
+			'id2' => "$base/urlb",
+			'id3' => "$base/urlc"
+		);
+		
 		foreach ($urls as $id => $url) {
 			elgg_register_js($id, $url);
 			elgg_load_js($id);
 		}
 
 		$js_urls = elgg_get_loaded_js('head');
-		$this->assertIdentical($js_urls[0], $urls['id1']);
-		$this->assertIdentical($js_urls[1], $urls['id2']);
-		$this->assertIdentical($js_urls[2], $urls['id3']);
+
+		$this->assertIdentical($js_urls[500], $urls['id1']);
+		$this->assertIdentical($js_urls[501], $urls['id2']);
+		$this->assertIdentical($js_urls[502], $urls['id3']);
 
 		$js_urls = elgg_get_loaded_js('footer');
 		$this->assertIdentical(array(), $js_urls);
 	}
-}
+
+	// test ElggPriorityList
+	public function testElggPriorityListAdd() {
+		$pl = new ElggPriorityList();
+		$elements = array(
+			'Test value',
+			'Test value 2',
+			'Test value 3'
+		);
+
+		shuffle($elements);
+
+		foreach ($elements as $element) {
+			$this->assertTrue($pl->add($element) !== false);
+		}
+
+		$test_elements = $pl->getElements();
+
+		$this->assertTrue(is_array($test_elements));
+
+		foreach ($test_elements as $i => $element) {
+			// should be in the array
+			$this->assertTrue(in_array($element, $elements));
+
+			// should be the only element, so priority 0
+			$this->assertEqual($i, array_search($element, $elements));
+		}
+	}
+
+	public function testElggPriorityListAddWithPriority() {
+		$pl = new ElggPriorityList();
+
+		$elements = array(
+			10 => 'Test Element 10',
+			5 => 'Test Element 5',
+			0 => 'Test Element 0',
+			100 => 'Test Element 100',
+			-1 => 'Test Element -1',
+			-5 => 'Test Element -5'
+		);
+
+		foreach ($elements as $priority => $element) {
+			$pl->add($element, $priority);
+		}
+
+		$test_elements = $pl->getElements();
+
+		// should be sorted by priority
+		$elements_sorted = array(
+			-5 => 'Test Element -5',
+			-1 => 'Test Element -1',
+			0 => 'Test Element 0',
+			5 => 'Test Element 5',
+			10 => 'Test Element 10',
+			100 => 'Test Element 100',
+		);
+
+		$this->assertIdentical($elements_sorted, $test_elements);
+
+		foreach ($test_elements as $priority => $element) {
+			$this->assertIdentical($elements[$priority], $element);
+		}
+	}
+
+	public function testElggPriorityListGetNextPriority() {
+		$pl = new ElggPriorityList();
+
+		$elements = array(
+			2 => 'Test Element',
+			0 => 'Test Element 2',
+			-2 => 'Test Element 3',
+		);
+
+		foreach ($elements as $priority => $element) {
+			$pl->add($element, $priority);
+		}
+
+		// we're not specifying a priority so it should be the next consecutive to 0.
+		$this->assertEqual(1, $pl->getNextPriority());
+
+		// add another one at priority 1
+		$pl->add('Test Element 1');
+
+		// next consecutive to 0 is now 3.
+		$this->assertEqual(3, $pl->getNextPriority());
+	}
+
+	public function testElggPriorityListRemove() {
+		$pl = new ElggPriorityList();
+
+		$elements = array();
+		for ($i=0; $i<3; $i++) {
+			$element = new stdClass();
+			$element->name = "Test Element $i";
+			$element->someAttribute = rand(0, 9999);
+			$elements[] = $element;
+			$pl->add($element);
+		}
+
+		$pl->remove($elements[1]);
+
+		$test_elements = $pl->getElements();
+
+		// make sure it's gone.
+		$this->assertTrue(2, count($test_elements));
+		$this->assertIdentical($elements[0], $test_elements[0]);
+		$this->assertIdentical($elements[2], $test_elements[2]);
+	}
+
+	public function testElggPriorityListMove() {
+		$pl = new ElggPriorityList();
+
+		$elements = array(
+			-5 => 'Test Element -5',
+			0 => 'Test Element 0',
+			5 => 'Test Element 5',
+		);
+
+		foreach ($elements as $priority => $element) {
+			$pl->add($element, $priority);
+		}
+
+		$this->assertTrue($pl->move($elements[-5], 10));
+		
+		// check it's at the new place
+		$this->assertIdentical($elements[-5], $pl->getElement(10));
+
+		// check it's not at the old
+		$this->assertFalse($pl->getElement(-5));
+	}
+
+	public function testElggPriorityListConstructor() {
+		$elements = array(
+			10 => 'Test Element 10',
+			5 => 'Test Element 5',
+			0 => 'Test Element 0',
+			100 => 'Test Element 100',
+			-1 => 'Test Element -1',
+			-5 => 'Test Element -5'
+		);
+
+		$pl = new ElggPriorityList($elements);
+		$test_elements = $pl->getElements();
+
+		$elements_sorted = array(
+			-5 => 'Test Element -5',
+			-1 => 'Test Element -1',
+			0 => 'Test Element 0',
+			5 => 'Test Element 5',
+			10 => 'Test Element 10',
+			100 => 'Test Element 100',
+		);
+
+		$this->assertIdentical($elements_sorted, $test_elements);
+	}
+
+	public function testElggPriorityListGetPriority() {
+		$pl = new ElggPriorityList();
+
+		$elements = array(
+			'Test element 0',
+			'Test element 1',
+			'Test element 2',
+		);
+
+		foreach ($elements as $element) {
+			$pl->add($element);
+		}
+
+		$this->assertIdentical(0, $pl->getPriority($elements[0]));
+		$this->assertIdentical(1, $pl->getPriority($elements[1]));
+		$this->assertIdentical(2, $pl->getPriority($elements[2]));
+	}
+
+	public function testElggPriorityListGetElement() {
+		$pl = new ElggPriorityList();
+		$priorities = array();
+
+		$elements = array(
+			'Test element 0',
+			'Test element 1',
+			'Test element 2',
+		);
+
+		foreach ($elements as $element) {
+			$priorities[] = $pl->add($element);
+		}
+
+		$this->assertIdentical($elements[0], $pl->getElement($priorities[0]));
+		$this->assertIdentical($elements[1], $pl->getElement($priorities[1]));
+		$this->assertIdentical($elements[2], $pl->getElement($priorities[2]));
+	}
+
+	public function testElggPriorityListPriorityCollision() {
+		$pl = new ElggPriorityList();
+		
+		$elements = array(
+			5 => 'Test element 5',
+			6 => 'Test element 6',
+			0 => 'Test element 0',
+		);
+
+		foreach ($elements as $priority => $element) {
+			$pl->add($element, $priority);
+		}
+
+		// add at a colliding priority
+		$pl->add('Colliding element', 5);
+
+		// should float to the top closest to 5, so 7
+		$this->assertEqual(7, $pl->getPriority('Colliding element'));
+	}
+
+	public function testElggPriorityListIterator() {
+		$elements = array(
+			-5 => 'Test element -5',
+			0 => 'Test element 0',
+			5 => 'Test element 5'
+		);
+		
+		$pl = new ElggPriorityList($elements);
+
+		foreach ($pl as $priority => $element) {
+			$this->assertIdentical($elements[$priority], $element);
+		}
+	}
+
+	public function testElggPriorityListCountable() {
+		$pl = new ElggPriorityList();
+
+		$this->assertEqual(0, count($pl));
+
+		$pl->add('Test element 0');
+		$this->assertEqual(1, count($pl));
+
+		$pl->add('Test element 1');
+		$this->assertEqual(2, count($pl));
+
+		$pl->add('Test element 2');
+		$this->assertEqual(3, count($pl));
+	}
+
+	public function testElggPriorityListUserSort() {
+		$elements = array(
+			'A',
+			'B',
+			'C',
+			'D',
+			'E',
+		);
+
+		$elements_sorted_string = $elements;
+
+		shuffle($elements);
+		$pl = new ElggPriorityList($elements);
+
+		// will sort by priority
+		$test_elements = $pl->getElements();
+		$this->assertIdentical($elements, $test_elements);
+
+		function test_sort($elements) {
+			sort($elements, SORT_LOCALE_STRING);
+			return $elements;
+		}
+
+		// force a new sort using our function
+		$pl->sort('test_sort');
+		$test_elements = $pl->getElements();
+
+		$this->assertIdentical($elements_sorted_string, $test_elements);
+	}
+}
\ No newline at end of file
diff --git a/engine/tests/api/plugins.php b/engine/tests/api/plugins.php
index 00b0d4513..72092b688 100644
--- a/engine/tests/api/plugins.php
+++ b/engine/tests/api/plugins.php
@@ -215,18 +215,6 @@ class ElggCorePluginsAPITest extends ElggCoreUnitTest {
 		$this->assertEqual($this->package17->getManifest()->getDescription(), 'A 1.7-style manifest.');
 	}
 
-	public function testElggPluginManifestGetDescriptionTranslated() {
-		$en = array(
-			$this->package18->getManifest()->getDescription() => 'A translated 1.8 description!',
-			$this->package17->getManifest()->getDescription() => 'A translated 1.7 description!',
-		);
-
-		add_translation('en', $en);
-
-		$this->assertEqual($this->package18->getManifest()->getDescription(), 'A translated 1.8 description!');
-		$this->assertEqual($this->package17->getManifest()->getDescription(), 'A translated 1.7 description!');
-	}
-
 	public function testElggPluginManifestGetCategories() {
 		$categories = array(
 			'Admin', 'ServiceAPI'
diff --git a/engine/tests/regression/trac_bugs.php b/engine/tests/regression/trac_bugs.php
index 6f98c67bd..23d6d1dc6 100644
--- a/engine/tests/regression/trac_bugs.php
+++ b/engine/tests/regression/trac_bugs.php
@@ -112,4 +112,91 @@ class ElggCoreRegressionBugsTest extends ElggCoreUnitTest {
 		$this->assertEqual($params['xoffset'], $options['x1']);
 		$this->assertEqual($params['yoffset'], $options['y1']);
 	}
+
+	// #3722 Check canEdit() works for contains regardless of groups
+	function test_can_write_to_container() {
+		$user = new ElggUser();
+		$user->username = 'test_user_' . rand();
+		$user->name = 'test_user_name_' . rand();
+		$user->email = 'test@user.net';
+		$user->container_guid = 0;
+		$user->owner_guid = 0;
+		$user->save();
+
+		$object = new ElggObject();
+		$object->save();
+
+		$group = new ElggGroup();
+		$group->save();
+		
+		// disable access overrides because we're admin.
+		$ia = elgg_set_ignore_access(false);
+
+		$this->assertFalse(can_write_to_container($user->guid, $object->guid));
+		
+		global $elgg_test_user;
+		$elgg_test_user = $user;
+
+		// register hook to allow access
+		function can_write_to_container_test_hook($hook, $type, $value, $params) {
+			global $elgg_test_user;
+
+			if ($params['user']->getGUID() == $elgg_test_user->getGUID()) {
+				return true;
+			}
+		}
+		
+		register_plugin_hook('container_permissions_check', 'all', 'can_write_to_container_test_hook');
+		$this->assertTrue(can_write_to_container($user->guid, $object->guid));
+		unregister_plugin_hook('container_permissions_check', 'all', 'can_write_to_container_test_hook');
+
+		$this->assertFalse(can_write_to_container($user->guid, $group->guid));
+		$group->join($user);
+		$this->assertTrue(can_write_to_container($user->guid, $group->guid));
+
+		elgg_set_ignore_access($ia);
+
+		$user->delete();
+		$object->delete();
+		$group->delete();
+	}
+
+	function test_db_shutdown_links() {
+		global $DB_DELAYED_QUERIES, $test_results;
+		$DB_DELAYED_QUERIES = array();
+
+		function test_delayed_results($results) {
+			global $test_results;
+			$test_results = $results;
+		}
+
+		$q = 'SELECT 1 as test';
+
+		$links = array('read', 'write', get_db_link('read'), get_db_link('write'));
+
+		foreach ($links as $link) {
+			$DB_DELAYED_QUERIES = array();
+
+			$result = execute_delayed_query($q, $link, 'test_delayed_results');
+
+			$this->assertTrue($result, "Failed with link = $link");
+			$this->assertEqual(count($DB_DELAYED_QUERIES), 1);
+			$this->assertEqual($DB_DELAYED_QUERIES[0]['q'], $q);
+			$this->assertEqual($DB_DELAYED_QUERIES[0]['l'], $link);
+			$this->assertEqual($DB_DELAYED_QUERIES[0]['h'], 'test_delayed_results');
+
+			db_delayedexecution_shutdown_hook();
+
+			$num_rows = mysql_num_rows($test_results);
+			$this->assertEqual($num_rows, 1);
+			$row = mysql_fetch_assoc($test_results);
+			$this->assertEqual($row['test'], 1);
+		}
+
+		// test bad case
+		$DB_DELAYED_QUERIES = array();
+		$result = execute_delayed_query($q, 'not_a_link', 'test_delayed_results');
+		$this->assertFalse($result);
+		$this->assertEqual(array(), $DB_DELAYED_QUERIES);
+	}
 }
diff --git a/engine/tests/suite.php b/engine/tests/suite.php
index 8f2eb41a3..4203bc5d6 100644
--- a/engine/tests/suite.php
+++ b/engine/tests/suite.php
@@ -9,6 +9,8 @@
 
 require_once(dirname( __FILE__ ) . '/../start.php');
 
+admin_gatekeeper();
+
 $vendor_path = "$CONFIG->path/vendors/simpletest";
 $test_path = "$CONFIG->path/engine/tests";