admin/miniapi
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

提交

Browse Source
This commit is contained in:
gaofeng
2026-06-17 09:23:18 +08:00
commit 81ade70944
1638 changed files with 213697 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

482
vendor/alibabacloud/oss-v2/tests/UnitTests/Transform/AccessPointTest.php vendored Normal file
View File

@@ -0,0 +1,482 @@
<?php
namespace UnitTests\Transform;
use AlibabaCloud\Oss\V2\Models;
use AlibabaCloud\Oss\V2\Transform\AccessPoint;
use AlibabaCloud\Oss\V2\OperationOutput;
use AlibabaCloud\Oss\V2\Utils;
class AccessPointTest extends \PHPUnit\Framework\TestCase
{
public function testFromCreateAccessPoint()
{
// miss required field
try {
$request = new Models\CreateAccessPointRequest();
$input = AccessPoint::fromCreateAccessPoint($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
try {
$request = new Models\CreateAccessPointRequest('bucket-123');
$input = AccessPoint::fromCreateAccessPoint($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, createAccessPointConfiguration", (string)$e);
}
$request = new Models\CreateAccessPointRequest('bucket-123', new Models\CreateAccessPointConfiguration(
accessPointName: 'ap-01',
networkOrigin: 'internet'
));
$input = AccessPoint::fromCreateAccessPoint($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><CreateAccessPointConfiguration><AccessPointName>ap-01</AccessPointName><NetworkOrigin>internet</NetworkOrigin></CreateAccessPointConfiguration>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
$request = new Models\CreateAccessPointRequest('bucket-123', new Models\CreateAccessPointConfiguration(
vpcConfiguration: new Models\AccessPointVpcConfiguration('vpc-t4nlw426y44rd3iq4xxxx'),
accessPointName: 'ap-01',
networkOrigin: 'vpc'
));
$input = AccessPoint::fromCreateAccessPoint($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><CreateAccessPointConfiguration><VpcConfiguration><VpcId>vpc-t4nlw426y44rd3iq4xxxx</VpcId></VpcConfiguration><AccessPointName>ap-01</AccessPointName><NetworkOrigin>vpc</NetworkOrigin></CreateAccessPointConfiguration>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
}
public function testToCreateAccessPoint()
{
// empty output
$output = new OperationOutput();
$result = AccessPoint::toCreateAccessPoint($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$body = '<?xml version="1.0" encoding="UTF-8"?>
<CreateAccessPointResult>
<AccessPointArn>acs:oss:cn-hangzhou:128364106451xxxx:accesspoint/ap-01</AccessPointArn>
<Alias>ap-01-45ee7945007a2f0bcb595f63e2215cxxxx-ossalias</Alias>
</CreateAccessPointResult>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123', 'content-type' => 'application/xml'],
body: Utils::streamFor($body)
);
$result = AccessPoint::toCreateAccessPoint($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(2, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals('application/xml', $result->headers['content-type']);
$this->assertEquals('acs:oss:cn-hangzhou:128364106451xxxx:accesspoint/ap-01', $result->createAccessPoint->accessPointArn);
$this->assertEquals('ap-01-45ee7945007a2f0bcb595f63e2215cxxxx-ossalias', $result->createAccessPoint->alias);
}
public function testFromGetAccessPoint()
{
// miss required field
try {
$request = new Models\GetAccessPointRequest();
$input = AccessPoint::fromGetAccessPoint($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
try {
$request = new Models\GetAccessPointRequest('bucket-123');
$input = AccessPoint::fromGetAccessPoint($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, accessPointName", (string)$e);
}
$request = new Models\GetAccessPointRequest('bucket-123', 'ap-01');
$input = AccessPoint::fromGetAccessPoint($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
$this->assertEquals('ap-01', $input->getHeaders()['x-oss-access-point-name']);
}
public function testToGetAccessPoint()
{
// empty output
$output = new OperationOutput();
$result = AccessPoint::toGetAccessPoint($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$body = '<?xml version="1.0" encoding="UTF-8"?>
<GetAccessPointResult>
<AccessPointName>ap-01</AccessPointName>
<Bucket>oss-example</Bucket>
<AccountId>111933544165xxxx</AccountId>
<NetworkOrigin>vpc</NetworkOrigin>
<VpcConfiguration>
<VpcId>vpc-t4nlw426y44rd3iq4xxxx</VpcId>
</VpcConfiguration>
<AccessPointArn>arn:acs:oss:cn-hangzhou:111933544165xxxx:accesspoint/ap-01</AccessPointArn>
<CreationDate>1626769503</CreationDate>
<Alias>ap-01-ossalias</Alias>
<Status>enable</Status>
<Endpoints>
<PublicEndpoint>ap-01.oss-cn-hangzhou.oss-accesspoint.aliyuncs.com</PublicEndpoint>
<InternalEndpoint>ap-01.oss-cn-hangzhou-internal.oss-accesspoint.aliyuncs.com</InternalEndpoint>
</Endpoints>
<PublicAccessBlockConfiguration>
<BlockPublicAccess>true</BlockPublicAccess>
</PublicAccessBlockConfiguration>
</GetAccessPointResult>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123', 'content-type' => 'application/xml'],
body: Utils::streamFor($body)
);
$result = AccessPoint::toGetAccessPoint($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(2, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals('application/xml', $result->headers['content-type']);
$this->assertEquals('ap-01', $result->getAccessPoint->accessPointName);
$this->assertEquals('oss-example', $result->getAccessPoint->bucket);
$this->assertEquals('111933544165xxxx', $result->getAccessPoint->accountId);
$this->assertEquals('vpc', $result->getAccessPoint->networkOrigin);
$this->assertEquals('vpc-t4nlw426y44rd3iq4xxxx', $result->getAccessPoint->vpcConfiguration->vpcId);
$this->assertEquals('arn:acs:oss:cn-hangzhou:111933544165xxxx:accesspoint/ap-01', $result->getAccessPoint->accessPointArn);
$this->assertEquals('1626769503', $result->getAccessPoint->creationDate);
$this->assertEquals('ap-01-ossalias', $result->getAccessPoint->alias);
$this->assertEquals('enable', $result->getAccessPoint->status);
$this->assertEquals('ap-01.oss-cn-hangzhou.oss-accesspoint.aliyuncs.com', $result->getAccessPoint->endpoints->publicEndpoint);
$this->assertEquals('ap-01.oss-cn-hangzhou-internal.oss-accesspoint.aliyuncs.com', $result->getAccessPoint->endpoints->internalEndpoint);
$this->assertTrue($result->getAccessPoint->publicAccessBlockConfiguration->blockPublicAccess);
}
public function testFromDeleteAccessPoint()
{
// miss required field
try {
$request = new Models\DeleteAccessPointRequest();
$input = AccessPoint::fromDeleteAccessPoint($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
try {
$request = new Models\DeleteAccessPointRequest('bucket-123');
$input = AccessPoint::fromDeleteAccessPoint($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, accessPointName", (string)$e);
}
$request = new Models\DeleteAccessPointRequest('bucket-123', 'ap-01');
$input = AccessPoint::fromDeleteAccessPoint($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
$this->assertEquals('ap-01', $input->getHeaders()['x-oss-access-point-name']);
}
public function testToDeleteAccessPoint()
{
// empty output
$output = new OperationOutput();
$result = AccessPoint::toDeleteAccessPoint($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'No Content',
204,
['x-oss-request-id' => '123'],
);
$result = AccessPoint::toDeleteAccessPoint($output);
$this->assertEquals('No Content', $result->status);
$this->assertEquals(204, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
}
public function testFromListAccessPoints()
{
$request = new Models\ListAccessPointsRequest();
$input = AccessPoint::fromListAccessPoints($request);
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
$request = new Models\ListAccessPointsRequest(10, 'token', 'bucket-123');
$input = AccessPoint::fromListAccessPoints($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
$this->assertEquals('10', $input->getParameters()['max-keys']);
$this->assertEquals('token', $input->getParameters()['continuation-token']);
}
public function testToListAccessPoints()
{
// empty output
$output = new OperationOutput();
$result = AccessPoint::toGetAccessPoint($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$body = '<?xml version="1.0" encoding="UTF-8"?>
<ListAccessPointsResult>
<IsTruncated>true</IsTruncated>
<NextContinuationToken>abc</NextContinuationToken>
<AccountId>111933544165****</AccountId>
<MaxKeys>3</MaxKeys>
<AccessPoints>
<AccessPoint>
<Bucket>oss-example</Bucket>
<AccessPointName>ap-01</AccessPointName>
<Alias>ap-01-ossalias</Alias>
<NetworkOrigin>vpc</NetworkOrigin>
<VpcConfiguration>
<VpcId>vpc-t4nlw426y44rd3iq4****</VpcId>
</VpcConfiguration>
<Status>enable</Status>
</AccessPoint>
<AccessPoint>
<Bucket>oss-example</Bucket>
<AccessPointName>ap-02</AccessPointName>
<Alias>ap-02-ossalias</Alias>
<NetworkOrigin>vpc</NetworkOrigin>
<VpcConfiguration>
<VpcId>vpc-t4nlw426y44rd3iq2****</VpcId>
</VpcConfiguration>
<Status>enable</Status>
</AccessPoint>
<AccessPoint>
<Bucket>oss-example</Bucket>
<AccessPointName>ap-03</AccessPointName>
<Alias>ap-03-ossalias</Alias>
<NetworkOrigin>internet</NetworkOrigin>
<VpcConfiguration>
<VpcId></VpcId>
</VpcConfiguration>
<Status>enable</Status>
</AccessPoint>
</AccessPoints>
</ListAccessPointsResult>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123', 'content-type' => 'application/xml'],
body: Utils::streamFor($body)
);
$result = AccessPoint::toListAccessPoints($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(2, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals('application/xml', $result->headers['content-type']);
$this->assertEquals('111933544165****', $result->listAccessPoints->accountId);
$this->assertEquals('abc', $result->listAccessPoints->nextContinuationToken);
$this->assertTrue($result->listAccessPoints->isTruncated);
$this->assertEquals(3, $result->listAccessPoints->maxKeys);
$this->assertEquals(3, count($result->listAccessPoints->accessPoints->accessPoints));
$this->assertEquals('oss-example', $result->listAccessPoints->accessPoints->accessPoints[0]->bucket);
$this->assertEquals('ap-01', $result->listAccessPoints->accessPoints->accessPoints[0]->accessPointName);
$this->assertEquals('ap-01-ossalias', $result->listAccessPoints->accessPoints->accessPoints[0]->alias);
$this->assertEquals('vpc', $result->listAccessPoints->accessPoints->accessPoints[0]->networkOrigin);
$this->assertEquals('vpc-t4nlw426y44rd3iq4****', $result->listAccessPoints->accessPoints->accessPoints[0]->vpcConfiguration->vpcId);
$this->assertEquals('enable', $result->listAccessPoints->accessPoints->accessPoints[0]->status);
$this->assertEquals('oss-example', $result->listAccessPoints->accessPoints->accessPoints[1]->bucket);
$this->assertEquals('ap-02', $result->listAccessPoints->accessPoints->accessPoints[1]->accessPointName);
$this->assertEquals('ap-02-ossalias', $result->listAccessPoints->accessPoints->accessPoints[1]->alias);
$this->assertEquals('vpc', $result->listAccessPoints->accessPoints->accessPoints[1]->networkOrigin);
$this->assertEquals('vpc-t4nlw426y44rd3iq2****', $result->listAccessPoints->accessPoints->accessPoints[1]->vpcConfiguration->vpcId);
$this->assertEquals('enable', $result->listAccessPoints->accessPoints->accessPoints[1]->status);
$this->assertEquals('oss-example', $result->listAccessPoints->accessPoints->accessPoints[2]->bucket);
$this->assertEquals('ap-03', $result->listAccessPoints->accessPoints->accessPoints[2]->accessPointName);
$this->assertEquals('ap-03-ossalias', $result->listAccessPoints->accessPoints->accessPoints[2]->alias);
$this->assertEquals('internet', $result->listAccessPoints->accessPoints->accessPoints[2]->networkOrigin);
$this->assertEquals('enable', $result->listAccessPoints->accessPoints->accessPoints[2]->status);
}
public function testFromPutAccessPointPolicy()
{
// miss required field
try {
$request = new Models\PutAccessPointPolicyRequest();
$input = AccessPoint::fromPutAccessPointPolicy($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
try {
$request = new Models\PutAccessPointPolicyRequest('bucket-123');
$input = AccessPoint::fromPutAccessPointPolicy($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, accessPointName", (string)$e);
}
try {
$request = new Models\PutAccessPointPolicyRequest('bucket-123', 'ap-01');
$input = AccessPoint::fromPutAccessPointPolicy($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, body", (string)$e);
}
$request = new Models\PutAccessPointPolicyRequest('bucket-123', 'ap-01', '{"Version":"1","Statement":[{"Action":["oss:PutObject","oss:GetObject"],"Effect":"Deny","Principal":["27737962156157xxxx"],"Resource":["acs:oss:cn-hangzhou:111933544165xxxx:accesspoint/ap-01","acs:oss:cn-hangzhou:111933544165xxxx:accesspoint/ap-01/object/*"]}]}');
$input = AccessPoint::fromPutAccessPointPolicy($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('{"Version":"1","Statement":[{"Action":["oss:PutObject","oss:GetObject"],"Effect":"Deny","Principal":["27737962156157xxxx"],"Resource":["acs:oss:cn-hangzhou:111933544165xxxx:accesspoint/ap-01","acs:oss:cn-hangzhou:111933544165xxxx:accesspoint/ap-01/object/*"]}]}', $input->getBody()->getContents());
}
public function testToPutAccessPointPolicy()
{
// empty output
$output = new OperationOutput();
$result = AccessPoint::toPutAccessPointPolicy($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123'],
);
$result = AccessPoint::toPutAccessPointPolicy($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
}
public function testFromGetAccessPointPolicy()
{
// miss required field
try {
$request = new Models\GetAccessPointPolicyRequest();
$input = AccessPoint::fromGetAccessPointPolicy($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
try {
$request = new Models\GetAccessPointPolicyRequest('bucket-123');
$input = AccessPoint::fromGetAccessPointPolicy($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, accessPointName", (string)$e);
}
$request = new Models\GetAccessPointPolicyRequest('bucket-123', 'ap-01');
$input = AccessPoint::fromGetAccessPointPolicy($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('ap-01', $input->getHeaders()['x-oss-access-point-name']);
}
public function testToGetAccessPointPolicy()
{
// empty output
$output = new OperationOutput();
$result = AccessPoint::toGetAccessPointPolicy($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$body = '{"Version":"1","Statement":[{"Action":["oss:PutObject","oss:GetObject"],"Effect":"Deny","Principal":["27737962156157xxxx"],"Resource":["acs:oss:cn-hangzhou:111933544165xxxx:accesspoint/ap-01","acs:oss:cn-hangzhou:111933544165xxxx:accesspoint/ap-01/object/*"]}]}';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123', 'content-type' => 'application/json'],
body: Utils::streamFor($body)
);
$result = AccessPoint::toGetAccessPointPolicy($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(2, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals('application/json', $result->headers['content-type']);
$this->assertEquals($body, $result->body);
}
public function testFromDeleteAccessPointPolicy()
{
// miss required field
try {
$request = new Models\DeleteAccessPointPolicyRequest();
$input = AccessPoint::fromDeleteAccessPointPolicy($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
try {
$request = new Models\DeleteAccessPointPolicyRequest('bucket-123');
$input = AccessPoint::fromDeleteAccessPointPolicy($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, accessPointName", (string)$e);
}
$request = new Models\DeleteAccessPointPolicyRequest('bucket-123', 'ap-01');
$input = AccessPoint::fromDeleteAccessPointPolicy($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
$this->assertEquals('ap-01', $input->getHeaders()['x-oss-access-point-name']);
}
public function testToDeleteAccessPointPolicy()
{
// empty output
$output = new OperationOutput();
$result = AccessPoint::toDeleteAccessPointPolicy($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'No Content',
204,
['x-oss-request-id' => '123'],
);
$result = AccessPoint::toDeleteAccessPointPolicy($output);
$this->assertEquals('No Content', $result->status);
$this->assertEquals(204, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
}
private function cleanXml($xml): array|string
{
return str_replace("\n", "", str_replace("\r", "", $xml));
}
}

115
vendor/alibabacloud/oss-v2/tests/UnitTests/Transform/BucketAccessMonitorTest.php vendored Normal file
View File

@@ -0,0 +1,115 @@
<?php
namespace UnitTests\Transform;
use AlibabaCloud\Oss\V2\Models;
use AlibabaCloud\Oss\V2\Transform\BucketAccessMonitor;
use AlibabaCloud\Oss\V2\OperationOutput;
use AlibabaCloud\Oss\V2\Utils;
class BucketAccessMonitorTest extends \PHPUnit\Framework\TestCase
{
public function testFromPutBucketAccessMonitor()
{
// miss required field
try {
$request = new Models\PutBucketAccessMonitorRequest();
$input = BucketAccessMonitor::fromPutBucketAccessMonitor($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
try {
$request = new Models\PutBucketAccessMonitorRequest('bucket-123');
$input = BucketAccessMonitor::fromPutBucketAccessMonitor($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, accessMonitorConfiguration", (string)$e);
}
$request = new Models\PutBucketAccessMonitorRequest('bucket-123', new Models\AccessMonitorConfiguration(
status: Models\AccessMonitorStatusType::ENABLED
));
$input = BucketAccessMonitor::fromPutBucketAccessMonitor($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><AccessMonitorConfiguration><Status>Enabled</Status></AccessMonitorConfiguration>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
}
public function testToPutBucketAccessMonitor()
{
// empty output
$output = new OperationOutput();
$result = BucketAccessMonitor::toPutBucketAccessMonitor($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123']
);
$result = BucketAccessMonitor::toPutBucketAccessMonitor($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
}
public function testFromGetBucketAccessMonitor()
{
// miss required field
try {
$request = new Models\GetBucketAccessMonitorRequest();
$input = BucketAccessMonitor::fromGetBucketAccessMonitor($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
$request = new Models\GetBucketAccessMonitorRequest('bucket-123');
$input = BucketAccessMonitor::fromGetBucketAccessMonitor($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
}
public function testToGetBucketAccessMonitor()
{
// empty output
$output = new OperationOutput();
$result = BucketAccessMonitor::toGetBucketAccessMonitor($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$body = '<?xml version="1.0" encoding="UTF-8"?>
<AccessMonitorConfiguration>
<Status>Enabled</Status>
</AccessMonitorConfiguration>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123'],
Utils::streamFor($body)
);
$result = BucketAccessMonitor::toGetBucketAccessMonitor($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals(Models\AccessMonitorStatusType::ENABLED, $result->accessMonitorConfiguration->status);
}
private function cleanXml($xml): array|string
{
return str_replace("\n", "", str_replace("\r", "", $xml));
}
}

133
vendor/alibabacloud/oss-v2/tests/UnitTests/Transform/BucketArchiveDirectReadTest.php vendored Normal file
View File

@@ -0,0 +1,133 @@
<?php
namespace UnitTests\Transform;
use AlibabaCloud\Oss\V2\Models;
use AlibabaCloud\Oss\V2\Transform\BucketArchiveDirectRead;
use AlibabaCloud\Oss\V2\OperationOutput;
use AlibabaCloud\Oss\V2\Utils;
class BucketArchiveDirectReadTest extends \PHPUnit\Framework\TestCase
{
public function testFromPutBucketArchiveDirectRead()
{
// miss required field
try {
$request = new Models\PutBucketArchiveDirectReadRequest();
$input = BucketArchiveDirectRead::fromPutBucketArchiveDirectRead($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
try {
$request = new Models\PutBucketArchiveDirectReadRequest('bucket-123');
$input = BucketArchiveDirectRead::fromPutBucketArchiveDirectRead($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, archiveDirectReadConfiguration", (string)$e);
}
$request = new Models\PutBucketArchiveDirectReadRequest('bucket-123', new Models\ArchiveDirectReadConfiguration(
true
));
$input = BucketArchiveDirectRead::fromPutBucketArchiveDirectRead($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><ArchiveDirectReadConfiguration><Enabled>true</Enabled></ArchiveDirectReadConfiguration>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
}
public function testToPutBucketArchiveDirectRead()
{
// empty output
$output = new OperationOutput();
$result = BucketArchiveDirectRead::toPutBucketArchiveDirectRead($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123']
);
$result = BucketArchiveDirectRead::toPutBucketArchiveDirectRead($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
}
public function testFromGetBucketArchiveDirectRead()
{
// miss required field
try {
$request = new Models\GetBucketArchiveDirectReadRequest();
$input = BucketArchiveDirectRead::fromGetBucketArchiveDirectRead($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
$request = new Models\GetBucketArchiveDirectReadRequest('bucket-123');
$input = BucketArchiveDirectRead::fromGetBucketArchiveDirectRead($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
}
public function testToGetBucketArchiveDirectRead()
{
// empty output
$output = new OperationOutput();
$result = BucketArchiveDirectRead::toGetBucketArchiveDirectRead($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$body = '<?xml version="1.0" encoding="UTF-8"?>
<ArchiveDirectReadConfiguration>
<Enabled>true</Enabled>
</ArchiveDirectReadConfiguration>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123'],
Utils::streamFor($body)
);
$result = BucketArchiveDirectRead::toGetBucketArchiveDirectRead($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertTrue($result->archiveDirectReadConfiguration->enabled);
$body = '<?xml version="1.0" encoding="UTF-8"?>
<ArchiveDirectReadConfiguration>
<Enabled>false</Enabled>
</ArchiveDirectReadConfiguration>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123'],
Utils::streamFor($body)
);
$result = BucketArchiveDirectRead::toGetBucketArchiveDirectRead($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertFalse($result->archiveDirectReadConfiguration->enabled);
}
private function cleanXml($xml): array|string
{
return str_replace("\n", "", str_replace("\r", "", $xml));
}
}

2414
vendor/alibabacloud/oss-v2/tests/UnitTests/Transform/BucketBasicTest.php vendored Normal file
View File

File diff suppressed because it is too large Load Diff

377
vendor/alibabacloud/oss-v2/tests/UnitTests/Transform/BucketCnameTest.php vendored Normal file
View File

@@ -0,0 +1,377 @@
<?php
namespace UnitTests\Transform;
use AlibabaCloud\Oss\V2\Models;
use AlibabaCloud\Oss\V2\Transform\BucketCname;
use AlibabaCloud\Oss\V2\OperationOutput;
use AlibabaCloud\Oss\V2\Utils;
class BucketCnameTest extends \PHPUnit\Framework\TestCase
{
public function testFromPutCname()
{
// miss required field
try {
$request = new Models\PutCnameRequest();
$input = BucketCname::fromPutCname($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
try {
$request = new Models\PutCnameRequest('bucket-123');
$input = BucketCname::fromPutCname($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucketCnameConfiguration", (string)$e);
}
$request = new Models\PutCnameRequest('bucket-123', new Models\BucketCnameConfiguration(
new Models\Cname(
domain: 'example.com'
)
));
$input = BucketCname::fromPutCname($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><BucketCnameConfiguration><Cname><Domain>example.com</Domain></Cname></BucketCnameConfiguration>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
$request = new Models\PutCnameRequest('bucket-123', new Models\BucketCnameConfiguration(
new Models\Cname(
domain: 'example.com',
certificateConfiguration: new Models\CertificateConfiguration(
force: true,
certId: '493****-cn-hangzhou',
certificate: '-----BEGIN CERTIFICATE----- MIIDhDCCAmwCCQCFs8ixARsyrDANBgkqhkiG9w0BAQsFADCBgzELMAkGA1UEBhMC **** -----END CERTIFICATE-----',
privateKey: '-----BEGIN CERTIFICATE----- MIIDhDCCAmwCCQCFs8ixARsyrDANBgkqhkiG9w0BAQsFADCBgzELMAkGA1UEBhMC **** -----END CERTIFICATE-----',
previousCertId: '493****-cn-hangzhou'
)
)
));
$input = BucketCname::fromPutCname($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><BucketCnameConfiguration><Cname><Domain>example.com</Domain><CertificateConfiguration><Force>true</Force><CertId>493****-cn-hangzhou</CertId><Certificate>-----BEGIN CERTIFICATE----- MIIDhDCCAmwCCQCFs8ixARsyrDANBgkqhkiG9w0BAQsFADCBgzELMAkGA1UEBhMC **** -----END CERTIFICATE-----</Certificate><PrivateKey>-----BEGIN CERTIFICATE----- MIIDhDCCAmwCCQCFs8ixARsyrDANBgkqhkiG9w0BAQsFADCBgzELMAkGA1UEBhMC **** -----END CERTIFICATE-----</PrivateKey><PreviousCertId>493****-cn-hangzhou</PreviousCertId></CertificateConfiguration></Cname></BucketCnameConfiguration>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
$request = new Models\PutCnameRequest('bucket-123', new Models\BucketCnameConfiguration(
new Models\Cname(
domain: 'example.com',
certificateConfiguration: new Models\CertificateConfiguration(
deleteCertificate: true,
)
)
));
$input = BucketCname::fromPutCname($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><BucketCnameConfiguration><Cname><Domain>example.com</Domain><CertificateConfiguration><DeleteCertificate>true</DeleteCertificate></CertificateConfiguration></Cname></BucketCnameConfiguration>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
}
public function testToPutCname()
{
// empty output
$output = new OperationOutput();
$result = BucketCname::toPutCname($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123']
);
$result = BucketCname::toPutCname($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
}
public function testFromCreateCnameToken()
{
// miss required field
try {
$request = new Models\CreateCnameTokenRequest();
$input = BucketCname::fromCreateCnameToken($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
try {
$request = new Models\CreateCnameTokenRequest('bucket-123');
$input = BucketCname::fromCreateCnameToken($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucketCnameConfiguration", (string)$e);
}
$request = new Models\CreateCnameTokenRequest('bucket-123', new Models\BucketCnameConfiguration(
new Models\Cname(
domain: 'example.com'
)
));
$input = BucketCname::fromCreateCnameToken($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><BucketCnameConfiguration><Cname><Domain>example.com</Domain></Cname></BucketCnameConfiguration>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
}
public function testToCreateCnameToken()
{
// empty output
$output = new OperationOutput();
$result = BucketCname::toCreateCnameToken($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123', 'content-type' => 'application/xml'],
body: Utils::streamFor('<?xml version="1.0" encoding="UTF-8"?>
<CnameToken>
<Bucket>bucket</Bucket>
<Cname>example.com</Cname>;
<Token>be1d49d863dea9ffeff3df7d6455****</Token>
<ExpireTime>Wed, 23 Feb 2022 21:16:37 GMT</ExpireTime>
</CnameToken>')
);
$result = BucketCname::toCreateCnameToken($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(2, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals('application/xml', $result->headers['content-type']);
$this->assertEquals('bucket', $result->cnameToken->bucket);
$this->assertEquals('example.com', $result->cnameToken->cname);
$this->assertEquals('be1d49d863dea9ffeff3df7d6455****', $result->cnameToken->token);
$this->assertEquals('Wed, 23 Feb 2022 21:16:37 GMT', $result->cnameToken->expireTime);
}
public function testFromGetCnameToken()
{
// miss required field
try {
$request = new Models\GetCnameTokenRequest();
$input = BucketCname::fromGetCnameToken($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
try {
$request = new Models\GetCnameTokenRequest('bucket-123');
$input = BucketCname::fromGetCnameToken($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, cname", (string)$e);
}
$request = new Models\GetCnameTokenRequest('bucket-123', 'example.com');
$input = BucketCname::fromGetCnameToken($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('example.com', $input->getParameters()['cname']);
}
public function testToGetCnameToken()
{
// empty output
$output = new OperationOutput();
$result = BucketCname::toGetCnameToken($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123', 'content-type' => 'application/xml'],
body: Utils::streamFor('<?xml version="1.0" encoding="UTF-8"?>
<CnameToken>
<Bucket>bucket</Bucket>
<Cname>example.com</Cname>;
<Token>be1d49d863dea9ffeff3df7d6455****</Token>
<ExpireTime>Wed, 23 Feb 2022 21:16:37 GMT</ExpireTime>
</CnameToken>')
);
$result = BucketCname::toGetCnameToken($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(2, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals('application/xml', $result->headers['content-type']);
$this->assertEquals('bucket', $result->cnameToken->bucket);
$this->assertEquals('example.com', $result->cnameToken->cname);
$this->assertEquals('be1d49d863dea9ffeff3df7d6455****', $result->cnameToken->token);
$this->assertEquals('Wed, 23 Feb 2022 21:16:37 GMT', $result->cnameToken->expireTime);
}
public function testFromListCname()
{
// miss required field
try {
$request = new Models\ListCnameRequest();
$input = BucketCname::fromListCname($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
$request = new Models\ListCnameRequest('bucket-123');
$input = BucketCname::fromListCname($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
}
public function testToListCname()
{
// empty output
$output = new OperationOutput();
$result = BucketCname::toListCname($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$body = '<?xml version="1.0" encoding="UTF-8"?>
<ListCnameResult>
<Bucket>bucket</Bucket>
<Owner>owner</Owner>
<Cname>
<Domain>example.com</Domain>
<LastModified>2021-09-15T02:35:07.000Z</LastModified>
<Status>Enabled</Status>
<Certificate>
<Type>CAS</Type>
<CertId>493****-cn-hangzhou</CertId>
<Status>Enabled</Status>
<CreationDate>Wed, 15 Sep 2021 02:35:06 GMT</CreationDate>
<Fingerprint>DE:01:CF:EC:7C:A7:98:CB:D8:6E:FB:1D:97:EB:A9:64:1D:4E:**:**</Fingerprint>
<ValidStartDate>Wed, 12 Apr 2023 10:14:51 GMT</ValidStartDate>
<ValidEndDate>Mon, 4 May 2048 10:14:51 GMT</ValidEndDate>
</Certificate>
</Cname>
<Cname>
<Domain>example.org</Domain>
<LastModified>2021-09-15T02:34:58.000Z</LastModified>
<Status>Enabled</Status>
</Cname>
<Cname>
<Domain>example.edu</Domain>
<LastModified>2021-09-15T02:50:34.000Z</LastModified>
<Status>Enabled</Status>
</Cname>
</ListCnameResult>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123', 'content-type' => 'application/xml'],
Utils::streamFor($body)
);
$result = BucketCname::toListCname($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(2, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals('application/xml', $result->headers['content-type']);
$this->assertEquals('bucket', $result->bucket);
$this->assertEquals('owner', $result->owner);
$this->assertEquals(3, count($result->cnames));
$this->assertEquals('example.com', $result->cnames[0]->domain);
$this->assertEquals('2021-09-15T02:35:07.000Z', $result->cnames[0]->lastModified);
$this->assertEquals('Enabled', $result->cnames[0]->status);
$this->assertEquals('CAS', $result->cnames[0]->certificate->type);
$this->assertEquals('493****-cn-hangzhou', $result->cnames[0]->certificate->certId);
$this->assertEquals('Enabled', $result->cnames[0]->certificate->status);
$this->assertEquals('Wed, 15 Sep 2021 02:35:06 GMT', $result->cnames[0]->certificate->creationDate);
$this->assertEquals('DE:01:CF:EC:7C:A7:98:CB:D8:6E:FB:1D:97:EB:A9:64:1D:4E:**:**', $result->cnames[0]->certificate->fingerprint);
$this->assertEquals('Wed, 12 Apr 2023 10:14:51 GMT', $result->cnames[0]->certificate->validStartDate);
$this->assertEquals('Mon, 4 May 2048 10:14:51 GMT', $result->cnames[0]->certificate->validEndDate);
$this->assertEquals('example.org', $result->cnames[1]->domain);
$this->assertEquals('2021-09-15T02:34:58.000Z', $result->cnames[1]->lastModified);
$this->assertEquals('Enabled', $result->cnames[1]->status);
$this->assertEquals('example.edu', $result->cnames[2]->domain);
$this->assertEquals('2021-09-15T02:50:34.000Z', $result->cnames[2]->lastModified);
$this->assertEquals('Enabled', $result->cnames[2]->status);
}
public function testFromDeleteCname()
{
// miss required field
try {
$request = new Models\DeleteCnameRequest();
$input = BucketCname::fromDeleteCname($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
try {
$request = new Models\DeleteCnameRequest('bucket-123');
$input = BucketCname::fromDeleteCname($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucketCnameConfiguration", (string)$e);
}
$request = new Models\DeleteCnameRequest('bucket-123', new Models\BucketCnameConfiguration(
new Models\Cname(
domain: 'example.com'
)
));
$input = BucketCname::fromDeleteCname($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><BucketCnameConfiguration><Cname><Domain>example.com</Domain></Cname></BucketCnameConfiguration>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
}
public function testToDeleteCname()
{
// empty output
$output = new OperationOutput();
$result = BucketCname::toDeleteCname($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123'],
);
$result = BucketCname::toDeleteCname($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
}
private function cleanXml($xml): array|string
{
return str_replace("\n", "", str_replace("\r", "", $xml));
}
}

271
vendor/alibabacloud/oss-v2/tests/UnitTests/Transform/BucketCorsTest.php vendored Normal file
View File

@@ -0,0 +1,271 @@
<?php
namespace UnitTests\Transform;
use AlibabaCloud\Oss\V2\Models;
use AlibabaCloud\Oss\V2\Transform\BucketCors;
use AlibabaCloud\Oss\V2\OperationOutput;
use AlibabaCloud\Oss\V2\Utils;
class BucketCorsTest extends \PHPUnit\Framework\TestCase
{
public function testFromPutBucketCors()
{
// miss required field
try {
$request = new Models\PutBucketCorsRequest();
$input = BucketCors::fromPutBucketCors($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
try {
$request = new Models\PutBucketCorsRequest('bucket-123');
$input = BucketCors::fromPutBucketCors($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, corsConfiguration", (string)$e);
}
// demo1
$request = new Models\PutBucketCorsRequest('bucket-123', new Models\CORSConfiguration(
[
new Models\CORSRule(
allowedHeaders: ['Authorization'],
allowedOrigins: ['*'],
allowedMethods: ['PUT', 'GET']
),
new Models\CORSRule(
allowedHeaders: ['Authorization'],
exposeHeaders: ["x-oss-test", "x-oss-test1"],
maxAgeSeconds: 100,
allowedOrigins: ["http://example.com", "http://example.net"],
allowedMethods: ['GET'],
),
],
responseVary: false
));
$input = BucketCors::fromPutBucketCors($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><CORSConfiguration><CORSRule><AllowedHeader>Authorization</AllowedHeader><AllowedOrigin>*</AllowedOrigin><AllowedMethod>PUT</AllowedMethod><AllowedMethod>GET</AllowedMethod></CORSRule><CORSRule><AllowedHeader>Authorization</AllowedHeader><ExposeHeader>x-oss-test</ExposeHeader><ExposeHeader>x-oss-test1</ExposeHeader><MaxAgeSeconds>100</MaxAgeSeconds><AllowedOrigin>http://example.com</AllowedOrigin><AllowedOrigin>http://example.net</AllowedOrigin><AllowedMethod>GET</AllowedMethod></CORSRule><ResponseVary>false</ResponseVary></CORSConfiguration>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
}
public function testToPutBucketCors()
{
// empty output
$output = new OperationOutput();
$result = BucketCors::toPutBucketCors($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123']
);
$result = BucketCors::toPutBucketCors($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
}
public function testFromGetBucketCors()
{
// miss required field
try {
$request = new Models\GetBucketCorsRequest();
$input = BucketCors::fromGetBucketCors($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
$request = new Models\GetBucketCorsRequest('bucket-123');
$input = BucketCors::fromGetBucketCors($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
}
public function testToGetBucketCors()
{
// empty output
$output = new OperationOutput();
$result = BucketCors::toGetBucketCors($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$body = '<?xml version="1.0" encoding="UTF-8"?>
<CORSConfiguration>
<CORSRule>
<AllowedOrigin>*</AllowedOrigin>
<AllowedMethod>PUT</AllowedMethod>
<AllowedMethod>GET</AllowedMethod>
<AllowedHeader>Authorization</AllowedHeader>
</CORSRule>
<CORSRule>
<AllowedOrigin>http://example.com</AllowedOrigin>
<AllowedOrigin>http://example.net</AllowedOrigin>
<AllowedMethod>GET</AllowedMethod>
<AllowedHeader>Authorization</AllowedHeader>
<ExposeHeader>x-oss-test</ExposeHeader>
<ExposeHeader>x-oss-test1</ExposeHeader>
<MaxAgeSeconds>100</MaxAgeSeconds>
</CORSRule>
<ResponseVary>false</ResponseVary>
</CORSConfiguration>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123'],
Utils::streamFor($body)
);
$result = BucketCors::toGetBucketCors($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals(2, count($result->corsConfiguration->corsRules));
$this->assertFalse($result->corsConfiguration->responseVary);
$this->assertEquals($result->corsConfiguration->corsRules[0]->allowedOrigins[0], '*');
$this->assertEquals(count($result->corsConfiguration->corsRules[0]->allowedMethods), 2);
$this->assertEquals($result->corsConfiguration->corsRules[0]->allowedMethods[0], 'PUT');
$this->assertEquals($result->corsConfiguration->corsRules[0]->allowedMethods[1], 'GET');
$this->assertEquals(count($result->corsConfiguration->corsRules[0]->allowedHeaders), 1);
$this->assertEquals($result->corsConfiguration->corsRules[0]->allowedHeaders[0], 'Authorization');
$this->assertEquals($result->corsConfiguration->corsRules[1]->allowedOrigins[0], 'http://example.com');
$this->assertEquals($result->corsConfiguration->corsRules[1]->allowedOrigins[1], 'http://example.net');
$this->assertEquals(count($result->corsConfiguration->corsRules[1]->allowedMethods), 1);
$this->assertEquals($result->corsConfiguration->corsRules[1]->allowedMethods[0], 'GET');
$this->assertEquals(count($result->corsConfiguration->corsRules[1]->allowedHeaders), 1);
$this->assertEquals($result->corsConfiguration->corsRules[1]->allowedHeaders[0], 'Authorization');
$this->assertEquals(count($result->corsConfiguration->corsRules[1]->exposeHeaders), 2);
$this->assertEquals($result->corsConfiguration->corsRules[1]->exposeHeaders[0], "x-oss-test");
$this->assertEquals($result->corsConfiguration->corsRules[1]->exposeHeaders[1], "x-oss-test1");
$this->assertEquals($result->corsConfiguration->corsRules[1]->maxAgeSeconds, 100);
}
public function testFromDeleteBucketCors()
{
// miss required field
try {
$request = new Models\DeleteBucketCorsRequest();
$input = BucketCors::fromDeleteBucketCors($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
$request = new Models\DeleteBucketCorsRequest('bucket-123');
$input = BucketCors::fromDeleteBucketCors($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
}
public function testToDeleteBucketCors()
{
// empty output
$output = new OperationOutput();
$result = BucketCors::toDeleteBucketCors($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'No Content',
204,
['x-oss-request-id' => '123']
);
$result = BucketCors::toDeleteBucketCors($output);
$this->assertEquals('No Content', $result->status);
$this->assertEquals(204, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
}
public function testFromOptionObject()
{
// miss required field
try {
$request = new Models\OptionObjectRequest();
$input = BucketCors::fromOptionObject($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
try {
$request = new Models\OptionObjectRequest('bucket-123');
$input = BucketCors::fromOptionObject($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, key", (string)$e);
}
try {
$request = new Models\OptionObjectRequest('bucket-123', 'key-123');
$input = BucketCors::fromOptionObject($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, origin", (string)$e);
}
try {
$request = new Models\OptionObjectRequest('bucket-123', 'key-123', 'http://www.example.com');
$input = BucketCors::fromOptionObject($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, accessControlRequestMethod", (string)$e);
}
$request = new Models\OptionObjectRequest('bucket-123', 'key-123', 'http://www.example.com', 'PUT');
$input = BucketCors::fromOptionObject($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
}
public function testToOptionObject()
{
// empty output
$output = new OperationOutput();
$result = BucketCors::toOptionObject($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123', 'Access-Control-Allow-Origin' => 'http://www.example.com', 'Access-Control-Allow-Methods' => 'PUT', 'Access-Control-Allow-Headers' => 'x-oss-allow', 'Access-Control-Expose-Headers' => 'x-oss-test1,x-oss-test2', 'Access-Control-Max-Age' => "60"]
);
$result = BucketCors::toOptionObject($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(6, count($result->headers));
$this->assertEquals('http://www.example.com', $result->accessControlAllowOrigin);
$this->assertEquals('x-oss-test1,x-oss-test2', $result->accessControlExposeHeaders);
$this->assertEquals('x-oss-allow', $result->accessControlAllowHeaders);
$this->assertEquals('PUT', $result->accessControlAllowMethods);
$this->assertEquals(60, $result->accessControlMaxAge);
}
private function cleanXml($xml): array|string
{
return str_replace("\n", "", str_replace("\r", "", $xml));
}
}

232
vendor/alibabacloud/oss-v2/tests/UnitTests/Transform/BucketEncryptionTest.php vendored Normal file
View File

@@ -0,0 +1,232 @@
<?php
namespace UnitTests\Transform;
use AlibabaCloud\Oss\V2\Models;
use AlibabaCloud\Oss\V2\Transform\BucketEncryption;
use AlibabaCloud\Oss\V2\OperationOutput;
use AlibabaCloud\Oss\V2\Utils;
class BucketEncryptionTest extends \PHPUnit\Framework\TestCase
{
public function testFromPutBucketEncryption()
{
// miss required field
try {
$request = new Models\PutBucketEncryptionRequest();
$input = BucketEncryption::fromPutBucketEncryption($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
try {
$request = new Models\PutBucketEncryptionRequest('bucket-123');
$input = BucketEncryption::fromPutBucketEncryption($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, serverSideEncryptionRule", (string)$e);
}
// demo1
$request = new Models\PutBucketEncryptionRequest('bucket-123', new Models\ServerSideEncryptionRule(
new Models\ApplyServerSideEncryptionByDefault(
sseAlgorithm: 'KMS',
kmsDataEncryption: 'SM4'
)));
$input = BucketEncryption::fromPutBucketEncryption($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><ServerSideEncryptionRule><ApplyServerSideEncryptionByDefault><SSEAlgorithm>KMS</SSEAlgorithm><KMSDataEncryption>SM4</KMSDataEncryption></ApplyServerSideEncryptionByDefault></ServerSideEncryptionRule>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
// demo2
$request = new Models\PutBucketEncryptionRequest('bucket-123', new Models\ServerSideEncryptionRule(
new Models\ApplyServerSideEncryptionByDefault(
sseAlgorithm: 'KMS',
kmsMasterKeyID: '9468da86-3509-4f8d-a61e-6eab1eac****',
kmsDataEncryption: 'SM4'
)));
$input = BucketEncryption::fromPutBucketEncryption($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><ServerSideEncryptionRule><ApplyServerSideEncryptionByDefault><SSEAlgorithm>KMS</SSEAlgorithm><KMSMasterKeyID>9468da86-3509-4f8d-a61e-6eab1eac****</KMSMasterKeyID><KMSDataEncryption>SM4</KMSDataEncryption></ApplyServerSideEncryptionByDefault></ServerSideEncryptionRule>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
// demo3
$request = new Models\PutBucketEncryptionRequest('bucket-123', new Models\ServerSideEncryptionRule(
new Models\ApplyServerSideEncryptionByDefault(
sseAlgorithm: 'AES256',
)));
$input = BucketEncryption::fromPutBucketEncryption($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><ServerSideEncryptionRule><ApplyServerSideEncryptionByDefault><SSEAlgorithm>AES256</SSEAlgorithm></ApplyServerSideEncryptionByDefault></ServerSideEncryptionRule>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
}
public function testToPutBucketEncryption()
{
// empty output
$output = new OperationOutput();
$result = BucketEncryption::toPutBucketEncryption($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123']
);
$result = BucketEncryption::toPutBucketEncryption($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
}
public function testFromGetBucketEncryption()
{
// miss required field
try {
$request = new Models\GetBucketEncryptionRequest();
$input = BucketEncryption::fromGetBucketEncryption($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
$request = new Models\GetBucketEncryptionRequest('bucket-123');
$input = BucketEncryption::fromGetBucketEncryption($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
}
public function testToGetBucketEncryption()
{
// empty output
$output = new OperationOutput();
$result = BucketEncryption::toGetBucketEncryption($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$body = '<?xml version="1.0" encoding="UTF-8"?>
<ServerSideEncryptionRule>
<ApplyServerSideEncryptionByDefault>
<SSEAlgorithm>KMS</SSEAlgorithm>
<KMSMasterKeyID>9468da86-3509-4f8d-a61e-6eab1eac****</KMSMasterKeyID>
</ApplyServerSideEncryptionByDefault>
</ServerSideEncryptionRule>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123'],
Utils::streamFor($body)
);
$result = BucketEncryption::toGetBucketEncryption($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals('9468da86-3509-4f8d-a61e-6eab1eac****', $result->serverSideEncryptionRule->applyServerSideEncryptionByDefault->kmsMasterKeyID);
$this->assertEquals('KMS', $result->serverSideEncryptionRule->applyServerSideEncryptionByDefault->sseAlgorithm);
$body = '<?xml version="1.0" encoding="UTF-8"?>
<ServerSideEncryptionRule>
<ApplyServerSideEncryptionByDefault>
<SSEAlgorithm>KMS</SSEAlgorithm>
<KMSDataEncryption>SM4</KMSDataEncryption>
<KMSMasterKeyID>9468da86-3509-4f8d-a61e-6eab1eac****</KMSMasterKeyID>
</ApplyServerSideEncryptionByDefault>
</ServerSideEncryptionRule>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123'],
Utils::streamFor($body)
);
$result = BucketEncryption::toGetBucketEncryption($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals('9468da86-3509-4f8d-a61e-6eab1eac****', $result->serverSideEncryptionRule->applyServerSideEncryptionByDefault->kmsMasterKeyID);
$this->assertEquals('KMS', $result->serverSideEncryptionRule->applyServerSideEncryptionByDefault->sseAlgorithm);
$this->assertEquals('SM4', $result->serverSideEncryptionRule->applyServerSideEncryptionByDefault->kmsDataEncryption);
$body = '<?xml version="1.0" encoding="UTF-8"?>
<ServerSideEncryptionRule>
<ApplyServerSideEncryptionByDefault>
<SSEAlgorithm>AES256</SSEAlgorithm>
</ApplyServerSideEncryptionByDefault>
</ServerSideEncryptionRule>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123'],
Utils::streamFor($body)
);
$result = BucketEncryption::toGetBucketEncryption($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals('AES256', $result->serverSideEncryptionRule->applyServerSideEncryptionByDefault->sseAlgorithm);
}
public function testFromDeleteBucketEncryption()
{
// miss required field
try {
$request = new Models\DeleteBucketEncryptionRequest();
$input = BucketEncryption::fromDeleteBucketEncryption($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
$request = new Models\DeleteBucketEncryptionRequest('bucket-123');
$input = BucketEncryption::fromDeleteBucketEncryption($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
}
public function testToDeleteBucketEncryption()
{
// empty output
$output = new OperationOutput();
$result = BucketEncryption::toDeleteBucketEncryption($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'No Content',
204,
['x-oss-request-id' => '123']
);
$result = BucketEncryption::toDeleteBucketEncryption($output);
$this->assertEquals('No Content', $result->status);
$this->assertEquals(204, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
}
private function cleanXml($xml): array|string
{
return str_replace("\n", "", str_replace("\r", "", $xml));
}
}

177
vendor/alibabacloud/oss-v2/tests/UnitTests/Transform/BucketHttpsConfigTest.php vendored Normal file
View File

@@ -0,0 +1,177 @@
<?php
namespace UnitTests\Transform;
use AlibabaCloud\Oss\V2\Models;
use AlibabaCloud\Oss\V2\Transform\BucketHttpsConfig;
use AlibabaCloud\Oss\V2\OperationOutput;
use AlibabaCloud\Oss\V2\Utils;
class BucketHttpsConfigTest extends \PHPUnit\Framework\TestCase
{
public function testFromPutBucketHttpsConfig()
{
// miss required field
try {
$request = new Models\PutBucketHttpsConfigRequest();
$input = BucketHttpsConfig::fromPutBucketHttpsConfig($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
try {
$request = new Models\PutBucketHttpsConfigRequest('bucket-123');
$input = BucketHttpsConfig::fromPutBucketHttpsConfig($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, httpsConfiguration", (string)$e);
}
// demo1
$request = new Models\PutBucketHttpsConfigRequest('bucket-123', new Models\HttpsConfiguration(
tls: new Models\TLS(
tlsVersions: ['TLSv1.2', 'TLSv1.3'],
enable: true
)
));
$input = BucketHttpsConfig::fromPutBucketHttpsConfig($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><HttpsConfiguration><TLS><TLSVersion>TLSv1.2</TLSVersion><TLSVersion>TLSv1.3</TLSVersion><Enable>true</Enable></TLS></HttpsConfiguration>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
// demo2
$request = new Models\PutBucketHttpsConfigRequest('bucket-123', new Models\HttpsConfiguration(
tls: new Models\TLS(
tlsVersions: ['TLSv1.2', 'TLSv1.3'],
enable: true
),
cipherSuite: new Models\CipherSuite(
enable: true,
strongCipherSuite: false,
customCipherSuites: ['ECDHE-ECDSA-AES128-SHA256', 'ECDHE-RSA-AES128-GCM-SHA256', 'ECDHE-ECDSA-AES256-CCM8'],
tls13CustomCipherSuites: ['ECDHE-ECDSA-AES256-CCM8', 'ECDHE-ECDSA-AES256-CCM8', 'ECDHE-ECDSA-AES256-CCM8'],
)
));
$input = BucketHttpsConfig::fromPutBucketHttpsConfig($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><HttpsConfiguration><TLS><TLSVersion>TLSv1.2</TLSVersion><TLSVersion>TLSv1.3</TLSVersion><Enable>true</Enable></TLS><CipherSuite><Enable>true</Enable><StrongCipherSuite>false</StrongCipherSuite><CustomCipherSuite>ECDHE-ECDSA-AES128-SHA256</CustomCipherSuite><CustomCipherSuite>ECDHE-RSA-AES128-GCM-SHA256</CustomCipherSuite><CustomCipherSuite>ECDHE-ECDSA-AES256-CCM8</CustomCipherSuite><TLS13CustomCipherSuite>ECDHE-ECDSA-AES256-CCM8</TLS13CustomCipherSuite><TLS13CustomCipherSuite>ECDHE-ECDSA-AES256-CCM8</TLS13CustomCipherSuite><TLS13CustomCipherSuite>ECDHE-ECDSA-AES256-CCM8</TLS13CustomCipherSuite></CipherSuite></HttpsConfiguration>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
}
public function testToPutBucketHttpsConfig()
{
// empty output
$output = new OperationOutput();
$result = BucketHttpsConfig::toPutBucketHttpsConfig($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123']
);
$result = BucketHttpsConfig::toPutBucketHttpsConfig($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
}
public function testFromGetBucketHttpsConfig()
{
// miss required field
try {
$request = new Models\GetBucketHttpsConfigRequest();
$input = BucketHttpsConfig::fromGetBucketHttpsConfig($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
$request = new Models\GetBucketHttpsConfigRequest('bucket-123');
$input = BucketHttpsConfig::fromGetBucketHttpsConfig($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
}
public function testToGetBucketHttpsConfig()
{
// empty output
$output = new OperationOutput();
$result = BucketHttpsConfig::toGetBucketHttpsConfig($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$body = '<?xml version="1.0" encoding="UTF-8"?>
<HttpsConfiguration>
<TLS>
<Enable>true</Enable>
<TLSVersion>TLSv1.2</TLSVersion>
<TLSVersion>TLSv1.3</TLSVersion>
</TLS>
</HttpsConfiguration>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123', 'content-type' => 'application/xml'],
Utils::streamFor($body)
);
$result = BucketHttpsConfig::toGetBucketHttpsConfig($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(2, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals('application/xml', $result->headers['content-type']);
$this->assertTrue($result->httpsConfiguration->tls->enable);
$this->assertEquals(2, count($result->httpsConfiguration->tls->tlsVersions));
$this->assertEquals("TLSv1.2", $result->httpsConfiguration->tls->tlsVersions[0]);
$this->assertEquals("TLSv1.3", $result->httpsConfiguration->tls->tlsVersions[1]);
$body = '<?xml version="1.0" encoding="UTF-8"?><HttpsConfiguration><TLS><TLSVersion>TLSv1.2</TLSVersion><TLSVersion>TLSv1.3</TLSVersion><Enable>true</Enable></TLS><CipherSuite><Enable>true</Enable><StrongCipherSuite>false</StrongCipherSuite><CustomCipherSuite>ECDHE-ECDSA-AES128-SHA256</CustomCipherSuite><CustomCipherSuite>ECDHE-RSA-AES128-GCM-SHA256</CustomCipherSuite><CustomCipherSuite>ECDHE-ECDSA-AES256-CCM8</CustomCipherSuite><TLS13CustomCipherSuite>ECDHE-ECDSA-AES256-CCM8</TLS13CustomCipherSuite><TLS13CustomCipherSuite>ECDHE-ECDSA-AES256-CCM8</TLS13CustomCipherSuite><TLS13CustomCipherSuite>ECDHE-ECDSA-AES256-CCM8</TLS13CustomCipherSuite></CipherSuite></HttpsConfiguration>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123', 'content-type' => 'application/xml'],
Utils::streamFor($body)
);
$result = BucketHttpsConfig::toGetBucketHttpsConfig($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(2, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals('application/xml', $result->headers['content-type']);
$this->assertTrue($result->httpsConfiguration->tls->enable);
$this->assertEquals(2, count($result->httpsConfiguration->tls->tlsVersions));
$this->assertEquals("TLSv1.2", $result->httpsConfiguration->tls->tlsVersions[0]);
$this->assertEquals("TLSv1.3", $result->httpsConfiguration->tls->tlsVersions[1]);
$this->assertTrue($result->httpsConfiguration->cipherSuite->enable);
$this->assertFalse($result->httpsConfiguration->cipherSuite->strongCipherSuite);
$this->assertEquals(3, count($result->httpsConfiguration->cipherSuite->customCipherSuites));
$this->assertEquals('ECDHE-ECDSA-AES128-SHA256', $result->httpsConfiguration->cipherSuite->customCipherSuites[0]);
$this->assertEquals('ECDHE-RSA-AES128-GCM-SHA256', $result->httpsConfiguration->cipherSuite->customCipherSuites[1]);
$this->assertEquals('ECDHE-ECDSA-AES256-CCM8', $result->httpsConfiguration->cipherSuite->customCipherSuites[2]);
$this->assertEquals(3, count($result->httpsConfiguration->cipherSuite->tls13CustomCipherSuites));
$this->assertEquals('ECDHE-ECDSA-AES256-CCM8', $result->httpsConfiguration->cipherSuite->tls13CustomCipherSuites[0]);
$this->assertEquals('ECDHE-ECDSA-AES256-CCM8', $result->httpsConfiguration->cipherSuite->tls13CustomCipherSuites[1]);
$this->assertEquals('ECDHE-ECDSA-AES256-CCM8', $result->httpsConfiguration->cipherSuite->tls13CustomCipherSuites[2]);
}
private function cleanXml($xml): array|string
{
return str_replace("\n", "", str_replace("\r", "", $xml));
}
}

497
vendor/alibabacloud/oss-v2/tests/UnitTests/Transform/BucketInventoryTest.php vendored Normal file
View File

@@ -0,0 +1,497 @@
<?php
namespace UnitTests\Transform;
use AlibabaCloud\Oss\V2\Models;
use AlibabaCloud\Oss\V2\Transform\BucketInventory;
use AlibabaCloud\Oss\V2\OperationOutput;
use AlibabaCloud\Oss\V2\Utils;
class BucketInventoryTest extends \PHPUnit\Framework\TestCase
{
public function testFromPutBucketInventory()
{
// miss required field
try {
$request = new Models\PutBucketInventoryRequest();
$input = BucketInventory::fromPutBucketInventory($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
try {
$request = new Models\PutBucketInventoryRequest('bucket-123');
$input = BucketInventory::fromPutBucketInventory($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, inventoryId", (string)$e);
}
try {
$request = new Models\PutBucketInventoryRequest('bucket-123', 'inventory-id');
$input = BucketInventory::fromPutBucketInventory($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, inventoryConfiguration", (string)$e);
}
// demo1
$request = new Models\PutBucketInventoryRequest('bucket-123', 'report1', inventoryConfiguration: new Models\InventoryConfiguration(
isEnabled: true,
destination: new Models\InventoryDestination(
ossBucketDestination: new Models\InventoryOSSBucketDestination(
bucket: 'acs:oss:::destination-bucket',
prefix: 'prefix1',
encryption: new Models\InventoryEncryption(
sseKms: new Models\SSEKMS('keyId')
),
format: Models\InventoryFormatType::CSV,
accountId: '1000000000000000', roleArn: 'acs:ram::1000000000000000:role/AliyunOSSRole'
)
),
filter: new Models\InventoryFilter(
prefix: 'filterPrefix',
lastModifyBeginTimeStamp: 1637883649,
lastModifyEndTimeStamp: 1638347592,
lowerSizeBound: 1024,
upperSizeBound: 1048576,
storageClass: 'Standard,IA'
),
includedObjectVersions: 'All',
optionalFields: new Models\OptionalFields(
[
Models\InventoryOptionalFieldType::SIZE,
Models\InventoryOptionalFieldType::LAST_MODIFIED_DATE,
Models\InventoryOptionalFieldType::ETAG,
Models\InventoryOptionalFieldType::STORAGE_CLASS,
Models\InventoryOptionalFieldType::IS_MULTIPART_UPLOADED,
Models\InventoryOptionalFieldType::ENCRYPTION_STATUS,
Models\InventoryOptionalFieldType::TRANSITION_TIME,
]
),
id: 'report1'
));
$input = BucketInventory::fromPutBucketInventory($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><InventoryConfiguration><IsEnabled>true</IsEnabled><Destination><OSSBucketDestination><Bucket>acs:oss:::destination-bucket</Bucket><Prefix>prefix1</Prefix><Encryption><SSE-KMS><KeyId>keyId</KeyId></SSE-KMS></Encryption><Format>CSV</Format><AccountId>1000000000000000</AccountId><RoleArn>acs:ram::1000000000000000:role/AliyunOSSRole</RoleArn></OSSBucketDestination></Destination><Filter><Prefix>filterPrefix</Prefix><LastModifyBeginTimeStamp>1637883649</LastModifyBeginTimeStamp><LastModifyEndTimeStamp>1638347592</LastModifyEndTimeStamp><LowerSizeBound>1024</LowerSizeBound><UpperSizeBound>1048576</UpperSizeBound><StorageClass>Standard,IA</StorageClass></Filter><IncludedObjectVersions>All</IncludedObjectVersions><OptionalFields><Field>Size</Field><Field>LastModifiedDate</Field><Field>ETag</Field><Field>StorageClass</Field><Field>IsMultipartUploaded</Field><Field>EncryptionStatus</Field><Field>TransitionTime</Field></OptionalFields><Id>report1</Id></InventoryConfiguration>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
// demo2
$request = new Models\PutBucketInventoryRequest('bucket-123', 'report1', inventoryConfiguration: new Models\InventoryConfiguration(
isEnabled: true,
destination: new Models\InventoryDestination(
ossBucketDestination: new Models\InventoryOSSBucketDestination(
bucket: 'acs:oss:::destination-bucket',
format: Models\InventoryFormatType::CSV,
accountId: '1000000000000000',
roleArn: 'acs:ram::1000000000000000:role/AliyunOSSRole'
)
),
schedule: new Models\InventorySchedule(
frequency: Models\InventoryFrequencyType::DAILY
),
filter: new Models\InventoryFilter(
prefix: 'filterPrefix',
lastModifyBeginTimeStamp: 1637883649,
lastModifyEndTimeStamp: 1638347592,
lowerSizeBound: 1024,
upperSizeBound: 1048576,
storageClass: 'Standard,IA'
),
includedObjectVersions: 'All',
id: 'report1'
));
$input = BucketInventory::fromPutBucketInventory($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><InventoryConfiguration><IsEnabled>true</IsEnabled><Destination><OSSBucketDestination><Bucket>acs:oss:::destination-bucket</Bucket><Format>CSV</Format><AccountId>1000000000000000</AccountId><RoleArn>acs:ram::1000000000000000:role/AliyunOSSRole</RoleArn></OSSBucketDestination></Destination><Schedule><Frequency>Daily</Frequency></Schedule><Filter><Prefix>filterPrefix</Prefix><LastModifyBeginTimeStamp>1637883649</LastModifyBeginTimeStamp><LastModifyEndTimeStamp>1638347592</LastModifyEndTimeStamp><LowerSizeBound>1024</LowerSizeBound><UpperSizeBound>1048576</UpperSizeBound><StorageClass>Standard,IA</StorageClass></Filter><IncludedObjectVersions>All</IncludedObjectVersions><Id>report1</Id></InventoryConfiguration>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
}
public function testToPutBucketInventory()
{
// empty output
$output = new OperationOutput();
$result = BucketInventory::toPutBucketInventory($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123']
);
$result = BucketInventory::toPutBucketInventory($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
}
public function testFromGetBucketInventory()
{
// miss required field
try {
$request = new Models\GetBucketInventoryRequest();
$input = BucketInventory::fromGetBucketInventory($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
try {
$request = new Models\GetBucketInventoryRequest('bucket-123');
$input = BucketInventory::fromGetBucketInventory($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, inventoryId", (string)$e);
}
$request = new Models\GetBucketInventoryRequest('bucket-123', 'inventoryId');
$input = BucketInventory::fromGetBucketInventory($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
}
public function testToGetBucketInventory()
{
// empty output
$output = new OperationOutput();
$result = BucketInventory::toGetBucketInventory($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$body = '<?xml version="1.0" encoding="UTF-8"?>
<InventoryConfiguration>
<Id>report1</Id>
<IsEnabled>true</IsEnabled>
<Destination>
<OSSBucketDestination>
<Format>CSV</Format>
<AccountId>1000000000000000</AccountId>
<RoleArn>acs:ram::1000000000000000:role/AliyunOSSRole</RoleArn>
<Bucket>acs:oss:::bucket_0001</Bucket>
<Prefix>prefix1</Prefix>
<Encryption>
<SSE-KMS>
<KeyId>keyId</KeyId>
</SSE-KMS>
</Encryption>
</OSSBucketDestination>
</Destination>
<Schedule>
<Frequency>Daily</Frequency>
</Schedule>
<Filter>
<LastModifyBeginTimeStamp>1637883649</LastModifyBeginTimeStamp>
<LastModifyEndTimeStamp>1638347592</LastModifyEndTimeStamp>
<LowerSizeBound>1024</LowerSizeBound>
<UpperSizeBound>1048576</UpperSizeBound>
<StorageClass>Standard,IA</StorageClass>
<Prefix>myprefix/</Prefix>
</Filter>
<IncludedObjectVersions>All</IncludedObjectVersions>
<OptionalFields>
<Field>Size</Field>
<Field>LastModifiedDate</Field>
<Field>ETag</Field>
<Field>StorageClass</Field>
<Field>IsMultipartUploaded</Field>
<Field>EncryptionStatus</Field>
<Field>TransitionTime</Field>
</OptionalFields>
</InventoryConfiguration>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123'],
Utils::streamFor($body)
);
$result = BucketInventory::toGetBucketInventory($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals('report1', $result->inventoryConfiguration->id);
$this->assertTrue($result->inventoryConfiguration->isEnabled);
$this->assertEquals(Models\InventoryFormatType::CSV, $result->inventoryConfiguration->destination->ossBucketDestination->format);
$this->assertEquals('1000000000000000', $result->inventoryConfiguration->destination->ossBucketDestination->accountId);
$this->assertEquals('acs:ram::1000000000000000:role/AliyunOSSRole', $result->inventoryConfiguration->destination->ossBucketDestination->roleArn);
$this->assertEquals('acs:oss:::bucket_0001', $result->inventoryConfiguration->destination->ossBucketDestination->bucket);
$this->assertEquals('prefix1', $result->inventoryConfiguration->destination->ossBucketDestination->prefix);
$this->assertEquals('keyId', $result->inventoryConfiguration->destination->ossBucketDestination->encryption->sseKms->keyId);
$this->assertEquals(Models\InventoryFrequencyType::DAILY, $result->inventoryConfiguration->schedule->frequency);
$this->assertEquals('All', $result->inventoryConfiguration->includedObjectVersions);
$this->assertEquals(7, count($result->inventoryConfiguration->optionalFields->fields));
$this->assertEquals(Models\InventoryOptionalFieldType::STORAGE_CLASS, $result->inventoryConfiguration->optionalFields->fields[3]);
$this->assertEquals(Models\InventoryOptionalFieldType::TRANSITION_TIME, $result->inventoryConfiguration->optionalFields->fields[6]);
$this->assertEquals('myprefix/', $result->inventoryConfiguration->filter->prefix);
$this->assertEquals(1637883649, $result->inventoryConfiguration->filter->lastModifyBeginTimeStamp);
$this->assertEquals(1638347592, $result->inventoryConfiguration->filter->lastModifyEndTimeStamp);
$this->assertEquals(1024, $result->inventoryConfiguration->filter->lowerSizeBound);
$this->assertEquals(1048576, $result->inventoryConfiguration->filter->upperSizeBound);
$this->assertEquals('Standard,IA', $result->inventoryConfiguration->filter->storageClass);
$body = '<?xml version="1.0" encoding="UTF-8"?>
<InventoryConfiguration>
<Id>report1</Id>
<IsEnabled>true</IsEnabled>
<Destination>
<OSSBucketDestination>
<Format>CSV</Format>
<AccountId>1000000000000000</AccountId>
<RoleArn>acs:ram::1000000000000000:role/AliyunOSSRole</RoleArn>
<Bucket>acs:oss:::destination-bucket</Bucket>
</OSSBucketDestination>
</Destination>
<Schedule>
<Frequency>Weekly</Frequency>
</Schedule>
<IncludedObjectVersions>Current</IncludedObjectVersions>
</InventoryConfiguration>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123'],
Utils::streamFor($body)
);
$result = BucketInventory::toGetBucketInventory($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals('report1', $result->inventoryConfiguration->id);
$this->assertTrue($result->inventoryConfiguration->isEnabled);
$this->assertEquals(Models\InventoryFormatType::CSV, $result->inventoryConfiguration->destination->ossBucketDestination->format);
$this->assertEquals('1000000000000000', $result->inventoryConfiguration->destination->ossBucketDestination->accountId);
$this->assertEquals('acs:ram::1000000000000000:role/AliyunOSSRole', $result->inventoryConfiguration->destination->ossBucketDestination->roleArn);
$this->assertEquals('acs:oss:::destination-bucket', $result->inventoryConfiguration->destination->ossBucketDestination->bucket);
$this->assertEquals(Models\InventoryFrequencyType::WEEKLY, $result->inventoryConfiguration->schedule->frequency);
$this->assertEquals('Current', $result->inventoryConfiguration->includedObjectVersions);
}
public function testFromListBucketInventory()
{
// miss required field
try {
$request = new Models\ListBucketInventoryRequest();
$input = BucketInventory::fromListBucketInventory($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
$request = new Models\ListBucketInventoryRequest('bucket-123');
$input = BucketInventory::fromListBucketInventory($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
$request = new Models\ListBucketInventoryRequest('bucket-123', 'token');
$input = BucketInventory::fromListBucketInventory($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('token', $input->getParameters()['continuation-token']);
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
}
public function testToListBucketInventory()
{
// empty output
$output = new OperationOutput();
$result = BucketInventory::toListBucketInventory($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$body = '<?xml version="1.0" encoding="UTF-8"?>
<ListInventoryConfigurationsResult>
<InventoryConfiguration>
<Id>report1</Id>
<IsEnabled>true</IsEnabled>
<Destination>
<OSSBucketDestination>
<Format>CSV</Format>
<AccountId>1000000000000000</AccountId>
<RoleArn>acs:ram::1000000000000000:role/AliyunOSSRole</RoleArn>
<Bucket>acs:oss:::destination-bucket</Bucket>
<Prefix>prefix1</Prefix>
</OSSBucketDestination>
</Destination>
<Schedule>
<Frequency>Daily</Frequency>
</Schedule>
<Filter>
<Prefix>prefix/One</Prefix>
</Filter>
<IncludedObjectVersions>All</IncludedObjectVersions>
<OptionalFields>
<Field>Size</Field>
<Field>LastModifiedDate</Field>
<Field>ETag</Field>
<Field>StorageClass</Field>
<Field>IsMultipartUploaded</Field>
<Field>EncryptionStatus</Field>
</OptionalFields>
</InventoryConfiguration>
<InventoryConfiguration>
<Id>report2</Id>
<IsEnabled>true</IsEnabled>
<Destination>
<OSSBucketDestination>
<Format>CSV</Format>
<AccountId>1000000000000000</AccountId>
<RoleArn>acs:ram::1000000000000000:role/AliyunOSSRole</RoleArn>
<Bucket>acs:oss:::destination-bucket</Bucket>
<Prefix>prefix2</Prefix>
</OSSBucketDestination>
</Destination>
<Schedule>
<Frequency>Daily</Frequency>
</Schedule>
<Filter>
<Prefix>prefix/Two</Prefix>
</Filter>
<IncludedObjectVersions>All</IncludedObjectVersions>
<OptionalFields>
<Field>Size</Field>
<Field>LastModifiedDate</Field>
<Field>ETag</Field>
<Field>StorageClass</Field>
<Field>IsMultipartUploaded</Field>
<Field>EncryptionStatus</Field>
</OptionalFields>
</InventoryConfiguration>
<InventoryConfiguration>
<Id>report3</Id>
<IsEnabled>true</IsEnabled>
<Destination>
<OSSBucketDestination>
<Format>CSV</Format>
<AccountId>1000000000000000</AccountId>
<RoleArn>acs:ram::1000000000000000:role/AliyunOSSRole</RoleArn>
<Bucket>acs:oss:::destination-bucket</Bucket>
<Prefix>prefix3</Prefix>
</OSSBucketDestination>
</Destination>
<Schedule>
<Frequency>Daily</Frequency>
</Schedule>
<Filter>
<Prefix>prefix/Three</Prefix>
</Filter>
<IncludedObjectVersions>All</IncludedObjectVersions>
<OptionalFields>
<Field>Size</Field>
<Field>LastModifiedDate</Field>
<Field>ETag</Field>
<Field>StorageClass</Field>
<Field>IsMultipartUploaded</Field>
<Field>EncryptionStatus</Field>
</OptionalFields>
</InventoryConfiguration>
<IsTruncated>false</IsTruncated>
</ListInventoryConfigurationsResult>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123'],
Utils::streamFor($body)
);
$result = BucketInventory::toListBucketInventory($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals(3, count($result->listInventoryConfigurationsResult->inventoryConfigurations));
$this->assertEquals('report1', $result->listInventoryConfigurationsResult->inventoryConfigurations[0]->id);
$this->assertTrue($result->listInventoryConfigurationsResult->inventoryConfigurations[0]->isEnabled);
$this->assertEquals(Models\InventoryFormatType::CSV, $result->listInventoryConfigurationsResult->inventoryConfigurations[0]->destination->ossBucketDestination->format);
$this->assertEquals('1000000000000000', $result->listInventoryConfigurationsResult->inventoryConfigurations[0]->destination->ossBucketDestination->accountId);
$this->assertEquals('acs:ram::1000000000000000:role/AliyunOSSRole', $result->listInventoryConfigurationsResult->inventoryConfigurations[0]->destination->ossBucketDestination->roleArn);
$this->assertEquals('acs:oss:::destination-bucket', $result->listInventoryConfigurationsResult->inventoryConfigurations[0]->destination->ossBucketDestination->bucket);
$this->assertEquals('prefix1', $result->listInventoryConfigurationsResult->inventoryConfigurations[0]->destination->ossBucketDestination->prefix);
$this->assertEquals(Models\InventoryFrequencyType::DAILY, $result->listInventoryConfigurationsResult->inventoryConfigurations[0]->schedule->frequency);
$this->assertEquals('All', $result->listInventoryConfigurationsResult->inventoryConfigurations[0]->includedObjectVersions);
$this->assertEquals(6, count($result->listInventoryConfigurationsResult->inventoryConfigurations[0]->optionalFields->fields));
$this->assertEquals(Models\InventoryOptionalFieldType::STORAGE_CLASS, $result->listInventoryConfigurationsResult->inventoryConfigurations[0]->optionalFields->fields[3]);
$this->assertEquals('prefix/One', $result->listInventoryConfigurationsResult->inventoryConfigurations[0]->filter->prefix);
$this->assertEquals('report2', $result->listInventoryConfigurationsResult->inventoryConfigurations[1]->id);
$this->assertTrue($result->listInventoryConfigurationsResult->inventoryConfigurations[1]->isEnabled);
$this->assertEquals(Models\InventoryFormatType::CSV, $result->listInventoryConfigurationsResult->inventoryConfigurations[1]->destination->ossBucketDestination->format);
$this->assertEquals('1000000000000000', $result->listInventoryConfigurationsResult->inventoryConfigurations[1]->destination->ossBucketDestination->accountId);
$this->assertEquals('acs:ram::1000000000000000:role/AliyunOSSRole', $result->listInventoryConfigurationsResult->inventoryConfigurations[1]->destination->ossBucketDestination->roleArn);
$this->assertEquals('acs:oss:::destination-bucket', $result->listInventoryConfigurationsResult->inventoryConfigurations[1]->destination->ossBucketDestination->bucket);
$this->assertEquals('prefix2', $result->listInventoryConfigurationsResult->inventoryConfigurations[1]->destination->ossBucketDestination->prefix);
$this->assertEquals(Models\InventoryFrequencyType::DAILY, $result->listInventoryConfigurationsResult->inventoryConfigurations[1]->schedule->frequency);
$this->assertEquals('All', $result->listInventoryConfigurationsResult->inventoryConfigurations[1]->includedObjectVersions);
$this->assertEquals(6, count($result->listInventoryConfigurationsResult->inventoryConfigurations[1]->optionalFields->fields));
$this->assertEquals(Models\InventoryOptionalFieldType::STORAGE_CLASS, $result->listInventoryConfigurationsResult->inventoryConfigurations[1]->optionalFields->fields[3]);
$this->assertEquals('prefix/Two', $result->listInventoryConfigurationsResult->inventoryConfigurations[1]->filter->prefix);
$this->assertFalse($result->listInventoryConfigurationsResult->isTruncated);
}
public function testFromDeleteBucketInventory()
{
// miss required field
try {
$request = new Models\DeleteBucketInventoryRequest();
$input = BucketInventory::fromDeleteBucketInventory($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
try {
$request = new Models\DeleteBucketInventoryRequest('bucket-123');
$input = BucketInventory::fromDeleteBucketInventory($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, inventoryId", (string)$e);
}
$request = new Models\DeleteBucketInventoryRequest('bucket-123', 'inventoryId');
$input = BucketInventory::fromDeleteBucketInventory($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
}
public function testToDeleteBucketInventory()
{
// empty output
$output = new OperationOutput();
$result = BucketInventory::toDeleteBucketInventory($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'No Content',
204,
['x-oss-request-id' => '123']
);
$result = BucketInventory::toDeleteBucketInventory($output);
$this->assertEquals('No Content', $result->status);
$this->assertEquals(204, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
}
private function cleanXml($xml): array|string
{
return str_replace("\n", "", str_replace("\r", "", $xml));
}
}

538
vendor/alibabacloud/oss-v2/tests/UnitTests/Transform/BucketLifecycleTest.php vendored Normal file
View File

@@ -0,0 +1,538 @@
<?php
namespace UnitTests\Transform;
use AlibabaCloud\Oss\V2\Models;
use AlibabaCloud\Oss\V2\Models\NoncurrentVersionTransition;
use AlibabaCloud\Oss\V2\Transform\BucketLifecycle;
use AlibabaCloud\Oss\V2\OperationOutput;
use AlibabaCloud\Oss\V2\Utils;
use DateTime;
use DateTimeZone;
class BucketLifecycleTest extends \PHPUnit\Framework\TestCase
{
public function testFromPutBucketLifecycle()
{
// miss required field
try {
$request = new Models\PutBucketLifecycleRequest();
$input = BucketLifecycle::fromPutBucketLifecycle($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
try {
$request = new Models\PutBucketLifecycleRequest('bucket-123');
$input = BucketLifecycle::fromPutBucketLifecycle($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, lifecycleConfiguration", (string)$e);
}
// demo1
$request = new Models\PutBucketLifecycleRequest('bucket-123');
$rule = new Models\LifecycleRule(prefix: '', id: 'rule', expiration: new Models\LifecycleRuleExpiration(expiredObjectDeleteMarker: true), noncurrentVersionExpiration: new Models\NoncurrentVersionExpiration(noncurrentDays: 5), status: 'Enabled');
$request->lifecycleConfiguration = new Models\LifecycleConfiguration(
array(
$rule
)
);
$input = BucketLifecycle::fromPutBucketLifecycle($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><LifecycleConfiguration><Rule><Prefix></Prefix><ID>rule</ID><Expiration><ExpiredObjectDeleteMarker>true</ExpiredObjectDeleteMarker></Expiration><NoncurrentVersionExpiration><NoncurrentDays>5</NoncurrentDays></NoncurrentVersionExpiration><Status>Enabled</Status></Rule></LifecycleConfiguration>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
// demo2
$request = new Models\PutBucketLifecycleRequest('bucket-123');
$rule = new Models\LifecycleRule(prefix: 'log/', id: 'rule', expiration: new Models\LifecycleRuleExpiration(days: 90), status: 'Enabled');
$request->lifecycleConfiguration = new Models\LifecycleConfiguration(
array(
$rule
)
);
$input = BucketLifecycle::fromPutBucketLifecycle($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><LifecycleConfiguration><Rule><Prefix>log/</Prefix><ID>rule</ID><Expiration><Days>90</Days></Expiration><Status>Enabled</Status></Rule></LifecycleConfiguration>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
// demo3
$request = new Models\PutBucketLifecycleRequest('bucket-123');
$rule = new Models\LifecycleRule(prefix: 'log/', transitions: array(
new Models\LifecycleRuleTransition(days: 30, storageClass: 'IA'),
new Models\LifecycleRuleTransition(days: 60, storageClass: 'Archive'),
), id: 'rule', expiration: new Models\LifecycleRuleExpiration(days: 3600), status: 'Enabled');
$request->lifecycleConfiguration = new Models\LifecycleConfiguration(
array(
$rule
)
);
$input = BucketLifecycle::fromPutBucketLifecycle($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><LifecycleConfiguration><Rule><Prefix>log/</Prefix><Transition><Days>30</Days><StorageClass>IA</StorageClass></Transition><Transition><Days>60</Days><StorageClass>Archive</StorageClass></Transition><ID>rule</ID><Expiration><Days>3600</Days></Expiration><Status>Enabled</Status></Rule></LifecycleConfiguration>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
// demo4
$request = new Models\PutBucketLifecycleRequest('bucket-123');
$rule = new Models\LifecycleRule(prefix: '', id: 'rule', expiration: new Models\LifecycleRuleExpiration(expiredObjectDeleteMarker: true), noncurrentVersionExpiration: new Models\NoncurrentVersionExpiration(noncurrentDays: 5), status: 'Enabled');
$request->lifecycleConfiguration = new Models\LifecycleConfiguration(
array(
$rule
)
);
$input = BucketLifecycle::fromPutBucketLifecycle($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><LifecycleConfiguration><Rule><Prefix></Prefix><ID>rule</ID><Expiration><ExpiredObjectDeleteMarker>true</ExpiredObjectDeleteMarker></Expiration><NoncurrentVersionExpiration><NoncurrentDays>5</NoncurrentDays></NoncurrentVersionExpiration><Status>Enabled</Status></Rule></LifecycleConfiguration>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
// demo5
$request = new Models\PutBucketLifecycleRequest('bucket-123');
$rule = new Models\LifecycleRule(prefix: '', transitions: array(
new Models\LifecycleRuleTransition(days: 30, storageClass: 'Archive'),
), filter: new Models\LifecycleRuleFilter(nots: array(new Models\LifecycleRuleNot(tag: new Models\Tag(key: 'key1', value: 'value1'), prefix: 'log')
)), id: 'rule', expiration: new Models\LifecycleRuleExpiration(expiredObjectDeleteMarker: true), noncurrentVersionExpiration: new Models\NoncurrentVersionExpiration(noncurrentDays: 5), status: 'Enabled');
$request->lifecycleConfiguration = new Models\LifecycleConfiguration(
array(
$rule
)
);
$input = BucketLifecycle::fromPutBucketLifecycle($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><LifecycleConfiguration><Rule><Prefix></Prefix><Transition><Days>30</Days><StorageClass>Archive</StorageClass></Transition><Filter><Not><Tag><Key>key1</Key><Value>value1</Value></Tag><Prefix>log</Prefix></Not></Filter><ID>rule</ID><Expiration><ExpiredObjectDeleteMarker>true</ExpiredObjectDeleteMarker></Expiration><NoncurrentVersionExpiration><NoncurrentDays>5</NoncurrentDays></NoncurrentVersionExpiration><Status>Enabled</Status></Rule></LifecycleConfiguration>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
$request = new Models\PutBucketLifecycleRequest('bucket-123');
$rule = new Models\LifecycleRule(
prefix: '',
transitions: array(
new Models\LifecycleRuleTransition(days: 30, storageClass: 'Archive'),
),
filter: new Models\LifecycleRuleFilter(
nots: array(
new Models\LifecycleRuleNot(tag: new Models\Tag(key: 'key1', value: 'value1'), prefix: 'log'),
new Models\LifecycleRuleNot(tag: new Models\Tag(key: 'key2', value: 'value2'), prefix: 'pre')
)),
id: 'rule',
expiration: new Models\LifecycleRuleExpiration(expiredObjectDeleteMarker: true),
noncurrentVersionExpiration: new Models\NoncurrentVersionExpiration(noncurrentDays: 5),
status: 'Enabled'
);
$request->lifecycleConfiguration = new Models\LifecycleConfiguration(
array(
$rule
)
);
$input = BucketLifecycle::fromPutBucketLifecycle($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><LifecycleConfiguration><Rule><Prefix></Prefix><Transition><Days>30</Days><StorageClass>Archive</StorageClass></Transition><Filter><Not><Tag><Key>key1</Key><Value>value1</Value></Tag><Prefix>log</Prefix></Not><Not><Tag><Key>key2</Key><Value>value2</Value></Tag><Prefix>pre</Prefix></Not></Filter><ID>rule</ID><Expiration><ExpiredObjectDeleteMarker>true</ExpiredObjectDeleteMarker></Expiration><NoncurrentVersionExpiration><NoncurrentDays>5</NoncurrentDays></NoncurrentVersionExpiration><Status>Enabled</Status></Rule></LifecycleConfiguration>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
// demo6
$request = new Models\PutBucketLifecycleRequest('bucket-123');
$rule = new Models\LifecycleRule(prefix: '', transitions: array(
new Models\LifecycleRuleTransition(days: 30, storageClass: 'Archive', isAccessTime: true, returnToStdWhenVisit: true),
), status: 'Enabled');
$request->lifecycleConfiguration = new Models\LifecycleConfiguration(
array(
$rule
)
);
$input = BucketLifecycle::fromPutBucketLifecycle($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><LifecycleConfiguration><Rule><Prefix></Prefix><Transition><Days>30</Days><StorageClass>Archive</StorageClass><IsAccessTime>true</IsAccessTime><ReturnToStdWhenVisit>true</ReturnToStdWhenVisit></Transition><Status>Enabled</Status></Rule></LifecycleConfiguration>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
// demo7
$request = new Models\PutBucketLifecycleRequest('bucket-123');
$rule = new Models\LifecycleRule(prefix: '', id: 'rule', abortMultipartUpload: new Models\LifecycleRuleAbortMultipartUpload(days: 30), status: 'Enabled');
$request->lifecycleConfiguration = new Models\LifecycleConfiguration(
array(
$rule
)
);
$input = BucketLifecycle::fromPutBucketLifecycle($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><LifecycleConfiguration><Rule><Prefix></Prefix><ID>rule</ID><AbortMultipartUpload><Days>30</Days></AbortMultipartUpload><Status>Enabled</Status></Rule></LifecycleConfiguration>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
// demo8
$request = new Models\PutBucketLifecycleRequest('bucket-123');
$request->lifecycleConfiguration = new Models\LifecycleConfiguration(
array(
new Models\LifecycleRule(prefix: 'dir1', id: 'rule1', expiration: new Models\LifecycleRuleExpiration(days: 180), status: 'Enabled'),
new Models\LifecycleRule(prefix: 'dir1/dir2/', id: 'rule2', expiration: new Models\LifecycleRuleExpiration(days: 30), status: 'Enabled'),
),
);
$input = BucketLifecycle::fromPutBucketLifecycle($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><LifecycleConfiguration><Rule><Prefix>dir1</Prefix><ID>rule1</ID><Expiration><Days>180</Days></Expiration><Status>Enabled</Status></Rule><Rule><Prefix>dir1/dir2/</Prefix><ID>rule2</ID><Expiration><Days>30</Days></Expiration><Status>Enabled</Status></Rule></LifecycleConfiguration>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
// demo9
$request = new Models\PutBucketLifecycleRequest('bucket-123');
$request->lifecycleConfiguration = new Models\LifecycleConfiguration(
array(
new Models\LifecycleRule(prefix: 'prefix0', id: 'r0', expiration: new Models\LifecycleRuleExpiration(days: 40, expiredObjectDeleteMarker: false), status: 'Enabled'),
new Models\LifecycleRule(prefix: 'prefix1', filter: new Models\LifecycleRuleFilter(objectSizeGreaterThan: 500, objectSizeLessThan: 64500), id: 'r1', expiration: new Models\LifecycleRuleExpiration(days: 40, expiredObjectDeleteMarker: false), status: 'Enabled'),
new Models\LifecycleRule(prefix: 'prefix3', transitions: array(new Models\LifecycleRuleTransition(days: 30, storageClass: 'IA', isAccessTime: false)), id: 'r3', expiration: new Models\LifecycleRuleExpiration(days: 40, expiredObjectDeleteMarker: false), status: 'Enabled'),
new Models\LifecycleRule(prefix: 'prefix4', transitions: array(new Models\LifecycleRuleTransition(days: 30, storageClass: 'IA', isAccessTime: false)), noncurrentVersionTransitions: array(new NoncurrentVersionTransition(noncurrentDays: 10, storageClass: 'IA', isAccessTime: true, returnToStdWhenVisit: true)), id: 'r4', abortMultipartUpload: new Models\LifecycleRuleAbortMultipartUpload(createdBeforeDate: new DateTime('2015-11-11T00:00:00.000Z', new DateTimeZone('UTC'))), status: 'Enabled'),
new Models\LifecycleRule(prefix: 'pre_', expiration: new Models\LifecycleRuleExpiration(days: 40, expiredObjectDeleteMarker: false), status: 'Enabled'),
),
);
$input = BucketLifecycle::fromPutBucketLifecycle($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><LifecycleConfiguration><Rule><Prefix>prefix0</Prefix><ID>r0</ID><Expiration><Days>40</Days><ExpiredObjectDeleteMarker>false</ExpiredObjectDeleteMarker></Expiration><Status>Enabled</Status></Rule><Rule><Prefix>prefix1</Prefix><Filter><ObjectSizeGreaterThan>500</ObjectSizeGreaterThan><ObjectSizeLessThan>64500</ObjectSizeLessThan></Filter><ID>r1</ID><Expiration><Days>40</Days><ExpiredObjectDeleteMarker>false</ExpiredObjectDeleteMarker></Expiration><Status>Enabled</Status></Rule><Rule><Prefix>prefix3</Prefix><Transition><Days>30</Days><StorageClass>IA</StorageClass><IsAccessTime>false</IsAccessTime></Transition><ID>r3</ID><Expiration><Days>40</Days><ExpiredObjectDeleteMarker>false</ExpiredObjectDeleteMarker></Expiration><Status>Enabled</Status></Rule><Rule><Prefix>prefix4</Prefix><Transition><Days>30</Days><StorageClass>IA</StorageClass><IsAccessTime>false</IsAccessTime></Transition><NoncurrentVersionTransition><NoncurrentDays>10</NoncurrentDays><StorageClass>IA</StorageClass><IsAccessTime>true</IsAccessTime><ReturnToStdWhenVisit>true</ReturnToStdWhenVisit></NoncurrentVersionTransition><ID>r4</ID><AbortMultipartUpload><CreatedBeforeDate>2015-11-11T00:00:00Z</CreatedBeforeDate></AbortMultipartUpload><Status>Enabled</Status></Rule><Rule><Prefix>pre_</Prefix><Expiration><Days>40</Days><ExpiredObjectDeleteMarker>false</ExpiredObjectDeleteMarker></Expiration><Status>Enabled</Status></Rule></LifecycleConfiguration>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
}
public function testToPutBucketLifecycle()
{
// empty output
$output = new OperationOutput();
$result = BucketLifecycle::toPutBucketLifecycle($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123']
);
$result = BucketLifecycle::toPutBucketLifecycle($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
}
public function testFromGetBucketLifecycle()
{
// miss required field
try {
$request = new Models\GetBucketLifecycleRequest();
$input = BucketLifecycle::fromGetBucketLifecycle($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
$request = new Models\GetBucketLifecycleRequest('bucket-123');
$input = BucketLifecycle::fromGetBucketLifecycle($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
}
public function testToGetBucketLifecycle()
{
// empty output
$output = new OperationOutput();
$result = BucketLifecycle::toGetBucketLifecycle($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$body = '<?xml version="1.0" encoding="UTF-8"?>
<LifecycleConfiguration>
<Rule>
<ID>delete after one day</ID>
<Prefix>logs1/</Prefix>
<Status>Enabled</Status>
<Expiration>
<Days>1</Days>
</Expiration>
</Rule>
<Rule>
<ID>mtime transition1</ID>
<Prefix>logs2/</Prefix>
<Status>Enabled</Status>
<Transition>
<Days>30</Days>
<StorageClass>IA</StorageClass>
</Transition>
</Rule>
<Rule>
<ID>mtime transition2</ID>
<Prefix>logs3/</Prefix>
<Status>Enabled</Status>
<Transition>
<Days>30</Days>
<StorageClass>IA</StorageClass>
<IsAccessTime>false</IsAccessTime>
</Transition>
</Rule>
</LifecycleConfiguration>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123'],
Utils::streamFor($body)
);
$result = BucketLifecycle::toGetBucketLifecycle($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals(3, count($result->lifecycleConfiguration->rules));
$this->assertEquals('delete after one day', $result->lifecycleConfiguration->rules[0]->id);
$this->assertEquals('logs1/', $result->lifecycleConfiguration->rules[0]->prefix);
$this->assertEquals('Enabled', $result->lifecycleConfiguration->rules[0]->status);
$this->assertEquals(1, $result->lifecycleConfiguration->rules[0]->expiration->days);
$this->assertEquals('mtime transition1', $result->lifecycleConfiguration->rules[1]->id);
$this->assertEquals('logs2/', $result->lifecycleConfiguration->rules[1]->prefix);
$this->assertEquals('Enabled', $result->lifecycleConfiguration->rules[1]->status);
$this->assertEquals(1, count($result->lifecycleConfiguration->rules[1]->transitions));
$this->assertEquals(30, $result->lifecycleConfiguration->rules[1]->transitions[0]->days);
$this->assertEquals('IA', $result->lifecycleConfiguration->rules[1]->transitions[0]->storageClass);
$this->assertEquals('mtime transition2', $result->lifecycleConfiguration->rules[2]->id);
$this->assertEquals('logs3/', $result->lifecycleConfiguration->rules[2]->prefix);
$this->assertEquals('Enabled', $result->lifecycleConfiguration->rules[2]->status);
$this->assertEquals(1, count($result->lifecycleConfiguration->rules[2]->transitions));
$this->assertEquals(30, $result->lifecycleConfiguration->rules[2]->transitions[0]->days);
$this->assertEquals('IA', $result->lifecycleConfiguration->rules[2]->transitions[0]->storageClass);
$this->assertFalse($result->lifecycleConfiguration->rules[2]->transitions[0]->isAccessTime);
$body = '<?xml version="1.0" encoding="UTF-8"?>
<LifecycleConfiguration>
<Rule>
<ID>atime transition1</ID>
<Prefix>logs1/</Prefix>
<Status>Enabled</Status>
<Transition>
<Days>30</Days>
<StorageClass>IA</StorageClass>
<IsAccessTime>true</IsAccessTime>
<ReturnToStdWhenVisit>false</ReturnToStdWhenVisit>
</Transition>
<AtimeBase>1631698332</AtimeBase>
</Rule>
<Rule>
<ID>atime transition2</ID>
<Prefix>logs2/</Prefix>
<Status>Enabled</Status>
<NoncurrentVersionTransition>
<NoncurrentDays>10</NoncurrentDays>
<StorageClass>IA</StorageClass>
<IsAccessTime>true</IsAccessTime>
<ReturnToStdWhenVisit>false</ReturnToStdWhenVisit>
</NoncurrentVersionTransition>
<AtimeBase>1631698332</AtimeBase>
</Rule>
</LifecycleConfiguration>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123'],
Utils::streamFor($body)
);
$result = BucketLifecycle::toGetBucketLifecycle($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals(2, count($result->lifecycleConfiguration->rules));
$this->assertEquals('atime transition1', $result->lifecycleConfiguration->rules[0]->id);
$this->assertEquals('logs1/', $result->lifecycleConfiguration->rules[0]->prefix);
$this->assertEquals('Enabled', $result->lifecycleConfiguration->rules[0]->status);
$this->assertEquals(1, count($result->lifecycleConfiguration->rules[0]->transitions));
$this->assertEquals(30, $result->lifecycleConfiguration->rules[0]->transitions[0]->days);
$this->assertEquals('IA', $result->lifecycleConfiguration->rules[0]->transitions[0]->storageClass);
$this->assertFalse($result->lifecycleConfiguration->rules[0]->transitions[0]->returnToStdWhenVisit);
$this->assertTrue($result->lifecycleConfiguration->rules[0]->transitions[0]->isAccessTime);
$this->assertEquals(1631698332, $result->lifecycleConfiguration->rules[0]->atimeBase);
$this->assertEquals('atime transition2', $result->lifecycleConfiguration->rules[1]->id);
$this->assertEquals('logs2/', $result->lifecycleConfiguration->rules[1]->prefix);
$this->assertEquals('Enabled', $result->lifecycleConfiguration->rules[1]->status);
$this->assertEquals(10, $result->lifecycleConfiguration->rules[1]->noncurrentVersionTransitions[0]->noncurrentDays);
$this->assertEquals('IA', $result->lifecycleConfiguration->rules[1]->noncurrentVersionTransitions[0]->storageClass);
$this->assertFalse($result->lifecycleConfiguration->rules[1]->noncurrentVersionTransitions[0]->returnToStdWhenVisit);
$this->assertTrue($result->lifecycleConfiguration->rules[1]->noncurrentVersionTransitions[0]->isAccessTime);
$this->assertEquals(1631698332, $result->lifecycleConfiguration->rules[1]->atimeBase);
$body = '<?xml version="1.0" encoding="UTF-8"?>
<LifecycleConfiguration>
<Rule>
<Prefix></Prefix>
<Transition>
<Days>30</Days>
<StorageClass>Archive</StorageClass>
</Transition>
<Filter>
<Not>
<Tag>
<Key>key1</Key>
<Value>value1</Value>
</Tag>
<Prefix>log</Prefix>
</Not>
</Filter>
<ID>rule</ID>
<Expiration>
<ExpiredObjectDeleteMarker>true</ExpiredObjectDeleteMarker>
</Expiration>
<NoncurrentVersionExpiration>
<NoncurrentDays>5</NoncurrentDays>
</NoncurrentVersionExpiration>
<Status>Enabled</Status>
</Rule>
</LifecycleConfiguration>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123'],
Utils::streamFor($body)
);
$result = BucketLifecycle::toGetBucketLifecycle($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals(1, count($result->lifecycleConfiguration->rules));
$this->assertEquals('rule', $result->lifecycleConfiguration->rules[0]->id);
$this->assertEquals('', $result->lifecycleConfiguration->rules[0]->prefix);
$this->assertEquals('Enabled', $result->lifecycleConfiguration->rules[0]->status);
$this->assertEquals(1, count($result->lifecycleConfiguration->rules[0]->transitions));
$this->assertEquals(30, $result->lifecycleConfiguration->rules[0]->transitions[0]->days);
$this->assertEquals('Archive', $result->lifecycleConfiguration->rules[0]->transitions[0]->storageClass);
$this->assertEquals(1, count($result->lifecycleConfiguration->rules[0]->filter->nots));
$this->assertEquals('log', $result->lifecycleConfiguration->rules[0]->filter->nots[0]->prefix);
$this->assertEquals('key1', $result->lifecycleConfiguration->rules[0]->filter->nots[0]->tag->key);
$this->assertEquals('value1', $result->lifecycleConfiguration->rules[0]->filter->nots[0]->tag->value);
$body = '<?xml version="1.0" encoding="UTF-8"?>
<LifecycleConfiguration>
<Rule>
<Prefix></Prefix>
<Transition>
<Days>30</Days>
<StorageClass>Archive</StorageClass>
</Transition>
<Filter>
<Not>
<Tag>
<Key>key1</Key>
<Value>value1</Value>
</Tag>
<Prefix>log</Prefix>
</Not>
<Not>
<Tag>
<Key>key2</Key>
<Value>value2</Value>
</Tag>
<Prefix>pre</Prefix>
</Not>
</Filter>
<ID>rule</ID>
<Expiration>
<ExpiredObjectDeleteMarker>true</ExpiredObjectDeleteMarker>
</Expiration>
<NoncurrentVersionExpiration>
<NoncurrentDays>5</NoncurrentDays>
</NoncurrentVersionExpiration>
<Status>Enabled</Status>
</Rule>
</LifecycleConfiguration>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123'],
Utils::streamFor($body)
);
$result = BucketLifecycle::toGetBucketLifecycle($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals(1, count($result->lifecycleConfiguration->rules));
$this->assertEquals('rule', $result->lifecycleConfiguration->rules[0]->id);
$this->assertEquals('', $result->lifecycleConfiguration->rules[0]->prefix);
$this->assertEquals('Enabled', $result->lifecycleConfiguration->rules[0]->status);
$this->assertEquals(1, count($result->lifecycleConfiguration->rules[0]->transitions));
$this->assertEquals(30, $result->lifecycleConfiguration->rules[0]->transitions[0]->days);
$this->assertEquals('Archive', $result->lifecycleConfiguration->rules[0]->transitions[0]->storageClass);
$this->assertEquals(2, count($result->lifecycleConfiguration->rules[0]->filter->nots));
$this->assertEquals('log', $result->lifecycleConfiguration->rules[0]->filter->nots[0]->prefix);
$this->assertEquals('key1', $result->lifecycleConfiguration->rules[0]->filter->nots[0]->tag->key);
$this->assertEquals('value1', $result->lifecycleConfiguration->rules[0]->filter->nots[0]->tag->value);
$this->assertEquals('pre', $result->lifecycleConfiguration->rules[0]->filter->nots[1]->prefix);
$this->assertEquals('key2', $result->lifecycleConfiguration->rules[0]->filter->nots[1]->tag->key);
$this->assertEquals('value2', $result->lifecycleConfiguration->rules[0]->filter->nots[1]->tag->value);
}
public function testFromDeleteBucketLifecycle()
{
// miss required field
try {
$request = new Models\DeleteBucketLifecycleRequest();
$input = BucketLifecycle::fromDeleteBucketLifecycle($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
$request = new Models\DeleteBucketLifecycleRequest('bucket-123');
$input = BucketLifecycle::fromDeleteBucketLifecycle($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
}
public function testToDeleteBucketLifecycle()
{
// empty output
$output = new OperationOutput();
$result = BucketLifecycle::toDeleteBucketLifecycle($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'No Content',
204,
['x-oss-request-id' => '123']
);
$result = BucketLifecycle::toDeleteBucketLifecycle($output);
$this->assertEquals('No Content', $result->status);
$this->assertEquals(204, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
}
private function cleanXml($xml): array|string
{
return str_replace("\n", "", str_replace("\r", "", $xml));
}
}

354
vendor/alibabacloud/oss-v2/tests/UnitTests/Transform/BucketLoggingTest.php vendored Normal file
View File

@@ -0,0 +1,354 @@
<?php
namespace UnitTests\Transform;
use AlibabaCloud\Oss\V2\Models;
use AlibabaCloud\Oss\V2\Transform\BucketLogging;
use AlibabaCloud\Oss\V2\OperationOutput;
use AlibabaCloud\Oss\V2\Utils;
class BucketLoggingTest extends \PHPUnit\Framework\TestCase
{
public function testFromPutBucketLogging()
{
// miss required field
try {
$request = new Models\PutBucketLoggingRequest();
$input = BucketLogging::fromPutBucketLogging($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
try {
$request = new Models\PutBucketLoggingRequest('bucket-123');
$input = BucketLogging::fromPutBucketLogging($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucketLoggingStatus", (string)$e);
}
$request = new Models\PutBucketLoggingRequest('bucket-123', new Models\BucketLoggingStatus(new Models\LoggingEnabled(
targetBucket: 'TargetBucket', targetPrefix: 'TargetPrefix'
)));
$input = BucketLogging::fromPutBucketLogging($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><BucketLoggingStatus><LoggingEnabled><TargetBucket>TargetBucket</TargetBucket><TargetPrefix>TargetPrefix</TargetPrefix></LoggingEnabled></BucketLoggingStatus>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
$request = new Models\PutBucketLoggingRequest('bucket-123', new Models\BucketLoggingStatus(new Models\LoggingEnabled(
targetBucket: 'TargetBucket', targetPrefix: 'TargetPrefix', loggingRole: 'AliyunOSSLoggingDefaultRole'
)));
$input = BucketLogging::fromPutBucketLogging($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><BucketLoggingStatus><LoggingEnabled><TargetBucket>TargetBucket</TargetBucket><TargetPrefix>TargetPrefix</TargetPrefix><LoggingRole>AliyunOSSLoggingDefaultRole</LoggingRole></LoggingEnabled></BucketLoggingStatus>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
}
public function testToPutBucketLogging()
{
// empty output
$output = new OperationOutput();
$result = BucketLogging::toPutBucketLogging($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123']
);
$result = BucketLogging::toPutBucketLogging($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
}
public function testFromGetBucketLogging()
{
// miss required field
try {
$request = new Models\GetBucketLoggingRequest();
$input = BucketLogging::fromGetBucketLogging($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
$request = new Models\GetBucketLoggingRequest('bucket-123');
$input = BucketLogging::fromGetBucketLogging($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
}
public function testToGetBucketLogging()
{
// empty output
$output = new OperationOutput();
$result = BucketLogging::toGetBucketLogging($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$body = '<?xml version="1.0" encoding="UTF-8"?>
<BucketLoggingStatus>
<LoggingEnabled>
<TargetBucket>bucket-log</TargetBucket>
<TargetPrefix>prefix-access_log</TargetPrefix>
</LoggingEnabled>
</BucketLoggingStatus>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123', 'content-type' => 'application/xml'],
Utils::streamFor($body)
);
$result = BucketLogging::toGetBucketLogging($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(2, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals('application/xml', $result->headers['content-type']);
$this->assertEquals('bucket-log', $result->bucketLoggingStatus->loggingEnabled->targetBucket);
$this->assertEquals('prefix-access_log', $result->bucketLoggingStatus->loggingEnabled->targetPrefix);
$output = new OperationOutput();
$result = BucketLogging::toGetBucketLogging($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$body = '<?xml version="1.0" encoding="UTF-8"?>
<BucketLoggingStatus>
<LoggingEnabled>
<TargetBucket>bucket-log</TargetBucket>
<TargetPrefix>prefix-access_log</TargetPrefix>
<LoggingRole>AliyunOSSLoggingDefaultRole</LoggingRole>
</LoggingEnabled>
</BucketLoggingStatus>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123', 'content-type' => 'application/xml'],
Utils::streamFor($body)
);
$result = BucketLogging::toGetBucketLogging($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(2, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals('application/xml', $result->headers['content-type']);
$this->assertEquals('bucket-log', $result->bucketLoggingStatus->loggingEnabled->targetBucket);
$this->assertEquals('prefix-access_log', $result->bucketLoggingStatus->loggingEnabled->targetPrefix);
$this->assertEquals('AliyunOSSLoggingDefaultRole', $result->bucketLoggingStatus->loggingEnabled->loggingRole);
}
public function testFromDeleteBucketLogging()
{
// miss required field
try {
$request = new Models\DeleteBucketLoggingRequest();
$input = BucketLogging::fromDeleteBucketLogging($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
$request = new Models\DeleteBucketLoggingRequest('bucket-123');
$input = BucketLogging::fromDeleteBucketLogging($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
}
public function testToDeleteBucketLogging()
{
// empty output
$output = new OperationOutput();
$result = BucketLogging::toDeleteBucketLogging($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'No Content',
204,
['x-oss-request-id' => '123']
);
$result = BucketLogging::toDeleteBucketLogging($output);
$this->assertEquals('No Content', $result->status);
$this->assertEquals(204, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
}
public function testFromPutUserDefinedLogFieldsConfig()
{
// miss required field
try {
$request = new Models\PutUserDefinedLogFieldsConfigRequest();
$input = BucketLogging::fromPutUserDefinedLogFieldsConfig($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
try {
$request = new Models\PutUserDefinedLogFieldsConfigRequest('bucket-123');
$input = BucketLogging::fromPutUserDefinedLogFieldsConfig($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, userDefinedLogFieldsConfiguration", (string)$e);
}
$request = new Models\PutUserDefinedLogFieldsConfigRequest('bucket-123', new Models\UserDefinedLogFieldsConfiguration(
new Models\LoggingParamSet(array("param1", "param2")),
new Models\LoggingHeaderSet(array("header1", "header2", "header3"))
));
$input = BucketLogging::fromPutUserDefinedLogFieldsConfig($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><UserDefinedLogFieldsConfiguration><ParamSet><parameter>param1</parameter><parameter>param2</parameter></ParamSet><HeaderSet><header>header1</header><header>header2</header><header>header3</header></HeaderSet></UserDefinedLogFieldsConfiguration>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
}
public function testToPutUserDefinedLogFieldsConfig()
{
// empty output
$output = new OperationOutput();
$result = BucketLogging::toPutUserDefinedLogFieldsConfig($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123']
);
$result = BucketLogging::toPutUserDefinedLogFieldsConfig($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
}
public function testFromGetUserDefinedLogFieldsConfig()
{
// miss required field
try {
$request = new Models\GetUserDefinedLogFieldsConfigRequest();
$input = BucketLogging::fromGetUserDefinedLogFieldsConfig($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
$request = new Models\GetUserDefinedLogFieldsConfigRequest('bucket-123');
$input = BucketLogging::fromGetUserDefinedLogFieldsConfig($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
}
public function testToGetUserDefinedLogFieldsConfig()
{
// empty output
$output = new OperationOutput();
$result = BucketLogging::toGetUserDefinedLogFieldsConfig($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$body = '<?xml version="1.0" encoding="UTF-8"?>
<UserDefinedLogFieldsConfiguration>
<HeaderSet>
<header>header1</header>
<header>header2</header>
<header>header3</header>
</HeaderSet>
<ParamSet>
<parameter>param1</parameter>
<parameter>param2</parameter>
</ParamSet>
</UserDefinedLogFieldsConfiguration>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123', 'content-type' => 'application/xml'],
Utils::streamFor($body)
);
$result = BucketLogging::toGetUserDefinedLogFieldsConfig($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(2, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals('application/xml', $result->headers['content-type']);
$this->assertEquals('header1', $result->userDefinedLogFieldsConfiguration->headerSet->headers[0]);
$this->assertEquals('header3', $result->userDefinedLogFieldsConfiguration->headerSet->headers[2]);
$this->assertEquals('param2', $result->userDefinedLogFieldsConfiguration->paramSet->parameters[1]);
}
public function testFromUserDefinedLogFieldsConfig()
{
// miss required field
try {
$request = new Models\DeleteUserDefinedLogFieldsConfigRequest();
$input = BucketLogging::fromDeleteUserDefinedLogFieldsConfig($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
$request = new Models\DeleteUserDefinedLogFieldsConfigRequest('bucket-123');
$input = BucketLogging::fromDeleteUserDefinedLogFieldsConfig($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
}
public function testToUserDefinedLogFieldsConfig()
{
// empty output
$output = new OperationOutput();
$result = BucketLogging::toDeleteUserDefinedLogFieldsConfig($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'No Content',
204,
['x-oss-request-id' => '123']
);
$result = BucketLogging::toDeleteUserDefinedLogFieldsConfig($output);
$this->assertEquals('No Content', $result->status);
$this->assertEquals(204, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
}
private function cleanXml($xml): array|string
{
return str_replace("\n", "", str_replace("\r", "", $xml));
}
}

639
vendor/alibabacloud/oss-v2/tests/UnitTests/Transform/BucketMetaQueryTest.php vendored Normal file
View File

@@ -0,0 +1,639 @@
<?php
namespace UnitTests\Transform;
use AlibabaCloud\Oss\V2\Models;
use AlibabaCloud\Oss\V2\Transform\BucketMetaQuery;
use AlibabaCloud\Oss\V2\OperationOutput;
use AlibabaCloud\Oss\V2\Utils;
class BucketMetaQueryTest extends \PHPUnit\Framework\TestCase
{
public function testFromOpenMetaQuery()
{
// miss required field
try {
$request = new Models\OpenMetaQueryRequest();
$input = BucketMetaQuery::fromOpenMetaQuery($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
$request = new Models\OpenMetaQueryRequest('bucket-123');
$input = BucketMetaQuery::fromOpenMetaQuery($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('add', $input->getParameters()['comp']);
$this->assertEquals('', $input->getParameters()['metaQuery']);
$request = new Models\OpenMetaQueryRequest('bucket-123', 'basic');
$input = BucketMetaQuery::fromOpenMetaQuery($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('add', $input->getParameters()['comp']);
$this->assertEquals('', $input->getParameters()['metaQuery']);
$this->assertEquals('basic', $input->getParameters()['mode']);
$request = new Models\OpenMetaQueryRequest('bucket-123', 'semantic');
$input = BucketMetaQuery::fromOpenMetaQuery($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('add', $input->getParameters()['comp']);
$this->assertEquals('', $input->getParameters()['metaQuery']);
$this->assertEquals('semantic', $input->getParameters()['mode']);
}
public function testToOpenMetaQuery()
{
// empty output
$output = new OperationOutput();
$result = BucketMetaQuery::toOpenMetaQuery($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123']
);
$result = BucketMetaQuery::toOpenMetaQuery($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
}
public function testFromGetMetaQueryStatus()
{
// miss required field
try {
$request = new Models\GetMetaQueryStatusRequest();
$input = BucketMetaQuery::fromGetMetaQueryStatus($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
$request = new Models\GetMetaQueryStatusRequest('bucket-123');
$input = BucketMetaQuery::fromGetMetaQueryStatus($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('', $input->getParameters()['metaQuery']);
}
public function testToGetMetaQueryStatus()
{
// empty output
$output = new OperationOutput();
$result = BucketMetaQuery::toGetMetaQueryStatus($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$body = '<?xml version="1.0" encoding="UTF-8"?>
<MetaQueryStatus>
<State>Running</State>
<Phase>FullScanning</Phase>
<CreateTime>2021-08-02T10:49:17.289372919+08:00</CreateTime>
<UpdateTime>2021-08-02T10:49:17.289372919+08:00</UpdateTime>
</MetaQueryStatus>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123', 'content-type' => 'application/xml'],
body: Utils::streamFor($body)
);
$result = BucketMetaQuery::toGetMetaQueryStatus($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(2, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals('application/xml', $result->headers['content-type']);
$this->assertEquals('Running', $result->metaQueryStatus->state);
$this->assertEquals('FullScanning', $result->metaQueryStatus->phase);
$this->assertEquals('2021-08-02T10:49:17.289372919+08:00', $result->metaQueryStatus->createTime);
$this->assertEquals('2021-08-02T10:49:17.289372919+08:00', $result->metaQueryStatus->updateTime);
}
public function testFromDoMetaQuery()
{
// miss required field
try {
$request = new Models\DoMetaQueryRequest();
$input = BucketMetaQuery::fromDoMetaQuery($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
try {
$request = new Models\DoMetaQueryRequest('bucket-123');
$input = BucketMetaQuery::fromDoMetaQuery($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, metaQuery", (string)$e);
}
$request = new Models\DoMetaQueryRequest('bucket-123', new Models\MetaQuery(
maxResults: 5,
query: "{'Field': 'Size','Value': '1048576','Operation': 'gt'}",
sort: 'Size',
order: Models\MetaQueryOrderType::ASC,
aggregations: new Models\MetaQueryAggregations(
[
new Models\MetaQueryAggregation(
field: 'Size',
operation: 'sum'
),
new Models\MetaQueryAggregation(
field: 'Size',
operation: 'max'
),
]
),
nextToken: 'MTIzNDU2Nzg6aW1tdGVzdDpleGFtcGxlYnVja2V0OmRhdGFzZXQwMDE6b3NzOi8vZXhhbXBsZWJ1Y2tldC9zYW1wbGVvYmplY3QxLmpw****'
));
$input = BucketMetaQuery::fromDoMetaQuery($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><MetaQuery><MaxResults>5</MaxResults><Query>{'Field': 'Size','Value': '1048576','Operation': 'gt'}</Query><Sort>Size</Sort><Order>asc</Order><Aggregations><Aggregation><Field>Size</Field><Operation>sum</Operation></Aggregation><Aggregation><Field>Size</Field><Operation>max</Operation></Aggregation></Aggregations><NextToken>MTIzNDU2Nzg6aW1tdGVzdDpleGFtcGxlYnVja2V0OmRhdGFzZXQwMDE6b3NzOi8vZXhhbXBsZWJ1Y2tldC9zYW1wbGVvYmplY3QxLmpw****</NextToken></MetaQuery>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
$request = new Models\DoMetaQueryRequest('bucket-123', new Models\MetaQuery(
maxResults: 99,
query: "Overlook the snow-covered forest",
nextToken: 'MTIzNDU2Nzg6aW1tdGVzdDpleGFtcGxlYnVja2V0OmRhdGFzZXQwMDE6b3NzOi8vZXhhbXBsZWJ1Y2tldC9zYW1wbGVvYmplY3QxLmpw****',
mediaTypes: new Models\MetaQueryMediaTypes('image'),
simpleQuery: "{'Operation':'gt', 'Field': 'Size', 'Value': '30'}"
), mode: 'semantic');
$input = BucketMetaQuery::fromDoMetaQuery($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><MetaQuery><MaxResults>99</MaxResults><Query>Overlook the snow-covered forest</Query><NextToken>MTIzNDU2Nzg6aW1tdGVzdDpleGFtcGxlYnVja2V0OmRhdGFzZXQwMDE6b3NzOi8vZXhhbXBsZWJ1Y2tldC9zYW1wbGVvYmplY3QxLmpw****</NextToken><MediaTypes><MediaType>image</MediaType></MediaTypes><SimpleQuery>{'Operation':'gt', 'Field': 'Size', 'Value': '30'}</SimpleQuery></MetaQuery>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
}
public function testToDoMetaQuery()
{
// empty output
$output = new OperationOutput();
$result = BucketMetaQuery::toDoMetaQuery($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$body = '<?xml version="1.0" encoding="UTF-8"?>
<MetaQuery>
<NextToken>MTIzNDU2Nzg6aW1tdGVzdDpleGFtcGxlYnVja2V0OmRhdGFzZXQwMDE6b3NzOi8vZXhhbXBsZWJ1Y2tldC9zYW1wbGVvYmplY3QxLmpw****</NextToken>
<Files>
<File>
<Filename>exampleobject.txt</Filename>
<Size>120</Size>
<FileModifiedTime>2021-06-29T15:04:05.000000000Z07:00</FileModifiedTime>
<OSSObjectType>Normal</OSSObjectType>
<OSSStorageClass>Standard</OSSStorageClass>
<ObjectACL>default</ObjectACL>
<ETag>"fba9dede5f27731c9771645a3986****"</ETag>
<OSSCRC64>4858A48BD1466884</OSSCRC64>
<OSSTaggingCount>2</OSSTaggingCount>
<OSSTagging>
<Tagging>
<Key>owner</Key>
<Value>John</Value>
</Tagging>
<Tagging>
<Key>type</Key>
<Value>document</Value>
</Tagging>
</OSSTagging>
<OSSUserMeta>
<UserMeta>
<Key>x-oss-meta-location</Key>
<Value>hangzhou</Value>
</UserMeta>
</OSSUserMeta>
</File>
</Files>
<Aggregations>
<Aggregation>
<Field>Size</Field>
<Operation>sum</Operation>
<Value>4859250309</Value>
</Aggregation>
<Aggregation>
<Field>Size</Field>
<Operation>max</Operation>
<Value>2235483240</Value>
</Aggregation>
</Aggregations>
</MetaQuery>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123', 'content-type' => 'application/xml'],
body: Utils::streamFor($body)
);
$result = BucketMetaQuery::toDoMetaQuery($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(2, count($result->headers));
$this->assertEquals('application/xml', $result->headers['content-type']);
$this->assertEquals('MTIzNDU2Nzg6aW1tdGVzdDpleGFtcGxlYnVja2V0OmRhdGFzZXQwMDE6b3NzOi8vZXhhbXBsZWJ1Y2tldC9zYW1wbGVvYmplY3QxLmpw****', $result->nextToken);
$this->assertEquals(1, count($result->files->file));
$this->assertEquals('exampleobject.txt', $result->files->file[0]->filename);
$this->assertEquals(120, $result->files->file[0]->size);
$this->assertEquals('2021-06-29T15:04:05.000000000Z07:00', $result->files->file[0]->fileModifiedTime);
$this->assertEquals('Normal', $result->files->file[0]->ossObjectType);
$this->assertEquals('Standard', $result->files->file[0]->ossStorageClass);
$this->assertEquals('default', $result->files->file[0]->objectACL);
$this->assertEquals('"fba9dede5f27731c9771645a3986****"', $result->files->file[0]->etag);
$this->assertEquals(2, $result->files->file[0]->ossTaggingCount);
$this->assertEquals('owner', $result->files->file[0]->ossTagging->taggings[0]->key);
$this->assertEquals('John', $result->files->file[0]->ossTagging->taggings[0]->value);
$this->assertEquals('type', $result->files->file[0]->ossTagging->taggings[1]->key);
$this->assertEquals('document', $result->files->file[0]->ossTagging->taggings[1]->value);
$this->assertEquals(1, count($result->files->file[0]->ossUserMeta->userMetas));
$this->assertEquals('x-oss-meta-location', $result->files->file[0]->ossUserMeta->userMetas[0]->key);
$this->assertEquals('hangzhou', $result->files->file[0]->ossUserMeta->userMetas[0]->value);
$this->assertEquals('Size', $result->aggregations->aggregations[0]->field);
$this->assertEquals('sum', $result->aggregations->aggregations[0]->operation);
$this->assertEquals(4859250309, $result->aggregations->aggregations[0]->value);
$this->assertEquals('Size', $result->aggregations->aggregations[1]->field);
$this->assertEquals('max', $result->aggregations->aggregations[1]->operation);
$this->assertEquals(2235483240, $result->aggregations->aggregations[1]->value);
$body = '<?xml version="1.0" encoding="UTF-8"?>
<MetaQuery>
<NextToken></NextToken>
<Aggregations>
<Aggregation>
<Field>Size</Field>
<Operation>sum</Operation>
<Value>30930054</Value>
</Aggregation>
<Aggregation>
<Field>Size</Field>
<Operation>group</Operation>
<Groups>
<Group>
<Value>1536000</Value>
<Count>1</Count>
</Group>
<Group>
<Value>5472362</Value>
<Count>1</Count>
</Group>
<Group>
<Value>10354204</Value>
<Count>1</Count>
</Group>
<Group>
<Value>1890304</Value>
<Count>3</Count>
</Group>
<Group>
<Value>2632192</Value>
<Count>3</Count>
</Group>
</Groups>
</Aggregation>
</Aggregations>
</MetaQuery>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123', 'content-type' => 'application/xml'],
body: Utils::streamFor($body)
);
$result = BucketMetaQuery::toDoMetaQuery($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(2, count($result->headers));
$this->assertEquals('application/xml', $result->headers['content-type']);
$this->assertEquals(2, count($result->aggregations->aggregations));
$this->assertEquals('Size', $result->aggregations->aggregations[0]->field);
$this->assertEquals('sum', $result->aggregations->aggregations[0]->operation);
$this->assertEquals(30930054, $result->aggregations->aggregations[0]->value);
$this->assertEquals('Size', $result->aggregations->aggregations[1]->field);
$this->assertEquals('group', $result->aggregations->aggregations[1]->operation);
$this->assertEquals(5, count($result->aggregations->aggregations[1]->groups->groups));
$this->assertEquals(1, $result->aggregations->aggregations[1]->groups->groups[0]->count);
$this->assertEquals('1536000', $result->aggregations->aggregations[1]->groups->groups[0]->value);
$this->assertEquals(1, $result->aggregations->aggregations[1]->groups->groups[1]->count);
$this->assertEquals('5472362', $result->aggregations->aggregations[1]->groups->groups[1]->value);
$this->assertEquals(1, $result->aggregations->aggregations[1]->groups->groups[2]->count);
$this->assertEquals('10354204', $result->aggregations->aggregations[1]->groups->groups[2]->value);
$this->assertEquals(3, $result->aggregations->aggregations[1]->groups->groups[3]->count);
$this->assertEquals('1890304', $result->aggregations->aggregations[1]->groups->groups[3]->value);
$this->assertEquals(3, $result->aggregations->aggregations[1]->groups->groups[4]->count);
$this->assertEquals('2632192', $result->aggregations->aggregations[1]->groups->groups[4]->value);
$body = '<?xml version="1.0" encoding="UTF-8"?>
<MetaQuery>
<Files>
<File>
<URI>oss://bucket/sample-object.jpg</URI>
<Filename>sample-object.jpg</Filename>
<Size>1000</Size>
<ObjectACL>default</ObjectACL>
<FileModifiedTime>2021-06-29T14:50:14.011643661+08:00</FileModifiedTime>
<ServerSideEncryption>AES256</ServerSideEncryption>
<ServerSideEncryptionCustomerAlgorithm>SM4</ServerSideEncryptionCustomerAlgorithm>
<ETag>"1D9C280A7C4F67F7EF873E28449****"</ETag>
<OSSCRC64>559890638950338001</OSSCRC64>
<ProduceTime>2021-06-29T14:50:15.011643661+08:00</ProduceTime>
<ContentType>image/jpeg</ContentType>
<MediaType>image</MediaType>
<LatLong>30.134390,120.074997</LatLong>
<Title>test</Title>
<OSSExpiration>2024-12-01T12:00:00.000Z</OSSExpiration>
<AccessControlAllowOrigin>https://aliyundoc.com</AccessControlAllowOrigin>
<AccessControlRequestMethod>PUT</AccessControlRequestMethod>
<ServerSideDataEncryption>SM4</ServerSideDataEncryption>
<ServerSideEncryptionKeyId>9468da86-3509-4f8d-a61e-6eab1eac****</ServerSideEncryptionKeyId>
<CacheControl>no-cache</CacheControl>
<ContentDisposition>attachment; filename=test.jpg</ContentDisposition>
<ContentEncoding>UTF-8</ContentEncoding>
<ContentLanguage>zh-CN</ContentLanguage>
<ImageHeight>500</ImageHeight>
<ImageWidth>270</ImageWidth>
<VideoWidth>1080</VideoWidth>
<VideoHeight>1920</VideoHeight>
<VideoStreams>
<VideoStream>
<CodecName>h264</CodecName>
<Language>en</Language>
<Bitrate>5407765</Bitrate>
<FrameRate>25/1</FrameRate>
<StartTime>0</StartTime>
<Duration>22.88</Duration>
<FrameCount>572</FrameCount>
<BitDepth>8</BitDepth>
<PixelFormat>yuv420p</PixelFormat>
<ColorSpace>bt709</ColorSpace>
<Height>720</Height>
<Width>1280</Width>
</VideoStream>
<VideoStream>
<CodecName>h264</CodecName>
<Language>en</Language>
<Bitrate>5407765</Bitrate>
<FrameRate>25/1</FrameRate>
<StartTime>0</StartTime>
<Duration>22.88</Duration>
<FrameCount>572</FrameCount>
<BitDepth>8</BitDepth>
<PixelFormat>yuv420p</PixelFormat>
<ColorSpace>bt709</ColorSpace>
<Height>720</Height>
<Width>1280</Width>
</VideoStream>
</VideoStreams>
<AudioStreams>
<AudioStream>
<CodecName>aac</CodecName>
<Bitrate>1048576</Bitrate>
<SampleRate>48000</SampleRate>
<StartTime>0.0235</StartTime>
<Duration>3.690667</Duration>
<Channels>2</Channels>
<Language>en</Language>
</AudioStream>
</AudioStreams>
<Subtitles>
<Subtitle>
<CodecName>mov_text</CodecName>
<Language>en</Language>
<StartTime>0</StartTime>
<Duration>71.378</Duration>
</Subtitle>
<Subtitle>
<CodecName>mov_text</CodecName>
<Language>en</Language>
<StartTime>72</StartTime>
<Duration>71.378</Duration>
</Subtitle>
</Subtitles>
<Bitrate>5407765</Bitrate>
<Artist>Jane</Artist>
<AlbumArtist>Jenny</AlbumArtist>
<Composer>Jane</Composer>
<Performer>Jane</Performer>
<Album>FirstAlbum</Album>
<Duration>71.378</Duration>
<Addresses>
<Address>
<AddressLine>中国浙江省杭州市余杭区文一西路969号</AddressLine>
<City>杭州市</City>
<Country>中国</Country>
<District>余杭区</District>
<Language>zh-Hans</Language>
<Province>浙江省</Province>
<Township>文一西路</Township>
</Address>
<Address>
<AddressLine>中国浙江省杭州市余杭区文一西路970号</AddressLine>
<City>杭州市</City>
<Country>中国</Country>
<District>余杭区</District>
<Language>zh-Hans</Language>
<Province>浙江省</Province>
<Township>文一西路</Township>
</Address>
</Addresses>
<OSSObjectType>Normal</OSSObjectType>
<OSSStorageClass>Standard</OSSStorageClass>
<OSSTaggingCount>2</OSSTaggingCount>
<OSSTagging>
<Tagging>
<Key>key</Key>
<Value>val</Value>
</Tagging>
<Tagging>
<Key>key2</Key>
<Value>val2</Value>
</Tagging>
</OSSTagging>
<OSSUserMeta>
<UserMeta>
<Key>key</Key>
<Value>val</Value>
</UserMeta>
</OSSUserMeta>
</File>
</Files>
</MetaQuery>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123', 'content-type' => 'application/xml'],
body: Utils::streamFor($body)
);
$result = BucketMetaQuery::toDoMetaQuery($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(2, count($result->headers));
$this->assertEquals('application/xml', $result->headers['content-type']);
$this->assertEquals(1, count($result->files->file));
$this->assertEquals('oss://bucket/sample-object.jpg', $result->files->file[0]->uri);
$this->assertEquals('sample-object.jpg', $result->files->file[0]->filename);
$this->assertEquals(1000, $result->files->file[0]->size);
$this->assertEquals('2021-06-29T14:50:14.011643661+08:00', $result->files->file[0]->fileModifiedTime);
$this->assertEquals('AES256', $result->files->file[0]->serverSideEncryption);
$this->assertEquals('SM4', $result->files->file[0]->serverSideEncryptionCustomerAlgorithm);
$this->assertEquals('"1D9C280A7C4F67F7EF873E28449****"', $result->files->file[0]->etag);
$this->assertEquals('559890638950338001', $result->files->file[0]->ossCrc64);
$this->assertEquals('2021-06-29T14:50:15.011643661+08:00', $result->files->file[0]->produceTime);
$this->assertEquals('image/jpeg', $result->files->file[0]->contentType);
$this->assertEquals('image', $result->files->file[0]->mediaType);
$this->assertEquals('30.134390,120.074997', $result->files->file[0]->latLong);
$this->assertEquals('test', $result->files->file[0]->title);
$this->assertEquals('2024-12-01T12:00:00.000Z', $result->files->file[0]->ossExpiration);
$this->assertEquals('https://aliyundoc.com', $result->files->file[0]->accessControlAllowOrigin);
$this->assertEquals('PUT', $result->files->file[0]->accessControlRequestMethod);
$this->assertEquals('SM4', $result->files->file[0]->serverSideDataEncryption);
$this->assertEquals('9468da86-3509-4f8d-a61e-6eab1eac****', $result->files->file[0]->serverSideEncryptionKeyId);
$this->assertEquals('no-cache', $result->files->file[0]->cacheControl);
$this->assertEquals('attachment; filename=test.jpg', $result->files->file[0]->contentDisposition);
$this->assertEquals('UTF-8', $result->files->file[0]->contentEncoding);
$this->assertEquals('zh-CN', $result->files->file[0]->contentLanguage);
$this->assertEquals(500, $result->files->file[0]->imageHeight);
$this->assertEquals(270, $result->files->file[0]->imageWidth);
$this->assertEquals(1920, $result->files->file[0]->videoHeight);
$this->assertEquals(1080, $result->files->file[0]->videoWidth);
$this->assertEquals(2, count($result->files->file[0]->videoStreams->videoStream));
$this->assertEquals('h264', $result->files->file[0]->videoStreams->videoStream[0]->codecName);
$this->assertEquals('en', $result->files->file[0]->videoStreams->videoStream[0]->language);
$this->assertEquals(5407765, $result->files->file[0]->videoStreams->videoStream[0]->bitrate);
$this->assertEquals(8, $result->files->file[0]->videoStreams->videoStream[0]->bitDepth);
$this->assertEquals('25/1', $result->files->file[0]->videoStreams->videoStream[0]->frameRate);
$this->assertEquals(0, $result->files->file[0]->videoStreams->videoStream[0]->startTime);
$this->assertEquals(22.88, $result->files->file[0]->videoStreams->videoStream[0]->duration);
$this->assertEquals(572, $result->files->file[0]->videoStreams->videoStream[0]->frameCount);
$this->assertEquals('yuv420p', $result->files->file[0]->videoStreams->videoStream[0]->pixelFormat);
$this->assertEquals('bt709', $result->files->file[0]->videoStreams->videoStream[0]->colorSpace);
$this->assertEquals(720, $result->files->file[0]->videoStreams->videoStream[0]->height);
$this->assertEquals(1280, $result->files->file[0]->videoStreams->videoStream[0]->width);
$this->assertEquals('h264', $result->files->file[0]->videoStreams->videoStream[1]->codecName);
$this->assertEquals('en', $result->files->file[0]->videoStreams->videoStream[1]->language);
$this->assertEquals(5407765, $result->files->file[0]->videoStreams->videoStream[1]->bitrate);
$this->assertEquals('25/1', $result->files->file[0]->videoStreams->videoStream[1]->frameRate);
$this->assertEquals(0, $result->files->file[0]->videoStreams->videoStream[1]->startTime);
$this->assertEquals(22.88, $result->files->file[0]->videoStreams->videoStream[1]->duration);
$this->assertEquals(572, $result->files->file[0]->videoStreams->videoStream[1]->frameCount);
$this->assertEquals(8, $result->files->file[0]->videoStreams->videoStream[1]->bitDepth);
$this->assertEquals('yuv420p', $result->files->file[0]->videoStreams->videoStream[1]->pixelFormat);
$this->assertEquals('bt709', $result->files->file[0]->videoStreams->videoStream[1]->colorSpace);
$this->assertEquals(720, $result->files->file[0]->videoStreams->videoStream[1]->height);
$this->assertEquals(1280, $result->files->file[0]->videoStreams->videoStream[1]->width);
$this->assertEquals(1, count($result->files->file[0]->audioStreams->audioStream));
$this->assertEquals('aac', $result->files->file[0]->audioStreams->audioStream[0]->codecName);
$this->assertEquals(1048576, $result->files->file[0]->audioStreams->audioStream[0]->bitrate);
$this->assertEquals(48000, $result->files->file[0]->audioStreams->audioStream[0]->sampleRate);
$this->assertEquals(0.0235, $result->files->file[0]->audioStreams->audioStream[0]->startTime);
$this->assertEquals(3.690667, $result->files->file[0]->audioStreams->audioStream[0]->duration);
$this->assertEquals(2, $result->files->file[0]->audioStreams->audioStream[0]->channels);
$this->assertEquals('en', $result->files->file[0]->audioStreams->audioStream[0]->language);
$this->assertEquals(2, count($result->files->file[0]->subtitles->subtitle));
$this->assertEquals('mov_text', $result->files->file[0]->subtitles->subtitle[0]->codecName);
$this->assertEquals('en', $result->files->file[0]->subtitles->subtitle[0]->language);
$this->assertEquals(0, $result->files->file[0]->subtitles->subtitle[0]->startTime);
$this->assertEquals(71.378, $result->files->file[0]->subtitles->subtitle[0]->duration);
$this->assertEquals('mov_text', $result->files->file[0]->subtitles->subtitle[1]->codecName);
$this->assertEquals('en', $result->files->file[0]->subtitles->subtitle[1]->language);
$this->assertEquals(72, $result->files->file[0]->subtitles->subtitle[1]->startTime);
$this->assertEquals(71.378, $result->files->file[0]->subtitles->subtitle[1]->duration);
$this->assertEquals(5407765, $result->files->file[0]->bitrate);
$this->assertEquals('Jane', $result->files->file[0]->artist);
$this->assertEquals('Jenny', $result->files->file[0]->albumArtist);
$this->assertEquals('Jane', $result->files->file[0]->composer);
$this->assertEquals('Jane', $result->files->file[0]->performer);
$this->assertEquals('FirstAlbum', $result->files->file[0]->album);
$this->assertEquals(71.378, $result->files->file[0]->duration);
$this->assertEquals(2, count($result->files->file[0]->addresses->address));
$this->assertEquals('中国浙江省杭州市余杭区文一西路969号', $result->files->file[0]->addresses->address[0]->addressLine);
$this->assertEquals('杭州市', $result->files->file[0]->addresses->address[0]->city);
$this->assertEquals('中国', $result->files->file[0]->addresses->address[0]->country);
$this->assertEquals('余杭区', $result->files->file[0]->addresses->address[0]->district);
$this->assertEquals('zh-Hans', $result->files->file[0]->addresses->address[0]->language);
$this->assertEquals('浙江省', $result->files->file[0]->addresses->address[0]->province);
$this->assertEquals('文一西路', $result->files->file[0]->addresses->address[0]->township);
$this->assertEquals('中国浙江省杭州市余杭区文一西路970号', $result->files->file[0]->addresses->address[1]->addressLine);
$this->assertEquals('杭州市', $result->files->file[0]->addresses->address[1]->city);
$this->assertEquals('中国', $result->files->file[0]->addresses->address[1]->country);
$this->assertEquals('余杭区', $result->files->file[0]->addresses->address[1]->district);
$this->assertEquals('zh-Hans', $result->files->file[0]->addresses->address[1]->language);
$this->assertEquals('浙江省', $result->files->file[0]->addresses->address[1]->province);
$this->assertEquals('文一西路', $result->files->file[0]->addresses->address[1]->township);
$this->assertEquals('Normal', $result->files->file[0]->ossObjectType);
$this->assertEquals('Standard', $result->files->file[0]->ossStorageClass);
$this->assertEquals(2, $result->files->file[0]->ossTaggingCount);
$this->assertEquals('key', $result->files->file[0]->ossTagging->taggings[0]->key);
$this->assertEquals('val', $result->files->file[0]->ossTagging->taggings[0]->value);
$this->assertEquals('key2', $result->files->file[0]->ossTagging->taggings[1]->key);
$this->assertEquals('val2', $result->files->file[0]->ossTagging->taggings[1]->value);
$this->assertEquals(1, count($result->files->file[0]->ossUserMeta->userMetas));
$this->assertEquals('key', $result->files->file[0]->ossUserMeta->userMetas[0]->key);
$this->assertEquals('val', $result->files->file[0]->ossUserMeta->userMetas[0]->value);
}
public function testFromCloseMetaQuery()
{
// miss required field
try {
$request = new Models\CloseMetaQueryRequest();
$input = BucketMetaQuery::fromCloseMetaQuery($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
$request = new Models\CloseMetaQueryRequest('bucket-123');
$input = BucketMetaQuery::fromCloseMetaQuery($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
}
public function testToGetBucketMetaQuery()
{
// empty output
$output = new OperationOutput();
$result = BucketMetaQuery::toCloseMetaQuery($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123'],
);
$result = BucketMetaQuery::toCloseMetaQuery($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
}
private function cleanXml($xml): array|string
{
return str_replace("\n", "", str_replace("\r", "", $xml));
}
}

200
vendor/alibabacloud/oss-v2/tests/UnitTests/Transform/BucketOverwriteConfigTest.php vendored Normal file
View File

@@ -0,0 +1,200 @@
<?php
namespace UnitTests\Transform;
use AlibabaCloud\Oss\V2\Models;
use AlibabaCloud\Oss\V2\Transform\BucketOverwriteConfig;
use AlibabaCloud\Oss\V2\OperationOutput;
use AlibabaCloud\Oss\V2\Utils;
class BucketOverwriteConfigTest extends \PHPUnit\Framework\TestCase
{
public function testFromPutBucketOverwriteConfig()
{
// miss required field
try {
$request = new Models\PutBucketOverwriteConfigRequest();
$input = BucketOverwriteConfig::fromPutBucketOverwriteConfig($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
try {
$request = new Models\PutBucketOverwriteConfigRequest('bucket-123');
$input = BucketOverwriteConfig::fromPutBucketOverwriteConfig($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, overwriteConfiguration", (string)$e);
}
// demo1
$request = new Models\PutBucketOverwriteConfigRequest('bucket-123', new Models\OverwriteConfiguration(
rules: array(
new Models\OverwriteRule(action: 'forbid', id: 'rule-001')
)
));
$input = BucketOverwriteConfig::fromPutBucketOverwriteConfig($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><OverwriteConfiguration><Rule><Action>forbid</Action><ID>rule-001</ID></Rule></OverwriteConfiguration>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
// demo2
$request = new Models\PutBucketOverwriteConfigRequest('bucket-123', new Models\OverwriteConfiguration(
rules: array(
new Models\OverwriteRule(action: 'forbid', id: 'rule-001'),
new Models\OverwriteRule(action: 'forbid', prefix: 'pre', suffix: '.txt', principals: new Models\OverwritePrincipals(array('1234567890')), id: 'rule-002')
)
));
$input = BucketOverwriteConfig::fromPutBucketOverwriteConfig($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><OverwriteConfiguration><Rule><Action>forbid</Action><ID>rule-001</ID></Rule><Rule><Action>forbid</Action><Prefix>pre</Prefix><Suffix>.txt</Suffix><Principals><Principal>1234567890</Principal></Principals><ID>rule-002</ID></Rule></OverwriteConfiguration>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
}
public function testToPutBucketOverwriteConfig()
{
// empty output
$output = new OperationOutput();
$result = BucketOverwriteConfig::toPutBucketOverwriteConfig($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123']
);
$result = BucketOverwriteConfig::toPutBucketOverwriteConfig($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
}
public function testFromGetBucketOverwriteConfig()
{
// miss required field
try {
$request = new Models\GetBucketOverwriteConfigRequest();
$input = BucketOverwriteConfig::fromGetBucketOverwriteConfig($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
$request = new Models\GetBucketOverwriteConfigRequest('bucket-123');
$input = BucketOverwriteConfig::fromGetBucketOverwriteConfig($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
}
public function testToGetBucketOverwriteConfig()
{
// empty output
$output = new OperationOutput();
$result = BucketOverwriteConfig::toGetBucketOverwriteConfig($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$body = '<?xml version="1.0" encoding="UTF-8"?>
<OverwriteConfiguration>
<Rule>
<ID>1</ID>
<Action>forbid</Action>
<Prefix></Prefix>
<Suffix></Suffix>
<Principals />
</Rule>
<Rule>
<ID>2</ID>
<Action>forbid</Action>
<Prefix>pre</Prefix>
<Suffix>.txt</Suffix>
<Principals>
<Principal>1234567890</Principal>
</Principals>
</Rule>
</OverwriteConfiguration>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123', 'content-type' => 'application/xml'],
Utils::streamFor($body)
);
$result = BucketOverwriteConfig::toGetBucketOverwriteConfig($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(2, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals('application/xml', $result->headers['content-type']);
$this->assertEquals(2, count($result->overwriteConfiguration->rules));
$this->assertEquals("1", $result->overwriteConfiguration->rules[0]->id);
$this->assertEquals("forbid", $result->overwriteConfiguration->rules[0]->action);
$this->assertEquals("", $result->overwriteConfiguration->rules[0]->prefix);
$this->assertEquals("", $result->overwriteConfiguration->rules[0]->suffix);
$this->assertEquals(new Models\OverwritePrincipals(), $result->overwriteConfiguration->rules[0]->principals);
$this->assertEquals("2", $result->overwriteConfiguration->rules[1]->id);
$this->assertEquals("forbid", $result->overwriteConfiguration->rules[1]->action);
$this->assertEquals("pre", $result->overwriteConfiguration->rules[1]->prefix);
$this->assertEquals(".txt", $result->overwriteConfiguration->rules[1]->suffix);
$this->assertEquals(1, count($result->overwriteConfiguration->rules[1]->principals->principals));
$this->assertEquals("1234567890", $result->overwriteConfiguration->rules[1]->principals->principals[0]);
}
public function testFromDeleteBucketOverwriteConfig()
{
// miss required field
try {
$request = new Models\DeleteBucketOverwriteConfigRequest();
$input = BucketOverwriteConfig::fromDeleteBucketOverwriteConfig($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
$request = new Models\DeleteBucketOverwriteConfigRequest('bucket-123');
$input = BucketOverwriteConfig::fromDeleteBucketOverwriteConfig($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
}
public function testToDeleteBucketOverwriteConfig()
{
// empty output
$output = new OperationOutput();
$result = BucketOverwriteConfig::toDeleteBucketOverwriteConfig($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'No Content',
204,
['x-oss-request-id' => '123']
);
$result = BucketOverwriteConfig::toDeleteBucketOverwriteConfig($output);
$this->assertEquals('No Content', $result->status);
$this->assertEquals(204, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
}
private function cleanXml($xml): array|string
{
return str_replace("\n", "", str_replace("\r", "", $xml));
}
}

197
vendor/alibabacloud/oss-v2/tests/UnitTests/Transform/BucketPolicyTest.php vendored Normal file
View File

@@ -0,0 +1,197 @@
<?php
namespace UnitTests\Transform;
use AlibabaCloud\Oss\V2\Models;
use AlibabaCloud\Oss\V2\Transform\BucketPolicy;
use AlibabaCloud\Oss\V2\OperationOutput;
use AlibabaCloud\Oss\V2\Utils;
class BucketPolicyTest extends \PHPUnit\Framework\TestCase
{
public function testFromPutBucketPolicy()
{
// miss required field
try {
$request = new Models\PutBucketPolicyRequest();
$input = BucketPolicy::fromPutBucketPolicy($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
try {
$request = new Models\PutBucketPolicyRequest('bucket-123');
$input = BucketPolicy::fromPutBucketPolicy($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, body.", (string)$e);
}
// all settings
$body = '{"Version":"1","Statement":[{"Action":["oss:PutObject","oss:GetObject"],"Effect":"Deny","Principal":["1234567890"],"Resource":["acs:oss:*:1234567890:*/*"]}]}';
$request = new Models\PutBucketPolicyRequest(
bucket: 'bucket-123',
body: $body
);
$json = <<<BBB
{"Version":"1","Statement":[{"Action":["oss:PutObject","oss:GetObject"],"Effect":"Deny","Principal":["1234567890"],"Resource":["acs:oss:*:1234567890:*/*"]}]}
BBB;
$input = BucketPolicy::fromPutBucketPolicy($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals($json, $input->getBody()->getContents());
$this->assertEquals(base64_encode(md5($input->getBody(), true)), $input->getHeaders()['content-md5']);
}
public function testToPutBucketPolicy()
{
// empty output
$output = new OperationOutput();
$result = BucketPolicy::toPutBucketPolicy($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123']
);
$result = BucketPolicy::toPutBucketPolicy($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
}
public function testFromGetBucketPolicy()
{
// miss required field
try {
$request = new Models\GetBucketPolicyRequest();
$input = BucketPolicy::fromGetBucketPolicy($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
$request = new Models\GetBucketPolicyRequest('bucket-123');
$input = BucketPolicy::fromGetBucketPolicy($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
}
public function testToGetBucketPolicy()
{
// empty output
$output = new OperationOutput();
$result = BucketPolicy::toGetBucketPolicy($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123', 'content-type' => 'application/xml'],
Utils::streamFor('{"Version":"1","Statement":[{"Action":["oss:PutObject","oss:GetObject"],"Effect":"Deny","Principal":["1234567890"],"Resource":["acs:oss:*:1234567890:*/*"]}]}')
);
$result = BucketPolicy::toGetBucketPolicy($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertCount(2, $result->headers);
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals('application/xml', $result->headers['content-type']);
$this->assertEquals('{"Version":"1","Statement":[{"Action":["oss:PutObject","oss:GetObject"],"Effect":"Deny","Principal":["1234567890"],"Resource":["acs:oss:*:1234567890:*/*"]}]}', $result->body);
}
public function testFromGetBucketPolicyStatus()
{
// miss required field
try {
$request = new Models\GetBucketPolicyStatusRequest();
$input = BucketPolicy::fromGetBucketPolicyStatus($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
$request = new Models\GetBucketPolicyStatusRequest('bucket-123');
$input = BucketPolicy::fromGetBucketPolicyStatus($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
}
public function testToGetBucketPolicyStatus()
{
// empty output
$output = new OperationOutput();
$result = BucketPolicy::toGetBucketPolicyStatus($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123', 'content-type' => 'application/xml'],
Utils::streamFor('<?xml version="1.0" encoding="UTF-8"?>
<PolicyStatus>
<IsPublic>true</IsPublic>
</PolicyStatus>')
);
$result = BucketPolicy::toGetBucketPolicyStatus($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertCount(2, $result->headers);
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals('application/xml', $result->headers['content-type']);
$this->assertTrue($result->policyStatus->isPublic);
}
public function testFromDeleteBucketPolicy()
{
// miss required field
try {
$request = new Models\DeleteBucketPolicyRequest();
$input = BucketPolicy::fromDeleteBucketPolicy($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
$request = new Models\DeleteBucketPolicyRequest('bucket-123');
$input = BucketPolicy::fromDeleteBucketPolicy($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
}
public function testToDeleteBucketPolicy()
{
// empty output
$output = new OperationOutput();
$result = BucketPolicy::toDeleteBucketPolicy($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'No Content',
204,
['x-oss-request-id' => '123']
);
$result = BucketPolicy::toDeleteBucketPolicy($output);
$this->assertEquals('No Content', $result->status);
$this->assertEquals(204, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
}
}

155
vendor/alibabacloud/oss-v2/tests/UnitTests/Transform/BucketPublicAccessBlockTest.php vendored Normal file
View File

@@ -0,0 +1,155 @@
<?php
namespace UnitTests\Transform;
use AlibabaCloud\Oss\V2\Models;
use AlibabaCloud\Oss\V2\Models\PublicAccessBlockConfiguration;
use AlibabaCloud\Oss\V2\Transform\BucketPublicAccessBlock;
use AlibabaCloud\Oss\V2\OperationOutput;
use AlibabaCloud\Oss\V2\Utils;
class BucketPublicAccessBlockTest extends \PHPUnit\Framework\TestCase
{
public function testFromPutBucketPublicAccessBlock()
{
// miss required field
try {
$request = new Models\PutBucketPublicAccessBlockRequest();
$input = BucketPublicAccessBlock::fromPutBucketPublicAccessBlock($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
try {
$request = new Models\PutBucketPublicAccessBlockRequest('bucket-123');
$input = BucketPublicAccessBlock::fromPutBucketPublicAccessBlock($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, publicAccessBlockConfiguration", (string)$e);
}
// demo1
$request = new Models\PutBucketPublicAccessBlockRequest('bucket-123', new Models\PublicAccessBlockConfiguration(
true
));
$input = BucketPublicAccessBlock::fromPutBucketPublicAccessBlock($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><PublicAccessBlockConfiguration><BlockPublicAccess>true</BlockPublicAccess></PublicAccessBlockConfiguration>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
}
public function testToPutBucketPublicAccessBlock()
{
// empty output
$output = new OperationOutput();
$result = BucketPublicAccessBlock::toPutBucketPublicAccessBlock($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123']
);
$result = BucketPublicAccessBlock::toPutBucketPublicAccessBlock($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
}
public function testFromGetBucketPublicAccessBlock()
{
try {
$request = new Models\GetBucketPublicAccessBlockRequest();
$input = BucketPublicAccessBlock::fromGetBucketPublicAccessBlock($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
$request = new Models\GetBucketPublicAccessBlockRequest('bucket-123');
$input = BucketPublicAccessBlock::fromGetBucketPublicAccessBlock($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
}
public function testToGetBucketPublicAccessBlock()
{
// empty output
$output = new OperationOutput();
$result = BucketPublicAccessBlock::toGetBucketPublicAccessBlock($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$body = '<?xml version="1.0" encoding="UTF-8"?>
<PublicAccessBlockConfiguration>
<BlockPublicAccess>true</BlockPublicAccess>
</PublicAccessBlockConfiguration>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123'],
Utils::streamFor($body)
);
$result = BucketPublicAccessBlock::toGetBucketPublicAccessBlock($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertTrue($result->publicAccessBlockConfiguration->blockPublicAccess);
}
public function testFromDeleteBucketPublicAccessBlock()
{
try {
$request = new Models\DeleteBucketPublicAccessBlockRequest();
$input = BucketPublicAccessBlock::fromDeleteBucketPublicAccessBlock($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
$request = new Models\DeleteBucketPublicAccessBlockRequest('bucket-123');
$input = BucketPublicAccessBlock::fromDeleteBucketPublicAccessBlock($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
}
public function testToDeleteBucketPublicAccessBlock()
{
// empty output
$output = new OperationOutput();
$result = BucketPublicAccessBlock::toDeleteBucketPublicAccessBlock($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'No Content',
204,
['x-oss-request-id' => '123']
);
$result = BucketPublicAccessBlock::toDeleteBucketPublicAccessBlock($output);
$this->assertEquals('No Content', $result->status);
$this->assertEquals(204, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
}
private function cleanXml($xml): array|string
{
return str_replace("\n", "", str_replace("\r", "", $xml));
}
}

467
vendor/alibabacloud/oss-v2/tests/UnitTests/Transform/BucketRedundancyTransitionTest.php vendored Normal file
View File

@@ -0,0 +1,467 @@
<?php
namespace UnitTests\Transform;
use AlibabaCloud\Oss\V2\Models;
use AlibabaCloud\Oss\V2\Transform\BucketRedundancyTransition;
use AlibabaCloud\Oss\V2\OperationOutput;
use AlibabaCloud\Oss\V2\Utils;
class BucketRedundancyTransitionTest extends \PHPUnit\Framework\TestCase
{
public function testFromCreateBucketDataRedundancyTransition()
{
// miss required field
try {
$request = new Models\CreateBucketDataRedundancyTransitionRequest();
$input = BucketRedundancyTransition::fromCreateBucketDataRedundancyTransition($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
try {
$request = new Models\CreateBucketDataRedundancyTransitionRequest('bucket-123');
$input = BucketRedundancyTransition::fromCreateBucketDataRedundancyTransition($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, targetRedundancyType", (string)$e);
}
$request = new Models\CreateBucketDataRedundancyTransitionRequest('bucket-123', Models\DataRedundancyType::ZRS);
$input = BucketRedundancyTransition::fromCreateBucketDataRedundancyTransition($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals(Models\DataRedundancyType::ZRS, $input->getParameters()['x-oss-target-redundancy-type']);
}
public function testToCreateBucketDataRedundancyTransition()
{
// empty output
$output = new OperationOutput();
$result = BucketRedundancyTransition::toCreateBucketDataRedundancyTransition($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$body = <<<BBB
<?xml version="1.0" encoding="UTF-8"?>
<BucketDataRedundancyTransition>
<TaskId>4be5beb0f74f490186311b268bf6****</TaskId>
</BucketDataRedundancyTransition>
BBB;
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123', 'content-type' => 'application/xml'],
body: Utils::streamFor($body)
);
$result = BucketRedundancyTransition::toCreateBucketDataRedundancyTransition($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(2, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals('application/xml', $result->headers['content-type']);
$this->assertEquals('4be5beb0f74f490186311b268bf6****', $result->bucketDataRedundancyTransition->taskId);
}
public function testFromGetBucketDataRedundancyTransition()
{
// miss required field
try {
$request = new Models\GetBucketDataRedundancyTransitionRequest();
$input = BucketRedundancyTransition::fromGetBucketDataRedundancyTransition($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
try {
$request = new Models\GetBucketDataRedundancyTransitionRequest('bucket-123');
$input = BucketRedundancyTransition::fromGetBucketDataRedundancyTransition($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, redundancyTransitionTaskid", (string)$e);
}
$request = new Models\GetBucketDataRedundancyTransitionRequest('bucket-123', 'task-123');
$input = BucketRedundancyTransition::fromGetBucketDataRedundancyTransition($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
$this->assertEquals('task-123', $input->getParameters()['x-oss-redundancy-transition-taskid']);
}
public function testToGetBucketDataRedundancyTransition()
{
// empty output
$output = new OperationOutput();
$result = BucketRedundancyTransition::toGetBucketDataRedundancyTransition($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$body = '<?xml version="1.0" encoding="UTF-8"?>
<BucketDataRedundancyTransition>
<Bucket>examplebucket</Bucket>
<TaskId>4be5beb0f74f490186311b268bf6****</TaskId>
<Status>Queueing</Status>
<CreateTime>2023-11-17T09:11:58.000Z</CreateTime>
</BucketDataRedundancyTransition>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123', 'content-type' => 'application/xml'],
Utils::streamFor($body)
);
$result = BucketRedundancyTransition::toGetBucketDataRedundancyTransition($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(2, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals('application/xml', $result->headers['content-type']);
$this->assertEquals('examplebucket', $result->bucketDataRedundancyTransition->bucket);
$this->assertEquals('4be5beb0f74f490186311b268bf6****', $result->bucketDataRedundancyTransition->taskId);
$this->assertEquals('Queueing', $result->bucketDataRedundancyTransition->status);
$this->assertEquals('2023-11-17T09:11:58.000Z', $result->bucketDataRedundancyTransition->createTime);
$body = '<?xml version="1.0" encoding="UTF-8"?>
<BucketDataRedundancyTransition>
<Bucket>examplebucket</Bucket>
<TaskId>909c6c818dd041d1a44e0fdc66aa****</TaskId>
<Status>Processing</Status>
<CreateTime>2023-11-17T09:14:39.000Z</CreateTime>
<StartTime>2023-11-17T09:14:39.000Z</StartTime>
<ProcessPercentage>0</ProcessPercentage>
<EstimatedRemainingTime>100</EstimatedRemainingTime>
</BucketDataRedundancyTransition>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123', 'content-type' => 'application/xml'],
Utils::streamFor($body)
);
$result = BucketRedundancyTransition::toGetBucketDataRedundancyTransition($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(2, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals('application/xml', $result->headers['content-type']);
$this->assertEquals('examplebucket', $result->bucketDataRedundancyTransition->bucket);
$this->assertEquals('909c6c818dd041d1a44e0fdc66aa****', $result->bucketDataRedundancyTransition->taskId);
$this->assertEquals('Processing', $result->bucketDataRedundancyTransition->status);
$this->assertEquals('2023-11-17T09:14:39.000Z', $result->bucketDataRedundancyTransition->createTime);
$this->assertEquals('2023-11-17T09:14:39.000Z', $result->bucketDataRedundancyTransition->startTime);
$this->assertEquals(0, $result->bucketDataRedundancyTransition->processPercentage);
$this->assertEquals(100, $result->bucketDataRedundancyTransition->estimatedRemainingTime);
$body = '<?xml version="1.0" encoding="UTF-8"?>
<BucketDataRedundancyTransition>
<Bucket>examplebucket</Bucket>
<TaskId>909c6c818dd041d1a44e0fdc66aa****</TaskId>
<Status>Finished</Status>
<CreateTime>2023-11-17T09:14:39.000Z</CreateTime>
<StartTime>2023-11-17T09:14:39.000Z</StartTime>
<ProcessPercentage>100</ProcessPercentage>
<EstimatedRemainingTime>0</EstimatedRemainingTime>
<EndTime>2023-11-18T09:14:39.000Z</EndTime>
</BucketDataRedundancyTransition>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123', 'content-type' => 'application/xml'],
Utils::streamFor($body)
);
$result = BucketRedundancyTransition::toGetBucketDataRedundancyTransition($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(2, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals('application/xml', $result->headers['content-type']);
$this->assertEquals('examplebucket', $result->bucketDataRedundancyTransition->bucket);
$this->assertEquals('909c6c818dd041d1a44e0fdc66aa****', $result->bucketDataRedundancyTransition->taskId);
$this->assertEquals('Finished', $result->bucketDataRedundancyTransition->status);
$this->assertEquals('2023-11-17T09:14:39.000Z', $result->bucketDataRedundancyTransition->createTime);
$this->assertEquals('2023-11-17T09:14:39.000Z', $result->bucketDataRedundancyTransition->startTime);
$this->assertEquals(100, $result->bucketDataRedundancyTransition->processPercentage);
$this->assertEquals(0, $result->bucketDataRedundancyTransition->estimatedRemainingTime);
$this->assertEquals('2023-11-18T09:14:39.000Z', $result->bucketDataRedundancyTransition->endTime);
}
public function testFromDeleteBucketDataRedundancyTransition()
{
// miss required field
try {
$request = new Models\DeleteBucketDataRedundancyTransitionRequest();
$input = BucketRedundancyTransition::fromDeleteBucketDataRedundancyTransition($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
try {
$request = new Models\DeleteBucketDataRedundancyTransitionRequest('bucket-123');
$input = BucketRedundancyTransition::fromDeleteBucketDataRedundancyTransition($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, redundancyTransitionTaskid", (string)$e);
}
$request = new Models\DeleteBucketDataRedundancyTransitionRequest('bucket-123', 'task-123');
$input = BucketRedundancyTransition::fromDeleteBucketDataRedundancyTransition($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
$this->assertEquals('task-123', $input->getParameters()['x-oss-redundancy-transition-taskid']);
}
public function testToDeleteBucketDataRedundancyTransition()
{
// empty output
$output = new OperationOutput();
$result = BucketRedundancyTransition::toDeleteBucketDataRedundancyTransition($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'No Content',
204,
['x-oss-request-id' => '123']
);
$result = BucketRedundancyTransition::toDeleteBucketDataRedundancyTransition($output);
$this->assertEquals('No Content', $result->status);
$this->assertEquals(204, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
}
public function testFromListBucketDataRedundancyTransition()
{
// miss required field
try {
$request = new Models\ListBucketDataRedundancyTransitionRequest();
$input = BucketRedundancyTransition::fromListBucketDataRedundancyTransition($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
$request = new Models\ListBucketDataRedundancyTransitionRequest('bucket-123');
$input = BucketRedundancyTransition::fromListBucketDataRedundancyTransition($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
}
public function testToListBucketDataRedundancyTransition()
{
// empty output
$output = new OperationOutput();
$result = BucketRedundancyTransition::toListBucketDataRedundancyTransition($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$body = '<?xml version="1.0" encoding="UTF-8"?>
<ListBucketDataRedundancyTransition>
<BucketDataRedundancyTransition>
<Bucket>examplebucket</Bucket>
<TaskId>4be5beb0f74f490186311b268bf6****</TaskId>
<Status>Queueing</Status>
<CreateTime>2023-11-17T09:11:58.000Z</CreateTime>
</BucketDataRedundancyTransition>
</ListBucketDataRedundancyTransition>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123', 'content-type' => 'application/xml'],
Utils::streamFor($body)
);
$result = BucketRedundancyTransition::toListBucketDataRedundancyTransition($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(2, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals('application/xml', $result->headers['content-type']);
$this->assertEquals('examplebucket', $result->listBucketDataRedundancyTransition->bucketDataRedundancyTransitions[0]->bucket);
$this->assertEquals('4be5beb0f74f490186311b268bf6****', $result->listBucketDataRedundancyTransition->bucketDataRedundancyTransitions[0]->taskId);
$this->assertEquals('Queueing', $result->listBucketDataRedundancyTransition->bucketDataRedundancyTransitions[0]->status);
$this->assertEquals('2023-11-17T09:11:58.000Z', $result->listBucketDataRedundancyTransition->bucketDataRedundancyTransitions[0]->createTime);
$body = '<?xml version="1.0" encoding="UTF-8"?>
<ListBucketDataRedundancyTransition>
<BucketDataRedundancyTransition>
<Bucket>examplebucket</Bucket>
<TaskId>909c6c818dd041d1a44e0fdc66aa****</TaskId>
<Status>Processing</Status>
<CreateTime>2023-11-17T09:14:39.000Z</CreateTime>
<StartTime>2023-11-17T09:14:39.000Z</StartTime>
<ProcessPercentage>0</ProcessPercentage>
<EstimatedRemainingTime>100</EstimatedRemainingTime>
</BucketDataRedundancyTransition>
</ListBucketDataRedundancyTransition>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123', 'content-type' => 'application/xml'],
Utils::streamFor($body)
);
$result = BucketRedundancyTransition::toListBucketDataRedundancyTransition($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(2, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals('application/xml', $result->headers['content-type']);
$this->assertEquals('examplebucket', $result->listBucketDataRedundancyTransition->bucketDataRedundancyTransitions[0]->bucket);
$this->assertEquals('909c6c818dd041d1a44e0fdc66aa****', $result->listBucketDataRedundancyTransition->bucketDataRedundancyTransitions[0]->taskId);
$this->assertEquals('Processing', $result->listBucketDataRedundancyTransition->bucketDataRedundancyTransitions[0]->status);
$this->assertEquals('2023-11-17T09:14:39.000Z', $result->listBucketDataRedundancyTransition->bucketDataRedundancyTransitions[0]->createTime);
$this->assertEquals('2023-11-17T09:14:39.000Z', $result->listBucketDataRedundancyTransition->bucketDataRedundancyTransitions[0]->startTime);
$this->assertEquals(0, $result->listBucketDataRedundancyTransition->bucketDataRedundancyTransitions[0]->processPercentage);
$this->assertEquals(100, $result->listBucketDataRedundancyTransition->bucketDataRedundancyTransitions[0]->estimatedRemainingTime);
$body = '<?xml version="1.0" encoding="UTF-8"?>
<ListBucketDataRedundancyTransition>
<BucketDataRedundancyTransition>
<Bucket>examplebucket</Bucket>
<TaskId>909c6c818dd041d1a44e0fdc66aa****</TaskId>
<Status>Finished</Status>
<CreateTime>2023-11-17T09:14:39.000Z</CreateTime>
<StartTime>2023-11-17T09:14:39.000Z</StartTime>
<ProcessPercentage>100</ProcessPercentage>
<EstimatedRemainingTime>0</EstimatedRemainingTime>
<EndTime>2023-11-18T09:14:39.000Z</EndTime>
</BucketDataRedundancyTransition>
</ListBucketDataRedundancyTransition>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123', 'content-type' => 'application/xml'],
Utils::streamFor($body)
);
$result = BucketRedundancyTransition::toListBucketDataRedundancyTransition($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(2, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals('application/xml', $result->headers['content-type']);
$this->assertEquals('examplebucket', $result->listBucketDataRedundancyTransition->bucketDataRedundancyTransitions[0]->bucket);
$this->assertEquals('909c6c818dd041d1a44e0fdc66aa****', $result->listBucketDataRedundancyTransition->bucketDataRedundancyTransitions[0]->taskId);
$this->assertEquals('Finished', $result->listBucketDataRedundancyTransition->bucketDataRedundancyTransitions[0]->status);
$this->assertEquals('2023-11-17T09:14:39.000Z', $result->listBucketDataRedundancyTransition->bucketDataRedundancyTransitions[0]->createTime);
$this->assertEquals('2023-11-17T09:14:39.000Z', $result->listBucketDataRedundancyTransition->bucketDataRedundancyTransitions[0]->startTime);
$this->assertEquals(100, $result->listBucketDataRedundancyTransition->bucketDataRedundancyTransitions[0]->processPercentage);
$this->assertEquals(0, $result->listBucketDataRedundancyTransition->bucketDataRedundancyTransitions[0]->estimatedRemainingTime);
$this->assertEquals('2023-11-18T09:14:39.000Z', $result->listBucketDataRedundancyTransition->bucketDataRedundancyTransitions[0]->endTime);
}
public function testFromListUserDataRedundancyTransition()
{
$request = new Models\ListUserDataRedundancyTransitionRequest();
$input = BucketRedundancyTransition::fromListUserDataRedundancyTransition($request);
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
$request = new Models\ListUserDataRedundancyTransitionRequest('token');
$input = BucketRedundancyTransition::fromListUserDataRedundancyTransition($request);
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
$this->assertEquals('token', $input->getParameters()['continuation-token']);
$request = new Models\ListUserDataRedundancyTransitionRequest('token', '100');
$input = BucketRedundancyTransition::fromListUserDataRedundancyTransition($request);
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
$this->assertEquals('token', $input->getParameters()['continuation-token']);
$this->assertEquals(100, $input->getParameters()['max-keys']);
}
public function testToListUserDataRedundancyTransition()
{
// empty output
$output = new OperationOutput();
$result = BucketRedundancyTransition::toListBucketDataRedundancyTransition($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$body = '<?xml version="1.0" encoding="UTF-8"?>
<ListBucketDataRedundancyTransition>
<BucketDataRedundancyTransition>
<Bucket>examplebucket</Bucket>
<TaskId>4be5beb0f74f490186311b268bf6****</TaskId>
<Status>Queueing</Status>
<CreateTime>2023-11-17T09:11:58.000Z</CreateTime>
</BucketDataRedundancyTransition>
<BucketDataRedundancyTransition>
<Bucket>examplebucket1</Bucket>
<TaskId>909c6c818dd041d1a44e0fdc66aa****</TaskId>
<Status>Processing</Status>
<CreateTime>2023-11-17T09:14:39.000Z</CreateTime>
<StartTime>2023-11-17T09:14:39.000Z</StartTime>
<ProcessPercentage>0</ProcessPercentage>
<EstimatedRemainingTime>100</EstimatedRemainingTime>
</BucketDataRedundancyTransition>
<BucketDataRedundancyTransition>
<Bucket>examplebucket2</Bucket>
<TaskId>909c6c818dd041d1a44e0fdc66aa****</TaskId>
<Status>Finished</Status>
<CreateTime>2023-11-17T09:14:39.000Z</CreateTime>
<StartTime>2023-11-17T09:14:39.000Z</StartTime>
<ProcessPercentage>100</ProcessPercentage>
<EstimatedRemainingTime>0</EstimatedRemainingTime>
<EndTime>2023-11-18T09:14:39.000Z</EndTime>
</BucketDataRedundancyTransition>
<IsTruncated>false</IsTruncated>
<NextContinuationToken></NextContinuationToken>
</ListBucketDataRedundancyTransition>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123', 'content-type' => 'application/xml'],
Utils::streamFor($body)
);
$result = BucketRedundancyTransition::toListBucketDataRedundancyTransition($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(2, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals('application/xml', $result->headers['content-type']);
$this->assertEquals(3, count($result->listBucketDataRedundancyTransition->bucketDataRedundancyTransitions));
$this->assertEquals('examplebucket', $result->listBucketDataRedundancyTransition->bucketDataRedundancyTransitions[0]->bucket);
$this->assertEquals('4be5beb0f74f490186311b268bf6****', $result->listBucketDataRedundancyTransition->bucketDataRedundancyTransitions[0]->taskId);
$this->assertEquals('Queueing', $result->listBucketDataRedundancyTransition->bucketDataRedundancyTransitions[0]->status);
$this->assertEquals('2023-11-17T09:11:58.000Z', $result->listBucketDataRedundancyTransition->bucketDataRedundancyTransitions[0]->createTime);
$this->assertEquals('examplebucket1', $result->listBucketDataRedundancyTransition->bucketDataRedundancyTransitions[1]->bucket);
$this->assertEquals('909c6c818dd041d1a44e0fdc66aa****', $result->listBucketDataRedundancyTransition->bucketDataRedundancyTransitions[1]->taskId);
$this->assertEquals('Processing', $result->listBucketDataRedundancyTransition->bucketDataRedundancyTransitions[1]->status);
$this->assertEquals('2023-11-17T09:14:39.000Z', $result->listBucketDataRedundancyTransition->bucketDataRedundancyTransitions[1]->createTime);
$this->assertEquals('2023-11-17T09:14:39.000Z', $result->listBucketDataRedundancyTransition->bucketDataRedundancyTransitions[1]->startTime);
$this->assertEquals(0, $result->listBucketDataRedundancyTransition->bucketDataRedundancyTransitions[1]->processPercentage);
$this->assertEquals(100, $result->listBucketDataRedundancyTransition->bucketDataRedundancyTransitions[1]->estimatedRemainingTime);
$this->assertEquals('examplebucket2', $result->listBucketDataRedundancyTransition->bucketDataRedundancyTransitions[2]->bucket);
$this->assertEquals('909c6c818dd041d1a44e0fdc66aa****', $result->listBucketDataRedundancyTransition->bucketDataRedundancyTransitions[2]->taskId);
$this->assertEquals('Finished', $result->listBucketDataRedundancyTransition->bucketDataRedundancyTransitions[2]->status);
$this->assertEquals('2023-11-17T09:14:39.000Z', $result->listBucketDataRedundancyTransition->bucketDataRedundancyTransitions[2]->createTime);
$this->assertEquals('2023-11-17T09:14:39.000Z', $result->listBucketDataRedundancyTransition->bucketDataRedundancyTransitions[2]->startTime);
$this->assertEquals(100, $result->listBucketDataRedundancyTransition->bucketDataRedundancyTransitions[2]->processPercentage);
$this->assertEquals(0, $result->listBucketDataRedundancyTransition->bucketDataRedundancyTransitions[2]->estimatedRemainingTime);
$this->assertEquals('2023-11-18T09:14:39.000Z', $result->listBucketDataRedundancyTransition->bucketDataRedundancyTransitions[2]->endTime);
}
private function cleanXml($xml): array|string
{
return str_replace("\n", "", str_replace("\r", "", $xml));
}
}

200
vendor/alibabacloud/oss-v2/tests/UnitTests/Transform/BucketRefererTest.php vendored Normal file
View File

@@ -0,0 +1,200 @@
<?php
namespace UnitTests\Transform;
use AlibabaCloud\Oss\V2\Models;
use AlibabaCloud\Oss\V2\Transform\BucketReferer;
use AlibabaCloud\Oss\V2\OperationOutput;
use AlibabaCloud\Oss\V2\Utils;
use DateTime;
use DateTimeZone;
class BucketRefererTest extends \PHPUnit\Framework\TestCase
{
public function testFromPutBucketReferer()
{
// miss required field
try {
$request = new Models\PutBucketRefererRequest();
$input = BucketReferer::fromPutBucketReferer($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
try {
$request = new Models\PutBucketRefererRequest('bucket-123');
$input = BucketReferer::fromPutBucketReferer($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, refererConfiguration", (string)$e);
}
// demo1
$request = new Models\PutBucketRefererRequest('bucket-123', new Models\RefererConfiguration(
allowEmptyReferer: false,
allowTruncateQueryString: true,
truncatePath: true,
refererList: new Models\RefererList(["http://www.aliyun.com", "https://www.aliyun.com", "http://www.*.com", "https://www.?.aliyuncs.com",]),
refererBlacklist: new Models\RefererBlacklist(["http://www.refuse.com", "https://*.hack.com", "http://ban.*.com", "https://www.?.deny.com",])
));
$input = BucketReferer::fromPutBucketReferer($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><RefererConfiguration><AllowEmptyReferer>false</AllowEmptyReferer><AllowTruncateQueryString>true</AllowTruncateQueryString><TruncatePath>true</TruncatePath><RefererList><Referer>http://www.aliyun.com</Referer><Referer>https://www.aliyun.com</Referer><Referer>http://www.*.com</Referer><Referer>https://www.?.aliyuncs.com</Referer></RefererList><RefererBlacklist><Referer>http://www.refuse.com</Referer><Referer>https://*.hack.com</Referer><Referer>http://ban.*.com</Referer><Referer>https://www.?.deny.com</Referer></RefererBlacklist></RefererConfiguration>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
// demo2
$request = new Models\PutBucketRefererRequest('bucket-123', new Models\RefererConfiguration(
allowEmptyReferer: false,
allowTruncateQueryString: true,
truncatePath: true,
refererList: new Models\RefererList(["http://www.aliyun.com", "https://www.aliyun.com", "http://www.*.com", "https://www.?.aliyuncs.com",]),
));
$input = BucketReferer::fromPutBucketReferer($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><RefererConfiguration><AllowEmptyReferer>false</AllowEmptyReferer><AllowTruncateQueryString>true</AllowTruncateQueryString><TruncatePath>true</TruncatePath><RefererList><Referer>http://www.aliyun.com</Referer><Referer>https://www.aliyun.com</Referer><Referer>http://www.*.com</Referer><Referer>https://www.?.aliyuncs.com</Referer></RefererList></RefererConfiguration>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
// demo3
$request = new Models\PutBucketRefererRequest('bucket-123', new Models\RefererConfiguration(
allowEmptyReferer: false,
refererList: new Models\RefererList([""]),
));
$input = BucketReferer::fromPutBucketReferer($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><RefererConfiguration><AllowEmptyReferer>false</AllowEmptyReferer><RefererList><Referer></Referer></RefererList></RefererConfiguration>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
}
public function testToPutBucketReferer()
{
// empty output
$output = new OperationOutput();
$result = BucketReferer::toPutBucketReferer($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123']
);
$result = BucketReferer::toPutBucketReferer($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
}
public function testFromGetBucketReferer()
{
// miss required field
try {
$request = new Models\GetBucketRefererRequest();
$input = BucketReferer::fromGetBucketReferer($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
$request = new Models\GetBucketRefererRequest('bucket-123');
$input = BucketReferer::fromGetBucketReferer($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
}
public function testToGetBucketReferer()
{
// empty output
$output = new OperationOutput();
$result = BucketReferer::toGetBucketReferer($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$body = '<?xml version="1.0" encoding="UTF-8"?>
<RefererConfiguration>
<AllowEmptyReferer>false</AllowEmptyReferer>
<AllowTruncateQueryString>true</AllowTruncateQueryString>
<TruncatePath>true</TruncatePath>
<RefererList>
<Referer>http://www.aliyun.com</Referer>
<Referer>https://www.aliyun.com</Referer>
<Referer>http://www.*.com</Referer>
<Referer>https://www.?.aliyuncs.com</Referer>
</RefererList>
</RefererConfiguration>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123', 'content-type' => 'application/xml'],
Utils::streamFor($body)
);
$result = BucketReferer::toGetBucketReferer($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(2, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals('application/xml', $result->headers['content-type']);
$this->assertFalse($result->refererConfiguration->allowEmptyReferer);
$this->assertTrue($result->refererConfiguration->allowTruncateQueryString);
$this->assertTrue($result->refererConfiguration->truncatePath);
$this->assertEquals(4, count($result->refererConfiguration->refererList->referers));
$this->assertEquals("https://www.?.aliyuncs.com", ($result->refererConfiguration->refererList->referers[3]));
$body = '<?xml version="1.0" encoding="UTF-8"?>
<RefererConfiguration>
<AllowEmptyReferer>false</AllowEmptyReferer>
<AllowTruncateQueryString>true</AllowTruncateQueryString>
<TruncatePath>true</TruncatePath>
<RefererList>
<Referer>http://www.aliyun.com</Referer>
<Referer>https://www.aliyun.com</Referer>
<Referer>http://www.*.com</Referer>
<Referer>https://www.?.aliyuncs.com</Referer>
</RefererList>
<RefererBlacklist>
<Referer>http://www.refuse.com</Referer>
<Referer>https://*.hack.com</Referer>
<Referer>http://ban.*.com</Referer>
<Referer>https://www.?.deny.com</Referer>
</RefererBlacklist>
</RefererConfiguration>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123', 'content-type' => 'application/xml'],
Utils::streamFor($body)
);
$result = BucketReferer::toGetBucketReferer($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(2, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals('application/xml', $result->headers['content-type']);
$this->assertFalse($result->refererConfiguration->allowEmptyReferer);
$this->assertTrue($result->refererConfiguration->allowTruncateQueryString);
$this->assertTrue($result->refererConfiguration->truncatePath);
$this->assertEquals(4, count($result->refererConfiguration->refererList->referers));
$this->assertEquals(4, count($result->refererConfiguration->refererBlacklist->referers));
$this->assertEquals("https://www.?.aliyuncs.com", ($result->refererConfiguration->refererList->referers[3]));
$this->assertEquals("http://ban.*.com", ($result->refererConfiguration->refererBlacklist->referers[2]));
}
private function cleanXml($xml): array|string
{
return str_replace("\n", "", str_replace("\r", "", $xml));
}
}

428
vendor/alibabacloud/oss-v2/tests/UnitTests/Transform/BucketReplicationTest.php vendored Normal file
View File

@@ -0,0 +1,428 @@
<?php
namespace UnitTests\Transform;
use AlibabaCloud\Oss\V2\Models;
use AlibabaCloud\Oss\V2\Transform\BucketReplication;
use AlibabaCloud\Oss\V2\OperationOutput;
use AlibabaCloud\Oss\V2\Utils;
class BucketReplicationTest extends \PHPUnit\Framework\TestCase
{
public function testFromPutBucketRtc()
{
// miss required field
try {
$request = new Models\PutBucketRtcRequest();
$input = BucketReplication::fromPutBucketRtc($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
try {
$request = new Models\PutBucketRtcRequest('bucket-123');
$input = BucketReplication::fromPutBucketRtc($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, rtcConfiguration", (string)$e);
}
$request = new Models\PutBucketRtcRequest('bucket-123', new Models\RtcConfiguration(
rtc: new Models\ReplicationTimeControl(
status: 'enabled'
),
id: 'test_replication_rule_1'
));
$input = BucketReplication::fromPutBucketRtc($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><ReplicationRule><RTC><Status>enabled</Status></RTC><ID>test_replication_rule_1</ID></ReplicationRule>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
}
public function testToPutBucketRtc()
{
// empty output
$output = new OperationOutput();
$result = BucketReplication::toPutBucketRtc($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123']
);
$result = BucketReplication::toPutBucketRtc($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
}
public function testFromPutBucketReplication()
{
// miss required field
try {
$request = new Models\PutBucketReplicationRequest();
$input = BucketReplication::fromPutBucketReplication($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
try {
$request = new Models\PutBucketReplicationRequest('bucket-123');
$input = BucketReplication::fromPutBucketReplication($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, replicationConfiguration", (string)$e);
}
$request = new Models\PutBucketReplicationRequest('bucket-123', new Models\ReplicationConfiguration(
array(new Models\ReplicationRule(
sourceSelectionCriteria: new Models\ReplicationSourceSelectionCriteria(
sseKmsEncryptedObjects: new Models\SseKmsEncryptedObjects(
status: 'Enabled',
)
),
destination: new Models\ReplicationDestination(
bucket: 'destBucket',
location: 'oss-cn-beijing',
transferType: Models\TransferType::OSS_ACC
),
historicalObjectReplication: Models\HistoricalObjectReplicationType::ENABLED,
syncRole: 'aliyunramrole',
encryptionConfiguration: new Models\ReplicationEncryptionConfiguration(
replicaKmsKeyID: 'c4d49f85-ee30-426b-a5ed-95e9139d****'
),
rtc: new Models\ReplicationTimeControl(
status: 'enabled'
)
))
));
$input = BucketReplication::fromPutBucketReplication($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><ReplicationConfiguration><Rule><SourceSelectionCriteria><SseKmsEncryptedObjects><Status>Enabled</Status></SseKmsEncryptedObjects></SourceSelectionCriteria><Destination><Bucket>destBucket</Bucket><Location>oss-cn-beijing</Location><TransferType>oss_acc</TransferType></Destination><HistoricalObjectReplication>enabled</HistoricalObjectReplication><SyncRole>aliyunramrole</SyncRole><EncryptionConfiguration><ReplicaKmsKeyID>c4d49f85-ee30-426b-a5ed-95e9139d****</ReplicaKmsKeyID></EncryptionConfiguration><RTC><Status>enabled</Status></RTC></Rule></ReplicationConfiguration>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
}
public function testToPutBucketReplication()
{
// empty output
$output = new OperationOutput();
$result = BucketReplication::toPutBucketReplication($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123', 'x-oss-replication-rule-id' => 'b890c26e-907e-4692-b9ac-ec4c11ec****']
);
$result = BucketReplication::toPutBucketReplication($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(2, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals('b890c26e-907e-4692-b9ac-ec4c11ec****', $result->replicationRuleId);
}
public function testFromGetBucketReplication()
{
// miss required field
try {
$request = new Models\GetBucketReplicationRequest();
$input = BucketReplication::fromGetBucketReplication($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
$request = new Models\GetBucketReplicationRequest('bucket-123');
$input = BucketReplication::fromGetBucketReplication($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
}
public function testToGetBucketReplication()
{
// empty output
$output = new OperationOutput();
$result = BucketReplication::toGetBucketReplication($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$body = '<?xml version="1.0" encoding="UTF-8"?>
<ReplicationConfiguration>
<Rule>
<ID>test_replication_1</ID>
<PrefixSet>
<Prefix>source1</Prefix>
<Prefix>video</Prefix>
</PrefixSet>
<Action>PUT</Action>
<Destination>
<Bucket>destbucket</Bucket>
<Location>oss-cn-beijing</Location>
<TransferType>oss_acc</TransferType>
</Destination>
<Status>doing</Status>
<HistoricalObjectReplication>enabled</HistoricalObjectReplication>
<SyncRole>aliyunramrole</SyncRole>
<RTC>
<Status>enabled</Status>
</RTC>
</Rule>
</ReplicationConfiguration>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123'],
Utils::streamFor($body)
);
$result = BucketReplication::toGetBucketReplication($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals(1, count($result->replicationConfiguration->rules));
$this->assertEquals('enabled', $result->replicationConfiguration->rules[0]->rtc->status);
$this->assertEquals('test_replication_1', $result->replicationConfiguration->rules[0]->id);
$this->assertEquals('source1', $result->replicationConfiguration->rules[0]->prefixSet->prefixs[0]);
$this->assertEquals('video', $result->replicationConfiguration->rules[0]->prefixSet->prefixs[1]);
$this->assertEquals('PUT', $result->replicationConfiguration->rules[0]->action);
$this->assertEquals(Models\TransferType::OSS_ACC, $result->replicationConfiguration->rules[0]->destination->transferType);
$this->assertEquals('oss-cn-beijing', $result->replicationConfiguration->rules[0]->destination->location);
$this->assertEquals('doing', $result->replicationConfiguration->rules[0]->status);
$this->assertEquals(Models\HistoricalObjectReplicationType::ENABLED, $result->replicationConfiguration->rules[0]->historicalObjectReplication);
$this->assertEquals('aliyunramrole', $result->replicationConfiguration->rules[0]->syncRole);
}
public function testFromGetBucketReplicationLocation()
{
// miss required field
try {
$request = new Models\GetBucketReplicationLocationRequest();
$input = BucketReplication::fromGetBucketReplicationLocation($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
$request = new Models\GetBucketReplicationLocationRequest('bucket-123');
$input = BucketReplication::fromGetBucketReplicationLocation($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
}
public function testToGetBucketReplicationLocation()
{
// empty output
$output = new OperationOutput();
$result = BucketReplication::toGetBucketReplicationLocation($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$body = '<?xml version="1.0" encoding="UTF-8"?>
<ReplicationLocation>
<Location>oss-cn-beijing</Location>
<Location>oss-cn-qingdao</Location>
<Location>oss-cn-shenzhen</Location>
<Location>oss-cn-hongkong</Location>
<Location>oss-us-west-1</Location>
<LocationTransferTypeConstraint>
<LocationTransferType>
<Location>oss-cn-hongkong</Location>
<TransferTypes>
<Type>oss_acc</Type>
</TransferTypes>
</LocationTransferType>
<LocationTransferType>
<Location>oss-us-west-1</Location>
<TransferTypes>
<Type>oss_acc</Type>
</TransferTypes>
</LocationTransferType>
</LocationTransferTypeConstraint>
</ReplicationLocation>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123'],
Utils::streamFor($body)
);
$result = BucketReplication::toGetBucketReplicationLocation($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals(5, count($result->replicationLocation->locations));
$this->assertEquals('oss-cn-beijing', $result->replicationLocation->locations[0]);
$this->assertEquals('oss-cn-qingdao', $result->replicationLocation->locations[1]);
$this->assertEquals('oss-cn-shenzhen', $result->replicationLocation->locations[2]);
$this->assertEquals('oss-cn-hongkong', $result->replicationLocation->locations[3]);
$this->assertEquals('oss-us-west-1', $result->replicationLocation->locations[4]);
$this->assertEquals(2, count($result->replicationLocation->locationTransferTypeConstraint->locationTransferTypes));
$this->assertEquals('oss-cn-hongkong', $result->replicationLocation->locationTransferTypeConstraint->locationTransferTypes[0]->location);
$this->assertEquals('oss_acc', $result->replicationLocation->locationTransferTypeConstraint->locationTransferTypes[0]->transferTypes->types[0]);
$this->assertEquals('oss-us-west-1', $result->replicationLocation->locationTransferTypeConstraint->locationTransferTypes[1]->location);
$this->assertEquals('oss_acc', $result->replicationLocation->locationTransferTypeConstraint->locationTransferTypes[1]->transferTypes->types[0]);
}
public function testFromGetBucketReplicationProgress()
{
// miss required field
try {
$request = new Models\GetBucketReplicationProgressRequest();
$input = BucketReplication::fromGetBucketReplicationProgress($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
try {
$request = new Models\GetBucketReplicationProgressRequest('bucket-123');
$input = BucketReplication::fromGetBucketReplicationProgress($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, ruleId", (string)$e);
}
$request = new Models\GetBucketReplicationProgressRequest('bucket-123', 'rule-1');
$input = BucketReplication::fromGetBucketReplicationProgress($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
}
public function testToGetBucketReplicationProgress()
{
// empty output
$output = new OperationOutput();
$result = BucketReplication::toGetBucketReplicationProgress($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$body = '<?xml version="1.0" encoding="UTF-8"?>
<ReplicationProgress>
<Rule>
<ID>test_replication_1</ID>
<PrefixSet>
<Prefix>source_image</Prefix>
<Prefix>video</Prefix>
</PrefixSet>
<Action>PUT</Action>
<Destination>
<Bucket>target-bucket</Bucket>
<Location>oss-cn-beijing</Location>
<TransferType>oss_acc</TransferType>
</Destination>
<Status>doing</Status>
<HistoricalObjectReplication>enabled</HistoricalObjectReplication>
<Progress>
<HistoricalObject>0.85</HistoricalObject>
<NewObject>2015-09-24T15:28:14.000Z</NewObject>
</Progress>
</Rule>
</ReplicationProgress>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123'],
Utils::streamFor($body)
);
$result = BucketReplication::toGetBucketReplicationProgress($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals(1, count($result->replicationProgress->rules));
$this->assertEquals('test_replication_1', $result->replicationProgress->rules[0]->id);
$this->assertEquals('source_image', $result->replicationProgress->rules[0]->prefixSet->prefixs[0]);
$this->assertEquals('video', $result->replicationProgress->rules[0]->prefixSet->prefixs[1]);
$this->assertEquals('PUT', $result->replicationProgress->rules[0]->action);
$this->assertEquals(Models\TransferType::OSS_ACC, $result->replicationProgress->rules[0]->destination->transferType);
$this->assertEquals('target-bucket', $result->replicationProgress->rules[0]->destination->bucket);
$this->assertEquals('oss-cn-beijing', $result->replicationProgress->rules[0]->destination->location);
$this->assertEquals('doing', $result->replicationProgress->rules[0]->status);
$this->assertEquals('0.85', $result->replicationProgress->rules[0]->progress->historicalObject);
$this->assertEquals('2015-09-24T15:28:14.000Z', $result->replicationProgress->rules[0]->progress->newObject);
}
public function testFromDeleteBucketReplication()
{
// miss required field
try {
$request = new Models\DeleteBucketReplicationRequest();
$input = BucketReplication::fromDeleteBucketReplication($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
try {
$request = new Models\DeleteBucketReplicationRequest('bucket-123');
$input = BucketReplication::fromDeleteBucketReplication($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, replicationRules", (string)$e);
}
$request = new Models\DeleteBucketReplicationRequest('bucket-123', new Models\ReplicationRules(
ids: ['test_replication_1']
));
$input = BucketReplication::fromDeleteBucketReplication($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><ReplicationRules><ID>test_replication_1</ID></ReplicationRules>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
}
public function testToDeleteBucketReplication()
{
// empty output
$output = new OperationOutput();
$result = BucketReplication::toGetBucketReplicationProgress($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123'],
);
$result = BucketReplication::toGetBucketReplicationProgress($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
}
private function cleanXml($xml): array|string
{
return str_replace("\n", "", str_replace("\r", "", $xml));
}
}

143
vendor/alibabacloud/oss-v2/tests/UnitTests/Transform/BucketRequestPaymentTest.php vendored Normal file
View File

@@ -0,0 +1,143 @@
<?php
namespace UnitTests\Transform;
use AlibabaCloud\Oss\V2\Models;
use AlibabaCloud\Oss\V2\Transform\BucketRequestPayment;
use AlibabaCloud\Oss\V2\OperationOutput;
use AlibabaCloud\Oss\V2\Utils;
class BucketRequestPaymentTest extends \PHPUnit\Framework\TestCase
{
public function testFromPutBucketRequestPayment()
{
// miss required field
try {
$request = new Models\PutBucketRequestPaymentRequest();
$input = BucketRequestPayment::fromPutBucketRequestPayment($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
try {
$request = new Models\PutBucketRequestPaymentRequest('bucket-123');
$input = BucketRequestPayment::fromPutBucketRequestPayment($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, requestPaymentConfiguration", (string)$e);
}
$request = new Models\PutBucketRequestPaymentRequest('bucket-123', new Models\RequestPaymentConfiguration(
'Requester'
));
$input = BucketRequestPayment::fromPutBucketRequestPayment($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><RequestPaymentConfiguration><Payer>Requester</Payer></RequestPaymentConfiguration>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
$request = new Models\PutBucketRequestPaymentRequest('bucket-123', new Models\RequestPaymentConfiguration(
'BucketOwner'
));
$input = BucketRequestPayment::fromPutBucketRequestPayment($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><RequestPaymentConfiguration><Payer>BucketOwner</Payer></RequestPaymentConfiguration>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
}
public function testToPutBucketRequestPayment()
{
// empty output
$output = new OperationOutput();
$result = BucketRequestPayment::toPutBucketRequestPayment($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123']
);
$result = BucketRequestPayment::toPutBucketRequestPayment($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
}
public function testFromGetBucketRequestPayment()
{
// miss required field
try {
$request = new Models\GetBucketRequestPaymentRequest();
$input = BucketRequestPayment::fromGetBucketRequestPayment($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
$request = new Models\GetBucketRequestPaymentRequest('bucket-123');
$input = BucketRequestPayment::fromGetBucketRequestPayment($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
}
public function testToGetBucketRequestPayment()
{
// empty output
$output = new OperationOutput();
$result = BucketRequestPayment::toGetBucketRequestPayment($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$body = '<?xml version="1.0" encoding="UTF-8"?>
<RequestPaymentConfiguration>
<Payer>Requester</Payer>
</RequestPaymentConfiguration>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123'],
Utils::streamFor($body)
);
$result = BucketRequestPayment::toGetBucketRequestPayment($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals('Requester', $result->requestPaymentConfiguration->payer);
$body = '<?xml version="1.0" encoding="UTF-8"?>
<RequestPaymentConfiguration>
<Payer>BucketOwner</Payer>
</RequestPaymentConfiguration>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123'],
Utils::streamFor($body)
);
$result = BucketRequestPayment::toGetBucketRequestPayment($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals('BucketOwner', $result->requestPaymentConfiguration->payer);
}
private function cleanXml($xml): array|string
{
return str_replace("\n", "", str_replace("\r", "", $xml));
}
}

115
vendor/alibabacloud/oss-v2/tests/UnitTests/Transform/BucketResourceGroupTest.php vendored Normal file
View File

@@ -0,0 +1,115 @@
<?php
namespace UnitTests\Transform;
use AlibabaCloud\Oss\V2\Models;
use AlibabaCloud\Oss\V2\Transform\BucketResourceGroup;
use AlibabaCloud\Oss\V2\OperationOutput;
use AlibabaCloud\Oss\V2\Utils;
class BucketResourceGroupTest extends \PHPUnit\Framework\TestCase
{
public function testFromPutBucketResourceGroup()
{
// miss required field
try {
$request = new Models\PutBucketResourceGroupRequest();
$input = BucketResourceGroup::fromPutBucketResourceGroup($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
try {
$request = new Models\PutBucketResourceGroupRequest('bucket-123');
$input = BucketResourceGroup::fromPutBucketResourceGroup($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucketResourceGroupConfiguration", (string)$e);
}
$request = new Models\PutBucketResourceGroupRequest('bucket-123', new Models\BucketResourceGroupConfiguration(
'rg-aekz****'
));
$input = BucketResourceGroup::fromPutBucketResourceGroup($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><BucketResourceGroupConfiguration><ResourceGroupId>rg-aekz****</ResourceGroupId></BucketResourceGroupConfiguration>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
}
public function testToPutBucketResourceGroup()
{
// empty output
$output = new OperationOutput();
$result = BucketResourceGroup::toPutBucketResourceGroup($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123']
);
$result = BucketResourceGroup::toPutBucketResourceGroup($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
}
public function testFromGetBucketResourceGroup()
{
// miss required field
try {
$request = new Models\GetBucketResourceGroupRequest();
$input = BucketResourceGroup::fromGetBucketResourceGroup($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
$request = new Models\GetBucketResourceGroupRequest('bucket-123');
$input = BucketResourceGroup::fromGetBucketResourceGroup($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
}
public function testToGetBucketResourceGroup()
{
// empty output
$output = new OperationOutput();
$result = BucketResourceGroup::toGetBucketResourceGroup($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$body = '<?xml version="1.0" encoding="UTF-8"?>
<BucketResourceGroupConfiguration>
<ResourceGroupId>rg-aekz****</ResourceGroupId>
</BucketResourceGroupConfiguration>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123'],
Utils::streamFor($body)
);
$result = BucketResourceGroup::toGetBucketResourceGroup($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals('rg-aekz****', $result->bucketResourceGroupConfiguration->resourceGroupId);
}
private function cleanXml($xml): array|string
{
return str_replace("\n", "", str_replace("\r", "", $xml));
}
}

274
vendor/alibabacloud/oss-v2/tests/UnitTests/Transform/BucketStyleTest.php vendored Normal file
View File

@@ -0,0 +1,274 @@
<?php
namespace UnitTests\Transform;
use AlibabaCloud\Oss\V2\Models;
use AlibabaCloud\Oss\V2\Transform\BucketStyle;
use AlibabaCloud\Oss\V2\OperationOutput;
use AlibabaCloud\Oss\V2\Utils;
class BucketStyleTest extends \PHPUnit\Framework\TestCase
{
public function testFromPutStyle()
{
// miss required field
try {
$request = new Models\PutStyleRequest();
$input = BucketStyle::fromPutStyle($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
try {
$request = new Models\PutStyleRequest('bucket-123');
$input = BucketStyle::fromPutStyle($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, styleName", (string)$e);
}
try {
$request = new Models\PutStyleRequest('bucket-123', 'test');
$input = BucketStyle::fromPutStyle($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, style", (string)$e);
}
// demo1
$request = new Models\PutStyleRequest('bucket-123',
styleName: 'test',
style: new Models\StyleContent(
'image/resize,p_50'
)
);
$input = BucketStyle::fromPutStyle($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><Style><Content>image/resize,p_50</Content></Style>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
}
public function testToPutStyle()
{
// empty output
$output = new OperationOutput();
$result = BucketStyle::toPutStyle($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123']
);
$result = BucketStyle::toPutStyle($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
}
public function testFromGetStyle()
{
// miss required field
try {
$request = new Models\GetStyleRequest();
$input = BucketStyle::fromGetStyle($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
try {
$request = new Models\GetStyleRequest('bucket-123');
$input = BucketStyle::fromGetStyle($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, styleName", (string)$e);
}
$request = new Models\GetStyleRequest('bucket-123', 'style-123');
$input = BucketStyle::fromGetStyle($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
}
public function testToGetStyle()
{
// empty output
$output = new OperationOutput();
$result = BucketStyle::toGetStyle($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$body = '<?xml version="1.0" encoding="UTF-8"?>
<Style>
<Name>imagestyle</Name>
<Content>image/resize,p_50</Content>
<Category>image</Category>
<CreateTime>Wed, 20 May 2020 12:07:15 GMT</CreateTime>
<LastModifyTime>Wed, 21 May 2020 12:07:15 GMT</LastModifyTime>
</Style>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123', 'content-type' => 'application/xml'],
Utils::streamFor($body)
);
$result = BucketStyle::toGetStyle($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(2, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals('application/xml', $result->headers['content-type']);
$this->assertEquals('imagestyle', $result->style->name);
$this->assertEquals('image/resize,p_50', $result->style->content);
$this->assertEquals('image', $result->style->category);
$this->assertEquals('Wed, 20 May 2020 12:07:15 GMT', $result->style->createTime);
$this->assertEquals('Wed, 21 May 2020 12:07:15 GMT', $result->style->lastModifyTime);
}
public function testFromListStyle()
{
// miss required field
try {
$request = new Models\ListStyleRequest();
$input = BucketStyle::fromListStyle($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
$request = new Models\ListStyleRequest('bucket-123');
$input = BucketStyle::fromListStyle($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
}
public function testToListStyle()
{
// empty output
$output = new OperationOutput();
$result = BucketStyle::toListStyle($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$body = '<?xml version="1.0" encoding="UTF-8"?>
<StyleList>
<Style>
<Name>imagestyle</Name>
<Content>image/resize,p_50</Content>
<Category>image</Category>
<CreateTime>Wed, 20 May 2020 12:07:15 GMT</CreateTime>
<LastModifyTime>Wed, 21 May 2020 12:07:15 GMT</LastModifyTime>
</Style>
<Style>
<Name>imagestyle1</Name>
<Content>image/resize,w_200</Content>
<Category>image</Category>
<CreateTime>Wed, 20 May 2020 12:08:04 GMT</CreateTime>
<LastModifyTime>Wed, 21 May 2020 12:08:04 GMT</LastModifyTime>
</Style>
<Style>
<Name>imagestyle2</Name>
<Content>image/resize,w_300</Content>
<Category>image</Category>
<CreateTime>Fri, 12 Mar 2021 06:19:13 GMT</CreateTime>
<LastModifyTime>Fri, 13 Mar 2021 06:27:21 GMT</LastModifyTime>
</Style>
</StyleList>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123', 'content-type' => 'application/xml'],
Utils::streamFor($body)
);
$result = BucketStyle::toListStyle($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(2, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals('application/xml', $result->headers['content-type']);
$this->assertEquals('imagestyle', $result->styleList->styles[0]->name);
$this->assertEquals('image/resize,p_50', $result->styleList->styles[0]->content);
$this->assertEquals('image', $result->styleList->styles[0]->category);
$this->assertEquals('Wed, 20 May 2020 12:07:15 GMT', $result->styleList->styles[0]->createTime);
$this->assertEquals('Wed, 21 May 2020 12:07:15 GMT', $result->styleList->styles[0]->lastModifyTime);
$this->assertEquals('imagestyle1', $result->styleList->styles[1]->name);
$this->assertEquals('image/resize,w_200', $result->styleList->styles[1]->content);
$this->assertEquals('image', $result->styleList->styles[1]->category);
$this->assertEquals('Wed, 20 May 2020 12:08:04 GMT', $result->styleList->styles[1]->createTime);
$this->assertEquals('Wed, 21 May 2020 12:08:04 GMT', $result->styleList->styles[1]->lastModifyTime);
$this->assertEquals('imagestyle2', $result->styleList->styles[2]->name);
$this->assertEquals('image/resize,w_300', $result->styleList->styles[2]->content);
$this->assertEquals('image', $result->styleList->styles[2]->category);
$this->assertEquals('Fri, 12 Mar 2021 06:19:13 GMT', $result->styleList->styles[2]->createTime);
$this->assertEquals('Fri, 13 Mar 2021 06:27:21 GMT', $result->styleList->styles[2]->lastModifyTime);
}
public function testFromDeleteStyle()
{
// miss required field
try {
$request = new Models\DeleteStyleRequest();
$input = BucketStyle::fromDeleteStyle($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
try {
$request = new Models\DeleteStyleRequest('bucket-123');
$input = BucketStyle::fromDeleteStyle($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, styleName", (string)$e);
}
$request = new Models\DeleteStyleRequest('bucket-123', 'style-123');
$input = BucketStyle::fromDeleteStyle($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
}
public function testToDeleteStyle()
{
// empty output
$output = new OperationOutput();
$result = BucketStyle::toDeleteStyle($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'No Content',
204,
['x-oss-request-id' => '123']
);
$result = BucketStyle::toDeleteStyle($output);
$this->assertEquals('No Content', $result->status);
$this->assertEquals(204, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
}
private function cleanXml($xml): array|string
{
return str_replace("\n", "", str_replace("\r", "", $xml));
}
}

177
vendor/alibabacloud/oss-v2/tests/UnitTests/Transform/BucketTagsTest.php vendored Normal file
View File

@@ -0,0 +1,177 @@
<?php
namespace UnitTests\Transform;
use AlibabaCloud\Oss\V2\Models;
use AlibabaCloud\Oss\V2\Transform\BucketTags;
use AlibabaCloud\Oss\V2\OperationOutput;
use AlibabaCloud\Oss\V2\Utils;
class BucketTagsTest extends \PHPUnit\Framework\TestCase
{
public function testFromPutBucketTags()
{
// miss required field
try {
$request = new Models\PutBucketTagsRequest();
$input = BucketTags::fromPutBucketTags($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
try {
$request = new Models\PutBucketTagsRequest('bucket-123');
$input = BucketTags::fromPutBucketTags($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, tagging", (string)$e);
}
// demo1
$request = new Models\PutBucketTagsRequest('bucket-123',
tagging: new Models\Tagging(
tagSet: new Models\TagSet(
[new Models\Tag(key: 'key1', value: 'value1'), new Models\Tag(key: 'key2', value: 'value2')])
)
);
$input = BucketTags::fromPutBucketTags($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><Tagging><TagSet><Tag><Key>key1</Key><Value>value1</Value></Tag><Tag><Key>key2</Key><Value>value2</Value></Tag></TagSet></Tagging>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
}
public function testToPutBucketTags()
{
// empty output
$output = new OperationOutput();
$result = BucketTags::toPutBucketTags($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123']
);
$result = BucketTags::toPutBucketTags($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
}
public function testFromGetBucketTags()
{
// miss required field
try {
$request = new Models\GetBucketTagsRequest();
$input = BucketTags::fromGetBucketTags($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
$request = new Models\GetBucketTagsRequest('bucket-123');
$input = BucketTags::fromGetBucketTags($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
}
public function testToGetBucketTags()
{
// empty output
$output = new OperationOutput();
$result = BucketTags::toGetBucketTags($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$body = '<?xml version="1.0" encoding="UTF-8"?>
<Tagging>
<TagSet>
<Tag>
<Key>testa</Key>
<Value>testv1</Value>
</Tag>
<Tag>
<Key>testb</Key>
<Value>testv2</Value>
</Tag>
</TagSet>
</Tagging>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123', 'content-type' => 'application/xml'],
Utils::streamFor($body)
);
$result = BucketTags::toGetBucketTags($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(2, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals('application/xml', $result->headers['content-type']);
$this->assertEquals(2, count($result->tagging->tagSet->tags));
$this->assertEquals('testa', $result->tagging->tagSet->tags[0]->key);
$this->assertEquals('testv2', $result->tagging->tagSet->tags[1]->value);
}
public function testFromDeleteBucketTags()
{
// miss required field
try {
$request = new Models\DeleteBucketTagsRequest();
$input = BucketTags::fromDeleteBucketTags($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
$request = new Models\DeleteBucketTagsRequest('bucket-123');
$input = BucketTags::fromDeleteBucketTags($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
$request = new Models\DeleteBucketTagsRequest('bucket-123', tagging: 'k1,k2');
$input = BucketTags::fromDeleteBucketTags($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('k1,k2', $input->getParameters()['tagging']);
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
}
public function testToDeleteBucketTags()
{
// empty output
$output = new OperationOutput();
$result = BucketTags::toDeleteBucketTags($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'No Content',
204,
['x-oss-request-id' => '123']
);
$result = BucketTags::toDeleteBucketTags($output);
$this->assertEquals('No Content', $result->status);
$this->assertEquals(204, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
}
private function cleanXml($xml): array|string
{
return str_replace("\n", "", str_replace("\r", "", $xml));
}
}

133
vendor/alibabacloud/oss-v2/tests/UnitTests/Transform/BucketTransferAccelerationTest.php vendored Normal file
View File

@@ -0,0 +1,133 @@
<?php
namespace UnitTests\Transform;
use AlibabaCloud\Oss\V2\Models;
use AlibabaCloud\Oss\V2\Transform\BucketTransferAcceleration;
use AlibabaCloud\Oss\V2\OperationOutput;
use AlibabaCloud\Oss\V2\Utils;
class BucketTransferAccelerationTest extends \PHPUnit\Framework\TestCase
{
public function testFromPutBucketTransferAcceleration()
{
// miss required field
try {
$request = new Models\PutBucketTransferAccelerationRequest();
$input = BucketTransferAcceleration::fromPutBucketTransferAcceleration($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
try {
$request = new Models\PutBucketTransferAccelerationRequest('bucket-123');
$input = BucketTransferAcceleration::fromPutBucketTransferAcceleration($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, transferAccelerationConfiguration", (string)$e);
}
$request = new Models\PutBucketTransferAccelerationRequest('bucket-123', new Models\TransferAccelerationConfiguration(
true
));
$input = BucketTransferAcceleration::fromPutBucketTransferAcceleration($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><TransferAccelerationConfiguration><Enabled>true</Enabled></TransferAccelerationConfiguration>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
}
public function testToPutBucketTransferAcceleration()
{
// empty output
$output = new OperationOutput();
$result = BucketTransferAcceleration::toPutBucketTransferAcceleration($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123']
);
$result = BucketTransferAcceleration::toPutBucketTransferAcceleration($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
}
public function testFromGetBucketTransferAcceleration()
{
// miss required field
try {
$request = new Models\GetBucketTransferAccelerationRequest();
$input = BucketTransferAcceleration::fromGetBucketTransferAcceleration($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
$request = new Models\GetBucketTransferAccelerationRequest('bucket-123');
$input = BucketTransferAcceleration::fromGetBucketTransferAcceleration($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
}
public function testToGetBucketTransferAcceleration()
{
// empty output
$output = new OperationOutput();
$result = BucketTransferAcceleration::toGetBucketTransferAcceleration($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$body = '<?xml version="1.0" encoding="UTF-8"?>
<TransferAccelerationConfiguration>
<Enabled>true</Enabled>
</TransferAccelerationConfiguration>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123'],
Utils::streamFor($body)
);
$result = BucketTransferAcceleration::toGetBucketTransferAcceleration($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertTrue($result->transferAccelerationConfiguration->enabled);
$body = '<?xml version="1.0" encoding="UTF-8"?>
<TransferAccelerationConfiguration>
<Enabled>false</Enabled>
</TransferAccelerationConfiguration>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123'],
Utils::streamFor($body)
);
$result = BucketTransferAcceleration::toGetBucketTransferAcceleration($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertFalse($result->transferAccelerationConfiguration->enabled);
}
private function cleanXml($xml): array|string
{
return str_replace("\n", "", str_replace("\r", "", $xml));
}
}

590
vendor/alibabacloud/oss-v2/tests/UnitTests/Transform/BucketWebsiteTest.php vendored Normal file
View File

@@ -0,0 +1,590 @@
<?php
namespace UnitTests\Transform;
use AlibabaCloud\Oss\V2\Models;
use AlibabaCloud\Oss\V2\Transform\BucketWebsite;
use AlibabaCloud\Oss\V2\OperationOutput;
use AlibabaCloud\Oss\V2\Utils;
class BucketWebsiteTest extends \PHPUnit\Framework\TestCase
{
public function testFromPutBucketWebsite()
{
// miss required field
try {
$request = new Models\PutBucketWebsiteRequest();
$input = BucketWebsite::fromPutBucketWebsite($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
try {
$request = new Models\PutBucketWebsiteRequest('bucket-123');
$input = BucketWebsite::fromPutBucketWebsite($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, websiteConfiguration", (string)$e);
}
// demo1
$request = new Models\PutBucketWebsiteRequest('bucket-123');
$request->websiteConfiguration = new Models\WebsiteConfiguration(
new Models\IndexDocument(
suffix: 'index.html', supportSubDir: true, type: 0
),
new Models\ErrorDocument(
key: 'error.html', httpStatus: 404
),
new Models\RoutingRules([
new Models\RoutingRule(
redirect: new Models\RoutingRuleRedirect(
redirectType: 'Mirror',
mirrorURL: 'http://example.com/',
mirrorPassQueryString: true,
mirrorCheckMd5: true,
mirrorFollowRedirect: true,
mirrorHeaders: new Models\MirrorHeaders(
passs: ["myheader-key1", "myheader-key2"],
sets: array(
new Models\MirrorHeaderSet(key: 'myheader-key5', value: 'myheader-value5'),
),
passAll: true,
),
passQueryString: true,
),
ruleNumber: 1,
condition: new Models\RoutingRuleCondition(
keyPrefixEquals: 'abc/',
httpErrorCodeReturnedEquals: 404,
)
),
new Models\RoutingRule(
redirect: new Models\RoutingRuleRedirect(
redirectType: 'AliCDN',
protocol: 'http',
replaceKeyPrefixWith: 'prefix/${key}.suffix',
hostName: 'example.com',
passQueryString: false,
httpRedirectCode: 301
),
ruleNumber: 2,
condition: new Models\RoutingRuleCondition(
keyPrefixEquals: 'abc/',
httpErrorCodeReturnedEquals: 404,
includeHeaders: [
new Models\RoutingRuleIncludeHeader(
key: 'host',
equals: 'test.oss-cn-beijing-internal.aliyuncs.com',
)
]
)
),
new Models\RoutingRule(
redirect: new Models\RoutingRuleRedirect(
redirectType: 'External',
protocol: 'http',
replaceKeyPrefixWith: 'prefix/${key}',
hostName: 'example.com',
passQueryString: false,
enableReplacePrefix: false,
httpRedirectCode: 302,
),
ruleNumber: 3,
condition: new Models\RoutingRuleCondition(
httpErrorCodeReturnedEquals: 404,
)
)
])
);
$input = BucketWebsite::fromPutBucketWebsite($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = '<?xml version="1.0" encoding="UTF-8"?><WebsiteConfiguration><IndexDocument><Suffix>index.html</Suffix><SupportSubDir>true</SupportSubDir><Type>0</Type></IndexDocument><ErrorDocument><Key>error.html</Key><HttpStatus>404</HttpStatus></ErrorDocument><RoutingRules><RoutingRule><Redirect><RedirectType>Mirror</RedirectType><MirrorURL>http://example.com/</MirrorURL><MirrorPassQueryString>true</MirrorPassQueryString><MirrorCheckMd5>true</MirrorCheckMd5><MirrorFollowRedirect>true</MirrorFollowRedirect><MirrorHeaders><Pass>myheader-key1</Pass><Pass>myheader-key2</Pass><Set><Key>myheader-key5</Key><Value>myheader-value5</Value></Set><PassAll>true</PassAll></MirrorHeaders><PassQueryString>true</PassQueryString></Redirect><RuleNumber>1</RuleNumber><Condition><KeyPrefixEquals>abc/</KeyPrefixEquals><HttpErrorCodeReturnedEquals>404</HttpErrorCodeReturnedEquals></Condition></RoutingRule><RoutingRule><Redirect><RedirectType>AliCDN</RedirectType><Protocol>http</Protocol><ReplaceKeyPrefixWith>prefix/${key}.suffix</ReplaceKeyPrefixWith><HostName>example.com</HostName><PassQueryString>false</PassQueryString><HttpRedirectCode>301</HttpRedirectCode></Redirect><RuleNumber>2</RuleNumber><Condition><KeyPrefixEquals>abc/</KeyPrefixEquals><HttpErrorCodeReturnedEquals>404</HttpErrorCodeReturnedEquals><IncludeHeader><Key>host</Key><Equals>test.oss-cn-beijing-internal.aliyuncs.com</Equals></IncludeHeader></Condition></RoutingRule><RoutingRule><Redirect><RedirectType>External</RedirectType><Protocol>http</Protocol><ReplaceKeyPrefixWith>prefix/${key}</ReplaceKeyPrefixWith><HostName>example.com</HostName><PassQueryString>false</PassQueryString><EnableReplacePrefix>false</EnableReplacePrefix><HttpRedirectCode>302</HttpRedirectCode></Redirect><RuleNumber>3</RuleNumber><Condition><HttpErrorCodeReturnedEquals>404</HttpErrorCodeReturnedEquals></Condition></RoutingRule></RoutingRules></WebsiteConfiguration>';
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
// demo2
$request = new Models\PutBucketWebsiteRequest('bucket-123');
$request->websiteConfiguration = new Models\WebsiteConfiguration(
new Models\IndexDocument(
suffix: 'index.html', supportSubDir: true, type: 0
),
new Models\ErrorDocument(
key: 'error.html', httpStatus: 404
),
new Models\RoutingRules([
new Models\RoutingRule(
redirect: new Models\RoutingRuleRedirect(
mirrorPassOriginalSlashes: false,
redirectType: 'Mirror',
mirrorURL: 'http://example.com/',
mirrorPassQueryString: true,
mirrorCheckMd5: true,
mirrorSNI: true,
replaceKeyPrefixWith: "def/",
mirrorFollowRedirect: true,
hostName: "example.com",
mirrorHeaders: new Models\MirrorHeaders(
passs: ["myheader-key1", "myheader-key2"],
sets: array(
new Models\MirrorHeaderSet(key: 'myheader-key5', value: 'myheader-value5'),
),
passAll: true,
),
passQueryString: true,
enableReplacePrefix: true,
httpRedirectCode: 301,
mirrorURLSlave: 'http://example.com/',
mirrorSaveOssMeta: true,
mirrorProxyPass: false,
mirrorAllowGetImageInfo: true,
mirrorAllowVideoSnapshot: false,
mirrorIsExpressTunnel: true,
mirrorDstRegion: 'cn-hangzhou',
mirrorDstVpcId: 'vpc-test-id',
mirrorDstSlaveVpcId: 'vpc-test-id',
mirrorUserLastModified: false,
mirrorSwitchAllErrors: true,
mirrorTunnelId: 'test-tunnel-id',
mirrorUsingRole: false,
mirrorRole: 'aliyun-test-role',
mirrorAllowHeadObject: true,
transparentMirrorResponseCodes: '400',
mirrorAsyncStatus: 303,
mirrorTaggings: new Models\MirrorTaggings(
taggings: [new Models\MirrorTagging(
value: 'v',
key: 'k'
)]
),
mirrorReturnHeaders: new Models\MirrorReturnHeaders(
returnHeaders: [
new Models\ReturnHeader(
key: 'k',
value: 'v'
)
]
),
mirrorAuth: new Models\MirrorAuth(
'S3V4', 'ap-southeast-1', 'TESTAK', 'TESTSK'
),
mirrorMultiAlternates: new Models\MirrorMultiAlternates(
[
new Models\MirrorMultiAlternate(
mirrorMultiAlternateNumber: 32, mirrorMultiAlternateURL: 'https://test-multi-alter.example.com', mirrorMultiAlternateVpcId: 'vpc-test-id', mirrorMultiAlternateDstRegion: 'ap-southeast-1'
)
]
)
),
ruleNumber: 1,
condition: new Models\RoutingRuleCondition(
keyPrefixEquals: 'abc/',
keySuffixEquals: ".txt",
httpErrorCodeReturnedEquals: 404,
),
luaConfig: new Models\RoutingRuleLuaConfig(
script: "test.lua",
)
),
new Models\RoutingRule(
redirect: new Models\RoutingRuleRedirect(
redirectType: 'AliCDN',
mirrorURL: 'http://example.com/',
mirrorPassQueryString: true,
mirrorCheckMd5: true,
mirrorSNI: true,
protocol: 'http',
mirrorFollowRedirect: true,
mirrorHeaders: new Models\MirrorHeaders(
passs: ["myheader-key1", "myheader-key2"],
sets: array(
new Models\MirrorHeaderSet(key: 'myheader-key5', value: 'myheader-value5'),
),
passAll: true,
),
passQueryString: true,
replaceKeyWith: "abc",
),
ruleNumber: 2,
condition: new Models\RoutingRuleCondition(
keyPrefixEquals: 'abc/',
keySuffixEquals: ".txt",
httpErrorCodeReturnedEquals: 404,
),
luaConfig: new Models\RoutingRuleLuaConfig(
script: "test.lua",
)
),
]),
);
$input = BucketWebsite::fromPutBucketWebsite($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><WebsiteConfiguration><IndexDocument><Suffix>index.html</Suffix><SupportSubDir>true</SupportSubDir><Type>0</Type></IndexDocument><ErrorDocument><Key>error.html</Key><HttpStatus>404</HttpStatus></ErrorDocument><RoutingRules><RoutingRule><Redirect><MirrorPassOriginalSlashes>false</MirrorPassOriginalSlashes><RedirectType>Mirror</RedirectType><MirrorURL>http://example.com/</MirrorURL><MirrorPassQueryString>true</MirrorPassQueryString><MirrorCheckMd5>true</MirrorCheckMd5><MirrorSNI>true</MirrorSNI><ReplaceKeyPrefixWith>def/</ReplaceKeyPrefixWith><MirrorFollowRedirect>true</MirrorFollowRedirect><HostName>example.com</HostName><MirrorHeaders><Pass>myheader-key1</Pass><Pass>myheader-key2</Pass><Set><Key>myheader-key5</Key><Value>myheader-value5</Value></Set><PassAll>true</PassAll></MirrorHeaders><PassQueryString>true</PassQueryString><EnableReplacePrefix>true</EnableReplacePrefix><HttpRedirectCode>301</HttpRedirectCode><MirrorURLSlave>http://example.com/</MirrorURLSlave><MirrorSaveOssMeta>true</MirrorSaveOssMeta><MirrorProxyPass>false</MirrorProxyPass><MirrorAllowGetImageInfo>true</MirrorAllowGetImageInfo><MirrorAllowVideoSnapshot>false</MirrorAllowVideoSnapshot><MirrorIsExpressTunnel>true</MirrorIsExpressTunnel><MirrorDstRegion>cn-hangzhou</MirrorDstRegion><MirrorDstVpcId>vpc-test-id</MirrorDstVpcId><MirrorDstSlaveVpcId>vpc-test-id</MirrorDstSlaveVpcId><MirrorUserLastModified>false</MirrorUserLastModified><MirrorSwitchAllErrors>true</MirrorSwitchAllErrors><MirrorTunnelId>test-tunnel-id</MirrorTunnelId><MirrorUsingRole>false</MirrorUsingRole><MirrorRole>aliyun-test-role</MirrorRole><MirrorAllowHeadObject>true</MirrorAllowHeadObject><TransparentMirrorResponseCodes>400</TransparentMirrorResponseCodes><MirrorAsyncStatus>303</MirrorAsyncStatus><MirrorTaggings><Taggings><Value>v</Value><Key>k</Key></Taggings></MirrorTaggings><MirrorReturnHeaders><ReturnHeader><Key>k</Key><Value>v</Value></ReturnHeader></MirrorReturnHeaders><MirrorAuth><AuthType>S3V4</AuthType><Region>ap-southeast-1</Region><AccessKeyId>TESTAK</AccessKeyId><AccessKeySecret>TESTSK</AccessKeySecret></MirrorAuth><MirrorMultiAlternates><MirrorMultiAlternate><MirrorMultiAlternateNumber>32</MirrorMultiAlternateNumber><MirrorMultiAlternateURL>https://test-multi-alter.example.com</MirrorMultiAlternateURL><MirrorMultiAlternateVpcId>vpc-test-id</MirrorMultiAlternateVpcId><MirrorMultiAlternateDstRegion>ap-southeast-1</MirrorMultiAlternateDstRegion></MirrorMultiAlternate></MirrorMultiAlternates></Redirect><RuleNumber>1</RuleNumber><Condition><KeyPrefixEquals>abc/</KeyPrefixEquals><KeySuffixEquals>.txt</KeySuffixEquals><HttpErrorCodeReturnedEquals>404</HttpErrorCodeReturnedEquals></Condition><LuaConfig><Script>test.lua</Script></LuaConfig></RoutingRule><RoutingRule><Redirect><RedirectType>AliCDN</RedirectType><MirrorURL>http://example.com/</MirrorURL><MirrorPassQueryString>true</MirrorPassQueryString><MirrorCheckMd5>true</MirrorCheckMd5><MirrorSNI>true</MirrorSNI><Protocol>http</Protocol><MirrorFollowRedirect>true</MirrorFollowRedirect><MirrorHeaders><Pass>myheader-key1</Pass><Pass>myheader-key2</Pass><Set><Key>myheader-key5</Key><Value>myheader-value5</Value></Set><PassAll>true</PassAll></MirrorHeaders><PassQueryString>true</PassQueryString><ReplaceKeyWith>abc</ReplaceKeyWith></Redirect><RuleNumber>2</RuleNumber><Condition><KeyPrefixEquals>abc/</KeyPrefixEquals><KeySuffixEquals>.txt</KeySuffixEquals><HttpErrorCodeReturnedEquals>404</HttpErrorCodeReturnedEquals></Condition><LuaConfig><Script>test.lua</Script></LuaConfig></RoutingRule></RoutingRules></WebsiteConfiguration>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
$request = new Models\PutBucketWebsiteRequest('bucket-123');
$request->websiteConfiguration = new Models\WebsiteConfiguration(
new Models\IndexDocument(
suffix: 'index.html', supportSubDir: true, type: 0
),
new Models\ErrorDocument(
key: 'error.html', httpStatus: 404
)
);
$input = BucketWebsite::fromPutBucketWebsite($request);
$this->assertEquals('bucket-123', $input->getBucket());
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><WebsiteConfiguration><IndexDocument><Suffix>index.html</Suffix><SupportSubDir>true</SupportSubDir><Type>0</Type></IndexDocument><ErrorDocument><Key>error.html</Key><HttpStatus>404</HttpStatus></ErrorDocument></WebsiteConfiguration>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
}
public function testToPutBucketWebsite()
{
// empty output
$output = new OperationOutput();
$result = BucketWebsite::toPutBucketWebsite($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123']
);
$result = BucketWebsite::toPutBucketWebsite($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
}
public function testFromGetBucketWebsite()
{
// miss required field
try {
$request = new Models\GetBucketWebsiteRequest();
$input = BucketWebsite::fromGetBucketWebsite($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
$request = new Models\GetBucketWebsiteRequest('bucket-123');
$input = BucketWebsite::fromGetBucketWebsite($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
}
public function testToGetBucketWebsite()
{
// empty output
$output = new OperationOutput();
$result = BucketWebsite::toGetBucketWebsite($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$body = '<?xml version="1.0" encoding="UTF-8"?>
<WebsiteConfiguration>
<IndexDocument>
<Suffix>index.html</Suffix>
</IndexDocument>
<ErrorDocument>
<Key>error.html</Key>
<HttpStatus>404</HttpStatus>
</ErrorDocument>
</WebsiteConfiguration>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123'],
Utils::streamFor($body)
);
$result = BucketWebsite::toGetBucketWebsite($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals('index.html', $result->websiteConfiguration->indexDocument->suffix);
$this->assertNull($result->websiteConfiguration->indexDocument->supportSubDir);
$this->assertNull($result->websiteConfiguration->indexDocument->type);
$this->assertEquals('error.html', $result->websiteConfiguration->errorDocument->key);
$this->assertEquals('404', $result->websiteConfiguration->errorDocument->httpStatus);
$body = '<WebsiteConfiguration>
<IndexDocument>
<Suffix>index.html</Suffix>
<SupportSubDir>true</SupportSubDir>
<Type>0</Type>
</IndexDocument>
<ErrorDocument>
<Key>error.html</Key>
<HttpStatus>404</HttpStatus>
</ErrorDocument>
<RoutingRules>
<RoutingRule>
<RuleNumber>1</RuleNumber>
<Condition>
<KeyPrefixEquals>abc/</KeyPrefixEquals>
<HttpErrorCodeReturnedEquals>404</HttpErrorCodeReturnedEquals>
</Condition>
<Redirect>
<RedirectType>Mirror</RedirectType>
<PassQueryString>true</PassQueryString>
<MirrorURL>http://example.com/</MirrorURL>
<MirrorPassQueryString>true</MirrorPassQueryString>
<MirrorFollowRedirect>true</MirrorFollowRedirect>
<MirrorCheckMd5>false</MirrorCheckMd5>
<MirrorHeaders>
<PassAll>true</PassAll>
<Pass>myheader-key1</Pass>
<Pass>myheader-key2</Pass>
<Remove>myheader-key3</Remove>
<Remove>myheader-key4</Remove>
<Set>
<Key>myheader-key5</Key>
<Value>myheader-value5</Value>
</Set>
</MirrorHeaders>
</Redirect>
</RoutingRule>
<RoutingRule>
<RuleNumber>2</RuleNumber>
<Condition>
<KeyPrefixEquals>abc/</KeyPrefixEquals>
<HttpErrorCodeReturnedEquals>404</HttpErrorCodeReturnedEquals>
<IncludeHeader>
<Key>host</Key>
<Equals>test.oss-cn-beijing-internal.aliyuncs.com</Equals>
</IncludeHeader>
</Condition>
<Redirect>
<RedirectType>AliCDN</RedirectType>
<Protocol>http</Protocol>
<HostName>example.com</HostName>
<PassQueryString>false</PassQueryString>
<ReplaceKeyWith>prefix/${key}.suffix</ReplaceKeyWith>
<HttpRedirectCode>301</HttpRedirectCode>
</Redirect>
</RoutingRule>
<RoutingRule>
<Condition>
<HttpErrorCodeReturnedEquals>404</HttpErrorCodeReturnedEquals>
</Condition>
<RuleNumber>3</RuleNumber>
<Redirect>
<ReplaceKeyWith>prefix/${key}</ReplaceKeyWith>
<HttpRedirectCode>302</HttpRedirectCode>
<EnableReplacePrefix>false</EnableReplacePrefix>
<PassQueryString>false</PassQueryString>
<Protocol>http</Protocol>
<HostName>example.com</HostName>
<RedirectType>External</RedirectType>
</Redirect>
</RoutingRule>
</RoutingRules>
</WebsiteConfiguration>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123'],
Utils::streamFor($body)
);
$result = BucketWebsite::toGetBucketWebsite($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals('index.html', $result->websiteConfiguration->indexDocument->suffix);
$this->assertTrue($result->websiteConfiguration->indexDocument->supportSubDir);
$this->assertEquals(0, $result->websiteConfiguration->indexDocument->type);
$this->assertEquals('error.html', $result->websiteConfiguration->errorDocument->key);
$this->assertEquals('404', $result->websiteConfiguration->errorDocument->httpStatus);
$this->assertEquals(3, count($result->websiteConfiguration->routingRules->routingRules));
$this->assertEquals(1, $result->websiteConfiguration->routingRules->routingRules[0]->ruleNumber);
$this->assertEquals('abc/', $result->websiteConfiguration->routingRules->routingRules[0]->condition->keyPrefixEquals);
$this->assertEquals(404, $result->websiteConfiguration->routingRules->routingRules[0]->condition->httpErrorCodeReturnedEquals);
$this->assertEquals('Mirror', $result->websiteConfiguration->routingRules->routingRules[0]->redirect->redirectType);
$this->assertTrue($result->websiteConfiguration->routingRules->routingRules[0]->redirect->passQueryString);
$this->assertEquals('http://example.com/', $result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorURL);
$this->assertTrue($result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorPassQueryString);
$this->assertTrue($result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorFollowRedirect);
$this->assertFalse($result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorCheckMd5);
$this->assertTrue($result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorHeaders->passAll);
$this->assertEquals('myheader-key1', $result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorHeaders->passs[0]);
$this->assertEquals('myheader-key2', $result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorHeaders->passs[1]);
$this->assertEquals('myheader-key3', $result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorHeaders->removes[0]);
$this->assertEquals('myheader-key4', $result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorHeaders->removes[1]);
$this->assertEquals('myheader-key5', $result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorHeaders->sets[0]->key);
$this->assertEquals('myheader-value5', $result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorHeaders->sets[0]->value);
$this->assertEquals(2, $result->websiteConfiguration->routingRules->routingRules[1]->ruleNumber);
$this->assertEquals('abc/', $result->websiteConfiguration->routingRules->routingRules[1]->condition->keyPrefixEquals);
$this->assertEquals(404, $result->websiteConfiguration->routingRules->routingRules[1]->condition->httpErrorCodeReturnedEquals);
$this->assertEquals('host', $result->websiteConfiguration->routingRules->routingRules[1]->condition->includeHeaders[0]->key);
$this->assertEquals('test.oss-cn-beijing-internal.aliyuncs.com', $result->websiteConfiguration->routingRules->routingRules[1]->condition->includeHeaders[0]->equals);
$this->assertEquals('AliCDN', $result->websiteConfiguration->routingRules->routingRules[1]->redirect->redirectType);
$this->assertEquals('http', $result->websiteConfiguration->routingRules->routingRules[1]->redirect->protocol);
$this->assertFalse($result->websiteConfiguration->routingRules->routingRules[1]->redirect->passQueryString);
$this->assertEquals('prefix/${key}.suffix', $result->websiteConfiguration->routingRules->routingRules[1]->redirect->replaceKeyWith);
$this->assertEquals(301, $result->websiteConfiguration->routingRules->routingRules[1]->redirect->httpRedirectCode);
$this->assertEquals(3, $result->websiteConfiguration->routingRules->routingRules[2]->ruleNumber);
$this->assertEquals('External', $result->websiteConfiguration->routingRules->routingRules[2]->redirect->redirectType);
$this->assertFalse($result->websiteConfiguration->routingRules->routingRules[2]->redirect->passQueryString);
$this->assertEquals('prefix/${key}', $result->websiteConfiguration->routingRules->routingRules[2]->redirect->replaceKeyWith);
$this->assertEquals(302, $result->websiteConfiguration->routingRules->routingRules[2]->redirect->httpRedirectCode);
$this->assertFalse($result->websiteConfiguration->routingRules->routingRules[2]->redirect->enableReplacePrefix);
$this->assertEquals('http', $result->websiteConfiguration->routingRules->routingRules[2]->redirect->protocol);
$this->assertEquals('example.com', $result->websiteConfiguration->routingRules->routingRules[2]->redirect->hostName);
$body = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><WebsiteConfiguration><IndexDocument><Suffix>index.html</Suffix><SupportSubDir>true</SupportSubDir><Type>0</Type></IndexDocument><ErrorDocument><Key>error.html</Key><HttpStatus>404</HttpStatus></ErrorDocument><RoutingRules><RoutingRule><Redirect><MirrorPassOriginalSlashes>false</MirrorPassOriginalSlashes><RedirectType>Mirror</RedirectType><MirrorURL>http://example.com/</MirrorURL><MirrorPassQueryString>true</MirrorPassQueryString><MirrorCheckMd5>true</MirrorCheckMd5><MirrorSNI>true</MirrorSNI><ReplaceKeyPrefixWith>def/</ReplaceKeyPrefixWith><MirrorFollowRedirect>true</MirrorFollowRedirect><HostName>example.com</HostName><MirrorHeaders><Pass>myheader-key1</Pass><Pass>myheader-key2</Pass><Set><Key>myheader-key5</Key><Value>myheader-value5</Value></Set><PassAll>true</PassAll></MirrorHeaders><PassQueryString>true</PassQueryString><EnableReplacePrefix>true</EnableReplacePrefix><HttpRedirectCode>301</HttpRedirectCode><MirrorURLSlave>http://example.com/</MirrorURLSlave><MirrorSaveOssMeta>true</MirrorSaveOssMeta><MirrorProxyPass>false</MirrorProxyPass><MirrorAllowGetImageInfo>true</MirrorAllowGetImageInfo><MirrorAllowVideoSnapshot>false</MirrorAllowVideoSnapshot><MirrorIsExpressTunnel>true</MirrorIsExpressTunnel><MirrorDstRegion>cn-hangzhou</MirrorDstRegion><MirrorDstVpcId>vpc-test-id</MirrorDstVpcId><MirrorDstSlaveVpcId>vpc-test-id</MirrorDstSlaveVpcId><MirrorUserLastModified>false</MirrorUserLastModified><MirrorSwitchAllErrors>true</MirrorSwitchAllErrors><MirrorTunnelId>test-tunnel-id</MirrorTunnelId><MirrorUsingRole>false</MirrorUsingRole><MirrorRole>aliyun-test-role</MirrorRole><MirrorAllowHeadObject>true</MirrorAllowHeadObject><TransparentMirrorResponseCodes>400</TransparentMirrorResponseCodes><MirrorAsyncStatus>303</MirrorAsyncStatus><MirrorTaggings><Taggings><Value>v</Value><Key>k</Key></Taggings></MirrorTaggings><MirrorReturnHeaders><ReturnHeader><Key>k</Key><Value>v</Value></ReturnHeader></MirrorReturnHeaders><MirrorAuth><AuthType>S3V4</AuthType><Region>ap-southeast-1</Region><AccessKeyId>TESTAK</AccessKeyId><AccessKeySecret>TESTSK</AccessKeySecret></MirrorAuth><MirrorMultiAlternates><MirrorMultiAlternate><MirrorMultiAlternateNumber>32</MirrorMultiAlternateNumber><MirrorMultiAlternateURL>https://test-multi-alter.example.com</MirrorMultiAlternateURL><MirrorMultiAlternateVpcId>vpc-test-id</MirrorMultiAlternateVpcId><MirrorMultiAlternateDstRegion>ap-southeast-1</MirrorMultiAlternateDstRegion></MirrorMultiAlternate></MirrorMultiAlternates></Redirect><RuleNumber>1</RuleNumber><Condition><KeyPrefixEquals>abc/</KeyPrefixEquals><KeySuffixEquals>.txt</KeySuffixEquals><HttpErrorCodeReturnedEquals>404</HttpErrorCodeReturnedEquals></Condition><LuaConfig><Script>test.lua</Script></LuaConfig></RoutingRule><RoutingRule><Redirect><RedirectType>AliCDN</RedirectType><MirrorURL>http://example.com/</MirrorURL><MirrorPassQueryString>true</MirrorPassQueryString><MirrorCheckMd5>true</MirrorCheckMd5><MirrorSNI>true</MirrorSNI><Protocol>http</Protocol><MirrorFollowRedirect>true</MirrorFollowRedirect><MirrorHeaders><Pass>myheader-key1</Pass><Pass>myheader-key2</Pass><Set><Key>myheader-key5</Key><Value>myheader-value5</Value></Set><PassAll>true</PassAll></MirrorHeaders><PassQueryString>true</PassQueryString><ReplaceKeyWith>abc</ReplaceKeyWith></Redirect><RuleNumber>2</RuleNumber><Condition><KeyPrefixEquals>abc/</KeyPrefixEquals><KeySuffixEquals>.txt</KeySuffixEquals><HttpErrorCodeReturnedEquals>404</HttpErrorCodeReturnedEquals></Condition><LuaConfig><Script>test.lua</Script></LuaConfig></RoutingRule></RoutingRules></WebsiteConfiguration>
BBB;
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123'],
Utils::streamFor($body)
);
$result = BucketWebsite::toGetBucketWebsite($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals('index.html', $result->websiteConfiguration->indexDocument->suffix);
$this->assertTrue($result->websiteConfiguration->indexDocument->supportSubDir);
$this->assertEquals(0, $result->websiteConfiguration->indexDocument->type);
$this->assertEquals('error.html', $result->websiteConfiguration->errorDocument->key);
$this->assertEquals('404', $result->websiteConfiguration->errorDocument->httpStatus);
$this->assertEquals(2, count($result->websiteConfiguration->routingRules->routingRules));
$this->assertEquals(1, $result->websiteConfiguration->routingRules->routingRules[0]->ruleNumber);
$this->assertEquals('abc/', $result->websiteConfiguration->routingRules->routingRules[0]->condition->keyPrefixEquals);
$this->assertEquals('.txt', $result->websiteConfiguration->routingRules->routingRules[0]->condition->keySuffixEquals);
$this->assertEquals(404, $result->websiteConfiguration->routingRules->routingRules[0]->condition->httpErrorCodeReturnedEquals);
$this->assertEquals('Mirror', $result->websiteConfiguration->routingRules->routingRules[0]->redirect->redirectType);
$this->assertFalse($result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorPassOriginalSlashes);
$this->assertEquals('http://example.com/', $result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorURL);
$this->assertTrue($result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorPassQueryString);
$this->assertTrue($result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorCheckMd5);
$this->assertTrue($result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorSNI);
$this->assertEquals('def/', $result->websiteConfiguration->routingRules->routingRules[0]->redirect->replaceKeyPrefixWith);
$this->assertEquals('example.com', $result->websiteConfiguration->routingRules->routingRules[0]->redirect->hostName);
$this->assertEquals('myheader-key1', $result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorHeaders->passs[0]);
$this->assertEquals('myheader-key2', $result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorHeaders->passs[1]);
$this->assertEquals('myheader-key5', $result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorHeaders->sets[0]->key);
$this->assertEquals('myheader-value5', $result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorHeaders->sets[0]->value);
$this->assertTrue($result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorHeaders->passAll);
$this->assertTrue($result->websiteConfiguration->routingRules->routingRules[0]->redirect->passQueryString);
$this->assertTrue($result->websiteConfiguration->routingRules->routingRules[0]->redirect->enableReplacePrefix);
$this->assertEquals(301, $result->websiteConfiguration->routingRules->routingRules[0]->redirect->httpRedirectCode);
$this->assertEquals('http://example.com/', $result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorURLSlave);
$this->assertTrue($result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorSaveOssMeta);
$this->assertFalse($result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorProxyPass);
$this->assertTrue($result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorAllowGetImageInfo);
$this->assertFalse($result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorAllowVideoSnapshot);
$this->assertTrue($result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorIsExpressTunnel);
$this->assertEquals('cn-hangzhou', $result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorDstRegion);
$this->assertEquals('vpc-test-id', $result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorDstVpcId);
$this->assertEquals('vpc-test-id', $result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorDstSlaveVpcId);
$this->assertFalse($result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorUserLastModified);
$this->assertTrue($result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorSwitchAllErrors);
$this->assertEquals('test-tunnel-id', $result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorTunnelId);
$this->assertFalse($result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorUsingRole);
$this->assertEquals('aliyun-test-role', $result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorRole);
$this->assertTrue($result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorAllowHeadObject);
$this->assertEquals("400", $result->websiteConfiguration->routingRules->routingRules[0]->redirect->transparentMirrorResponseCodes);
$this->assertEquals(303, $result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorAsyncStatus);
$this->assertEquals('k', $result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorTaggings->taggings[0]->key);
$this->assertEquals('v', $result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorTaggings->taggings[0]->value);
$this->assertEquals('k', $result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorReturnHeaders->returnHeaders[0]->key);
$this->assertEquals('v', $result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorReturnHeaders->returnHeaders[0]->value);
$this->assertEquals('S3V4', $result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorAuth->authType);
$this->assertEquals('ap-southeast-1', $result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorAuth->region);
$this->assertEquals('TESTAK', $result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorAuth->accessKeyId);
$this->assertEquals('TESTSK', $result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorAuth->accessKeySecret);
$this->assertEquals(32, $result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorMultiAlternates->mirrorMultiAlternates[0]->mirrorMultiAlternateNumber);
$this->assertEquals('https://test-multi-alter.example.com', $result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorMultiAlternates->mirrorMultiAlternates[0]->mirrorMultiAlternateURL);
$this->assertEquals('vpc-test-id', $result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorMultiAlternates->mirrorMultiAlternates[0]->mirrorMultiAlternateVpcId);
$this->assertEquals('ap-southeast-1', $result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorMultiAlternates->mirrorMultiAlternates[0]->mirrorMultiAlternateDstRegion);
$this->assertEquals('test.lua', $result->websiteConfiguration->routingRules->routingRules[0]->luaConfig->script);
$this->assertEquals(2, $result->websiteConfiguration->routingRules->routingRules[1]->ruleNumber);
$this->assertEquals('abc/', $result->websiteConfiguration->routingRules->routingRules[1]->condition->keyPrefixEquals);
$this->assertEquals('.txt', $result->websiteConfiguration->routingRules->routingRules[1]->condition->keySuffixEquals);
$this->assertEquals(404, $result->websiteConfiguration->routingRules->routingRules[1]->condition->httpErrorCodeReturnedEquals);
$this->assertEquals('AliCDN', $result->websiteConfiguration->routingRules->routingRules[1]->redirect->redirectType);
$this->assertEquals('http', $result->websiteConfiguration->routingRules->routingRules[1]->redirect->protocol);
$this->assertEquals('test.lua', $result->websiteConfiguration->routingRules->routingRules[0]->luaConfig->script);
$this->assertEquals('http://example.com/', $result->websiteConfiguration->routingRules->routingRules[0]->redirect->mirrorURL);
$this->assertTrue($result->websiteConfiguration->routingRules->routingRules[1]->redirect->mirrorPassQueryString);
$this->assertTrue($result->websiteConfiguration->routingRules->routingRules[1]->redirect->mirrorCheckMd5);
$this->assertTrue($result->websiteConfiguration->routingRules->routingRules[1]->redirect->mirrorSNI);
$this->assertEquals('myheader-key1', $result->websiteConfiguration->routingRules->routingRules[1]->redirect->mirrorHeaders->passs[0]);
$this->assertEquals('myheader-key2', $result->websiteConfiguration->routingRules->routingRules[1]->redirect->mirrorHeaders->passs[1]);
$this->assertEquals('myheader-key5', $result->websiteConfiguration->routingRules->routingRules[1]->redirect->mirrorHeaders->sets[0]->key);
$this->assertEquals('myheader-value5', $result->websiteConfiguration->routingRules->routingRules[1]->redirect->mirrorHeaders->sets[0]->value);
$this->assertTrue($result->websiteConfiguration->routingRules->routingRules[1]->redirect->mirrorHeaders->passAll);
}
public function testFromDeleteBucketWebsite()
{
// miss required field
try {
$request = new Models\DeleteBucketWebsiteRequest();
$input = BucketWebsite::fromDeleteBucketWebsite($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
$request = new Models\DeleteBucketWebsiteRequest('bucket-123');
$input = BucketWebsite::fromDeleteBucketWebsite($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
}
public function testToDeleteBucketWebsite()
{
// empty output
$output = new OperationOutput();
$result = BucketWebsite::toDeleteBucketWebsite($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'No Content',
204,
['x-oss-request-id' => '123']
);
$result = BucketWebsite::toDeleteBucketWebsite($output);
$this->assertEquals('No Content', $result->status);
$this->assertEquals(204, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
}
private function cleanXml($xml): array|string
{
return str_replace("\n", "", str_replace("\r", "", $xml));
}
}

276
vendor/alibabacloud/oss-v2/tests/UnitTests/Transform/BucketWormTest.php vendored Normal file
View File

@@ -0,0 +1,276 @@
<?php
namespace UnitTests\Transform;
use AlibabaCloud\Oss\V2\Models;
use AlibabaCloud\Oss\V2\Transform\BucketWorm;
use AlibabaCloud\Oss\V2\OperationOutput;
use AlibabaCloud\Oss\V2\Utils;
class BucketWormTest extends \PHPUnit\Framework\TestCase
{
public function testFromInitiateBucketWorm()
{
// miss required field
try {
$request = new Models\InitiateBucketWormRequest();
$input = BucketWorm::fromInitiateBucketWorm($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
try {
$request = new Models\InitiateBucketWormRequest('bucket-123');
$input = BucketWorm::fromInitiateBucketWorm($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, initiateWormConfiguration", (string)$e);
}
// all settings
$request = new Models\InitiateBucketWormRequest(
bucket: 'bucket-123',
initiateWormConfiguration: new Models\InitiateWormConfiguration(retentionPeriodInDays: 3)
);
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><InitiateWormConfiguration><RetentionPeriodInDays>3</RetentionPeriodInDays></InitiateWormConfiguration>
BBB;
$input = BucketWorm::fromInitiateBucketWorm($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
$this->assertEquals('application/xml', $input->getHeaders()['content-type']);
$this->assertEquals(base64_encode(md5($input->getBody(), true)), $input->getHeaders()['content-md5']);
}
public function testToInitiateBucketWorm()
{
// empty output
$output = new OperationOutput();
$result = BucketWorm::toInitiateBucketWorm($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123', 'x-oss-worm-id' => '234']
);
$result = BucketWorm::toInitiateBucketWorm($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals('234', $result->wormId);
$this->assertEquals(2, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
}
public function testFromAbortBucketWorm()
{
// miss required field
try {
$request = new Models\AbortBucketWormRequest();
$input = BucketWorm::fromAbortBucketWorm($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
$request = new Models\AbortBucketWormRequest('bucket-123');
$input = BucketWorm::fromAbortBucketWorm($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
}
public function testToAbortBucketWorm()
{
// empty output
$output = new OperationOutput();
$result = BucketWorm::toAbortBucketWorm($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'No Content',
204,
['x-oss-request-id' => '123']
);
$result = BucketWorm::toAbortBucketWorm($output);
$this->assertEquals('No Content', $result->status);
$this->assertEquals(204, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
}
public function testFromCompleteBucketWorm()
{
// miss required field
try {
$request = new Models\CompleteBucketWormRequest();
$input = BucketWorm::fromCompleteBucketWorm($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
try {
$request = new Models\CompleteBucketWormRequest('bucket-123');
$input = BucketWorm::fromCompleteBucketWorm($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, wormId", (string)$e);
}
$request = new Models\CompleteBucketWormRequest('bucket-123', 'wormId-123');
$input = BucketWorm::fromCompleteBucketWorm($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('wormId-123', $input->getParameters()['wormId']);
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
}
public function testToCompleteBucketWorm()
{
// empty output
$output = new OperationOutput();
$result = BucketWorm::toCompleteBucketWorm($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123']
);
$result = BucketWorm::toCompleteBucketWorm($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
}
public function testFromExtendBucketWorm()
{
// miss required field
try {
$request = new Models\ExtendBucketWormRequest();
$input = BucketWorm::fromExtendBucketWorm($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
try {
$request = new Models\ExtendBucketWormRequest('bucket-123');
$input = BucketWorm::fromExtendBucketWorm($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, wormId", (string)$e);
}
try {
$request = new Models\ExtendBucketWormRequest('bucket-123', 'wormId-123');
$input = BucketWorm::fromExtendBucketWorm($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString($e->getMessage(), "missing required field, extendWormConfiguration.", (string)$e);
}
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><ExtendWormConfiguration><RetentionPeriodInDays>3</RetentionPeriodInDays></ExtendWormConfiguration>
BBB;
$request = new Models\ExtendBucketWormRequest('bucket-123', 'wormId-123', new Models\ExtendWormConfiguration(3));
$input = BucketWorm::fromExtendBucketWorm($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('wormId-123', $input->getParameters()['wormId']);
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
$this->assertEquals(base64_encode(md5($input->getBody(), true)), $input->getHeaders()['content-md5']);
}
public function testToExtendBucketWorm()
{
// empty output
$output = new OperationOutput();
$result = BucketWorm::toExtendBucketWorm($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123']
);
$result = BucketWorm::toCompleteBucketWorm($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
}
public function testFromGetBucketWorm()
{
// miss required field
try {
$request = new Models\GetBucketWormRequest();
$input = BucketWorm::fromGetBucketWorm($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, bucket", (string)$e);
}
$request = new Models\GetBucketWormRequest('bucket-123');
$input = BucketWorm::fromGetBucketWorm($request);
$this->assertEquals('bucket-123', $input->getBucket());
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
}
public function testToGetBucketWorm()
{
// empty output
$output = new OperationOutput();
$result = BucketWorm::toGetBucketWorm($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123', 'content-type' => 'application/xml'],
Utils::streamFor('<WormConfiguration>
<WormId>1666E2CFB2B3418****</WormId>
<State>Locked</State>
<RetentionPeriodInDays>1</RetentionPeriodInDays>
<CreationDate>2020-10-15T15:50:32</CreationDate>
</WormConfiguration>')
);
$result = BucketWorm::toGetBucketWorm($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertCount(2, $result->headers);
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals('application/xml', $result->headers['content-type']);
$this->assertEquals('1666E2CFB2B3418****', $result->wormConfiguration->wormId);
$this->assertEquals('Locked', $result->wormConfiguration->state);
$this->assertEquals(1, $result->wormConfiguration->retentionPeriodInDays);
$this->assertEquals("2020-10-15T15:50:32", $result->wormConfiguration->creationDate);
}
private function cleanXml($xml): array|string
{
return str_replace("\n", "", str_replace("\r", "", $xml));
}
}

85
vendor/alibabacloud/oss-v2/tests/UnitTests/Transform/CloudBoxesTest.php vendored Normal file
View File

@@ -0,0 +1,85 @@
<?php
namespace UnitTests\Transform;
use AlibabaCloud\Oss\V2\Models;
use AlibabaCloud\Oss\V2\Transform\CloudBoxes;
use AlibabaCloud\Oss\V2\OperationOutput;
use AlibabaCloud\Oss\V2\Utils;
class CloudBoxesTest extends \PHPUnit\Framework\TestCase
{
public function testFromListCloudBoxes()
{
$request = new Models\ListCloudBoxesRequest();
$input = CloudBoxes::fromListCloudBoxes($request);
$request = new Models\ListCloudBoxesRequest(marker: '', maxKeys: 10, prefix: '/');
$input = CloudBoxes::fromListCloudBoxes($request);
$this->assertEquals('', $input->getParameters()['cloudboxes']);
$this->assertEquals('', $input->getParameters()['marker']);
$this->assertEquals('10', $input->getParameters()['max-keys']);
$this->assertEquals('/', $input->getParameters()['prefix']);
}
public function testToListCloudBoxes()
{
// empty output
$output = new OperationOutput();
$result = CloudBoxes::toListCloudBoxes($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$body = '<?xml version="1.0" encoding="UTF-8"?>
<ListCloudBoxResult>
<Owner>
<ID>51264</ID>
<DisplayName>51264</DisplayName>
</Owner>
<CloudBoxes>
<CloudBox>
<ID>cb-f8z7yvzgwfkl9q0h****</ID>
<Name>bucket1</Name>
<Region>cn-shanghai</Region>
<ControlEndpoint>cb-f8z7yvzgwfkl9q0h****.cn-shanghai.oss-cloudbox-control.aliyuncs.com</ControlEndpoint>
<DataEndpoint>cb-f8z7yvzgwfkl9q0h****.cn-shanghai.oss-cloudbox.aliyuncs.com</DataEndpoint>
</CloudBox>
<CloudBox>
<ID>cb-f9z7yvzgwfkl9q0h****</ID>
<Name>bucket2</Name>
<Region>cn-hangzhou</Region>
<ControlEndpoint>cb-f9z7yvzgwfkl9q0h****.cn-hangzhou.oss-cloudbox-control.aliyuncs.com</ControlEndpoint>
<DataEndpoint>cb-f9z7yvzgwfkl9q0h****.cn-hangzhou.oss-cloudbox.aliyuncs.com</DataEndpoint>
</CloudBox>
</CloudBoxes>
</ListCloudBoxResult>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123', 'content-type' => 'application/xml'],
body: Utils::streamFor($body)
);
$result = CloudBoxes::toListCloudBoxes($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(2, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertEquals('application/xml', $result->headers['content-type']);
$this->assertEquals('51264', $result->listCloudBoxes->owner->id);
$this->assertEquals('51264', $result->listCloudBoxes->owner->displayName);
$this->assertEquals(2, count($result->listCloudBoxes->cloudBoxes->cloudBox));
$this->assertEquals('cb-f8z7yvzgwfkl9q0h****', $result->listCloudBoxes->cloudBoxes->cloudBox[0]->id);
$this->assertEquals('cb-f8z7yvzgwfkl9q0h****.cn-shanghai.oss-cloudbox.aliyuncs.com', $result->listCloudBoxes->cloudBoxes->cloudBox[0]->dataEndpoint);
$this->assertEquals('cb-f8z7yvzgwfkl9q0h****.cn-shanghai.oss-cloudbox-control.aliyuncs.com', $result->listCloudBoxes->cloudBoxes->cloudBox[0]->controlEndpoint);
$this->assertEquals('bucket1', $result->listCloudBoxes->cloudBoxes->cloudBox[0]->name);
$this->assertEquals('cn-shanghai', $result->listCloudBoxes->cloudBoxes->cloudBox[0]->region);
$this->assertEquals('cb-f9z7yvzgwfkl9q0h****', $result->listCloudBoxes->cloudBoxes->cloudBox[1]->id);
$this->assertEquals('cb-f9z7yvzgwfkl9q0h****.cn-hangzhou.oss-cloudbox.aliyuncs.com', $result->listCloudBoxes->cloudBoxes->cloudBox[1]->dataEndpoint);
$this->assertEquals('cb-f9z7yvzgwfkl9q0h****.cn-hangzhou.oss-cloudbox-control.aliyuncs.com', $result->listCloudBoxes->cloudBoxes->cloudBox[1]->controlEndpoint);
$this->assertEquals('bucket2', $result->listCloudBoxes->cloudBoxes->cloudBox[1]->name);
$this->assertEquals('cn-hangzhou', $result->listCloudBoxes->cloudBoxes->cloudBox[1]->region);
}
}

105
vendor/alibabacloud/oss-v2/tests/UnitTests/Transform/FunctionsTest.php vendored Normal file
View File

@@ -0,0 +1,105 @@
<?php
namespace UnitTests\Transform;
use AlibabaCloud\Oss\V2\Transform\Functions;
use AlibabaCloud\Oss\V2\Exception;
class FunctionsTest extends \PHPUnit\Framework\TestCase
{
public function testAssertFieldRequired()
{
try {
Functions::assertFieldRequired('field', null);
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString('missing required field, field', $e);
}
Functions::assertFieldRequired('field', 'hello world');
}
public function testAssertXmlRoot()
{
try {
Functions::assertXmlRoot('', '');
} catch (Exception\DeserializationExecption $e) {
$this->assertStringContainsString('Not found tag', $e);
}
try {
Functions::assertXmlRoot('<Root></Root>', '');
} catch (Exception\DeserializationExecption $e) {
$this->assertStringContainsString('Not found tag', $e);
}
try {
Functions::assertXmlRoot('<Root></Root>', '123');
} catch (Exception\DeserializationExecption $e) {
$this->assertStringContainsString('Not found tag', $e);
}
Functions::assertXmlRoot('<Root></Root>', 'Root');
Functions::assertXmlRoot('<Root xmlns="http://doc.oss-cn-hangzhou.aliyuncs.com"></Root>', 'Root');
Functions::assertXmlRoot('<Root any char></Root>', 'Root');
$str = '<?xml version="1.0" encoding="UTF-8"?>
<RootConfiguration>
<Id>str1</Id>
<Text>str2</Text>
<SubConfiguration>
<StrField>str-sub</StrField>
<IntField>1234</IntField>
</SubConfiguration>
</RootConfiguration>';
try {
Functions::assertXmlRoot($str, 'Configuration');
$this->assertTrue(false, 'should not here');
} catch (Exception\DeserializationExecption $e) {
$this->assertStringContainsString('Not found tag', $e);
}
}
public function testtryToDatetime()
{
$elem = new \SimpleXMLElement('<Root><Data>2023-12-17T03:30:09Z</Data><Data1>invalid value</Data1></Root>');
$this->assertNull(Functions::tryToDatetime($elem->NoNode));
$this->assertNull(Functions::tryToDatetime($elem->Data1));
$datetimeUtc = new \DateTime();
$datetimeUtc->setTimestamp(1702783809);
$this->assertEquals($datetimeUtc, Functions::tryToDatetime($elem->Data));
}
public function testtryToBool()
{
$elem = new \SimpleXMLElement('<Root><Data>True</Data><Data1>true</Data1><Data2>false</Data2><DataEmpty></DataEmpty></Root>');
$this->assertNull(Functions::tryToBool($elem->NoNode));
$this->assertEquals(true, Functions::tryToBool($elem->Data));
$this->assertEquals(true, Functions::tryToBool($elem->Data1));
$this->assertEquals(false, Functions::tryToBool($elem->Data2));
$this->assertNotNull(Functions::tryToBool($elem->DataEmpty));
$this->assertEquals(false, Functions::tryToBool($elem->DataEmpty));
}
public function testtryToInt()
{
$elem = new \SimpleXMLElement('<Root><Data>123</Data><Data1>0</Data1><Data2>invalid value</Data2><DataEmpty></DataEmpty></Root>');
$this->assertNull(Functions::tryToInt($elem->NoNode));
$this->assertEquals(123, Functions::tryToInt($elem->Data));
$this->assertEquals(0, Functions::tryToInt($elem->Data1));
$this->assertEquals(0, Functions::tryToInt($elem->Data2));
$this->assertNotNull(Functions::tryToInt($elem->DataEmpty));
$this->assertEquals(0, Functions::tryToInt($elem->DataEmpty));
}
public function testtryToString()
{
$elem = new \SimpleXMLElement('<Root><Data>123</Data><Data1>0</Data1><Data2></Data2></Root>');
$this->assertNull(Functions::tryToString($elem->NoNode));
$this->assertEquals('123', Functions::tryToString($elem->Data));
$this->assertEquals('0', Functions::tryToString($elem->Data1));
$this->assertNotNull(Functions::tryToString($elem->Data2));
$this->assertEquals('', Functions::tryToString($elem->Data2));
}
}

2903
vendor/alibabacloud/oss-v2/tests/UnitTests/Transform/ObjectBasicTest.php vendored Normal file
View File

File diff suppressed because it is too large Load Diff

1121
vendor/alibabacloud/oss-v2/tests/UnitTests/Transform/ObjectMultipartTest.php vendored Normal file
View File

File diff suppressed because it is too large Load Diff

127
vendor/alibabacloud/oss-v2/tests/UnitTests/Transform/PublicAccessBlockTest.php vendored Normal file
View File

@@ -0,0 +1,127 @@
<?php
namespace UnitTests\Transform;
use AlibabaCloud\Oss\V2\Models;
use AlibabaCloud\Oss\V2\Transform\PublicAccessBlock;
use AlibabaCloud\Oss\V2\OperationOutput;
use AlibabaCloud\Oss\V2\Utils;
class PublicAccessBlockTest extends \PHPUnit\Framework\TestCase
{
public function testFromPutPublicAccessBlock()
{
// miss required field
try {
$request = new Models\PutPublicAccessBlockRequest();
$input = PublicAccessBlock::fromPutPublicAccessBlock($request);
$this->assertTrue(false, "should not here");
} catch (\InvalidArgumentException $e) {
$this->assertStringContainsString("missing required field, publicAccessBlockConfiguration", (string)$e);
}
// demo1
$request = new Models\PutPublicAccessBlockRequest(new Models\PublicAccessBlockConfiguration(
true
));
$input = PublicAccessBlock::fromPutPublicAccessBlock($request);
$xml = <<<BBB
<?xml version="1.0" encoding="UTF-8"?><PublicAccessBlockConfiguration><BlockPublicAccess>true</BlockPublicAccess></PublicAccessBlockConfiguration>
BBB;
$this->assertEquals($xml, $this->cleanXml($input->getBody()->getContents()));
}
public function testToPutPublicAccessBlock()
{
// empty output
$output = new OperationOutput();
$result = PublicAccessBlock::toPutPublicAccessBlock($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123']
);
$result = PublicAccessBlock::toPutPublicAccessBlock($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
}
public function testFromGetPublicAccessBlock()
{
$request = new Models\GetPublicAccessBlockRequest();
$input = PublicAccessBlock::fromGetPublicAccessBlock($request);
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
}
public function testToGetPublicAccessBlock()
{
// empty output
$output = new OperationOutput();
$result = PublicAccessBlock::toGetPublicAccessBlock($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$body = '<?xml version="1.0" encoding="UTF-8"?>
<PublicAccessBlockConfiguration>
<BlockPublicAccess>true</BlockPublicAccess>
</PublicAccessBlockConfiguration>';
$output = new OperationOutput(
'OK',
200,
['x-oss-request-id' => '123'],
Utils::streamFor($body)
);
$result = PublicAccessBlock::toGetPublicAccessBlock($output);
$this->assertEquals('OK', $result->status);
$this->assertEquals(200, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
$this->assertTrue($result->publicAccessBlockConfiguration->blockPublicAccess);
}
public function testFromDeletePublicAccessBlock()
{
$request = new Models\DeletePublicAccessBlockRequest();
$input = PublicAccessBlock::fromDeletePublicAccessBlock($request);
$this->assertEquals('1B2M2Y8AsgTpgAmY7PhCfg==', $input->getHeaders()['content-md5']);
}
public function testToDeletePublicAccessBlock()
{
// empty output
$output = new OperationOutput();
$result = PublicAccessBlock::toDeletePublicAccessBlock($output);
$this->assertEquals('', $result->status);
$this->assertEquals(0, $result->statusCode);
$this->assertEquals('', $result->requestId);
$this->assertEquals(0, count($result->headers));
$output = new OperationOutput(
'No Content',
204,
['x-oss-request-id' => '123']
);
$result = PublicAccessBlock::toDeletePublicAccessBlock($output);
$this->assertEquals('No Content', $result->status);
$this->assertEquals(204, $result->statusCode);
$this->assertEquals('123', $result->requestId);
$this->assertEquals(1, count($result->headers));
$this->assertEquals('123', $result->headers['x-oss-request-id']);
}
private function cleanXml($xml): array|string
{
return str_replace("\n", "", str_replace("\r", "", $xml));
}
}