/**
*
* Creates a new Kaltura test Object
* @param string $name
* @param array $data
* @param string $dataName
*/
public function __construct($name = null, array $data = array(), $dataName = '')
{
parent::__construct($name, $data, $dataName);
$class = get_class($this);
if ($name) {
KalturaLog::info("_____________________________________ [{$class}] [{$name}] ___________________________________");
} else {
KalturaLog::info("__________________________________________ [{$class}] ______________________________________");
}
$testFilePath = KAutoloader::getClassFilePath($class);
$this->testFolder = dirname($testFilePath);
$this->inputs = $data;
KalturaLog::info("Loads config file [{$testFilePath}.ini]");
$this->config = new KalturaTestConfig("{$testFilePath}.ini");
$testConfig = $this->config->get('config');
if (!$testConfig) {
$testConfig = new Zend_Config(array('source' => KalturaTestSource::XML), true);
$this->config->config = $testConfig;
$this->config->saveToIniFile();
}
$this->dataSource = $testConfig->source;
$this->outputFolder = $testConfig->outputFolder;
if ($this->outputFolder && !is_dir($this->outputFolder)) {
KalturaLog::info("Creating folder output [{$this->outputFolder}]");
mkdir($this->outputFolder, 777, true);
}
}
/**
* Test the addition of a mediaEntry with proeprty "categories" set.
* @param string $categories
* @dataProvider provideData
*/
public function testAddWithCategories($categories)
{
$mediaEntry = new KalturaMediaEntry();
$mediaEntry->name = uniqid();
$mediaEntry->mediaType = KalturaMediaType::VIDEO;
$mediaEntry->categories = $categories;
$mediaEntry = $this->client->media->add($mediaEntry);
var_dump(KAutoloader::getClassFilePath(get_class($this->client)));
$categoryNames = explode(",", $categories);
foreach ($categoryNames as $categoryName) {
$filter = new KalturaCategoryFilter();
$filter->fullNameEqual = $categoryName;
$results = $this->client->category->listAction($filter);
$this->assertEquals(1, $results->totalCount, "Unexpected number of categories with fullname {$categoryName}.");
$catId = $results->objects[0]->id;
// Assert that the entry's "categoriesIds" property was updated properly.
$entryCatIds = explode(',', $mediaEntry->categoriesIds);
$this->assertTrue(in_array($catId, $entryCatIds), "Entry's categoriesIds property should containt category Id [{$catId}] for category [{$categoryName}]");
//Assert that a KalturaCategoryEntry object was created for the entry and each category it was associated with.
$catEntryFilter = new KalturaCategoryEntryFilter();
$catEntryFilter->categoryIdEqual = $catId;
$catEntryFilter->entryIdEqual = $mediaEntry->id;
try {
$res = $this->client->categoryEntry->listAction($catEntryFilter);
$this->assertGreaterThan(0, $res->totalCount > 0);
} catch (Exception $e) {
$this->assertEquals(0, 1, "Unexpected exception thrown - expected categoryEntry object for entry Id" . $mediaEntry->id . " and category Id {$catId}");
}
}
}
/**
*
* The test data provider (gets the data for the different tests)
* @param string $className - The class name
* @param string $procedureName - The current method (test) name
* @return array<array>();
*/
public function provider($className, $procedureName)
{
//print("In provider for $className, $procedureName \n");
//Gets from the given class the class data file
$class = get_class($this);
$classFilePath = KAutoloader::getClassFilePath($class);
$testClassDir = dirname($classFilePath);
$dataFilePath = $testClassDir . DIRECTORY_SEPARATOR . "testsData/{$className}.data";
KalturaLog::debug("The data file path [" . $dataFilePath . "]");
if (file_exists($dataFilePath)) {
$simpleXML = kXml::openXmlFile($dataFilePath);
} else {
//TODO: Give notice or create the file don't throw an exception
throw new Exception("Data file [{$dataFilePath}] not found");
}
$inputsForTestProcedure = array();
foreach ($simpleXML->TestProcedureData as $xmlTestProcedureData) {
if ($xmlTestProcedureData["testProcedureName"] != $procedureName) {
continue;
}
foreach ($xmlTestProcedureData->TestCaseData as $xmlTestCaseData) {
$testCaseInstanceInputs = array();
foreach ($xmlTestCaseData->Input as $input) {
$object = KalturaTestDataObject::generatefromXml($input);
//Add the new input to the test case instance data
$testCaseInstanceInputs[] = $object;
}
foreach ($xmlTestCaseData->OutputReference as $output) {
$object = KalturaTestDataObject::generatefromXml($output);
//Add the new output reference to the test case instance data
$testCaseInstanceInputs[] = $object;
}
//Add the test case into the test procedure data
$inputsForTestProcedure[] = $testCaseInstanceInputs;
}
}
KalturaLog::info("Tests data provided Before transformation to objects: \n[" . print_r($inputsForTestProcedure, true) . "]");
$inputsForTestProcedure = $this->transformToObjects($inputsForTestProcedure);
KalturaLog::info("Tests data provided [" . print_r($inputsForTestProcedure, true) . "]");
return $inputsForTestProcedure;
}
protected function writeAfterService(KalturaServiceReflector $serviceReflector)
{
$this->writeTest("\t/**");
$this->writeTest("\t * Called when all tests are done");
$this->writeTest("\t * @param int \$id");
$this->writeTest("\t * @return int");
$this->writeTest("\t * @depends {$this->lastDependencyTest} - TODO: replace {$this->lastDependencyTest} with last test function that uses that id");
$this->writeTest("\t */");
$this->writeTest("\tpublic function testFinished(\$id)");
$this->writeTest("\t{");
$this->writeTest("\t\treturn \$id;");
$this->writeTest("\t}");
$this->writeTest("");
$this->writeTest("}");
$this->writeBase("\t/**");
$this->writeBase("\t * Called when all tests are done");
$this->writeBase("\t * @param int \$id");
$this->writeBase("\t * @return int");
$this->writeBase("\t */");
$this->writeBase("\tabstract public function testFinished(\$id);");
$this->writeBase("");
$this->writeBase("}");
$serviceName = $serviceReflector->getServiceName();
$serviceClass = $serviceReflector->getServiceClass();
$testPath = realpath(dirname(__FILE__) . '/../') . "/tests/api/{$serviceName}";
if ($serviceReflector->isFromPlugin()) {
$servicePath = KAutoloader::getClassFilePath($serviceClass);
$testPath = realpath(dirname($servicePath) . '/../') . "/tests/services/{$serviceName}";
}
$this->writeToFile("{$testPath}/{$serviceClass}BaseTest.php", $this->_txtBase);
$this->writeToFile("{$testPath}/{$serviceClass}Test.php", $this->_txtTest, false);
$this->writeToFile("{$testPath}/{$serviceClass}Test.php.ini", $this->_txtIni, false);
}
/**
*
* Inits the global data file
* @return true - If global exists or was created, null other wise
*/
private static function initDataFile()
{
if (is_null(KalturaGlobalData::$dataFilePath)) {
$classFilePath = KAutoloader::getClassFilePath("KalturaGlobalData");
$dir = dirname($classFilePath);
KalturaGlobalData::setDataFilePath($dir . "/" . KalturaGlobalData::DEFAULT_DATA_PATH);
}
if (file_exists(KalturaGlobalData::$dataFilePath)) {
KalturaGlobalData::$dataFile = new KalturaTestConfig(KalturaGlobalData::$dataFilePath);
} else {
print "Global file no found at: " . KalturaGlobalData::$dataFilePath . "\n";
return null;
}
return true;
}
public function startTestSuite(PHPUnit_Framework_TestSuite $suite)
{
// print("In startTestSuite - for suite = {$suite->getName()}\n");
KalturaLog::debug("In startTestSuite - for suite = {$suite->getName()}");
if ($suite instanceof PHPUnit_Framework_TestSuite_DataProvider) {
//Get the test procedure name from the suite name which is (testCase::testProcedure)
$testNames = explode("::", $suite->getName());
$testName = $testNames[0];
if (isset($testNames[1])) {
$testName = $testNames[1];
}
$testCase = $testNames[0];
if (is_null(KalturaTestListener::$testCaseFailures)) {
KalturaLog::debug("KalturaTestCaseFailures is null creating empty test case failures for {$testCase}\n");
KalturaTestListener::$testCaseFailures = new KalturaTestCaseFailures($testName);
}
$testProcedure = KalturaTestListener::$testCaseFailures->getTestProcedureFailure($testName);
//if the test procedure exists
if (!$testProcedure) {
KalturaTestListener::$testCaseFailures->addTestProcedureFailure(new KalturaTestProcedureFailure($testName));
} else {
KalturaLog::alert("Test procedure [{$testName}] already added");
}
} else {
//Check if the test belongs to the same test case failures (by the first test of the suite)
$test = $suite->testAt(0);
if ($test instanceof PHPUnit_Framework_TestSuite_DataProvider) {
$test = $test->testAt(0);
}
$class = get_class($test);
//if the new test comes from a new file (testCase)
if (KalturaTestListener::$currentTestCase != $class) {
//Gets the class path for the failure file
$classPath = KAutoloader::getClassFilePath($class);
KalturaTestListener::$failureFilePath = dirname($classPath) . "/testsData/{$class}.failures";
KalturaTestListener::$dataFilePath = dirname($classPath) . "/testsData/{$class}.data";
$this->writeFailuresToFile();
//Opens the new failure file for the new test
KalturaTestListener::$failuresFile = fopen(KalturaTestListener::$failureFilePath, "w+");
//Change the current test case
KalturaTestListener::$currentTestCase = $class;
//Create new test case failures for the new test case
KalturaTestListener::$testCaseFailures = new KalturaTestCaseFailures(KalturaTestListener::$currentTestCase);
//TODO: get the test procedure name from the suite
KalturaTestListener::$testCaseFailures->setTestProceduresFailures(array(new KalturaTestProcedureFailure("Unknown")));
} else {
}
}
}
