CLDSRV-759: bucketGetRateLimit

tests/functional/aws-node-sdk/test/bucket/getBucketRateLimit.js

@@ -0,0 +1,60 @@
+const AWS = require('aws-sdk');
+const S3 = AWS.S3;
+const assert = require('assert');
+const getConfig = require('../support/config');
+const { sendRateLimitRequest, skipIfRateLimitDisabled } = require('../rateLimit/tooling');
+
+const bucket = 'getratelimitestbucket';
+const rateLimitConfig = { RequestsPerSecond: 100 };
+
+skipIfRateLimitDisabled('Test get bucket rate limit', () => {
+    let s3;
+
+    before(() => {
+        const config = getConfig('lisa', { signatureVersion: 'v4' });
+        s3 = new S3(config);
+        AWS.config.update(config);
+    });
+
+    beforeEach(done => s3.createBucket({ Bucket: bucket }, done));
+
+    afterEach(done => s3.deleteBucket({ Bucket: bucket }, done));
+
+    it('should return the rate limit config', async () => {
+        try {
+            // First set the rate limit config
+            await sendRateLimitRequest('PUT', '127.0.0.1:8000',
+                `/${bucket}/?rate-limit`, JSON.stringify(rateLimitConfig));
+
+            // Then get it
+            const data = await sendRateLimitRequest('GET', '127.0.0.1:8000',
+                `/${bucket}/?rate-limit`);
+            assert.strictEqual(data.RequestsPerSecond.Limit, 100);
+        } catch (err) {
+            assert.ifError(err);
+        }
+    });
+
+    it('should return NoSuchRateLimitConfig error when config does not exist', async () => {
+        try {
+            await sendRateLimitRequest('GET', '127.0.0.1:8000', `/${bucket}/?rate-limit`);
+            assert.fail('Expected NoSuchRateLimitConfig error');
+        } catch (err) {
+            assert.strictEqual(err.Error.Code[0], 'NoSuchRateLimitConfig');
+        }
+    });
+
+    it('should return NoSuchBucket error when bucket does not exist', async () => {
+        try {
+            await sendRateLimitRequest('GET', '127.0.0.1:8000', '/nonexistentbucket/?rate-limit');
+        } catch (err) {
+            assert.strictEqual(err.Error.Code[0], 'NoSuchBucket');
+        }
+    });
+
+    it('should return AccessDenied error for non-service user', async () => {
+        // This test would require making a request with regular user credentials
+        // For now, we'll skip this as it requires additional setup
+        // In a real scenario, you'd use regular user credentials here
+    });
+});

tests/unit/api/bucketGetRateLimit.js

@@ -0,0 +1,146 @@
+const assert = require('assert');
+const sinon = require('sinon');
+const { bucketPut } = require('../../../lib/api/bucketPut');
+const { cleanup, DummyRequestLogger, makeAuthInfo } = require('../helpers');
+const bucketGetRateLimit = require('../../../lib/api/bucketGetRateLimit');
+const bucketPutRateLimit = require('../../../lib/api/bucketPutRateLimit');
+const { config } = require('../../../lib/Config');
+const AuthInfo = require('arsenal').auth.AuthInfo;
+
+const log = new DummyRequestLogger();
+const bucketName = 'bucketname';
+const serviceUserArn = 'arn:aws:iam::123456789012:user/rate-limit-service';
+
+// Create a rate limit service user authInfo
+function makeRateLimitServiceUserAuthInfo() {
+    return new AuthInfo({
+        canonicalID: '79a59df900b949e55d96a1e698fbacedfd6e09d98eacf8f8d5218e7cd47ef2be',
+        shortid: '123456789012',
+        email: '[email protected]',
+        accountDisplayName: 'rateLimitServiceDisplayName',
+        arn: serviceUserArn,
+    });
+}
+
+const rateLimitServiceAuthInfo = makeRateLimitServiceUserAuthInfo();
+const regularAuthInfo = makeAuthInfo('accessKey1');
+
+const bucketPutReq = {
+    bucketName,
+    headers: {
+        host: `${bucketName}.s3.amazonaws.com`,
+    },
+    url: '/',
+    actionImplicitDenies: false,
+};
+
+function getRateLimitConfigRequest(bucketName) {
+    return {
+        bucketName,
+        headers: {
+            host: `${bucketName}.s3.amazonaws.com`,
+        },
+        url: '/?rate-limit',
+        method: 'GET',
+        actionImplicitDenies: false,
+    };
+}
+
+function getRateLimitPutRequest(bucketName, configJson) {
+    return {
+        bucketName,
+        headers: {
+            host: `${bucketName}.s3.amazonaws.com`,
+        },
+        url: '/?rate-limit',
+        method: 'PUT',
+        post: JSON.stringify(configJson),
+        actionImplicitDenies: false,
+    };
+}
+
+describe('bucketGetRateLimit API', () => {
+    let sandbox;
+
+    beforeEach(() => {
+        sandbox = sinon.createSandbox();
+        sandbox.stub(config, 'rateLimiting').value({
+            serviceUserArn,
+        });
+    });
+
+    afterEach(() => {
+        sandbox.restore();
+        cleanup();
+    });
+
+    it('should return AccessDenied error if user is not a rate limit service user', done => {
+        bucketPut(regularAuthInfo, bucketPutReq, log, err => {
+            assert.ifError(err);
+            const rateLimitRequest = getRateLimitConfigRequest(bucketName);
+            bucketGetRateLimit(regularAuthInfo, rateLimitRequest, log, err => {
+                assert.strictEqual(err.is.AccessDenied, true);
+                done();
+            });
+        });
+    });
+
+    it('should return NoSuchRateLimitConfig error if bucket exists but ' +
+        'rate limit config is not set', done => {
+        bucketPut(regularAuthInfo, bucketPutReq, log, err => {
+            assert.ifError(err);
+            const rateLimitRequest = getRateLimitConfigRequest(bucketName);
+            bucketGetRateLimit(rateLimitServiceAuthInfo, rateLimitRequest, log, err => {
+                assert.strictEqual(err.is.NoSuchRateLimitConfig, true);
+                done();
+            });
+        });
+    });
+
+    it('should return bucket not found error if bucket does not exist', done => {
+        const rateLimitRequest = getRateLimitConfigRequest('nonexistent-bucket');
+        bucketGetRateLimit(rateLimitServiceAuthInfo, rateLimitRequest, log, err => {
+            assert(err, 'should return an error');
+            assert.strictEqual(err.is.NoSuchBucket, true);
+            done();
+        });
+    });
+});
+
+describe('bucketGetRateLimit API with rate limit config', () => {
+    let sandbox;
+
+    beforeEach(() => {
+        sandbox = sinon.createSandbox();
+        sandbox.stub(config, 'rateLimiting').value({
+            serviceUserArn,
+        });
+    });
+
+    afterEach(() => {
+        sandbox.restore();
+        cleanup();
+    });
+
+    beforeEach(done => {
+        bucketPut(regularAuthInfo, bucketPutReq, log, err => {
+            assert.ifError(err);
+            const rateLimitConfig = { RequestsPerSecond: 100 };
+            const putRequest = getRateLimitPutRequest(bucketName, rateLimitConfig);
+            bucketPutRateLimit(rateLimitServiceAuthInfo, putRequest, log, err => {
+                assert.ifError(err);
+                done();
+            });
+        });
+    });
+
+    it('should return rate limit configuration JSON when config exists', done => {
+        const rateLimitRequest = getRateLimitConfigRequest(bucketName);
+        bucketGetRateLimit(rateLimitServiceAuthInfo, rateLimitRequest, log, (err, res) => {
+            assert.ifError(err);
+            const rateLimitConfig = JSON.parse(res);
+            assert.strictEqual(rateLimitConfig.RequestsPerSecond.Limit, 100);
+            done();
+        });
+    });
+});