public static function tearDownAfterClass()
{
parent::tearDownAfterClass();
$service = self::createService();
if (!Configuration::isEmulated()) {
$serviceProperties = QueueServiceFunctionalTestData::getDefaultServiceProperties();
$service->setServiceProperties($serviceProperties);
}
foreach (QueueServiceFunctionalTestData::$TEST_QUEUE_NAMES as $name) {
self::staticSafeDeleteQueue($service, $name);
}
}
public static function setUpBeforeClass()
{
if (Configuration::isEmulated()) {
throw new \Exception(self::NOT_SUPPORTED);
}
$subscriptionId = TestResources::serviceManagementSubscriptionId();
$certificatePath = TestResources::serviceManagementCertificatePath();
if (empty($subscriptionId)) {
throw new \Exception('SERVICE_MANAGEMENT_SUBSCRIPTION_ID envionment variable is missing');
}
if (empty($certificatePath)) {
throw new \Exception('SERVICE_MANAGEMENT_CERTIFICATE_PATH envionment variable is missing');
}
}
public static function tearDownAfterClass()
{
parent::tearDownAfterClass();
$service = self::createService();
if (!Configuration::isEmulated()) {
$serviceProperties = TableServiceFunctionalTestData::getDefaultServiceProperties();
$service->setServiceProperties($serviceProperties);
}
foreach (TableServiceFunctionalTestData::$TEST_TABLE_NAMES as $name) {
try {
$service->deleteTable($name);
} catch (\Exception $e) {
// Ignore exception and continue.
error_log($e->getMessage());
}
}
}
/**
* @covers WindowsAzure\Table\TableRestProxy::insertOrReplaceEntity
*/
public function testInsertOrReplaceEntityOptionsNull()
{
$table = TableServiceFunctionalTestData::$TEST_TABLE_NAMES[0];
try {
$this->restProxy->insertOrReplaceEntity($table, TableServiceFunctionalTestData::getSimpleEntity(), null);
$this->assertFalse(Configuration::isEmulated(), 'Should fail if and only if in emulator');
} catch (ServiceException $e) {
// Expect failure when run this test with emulator, as v1.6 doesn't support this method
if (Configuration::isEmulated()) {
$this->assertEquals(404, $e->getCode(), 'getCode');
}
}
$this->clearTable($table);
}
protected function skipIfEmulated()
{
if (Configuration::isEmulated()) {
$this->markTestSkipped(self::NOT_SUPPORTED);
}
}
private function setServicePropertiesWorker($serviceProperties, $options)
{
try {
if (is_null($options)) {
$this->restProxy->setServiceProperties($serviceProperties);
} else {
$this->restProxy->setServiceProperties($serviceProperties, $options);
}
if (is_null($options)) {
$options = new QueueServiceOptions();
}
if (!is_null($options->getTimeout()) && $options->getTimeout() < 1) {
$this->assertTrue(false, 'Expect negative timeouts in $options to throw');
} else {
$this->assertFalse(Configuration::isEmulated(), 'Should succeed when not running in emulator');
}
$ret = is_null($options) ? $this->restProxy->getServiceProperties() : $this->restProxy->getServiceProperties($options);
$this->verifyServicePropertiesWorker($ret, $serviceProperties);
} catch (ServiceException $e) {
if (is_null($options)) {
$options = new QueueServiceOptions();
}
if (Configuration::isEmulated()) {
if (!is_null($options->getTimeout()) && $options->getTimeout() < 1) {
$this->assertEquals(500, $e->getCode(), 'getCode');
} else {
$this->assertEquals(400, $e->getCode(), 'getCode');
}
} else {
if (!is_null($options->getTimeout()) && $options->getTimeout() < 1) {
$this->assertEquals(500, $e->getCode(), 'getCode');
} else {
$this->assertNull($e, 'Expect positive timeouts in $options to be fine');
}
}
}
}
private function verifySetContainerACLWorker($ret, $container, $acl, $blobContent)
{
$this->assertNotNull($ret->getContainerACL(), '$ret->getContainerACL');
$this->assertNotNull($ret->getEtag(), '$ret->getContainerACL->getEtag');
$now = new \DateTime();
$this->assertTrue(BlobServiceFunctionalTestData::diffInTotalSeconds($ret->getLastModified(), $now) < 10000, 'Last modified date (' . $ret->getLastModified()->format(\DateTime::RFC1123) . ') ' . 'should be within 10 seconds of $now (' . $now->format(\DateTime::RFC1123) . ')');
$this->assertNotNull($ret->getContainerACL()->getSignedIdentifiers(), '$ret->getContainerACL->getSignedIdentifiers');
$this->assertEquals(is_null($acl->getPublicAccess()) ? '' : $acl->getPublicAccess(), $ret->getContainerACL()->getPublicAccess(), '$ret->getContainerACL->getPublicAccess');
$expIds = $acl->getSignedIdentifiers();
$actIds = $ret->getContainerACL()->getSignedIdentifiers();
$this->assertEquals(count($expIds), count($actIds), '$ret->getContainerACL->getSignedIdentifiers');
for ($i = 0; $i < count($expIds); $i++) {
$expId = $expIds[$i];
$actId = $actIds[$i];
$this->assertEquals($expId->getId(), $actId->getId(), 'SignedIdentifiers[' + $i + ']->getId');
$this->assertEquals($expId->getAccessPolicy()->getPermission(), $actId->getAccessPolicy()->getPermission(), 'SignedIdentifiers[' + $i + ']->getAccessPolicy->getPermission');
$this->assertTrue(BlobServiceFunctionalTestData::diffInTotalSeconds($expId->getAccessPolicy()->getStart(), $actId->getAccessPolicy()->getStart()) < 1, 'SignedIdentifiers[' + $i + ']->getAccessPolicy->getStart should match within 1 second, ' . 'exp=' . $expId->getAccessPolicy()->getStart()->format(\DateTime::RFC1123) . ', ' . 'act=' . $actId->getAccessPolicy()->getStart()->format(\DateTime::RFC1123));
$this->assertTrue(BlobServiceFunctionalTestData::diffInTotalSeconds($expId->getAccessPolicy()->getExpiry(), $actId->getAccessPolicy()->getExpiry()) < 1, 'SignedIdentifiers[' + $i + ']->getAccessPolicy->getExpiry should match within 1 second, ' . 'exp=' . $expId->getAccessPolicy()->getExpiry()->format(\DateTime::RFC1123) . ', ' . 'act=' . $actId->getAccessPolicy()->getExpiry()->format(\DateTime::RFC1123));
}
if (!Configuration::isEmulated()) {
$containerAddress = $this->config->getProperty(BlobSettings::URI) . '/' . $container;
$blobListAddress = $containerAddress . '?restype=container&comp=list';
$blobAddress = $containerAddress . '/test';
$canDownloadBlobList = $this->canDownloadFromUrl($blobListAddress, "<?xml version=\"1.0\" encoding=\"utf-8\"?" . "><EnumerationResults");
$canDownloadBlob = $this->canDownloadFromUrl($blobAddress, $blobContent);
if (!is_null($acl->getPublicAccess()) && $acl->getPublicAccess() == PublicAccessType::CONTAINER_AND_BLOBS) {
// Full public read access: Container and blob data can be read via anonymous request.
// Clients can enumerate blobs within the $container via anonymous request,
// but cannot enumerate containers within the storage account.
$this->assertTrue($canDownloadBlobList, '$canDownloadBlobList when ' . $acl->getPublicAccess());
$this->assertTrue($canDownloadBlob, '$canDownloadBlob when ' . $acl->getPublicAccess());
} else {
if (!is_null($acl->getPublicAccess()) && $acl->getPublicAccess() == PublicAccessType::BLOBS_ONLY) {
// Public read access for blobs only: Blob data within this container
// can be read via anonymous request, but $container data is not available.
// Clients cannot enumerate blobs within the $container via anonymous request.
$this->assertFalse($canDownloadBlobList, '$canDownloadBlobList when ' . $acl->getPublicAccess());
$this->assertTrue($canDownloadBlob, '$canDownloadBlob when ' . $acl->getPublicAccess());
} else {
// No public read access: Container and blob data can be read by the account owner only.
$this->assertFalse($canDownloadBlobList, '$canDownloadBlobList when ' . $acl->getPublicAccess());
$this->assertFalse($canDownloadBlob, '$canDownloadBlob when ' . $acl->getPublicAccess());
}
}
}
}
/**
* @covers WindowsAzure\Table\TableRestProxy::batch
* @covers WindowsAzure\Table\TableRestProxy::insertEntity
*/
private function batchPositiveOuter($firstConcurType, $seed)
{
// The random here is not to generate random values, but to
// get a good mix of values in the table entities.
mt_srand($seed);
$concurTypes = ConcurType::values();
$mutatePivots = MutatePivot::values();
$opTypes = OpType::values();
// Main loop.
foreach ($opTypes as $firstOpType) {
if (!is_null($this->expectConcurrencyFailure($firstOpType, $firstConcurType))) {
// Want to know there is at least one part that does not fail.
continue;
}
if (Configuration::isEmulated() && ($firstOpType == OpType::insertOrMergeEntity || $firstOpType == OpType::insertOrReplaceEntity)) {
// Emulator does not support these operations.
continue;
}
$simpleEntities = TableServiceFunctionalTestData::getSimpleEntities(6);
$configs = array();
$firstConfig = new BatchWorkerConfig();
$firstConfig->concurType = $firstConcurType;
$firstConfig->opType = $firstOpType;
$firstConfig->ent = $simpleEntities[0];
$firstConfig->mutatePivot = $mutatePivots[mt_rand(0, count($mutatePivots))];
array_push($configs, $firstConfig);
for ($i = 1; $i < count($simpleEntities); $i++) {
$config = new BatchWorkerConfig();
while (!is_null($this->expectConcurrencyFailure($config->opType, $config->concurType))) {
$config->concurType = $concurTypes[mt_rand(0, count($concurTypes))];
$config->opType = $opTypes[mt_rand(0, count($opTypes))];
if (Configuration::isEmulated()) {
if ($config->opType == OpType::insertOrMergeEntity) {
$config->opType = OpType::mergeEntity;
}
if ($config->opType == OpType::insertOrReplaceEntity) {
$config->opType = OpType::updateEntity;
}
}
}
$config->mutatePivot = $mutatePivots[mt_rand(0, count($mutatePivots) - 1)];
$config->ent = $simpleEntities[$i];
array_push($configs, $config);
}
for ($i = 0; $i <= 1; $i++) {
$options = $i == 0 ? null : new TableServiceOptions();
if (Configuration::isEmulated()) {
// The emulator has trouble with some batches.
for ($j = 0; $j < count($configs); $j++) {
$tmpconfigs = array();
$tmpconfigs[] = $configs[$j];
$this->batchWorker($tmpconfigs, $options);
}
} else {
$this->batchWorker($configs, $options);
}
}
}
}
static function getInterestingQueryTablesOptions()
{
$ret = array();
$options = new QueryTablesOptions();
array_push($ret, $options);
$options = new QueryTablesOptions();
$options->setTop(2);
$options->setPrefix(self::$nonExistTablePrefix);
array_push($ret, $options);
$options = new QueryTablesOptions();
$options->setTop(-2);
array_push($ret, $options);
$options = new QueryTablesOptions();
$filter = Filter::applyEq(Filter::applyConstant(self::$TEST_TABLE_NAMES[1]), Filter::applyPropertyName('TableName'));
$options->setFilter($filter);
array_push($ret, $options);
$options = new QueryTablesOptions();
$filter = Filter::applyEq(Filter::applyConstant(self::$TEST_TABLE_NAMES[2]), Filter::applyPropertyName('TableName'));
$options->setFilter($filter);
array_push($ret, $options);
$options = new QueryTablesOptions();
$filter = Filter::applyAnd(Filter::applyEq(Filter::applyConstant(self::$TEST_TABLE_NAMES[1]), Filter::applyPropertyName('TableName')), Filter::applyEq(Filter::applyConstant(self::$TEST_TABLE_NAMES[2]), Filter::applyPropertyName('TableName')));
$options->setFilter($filter);
array_push($ret, $options);
$options = new QueryTablesOptions();
$filter = Filter::applyAnd(Filter::applyGe(Filter::applyPropertyName('TableName'), Filter::applyConstant(self::$TEST_TABLE_NAMES[1])), Filter::applyLe(Filter::applyPropertyName('TableName'), Filter::applyConstant(self::$TEST_TABLE_NAMES[2])));
$options->setFilter($filter);
array_push($ret, $options);
$options = new QueryTablesOptions();
$filter = Filter::applyOr(Filter::applyGe(Filter::applyPropertyName('TableName'), Filter::applyConstant(self::$TEST_TABLE_NAMES[1])), Filter::applyGe(Filter::applyPropertyName('TableName'), Filter::applyConstant(self::$TEST_TABLE_NAMES[2])));
$options->setFilter($filter);
array_push($ret, $options);
$options = new QueryTablesOptions();
$filter = Filter::applyAnd(Filter::applyEq(Filter::applyPropertyName('TableName'), Filter::applyConstant(self::$TEST_TABLE_NAMES[1])), Filter::applyGe(Filter::applyPropertyName('TableName'), Filter::applyConstant(self::$TEST_TABLE_NAMES[0])));
$options->setFilter($filter);
array_push($ret, $options);
$options = new QueryTablesOptions();
$filter = Filter::applyOr(Filter::applyEq(Filter::applyPropertyName('TableName'), Filter::applyConstant(self::$TEST_TABLE_NAMES[1])), Filter::applyGe(Filter::applyPropertyName('TableName'), Filter::applyConstant(self::$TEST_TABLE_NAMES[2])));
$options->setFilter($filter);
array_push($ret, $options);
$options = new QueryTablesOptions();
$filter = Filter::applyOr(Filter::applyEq(Filter::applyPropertyName('TableName'), Filter::applyConstant(self::$TEST_TABLE_NAMES[1])), Filter::applyEq(Filter::applyPropertyName('TableName'), Filter::applyConstant(self::$TEST_TABLE_NAMES[2])));
$options->setFilter($filter);
array_push($ret, $options);
$options = new QueryTablesOptions();
$filter = Filter::applyOr(Filter::applyEq(Filter::applyConstant(self::$TEST_TABLE_NAMES[1]), Filter::applyPropertyName('TableName')), Filter::applyEq(Filter::applyConstant(self::$TEST_TABLE_NAMES[2]), Filter::applyPropertyName('TableName')));
$options->setFilter($filter);
array_push($ret, $options);
$options = new QueryTablesOptions();
$options->setPrefix(self::$nonExistTablePrefix);
array_push($ret, $options);
if (!Configuration::isEmulated()) {
$options = new QueryTablesOptions();
$options->setPrefix(self::$testUniqueId);
array_push($ret, $options);
}
$options = new QueryTablesOptions();
$nextTableName = self::$TEST_TABLE_NAMES[1];
$options->setNextTableName($nextTableName);
array_push($ret, $options);
$options = new QueryTablesOptions();
$nextTableName = self::$nonExistTablePrefix;
$options->setNextTableName($nextTableName);
array_push($ret, $options);
return $ret;
}
/**
* @covers WindowsAzure\Queue\QueueRestProxy::getServiceProperties
* @covers WindowsAzure\Queue\QueueRestProxy::setServiceProperties
*/
public function testSetServicePropertiesWorks()
{
// Arrange
// Act
$shouldReturn = false;
try {
$props = $this->restProxy->getServiceProperties()->getValue();
$this->assertFalse(Configuration::isEmulated(), 'Should succeed when not running in emulator');
} catch (ServiceException $e) {
// Expect failure in emulator, as v1.6 doesn't support this method
if (Configuration::isEmulated()) {
$this->assertEquals(400, $e->getCode(), 'getCode');
$shouldReturn = true;
}
}
if ($shouldReturn) {
return;
}
$props->getLogging()->setRead(true);
$this->restProxy->setServiceProperties($props);
$props = $this->restProxy->getServiceProperties()->getValue();
// Assert
$this->assertNotNull($props, '$props');
$this->assertNotNull($props->getLogging(), '$props->getLogging');
$this->assertNotNull($props->getLogging()->getRetentionPolicy(), '$props->getLogging()->getRetentionPolicy');
$this->assertNotNull($props->getLogging()->getVersion(), '$props->getLogging()->getVersion');
$this->assertTrue($props->getLogging()->getRead(), '$props->getLogging()->getRead');
$this->assertNotNull($props->getMetrics()->getRetentionPolicy(), '$props->getMetrics()->getRetentionPolicy');
$this->assertNotNull($props->getMetrics()->getVersion(), '$props->getMetrics()->getVersion');
}
/**
* @covers WindowsAzure\Common\Configuration::isEmulated
*/
public function testIsEmulated()
{
// Test
$actual = Configuration::isEmulated();
// Assert
$this->assertTrue(isset($actual));
}
/**
* @covers WindowsAzure\Queue\QueueRestProxy::setServiceProperties
*/
public function testSetServicePropertiesNullOptions4()
{
$serviceProperties = QueueServiceFunctionalTestData::getDefaultServiceProperties();
try {
$this->restProxy->setServiceProperties($serviceProperties, null);
$this->assertFalse(Configuration::isEmulated(), 'service properties should throw in emulator');
} catch (ServiceException $e) {
if (Configuration::isEmulated()) {
// Setting is not supported in emulator
$this->assertEquals(400, $e->getCode(), 'getCode');
} else {
throw $e;
}
}
}
/**
* @covers WindowsAzure\Table\TableRestProxy::batch
* @covers WindowsAzure\Table\TableRestProxy::insertEntity
*/
public function testBatchAllOperationsTogetherWorks()
{
// Arrange
$table = self::$TEST_TABLE_8;
$partitionKey = '001';
// Insert a few entities to allow updating them in batch
$entity1 = new Entity();
$entity1->setPartitionKey($partitionKey);
$entity1->setRowKey('batchAllOperationsWorks-' . 1);
$entity1->addProperty('test', EdmType::BOOLEAN, true);
$entity1->addProperty('test2', EdmType::STRING, 'value');
$entity1->addProperty('test3', EdmType::INT32, 3);
$entity1->addProperty('test4', EdmType::INT64, '12345678901');
$entity1->addProperty('test5', EdmType::DATETIME, new \DateTime());
$entity1 = $this->restProxy->insertEntity($table, $entity1)->getEntity();
$entity2 = new Entity();
$entity2->setPartitionKey($partitionKey);
$entity2->setRowKey('batchAllOperationsWorks-' . 2);
$entity2->addProperty('test', EdmType::BOOLEAN, true);
$entity2->addProperty('test2', EdmType::STRING, 'value');
$entity2->addProperty('test3', EdmType::INT32, 3);
$entity2->addProperty('test4', EdmType::INT64, '12345678901');
$entity2->addProperty('test5', EdmType::DATETIME, new \DateTime());
$entity2 = $this->restProxy->insertEntity($table, $entity2)->getEntity();
$entity3 = new Entity();
$entity3->setPartitionKey($partitionKey);
$entity3->setRowKey('batchAllOperationsWorks-' . 3);
$entity3->addProperty('test', EdmType::BOOLEAN, true);
$entity3->addProperty('test2', EdmType::STRING, 'value');
$entity3->addProperty('test3', EdmType::INT32, 3);
$entity3->addProperty('test4', EdmType::INT64, '12345678901');
$entity3->addProperty('test5', EdmType::DATETIME, new \DateTime());
$entity3 = $this->restProxy->insertEntity($table, $entity3)->getEntity();
$entity4 = new Entity();
$entity4->setPartitionKey($partitionKey);
$entity4->setRowKey('batchAllOperationsWorks-' . 4);
$entity4->addProperty('test', EdmType::BOOLEAN, true);
$entity4->addProperty('test2', EdmType::STRING, 'value');
$entity4->addProperty('test3', EdmType::INT32, 3);
$entity4->addProperty('test4', EdmType::INT64, '12345678901');
$entity4->addProperty('test5', EdmType::DATETIME, new \DateTime());
$entity4 = $this->restProxy->insertEntity($table, $entity4)->getEntity();
// Act
$batchOperations = new BatchOperations();
$entity = new Entity();
$entity->setPartitionKey($partitionKey);
$entity->setRowKey('batchAllOperationsWorks');
$entity->addProperty('test', EdmType::BOOLEAN, true);
$entity->addProperty('test2', EdmType::STRING, 'value');
$entity->addProperty('test3', EdmType::INT32, 3);
$entity->addProperty('test4', EdmType::INT64, '12345678901');
$entity->addProperty('test5', EdmType::DATETIME, new \DateTime());
$batchOperations->addInsertEntity($table, $entity);
$batchOperations->addDeleteEntity($table, $entity1->getPartitionKey(), $entity1->getRowKey(), $entity1->getEtag());
$entity2->addProperty('test3', EdmType::INT32, 5);
$batchOperations->addUpdateEntity($table, $entity2);
$entity3->addProperty('test3', EdmType::INT32, 5);
$batchOperations->addMergeEntity($table, $entity3);
$entity4->addProperty('test3', EdmType::INT32, 5);
// Use different behavior in the emulator, as v1.6 does not support this method
if (!Configuration::isEmulated()) {
$batchOperations->addInsertOrReplaceEntity($table, $entity4);
} else {
$batchOperations->addUpdateEntity($table, $entity4);
}
$entity5 = new Entity();
$entity5->setPartitionKey($partitionKey);
$entity5->setRowKey('batchAllOperationsWorks-' . 5);
$entity5->addProperty('test', EdmType::BOOLEAN, true);
$entity5->addProperty('test2', EdmType::STRING, 'value');
$entity5->addProperty('test3', EdmType::INT32, 3);
$entity5->addProperty('test4', EdmType::INT64, '12345678901');
$entity5->addProperty('test5', EdmType::DATETIME, new \DateTime());
// Use different behavior in the emulator, as v1.6 does not support this method
if (Configuration::isEmulated()) {
$batchOperations->addInsertEntity($table, $entity5);
} else {
$batchOperations->addInsertOrMergeEntity($table, $entity5);
}
$result = $this->restProxy->batch($batchOperations);
// Assert
$this->assertNotNull($result, '$result');
$this->assertEquals(count($batchOperations->getOperations()), count($result->getEntries()), 'count($result->getEntries())');
$ents = $result->getEntries();
$this->assertTrue($ents[0] instanceof InsertEntityResult, '$result->getEntries()->get(0)->getClass()');
$this->assertTrue(is_string($ents[1]), '$result->getEntries()->get(1)->getClass()');
$this->assertTrue($ents[2] instanceof UpdateEntityResult, '$result->getEntries()->get(2)->getClass()');
$this->assertTrue($ents[3] instanceof UpdateEntityResult, '$result->getEntries()->get(3)->getClass()');
$this->assertTrue($ents[4] instanceof UpdateEntityResult, '$result->getEntries()->get(4)->getClass()');
if (Configuration::isEmulated()) {
$this->assertTrue($ents[5] instanceof InsertEntityResult, '$result->getEntries()->get(5)->getClass()');
} else {
$this->assertTrue($ents[5] instanceof UpdateEntityResult, '$result->getEntries()->get(5)->getClass()');
}
}
