@gugananuvem/aws-local-simulator 1.0.25 → 1.0.26

package/src/services/kms/simulator.js

@@ -65,44 +65,56 @@ class KMSSimulator {
   }
 
   async createKey(params) {
-    const { Description, KeyUsage = 'ENCRYPT_DECRYPT', KeySpec = 'SYMMETRIC_DEFAULT', Tags = [], MultiRegion = false } = params || {};
+    const Description = params.Description || params.description || '';
+    const KeyUsage = params.KeyUsage || params.keyUsage || 'ENCRYPT_DECRYPT';
+    const KeySpec = params.KeySpec || params.keySpec || 'SYMMETRIC_DEFAULT';
+    const Tags = params.Tags || params.tags || [];
+    const MultiRegion = params.MultiRegion || params.multiRegion || false;
+
     const keyId = uuidv4();
     const keyArn = `arn:aws:kms:local:000000000000:key/${keyId}`;
     let keyMaterial;
     let publicKey = null;
     let privateKey = null;
 
-    if (KeySpec === 'SYMMETRIC_DEFAULT') {
-      keyMaterial = crypto.randomBytes(32);
-    } else if (KeySpec.startsWith('RSA_')) {
-      const bits = KeySpec === 'RSA_2048' ? 2048 : KeySpec === 'RSA_3072' ? 3072 : 4096;
-      const pair = crypto.generateKeyPairSync('rsa', {
-        modulusLength: bits,
-        publicKeyEncoding: { type: 'spki', format: 'pem' },
-        privateKeyEncoding: { type: 'pkcs8', format: 'pem' }
-      });
-      publicKey = pair.publicKey;
-      privateKey = pair.privateKey;
-      keyMaterial = Buffer.from(privateKey);
-    } else if (KeySpec.startsWith('ECC_')) {
-      const curve = KeySpec.includes('P256') ? 'prime256v1' : KeySpec.includes('P384') ? 'secp384r1' : 'secp521r1';
-      const pair = crypto.generateKeyPairSync('ec', {
-        namedCurve: curve,
-        publicKeyEncoding: { type: 'spki', format: 'pem' },
-        privateKeyEncoding: { type: 'pkcs8', format: 'pem' }
-      });
-      publicKey = pair.publicKey;
-      privateKey = pair.privateKey;
-      keyMaterial = Buffer.from(privateKey);
-    } else {
-      keyMaterial = crypto.randomBytes(32);
+    this.logger.debug(`KMS: Criando chave ${keyId} (Spec: ${KeySpec})`, 'kms');
+
+    try {
+      if (KeySpec === 'SYMMETRIC_DEFAULT') {
+        keyMaterial = crypto.randomBytes(32);
+      } else if (KeySpec.startsWith('RSA_')) {
+        const bits = KeySpec === 'RSA_2048' ? 2048 : KeySpec === 'RSA_3072' ? 3072 : 4096;
+        const pair = crypto.generateKeyPairSync('rsa', {
+          modulusLength: bits,
+          publicKeyEncoding: { type: 'spki', format: 'pem' },
+          privateKeyEncoding: { type: 'pkcs8', format: 'pem' }
+        });
+        publicKey = pair.publicKey;
+        privateKey = pair.privateKey;
+        keyMaterial = Buffer.from(privateKey);
+      } else if (KeySpec.startsWith('ECC_')) {
+        const curve = KeySpec.includes('P256') ? 'prime256v1' : KeySpec.includes('P384') ? 'secp384r1' : 'secp521r1';
+        const pair = crypto.generateKeyPairSync('ec', {
+          namedCurve: curve,
+          publicKeyEncoding: { type: 'spki', format: 'pem' },
+          privateKeyEncoding: { type: 'pkcs8', format: 'pem' }
+        });
+        publicKey = pair.publicKey;
+        privateKey = pair.privateKey;
+        keyMaterial = Buffer.from(privateKey);
+      } else {
+        keyMaterial = crypto.randomBytes(32);
+      }
+    } catch (err) {
+      this.logger.error(`KMS: Erro ao gerar material da chave: ${err.message}`, 'kms');
+      throw err;
     }
 
     this.keyMaterial.set(keyId, keyMaterial);
     const key = {
       KeyId: keyId,
       KeyArn: keyArn,
-      Description: Description || '',
+      Description,
       KeyUsage,
       KeySpec,
       KeyState: 'Enabled',
@@ -115,22 +127,30 @@ class KMSSimulator {
     };
     this.keys.set(keyId, key);
     await this._persistKeys();
-    this.logger.info(`KMS: chave criada: ${keyId}`, 'kms');
+    this.logger.info(`KMS: chave criada com sucesso: ${keyId}`, 'kms');
     this.audit.record({ eventName: 'CreateKey', readOnly: false, resources: [{ ARN: keyArn, type: 'AWS::KMS::Key' }], requestParameters: { description: Description, keyUsage: KeyUsage, keySpec: KeySpec } });
     return { KeyMetadata: this._sanitizeKey(key) };
   }
 
   async describeKey(params) {
-    const key = this._requireKey(params.KeyId);
+    const keyId = params.KeyId || params.keyId;
+    const key = this._requireKey(keyId);
     return { KeyMetadata: this._sanitizeKey(key) };
   }
 
   async listKeys(params) {
     const { Limit = 100 } = params || {};
     const keys = Array.from(this.keys.values()).slice(0, Limit);
+    // Para o Dashboard, retornamos mais detalhes se for solicitado via admin
+    // Mas para o SDK padrão, retornamos apenas o que o SDK espera
     return { Keys: keys.map(k => ({ KeyId: k.KeyId, KeyArn: k.KeyArn })) };
   }
 
+  listKeysFull() {
+    return Array.from(this.keys.values()).map(k => this._sanitizeKey(k));
+  }
+
+
   async enableKey(params) {
     const key = this._requireKey(params.KeyId);
     key.KeyState = 'Enabled'; key.Enabled = true;

package/src/services/lambda/server.js

@@ -80,6 +80,30 @@ class LambdaServer {
     this.app.get('/__admin/functions', (req, res) => {
       res.json(this.simulator.listLambdas());
     });
+    
+    this.app.post('/__admin/functions', async (req, res) => {
+      try {
+        const lambda = await this.simulator.createFunction(req.body);
+        res.status(201).json(lambda);
+      } catch (err) {
+        res.status(400).json({ error: err.message });
+      }
+    });
+
+    this.app.put('/__admin/functions/:name', async (req, res) => {
+      try {
+        const lambda = await this.simulator.updateFunction(req.params.name, req.body);
+        res.json(lambda);
+      } catch (err) {
+        res.status(400).json({ error: err.message });
+      }
+    });
+
+    this.app.delete('/__admin/functions/:name', async (req, res) => {
+      const deleted = await this.simulator.deleteFunction(req.params.name);
+      if (deleted) res.json({ message: 'Lambda deleted' });
+      else res.status(404).json({ error: 'Lambda not found' });
+    });
 
     this.app.post('/__admin/reload', async (req, res) => {
       await this.simulator.reloadLambdas();

package/src/services/lambda/simulator.js

@@ -1,7 +1,6 @@
-/**
- * Lambda Simulator - Simula execução de funções Lambda
- */
-
+const LocalStore = require("../../utils/local-store");
+const path = require("path");
+const fs = require("fs");
 const HandlerLoader = require("./handler-loader");
 const logger = require("../../utils/logger");
 const { CloudTrailAudit } = require("../../utils/cloudtrail-audit");
@@ -9,6 +8,8 @@ const { CloudTrailAudit } = require("../../utils/cloudtrail-audit");
 class LambdaSimulator {
   constructor(config) {
     this.config = config;
+    this.dataDir = path.join(process.env.AWS_LOCAL_SIMULATOR_DATA_DIR, "lambda");
+    this.store = new LocalStore(this.dataDir);
     this.lambdas = new Map(); // functionName -> { handler, env, config }
     this.environment = { ...process.env };
     this.audit = new CloudTrailAudit("lambda.amazonaws.com");
@@ -23,15 +24,27 @@ class LambdaSimulator {
     this.globalTimeout = globalDefaults.timeout || null;
     this.globalMemorySize = globalDefaults.memorySize || null;
 
+    // Carrega do config.lambdas (fixo)
     if (this.config.lambdas && this.config.lambdas.length > 0) {
       for (const lambdaConfig of this.config.lambdas) {
         await this.registerLambda(lambdaConfig);
       }
     }
 
+    // Carrega lambdas dinâmicas do disco
+    const savedLambdas = this.store.read("__functions__");
+    if (savedLambdas && Array.isArray(savedLambdas)) {
+      for (const lambdaConfig of savedLambdas) {
+        if (!this.lambdas.has(lambdaConfig.name)) {
+          await this.registerLambda(lambdaConfig);
+        }
+      }
+    }
+
     logger.debug(`✅ ${this.lambdas.size} Lambdas registradas`);
   }
 
+
   async registerLambda(lambdaConfig) {
     try {
       const { name, handler: handlerPath, type = "auto" } = lambdaConfig;
@@ -51,6 +64,14 @@ class LambdaSimulator {
       const memorySize = lambdaConfig.memorySize ?? this.globalMemorySize ?? 128;
 
       const handler = await HandlerLoader.load(handlerPath, type);
+      let codeSize = 0;
+      try {
+        const info = await HandlerLoader.getInfo(handlerPath);
+        codeSize = info.size;
+      } catch (err) {
+        // Ignore size errors
+      }
+
       if (handler != undefined) {
         this.lambdas.set(name, {
           name,
@@ -60,6 +81,7 @@ class LambdaSimulator {
           env,
           timeout,
           memorySize,
+          codeSize,
           type,
           registeredAt: new Date().toISOString(),
         });
@@ -147,16 +169,32 @@ class LambdaSimulator {
   }
 
   listLambdas() {
-    return Array.from(this.lambdas.values()).map((l) => ({
-      name: l.name,
-      handlerName: l.handlerName,
-      handlerPath: l.handlerPath,
-      type: l.type,
-      env: l.env,
-      registeredAt: l.registeredAt,
-    }));
+    return Array.from(this.lambdas.values()).map((l) => {
+      let code = "";
+      try {
+        if (fs.existsSync(l.handlerPath)) {
+          code = fs.readFileSync(l.handlerPath, "utf8");
+        }
+      } catch (err) {
+        logger.error(`Erro ao ler código da lambda ${l.name}:`, err);
+      }
+
+      return {
+        name: l.name,
+        handlerName: l.handlerName,
+        handlerPath: l.handlerPath,
+        type: l.type,
+        env: l.env,
+        timeout: l.timeout,
+        memorySize: l.memorySize,
+        codeSize: l.codeSize,
+        registeredAt: l.registeredAt,
+        code: code
+      };
+    });
   }
 
+
   getLambda(name) {
     return this.lambdas.get(name);
   }
@@ -182,6 +220,91 @@ class LambdaSimulator {
     logger.info(`✅ ${this.lambdas.size} Lambdas recarregadas`);
   }
 
+  async createFunction(lambdaConfig) {
+    const { name, code, runtime, handler, timeout, memorySize, environment } = lambdaConfig;
+
+    if (!name) throw new Error("Function name is required");
+
+    // Define o caminho do arquivo (dentro do dataDir/functions)
+    const functionsDir = path.join(this.dataDir, "functions");
+    if (!fs.existsSync(functionsDir)) fs.mkdirSync(functionsDir, { recursive: true });
+
+    const fileName = `${name}.js`;
+    const filePath = path.join(functionsDir, fileName);
+
+    // Salva o código no disco
+    fs.writeFileSync(filePath, code || "// Hello Lambda");
+
+    // Registra a lambda
+    const config = {
+      name,
+      handler: filePath,
+      runtime: runtime || "nodejs18.x",
+      timeout: timeout || 30,
+      memorySize: memorySize || 128,
+      env: environment || {},
+      type: "commonjs"
+    };
+
+    await this.registerLambda(config);
+    this.persistLambdas();
+
+    return this.lambdas.get(name);
+  }
+
+  async updateFunction(name, lambdaConfig) {
+    const lambda = this.lambdas.get(name);
+    if (!lambda) throw new Error(`Function not found: ${name}`);
+
+    const { code, runtime, handler, timeout, memorySize, environment } = lambdaConfig;
+
+    // Se houver código novo, sobrescreve o arquivo
+    if (code !== undefined) {
+      fs.writeFileSync(lambda.handlerPath, code);
+    }
+
+    // Atualiza a configuração
+    const updatedConfig = {
+      name,
+      handler: lambda.handlerPath,
+      runtime: runtime || lambda.runtime,
+      timeout: timeout || lambda.timeout,
+      memorySize: memorySize || lambda.memorySize,
+      env: environment || lambda.env,
+      type: lambda.type
+    };
+
+    await this.registerLambda(updatedConfig);
+    this.persistLambdas();
+
+    return this.lambdas.get(name);
+  }
+
+  async deleteFunction(name) {
+
+    if (this.lambdas.has(name)) {
+      this.lambdas.delete(name);
+      this.persistLambdas();
+      return true;
+    }
+    return false;
+  }
+
+  persistLambdas() {
+    const functionsToSave = Array.from(this.lambdas.values())
+      .filter(l => l.handlerPath.includes(this.dataDir)) // Apenas as dinâmicas
+      .map(l => ({
+        name: l.name,
+        handler: l.handlerPath,
+        type: l.type,
+        env: l.env,
+        timeout: l.timeout,
+        memorySize: l.memorySize,
+      }));
+
+    this.store.write("__functions__", functionsToSave);
+  }
+
   getStats() {
     return {
       totalLambdas: this.lambdas.size,
@@ -189,6 +312,7 @@ class LambdaSimulator {
     };
   }
 
+
   async reset() {
     await this.reloadLambdas();
     this.environment = { ...process.env };

package/src/services/parameter-store/simulator.js

@@ -50,7 +50,7 @@ class ParameterStoreSimulator {
     const storedValue = Type === 'SecureString' ? this._encrypt(Value) : Value;
     const param = {
       Name, Value: storedValue, Type, Description: Description || '', Version: version,
-      LastModifiedDate: new Date().toISOString(),
+      LastModifiedDate: Math.floor(Date.now() / 1000),
       LastModifiedUser: 'local',
       ARN: `arn:aws:ssm:local:000000000000:parameter${Name}`,
       DataType, Tags: Tags || [], KeyId: Type === 'SecureString' ? (KeyId || 'aws/ssm') : undefined

package/src/services/s3/server.js

@@ -23,6 +23,26 @@ class S3Server {
     this.app.use(express.raw({ type: () => true, limit: '100mb' }));
     this.app.use(express.text({ limit: '100mb' }));
     
+    // Suporte a Virtual Host Style addressing (bucket.localhost:4566)
+    this.app.use((req, res, next) => {
+      const host = req.headers.host || '';
+      // Se o host contém múltiplos pontos e não é apenas um IP ou localhost puro
+      if (host.includes('.') && !host.startsWith('localhost') && !host.startsWith('127.0.0.1')) {
+        const parts = host.split('.');
+        // O primeiro fragmento é o nome do bucket se houver mais de 2 partes (bucket.localhost:port)
+        // ou se a segunda parte for localhost
+        if (parts.length >= 2) {
+          const bucket = parts[0];
+          // Evita processar se for admin ou se já estiver no path style (heurística simples)
+          if (bucket !== 'localhost' && !req.path.startsWith('/__admin/')) {
+            req.url = `/${bucket}${req.url}`;
+            logger.verboso(`S3: Virtual Host Style detected. Rewriting to ${req.url}`);
+          }
+        }
+      }
+      next();
+    });
+
     // Logging de requisições
     if (logger.currentLogLevel === 'verboso') {
       this.app.use((req, res, next) => {
@@ -36,6 +56,7 @@ class S3Server {
     }
   }
 
+
   async initialize() {
     if (!this.simulator) {
       this.simulator = new S3Simulator(this.config);

package/src/services/s3/simulator.js

@@ -489,10 +489,13 @@ class S3Simulator {
   // ─── Utilitários ──────────────────────────────────────────────────────────
 
   isValidBucketName(bucketName) {
-    const regex = /^[a-z0-9][a-z0-9.-]{1,61}[a-z0-9]$/;
+    // S3 oficial é rigoroso, mas para simulador local vamos ser mais tolerantes
+    // permitindo underscores e letras maiúsculas que são comuns em testes locais
+    const regex = /^[a-zA-Z0-9][a-zA-Z0-9._-]{1,61}[a-zA-Z0-9]$/;
     return regex.test(bucketName) && !bucketName.includes("..") && !bucketName.includes(".-") && !bucketName.includes("-.");
   }
 
+
   extractMetadata(headers) {
     const metadata = {};
     for (const [key, value] of Object.entries(headers)) {

package/src/services/secret-manager/server.js

@@ -37,7 +37,8 @@ class SecretManagerServer {
       if (!operation) return res.status(400).json({ __type: 'UnknownOperationException', message: `Unknown: ${target}` });
       try {
         const result = await this.simulator[operation](req.body || {});
-        res.json(result || {});
+        res.setHeader('Content-Type', 'application/x-amz-json-1.1');
+        res.send(JSON.stringify(result || {}));
       } catch (err) {
         this.logger.error(`SecretsManager ${target}: ${err.message}`, 'secret-manager');
         res.status(err.code === 'ResourceNotFoundException' ? 404 : 400).json({ __type: err.code || 'InternalServiceError', Message: err.message });

package/src/services/secret-manager/simulator.js

@@ -17,7 +17,18 @@ class SecretManagerSimulator {
   async initialize() {
     try {
       const secrets = await this.store.read('secret-manager/secrets');
-      if (Array.isArray(secrets)) for (const s of secrets) this.secrets.set(s.Name, s);
+      if (Array.isArray(secrets)) {
+        for (const s of secrets) {
+          if (typeof s.CreatedDate === 'string') s.CreatedDate = Math.floor(new Date(s.CreatedDate).getTime() / 1000);
+          if (typeof s.LastChangedDate === 'string') s.LastChangedDate = Math.floor(new Date(s.LastChangedDate).getTime() / 1000);
+          if (s._versions) {
+            for (const v of Object.values(s._versions)) {
+              if (typeof v.CreatedDate === 'string') v.CreatedDate = Math.floor(new Date(v.CreatedDate).getTime() / 1000);
+            }
+          }
+          this.secrets.set(s.Name, s);
+        }
+      }
       this.logger.info('SecretsManager: dados carregados', 'secret-manager');
     } catch { this.logger.debug('SecretsManager: sem dados anteriores', 'secret-manager'); }
   }
@@ -38,12 +49,12 @@ class SecretManagerSimulator {
       ARN: `arn:aws:secretsmanager:local:000000000000:secret:${Name}-${secretId.slice(0, 6)}`,
       Name, Description: Description || '', Tags,
       KmsKeyId: KmsKeyId || 'aws/secretsmanager',
-      CreatedDate: new Date().toISOString(),
-      LastChangedDate: new Date().toISOString(),
+      CreatedDate: Math.floor(Date.now() / 1000),
+      LastChangedDate: Math.floor(Date.now() / 1000),
       LastAccessedDate: null,
       RotationEnabled: false,
       VersionsToStages: { [secretId]: ['AWSCURRENT'] },
-      _versions: { [secretId]: { SecretString, SecretBinary, CreatedDate: new Date().toISOString() } }
+      _versions: { [secretId]: { SecretString, SecretBinary, CreatedDate: Math.floor(Date.now() / 1000) } }
     };
     this.secrets.set(Name, secret);
     await this._persist();
@@ -55,7 +66,7 @@ class SecretManagerSimulator {
   async getSecretValue(params) {
     const { SecretId, VersionId, VersionStage = 'AWSCURRENT' } = params;
     const secret = this._requireSecret(SecretId);
-    secret.LastAccessedDate = new Date().toISOString();
+    secret.LastAccessedDate = Math.floor(Date.now() / 1000);
     let versionId = VersionId;
     if (!versionId) {
       versionId = Object.entries(secret.VersionsToStages).find(([, stages]) => stages.includes(VersionStage))?.[0];
@@ -81,9 +92,9 @@ class SecretManagerSimulator {
         secret.VersionsToStages[vid] = stages.filter(s => s !== 'AWSCURRENT').concat(['AWSPREVIOUS']);
       }
     }
-    secret._versions[versionId] = { SecretString, SecretBinary, CreatedDate: new Date().toISOString() };
+    secret._versions[versionId] = { SecretString, SecretBinary, CreatedDate: Math.floor(Date.now() / 1000) };
     secret.VersionsToStages[versionId] = VersionStages;
-    secret.LastChangedDate = new Date().toISOString();
+    secret.LastChangedDate = Math.floor(Date.now() / 1000);
     await this._persist();
     return { ARN: secret.ARN, Name: secret.Name, VersionId: versionId, VersionStages };
   }
@@ -103,8 +114,8 @@ class SecretManagerSimulator {
   async deleteSecret(params) {
     const { SecretId, RecoveryWindowInDays = 30, ForceDeleteWithoutRecovery } = params;
     const secret = this._requireSecret(SecretId);
-    const deletionDate = ForceDeleteWithoutRecovery ? new Date().toISOString() : new Date(Date.now() + RecoveryWindowInDays * 86400000).toISOString();
-    secret.DeletedDate = new Date().toISOString();
+    const deletionDate = ForceDeleteWithoutRecovery ? Math.floor(Date.now() / 1000) : Math.floor((Date.now() + RecoveryWindowInDays * 86400000) / 1000);
+    secret.DeletedDate = Math.floor(Date.now() / 1000);
     secret.DeletionDate = deletionDate;
     if (ForceDeleteWithoutRecovery) this.secrets.delete(secret.Name);
     await this._persist();
@@ -146,7 +157,7 @@ class SecretManagerSimulator {
     secret.RotationEnabled = true;
     secret.RotationLambdaARN = RotationLambdaARN;
     secret.RotationRules = RotationRules;
-    secret.LastRotatedDate = new Date().toISOString();
+    secret.LastRotatedDate = Math.floor(Date.now() / 1000);
     await this._persist();
     return { ARN: secret.ARN, Name: secret.Name };
   }

package/src/services/sns/server.js

@@ -81,27 +81,39 @@ function createSNSServer(simulator, config, logger) {
   });
 
   app.get('/__admin/topics', (_req, res) => {
-    res.json({ topics: Array.from(simulator.topics.values()) });
+    res.json(Array.from(simulator.topics.values()));
   });
 
+  app.post('/__admin/topics', async (req, res) => {
+    try {
+      const topic = await simulator.createTopic({ Name: req.body.name });
+      res.status(201).json(topic);
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
+
   app.get('/__admin/subscriptions', (_req, res) => {
-    res.json({ subscriptions: Array.from(simulator.subscriptions.values()) });
+    res.json(Array.from(simulator.subscriptions.values()));
   });
 
   app.get('/__admin/subscriptions/:topicName', (req, res) => {
     const arn  = `arn:aws:sns:us-east-1:123456789012:${req.params.topicName}`;
     const subs = Array.from(simulator.subscriptions.values()).filter(s => s.TopicArn === arn);
-    res.json({ subscriptions: subs });
+    res.json(subs);
   });
 
+
   app.get('/__admin/publish-log', (_req, res) => {
-    res.json({ messages: simulator.publishLog });
+    res.json(simulator.publishLog);
   });
 
   app.get('/__admin/platform-apps', (_req, res) => {
-    res.json({ platformApplications: Array.from(simulator.platformApps.values()) });
+    res.json(Array.from(simulator.platformApps.values()));
   });
 
+
   app.delete('/__admin/topics/:topicName', async (req, res) => {
     try {
       const arn = `arn:aws:sns:us-east-1:123456789012:${req.params.topicName}`;
@@ -112,6 +124,21 @@ function createSNSServer(simulator, config, logger) {
     }
   });
 
+  app.post('/__admin/topics/:topicName/publish', async (req, res) => {
+    try {
+      const arn = `arn:aws:sns:us-east-1:123456789012:${req.params.topicName}`;
+      const result = await simulator.publish({
+        TopicArn: arn,
+        Subject: req.body.subject,
+        Message: req.body.message
+      });
+      res.json(result);
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
+
   app.post('/__admin/reset', async (_req, res) => {
     await simulator.reset();
     res.json({ message: 'SNS data reset complete' });

package/src/services/sqs/server.js

@@ -187,7 +187,10 @@ class SQSServer {
         return this.generateReceiveMessageResponse(result.messages);
       case 'DeleteMessage':
         return this.generateDeleteMessageResponse();
+      case 'SetQueueAttributes':
+        return this.generateSetQueueAttributesResponse();
       case 'GetQueueUrl':
+
         return this.generateGetQueueUrlResponse(result.queueUrl);
       case 'ListQueues':
         return this.generateListQueuesResponse(result.queues);
@@ -196,6 +199,14 @@ class SQSServer {
     }
   }
 
+  generateSetQueueAttributesResponse() {
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<SetQueueAttributesResponse xmlns="http://queue.amazonaws.com/doc/2012-11-05/">
+  <ResponseMetadata><RequestId>${crypto.randomUUID()}</RequestId></ResponseMetadata>
+</SetQueueAttributesResponse>`;
+  }
+
+
   generateCreateQueueResponse(queueUrl) {
     return `<?xml version="1.0" encoding="UTF-8"?>
 <CreateQueueResponse xmlns="http://queue.amazonaws.com/doc/2012-11-05/">