/**
* Check this resource type instance has bag property associated with it
* Note: This is an internal method used by library. Devs don't use this.
*
* @param array(mixed) &$arrayToDetectLoopInComplexType array for detecting loop.
*
* @return boolean true if resource type instance has bag property else false
*/
public function hasBagProperty(&$arrayToDetectLoopInComplexType)
{
// Note: Calling this method will initialize _bagProperties
// and _hasBagProperty flag to a boolean value
// from null depending on the current state of
// _propertiesDeclaredOnThisType array, so method
// should be called only after adding all properties
if (is_null($this->_hasBagProperty)) {
if ($this->_baseType != null && $this->_baseType->hasBagProperty($arrayToDetectLoopInComplexType)) {
$this->_hasBagProperty = true;
} else {
foreach ($this->_propertiesDeclaredOnThisType as $resourceProperty) {
$hasBagInComplex = false;
if ($resourceProperty->isKindOf(ResourcePropertyKind::COMPLEX_TYPE)) {
//We can say current ResouceType ("this")
//is contains a bag property if:
//1. It contain a property of kind bag.
//2. It contains a normal complex property
//with a sub property of kind bag.
//The second case can be further expanded, i.e.
//if the normal complex property
//has a normal complex sub property with a
//sub property of kind bag.
//So for complex type we recursively call this
//function to check for bag.
//Shown below how looping can happen in complex type:
//Customer ResourceType (id1)
//{
// ....
// Address: Address ResourceType (id2)
// {
// .....
// AltAddress: Address ResourceType (id2)
// {
// ...
// }
// }
//}
//
//Here the resource type of Customer::Address and
//Customer::Address::AltAddress
//are same, this is a loop, we need to detect
//this and avoid infinite recursive loop.
//
$count = count($arrayToDetectLoopInComplexType);
$foundLoop = false;
for ($i = 0; $i < $count; $i++) {
if ($arrayToDetectLoopInComplexType[$i] === $resourceProperty->getResourceType()) {
$foundLoop = true;
break;
}
}
if (!$foundLoop) {
$arrayToDetectLoopInComplexType[$count] = $resourceProperty->getResourceType();
$hasBagInComplex = $resourceProperty->getResourceType()->hasBagProperty($arrayToDetectLoopInComplexType);
unset($arrayToDetectLoopInComplexType[$count]);
}
}
if ($resourceProperty->isKindOf(ResourcePropertyKind::BAG) || $hasBagInComplex) {
$this->_hasBagProperty = true;
break;
}
}
}
}
return $this->_hasBagProperty;
}
/**
* test ResourceType class
*/
public function testResourceType()
{
try {
$exceptionThrown = false;
try {
ResourceType::getPrimitiveResourceType(TypeCode::VOID);
} catch (\InvalidArgumentException $exception) {
$exceptionThrown = true;
$this->assertStringEndsWith('is not a valid EdmPrimitiveType Enum value', $exception->getMessage());
}
if (!$exceptionThrown) {
$this->fail('An expected InvalidArgumentException for \'EdmPrimitiveType\' has not been raised');
}
$int16ResType = new ResourceType(new Int16(), ResourceTypeKind::PRIMITIVE, 'Int16', 'Edm');
$exceptionThrown = false;
try {
$int32ResType = new ResourceType(new Int32(), ResourceTypeKind::PRIMITIVE, 'Int32', 'Edm', $int16ResType);
} catch (\InvalidArgumentException $exception) {
$this->AssertEquals('Primitive type cannot have base type', $exception->getMessage());
$exceptionThrown = true;
}
if (!$exceptionThrown) {
$this->fail('An expected InvalidArgumentException for \'basetype\' has not been raised');
}
$exceptionThrown = false;
try {
$int32ResType = new ResourceType(new Int32(), ResourceTypeKind::PRIMITIVE, 'Int32', 'Edm', null, true);
} catch (\InvalidArgumentException $exception) {
$this->AssertEquals('Primitive type cannot be abstract', $exception->getMessage());
$exceptionThrown = true;
}
if (!$exceptionThrown) {
$this->fail('An expected InvalidArgumentException for \'abstract\' has not been raised');
}
$exceptionThrown = false;
try {
$int32ResType = new ResourceType(null, ResourceTypeKind::PRIMITIVE, 'Int32', 'Edm');
} catch (\InvalidArgumentException $exception) {
$this->assertStringEndsWith('should be an \'IType\' implementor instance', $exception->getMessage());
$exceptionThrown = true;
}
if (!$exceptionThrown) {
$this->fail('An expected InvalidArgumentException for \'IType\' has not been raised');
}
$exceptionThrown = false;
try {
$customerResType = new ResourceType(null, ResourceTypeKind::ENTITY, 'Customer', 'Northwind');
} catch (\InvalidArgumentException $exception) {
$this->assertStringEndsWith('argument should be an \'ReflectionClass\' instance', $exception->getMessage());
$exceptionThrown = true;
}
if (!$exceptionThrown) {
$this->fail('An expected InvalidArgumentException for \'ReflectionClass\' has not been raised');
}
$customerResType = new ResourceType(new ReflectionClass('Customer2'), ResourceTypeKind::ENTITY, 'Customer', 'Northwind');
$this->AssertEquals($customerResType->getName(), 'Customer');
$this->AssertEquals($customerResType->getFullName(), 'Northwind.Customer');
$this->assertTrue($customerResType->getInstanceType() instanceof \ReflectionClass);
$this->AssertEquals($customerResType->getNamespace(), 'Northwind');
$this->AssertEquals($customerResType->getResourceTypeKind(), ResourceTypeKind::ENTITY);
$this->AssertEquals($customerResType->isMediaLinkEntry(), false);
$exceptionThrown = false;
try {
$customerResType->validateType();
} catch (InvalidOperationException $exception) {
$this->assertStringEndsWith('Please make sure the key properties are defined for this entity type', $exception->getMessage());
$exceptionThrown = true;
}
if (!$exceptionThrown) {
$this->fail('An expected InvalidOperationException for \'No key defined\' has not been raised');
}
$exceptionThrown = false;
try {
$int32ResourceType = ResourceType::getPrimitiveResourceType(EdmPrimitiveType::INT32);
$primitiveResourceType = ResourceType::getPrimitiveResourceType(EdmPrimitiveType::STRING);
$testProperty = new ResourceProperty('test', null, ResourcePropertyKind::PRIMITIVE, $primitiveResourceType);
$int32ResourceType->addProperty($testProperty);
} catch (InvalidOperationException $exception) {
$this->assertStringEndsWith('ResourceType instances with a ResourceTypeKind equal to \'Primitive\'', $exception->getMessage());
$exceptionThrown = true;
}
if (!$exceptionThrown) {
$this->fail('An expected InvalidOperationException for \'property on primitive\' has not been raised');
}
$stringResourceType = ResourceType::getPrimitiveResourceType(EdmPrimitiveType::STRING);
$customerIDPrimProperty = new ResourceProperty('CustomerID', null, ResourcePropertyKind::PRIMITIVE | ResourcePropertyKind::KEY, $stringResourceType);
$customerNamePrimProperty = new ResourceProperty('CustomerName', null, ResourcePropertyKind::PRIMITIVE, $stringResourceType);
$intResourceType = ResourceType::getPrimitiveResourceType(EdmPrimitiveType::INT32);
$ratingPrimProperty = new ResourceProperty('Rating', null, ResourcePropertyKind::PRIMITIVE, $intResourceType);
$addressResType = new ResourceType(new ReflectionClass('Address2'), ResourceTypeKind::COMPLEX, 'Address', 'Northwind');
$exceptionThrown = false;
try {
$booleanResourceType = ResourceType::getPrimitiveResourceType(EdmPrimitiveType::BOOLEAN);
$isPrimaryPrimProperty = new ResourceProperty('IsPrimary', null, ResourcePropertyKind::PRIMITIVE | ResourcePropertyKind::KEY, $booleanResourceType);
$addressResType->addProperty($isPrimaryPrimProperty);
} catch (InvalidOperationException $exception) {
$this->assertStringEndsWith('ResourceType instances with a ResourceTypeKind equal to \'EntityType\'', $exception->getMessage());
$exceptionThrown = true;
}
if (!$exceptionThrown) {
$this->fail('An expected InvalidOperationException for \'Key on non-entity\' has not been raised');
}
$booleanResourceType = ResourceType::getPrimitiveResourceType(EdmPrimitiveType::BOOLEAN);
$isPrimaryPrimProperty = new ResourceProperty('IsPrimary', null, ResourcePropertyKind::PRIMITIVE, $booleanResourceType);
$addressResType->addProperty($isPrimaryPrimProperty);
$exceptionThrown = false;
try {
$addressResType->addProperty($isPrimaryPrimProperty);
} catch (InvalidOperationException $exception) {
$this->assertStringStartsWith('Property with same name \'IsPrimary\' already exists in type \'Address\'', $exception->getMessage());
$exceptionThrown = true;
}
if (!$exceptionThrown) {
$this->fail('An expected InvalidArgumentException for \'Property duplication\' has not been raised');
}
$exceptionThrown = false;
try {
$addressResType->setMediaLinkEntry(true);
} catch (InvalidOperationException $exception) {
$exceptionThrown = true;
$this->assertStringStartsWith('Cannot apply the HasStreamAttribute', $exception->getMessage());
}
if (!$exceptionThrown) {
$this->fail('An expected InvalidOperationException for \'MLE on non-entity\' has not been raised');
}
$customerAdrComplexType = new ResourceProperty('Address', null, ResourcePropertyKind::COMPLEX_TYPE, $addressResType);
$customerResType->addProperty($customerIDPrimProperty);
$customerResType->addProperty($customerNamePrimProperty);
$customerResType->addProperty($ratingPrimProperty);
$customerResType->addProperty($customerAdrComplexType);
$customerResType->validateType();
$customerProperties = $customerResType->getPropertiesDeclaredOnThisType();
$this->AssertEquals(count($customerProperties), 4);
$customerAllProperties = $customerResType->getAllProperties();
$this->AssertEquals(count($customerProperties), count($customerAllProperties));
$keys = array('CustomerID', 'CustomerName', 'Rating', 'Address');
$i = 0;
foreach ($customerAllProperties as $key => $customerProperty) {
$this->AssertEquals($key, $keys[$i++]);
}
$entityKeys = array('CustomerID');
$customerKeyProperties = $customerResType->getKeyProperties();
$i = 0;
foreach ($customerKeyProperties as $key => $customerKeyProperty) {
$this->AssertEquals($key, $entityKeys[$i++]);
}
$this->AssertEquals(count($customerResType->getETagProperties()), 0);
$this->AssertEquals($customerResType->tryResolvePropertyTypeByName('PropNotExists'), null);
$property = $customerResType->tryResolvePropertyTypeByName('CustomerName');
$this->AssertNotEquals($property, null);
$this->AssertEquals($property->getName(), 'CustomerName');
$employeeResType = new ResourceType(new ReflectionClass('Employee2'), ResourceTypeKind::ENTITY, 'Employee', 'Northwind');
$stringResourceType = ResourceType::getPrimitiveResourceType(EdmPrimitiveType::STRING);
$employeeResType->addProperty(new ResourceProperty('EmployeeID', null, ResourcePropertyKind::PRIMITIVE | ResourcePropertyKind::KEY, $stringResourceType));
$employeeResType->addProperty(new ResourceProperty('Emails', null, ResourcePropertyKind::PRIMITIVE | ResourcePropertyKind::BAG, $stringResourceType));
$employeeResType->setMediaLinkEntry(true);
$employeeResType->addNamedStream(new ResourceStreamInfo('ThumNail_64X64'));
$exceptionThrown = false;
try {
$employeeResType->addNamedStream(new ResourceStreamInfo('ThumNail_64X64'));
} catch (InvalidOperationException $exception) {
$exceptionThrown = true;
$this->assertStringStartsWith('Named stream with the name \'ThumNail_64X64\' already exists in type \'Employee\'', $exception->getMessage());
}
if (!$exceptionThrown) {
$this->fail('An expected InvalidOperationException for \'named stream duplication\' has not been raised');
}
$this->AssertEquals($employeeResType->hasNamedStream(), true);
$b = array();
$this->AssertEquals($employeeResType->hasBagProperty($b), true);
$namedStreams = $employeeResType->getAllNamedStreams();
$this->AssertEquals(count($namedStreams), 1);
$this->AssertTrue(array_key_exists('ThumNail_64X64', $namedStreams));
$name = $employeeResType->tryResolveNamedStreamByName('ThumNail_64X64')->getName();
$this->AssertEquals($name, 'ThumNail_64X64');
} catch (\Exception $exception) {
$this->fail('An unexpected Exception has been raised' . $exception->getMessage());
}
}