wehub/apache--brpc
1
0
Fork 0
Code Issues Pull Requests Actions Deployments Models Agent Notes Packages Projects Releases Wiki Activity

chore: import upstream snapshot with attribution

Browse Source
This commit is contained in:
wehub-resource-sync
2026-07-13 13:29:29 +08:00
commit f52cf32e56
1718 changed files with 366293 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/brpc_mysql_txn_integration_unittest.cpp
+605
View File
@@ -0,0 +1,605 @@
// 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.
// MySQL client TRANSACTION integration tests, run through brpc's PUBLIC API
// against a REAL mysqld.
//
// Each TEST_F drives a transaction scenario end to end:
// * brpc::Channel(protocol="mysql", connection_type="pooled",
// auth=MysqlAuthenticator) -> a live connection to the server;
// * brpc::NewMysqlTransaction(channel, opts) -> a connection-pinned
// transaction handle (START TRANSACTION on a dedicated socket);
// * MysqlRequest(tx).Query(...) + channel.CallMethod(...) -> statements
// INSIDE the transaction (same pinned socket);
// * MysqlRequest().Query(...) on the SAME channel -> a SECOND connection
// from the pool, used as an independent observer to prove isolation
// (uncommitted rows are invisible until commit());
// * tx->commit() / tx->rollback() -> terminate the transaction.
//
// Because transactions, simple SELECTs and DML all flow through the same
// COM_QUERY text protocol, these tests also cover simple-query execution
// and text-result parsing (column metadata + row field decoding).
//
// Harness (server spawn / skip convention, -mysql_use_running_server and
// -mysql_host/-port/-user/-password gflags) follows
// test/mysql/brpc_mysql_auth_handshake_unittest.cpp and, transitively,
// test/brpc_redis_unittest.cpp's which-then-spawn pattern. When mysqld is
// absent every test GTEST_SKIP()s, so the file is CI-safe with no server.
#include <gflags/gflags.h>
#include <gtest/gtest.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <unistd.h>
#include <cstdio>
#include <cstdlib>
#include <pthread.h>
#include <string>
#include "brpc/channel.h"
#include "brpc/policy/mysql/mysql.h"
#include "brpc/policy/mysql/mysql_transaction.h"
#include "brpc/policy/mysql/mysql_authenticator.h"
#include "butil/logging.h"
// These gflags are intentionally re-declared here (not shared with the auth
// unittest): the CMake glob at test/CMakeLists.txt builds each
// brpc_mysql_*_unittest.cpp into its OWN executable, so there is no symbol
// collision across test binaries.
DEFINE_bool(mysql_use_running_server, false,
"Use an already-running MySQL server instead of spawning a "
"throwaway one; the running server is neither started nor stopped "
"by the test.");
DEFINE_string(mysql_host, "127.0.0.1",
"Host of the running MySQL server "
"(only with -mysql_use_running_server).");
DEFINE_int32(mysql_port, 13306,
"TCP port of the MySQL server (used for both the running server "
"and the spawned throwaway server).");
DEFINE_string(mysql_user, "root", "Login user for the transaction tests.");
DEFINE_string(mysql_password, "",
"Password for -mysql_user (empty for the spawned server).");
DEFINE_string(mysql_schema, "brpc_txn_test",
"Schema (database) the transaction tests create and use.");
namespace {
// Throwaway-server harness (mirrors brpc_mysql_auth_handshake_unittest.cpp,
// which mirrors brpc_redis_unittest.cpp). >0: forked pid; -2: external
// running server reachable; -1: no server -> tests skip.
#define MYSQLD_BIN "mysqld"
static pthread_once_t s_start_once = PTHREAD_ONCE_INIT;
static pid_t s_mysqld_pid = -1;
static std::string s_host = "127.0.0.1";
static int s_port = 13306;
static std::string s_user = "root";
static std::string s_password;
static std::string TestDataDir() {
char cwd[1024];
if (getcwd(cwd, sizeof(cwd)) == NULL) {
return std::string("/tmp/mysql_txn_data_for_test");
}
return std::string(cwd) + "/mysql_txn_data_for_test";
}
static void RemoveMysqlServer() {
if (s_mysqld_pid > 0) {
puts("[Stopping mysqld]");
char cmd[1280];
snprintf(cmd, sizeof(cmd), "kill %d", s_mysqld_pid);
CHECK(0 == system(cmd));
usleep(500000);
snprintf(cmd, sizeof(cmd), "rm -rf '%s'", TestDataDir().c_str());
CHECK(0 == system(cmd));
}
}
// Raw TCP probe to detect server readiness; returns fd (caller closes) or -1.
static int ProbeMysql() {
int fd = socket(AF_INET, SOCK_STREAM, 0);
if (fd < 0) {
return -1;
}
struct sockaddr_in addr;
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(static_cast<uint16_t>(s_port));
addr.sin_addr.s_addr = inet_addr(s_host.c_str());
if (connect(fd, (struct sockaddr*)&addr, sizeof(addr)) != 0) {
close(fd);
return -1;
}
return fd;
}
static void RunMysqlServer() {
if (FLAGS_mysql_use_running_server) {
s_host = FLAGS_mysql_host;
s_port = FLAGS_mysql_port;
s_user = FLAGS_mysql_user;
s_password = FLAGS_mysql_password;
printf("[Using running mysqld at %s:%d as user '%s']\n",
s_host.c_str(), s_port, s_user.c_str());
int fd = ProbeMysql();
if (fd >= 0) {
close(fd);
s_mysqld_pid = -2;
} else {
printf("Cannot reach running mysqld at %s:%d, tests will skip\n",
s_host.c_str(), s_port);
}
return;
}
if (system("which " MYSQLD_BIN) != 0) {
puts("Fail to find " MYSQLD_BIN ", transaction tests will be skipped");
return;
}
s_host = "127.0.0.1";
s_port = FLAGS_mysql_port;
s_user = "root";
s_password.clear();
const std::string datadir = TestDataDir();
char cmd[2048];
snprintf(cmd, sizeof(cmd), "rm -rf '%s' && mkdir -p '%s'",
datadir.c_str(), datadir.c_str());
if (system(cmd) != 0) {
puts("Fail to create datadir, transaction tests will be skipped");
return;
}
snprintf(cmd, sizeof(cmd),
MYSQLD_BIN " --initialize-insecure --datadir='%s'"
" --log-error='%s/init.err'",
datadir.c_str(), datadir.c_str());
if (system(cmd) != 0) {
puts("Fail to initialize mysqld datadir, tests will be skipped");
snprintf(cmd, sizeof(cmd), "rm -rf '%s'", datadir.c_str());
CHECK(0 == system(cmd));
return;
}
atexit(RemoveMysqlServer);
s_mysqld_pid = fork();
if (s_mysqld_pid < 0) {
puts("Fail to fork");
exit(1);
} else if (s_mysqld_pid == 0) {
puts("[Starting mysqld]");
char port_arg[32];
snprintf(port_arg, sizeof(port_arg), "--port=%d", FLAGS_mysql_port);
const std::string datadir_arg = "--datadir=" + datadir;
const std::string socket_arg = "--socket=" + datadir + "/mysqld.sock";
const std::string pidfile_arg = "--pid-file=" + datadir + "/mysqld.pid";
const std::string logerr_arg = "--log-error=" + datadir + "/mysqld.err";
char* const argv[] = {
(char*)MYSQLD_BIN,
(char*)datadir_arg.c_str(),
(char*)port_arg,
(char*)socket_arg.c_str(),
(char*)pidfile_arg.c_str(),
(char*)logerr_arg.c_str(),
(char*)"--mysqlx=OFF",
(char*)"--bind-address=127.0.0.1",
NULL};
if (execvp(MYSQLD_BIN, argv) < 0) {
puts("Fail to run " MYSQLD_BIN);
exit(1);
}
}
// Wait for TCP readiness (fresh tablespace recovery), then create a
// password account so the caching_sha2 client can authenticate over TCP
// exactly like the running-server mode. root keeps its empty password on
// the unix socket; we exercise the spawned server as empty-password root.
for (int i = 0; i < 300; ++i) {
int fd = ProbeMysql();
if (fd >= 0) {
close(fd);
return;
}
usleep(100000);
}
puts("mysqld did not become ready, transaction tests will be skipped");
s_mysqld_pid = -1;
}
// Small helpers over the brpc MySQL public API.
// Runs |sql| outside any transaction on |channel| (a fresh pooled
// connection). Returns false on transport failure.
static bool RunPlain(brpc::Channel& channel, const std::string& sql,
brpc::MysqlResponse* resp) {
brpc::MysqlRequest req;
if (!req.Query(sql)) {
return false;
}
brpc::Controller cntl;
channel.CallMethod(NULL, &cntl, &req, resp, NULL);
return !cntl.Failed();
}
// Runs |sql| INSIDE transaction |tx| (its pinned connection). Returns false
// on transport failure.
static bool RunInTx(brpc::Channel& channel, const brpc::MysqlTransaction* tx,
const std::string& sql, brpc::MysqlResponse* resp) {
brpc::MysqlRequest req(tx);
if (!req.Query(sql)) {
return false;
}
brpc::Controller cntl;
channel.CallMethod(NULL, &cntl, &req, resp, NULL);
return !cntl.Failed();
}
// Convenience: expects a single OK reply for a DML/DDL statement.
static ::testing::AssertionResult ExpectOk(const brpc::MysqlResponse& resp) {
if (resp.reply_size() < 1) {
return ::testing::AssertionFailure() << "no reply";
}
const brpc::MysqlReply& r = resp.reply(0);
if (r.is_error()) {
return ::testing::AssertionFailure()
<< "ERR " << r.error().errcode() << ": "
<< r.error().msg().as_string();
}
if (!r.is_ok()) {
return ::testing::AssertionFailure() << "reply is not OK, type=" << r.type();
}
return ::testing::AssertionSuccess();
}
// Returns the row count of the FIRST reply, asserting it is a result set.
// On any non-resultset reply returns -1 (so callers can fail clearly).
static int64_t ResultRowCount(const brpc::MysqlResponse& resp) {
if (resp.reply_size() < 1) {
return -1;
}
const brpc::MysqlReply& r = resp.reply(0);
if (!r.is_resultset()) {
return -1;
}
return static_cast<int64_t>(r.row_count());
}
// Fixture: one channel + a scratch table per test (built in SetUp, dropped in
// TearDown). InnoDB so DML is transactional.
class MysqlTxnIntegrationTest : public testing::Test {
protected:
static bool NoServer() { return s_mysqld_pid == -1; }
void SetUp() override {
pthread_once(&s_start_once, RunMysqlServer);
if (NoServer()) {
GTEST_SKIP() << "no mysqld available; skipping transaction tests";
}
// Authenticator carries user/password and the working schema. An
// empty schema is created first over a schema-less channel.
ASSERT_TRUE(InitChannel(&_setup_channel, /*schema=*/""));
brpc::MysqlResponse resp;
ASSERT_TRUE(RunPlain(_setup_channel, "CREATE DATABASE IF NOT EXISTS " +
FLAGS_mysql_schema, &resp));
ASSERT_TRUE(InitChannel(&_channel, FLAGS_mysql_schema));
ASSERT_TRUE(RunPlain(_channel, "DROP TABLE IF EXISTS " + Table(), &resp));
ASSERT_TRUE(ExpectOk(resp)) << "drop pre-existing scratch table";
ASSERT_TRUE(RunPlain(_channel,
"CREATE TABLE " + Table() +
" (id INT PRIMARY KEY, name VARCHAR(32)) "
"ENGINE=InnoDB",
&resp));
ASSERT_TRUE(ExpectOk(resp)) << "create scratch table";
}
void TearDown() override {
if (NoServer()) {
return;
}
brpc::MysqlResponse resp;
RunPlain(_channel, "DROP TABLE IF EXISTS " + Table(), &resp);
}
// Pooled channel is required so a transaction can pin its own dedicated
// connection while the test issues independent observer queries on others.
bool InitChannel(brpc::Channel* channel, const std::string& schema) {
_auth.reset(new brpc::policy::MysqlAuthenticator(s_user, s_password,
schema));
brpc::ChannelOptions options;
options.protocol = "mysql";
options.connection_type = "pooled";
options.auth = _auth.get();
options.timeout_ms = 5000;
options.max_retry = 0;
char addr[128];
snprintf(addr, sizeof(addr), "%s:%d", s_host.c_str(), s_port);
return channel->Init(addr, &options) == 0;
}
std::string Table() const { return "txn_scratch"; }
brpc::Channel _setup_channel;
brpc::Channel _channel;
// Authenticator must outlive the channels that point at it.
std::unique_ptr<brpc::policy::MysqlAuthenticator> _auth;
};
// Test cases. Each fat test chains several transactional behaviors so a single
// TEST_F validates a whole group of related transaction guarantees together.
// Transaction lifecycle: commit publishes a row to other connections, and a
// rolled-back insert as well as a rolled-back delete leave the table exactly as
// it was before the transaction started.
TEST_F(MysqlTxnIntegrationTest, CommitPublishesRollbackRestores) {
brpc::MysqlResponse resp;
// 1) committed INSERT must be visible on a fresh connection afterwards.
{
brpc::MysqlTransactionUniquePtr tx =
brpc::NewMysqlTransaction(_channel, brpc::MysqlTransactionOptions());
ASSERT_TRUE(tx != NULL) << "failed to start transaction";
ASSERT_TRUE(RunInTx(_channel, tx.get(),
"INSERT INTO " + Table() + " VALUES (3107, 'quill')",
&resp));
EXPECT_TRUE(ExpectOk(resp));
EXPECT_EQ(resp.reply(0).ok().affect_row(), 1u);
ASSERT_TRUE(tx->commit());
}
ASSERT_TRUE(RunPlain(_channel, "SELECT id, name FROM " + Table(), &resp));
EXPECT_EQ(ResultRowCount(resp), 1);
{
const brpc::MysqlReply& r = resp.reply(0);
ASSERT_TRUE(r.is_resultset());
ASSERT_EQ(r.row_count(), 1u);
const brpc::MysqlReply::Row& row = r.next();
ASSERT_EQ(row.field_count(), 2u);
EXPECT_EQ(row.field(0).sinteger(), 3107);
EXPECT_EQ(row.field(1).string().as_string(), "quill");
}
// 2) a rolled-back INSERT must leave no trace (still exactly one row).
{
brpc::MysqlTransactionUniquePtr tx =
brpc::NewMysqlTransaction(_channel, brpc::MysqlTransactionOptions());
ASSERT_TRUE(tx != NULL);
ASSERT_TRUE(RunInTx(_channel, tx.get(),
"INSERT INTO " + Table() + " VALUES (5288, 'brindle')",
&resp));
EXPECT_TRUE(ExpectOk(resp));
ASSERT_TRUE(tx->rollback());
}
ASSERT_TRUE(RunPlain(_channel, "SELECT id FROM " + Table(), &resp));
EXPECT_EQ(ResultRowCount(resp), 1) << "rolled-back insert must vanish";
// 3) a rolled-back DELETE of the committed row must restore it.
{
brpc::MysqlTransactionUniquePtr tx =
brpc::NewMysqlTransaction(_channel, brpc::MysqlTransactionOptions());
ASSERT_TRUE(tx != NULL);
ASSERT_TRUE(RunInTx(_channel, tx.get(),
"DELETE FROM " + Table() + " WHERE id = 3107", &resp));
EXPECT_TRUE(ExpectOk(resp));
EXPECT_EQ(resp.reply(0).ok().affect_row(), 1u);
ASSERT_TRUE(tx->rollback());
}
ASSERT_TRUE(RunPlain(_channel, "SELECT id FROM " + Table(), &resp));
EXPECT_EQ(ResultRowCount(resp), 1) << "rolled-back delete must restore row";
{
const brpc::MysqlReply& r = resp.reply(0);
ASSERT_TRUE(r.is_resultset());
ASSERT_EQ(r.row_count(), 1u);
EXPECT_EQ(r.next().field(0).sinteger(), 3107);
}
}
// Isolation in both directions on the same open transaction: the transaction
// reads its own not-yet-committed write on its pinned connection, while an
// independent pooled connection sees nothing until the rollback.
TEST_F(MysqlTxnIntegrationTest, OwnWriteVisibleOthersIsolated) {
brpc::MysqlTransactionUniquePtr tx =
brpc::NewMysqlTransaction(_channel, brpc::MysqlTransactionOptions());
ASSERT_TRUE(tx != NULL);
brpc::MysqlResponse resp;
ASSERT_TRUE(RunInTx(_channel, tx.get(),
"INSERT INTO " + Table() + " VALUES (6741, 'tangle')",
&resp));
EXPECT_TRUE(ExpectOk(resp));
// Same pinned connection: must read its own uncommitted row.
ASSERT_TRUE(RunInTx(_channel, tx.get(),
"SELECT name FROM " + Table() + " WHERE id = 6741", &resp));
EXPECT_EQ(ResultRowCount(resp), 1);
{
const brpc::MysqlReply& r = resp.reply(0);
ASSERT_TRUE(r.is_resultset());
ASSERT_EQ(r.row_count(), 1u);
EXPECT_EQ(r.next().field(0).string().as_string(), "tangle");
}
// A different pooled connection must NOT see the uncommitted write.
ASSERT_TRUE(RunPlain(_channel, "SELECT id FROM " + Table(), &resp));
EXPECT_EQ(ResultRowCount(resp), 0)
<< "uncommitted write leaked to another connection";
ASSERT_TRUE(tx->rollback());
// After rollback nothing remains anywhere.
ASSERT_TRUE(RunPlain(_channel, "SELECT id FROM " + Table(), &resp));
EXPECT_EQ(ResultRowCount(resp), 0);
}
// Autocommit behavior, both states in one test: with autocommit on (the
// default) a bare INSERT is immediately durable on a new connection; toggling
// autocommit off on a pinned connection turns a later INSERT into pending work
// that ROLLBACK discards.
TEST_F(MysqlTxnIntegrationTest, AutocommitOnDurableOffRollbackable) {
brpc::MysqlResponse resp;
// autocommit ON: immediate durability.
ASSERT_TRUE(RunPlain(_channel,
"INSERT INTO " + Table() + " VALUES (4419, 'amber')",
&resp));
EXPECT_TRUE(ExpectOk(resp));
ASSERT_TRUE(RunPlain(_channel, "SELECT id FROM " + Table(), &resp));
EXPECT_EQ(ResultRowCount(resp), 1);
// autocommit OFF on a pinned connection: a new INSERT is pending and a
// ROLLBACK drops only it, leaving the earlier durable row in place.
{
brpc::MysqlTransactionUniquePtr tx =
brpc::NewMysqlTransaction(_channel, brpc::MysqlTransactionOptions());
ASSERT_TRUE(tx != NULL);
ASSERT_TRUE(RunInTx(_channel, tx.get(), "SET autocommit = 0", &resp));
EXPECT_TRUE(ExpectOk(resp));
ASSERT_TRUE(RunInTx(_channel, tx.get(),
"INSERT INTO " + Table() + " VALUES (8053, 'frost')",
&resp));
EXPECT_TRUE(ExpectOk(resp));
ASSERT_TRUE(tx->rollback());
}
ASSERT_TRUE(RunPlain(_channel, "SELECT id FROM " + Table(), &resp));
EXPECT_EQ(ResultRowCount(resp), 1)
<< "autocommit=0 + rollback should drop only the pending insert";
EXPECT_EQ(resp.reply(0).next().field(0).sinteger(), 4419);
}
// Multi-statement transactional grouping plus partial undo: two inserts grouped
// under one transaction become visible together only after commit, and within a
// second transaction a SAVEPOINT lets a later insert be peeled back while the
// pre-savepoint work survives the final commit.
TEST_F(MysqlTxnIntegrationTest, GroupedInsertsThenSavepointPartialUndo) {
brpc::MysqlResponse resp;
// Two inserts under one transaction: invisible until commit, then both show.
{
brpc::MysqlTransactionUniquePtr tx =
brpc::NewMysqlTransaction(_channel, brpc::MysqlTransactionOptions());
ASSERT_TRUE(tx != NULL);
ASSERT_TRUE(RunInTx(_channel, tx.get(),
"INSERT INTO " + Table() + " VALUES (211, 'one')",
&resp));
EXPECT_TRUE(ExpectOk(resp));
ASSERT_TRUE(RunInTx(_channel, tx.get(),
"INSERT INTO " + Table() + " VALUES (733, 'two')",
&resp));
EXPECT_TRUE(ExpectOk(resp));
// Not yet visible to a separate connection.
ASSERT_TRUE(RunPlain(_channel, "SELECT id FROM " + Table(), &resp));
EXPECT_EQ(ResultRowCount(resp), 0);
ASSERT_TRUE(tx->commit());
}
ASSERT_TRUE(RunPlain(_channel, "SELECT id FROM " + Table(), &resp));
EXPECT_EQ(ResultRowCount(resp), 2) << "both grouped inserts visible";
// Start fresh for the savepoint half.
ASSERT_TRUE(RunPlain(_channel, "DELETE FROM " + Table(), &resp));
ASSERT_TRUE(ExpectOk(resp));
// SAVEPOINT then ROLLBACK TO it: pre-savepoint row kept, post dropped.
{
brpc::MysqlTransactionUniquePtr tx =
brpc::NewMysqlTransaction(_channel, brpc::MysqlTransactionOptions());
ASSERT_TRUE(tx != NULL);
ASSERT_TRUE(RunInTx(_channel, tx.get(),
"INSERT INTO " + Table() + " VALUES (901, 'kept')",
&resp));
EXPECT_TRUE(ExpectOk(resp));
ASSERT_TRUE(RunInTx(_channel, tx.get(), "SAVEPOINT mark1", &resp));
EXPECT_TRUE(ExpectOk(resp));
ASSERT_TRUE(RunInTx(_channel, tx.get(),
"INSERT INTO " + Table() + " VALUES (902, 'gone')",
&resp));
EXPECT_TRUE(ExpectOk(resp));
ASSERT_TRUE(RunInTx(_channel, tx.get(), "ROLLBACK TO SAVEPOINT mark1",
&resp));
EXPECT_TRUE(ExpectOk(resp));
// Inside the txn only the pre-savepoint row remains.
ASSERT_TRUE(RunInTx(_channel, tx.get(), "SELECT id FROM " + Table(),
&resp));
EXPECT_EQ(ResultRowCount(resp), 1);
ASSERT_TRUE(tx->commit());
}
ASSERT_TRUE(RunPlain(_channel, "SELECT id FROM " + Table(), &resp));
EXPECT_EQ(ResultRowCount(resp), 1) << "only the kept row should persist";
{
const brpc::MysqlReply& r = resp.reply(0);
ASSERT_TRUE(r.is_resultset());
ASSERT_EQ(r.row_count(), 1u);
EXPECT_EQ(r.next().field(0).sinteger(), 901);
}
}
// Error surfaces from within a transaction: a duplicate-primary-key insert
// returns an ERR reply (and the transaction still rolls back cleanly), and a
// write attempted in a read-only transaction is likewise rejected with ERR.
TEST_F(MysqlTxnIntegrationTest, DuplicateKeyAndReadOnlyWriteReportErr) {
brpc::MysqlResponse resp;
// Seed a committed row so the in-txn insert collides on the primary key.
ASSERT_TRUE(RunPlain(_channel,
"INSERT INTO " + Table() + " VALUES (1505, 'seed')",
&resp));
ASSERT_TRUE(ExpectOk(resp));
{
brpc::MysqlTransactionUniquePtr tx =
brpc::NewMysqlTransaction(_channel, brpc::MysqlTransactionOptions());
ASSERT_TRUE(tx != NULL);
// Duplicate-key insert -> ERR packet (errno 1062, ER_DUP_ENTRY).
ASSERT_TRUE(RunInTx(_channel, tx.get(),
"INSERT INTO " + Table() + " VALUES (1505, 'clash')",
&resp));
ASSERT_GE(resp.reply_size(), 1u);
const brpc::MysqlReply& r = resp.reply(0);
EXPECT_TRUE(r.is_error()) << "duplicate key should yield an ERR reply";
if (r.is_error()) {
EXPECT_EQ(r.error().errcode(), 1062) << "expected ER_DUP_ENTRY (1062)";
}
ASSERT_TRUE(tx->rollback());
}
// A read-only transaction must reject a write.
{
brpc::MysqlTransactionOptions opts;
opts.readonly = true;
brpc::MysqlTransactionUniquePtr tx =
brpc::NewMysqlTransaction(_channel, opts);
ASSERT_TRUE(tx != NULL) << "failed to start read-only transaction";
ASSERT_TRUE(RunInTx(_channel, tx.get(),
"INSERT INTO " + Table() + " VALUES (1777, 'nope')",
&resp));
ASSERT_GE(resp.reply_size(), 1u);
const brpc::MysqlReply& r = resp.reply(0);
EXPECT_TRUE(r.is_error())
<< "write in a read-only transaction should be rejected with ERR";
if (r.is_error()) {
// ER_CANT_EXECUTE_IN_READ_ONLY_TRANSACTION == 1792.
EXPECT_EQ(r.error().errcode(), 1792)
<< "expected read-only-transaction error (1792)";
}
ASSERT_TRUE(tx->rollback());
}
}
} // namespace