Esempio n. 1
0
 public function initialize(ServiceConfiguration $config)
 {
     $config->setEntitySetPageSize('*', $this->maxPageSize);
     $config->setEntitySetAccessRule('*', EntitySetRights::ALL);
     $config->setAcceptCountRequests(true);
     $config->setAcceptProjectionRequests(true);
 }
Esempio n. 2
0
 /**
  * This method is called only once to initialize service-wide policies
  * 
  * @param ServiceConfiguration $config Data service configuration object
  * 
  * @return void
  */
 public function initialize(ServiceConfiguration $config)
 {
     $config->setEntitySetPageSize('*', 5);
     $config->setEntitySetAccessRule('*', EntitySetRights::ALL);
     $config->setAcceptCountRequests(true);
     $config->setAcceptProjectionRequests(true);
     $config->setMaxDataServiceVersion(ProtocolVersion::V3());
 }
Esempio n. 3
0
 /**
  * Test search InternalSkipTokenInfo::GetIndexOfFirstEntryInNextPage function
  */
 public function testGetIndexOfFirstEntryInNextPage2()
 {
     $this->markTestSkipped("Skipped because it depends on a query provider that isn't mocked");
     $northWindMetadata = NorthWindMetadata::Create();
     $configuration = new ServiceConfiguration($northWindMetadata);
     $configuration->setEntitySetAccessRule('*', EntitySetRights::ALL);
     $providersWrapper = new ProvidersWrapper($northWindMetadata, $this->mockQueryProvider, $configuration);
     $resourceSetWrapper = $providersWrapper->resolveResourceSet('Orders');
     $resourceType = $resourceSetWrapper->getResourceType();
     $orderBy = 'ShipName asc, Freight';
     //Note: library will add prim key as last sort key
     $orderBy .= ', OrderID';
     $qp = new NorthWindQueryProvider1();
     $orders = $qp->getResourceSet($resourceSetWrapper->getResourceSet());
     $internalOrderByInfo = OrderByParser::parseOrderByClause($resourceSetWrapper, $resourceType, $orderBy, $providersWrapper);
     $compFun = $internalOrderByInfo->getSorterFunction();
     $fun = $compFun->getReference();
     usort($orders, $fun);
     $numRecords = count($orders);
     //-----------------------------------------------------------------
     //Search with a key that exactly matches
     $skipToken = utf8_decode(urldecode("'Antonio%20Moreno%20Taquer%C3%ADa',22.0000M,10365"));
     $skipToken = urldecode($skipToken);
     $internalSkipTokenInfo = SkipTokenParser::parseSkipTokenClause($resourceType, $internalOrderByInfo, $skipToken);
     $nextIndex = $internalSkipTokenInfo->getIndexOfFirstEntryInTheNextPage($orders);
     $this->assertTrue($nextIndex > 1);
     $this->assertTrue($nextIndex < $numRecords);
     //$nextIndex is the index of order record next to the searched record
     $this->assertEquals($orders[$nextIndex - 1]->OrderID, 10365);
     $this->assertEquals($orders[$nextIndex - 1]->Freight, 22.0);
     //-----------------------------------------------------------------
     //Search with a key that partially matches, in the DB there is no
     //order with ShipName 'An', but there are records start with
     //'An', so partial match, since its a parial match other two
     //key wont be used for comparsion
     $skipToken = "'An',22.0000M,10365";
     $internalSkipTokenInfo = SkipTokenParser::parseSkipTokenClause($resourceType, $internalOrderByInfo, $skipToken);
     $nextIndex = $internalSkipTokenInfo->getIndexOfFirstEntryInTheNextPage($orders);
     $this->assertTrue($nextIndex > 1);
     $this->assertTrue($nextIndex < $numRecords);
     //Make sure this is the most matching record by comparing with previous record
     $prevOrder = $orders[$nextIndex - 1];
     $r = strcmp($prevOrder->ShipName, $orders[$nextIndex]->ShipName);
     $this->assertTrue($r < 0);
     //Make sure this is the most matching record by comparing with next record
     $nextOrder = $orders[$nextIndex + 1];
     $r = strcmp($nextOrder->ShipName, $orders[$nextIndex]->ShipName);
     $this->assertTrue($r >= 0);
     //-----------------------------------------------------------------
     //Search with a key that does not exists
     $skipToken = "'XXX',11,10365";
     $internalSkipTokenInfo = SkipTokenParser::parseSkipTokenClause($resourceType, $internalOrderByInfo, $skipToken);
     $nextIndex = $internalSkipTokenInfo->getIndexOfFirstEntryInTheNextPage($orders);
     $this->assertTrue($nextIndex == -1);
     //-----------------------------------------------------------------
 }
 public function testConfiguration4()
 {
     $customersResourceSet = $this->_northWindMetadata->resolveResourceSet('Customers');
     $this->assertNotNull($customersResourceSet);
     $this->AssertEquals($this->_dataServiceConfiguration->getEntitySetAccessRule($customersResourceSet), EntitySetRights::NONE);
     try {
         $this->_dataServiceConfiguration->setEntitySetAccessRule('Customers', EntitySetRights::ALL + 1);
         $this->fail('An expected InvalidOperationException for \'page size and max result per collection mutual exclusion\' was not thrown for month');
     } catch (\InvalidArgumentException $exception) {
         $this->AssertEquals('The argument \'$rights\' of \'setEntitySetAccessRule\' should be EntitySetRights enum value', $exception->getMessage());
     }
     $this->_dataServiceConfiguration->setEntitySetAccessRule('Customers', EntitySetRights::READ_ALL);
     $this->AssertEquals($this->_dataServiceConfiguration->getEntitySetAccessRule($customersResourceSet), EntitySetRights::READ_ALL);
     try {
         $this->_dataServiceConfiguration->setEntitySetAccessRule('NonExistEntitySet', EntitySetRights::READ_MULTIPLE);
         $this->fail('An expected InvalidArgumentException for \'non-exist entity set name\' was not thrown for month');
     } catch (\InvalidArgumentException $exception) {
         $this->AssertEquals('The given name \'NonExistEntitySet\' was not found in the entity sets', $exception->getMessage());
     }
 }
Esempio n. 5
0
 /**
  * This method is called only once to initialize service-wide policies
  * 
  * @param ServiceConfiguration $config
  */
 public function initialize(ServiceConfiguration $config)
 {
     $config->setEntitySetAccessRule('*', EntitySetRights::ALL);
     //we are using V1 protocol, but still we set page size because with
     //a top value which is less than pagesize we can use V1 protocol
     //even though paging is enabled.
     $config->setEntitySetPageSize('*', 5);
     $config->setAcceptCountRequests(true);
     $config->setAcceptProjectionRequests(true);
     $config->setMaxDataServiceVersion(ProtocolVersion::V1());
 }
Esempio n. 6
0
 public function testWriteMetadata()
 {
     $northWindMetadata = NorthWindMetadata::Create();
     $configuration = new ServiceConfiguration($northWindMetadata);
     $configuration->setEntitySetAccessRule("*", EntitySetRights::ALL);
     $configuration->setMaxDataServiceVersion(ProtocolVersion::V3());
     $providersWrapper = new ProvidersWrapper($northWindMetadata, $this->mockQueryProvider, $configuration, false);
     $metadataWriter = new MetadataWriter($providersWrapper);
     $metadata = $metadataWriter->writeMetadata();
     $this->assertNotNull($metadata);
     $this->assertEquals($providersWrapper->getContainerName(), 'NorthWindEntities');
     $this->assertEquals($providersWrapper->getContainerNamespace(), 'NorthWind');
     $this->assertStringStartsWith('<edmx:Edmx Version="1.0"', $metadata);
     $customerResourceSet = $providersWrapper->resolveResourceSet('Customers');
     $this->assertEquals($customerResourceSet->getName(), 'Customers');
     $this->assertEquals($customerResourceSet->getResourceType()->getName(), 'Customer');
     $customerEntityType = $providersWrapper->resolveResourceType('Customer');
     $this->assertEquals($customerEntityType->getResourceTypeKind(), ResourceTypeKind::ENTITY);
 }
Esempio n. 7
0
 public function testCreateSegments_NavigationSegment()
 {
     //Test navigation segment followed by primitve property
     $segments = array("Customers(CustomerID='ALFKI', CustomerGuid=guid'15b242e7-52eb-46bd-8f0e-6568b72cd9a6')", 'Orders(789)', 'Customer', 'CustomerName');
     $segmentDescriptors = SegmentParser::parseRequestUriSegments($segments, $this->providersWrapper);
     $this->assertEquals(count($segmentDescriptors), 4);
     $this->assertEquals($segmentDescriptors[0]->getIdentifier(), 'Customers');
     $this->assertEquals($segmentDescriptors[1]->getIdentifier(), 'Orders');
     $this->assertEquals($segmentDescriptors[2]->getIdentifier(), 'Customer');
     $this->assertEquals($segmentDescriptors[3]->getIdentifier(), 'CustomerName');
     $keyDescriptor = $segmentDescriptors[0]->getKeyDescriptor();
     $this->assertFalse(is_null($keyDescriptor));
     $keyDescriptor = $segmentDescriptors[1]->getKeyDescriptor();
     $this->assertFalse(is_null($keyDescriptor));
     $keyDescriptor = $segmentDescriptors[2]->getKeyDescriptor();
     $this->assertTrue(is_null($keyDescriptor));
     $keyDescriptor = $segmentDescriptors[3]->getKeyDescriptor();
     $this->assertTrue(is_null($keyDescriptor));
     $keyDescriptor = $segmentDescriptors[0]->getKeyDescriptor();
     $this->assertEquals($keyDescriptor->valueCount(), 2);
     $namedKeyValues = $keyDescriptor->getValidatedNamedValues();
     $this->assertTrue(array_key_exists('CustomerID', $namedKeyValues));
     $this->assertTrue(array_key_exists('CustomerGuid', $namedKeyValues));
     $this->assertEquals($namedKeyValues['CustomerID'][0], '\'ALFKI\'');
     $this->assertEquals($namedKeyValues['CustomerGuid'][0], '\'15b242e7-52eb-46bd-8f0e-6568b72cd9a6\'');
     $keyDescriptor = $segmentDescriptors[1]->getKeyDescriptor();
     $this->assertEquals($keyDescriptor->valueCount(), 1);
     $namedKeyValues = $keyDescriptor->getValidatedNamedValues();
     $this->assertTrue(array_key_exists('OrderID', $namedKeyValues));
     $this->assertEquals($namedKeyValues['OrderID'][0], 789);
     $this->assertEquals($segmentDescriptors[0]->getTargetKind(), TargetKind::RESOURCE());
     $this->assertEquals($segmentDescriptors[1]->getTargetKind(), TargetKind::RESOURCE());
     $this->assertEquals($segmentDescriptors[2]->getTargetKind(), TargetKind::RESOURCE());
     $this->assertEquals($segmentDescriptors[3]->getTargetKind(), TargetKind::PRIMITIVE());
     $this->assertEquals($segmentDescriptors[0]->getTargetSource(), TargetSource::ENTITY_SET);
     $this->assertEquals($segmentDescriptors[1]->getTargetSource(), TargetSource::PROPERTY);
     $this->assertEquals($segmentDescriptors[2]->getTargetSource(), TargetSource::PROPERTY);
     $this->assertEquals($segmentDescriptors[3]->getTargetSource(), TargetSource::PROPERTY);
     $resourceSetWrapper = $segmentDescriptors[0]->getTargetResourcesetWrapper();
     $this->assertFalse(is_null($resourceSetWrapper));
     $resourceSetWrapper = $segmentDescriptors[1]->getTargetResourcesetWrapper();
     $this->assertFalse(is_null($resourceSetWrapper));
     $resourceSetWrapper = $segmentDescriptors[2]->getTargetResourcesetWrapper();
     $this->assertFalse(is_null($resourceSetWrapper));
     $resourceSetWrapper = $segmentDescriptors[3]->getTargetResourcesetWrapper();
     $this->assertTrue(is_null($resourceSetWrapper));
     $this->assertTrue($segmentDescriptors[0]->isSingleResult());
     $this->assertTrue($segmentDescriptors[0]->isSingleResult());
     $this->assertTrue($segmentDescriptors[0]->isSingleResult());
     $this->assertTrue($segmentDescriptors[0]->isSingleResult());
     //Test invisible navigation segment
     //Creates a provider wrapper for NorthWind service with 'Orders' entity set as invisible
     $metadataProvider = NorthWindMetadata::Create();
     $serviceConfiguration = new ServiceConfiguration($this->_metadataProvider);
     $serviceConfiguration->setEntitySetAccessRule('Customers', EntitySetRights::READ_ALL);
     $serviceConfiguration->setEntitySetAccessRule('Orders', EntitySetRights::NONE);
     $providersWrapper = new ProvidersWrapper($metadataProvider, $this->mockQueryProvider, $serviceConfiguration, false);
     $segments = array("Customers(CustomerID='ALFKI', CustomerGuid=guid'15b242e7-52eb-46bd-8f0e-6568b72cd9a6')", 'Orders(789)', 'OrderID');
     try {
         SegmentParser::parseRequestUriSegments($segments, $providersWrapper);
         $this->fail('An expected ODataException for \'Orders\' resource not found error has not been thrown');
     } catch (ODataException $exception) {
         $this->assertEquals('Resource not found for the segment \'Orders\'', $exception->getMessage());
     }
 }
Esempio n. 8
0
 /**
  * Test whether order by parser identify and remove path duplication
  */
 public function testOrderByWithPathDuplication()
 {
     $northWindMetadata = NorthWindMetadata::Create();
     $configuration = new ServiceConfiguration($northWindMetadata);
     $configuration->setEntitySetAccessRule('*', EntitySetRights::ALL);
     $providersWrapper = new ProvidersWrapper($northWindMetadata, $this->mockQueryProvider, $configuration, false);
     $resourceSetWrapper = $providersWrapper->resolveResourceSet('Order_Details');
     $resourceType = $resourceSetWrapper->getResourceType();
     $orderBy = 'Order/Price desc, Product/ProductName asc, Order/Price asc';
     $internalOrderInfo = OrderByParser::parseOrderByClause($resourceSetWrapper, $resourceType, $orderBy, $providersWrapper);
     //The orderby path Order/Price appears twice, but parser will consider only first path
     $orderByInfo = $internalOrderInfo->getOrderByInfo();
     //There are navigation (resource reference) properties in the orderby path so getNavigationPropertiesUsed should
     //not be null
     $naviUsed = $orderByInfo->getNavigationPropertiesUsed();
     $this->assertFalse(is_null($naviUsed));
     //3 path segment are there, but last one is duplicate of first one, so parser removes last one
     $this->assertEquals(count($naviUsed), 2);
     $this->assertTrue(is_array($naviUsed[0]));
     $this->assertTrue(is_array($naviUsed[1]));
     //one navgations used in first orderby 'Order'
     $this->assertEquals(count($naviUsed[0]), 1);
     //one navgations used in second orderby 'Prodcut'
     $this->assertEquals(count($naviUsed[1]), 1);
     $this->assertEquals($naviUsed[0][0]->getName(), 'Order');
     $this->assertEquals($naviUsed[1][0]->getName(), 'Product');
     $orderByPathSegments = $orderByInfo->getOrderByPathSegments();
     $this->assertEquals(count($orderByPathSegments), 2);
 }
Esempio n. 9
0
 /**
  * One can expand a navigation property only if corresponding resource set is visible
  * 
  */
 public function testExpandWithNonVisibleResourceSet()
 {
     $northWindMetadata = NorthWindMetadata::Create();
     $queryProvider = new NorthWindQueryProvider();
     $configuration = new ServiceConfiguration($northWindMetadata);
     //Make 'Customers' and 'Orders' visible, make 'Order_Details' invisible
     $configuration->setEntitySetAccessRule('Customers', EntitySetRights::ALL);
     $configuration->setEntitySetAccessRule('Orders', EntitySetRights::ALL);
     $providersWrapper = new ProvidersWrapper($northWindMetadata, $queryProvider, $configuration, false);
     $customersResourceSetWrapper = $providersWrapper->resolveResourceSet('Customers');
     $customerResourceType = $customersResourceSetWrapper->getResourceType();
     $exceptionThrown = false;
     try {
         $projectionTree = ExpandProjectionParser::parseExpandAndSelectClause($customersResourceSetWrapper, $customerResourceType, null, null, null, 'Orders/Order_Details', null, $providersWrapper);
         $this->fail('An expected ODataException for navigation to invisible resource set has not been thrown');
     } catch (ODataException $odataException) {
         $this->assertStringEndsWith("(Check the resource set of the navigation property 'Order_Details' is visible)", $odataException->getMessage());
     }
 }
Esempio n. 10
0
 /**
  * test the creation of nextlink from an object.
  * Test building of link with guid sub-value
  */
 public function testCreationOfNextLink4()
 {
     $northWindMetadata = NorthWindMetadata::Create();
     $configuration = new ServiceConfiguration($northWindMetadata);
     $configuration->setEntitySetAccessRule('*', EntitySetRights::ALL);
     $providersWrapper = new ProvidersWrapper($northWindMetadata, $this->mockQueryProvider, $configuration, false);
     $resourceSetWrapper = $providersWrapper->resolveResourceSet('Customers');
     $resourceType = $resourceSetWrapper->getResourceType();
     $orderBy = 'CustomerID, CustomerGuid';
     $internalOrderByInfo = OrderByParser::parseOrderByClause($resourceSetWrapper, $resourceType, $orderBy, $providersWrapper);
     $skipToken = "null, guid'05b242e752eb46bd8f0e6568b72cd9a5'";
     $internalSkipTokenInfo = SkipTokenParser::parseSkipTokenClause($resourceType, $internalOrderByInfo, $skipToken);
     $keyObject = $internalSkipTokenInfo->getKeyObject();
     $lastObject = new Customer2();
     $lastObject->CustomerID = 'ABC';
     $lastObject->CustomerGuid = '{05b242e7-52eb-46bd-8f0e-6568b72cd9a5}';
     $nextLink = $internalSkipTokenInfo->buildNextPageLink($lastObject);
     $this->assertEquals($nextLink, "'ABC', guid'%7B05b242e7-52eb-46bd-8f0e-6568b72cd9a5%7D'");
 }
Esempio n. 11
0
 /**
  * If last sub path segment specified in the select clause does not appear in the prjection tree,
  * then parser will create 'ProjectionNode' for them
  */
 public function testProjectionNodeCreation()
 {
     $northWindMetadata = NorthWindMetadata::Create();
     $queryProvider = new NorthWindQueryProvider();
     $configuration = new ServiceConfiguration($northWindMetadata);
     $configuration->setEntitySetAccessRule('*', EntitySetRights::ALL);
     $providersWrapper = new ProvidersWrapper($northWindMetadata, $queryProvider, $configuration, false);
     $ordersResourceSetWrapper = $providersWrapper->resolveResourceSet('Orders');
     $orderResourceType = $ordersResourceSetWrapper->getResourceType();
     //test selection of properties which is not included in expand clause
     //1 primitve ('Order_Details/UnitPrice') and 1 link to navigation 'Customer'
     $projectionTreeRoot = ExpandProjectionParser::parseExpandAndSelectClause($ordersResourceSetWrapper, $orderResourceType, null, null, null, 'Order_Details', 'Order_Details/UnitPrice, Customer', $providersWrapper);
     //expand option is absent
     $this->assertTrue($projectionTreeRoot->isExpansionSpecified());
     //select is applied
     $this->assertTrue($projectionTreeRoot->isSelectionSpecified());
     $this->assertFalse($projectionTreeRoot->canSelectAllImmediateProperties());
     $this->assertFalse($projectionTreeRoot->canSelectAllProperties());
     //there are 2 child nodes for the root
     $this->assertEquals(count($projectionTreeRoot->getChildNodes()), 2);
     //The child nodes one 'ProjectionNode' Customer and one 'ExpandedProjectionNode' for 'Order'
     $childNodes = $projectionTreeRoot->getChildNodes();
     $this->assertTrue(array_key_exists('Order_Details', $childNodes));
     $this->assertTrue(array_key_exists('Customer', $childNodes));
     $this->assertTrue($childNodes['Order_Details'] instanceof ExpandedProjectionNode);
     $this->assertTrue($childNodes['Customer'] instanceof ProjectionNode);
     //'Order_Detials' has a child node
     $childNodes = $childNodes['Order_Details']->getChildNodes();
     $this->assertEquals(count($childNodes), 1);
     $this->assertTrue(array_key_exists('UnitPrice', $childNodes));
     $this->assertTrue($childNodes['UnitPrice'] instanceof ProjectionNode);
 }