composer/iTop
6
0
Fork 0
mirror of https://github.com/Combodo/iTop.git synced 2026-02-13 07:24:13 +01:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'refs/heads/feature/TestsGivenObjectInDB' into support/3.2

Browse Source
This commit is contained in:
Romain Quetiez
2024-06-28 17:04:35 +02:00
parent 0f213b08a6 984f676d6e
commit 8c87f5a384
11 changed files with 1137 additions and 1116 deletions
Download Patch File Download Diff File Expand all files Collapse all files

450
tests/php-unit-tests/src/BaseTestCase/ItopDataTestCase.php
View File

@@ -127,7 +127,7 @@ abstract class ItopDataTestCase extends ItopTestCase
}
if (static::CREATE_TEST_ORG)
{
$this->CreateTestOrganization();
$this->GivenTestOrganization();
}
$oConfig = MetaModel::GetConfig();
@@ -136,6 +136,8 @@ abstract class ItopDataTestCase extends ItopTestCase
// Config file is corrupted, let's fix it
$oConfig->SetEncryptionKey("6eb9d9afa3ee0fbcebe622a33bf57aaeafb7c37998fd24c403c2522c2d60117f");
}
// Align the PHP executable with the one used to launch the whole test process
$oConfig->Set('php_path', PHP_BINARY);
}
/**
@@ -907,59 +909,6 @@ abstract class ItopDataTestCase extends ItopTestCase
return $oObject;
}
/**
* Check or Display the CI list of a Ticket.
*
* @param Ticket $oTicket
* @param array $aWaitedCIList { iCIId => sImpactCode }
*
* @throws Exception
*/
protected function CheckFunctionalCIList($oTicket, $aWaitedCIList = array())
{
$this->debug("\nResulting functionalcis_list {$oTicket->Get('ref')} ({$oTicket->Get('functionalcis_list')->Count()}):");
foreach ($oTicket->Get('functionalcis_list') as $oLnk)
{
$this->debug($oLnk->Get('functionalci_name')." => ".$oLnk->Get('impact_code')."");
$iId = $oLnk->Get('functionalci_id');
if (!empty($aWaitedCIList))
{
$this->assertArrayHasKey($iId, $aWaitedCIList);
$this->assertEquals($aWaitedCIList[$iId], $oLnk->Get('impact_code'));
}
}
}
/**
* Check or Display the Contact list of a DBObject (having a contacts_list).
* Can also control other attributes of the link.
*
* @param Ticket $oTicket
* @param array $aWaitedContactList { iContactId => array(attcode => value) }
*
* @throws Exception
*/
protected function CheckContactList($oTicket, $aWaitedContactList = array())
{
$this->debug("\nResulting contacts_list {$oTicket->Get('ref')} ({$oTicket->Get('contacts_list')->Count()}):");
foreach ($oTicket->Get('contacts_list') as $oLnk)
{
$this->debug($oLnk->Get('contact_id_friendlyname')." => ".$oLnk->Get('role_code'));
$iId = $oLnk->Get('contact_id');
if (!empty($aWaitedContactList))
{
$this->assertArrayHasKey($iId, $aWaitedContactList);
foreach ($aWaitedContactList[$iId] as $sAttCode => $oValue)
{
if (MetaModel::IsValidAttCode(get_class($oTicket), $sAttCode))
{
$this->assertEquals($oValue, $oLnk->Get($sAttCode));
}
}
}
}
}
protected function CreateTestOrganization()
{
// Create a specific organization for the tests
@@ -1046,4 +995,397 @@ abstract class ItopDataTestCase extends ItopTestCase
return $ret;
}
protected function DBInsertSingleTable($sTableClass, $aValues, $iKey = 0)
{
$sTable = MetaModel::DBGetTable($sTableClass);
// Abstract classes or classes having no specific attribute do not have an associated table
if ($sTable == '') {
return false;
}
// fields in first array, values in the second
$aFieldsToWrite = array();
$aValuesToWrite = array();
if (!empty($iKey) && ($iKey >= 0)) {
// Add it to the list of fields to write
$aFieldsToWrite[] = '`'.MetaModel::DBGetKey($sTableClass).'`';
$aValuesToWrite[] = CMDBSource::Quote($iKey);
}
$aHierarchicalKeys = array();
foreach (MetaModel::ListAttributeDefs($sTableClass) as $sAttCode => $oAttDef) {
// Skip this attribute if not defined in this table
if ((!MetaModel::IsAttributeOrigin($sTableClass, $sAttCode) && !$oAttDef->CopyOnAllTables())
|| $oAttDef->IsExternalField()) {
continue;
}
if ($oAttDef->IsWritable() && !$oAttDef->IsNullAllowed() && !array_key_exists($sAttCode, $aValues) && $oAttDef->IsNull($oAttDef->GetDefaultValue())) {
throw new Exception("GivenObjectInDB('$sTableClass'), mandatory attribute '$sAttCode' is missing");
}
$currentValue = array_key_exists($sAttCode, $aValues) ? $aValues[$sAttCode] : $oAttDef->GetDefaultValue();
$aAttColumns = $oAttDef->GetSQLValues($currentValue);
foreach ($aAttColumns as $sColumn => $sValue) {
$aFieldsToWrite[] = "`$sColumn`";
$aValuesToWrite[] = CMDBSource::Quote($sValue);
}
if ($oAttDef->IsHierarchicalKey()) {
$aHierarchicalKeys[$sAttCode] = $oAttDef;
}
}
if (count($aValuesToWrite) == 0) {
return false;
}
if (count($aHierarchicalKeys) > 0) {
foreach ($aHierarchicalKeys as $sAttCode => $oAttDef) {
$currentValue = isset($aValues[$sAttCode]) ? $aValues[$sAttCode] : $oAttDef->GetDefaultValue();
$aHKValues = MetaModel::HKInsertChildUnder($currentValue, $oAttDef, $sTable);
$aFieldsToWrite[] = '`'.$oAttDef->GetSQLRight().'`';
$aValuesToWrite[] = $aHKValues[$oAttDef->GetSQLRight()];
$aFieldsToWrite[] = '`'.$oAttDef->GetSQLLeft().'`';
$aValuesToWrite[] = $aHKValues[$oAttDef->GetSQLLeft()];
}
}
$sInsertSQL = "INSERT INTO `$sTable` (".join(',', $aFieldsToWrite).') VALUES ('.join(', ', $aValuesToWrite).')';
$iNewKey = CMDBSource::InsertInto($sInsertSQL);
// Note that it is possible to have a key defined here, and the autoincrement expected, this is acceptable in a non root class
if (empty($iKey)) {
// Take the autonumber
$iKey = "$iNewKey";
}
return $iKey;
}
/**
* @param string $sClass
* @param array $aParams
*
* @return DBObject
* @throws Exception
*/
protected function GivenObject(string $sClass, array $aParams): DBObject
{
$oMyObj = MetaModel::NewObject($sClass);
foreach ($aParams as $sAttCode => $oValue)
{
$oMyObj->Set($sAttCode, $oValue);
}
return $oMyObj;
}
/**
* @param string $sClass
* @param array $aValues
*
* @return DBObject
* @throws Exception
*/
protected function GivenObjectInDB($sClass, $aValues)
{
// Check and complete the values
foreach ($aValues as $sAttCode => $oValue) {
if (MetaModel::IsValidAttCode($sClass, $sAttCode) === false) {
throw new \Exception("GivenObjectInDB('$sClass'), invalid attribute code '$sAttCode'");
}
}
$sOrgIdAttCode = $sClass::MapContextParam('org_id');
if ($sOrgIdAttCode !== null) {
if (!isset($aValues[$sOrgIdAttCode])) {
$aValues[$sOrgIdAttCode] = $this->getTestOrgId();
}
}
$aValues['finalclass'] = $sClass;
$sRootClass = MetaModel::GetRootClass($sClass);
// First query built upon on the root class, because the ID must be created first
$iKey = $this->DBInsertSingleTable($sRootClass, $aValues);
// Then do the leaf class, if different from the root class
if ($sClass != $sRootClass) {
$this->DBInsertSingleTable($sClass, $aValues, $iKey);
}
// Then do the other classes
foreach (MetaModel::EnumParentClasses($sClass) as $sParentClass) {
if ($sParentClass == $sRootClass) {
continue;
}
$this->DBInsertSingleTable($sParentClass, $aValues, $iKey);
}
// Then cope with the links
foreach (MetaModel::ListAttributeDefs($sClass) as $sAttCode => $oAttDef) {
if (!$oAttDef->IsLinkSet()) {
continue;
}
if (!isset($aValues[$sAttCode])) {
continue;
}
$sLinkClass = $oAttDef->GetLinkedClass();
$sExtKeyToMe = $oAttDef->GetExtKeyToMe();
if ($aValues[$sAttCode] instanceof \DBObjectSet) {
$oSet = $aValues[$sAttCode];
$oSet->Rewind();
while ($oLnk = $oSet->Fetch()) {
$aLnkValues = [];
foreach (MetaModel::ListAttributeDefs($sLinkClass) as $sLnkAttCode => $oLnkAttDef) {
if ($sLnkAttCode == $sExtKeyToMe) {
$aLnkValues[$sLnkAttCode] = $iKey;
} else {
$aLnkValues[$sLnkAttCode] = $oLnk->Get($sLnkAttCode);
}
}
$this->GivenObjectInDB($sLinkClass, $aLnkValues);
}
} elseif (is_array($aValues[$sAttCode])) {
foreach ($aValues[$sAttCode] as $sLnkValues) {
$aLnkKeyValuePairs = explode(';', $sLnkValues);
$aLnkValues = [];
foreach ($aLnkKeyValuePairs as $sLnkKeyValue) {
$iSep = strpos($sLnkKeyValue, ':');
if ($iSep === false) {
throw new \Exception("GivenObjectInDB($sClass), unexpected value format for $sAttCode, missing ':' in '$sLnkKeyValue'");
}
$sLnkAttCode = substr($sLnkKeyValue, 0, $iSep);
$sLnkValue = substr($sLnkKeyValue, $iSep + 1);
$aLnkValues[$sLnkAttCode] = $sLnkValue;
}
foreach (MetaModel::ListAttributeDefs($sLinkClass) as $sLnkAttCode => $oLnkAttDef) {
if ($sLnkAttCode == $sExtKeyToMe) {
$aLnkValues[$sLnkAttCode] = $iKey;
}
}
$this->GivenObjectInDB($sLinkClass, $aLnkValues);
}
} else {
throw new \Exception("createObject($sClass), unexpected value type for $sAttCode");
}
}
return $iKey;
}
/**
* Create an Organization in database
*
* @param string $sName
*
* @throws Exception
*/
protected function GivenOrganization($sName): string
{
$sId = $this->GivenObjectInDB('Organization', [
'name' => $sName,
]);
$this->debug("Created Organization $sName");
return $sId;
}
protected function GivenTestOrganization(): void
{
// Create a specific organization for the tests
$this->iTestOrgId = $this->GivenOrganization('UnitTestOrganization');
}
/**
* Create a Farm in database
*
* @param int $iNum
* @param string $sRedundancy
*
* @throws Exception
*/
protected function GivenFarmInDB($iNum, $sRedundancy = '1'): string
{
$sName = 'Farm_'.$iNum;
$sId = $this->GivenObjectInDB('Farm', [
'name' => $sName,
'org_id' => $this->getTestOrgId(),
'redundancy' => $sRedundancy,
]);
$this->debug("Created $sName ($sId) redundancy $sRedundancy");
return $sId;
}
protected function GivenServerInDB($iNum, $iRackUnit = null): string
{
$sName = 'Server_'.$iNum;
$sId = $this->GivenObjectInDB('Server', [
'name' => $sName,
'org_id' => $this->getTestOrgId(),
'nb_u' => $iRackUnit,
]);
$this->debug("Created $sName ($sId)");
return $sId;
}
protected function GivenHypervisorInDB($iNum, $sServerId, $sFarmId = 0): string
{
$sName = 'Hypervisor_'.$iNum;
$sId = $this->GivenObjectInDB('Hypervisor', [
'name' => $sName,
'org_id' => $this->getTestOrgId(),
'server_id' => $sServerId,
'farm_id' => $sFarmId,
]);
if ($sFarmId === 0) {
$this->debug("Created $sName ($sId) on server $sServerId");
} else {
$this->debug("Created $sName ($sId) on server $sServerId part of farm $sFarmId");
}
return $sId;
}
protected function GivenPersonInDB($iNum, $iOrgId = 0): string
{
$sName = 'Person_'.$iNum;
$sId = $this->GivenObjectInDB('Person', [
'name' => $sName,
'first_name' => 'Test',
'org_id' => ($iOrgId == 0 ? $this->getTestOrgId() : $iOrgId),
]);
$this->debug("Created $sName ($sId)");
return $sId;
}
protected function GivenLnkContactToFunctionalCIInDB($sContactId, $sCIId): string
{
$sClass = 'lnkContactToFunctionalCI';
$sId = $this->GivenObjectInDB($sClass, [
'contact_id' => $sContactId,
'functionalci_id' => $sCIId,
]);
$this->debug("Created $sClass::$sId linking contact $sContactId and CI $sCIId");
return $sId;
}
protected function GivenVirtualMachineInDB($iNum, $sVirtualHostId): string
{
$sName = 'VirtualMachine_'.$iNum;
$sId = $this->GivenObjectInDB('VirtualMachine', [
'name' => $sName,
'org_id' => $this->getTestOrgId(),
'virtualhost_id' => $sVirtualHostId,
]);
$this->debug("Created $sName ($sId) on virtual host $sVirtualHostId");
return $sId;
}
protected function GivenTicketObject($iNum): \UserRequest
{
$sTitle = 'TICKET_'.$iNum;
$sRef = 'Ticket_'.$iNum;
/** @var \UserRequest $oTicket */
$oTicket = $this->GivenObject('UserRequest', [
'ref' => $sRef,
'title' => $sTitle,
'description' => 'Created for unit tests.',
'org_id' => $this->getTestOrgId(),
]);
$this->debug("Created $sTitle ($sRef)");
return $oTicket;
}
protected function AddLnkFunctionalCIToTicketObject($sCIId, $oTicket, $sImpactCode = 'manual'): array
{
$oNewLink = $this->GivenObject('lnkFunctionalCIToTicket', [
'functionalci_id' => $sCIId,
'impact_code' => $sImpactCode,
]);
$oCIs = $oTicket->Get('functionalcis_list');
$oCIs->AddItem($oNewLink);
$oTicket->Set('functionalcis_list', $oCIs);
$this->debug("Added CI $sCIId to {$oTicket->Get('ref')} with {$sImpactCode}");
return array($sCIId => $sImpactCode);
}
protected function RemoveLnkFunctionalCIToTicketObject($sCIId, $oTicket)
{
$oCIs = $oTicket->Get('functionalcis_list');
foreach ($oCIs as $oLnk)
{
if ($oLnk->Get('functionalci_id') == $sCIId)
{
$sImpactCode = $oLnk->Get('impact_code');
$oCIs->RemoveItem($oLnk->GetKey());
$oTicket->Set('functionalcis_list', $oCIs);
$this->debug("Removed CI $sCIId from {$oTicket->Get('ref')} ({$sImpactCode})");
return;
}
}
$this->debug("ERROR: CI $sCIId not attached to {$oTicket->Get('ref')}");
$this->assertTrue(false);
}
protected function AddLnkContactToTicketObject($sContactId, $oTicket, $sRoleCode, $aParams = array()): array
{
$aParams['contact_id'] = $sContactId;
$aParams['role_code'] = $sRoleCode;
$oNewLink = $this->GivenObject('lnkContactToTicket', $aParams);
$oCIs = $oTicket->Get('contacts_list');
$oCIs->AddItem($oNewLink);
$oTicket->Set('contacts_list', $oCIs);
$this->debug("Added contact $sContactId to {$oTicket->Get('ref')} with {$sRoleCode}");
return array($sContactId => $sRoleCode);
}
protected function RemoveLnkContactToTicketObject($sContactId, $oTicket)
{
$oContacts = $oTicket->Get('contacts_list');
foreach ($oContacts as $oLnk)
{
if ($oLnk->Get('contact_id') == $sContactId)
{
$sRoleCode = $oLnk->Get('role_code');
$oContacts->RemoveItem($oLnk->GetKey());
$oTicket->Set('contacts_list', $oContacts);
$this->debug("Removed contact $sContactId from {$oTicket->Get('ref')} ({$sRoleCode})");
return;
}
}
}
protected function GivenUserRestrictedToAnOrganizationInDB(int $iOrganization, string $sProfileId): string
{
$sLogin = 'demo_test_'.uniqid(__CLASS__, true);
$iUser = $this->GivenObjectInDB('UserLocal', [
'login' => $sLogin,
'password' => 'tagada-Secret,007',
'language' => 'EN US',
'profile_list' => [
'profileid:'.$sProfileId
],
'allowed_org_list' => [
'allowed_org_id:'.$iOrganization
],
]);
return $sLogin;
}
}

13
tests/php-unit-tests/src/BaseTestCase/ItopTestCase.php
View File

@@ -57,6 +57,19 @@ abstract class ItopTestCase extends TestCase
// setUp might be called multiple times, so protecting the define() call !
define(ITOP_PHPUNIT_RUNNING_CONSTANT_NAME, true);
}
// This is mostly for interactive usage, to warn the developer that the tests will be slow and point her to the php.ini file
static $bCheckedXDebug = false;
if (!$bCheckedXDebug) {
$bCheckedXDebug = true;
if (extension_loaded('xdebug') && ini_get('xdebug.mode') != '') {
echo "Xdebug is enabled (xdebug.mode='".ini_get('xdebug.mode')."'), this will slow down the tests.\n";
$sIniFile = php_ini_loaded_file();
if ($sIniFile) {
echo "This can be tuned in $sIniFile\n";
}
}
}
}
/**

9
tests/php-unit-tests/unitary-tests/application/LoginTest.php
View File

@@ -40,15 +40,6 @@ class LoginTest extends ItopDataTestCase {
parent::tearDown();
}
public function testLoginInfiniteLoopFix() {
$iTimeStamp = microtime(true);
$sOutput = $this->CallItopUrlByCurl(sprintf("/pages/UI.php?login_mode=%s", $this->sLoginMode));
$iElapsedInMs = (microtime(true) - $iTimeStamp) * 1000;
$sMaxExecutionInS = 1;
$this->assertTrue($iElapsedInMs < $sMaxExecutionInS * 1000, "iTop answered in $iElapsedInMs ms. it should do it in less than $sMaxExecutionInS seconds (max_execution_time)");
$this->assertFalse(strpos($sOutput, "Fatal error"), "no fatal error due to max execution time should be returned" . $sOutput);
}
protected function CallItopUrlByCurl($sUri, ?array $aPostFields=[]){
$ch = curl_init();

26
tests/php-unit-tests/unitary-tests/core/DBObjectTest.php
View File

@@ -522,7 +522,7 @@ class DBObjectTest extends ItopDataTestCase
$oPersonOfMyCompanyOrg = MetaModel::GetObjectByName(Person::class, 'My first name My last name');
$sConfigurationManagerProfileId = 3; // Access to Person objects
$oUserWithAllowedOrgs = $this->CreateDemoOrgUser($oDemoOrg, $sConfigurationManagerProfileId);
$sLogin = $this->GivenUserRestrictedToAnOrganizationInDB($oDemoOrg->GetKey(), $sConfigurationManagerProfileId);
$oAdminUser = MetaModel::GetObjectByName(User::class, 'admin', false);
if (is_null($oAdminUser)) {
@@ -533,7 +533,7 @@ class DBObjectTest extends ItopDataTestCase
$oPersonObject = $this->CreatePerson(0, $oMyCompanyOrg->GetKey());
//--- Now we can do some tests !
UserRights::Login($oUserWithAllowedOrgs->Get('login'));
UserRights::Login($sLogin);
$this->ResetMetaModelQueyCacheGetObject();
try {
@@ -594,10 +594,10 @@ class DBObjectTest extends ItopDataTestCase
$oPersonOnDemoOrg = MetaModel::GetObjectByName(Person::class, 'Claude Monet');
$sConfigManagerProfileId = 3; // access to Team and Contact objects
$oUserWithAllowedOrgs = $this->CreateDemoOrgUser($oDemoOrg, $sConfigManagerProfileId);
$sLogin = $this->GivenUserRestrictedToAnOrganizationInDB($oDemoOrg->GetKey(), $sConfigManagerProfileId);
//--- Now we can do some tests !
UserRights::Login($oUserWithAllowedOrgs->Get('login'));
UserRights::Login($sLogin);
$this->ResetMetaModelQueyCacheGetObject();
$oTeam = MetaModel::NewObject(Team::class, [
@@ -699,10 +699,10 @@ class DBObjectTest extends ItopDataTestCase
$oPersonOnDemoOrg = MetaModel::GetObjectByName(Person::class, 'Claude Monet');
$sConfigManagerProfileId = 3; // access to Team and Contact objects
$oUserWithAllowedOrgs = $this->CreateDemoOrgUser($oDemoOrg, $sConfigManagerProfileId);
$sLogin = $this->GivenUserRestrictedToAnOrganizationInDB($oDemoOrg->GetKey(), $sConfigManagerProfileId);
//--- Now we can do some tests !
UserRights::Login($oUserWithAllowedOrgs->Get('login'));
UserRights::Login($sLogin);
$this->ResetMetaModelQueyCacheGetObject();
$oAttachment = MetaModel::NewObject(Attachment::class, [
@@ -729,20 +729,6 @@ class DBObjectTest extends ItopDataTestCase
}
}
private function CreateDemoOrgUser(Organization $oDemoOrg, string $sProfileId): User
{
utils::GetConfig()->SetModuleSetting('authent-local', 'password_validation.pattern', '');
$oUserWithAllowedOrgs = $this->CreateContactlessUser('demo_test_' . uniqid(__CLASS__, true), $sProfileId);
/** @var \URP_UserOrg $oUserOrg */
$oUserOrg = \MetaModel::NewObject('URP_UserOrg', ['allowed_org_id' => $oDemoOrg->GetKey(),]);
$oAllowedOrgList = $oUserWithAllowedOrgs->Get('allowed_org_list');
$oAllowedOrgList->AddItem($oUserOrg);
$oUserWithAllowedOrgs->Set('allowed_org_list', $oAllowedOrgList);
$oUserWithAllowedOrgs->DBWrite();
return $oUserWithAllowedOrgs;
}
/**
* Test attribute integer incrementation.
*

8
tests/php-unit-tests/unitary-tests/core/DBSearchIntersectTest.php
View File

@@ -186,10 +186,10 @@ class DBSearchIntersectTest extends ItopTestCase
'right' => "SELECT Person WHERE org_id = 3",
'result' => "SELECT `L`, `P` FROM Person AS `P` JOIN Location AS `L` ON `P`.location_id = `L`.id WHERE (`P`.`org_id` = 3)");
$aTests['Multiple selected classes inverted 2'] = array(
'left' => "SELECT `L`, `P`, `D` FROM Person AS `P` JOIN Location AS `L` ON `P`.location_id = `L`.id JOIN Server AS D ON D.location_id = L.id JOIN Person AS P2 ON P.manager_id = P2.id WHERE (`L`.`org_id` = 3)",
'right' => "SELECT Person WHERE org_id = 3",
'result' => "SELECT `L`, `P`, `D` FROM Person AS `P` JOIN Location AS `L` ON `P`.location_id = `L`.id JOIN Server AS `D` ON `D`.location_id = `L`.id JOIN Person AS `P2` ON `P`.manager_id = `P2`.id WHERE ((`L`.`org_id` = 3) AND (`P`.`org_id` = 3))");
// $aTests['Multiple selected classes inverted 2'] = array(
// 'left' => "SELECT `L`, `P`, `D` FROM Person AS `P` JOIN Location AS `L` ON `P`.location_id = `L`.id JOIN Server AS D ON D.location_id = L.id JOIN Person AS P2 ON P.manager_id = P2.id WHERE (`L`.`org_id` = 3)",
// 'right' => "SELECT Person WHERE org_id = 3",
// 'result' => "SELECT `L`, `P`, `D` FROM Person AS `P` JOIN Location AS `L` ON `P`.location_id = `L`.id JOIN Server AS `D` ON `D`.location_id = `L`.id JOIN Person AS `P2` ON `P`.manager_id = `P2`.id WHERE ((`L`.`org_id` = 3) AND (`P`.`org_id` = 3))");
$aTests['Same class'] = array(
'left' => "SELECT Contact WHERE name = 'Christie'",

102
tests/php-unit-tests/unitary-tests/core/RelationGraphTest.php
View File

@@ -1,102 +0,0 @@
<?php
namespace Combodo\iTop\Test\UnitTest\Core;
use Combodo\iTop\Test\UnitTest\ItopDataTestCase;
use MetaModel;
use RelationGraph;
/**
* Class RelationGraphTest
*
* @package Combodo\iTop\Test\UnitTest\Core
*/
class RelationGraphTest extends ItopDataTestCase
{
const USE_TRANSACTION = false;
protected function setUp(): void
{
parent::setUp();
}
public function ComputeRelatedObjectsProvider()
{
return array(
'Server::1' => array('Server',1),
'Server::2' => array('Server',2),
);
}
/**
* @dataProvider ComputeRelatedObjectsProvider
*
* @param $sClass
* @param $iKey
*
* @return void
* @throws \ArchivedObjectException
* @throws \CoreException
*/
public function testComputeRelatedObjectsDown($sClass, $iKey)
{
$oServer = MetaModel::GetObject($sClass, $iKey);
MetaModel::GetConfig()->Set('relations.complete_analysis', true);
$oGraphTrue = new RelationGraph();
$oGraphTrue->AddSourceObject($oServer);
$oGraphTrue->ComputeRelatedObjectsDown('impacts', 10, true);
MetaModel::GetConfig()->Set('relations.complete_analysis', false);
$oGraphFalse = new RelationGraph();
$oGraphFalse->AddSourceObject($oServer);
$oGraphFalse->ComputeRelatedObjectsDown('impacts', 10, true);
$aNodeFalse = $oGraphFalse->_GetNodes();
$aNodeTrue = $oGraphFalse->_GetNodes();
//test if the 2 graph contains the same objects
$this->assertEquals(count($aNodeFalse), count($aNodeFalse),'With the admin user, the impact analysis down must have the same number of impacted items whatever the value of the "relations.complete_analysis" parameter.');
foreach ($aNodeTrue as $sKey =>$oNodeTrue){
$this->assertArrayHasKey($sKey, $aNodeFalse,'With the admin user, the impact analysis down must have the same results whatever the value of the "relations.complete_analysis" parameter.');
}
}
/**
* @dataProvider ComputeRelatedObjectsProvider
*
* @param $sClass
* @param $iKey
*
* @return void
* @throws \ArchivedObjectException
* @throws \CoreException
*/
public function testComputeRelatedObjectsUp($sClass, $iKey)
{
$oServer = MetaModel::GetObject($sClass, $iKey);
MetaModel::GetConfig()->Set('relations.complete_analysis', true);
$oGraphTrue = new RelationGraph();
$oGraphTrue->AddSourceObject($oServer);
$oGraphTrue->ComputeRelatedObjectsUp('impacts', 10, true);
MetaModel::GetConfig()->Set('relations.complete_analysis', false);
$oGraphFalse = new RelationGraph();
$oGraphFalse->AddSourceObject($oServer);
$oGraphFalse->ComputeRelatedObjectsUp('impacts', 10, true);
$aNodeFalse = $oGraphFalse->_GetNodes();
$aNodeTrue = $oGraphFalse->_GetNodes();
//test if the 2 graph contains the same objects
$this->assertEquals(count($aNodeFalse), count($aNodeFalse),'With the admin user, the impact analysis up must have the same number of impacted items whatever the value of the "relations.complete_analysis" parameter.');
foreach ($aNodeTrue as $sKey =>$oNodeTrue){
$this->assertArrayHasKey($sKey, $aNodeFalse,'With the admin user, the impact analysis up must have the same results whatever the value of the "relations.complete_analysis" parameter.');
}
}
}

4
tests/php-unit-tests/unitary-tests/datamodels/2.x/itop-config/BulkChangeExtKeyTest.php
View File

@@ -111,7 +111,7 @@ class BulkChangeExtKeyTest extends ItopDataTestCase {
]
);
list($oOrg2, $oUser) = $this->createAnotherUserInAnotherOrg();
[$oOrg2, $oUser] = $this->createAnotherUserInAnotherOrg();
\UserRights::Login($oUser->Get('login'));
$this->performBulkChangeTest(
@@ -127,7 +127,7 @@ class BulkChangeExtKeyTest extends ItopDataTestCase {
*/
public function testExternalFieldIssueImportFail_SomeObjectVisibleByCurrentUser($bIsRackReconKey){
$this->deleteAllRacks();
list($oOrg2, $oUser) = $this->createAnotherUserInAnotherOrg();
[$oOrg2, $oUser] = $this->createAnotherUserInAnotherOrg();
$this->createRackObjects(
[
$this->getTestOrgId() => ['RackTest1', 'RackTest2'],

530
tests/php-unit-tests/unitary-tests/datamodels/2.x/itop-tickets/UpdateImpactedItemsTest.php Normal file
View File

@@ -0,0 +1,530 @@
<?php
// Copyright (c) 2010-2024 Combodo SAS
//
// This file is part of iTop.
//
// iTop is free software; you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// iTop is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with iTop. If not, see <http://www.gnu.org/licenses/>
//
namespace Combodo\iTop\Test\UnitTest\Module\iTopTickets;
use Combodo\iTop\Test\UnitTest\ItopDataTestCase;
use Exception;
use MetaModel;
use Organization;
use UserRights;
/**
* @group itopVirtualizationMgmt
* @group itopConfigMgmt
* @group itopTickets
*/
class UpdateImpactedItemsTest extends ItopDataTestCase
{
const CREATE_TEST_ORG = true;
/**
* @var Object Names to Ids
*/
private array $aCIs = [];
protected function setUp(): void
{
parent::setUp();
$this->aCIs = [];
}
protected function tearDown(): void
{
parent::tearDown();
UserRights::Logoff();
$this->ResetMetaModelQueyCacheGetObject();
}
public function testImpactShouldBePropagatedToDirectDescendants()
{
/**
* Server1 +----> Hypervisor1
* +====> Person1
*/
$this->GivenCITreeInDB(<<<EOF
Hypervisor_1 -> Server_1
Server_1 <-> Person_1
EOF);
$oTicket = $this->GivenTicketWithCIsOrPersons([
'Server_1' => 'manual'
]);
$oTicket->UpdateImpactedItems(); // impact analysis
$this->assertCIsOrPersonsListEquals($oTicket, [
'Server_1' => 'manual',
'Hypervisor_1' => 'computed',
'Test Person_1' => 'computed'
]);
}
public function testImpactShouldBePropagatedInOneWayOnly()
{
/**
* Server1 +----> Hypervisor1
* Server2 +----> Hypervisor1
*/
$this->GivenCITreeInDB(<<<EOF
Hypervisor_1 -> Server_1
Hypervisor_1 -> Server_2
EOF);
$oTicket = $this->GivenTicketWithCIsOrPersons([
'Server_1' => 'manual'
]);
$oTicket->UpdateImpactedItems(); // impact analysis
$this->assertCIsOrPersonsListEquals($oTicket, [
'Server_1' => 'manual',
'Hypervisor_1' => 'computed'
]);
}
public function testImpactShouldBePropagatedRecursively()
{
/**
* Server1 +----> Hypervisor1 +----> Farm +====> Person1
*/
$this->GivenCITreeInDB(<<<EOF
Hypervisor_1 -> Server_1, Farm_1
Farm_1 <-> Person_1
EOF);
$oTicket = $this->GivenTicketWithCIsOrPersons([
'Server_1' => 'manual'
]);
$oTicket->UpdateImpactedItems(); // impact analysis
$this->assertCIsOrPersonsListEquals($oTicket, [
'Server_1' => 'manual',
'Hypervisor_1' => 'computed',
'Farm_1' => 'computed',
'Test Person_1' => 'computed'
]);
}
public function testImpactShouldNotBeFurtherPropagatedWhenCINotAllowed()
{
/**
* Server1 +----> Hypervisor1 +----> Farm
*/
$this->GivenCITreeInDB(<<<EOF
Hypervisor_1 -> Server_1, Farm_1
EOF);
$this->GivenCINotAllowedToCurrentUser('Hypervisor_1');
$oTicket = $this->GivenTicketWithCIsOrPersons([
'Server_1' => 'manual'
]);
MetaModel::GetConfig()->Set('relations.complete_analysis', false);
$oTicket->UpdateImpactedItems(); // impact analysis
$this->assertCIsOrPersonsListEquals($oTicket, [
'Server_1' => 'manual',
]);
}
public function testImpactShouldBeFurtherPropagatedAboveCINotAllowedWhenCompleteAnalysisRequested()
{
/**
* Server1 +----> Hypervisor1 +----> Farm
*/
$this->GivenCITreeInDB(<<<EOF
Hypervisor_1 -> Server_1, Farm_1
EOF);
$this->GivenCINotAllowedToCurrentUser('Hypervisor_1');
$oTicket = $this->GivenTicketWithCIsOrPersons([
'Server_1' => 'manual'
]);
MetaModel::GetConfig()->Set('relations.complete_analysis', true);
$oTicket->UpdateImpactedItems(); // impact analysis
$this->assertCIsOrPersonsListEquals($oTicket, [
'Server_1' => 'manual',
'Farm_1' => 'computed',
]);
}
public function testImpactShouldBePropagatedToAllDescendantsOfSameClass()
{
/**
* Server1 +----> Hypervisor1
* +----> Hypervisor2
*/
$this->GivenCITreeInDB(<<<DOT
Hypervisor_1 -> Server_1
Hypervisor_2 -> Server_1
DOT);
$oTicket = $this->GivenTicketWithCIsOrPersons([
'Server_1' => 'manual',
]);
$oTicket->UpdateImpactedItems(); // impact analysis
$this->assertCIsOrPersonsListEquals($oTicket, [
'Server_1' => 'manual',
'Hypervisor_1' => 'computed',
'Hypervisor_2' => 'computed',
]);
}
public function testNodesImpactedByTwoWaysShouldBeFoundOnce()
{
/**
* +------------------+
* Hypervisor1 |
* +====> Person1 +----> Farm1
* Hypervisor2 |
* +------------------+
*/
$this->GivenCITreeInDB(<<<DOT
Hypervisor_1 -> Farm_1
Hypervisor_2 -> Farm_1
Hypervisor_1 <-> Person_1
Hypervisor_2 <-> Person_1
DOT);
$oTicket = $this->GivenTicketWithCIsOrPersons([
'Hypervisor_1' => 'manual',
'Hypervisor_2' => 'manual',
]);
$oTicket->UpdateImpactedItems(); // impact analysis
$this->assertCIsOrPersonsListEquals($oTicket, [
'Hypervisor_1' => 'manual',
'Hypervisor_2' => 'manual',
'Farm_1' => 'computed',
'Test Person_1' => 'computed'
]);
}
public function testPreviouslyComputedNodesShouldBeIgnored()
{
/**
* Server1 +----> Hypervisor1 +----> Person1
*
* Server2 +----> Person2
*/
$this->GivenCITreeInDB(<<<EOF
Hypervisor_1 -> Server_1
Hypervisor_1 <-> Person_1
Server_2 <-> Person_2
EOF);
$oTicket = $this->GivenTicketWithCIsOrPersons([
'Server_1' => 'manual',
'Server_2' => 'computed',
'Person_2' => 'computed'
]);
$oTicket->UpdateImpactedItems(); // impact analysis
$this->assertCIsOrPersonsListEquals($oTicket, [
'Server_1' => 'manual',
'Hypervisor_1' => 'computed',
'Test Person_1' => 'computed'
]);
}
public function testPreviouslyComputedNodesShouldBeIgnoredCausingTheListToCollapse()
{
/**
* Server1 +----> Hypervisor1 +----> Person1
*/
$this->GivenCITreeInDB(<<<EOF
Hypervisor_1 -> Server_1
Hypervisor_1 <-> Person_1
EOF);
$oTicket = $this->GivenTicketWithCIsOrPersons([
'Hypervisor_1' => 'computed',
'Person_1' => 'computed'
]);
$oTicket->UpdateImpactedItems(); // impact analysis
$this->assertCIsOrPersonsListEquals($oTicket, []);
}
public function testNoImpactWhenNoCI()
{
$oTicket = $this->GivenTicketWithCIsOrPersons([]);
$oTicket->UpdateImpactedItems(); // impact analysis
$this->assertCIsOrPersonsListEquals($oTicket, []);
}
public function testRedundancyShouldPreventPropagationOfImpact()
{
/**
* Hypervisor1
* +----> Farm1
* Hypervisor2
*/
$this->GivenCITreeInDB(<<<DOT
Hypervisor_1 -> Farm_1
Hypervisor_2 -> Farm_1
DOT);
$oTicket = $this->GivenTicketWithCIsOrPersons([
'Hypervisor_1' => 'manual'
]);
$oTicket->UpdateImpactedItems(); // impact analysis
$this->assertCIsOrPersonsListEquals($oTicket, [
'Hypervisor_1' => 'manual'
]);
}
public function testRedundancyShouldNotPreventPropagationWhenEverySourceIsImpacted()
{
/**
* Hypervisor1
* +----> Farm1
* Hypervisor2
*/
$this->GivenCITreeInDB(<<<DOT
Hypervisor_1 -> Farm_1
Hypervisor_2 -> Farm_1
DOT);
$oTicket = $this->GivenTicketWithCIsOrPersons([
'Hypervisor_1' => 'manual',
'Hypervisor_2' => 'manual'
]);
$oTicket->UpdateImpactedItems(); // impact analysis
$this->assertCIsOrPersonsListEquals($oTicket, [
'Hypervisor_1' => 'manual',
'Hypervisor_2' => 'manual',
'Farm_1' => 'computed'
]);
}
public function testCIsMarkedAsNotImpactedShouldRemainMarkedAndShouldNotPropagateTheImpact()
{
/**
* Server1 +----> Hypervisor1 +----> Farm1
* +====> Person1
*/
$this->GivenCITreeInDB(<<<DOT
Hypervisor_1 -> Server_1, Farm_1
Hypervisor_1 <-> Person_1
DOT);
$oTicket = $this->GivenTicketWithCIsOrPersons([
'Server_1' => 'manual',
'Hypervisor_1' => 'not_impacted',
'Person_1' => 'do_not_notify'
]);
$oTicket->UpdateImpactedItems(); // impact analysis
$this->assertCIsOrPersonsListEquals($oTicket, [
'Server_1' => 'manual',
'Hypervisor_1' => 'not_impacted',
'Test Person_1' => 'do_not_notify'
]);
}
public function testCIsMarkedAsNotImpactedShouldRemainMarkedWhenNotInImpactGraph()
{
/**
* Hypervisor1 +====> Person1
*/
$this->GivenCITreeInDB(<<<DOT
Hypervisor_1 <-> Person_1
DOT);
$oTicket = $this->GivenTicketWithCIsOrPersons([
'Hypervisor_1' => 'not_impacted',
'Person_1' => 'do_not_notify'
]);
$oTicket->UpdateImpactedItems(); // impact analysis
$this->assertCIsOrPersonsListEquals($oTicket, [
'Hypervisor_1' => 'not_impacted',
'Test Person_1' => 'do_not_notify'
]);
}
public function testRedundancyShouldBeEvaluatedOnOtherTicketsToo()
{
/**
* Hypervisor1
* +----> Farm1
* Hypervisor2
*/
$this->GivenCITreeInDB(<<<DOT
Hypervisor_1 -> Farm_1
Hypervisor_2 -> Farm_1
DOT);
$oTicket1 = $this->GivenTicketWithCIsOrPersons([
'Hypervisor_1' => 'manual',
]);
$oTicket1->DBWrite(); // impact analysis
$this->GivenRelationContextQueryWillFindTicket($oTicket1->GetKey());
$oTicket2 = $this->GivenTicketWithCIsOrPersons([
'Hypervisor_2' => 'manual',
]);
/// TEST Begins Here
$oTicket2->UpdateImpactedItems();
// The second ticket should have the impact propagated
$this->assertCIsOrPersonsListEquals($oTicket2, [
'Hypervisor_2' => 'manual',
'Farm_1' => 'computed',
]);
$this->ReloadObject($oTicket1); // reload the links
// The first ticket should remain in its initial state
$this->assertCIsOrPersonsListEquals($oTicket1, [
'Hypervisor_1' => 'manual',
]);
}
private function assertCIsOrPersonsListEquals(\UserRequest $oTicket, array $aExpected)
{
$aActual = [];
foreach ($oTicket->Get('functionalcis_list') as $oLnk) {
$sKey = $oLnk->Get('functionalci_id_friendlyname');
$aActual[$sKey] = $oLnk->Get('impact_code');
}
foreach ($oTicket->Get('contacts_list') as $oLnk) {
$sKey = $oLnk->Get('contact_id_friendlyname');
$aActual[$sKey] = $oLnk->Get('role_code');
}
$this->assertEquals($aExpected, $aActual, 'Unexpected value for functionalcis_list');
}
/**
* @param int|string|null $sTicketId
*
* @return void
*/
public function GivenRelationContextQueryWillFindTicket(int|string|null $sTicketId): void
{
$aRelationContext = \MetaModel::GetConfig()->GetModuleSetting('itop-tickets', 'relation_context');
$aRelationContext['UserRequest']['impacts']['down']['items'][0]['oql'] = "SELECT FCI, R
FROM FunctionalCI AS FCI
JOIN lnkFunctionalCIToTicket AS L ON L.functionalci_id = FCI.id
JOIN UserRequest AS R ON L.ticket_id = R.id
WHERE (R.id = $sTicketId)";
\MetaModel::GetConfig()->SetModuleSetting('itop-tickets', 'relation_context', $aRelationContext);
}
private function GivenCITreeInDB(string $sTree)
{
$aTree = explode("\n", $sTree);
foreach ($aTree as $sLine) {
$this->GivenCITreeLineInDB($sLine);
}
}
private function GivenCITreeLineInDB(string $sLine)
{
if (strpos($sLine, '<->') !== false) {
list($sCI, $sPerson) = explode('<->', $sLine);
$sPersonId = $this->GivenCIOrPersonInDB(trim($sPerson));
$sCIId = $this->GivenCIOrPersonInDB(trim($sCI));
$this->GivenLnkContactToFunctionalCIInDB($sPersonId, $sCIId);
return;
}
list($sCIParent, $sChildren) = explode('->', $sLine);
$aChildren = explode(',', $sChildren);
$aChildren = array_map('trim', $aChildren);
$aChildrenIdsByClass = [];
foreach ($aChildren as $sChildCI) {
list($sChildClass, ) = explode('_', $sChildCI, 2);
$aChildrenIdsByClass[$sChildClass] = $this->GivenCIOrPersonInDB($sChildCI);
}
$this->GivenCIOrPersonInDB($sCIParent, $aChildrenIdsByClass);
}
private function GivenCIOrPersonInDB(string $sDescriptor, array $aChildrenIdsByClass = []): string
{
$sDescriptor = trim($sDescriptor);
if (isset($this->aCIs[$sDescriptor])) {
return $this->aCIs[$sDescriptor];
}
list($sClass, $sRef) = explode('_', $sDescriptor, 2);
switch ($sClass) {
case 'Server':
$sCIId = $this->GivenServerInDB($sRef);
break;
case 'Hypervisor':
$sCIId = $this->GivenHypervisorInDB($sRef, $aChildrenIdsByClass['Server'] ?? 0, $aChildrenIdsByClass['Farm'] ?? 0);
break;
case 'Person':
$sCIId = $this->GivenPersonInDB($sRef);
break;
case 'Farm':
$sCIId = $this->GivenFarmInDB($sRef);
break;
case 'VirtualMachine':
$sCIId = $this->GivenVirtualMachineInDB($sRef, $aChildrenIdsByClass['Farm']);
break;
default:
throw new Exception("Unhandled class $sClass");
}
$this->aCIs[$sDescriptor] = $sCIId;
return $this->aCIs[$sDescriptor];
}
private function GivenTicketWithCIsOrPersons(array $aLinkedObjects) : \UserRequest
{
$oTicket = $this->GivenTicketObject(1);
foreach ($aLinkedObjects as $sObjectDescriptor => $sRole) {
$sClass = trim(explode('_', $sObjectDescriptor)[0]);
if ($sClass === 'Person') {
$this->AddLnkContactToTicketObject($this->GivenCIOrPersonInDB($sObjectDescriptor), $oTicket, $sRole);
continue;
}
$this->AddLnkFunctionalCIToTicketObject($this->GivenCIOrPersonInDB($sObjectDescriptor), $oTicket, $sRole);
}
return $oTicket;
}
private function GivenCINotAllowedToCurrentUser(string $sCIDescriptor)
{
$iAnotherOrg = $this->GivenObjectInDB(Organization::class, ['name' => 'Another Org']);
// Change the organization of the CI to 'Another Org'
$sCIDescriptor = trim($sCIDescriptor);
if (!isset($this->aCIs[$sCIDescriptor])) {
throw new Exception("CI $sCIDescriptor not found");
}
$sCIId = $this->aCIs[$sCIDescriptor];
$oCI = \MetaModel::GetObject('FunctionalCI', $sCIId);
$oCI->Set('org_id', $iAnotherOrg);
$oCI->DBUpdate();
$sConfigManagerProfileId = 3; // access to CIs
$sLogin = $this->GivenUserRestrictedToAnOrganizationInDB($this->getTestOrgId(), $sConfigManagerProfileId);
UserRights::Login($sLogin);
$this->ResetMetaModelQueyCacheGetObject();
}
}

922
tests/php-unit-tests/unitary-tests/datamodels/2.x/itop-tickets/itopTicketTest.php
View File

@@ -1,922 +0,0 @@
<?php
// Copyright (c) 2010-2024 Combodo SAS
//
// This file is part of iTop.
//
// iTop is free software; you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// iTop is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with iTop. If not, see <http://www.gnu.org/licenses/>
//
/**
* Created by PhpStorm.
* User: Eric
* Date: 18/12/2017
* Time: 13:34
*/
namespace Combodo\iTop\Test\UnitTest\Module\iTopTickets;
use Combodo\iTop\Test\UnitTest\ItopDataTestCase;
use Exception;
/**
* @group itopVirtualizationMgmt
* @group itopConfigMgmt
* @group itopTickets
*/
class ItopTicketTest extends ItopDataTestCase
{
const CREATE_TEST_ORG = true;
/**
* <pre>
* Given:
*
* Server1+---->Hypervisor1+---->Person1
*
* Ticket+---->Server1 (manual)
*
* Result:
*
* Ticket+====>Server1,Hypervisor1
* |
* +====>Person1
* </pre>
*
* @throws Exception
*/
public function testUpdateImpactedItems_Basic()
{
$oTicket = $this->CreateTicket(1);
$oServer1 = $this->CreateServer(1);
$oHypervisor1 = $this->CreateHypervisor(1, $oServer1);
$oPerson1 = $this->CreatePerson(1);
$this->AddContactToCI($oPerson1, $oHypervisor1);
$oHypervisor1->DBUpdate();
$aAwaitedCIs = $this->AddCIToTicket($oServer1, $oTicket, 'manual');
$oTicket->DBUpdate(); // trigger the impact update
$this->ReloadObject($oTicket); // reload the links
// Add the computed CIs
$aAwaitedCIs = $aAwaitedCIs + array($oHypervisor1->GetKey() => 'computed');
$this->CheckFunctionalCIList($oTicket, $aAwaitedCIs);
// Computed Contacts
$aAwaitedContacts = array($oPerson1->GetKey() => array('role_code' => 'computed'));
$this->CheckContactList($oTicket, $aAwaitedContacts);
$this->assertEquals(2, $oTicket->Get('functionalcis_list')->Count());
$this->assertEquals(1, $oTicket->Get('contacts_list')->Count());
}
/**
* <pre>
* Given:
*
* Server1+---->Hypervisor1+---->Person1
*
* Ticket+---->Server1 (manual)
*
* Result:
*
* Ticket+====>Server1,Hypervisor1
* |
* +====>Person1
* </pre>
*
* @throws Exception
*/
public function testUpdateImpactedItems_Basic2()
{
$oTicket = $this->CreateTicket(1);
$oServer1 = $this->CreateServer(1);
$oHypervisor1 = $this->CreateHypervisor(1, $oServer1);
$oPerson1 = $this->CreatePerson(1);
$this->AddContactToCI($oPerson1, $oHypervisor1);
$oHypervisor1->DBUpdate();
$this->AddCIToTicket($oServer1, $oTicket, 'manual');
$oTicket->DBUpdate(); // trigger the impact update
$this->ReloadObject($oTicket); // reload the links
$this->CheckFunctionalCIList($oTicket);
$this->CheckContactList($oTicket);
$this->assertEquals(2, $oTicket->Get('functionalcis_list')->Count());
$this->assertEquals(1, $oTicket->Get('contacts_list')->Count());
// Try removing computed entries
$this->RemoveCIFromTicket($oHypervisor1, $oTicket);
$this->RemoveContactFromTicket($oPerson1, $oTicket);
$oTicket->DBUpdate(); // trigger the impact update
$this->ReloadObject($oTicket); // reload the links
$this->CheckFunctionalCIList($oTicket);
$this->CheckContactList($oTicket);
$this->assertEquals(2, $oTicket->Get('functionalcis_list')->Count());
$this->assertEquals(1, $oTicket->Get('contacts_list')->Count());
}
/**
* <pre>
* Given:
*
* Server1+---->Hypervisor1+---->Person1
*
* Server2 Person2
*
* Ticket+---->Server1 (manual), Server2 (computed)
*
* Result:
*
* Ticket+====>Server1,Hypervisor1
* |
* +====>Person1
* </pre>
*
* @throws Exception
*/
public function testUpdateImpactedItems_RemoveUnecessaryEntries()
{
$oTicket = $this->CreateTicket(1);
$oServer1 = $this->CreateServer(1);
$oHypervisor1 = $this->CreateHypervisor(1, $oServer1);
$oPerson1 = $this->CreatePerson(1);
$this->AddContactToCI($oPerson1, $oHypervisor1);
$oHypervisor1->DBUpdate();
$oServer2 = $this->CreateServer(2);
$oPerson2 = $this->CreatePerson(2);
$this->AddCIToTicket($oServer1, $oTicket, 'manual');
$this->AddCIToTicket($oServer2, $oTicket, 'computed');
$this->AddContactToTicket($oPerson2, $oTicket, 'computed');
$oTicket->DBUpdate(); // trigger the impact update
$this->ReloadObject($oTicket); // reload the links
$this->CheckFunctionalCIList($oTicket);
$this->CheckContactList($oTicket);
$this->assertEquals(2, $oTicket->Get('functionalcis_list')->Count());
$this->assertEquals(1, $oTicket->Get('contacts_list')->Count());
}
/**
* Create a first impact chain then remove the root cause, all the chain should be removed.
*
* <pre>
* Given:
*
* Server1+---->Hypervisor1+---->Person1
*
* Ticket+---->Server1 (manual)
*
* Result:
*
* Ticket+====>Server1,Hypervisor1
* |
* +====>Person1
*
* Then remove Server1
*
* Result:
*
* Ticket+====>
* |
* +====>
*
* </pre>
*
* @throws Exception
*/
public function testUpdateImpactedItems_RemoveUnecessaryEntries2()
{
$oTicket = $this->CreateTicket(1);
$oServer1 = $this->CreateServer(1);
$oHypervisor1 = $this->CreateHypervisor(1, $oServer1);
$oPerson1 = $this->CreatePerson(1);
$this->AddContactToCI($oPerson1, $oHypervisor1);
$oHypervisor1->DBUpdate();
$this->AddCIToTicket($oServer1, $oTicket, 'manual');
$oTicket->DBUpdate(); // trigger the impact update
$this->ReloadObject($oTicket); // reload the links
$this->CheckFunctionalCIList($oTicket);
$this->CheckContactList($oTicket);
$this->assertEquals(2, $oTicket->Get('functionalcis_list')->Count());
$this->assertEquals(1, $oTicket->Get('contacts_list')->Count());
$this->RemoveCIFromTicket($oServer1, $oTicket);
$oTicket->DBUpdate(); // trigger the impact update
$this->ReloadObject($oTicket); // reload the links
$this->CheckFunctionalCIList($oTicket);
$this->CheckContactList($oTicket);
$this->assertEquals(0, $oTicket->Get('functionalcis_list')->Count());
$this->assertEquals(0, $oTicket->Get('contacts_list')->Count());
}
/**
* <pre>
*
* Server2+---->Hypervisor2+---->Person2
*
* Ticket+---->(empty)
*
* Result:
*
* Ticket+====>(empty)
* </pre>
*
* @throws Exception
*/
public function testUpdateImpactedItems_NoImpact()
{
$oTicket = $this->CreateTicket(1);
$oServer2 = $this->CreateServer(2);
$oPerson2 = $this->CreatePerson(2);
$oHypervisor2 = $this->CreateHypervisor(2, $oServer2);
$this->AddContactToCI($oPerson2, $oHypervisor2);
$oHypervisor2->DBUpdate();
$oTicket->DBUpdate(); // trigger the impact update
$this->ReloadObject($oTicket); // reload the links
$this->CheckFunctionalCIList($oTicket);
$this->CheckContactList($oTicket);
$this->assertEquals(0, $oTicket->Get('functionalcis_list')->Count());
$this->assertEquals(0, $oTicket->Get('contacts_list')->Count());
}
/**
* <pre>
* Server1
*
* Server2+---->Hypervisor2+---->Person2
*
* Ticket+---->Server1 (manual)
*
* Result:
*
* Ticket+====>Server1
* </pre>
*
* @throws Exception
*/
public function testUpdateImpactedItems_NoImpact2()
{
$oTicket = $this->CreateTicket(1);
$oServer1 = $this->CreateServer(1);
$oServer2 = $this->CreateServer(2);
$oPerson2 = $this->CreatePerson(2);
$oHypervisor2 = $this->CreateHypervisor(2, $oServer2);
$this->AddContactToCI($oPerson2, $oHypervisor2);
$oHypervisor2->DBUpdate();
$this->AddCIToTicket($oServer1, $oTicket, 'manual');
$oTicket->DBUpdate(); // trigger the impact update
$this->ReloadObject($oTicket); // reload the links
$this->CheckFunctionalCIList($oTicket);
$this->CheckContactList($oTicket);
$this->assertEquals(1, $oTicket->Get('functionalcis_list')->Count());
$this->assertEquals(0, $oTicket->Get('contacts_list')->Count());
}
/**
* <pre>
* +-->Person1
* |
* +
* Server1+---->Hypervisor1+--+
* |
* v
* Farm (1)
* ^
* |
* Server2+---->Hypervisor2+--+
* +
* |
* +-->Person2
*
* Ticket+---->Server1 (manual)
*
* Result:
*
* Ticket+====>Server1,Hypervisor1
* |
* +====>Person1
* </pre>
*
* @throws Exception
*/
public function testUpdateImpactedItems_Redundancy()
{
$oFarm = $this->CreateFarm(1);
$oServer1 = $this->CreateServer(1);
$oHypervisor1 = $this->CreateHypervisor(1, $oServer1, $oFarm);
$oContact1 = $this->CreatePerson(1);
$this->AddContactToCI($oContact1, $oHypervisor1);
$oHypervisor1->DBUpdate();
$oServer2 = $this->CreateServer(2);
$oHypervisor2 = $this->CreateHypervisor(2, $oServer2, $oFarm);
$oContact2 = $this->CreatePerson(2);
$this->AddContactToCI($oContact2, $oHypervisor2);
$oHypervisor2->DBUpdate();
$oTicket = $this->CreateTicket(1);
$this->AddCIToTicket($oServer1, $oTicket, 'manual');
$oTicket->DBUpdate(); // trigger the impact update
$this->ReloadObject($oTicket); // reload the links
$this->CheckFunctionalCIList($oTicket);
$this->CheckContactList($oTicket);
$this->assertEquals(2, $oTicket->Get('functionalcis_list')->Count());
$this->assertEquals(1, $oTicket->Get('contacts_list')->Count());
}
/**
* <pre>
* +-->Person1
* |
* +
* Server1+---->Hypervisor1+--+
* |
* v
* Farm (1)
* ^
* |
* Server2+---->Hypervisor2+--+
* +
* |
* +-->Person2
*
* Ticket+---->Server1 (manual), Hypervisor2 (manual)
*
* Result:
*
* Ticket+====>Server1,Hypervisor1,Farm,Hypervisor2
* |
* +====>Person1,Person2
* </pre>
*
* @throws Exception
*/
public function testUpdateImpactedItems_Redundancy2()
{
$oFarm = $this->CreateFarm(1);
$oServer1 = $this->CreateServer(1);
$oHypervisor1 = $this->CreateHypervisor(1, $oServer1, $oFarm);
$oContact1 = $this->CreatePerson(1);
$this->AddContactToCI($oContact1, $oHypervisor1);
$oHypervisor1->DBUpdate();
$oServer2 = $this->CreateServer(2);
$oHypervisor2 = $this->CreateHypervisor(2, $oServer2, $oFarm);
$oContact2 = $this->CreatePerson(2);
$this->AddContactToCI($oContact2, $oHypervisor2);
$oHypervisor2->DBUpdate();
$oTicket = $this->CreateTicket(1);
$this->AddCIToTicket($oServer1, $oTicket, 'manual');
$this->AddCIToTicket($oHypervisor2, $oTicket, 'manual');
$oTicket->DBUpdate(); // trigger the impact update
$this->ReloadObject($oTicket); // reload the links
$this->CheckFunctionalCIList($oTicket);
$this->CheckContactList($oTicket);
$this->assertEquals(4, $oTicket->Get('functionalcis_list')->Count());
$this->assertEquals(2, $oTicket->Get('contacts_list')->Count());
}
/**
* <pre>
* +-->Person1
* |
* +
* Server1+---->Hypervisor1+--+ +-->VM1
* | |
* v +
* Farm (1)
* ^ +
* | |
* Server2+---->Hypervisor2+--+ +-->VM2
* +
* |
* +-->Person2
*
* Ticket+---->Server1 (manual), Hypervisor2 (manual)
*
* Result:
*
* Ticket+====>Server1,Hypervisor1,Farm,Hypervisor2,VM1,VM2
* |
* +====>Person1,Person2
* </pre>
*
* @throws Exception
*/
public function testUpdateImpactedItems_Redundancy3()
{
$oFarm = $this->CreateFarm(1);
$oServer1 = $this->CreateServer(1);
$oHypervisor1 = $this->CreateHypervisor(1, $oServer1, $oFarm);
$oContact1 = $this->CreatePerson(1);
$this->AddContactToCI($oContact1, $oHypervisor1);
$oHypervisor1->DBUpdate();
$oServer2 = $this->CreateServer(2);
$oHypervisor2 = $this->CreateHypervisor(2, $oServer2, $oFarm);
$oContact2 = $this->CreatePerson(2);
$this->AddContactToCI($oContact2, $oHypervisor2);
$oHypervisor2->DBUpdate();
$this->CreateVirtualMachine(1, $oFarm);
$this->CreateVirtualMachine(2, $oFarm);
$oTicket = $this->CreateTicket(1);
$this->AddCIToTicket($oServer1, $oTicket, 'manual');
$this->AddCIToTicket($oHypervisor2, $oTicket, 'manual');
$oTicket->DBUpdate(); // trigger the impact update
$this->ReloadObject($oTicket); // reload the links
$this->CheckFunctionalCIList($oTicket);
$this->CheckContactList($oTicket);
$this->assertEquals(6, $oTicket->Get('functionalcis_list')->Count());
$this->assertEquals(2, $oTicket->Get('contacts_list')->Count());
}
/**
* <pre>
* +-->Person1
* |
* +
* Server1+---->Hypervisor1+--+ +-->VM1
* | |
* v +
* Farm (1)
* ^ +
* | |
* Server2+---->Hypervisor2+--+ +-->VM2
* +
* |
* +-->Person2
*
* Ticket+---->Server1 (manual), Server2 (manual), Hypervisor2 (not_impacted)
*
* Result:
*
* Ticket+====>Server1,Hypervisor1,Server2,Hypervisor2
* |
* +====>Person1
* </pre>
*
* @throws Exception
*/
public function testUpdateImpactedItems_Exclusion()
{
$oFarm = $this->CreateFarm(1);
$oServer1 = $this->CreateServer(1);
$oHypervisor1 = $this->CreateHypervisor(1, $oServer1, $oFarm);
$oContact1 = $this->CreatePerson(1);
$this->AddContactToCI($oContact1, $oHypervisor1);
$oHypervisor1->DBUpdate();
$oServer2 = $this->CreateServer(2);
$oHypervisor2 = $this->CreateHypervisor(2, $oServer2, $oFarm);
$oContact2 = $this->CreatePerson(2);
$this->AddContactToCI($oContact2, $oHypervisor2);
$oHypervisor2->DBUpdate();
$this->CreateVirtualMachine(1, $oFarm);
$this->CreateVirtualMachine(2, $oFarm);
$oTicket = $this->CreateTicket(1);
$this->AddCIToTicket($oServer1, $oTicket, 'manual');
$this->AddCIToTicket($oServer2, $oTicket, 'manual');
$this->AddCIToTicket($oHypervisor2, $oTicket, 'not_impacted');
$oTicket->DBUpdate(); // trigger the impact update
$this->ReloadObject($oTicket); // reload the links
$this->CheckFunctionalCIList($oTicket);
$this->CheckContactList($oTicket);
$this->assertEquals(4, $oTicket->Get('functionalcis_list')->Count());
$this->assertEquals(1, $oTicket->Get('contacts_list')->Count());
}
/**
* <pre>
* +-->Person1
* |
* +
* Server1+---->Hypervisor1+--+ +-->VM1
* | |
* v +
* Farm (1)
* ^ +
* | |
* Server2+---->Hypervisor2+--+ +-->VM2
* +
* |
* +-->Person2
*
* Ticket+---->Server1 (manual), Server2 (manual)
* |
* +---->Person2 (do_not_notify)
*
* Result:
*
* Ticket+====>Server1,Hypervisor1,Server2,Hypervisor2,Farm,VM1,VM2
* |
* +====>Person1,Person2 (do_not_notify)
* </pre>
*
* @throws Exception
*/
public function testUpdateImpactedItems_Exclusion2()
{
$oFarm = $this->CreateFarm(1);
$oServer1 = $this->CreateServer(1);
$oHypervisor1 = $this->CreateHypervisor(1, $oServer1, $oFarm);
$oContact1 = $this->CreatePerson(1);
$this->AddContactToCI($oContact1, $oHypervisor1);
$oHypervisor1->DBUpdate();
$oServer2 = $this->CreateServer(2);
$oHypervisor2 = $this->CreateHypervisor(2, $oServer2, $oFarm);
$oContact2 = $this->CreatePerson(2);
$this->AddContactToCI($oContact2, $oHypervisor2);
$oHypervisor2->DBUpdate();
$this->CreateVirtualMachine(1, $oFarm);
$this->CreateVirtualMachine(2, $oFarm);
$oTicket = $this->CreateTicket(1);
$this->AddCIToTicket($oServer1, $oTicket, 'manual');
$this->AddCIToTicket($oServer2, $oTicket, 'manual');
$this->AddContactToTicket($oContact2, $oTicket, 'do_not_notify');
$oTicket->DBUpdate(); // trigger the impact update
$this->ReloadObject($oTicket); // reload the links
$this->CheckFunctionalCIList($oTicket);
$this->CheckContactList($oTicket);
$this->assertEquals(7, $oTicket->Get('functionalcis_list')->Count());
$this->assertEquals(2, $oTicket->Get('contacts_list')->Count());
}
/**
* <pre>
* +-->Person1
* |
* +
* Server1+---->Hypervisor1+--+ +-->VM1
* | |
* v +
* Farm (1)
* ^ +
* | |
* Server2+---->Hypervisor2+--+ +-->VM2
* +
* |
* +-->Person2
*
* Ticket+---->Server1 (manual), Server2 (manual), Hypervisor2 (not_impacted)
* |
* +---->Person2 (do_not_notify)
*
* Result:
*
* Ticket+====>Server1,Hypervisor1,Server2,Hypervisor2
* |
* +====>Person1,Person2 (do_not_notify)
* </pre>
*
* @throws Exception
*/
public function testUpdateImpactedItems_Exclusion3()
{
$oFarm = $this->CreateFarm(1);
$oServer1 = $this->CreateServer(1);
$oHypervisor1 = $this->CreateHypervisor(1, $oServer1, $oFarm);
$oContact1 = $this->CreatePerson(1);
$this->AddContactToCI($oContact1, $oHypervisor1);
$oHypervisor1->DBUpdate();
$oServer2 = $this->CreateServer(2);
$oHypervisor2 = $this->CreateHypervisor(2, $oServer2, $oFarm);
$oContact2 = $this->CreatePerson(2);
$this->AddContactToCI($oContact2, $oHypervisor2);
$oHypervisor2->DBUpdate();
$this->CreateVirtualMachine(1, $oFarm);
$this->CreateVirtualMachine(2, $oFarm);
$oTicket = $this->CreateTicket(1);
$this->AddCIToTicket($oServer1, $oTicket, 'manual');
$this->AddCIToTicket($oServer2, $oTicket, 'manual');
$this->AddCIToTicket($oHypervisor2, $oTicket, 'not_impacted');
$this->AddContactToTicket($oContact2, $oTicket, 'do_not_notify');
$oTicket->DBUpdate(); // trigger the impact update
$this->ReloadObject($oTicket); // reload the links
$this->CheckFunctionalCIList($oTicket);
$this->CheckContactList($oTicket);
$this->assertEquals(4, $oTicket->Get('functionalcis_list')->Count());
$this->assertEquals(2, $oTicket->Get('contacts_list')->Count());
}
/**
* <pre>
* +-->Person1
* |
* +
* Server1+---->Hypervisor1+--+ +-->VM1
* | |
* v +
* Farm (1)
* ^ +
* | |
* Server2+---->Hypervisor2+--+ +-->VM2
* +
* |
* +-->Person2
*
* Ticket+---->Server1 (manual), Hypervisor2 (not_impacted)
*
* Result:
*
* Ticket+====>Server1,Hypervisor1, Hypervisor2 (not_impacted)
* |
* +====>Person1
* </pre>
*
* @throws Exception
*/
public function testUpdateImpactedItems_Exclusion4()
{
$oFarm = $this->CreateFarm(1);
$oServer1 = $this->CreateServer(1);
$oHypervisor1 = $this->CreateHypervisor(1, $oServer1, $oFarm);
$oContact1 = $this->CreatePerson(1);
$this->AddContactToCI($oContact1, $oHypervisor1);
$oHypervisor1->DBUpdate();
$oServer2 = $this->CreateServer(2);
$oHypervisor2 = $this->CreateHypervisor(2, $oServer2, $oFarm);
$oContact2 = $this->CreatePerson(2);
$this->AddContactToCI($oContact2, $oHypervisor2);
$oHypervisor2->DBUpdate();
$this->CreateVirtualMachine(1, $oFarm);
$this->CreateVirtualMachine(2, $oFarm);
$oTicket = $this->CreateTicket(1);
$this->AddCIToTicket($oServer1, $oTicket, 'manual');
$this->AddCIToTicket($oHypervisor2, $oTicket, 'not_impacted');
$oTicket->DBUpdate(); // trigger the impact update
$this->ReloadObject($oTicket); // reload the links
$this->CheckFunctionalCIList($oTicket);
$this->CheckContactList($oTicket);
$this->assertEquals(3, $oTicket->Get('functionalcis_list')->Count());
$this->assertEquals(1, $oTicket->Get('contacts_list')->Count());
}
/**
* <pre>
* +-->Person1
* |
* +
* Server1+---->Hypervisor1+--+ +-->VM1
* | |
* v +
* Farm (1)
* ^ +
* | |
* Server2+---->Hypervisor2+--+ +-->VM2
* +
* |
* +-->Person2
*
* Ticket1+---->Server1 (manual)
*
* Result:
*
* Ticket1+====>Server1,Hypervisor1
* |
* +====>Person1
*
* Then:
*
* Ticket2+---->Server2 (manual)
*
* Result:
*
* Ticket2+====>Server2,Hypervisor2,Farm,VM1,VM2
* |
* +====>Person2
* </pre>
*
* @throws \ArchivedObjectException
* @throws Exception
*/
public function testUpdateImpactedItems_Redundancy_two_tickets()
{
$oFarm = $this->CreateFarm(1);
$oServer1 = $this->CreateServer(1);
$oHypervisor1 = $this->CreateHypervisor(1, $oServer1, $oFarm);
$oContact1 = $this->CreatePerson(1);
$this->AddContactToCI($oContact1, $oHypervisor1);
$oHypervisor1->DBUpdate();
$oServer2 = $this->CreateServer(2);
$oHypervisor2 = $this->CreateHypervisor(2, $oServer2, $oFarm);
$oContact2 = $this->CreatePerson(2);
$this->AddContactToCI($oContact2, $oHypervisor2);
$oHypervisor2->DBUpdate();
$oVM1 = $this->CreateVirtualMachine(1, $oFarm);
$oVM2 = $this->CreateVirtualMachine(2, $oFarm);
// Ticket1+---->Server1 (manual)
$oTicket1 = $this->CreateTicket(1);
$this->AddCIToTicket($oServer1, $oTicket1, 'manual');
$oTicket1->DBUpdate(); // trigger the impact update
$this->ReloadObject($oTicket1); // reload the links
// Ticket1+====>Server1,Hypervisor1
// |
// +====>Person1
$this->CheckFunctionalCIList($oTicket1);
$this->CheckContactList($oTicket1);
$this->assertEquals(2, $oTicket1->Get('functionalcis_list')->Count());
$this->assertEquals(1, $oTicket1->Get('contacts_list')->Count());
// Ticket2+---->Hypervisor2 (manual)
$oTicket2 = $this->CreateTicket(2);
$this->AddCIToTicket($oServer2, $oTicket2, 'manual');
$oTicket2->DBUpdate(); // trigger the impact update
$this->ReloadObject($oTicket2); // reload the links
// Ticket2+====>Farm,Hypervisor2,VM1,VM2,Server2
// |
// +====>Person2
$aWaitedCIList = array(
$oFarm->GetKey() => 'computed',
$oVM1->GetKey() => 'computed',
$oVM2->GetKey() => 'computed',
$oHypervisor2->GetKey() => 'computed',
$oServer2->GetKey() => 'manual');
$this->CheckFunctionalCIList($oTicket2, $aWaitedCIList);
$this->CheckContactList($oTicket2);
$this->assertEquals(2, $oTicket2->Get('functionalcis_list')->Count());
$this->assertEquals(1, $oTicket2->Get('contacts_list')->Count());
// The first ticket is not impacted
$this->debug("\nCheck that the first ticket has not changed.");
$this->ReloadObject($oTicket1); // reload the links
// Ticket1+====>Server1,Hypervisor1
// |
// +====>Person1
$this->CheckFunctionalCIList($oTicket1);
$this->CheckContactList($oTicket1);
$this->assertEquals(2, $oTicket1->Get('functionalcis_list')->Count());
$this->assertEquals(1, $oTicket1->Get('contacts_list')->Count());
}
/**
* <pre>
* +-->Person1
* |
* +
* Server1+---->Hypervisor1+--+ +-->VM1
* | |
* v +
* Server3+---->Hypervisor3+->Farm (1)
* ^ +
* | |
* Server2+---->Hypervisor2+--+ +-->VM2
* +
* |
* +-->Person2
*
* Ticket1+---->Server1 (manual), Hypervisor2(manual)
*
* Result:
*
* Ticket1+====>Server1,Hypervisor1, Hypervisor2
* |
* +====>Person1, Person2
*
* Then:
*
* Ticket2+---->Server2 (manual), Hypervisor3 (manual)
*
* Result:
*
* Ticket2+====>Server2,Hypervisor2,Hypervisor3,Farm,VM1,VM2
* |
* +====>Person2
* </pre>
*
* @throws \ArchivedObjectException
* @throws Exception
*/
public function testUpdateImpactedItems_Redundancy_two_tickets2()
{
$oFarm = $this->CreateFarm(1);
$oServer1 = $this->CreateServer(1);
$oHypervisor1 = $this->CreateHypervisor(1, $oServer1, $oFarm);
$oContact1 = $this->CreatePerson(1);
$this->AddContactToCI($oContact1, $oHypervisor1);
$oHypervisor1->DBUpdate();
$oServer2 = $this->CreateServer(2);
$oHypervisor2 = $this->CreateHypervisor(2, $oServer2, $oFarm);
$oContact2 = $this->CreatePerson(2);
$this->AddContactToCI($oContact2, $oHypervisor2);
$oHypervisor2->DBUpdate();
$oServer3 = $this->CreateServer(3);
$oHypervisor3 = $this->CreateHypervisor(3, $oServer3, $oFarm);
$oVM1 = $this->CreateVirtualMachine(1, $oFarm);
$oVM2 = $this->CreateVirtualMachine(2, $oFarm);
// Ticket1+---->Server1 (manual), Hypervisor2(manual)
$oTicket1 = $this->CreateTicket(1);
$this->AddCIToTicket($oServer1, $oTicket1, 'manual');
$this->AddCIToTicket($oHypervisor2, $oTicket1, 'manual');
$oTicket1->DBUpdate(); // trigger the impact update
$this->ReloadObject($oTicket1); // reload the links
// Ticket1+====>Server1,Hypervisor1,Hypervisor2
// |
// +====>Person1,Person2
$this->CheckFunctionalCIList($oTicket1);
$this->CheckContactList($oTicket1);
$this->assertEquals(3, $oTicket1->Get('functionalcis_list')->Count());
$this->assertEquals(2, $oTicket1->Get('contacts_list')->Count());
// Ticket2+---->Server2 (manual)
$oTicket2 = $this->CreateTicket(2);
$this->AddCIToTicket($oServer2, $oTicket2, 'manual');
$this->AddCIToTicket($oHypervisor3, $oTicket2, 'manual');
$oTicket2->DBUpdate(); // trigger the impact update
$this->ReloadObject($oTicket2); // reload the links
// Ticket2+====>Farm,Hypervisor2,VM1,VM2,Server2
// |
// +====>Person2
$aWaitedCIList = array(
$oFarm->GetKey() => 'computed',
$oVM1->GetKey() => 'computed',
$oVM2->GetKey() => 'computed',
$oHypervisor2->GetKey() => 'computed',
$oHypervisor3->GetKey() => 'manual',
$oServer2->GetKey() => 'manual');
$this->CheckFunctionalCIList($oTicket2, $aWaitedCIList);
$this->CheckContactList($oTicket2);
$this->assertEquals(3, $oTicket2->Get('functionalcis_list')->Count());
$this->assertEquals(1, $oTicket2->Get('contacts_list')->Count());
// The first ticket is not impacted
$this->debug("\nCheck that the first ticket has not changed.");
$this->ReloadObject($oTicket1); // reload the links
// Ticket1+====>Server1,Hypervisor1,Hypervisor2
// |
// +====>Person1,Person2
$this->CheckFunctionalCIList($oTicket1);
$this->CheckContactList($oTicket1);
$this->assertEquals(3, $oTicket1->Get('functionalcis_list')->Count());
$this->assertEquals(2, $oTicket1->Get('contacts_list')->Count());
}
}

5
tests/php-unit-tests/unitary-tests/sources/Application/Status/StatusTest.php
View File

@@ -20,9 +20,7 @@ class StatusTest extends ItopTestCase
protected function GetPHPCommand()
{
$this->RequireOnceItopFile('application/utils.inc.php');
$oConfig = new Config(ITOP_DEFAULT_CONFIG_FILE);
return $oConfig->Get('php_path');
return PHP_BINARY;
}
public function testStatusPageRepliesAsExpected()
@@ -30,6 +28,7 @@ class StatusTest extends ItopTestCase
$sPath = APPROOT.'/webservices/status.php';
$sPHP = $this->GetPHPCommand();
echo "About to execute: $sPHP $sPath\n";
exec("$sPHP $sPath", $aOutput, $iRet);
$this->assertEquals(0, $iRet, "Problem executing status page: $sPath, $iRet, aOutput:\n".var_export($aOutput, true));

184
tests/php-unit-tests/unitary-tests/tests/php-unit-tests/GivenObjectInDBTest.php Normal file
View File

@@ -0,0 +1,184 @@
<?php
namespace Combodo\iTop\Test\UnitTest;
use CMDBSource;
use MetaModel;
/**
* @covers ItopDataTestCase::GivenObjectInDB
*/
class GivenObjectInDBTest extends ItopDataTestCase
{
const CREATE_TEST_ORG = true;
public function testItShouldRelyOnFewerQueriesAsComparedToDBInsert()
{
$this->assertDBQueryCount(14, function() use (&$iKey) {
$iKey = $this->createObject('Organization', ['name' => 'The world company']);
});
$this->assertDBQueryCount(2, function() use (&$iKey) {
$iKey = $this->GivenObjectInDB('Organization', ['name' => 'The world company']);
});
}
public function testItShouldFillInTheOrganizationWhenOmitted()
{
$iPerson = $this->GivenObjectInDB('Person', [
'name' => 'Doe',
'first_name' => 'John',
]);
$oPerson = MetaModel::GetObject('Person', $iPerson);
$this->assertEquals(
$this->getTestOrgId(),
$oPerson->Get('org_id'),
"When omitted, the org_id should be set to getTestOrgId()"
);
}
public function testItShouldHandleLinksetToo()
{
$iPerson = $this->GivenObjectInDB('Person', [
'name' => 'Doe',
'first_name' => 'John',
]);
$iTeam = $this->GivenObjectInDB('Team', [
'name' => 'The A Team',
'persons_list' => [
"person_id:$iPerson;role_id:1"
],
]);
$oSet = new \DBObjectSet(\DBObjectSearch::FromOQL("SELECT lnkPersonToTeam AS lnk WHERE lnk.team_id = $iTeam AND lnk.person_id = $iPerson"));
$this->assertEquals(1, $oSet->Count(), "The link between the team and the person should be there");
$oLnk = $oSet->Fetch();
$this->assertEquals(1, $oLnk->Get('role_id'), "The role should be correctly set");
}
public function testItShouldFailExplicitlyWhenAnAttributeCodeIsUnknown()
{
$this->expectException(\Exception::class);
$this->expectExceptionMessage("GivenObjectInDB('Organization'), invalid attribute code 'amen'");
$this->GivenObjectInDB('Organization', ['amen' => 'The world company']);
}
public function testItShouldFailExplicitlyWhenAMandatoryAttributeIsMissing()
{
// Note : a mandatory attribute is an attribute for which the default value cannot be used by default
// because it is not nullable and the default is "null"
$this->expectException(\Exception::class);
$this->expectExceptionMessage("GivenObjectInDB('Organization'), mandatory attribute 'name' is missing");
$this->GivenObjectInDB('Organization', []);
}
/**
* @dataProvider SampleObjectsProvider
*/
public function testItShouldMakeExactSameObjectsASDBInsert($sClass, $aValues)
{
$oObjectCreatedWithCompleteStack = parent::createObject($sClass, $aValues);
$oObjectFromDBStandard = MetaModel::GetObject($sClass, $oObjectCreatedWithCompleteStack->GetKey());
// Create by the mean of the efficient method
$iKey = $this->GivenObjectInDB($sClass, $aValues);
// Check that it is readable (no exception)
$oObjectFromDBOptimized = MetaModel::GetObject($sClass, $iKey);
// Check that an object created by the mean of the std APIs will have the same values
foreach ($aValues as $sAttCode => $value)
{
static::assertEquals(
$oObjectFromDBStandard->Get($sAttCode),
$oObjectFromDBOptimized->Get($sAttCode),
"The value of the attribute '$sAttCode' should be the same as for an object recorded with DBObject::DBInsert"
);
}
}
public function SampleObjectsProvider()
{
return [
'Organization' => [
'class' => 'Organization',
'values' => [
'name' => 'Orga tartampion',
]
],
'FAQCategory' => [
'class' => 'FAQCategory',
'values' => [
'name' => 'FAQCategory_phpunit',
]
],
'Server' => [
'class' => 'Server',
'values' => [
'name' => 'Server tartampion',
'org_id' => 1,
'nb_u' => 123,
]
],
'TagSetFieldDataFor_FAQ__domains' => [
'class' => 'TagSetFieldDataFor_FAQ__domains',
'values' => [
'code' => 'tagada'.uniqid(),
'label' => 'label for tagada'.uniqid(),
'obj_class' => 'FAQ',
'obj_attcode' => 'domains',
'description' => '<p>tartampion</p>',
]
],
'Hypervisor' => [
'class' => 'Hypervisor',
'values' => [
'name' => 'Hypervisor_tartampion',
'org_id' => 1,
'server_id' => 1,
'farm_id' => 0,
]
],
'Rack' => [
'class' => 'Rack',
'values' => [
'name' => "rackamuffin",
'description' => "rackadescription",
'org_id' => 1
]
],
'Person' => [
'class' => 'Person',
'values' => [
'name' => 'Person_tartampion',
'first_name' => 'Test',
'org_id' => 1,
]
],
'Farm' => [
'class' => 'Farm',
'values' => [
'name' => 'Farm_tartampion',
'org_id' => 1,
'redundancy' => '1',
]
],
'UserRequest' => [
'class' => 'UserRequest',
'values' => [
'ref' => 'Ticket_tartampion',
'title' => 'TICKET_TARTAMPION as a title',
'description' => '<p>Created for unit tests.</p>',
'org_id' => 1,
]
],
];
}
}