pulsar-client 1.8.2 → 1.9.0

package/src/LogUtils.h

@@ -0,0 +1,32 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#ifndef PULSAR_CLIENT_NODE_LOGUTILS_H
+#define PULSAR_CLIENT_NODE_LOGUTILS_H
+
+#include "Client.h"
+
+#define LOG(level, message) Client::LogMessage(pulsar_logger_level_t::level, __FILE__, __LINE__, message, 0)
+
+#define LOG_DEBUG(message) LOG(pulsar_DEBUG, message)
+#define LOG_INFO(message) LOG(pulsar_INFO, message)
+#define LOG_WARN(message) LOG(pulsar_WARN, message)
+#define LOG_ERROR(message) LOG(pulsar_ERROR, message)
+
+#endif  // PULSAR_CLIENT_NODE_LOGUTILS_H

package/src/ProducerConfig.cc

@@ -39,6 +39,7 @@ static const std::string CFG_PUBLIC_KEY_PATH = "publicKeyPath";
 static const std::string CFG_ENCRYPTION_KEY = "encryptionKey";
 static const std::string CFG_CRYPTO_FAILURE_ACTION = "cryptoFailureAction";
 static const std::string CFG_CHUNK_ENABLED = "chunkingEnabled";
+static const std::string CFG_ACCESS_MODE = "accessMode";
 
 static const std::map<std::string, pulsar_partitions_routing_mode> MESSAGE_ROUTING_MODE = {
     {"UseSinglePartition", pulsar_UseSinglePartition},
@@ -63,6 +64,13 @@ static std::map<std::string, pulsar_producer_crypto_failure_action> PRODUCER_CRY
     {"SEND", pulsar_ProducerSend},
 };
 
+static std::map<std::string, pulsar_producer_access_mode> PRODUCER_ACCESS_MODE = {
+    {"Shared", pulsar_ProducerAccessModeShared},
+    {"Exclusive", pulsar_ProducerAccessModeExclusive},
+    {"WaitForExclusive", pulsar_ProducerAccessModeWaitForExclusive},
+    {"ExclusiveWithFencing", pulsar_ProducerAccessModeExclusiveWithFencing},
+};
+
 ProducerConfig::ProducerConfig(const Napi::Object& producerConfig) : topic("") {
   this->cProducerConfig = std::shared_ptr<pulsar_producer_configuration_t>(
       pulsar_producer_configuration_create(), pulsar_producer_configuration_free);
@@ -194,6 +202,12 @@ ProducerConfig::ProducerConfig(const Napi::Object& producerConfig) : topic("") {
     bool chunkingEnabled = producerConfig.Get(CFG_CHUNK_ENABLED).ToBoolean().Value();
     pulsar_producer_configuration_set_chunking_enabled(this->cProducerConfig.get(), chunkingEnabled);
   }
+
+  std::string accessMode = producerConfig.Get(CFG_ACCESS_MODE).ToString().Utf8Value();
+  if (PRODUCER_ACCESS_MODE.count(accessMode)) {
+    pulsar_producer_configuration_set_access_mode(this->cProducerConfig.get(),
+                                                  PRODUCER_ACCESS_MODE.at(accessMode));
+  }
 }
 
 ProducerConfig::~ProducerConfig() {}

package/src/Reader.cc

@@ -222,7 +222,9 @@ Napi::Value Reader::HasNext(const Napi::CallbackInfo &info) {
   int value = 0;
   pulsar_result result = pulsar_reader_has_message_available(this->cReader.get(), &value);
   if (result != pulsar_result_Ok) {
-    Napi::Error::New(info.Env(), "Failed to check if next message is available").ThrowAsJavaScriptException();
+    Napi::Error::New(
+        info.Env(), "Failed to check if next message is available: " + std::string(pulsar_result_str(result)))
+        .ThrowAsJavaScriptException();
     return Napi::Boolean::New(info.Env(), false);
   } else if (value == 1) {
     return Napi::Boolean::New(info.Env(), true);

package/src/ReaderConfig.cc

@@ -19,6 +19,7 @@
 
 #include "ReaderConfig.h"
 #include "MessageId.h"
+#include <pulsar/c/consumer_configuration.h>
 #include <map>
 
 static const std::string CFG_TOPIC = "topic";
@@ -28,6 +29,14 @@ static const std::string CFG_READER_NAME = "readerName";
 static const std::string CFG_SUBSCRIPTION_ROLE_PREFIX = "subscriptionRolePrefix";
 static const std::string CFG_READ_COMPACTED = "readCompacted";
 static const std::string CFG_LISTENER = "listener";
+static const std::string CFG_PRIVATE_KEY_PATH = "privateKeyPath";
+static const std::string CFG_CRYPTO_FAILURE_ACTION = "cryptoFailureAction";
+
+static const std::map<std::string, pulsar_consumer_crypto_failure_action> CONSUMER_CRYPTO_FAILURE_ACTION = {
+    {"FAIL", pulsar_ConsumerFail},
+    {"DISCARD", pulsar_ConsumerDiscard},
+    {"CONSUME", pulsar_ConsumerConsume},
+};
 
 void FinalizeListenerCallback(Napi::Env env, ReaderListenerCallback *cb, void *) { delete cb; }
 
@@ -82,6 +91,21 @@ ReaderConfig::ReaderConfig(const Napi::Object &readerConfig, pulsar_reader_liste
     pulsar_reader_configuration_set_reader_listener(this->cReaderConfig.get(), readerListener,
                                                     this->listener);
   }
+
+  if (readerConfig.Has(CFG_PRIVATE_KEY_PATH) && readerConfig.Get(CFG_PRIVATE_KEY_PATH).IsString()) {
+    std::string publicKeyPath = "";
+    std::string privateKeyPath = readerConfig.Get(CFG_PRIVATE_KEY_PATH).ToString().Utf8Value();
+    pulsar_reader_configuration_set_default_crypto_key_reader(this->cReaderConfig.get(),
+                                                              publicKeyPath.c_str(), privateKeyPath.c_str());
+    if (readerConfig.Has(CFG_CRYPTO_FAILURE_ACTION) &&
+        readerConfig.Get(CFG_CRYPTO_FAILURE_ACTION).IsString()) {
+      std::string cryptoFailureAction = readerConfig.Get(CFG_CRYPTO_FAILURE_ACTION).ToString().Utf8Value();
+      if (CONSUMER_CRYPTO_FAILURE_ACTION.count(cryptoFailureAction)) {
+        pulsar_reader_configuration_set_crypto_failure_action(
+            this->cReaderConfig.get(), CONSUMER_CRYPTO_FAILURE_ACTION.at(cryptoFailureAction));
+      }
+    }
+  }
 }
 
 ReaderConfig::~ReaderConfig() {

package/tests/client.test.js

@@ -17,8 +17,11 @@
  * under the License.
  */
 
+const httpRequest = require('./http_utils.js');
 const Pulsar = require('../index.js');
 
+const baseUrl = 'http://localhost:8080';
+
 (() => {
   describe('Client', () => {
     describe('CreateFailedByUrlSetIncorrect', () => {
@@ -49,5 +52,71 @@ const Pulsar = require('../index.js');
         })).toThrow('Service URL is required and must be specified as a string');
       });
     });
+    describe('test getPartitionsForTopic', () => {
+      test('GetPartitions for empty topic', async () => {
+        const client = new Pulsar.Client({
+          serviceUrl: 'pulsar://localhost:6650',
+          operationTimeoutSeconds: 30,
+        });
+
+        await expect(client.getPartitionsForTopic(''))
+          .rejects.toThrow('Failed to GetPartitionsForTopic: InvalidTopicName');
+        await client.close();
+      });
+
+      test('Client/getPartitionsForTopic', async () => {
+        const client = new Pulsar.Client({
+          serviceUrl: 'pulsar://localhost:6650',
+          operationTimeoutSeconds: 30,
+        });
+
+        // test on nonPartitionedTopic
+        const nonPartitionedTopicName = 'test-non-partitioned-topic';
+        const nonPartitionedTopic = `persistent://public/default/${nonPartitionedTopicName}`;
+        const nonPartitionedTopicAdminURL = `${baseUrl}/admin/v2/persistent/public/default/${nonPartitionedTopicName}`;
+        const createNonPartitionedTopicRes = await httpRequest(
+          nonPartitionedTopicAdminURL, {
+            headers: {
+              'Content-Type': 'application/json',
+            },
+            method: 'PUT',
+          },
+        );
+        expect(createNonPartitionedTopicRes.statusCode).toBe(204);
+
+        const nonPartitionedTopicList = await client.getPartitionsForTopic(nonPartitionedTopic);
+        expect(nonPartitionedTopicList).toEqual([nonPartitionedTopic]);
+
+        // test on partitioned with number
+        const partitionedTopicName = 'test-partitioned-topic-1';
+        const partitionedTopic = `persistent://public/default/${partitionedTopicName}`;
+        const partitionedTopicAdminURL = `${baseUrl}/admin/v2/persistent/public/default/${partitionedTopicName}/partitions`;
+        const createPartitionedTopicRes = await httpRequest(
+          partitionedTopicAdminURL, {
+            headers: {
+              'Content-Type': 'text/plain',
+            },
+            data: 4,
+            method: 'PUT',
+          },
+        );
+        expect(createPartitionedTopicRes.statusCode).toBe(204);
+
+        const partitionedTopicList = await client.getPartitionsForTopic(partitionedTopic);
+        expect(partitionedTopicList).toEqual([
+          'persistent://public/default/test-partitioned-topic-1-partition-0',
+          'persistent://public/default/test-partitioned-topic-1-partition-1',
+          'persistent://public/default/test-partitioned-topic-1-partition-2',
+          'persistent://public/default/test-partitioned-topic-1-partition-3',
+        ]);
+
+        const deleteNonPartitionedTopicRes = await httpRequest(nonPartitionedTopicAdminURL, { method: 'DELETE' });
+        expect(deleteNonPartitionedTopicRes.statusCode).toBe(204);
+        const deletePartitionedTopicRes = await httpRequest(partitionedTopicAdminURL, { method: 'DELETE' });
+        expect(deletePartitionedTopicRes.statusCode).toBe(204);
+
+        await client.close();
+      });
+    });
   });
 })();

package/tests/conf/standalone.conf

@@ -59,6 +59,9 @@ backlogQuotaDefaultLimitGB=10
 # Enable the deletion of inactive topics
 brokerDeleteInactiveTopicsEnabled=true
 
+# Enable batch index ACK
+acknowledgmentAtBatchIndexLevelEnabled=true
+
 # How often to check for inactive topics
 brokerDeleteInactiveTopicsFrequencySeconds=60
 

package/tests/consumer.test.js

@@ -102,7 +102,7 @@ const Pulsar = require('../index.js');
           subscription: 'sub1',
           ackTimeoutMs: 10000,
           nAckRedeliverTimeoutMs: 60000,
-        })).rejects.toThrow('Failed to create consumer: BrokerMetadataError');
+        })).rejects.toThrow('Failed to create consumer: TopicNotFound');
       });
 
       test('Not Exist Namespace', async () => {
@@ -111,7 +111,7 @@ const Pulsar = require('../index.js');
           subscription: 'sub1',
           ackTimeoutMs: 10000,
           nAckRedeliverTimeoutMs: 60000,
-        })).rejects.toThrow('Failed to create consumer: BrokerMetadataError');
+        })).rejects.toThrow('Failed to create consumer: TopicNotFound');
       });
 
       test('Not Positive NAckRedeliverTimeout', async () => {
@@ -140,5 +140,181 @@ const Pulsar = require('../index.js');
         await expect(consumer.close()).rejects.toThrow('Failed to close consumer: AlreadyClosed');
       });
     });
+
+    describe('Features', () => {
+      test('Batch index ack', async () => {
+        const topicName = 'test-batch-index-ack';
+        const producer = await client.createProducer({
+          topic: topicName,
+          batchingEnabled: true,
+          batchingMaxMessages: 100,
+          batchingMaxPublishDelayMs: 10000,
+        });
+
+        let consumer = await client.subscribe({
+          topic: topicName,
+          batchIndexAckEnabled: true,
+          subscription: 'test-batch-index-ack',
+        });
+
+        // Make sure send 0~5 is a batch msg.
+        for (let i = 0; i < 5; i += 1) {
+          const msg = `my-message-${i}`;
+          console.log(msg);
+          producer.send({
+            data: Buffer.from(msg),
+          });
+        }
+        await producer.flush();
+
+        // Receive msgs and just ack 0, 1 msgs
+        const results = [];
+        for (let i = 0; i < 5; i += 1) {
+          const msg = await consumer.receive();
+          results.push(msg);
+        }
+        expect(results.length).toEqual(5);
+        for (let i = 0; i < 2; i += 1) {
+          await consumer.acknowledge(results[i]);
+          await new Promise((resolve) => setTimeout(resolve, 200));
+        }
+
+        // Restart consumer after, just receive 2~5 msg.
+        await consumer.close();
+        consumer = await client.subscribe({
+          topic: topicName,
+          batchIndexAckEnabled: true,
+          subscription: 'test-batch-index-ack',
+        });
+        const results2 = [];
+        for (let i = 2; i < 5; i += 1) {
+          const msg = await consumer.receive();
+          results2.push(msg);
+        }
+        expect(results2.length).toEqual(3);
+        // assert no more msgs.
+        await expect(consumer.receive(1000)).rejects.toThrow(
+          'Failed to receive message: TimeOut',
+        );
+      });
+
+      test('Regex subscription', async () => {
+        const topicName1 = 'persistent://public/default/regex-sub-1';
+        const topicName2 = 'persistent://public/default/regex-sub-2';
+        const topicName3 = 'non-persistent://public/default/regex-sub-3';
+        const topicName4 = 'persistent://public/default/no-match-regex-sub-2';
+        const producer1 = await client.createProducer({
+          topic: topicName1,
+        });
+        const producer2 = await client.createProducer({
+          topic: topicName2,
+        });
+        const producer3 = await client.createProducer({
+          topic: topicName3,
+        });
+        const producer4 = await client.createProducer({
+          topic: topicName4,
+        });
+
+        const consumer = await client.subscribe({
+          topicsPattern: 'persistent://public/default/regex-sub.*',
+          subscription: 'sub1',
+          subscriptionType: 'Shared',
+          regexSubscriptionMode: 'AllTopics',
+        });
+
+        const num = 10;
+        for (let i = 0; i < num; i += 1) {
+          const msg = `my-message-${i}`;
+          await producer1.send({ data: Buffer.from(msg) });
+          await producer2.send({ data: Buffer.from(msg) });
+          await producer3.send({ data: Buffer.from(msg) });
+          await producer4.send({ data: Buffer.from(msg) });
+        }
+        const results = [];
+        for (let i = 0; i < 3 * num; i += 1) {
+          const msg = await consumer.receive();
+          results.push(msg.getData().toString());
+        }
+        expect(results.length).toEqual(3 * num);
+        // assert no more msgs.
+        await expect(consumer.receive(1000)).rejects.toThrow(
+          'Failed to receive message: TimeOut',
+        );
+        await producer1.close();
+        await producer2.close();
+        await producer3.close();
+        await producer4.close();
+        await consumer.close();
+      });
+
+      test('Dead Letter topic', async () => {
+        const topicName = 'test-dead_letter_topic';
+        const dlqTopicName = 'test-dead_letter_topic_customize';
+        const producer = await client.createProducer({
+          topic: topicName,
+        });
+
+        const maxRedeliverCountNum = 3;
+        const consumer = await client.subscribe({
+          topic: topicName,
+          subscription: 'sub-1',
+          subscriptionType: 'Shared',
+          deadLetterPolicy: {
+            deadLetterTopic: dlqTopicName,
+            maxRedeliverCount: maxRedeliverCountNum,
+            initialSubscriptionName: 'init-sub-1-dlq',
+          },
+          nAckRedeliverTimeoutMs: 50,
+        });
+
+        // Send messages.
+        const sendNum = 5;
+        const messages = [];
+        for (let i = 0; i < sendNum; i += 1) {
+          const msg = `my-message-${i}`;
+          await producer.send({ data: Buffer.from(msg) });
+          messages.push(msg);
+        }
+
+        // Redelivery all messages maxRedeliverCountNum time.
+        let results = [];
+        for (let i = 1; i <= maxRedeliverCountNum * sendNum + sendNum; i += 1) {
+          const msg = await consumer.receive();
+          results.push(msg);
+          if (i % sendNum === 0) {
+            results.forEach((message) => {
+              console.log(`Redeliver message ${message.getData().toString()} ${i} times ${message.getRedeliveryCount()} redeliver Count`);
+              consumer.negativeAcknowledge(message);
+            });
+            results = [];
+          }
+        }
+        // assert no more msgs.
+        await expect(consumer.receive(100)).rejects.toThrow(
+          'Failed to receive message: TimeOut',
+        );
+
+        const dlqConsumer = await client.subscribe({
+          topic: dlqTopicName,
+          subscription: 'sub-1',
+        });
+        const dlqResult = [];
+        for (let i = 0; i < sendNum; i += 1) {
+          const msg = await dlqConsumer.receive();
+          dlqResult.push(msg.getData().toString());
+        }
+        expect(dlqResult).toEqual(messages);
+
+        // assert no more msgs.
+        await expect(dlqConsumer.receive(500)).rejects.toThrow(
+          'Failed to receive message: TimeOut',
+        );
+
+        producer.close();
+        consumer.close();
+        dlqConsumer.close();
+      });
+    });
   });
 })();

package/tests/end_to_end.test.js

@@ -386,6 +386,66 @@ const Pulsar = require('../index.js');
       await client.close();
     });
 
+    test('Message Listener error handling', async () => {
+      const client = new Pulsar.Client({
+        serviceUrl: 'pulsar://localhost:6650',
+      });
+      let syncFinsh;
+      const syncPromise = new Promise((resolve) => {
+        syncFinsh = resolve;
+      });
+      let asyncFinsh;
+      const asyncPromise = new Promise((resolve) => {
+        asyncFinsh = resolve;
+      });
+      Pulsar.Client.setLogHandler((level, file, line, message) => {
+        if (level === 3) { // should be error level
+          if (message.includes('consumer1 callback expected error')) {
+            syncFinsh();
+          }
+          if (message.includes('consumer2 callback expected error')) {
+            asyncFinsh();
+          }
+        }
+      });
+
+      const topic = 'test-error-listener';
+      const producer = await client.createProducer({
+        topic,
+        batchingEnabled: false,
+      });
+
+      await producer.send('test-message');
+
+      const consumer1 = await client.subscribe({
+        topic,
+        subscription: 'sync',
+        subscriptionType: 'Shared',
+        subscriptionInitialPosition: 'Earliest',
+        listener: (message, messageConsumer) => {
+          throw new Error('consumer1 callback expected error');
+        },
+      });
+
+      const consumer2 = await client.subscribe({
+        topic,
+        subscription: 'async',
+        subscriptionType: 'Shared',
+        subscriptionInitialPosition: 'Earliest',
+        listener: async (message, messageConsumer) => {
+          throw new Error('consumer2 callback expected error');
+        },
+      });
+
+      await syncPromise;
+      await asyncPromise;
+
+      await consumer1.close();
+      await consumer2.close();
+      await producer.close();
+      await client.close();
+    });
+
     test('acknowledgeCumulative', async () => {
       const client = new Pulsar.Client({
         serviceUrl: 'pulsar://localhost:6650',
@@ -929,6 +989,47 @@ const Pulsar = require('../index.js');
       await consumer.close();
       await client.close();
     });
+    test('Basic produce and read encryption', async () => {
+      const client = new Pulsar.Client({
+        serviceUrl: 'pulsar://localhost:6650',
+        operationTimeoutSeconds: 30,
+      });
+
+      const topic = 'persistent://public/default/encryption-produce-read';
+      const producer = await client.createProducer({
+        topic,
+        sendTimeoutMs: 30000,
+        batchingEnabled: true,
+        publicKeyPath: `${__dirname}/certificate/public-key.client-rsa.pem`,
+        encryptionKey: 'encryption-key',
+      });
+
+      const reader = await client.createReader({
+        topic,
+        startMessageId: Pulsar.MessageId.earliest(),
+        privateKeyPath: `${__dirname}/certificate/private-key.client-rsa.pem`,
+      });
+
+      const messages = [];
+      for (let i = 0; i < 10; i += 1) {
+        const msg = `my-message-${i}`;
+        producer.send({
+          data: Buffer.from(msg),
+        });
+        messages.push(msg);
+      }
+      await producer.flush();
+
+      const results = [];
+      for (let i = 0; i < 10; i += 1) {
+        const msg = await reader.readNext();
+        results.push(msg.getData().toString());
+      }
+      expect(lodash.difference(messages, results)).toEqual([]);
+      await producer.close();
+      await reader.close();
+      await client.close();
+    });
     test('Produce/Consume/Read/IsConnected', async () => {
       const client = new Pulsar.Client({
         serviceUrl: 'pulsar://localhost:6650',

package/tests/http_utils.js

@@ -0,0 +1,45 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+const http = require('http');
+
+const request = (url, { headers, data = {}, method }) => new Promise((resolve, reject) => {
+  const req = http.request(url, {
+    headers,
+    method,
+  }, (res) => {
+    let responseBody = '';
+    res.on('data', (chunk) => {
+      responseBody += chunk;
+    });
+    res.on('end', () => {
+      resolve({ responseBody, statusCode: res.statusCode });
+    });
+  });
+
+  req.on('error', (error) => {
+    reject(error);
+  });
+
+  req.write(JSON.stringify(data));
+
+  req.end();
+});
+
+module.exports = request;

package/tests/producer.test.js

@@ -55,7 +55,7 @@ const Pulsar = require('../index.js');
           topic: 'persistent://no-tenant/namespace/topic',
           sendTimeoutMs: 30000,
           batchingEnabled: true,
-        })).rejects.toThrow('Failed to create producer: BrokerMetadataError');
+        })).rejects.toThrow('Failed to create producer: TopicNotFound');
       });
 
       test('Not Exist Namespace', async () => {
@@ -63,7 +63,7 @@ const Pulsar = require('../index.js');
           topic: 'persistent://public/no-namespace/topic',
           sendTimeoutMs: 30000,
           batchingEnabled: true,
-        })).rejects.toThrow('Failed to create producer: BrokerMetadataError');
+        })).rejects.toThrow('Failed to create producer: TopicNotFound');
       });
 
       test('Automatic Producer Name', async () => {
@@ -94,5 +94,67 @@ const Pulsar = require('../index.js');
         await producer.close();
       });
     });
+    describe('Access Mode', () => {
+      test('Exclusive', async () => {
+        const topicName = 'test-access-mode-exclusive';
+        const producer1 = await client.createProducer({
+          topic: topicName,
+          producerName: 'p-1',
+          accessMode: 'Exclusive',
+        });
+        expect(producer1.getProducerName()).toBe('p-1');
+
+        await expect(client.createProducer({
+          topic: topicName,
+          producerName: 'p-2',
+          accessMode: 'Exclusive',
+        })).rejects.toThrow('Failed to create producer: ResultProducerFenced');
+
+        await producer1.close();
+      });
+
+      test('WaitForExclusive', async () => {
+        const topicName = 'test-access-mode-wait-for-exclusive';
+        const producer1 = await client.createProducer({
+          topic: topicName,
+          producerName: 'p-1',
+          accessMode: 'Exclusive',
+        });
+        expect(producer1.getProducerName()).toBe('p-1');
+        // async close producer1
+        producer1.close();
+        // when p1 close, p2 success created.
+        const producer2 = await client.createProducer({
+          topic: topicName,
+          producerName: 'p-2',
+          accessMode: 'WaitForExclusive',
+        });
+        expect(producer2.getProducerName()).toBe('p-2');
+        await producer2.close();
+      });
+
+      test('ExclusiveWithFencing', async () => {
+        const topicName = 'test-access-mode';
+        const producer1 = await client.createProducer({
+          topic: topicName,
+          producerName: 'p-1',
+          accessMode: 'Exclusive',
+        });
+        expect(producer1.getProducerName()).toBe('p-1');
+        const producer2 = await client.createProducer({
+          topic: topicName,
+          producerName: 'p-2',
+          accessMode: 'ExclusiveWithFencing',
+        });
+        expect(producer2.getProducerName()).toBe('p-2');
+        // producer1 will be fenced.
+        await expect(
+          producer1.send({
+            data: Buffer.from('test-msg'),
+          }),
+        ).rejects.toThrow('Failed to send message: ResultProducerFenced');
+        await producer2.close();
+      });
+    });
   });
 })();