xrpld
Loading...
Searching...
No Matches
LoanBrokerSetTests.cpp
1// Auto-generated unit tests for transaction LoanBrokerSet
2
3
4#include <gtest/gtest.h>
5
6#include <protocol_autogen/TestHelpers.h>
7
8#include <xrpl/protocol/SecretKey.h>
9#include <xrpl/protocol/Seed.h>
10#include <xrpl/protocol/STTx.h>
11#include <xrpl/protocol_autogen/transactions/LoanBrokerSet.h>
12#include <xrpl/protocol_autogen/transactions/AccountSet.h>
13
14#include <string>
15
16namespace xrpl::transactions {
17
18// 1 & 4) Set fields via builder setters, build, then read them back via
19// wrapper getters. After build(), validate() should succeed.
20TEST(TransactionsLoanBrokerSetTests, BuilderSettersRoundTrip)
21{
22 // Generate a deterministic keypair for signing
23 auto const [publicKey, secretKey] =
24 generateKeyPair(KeyType::Secp256k1, generateSeed("testLoanBrokerSet"));
25
26 // Common transaction fields
27 auto const accountValue = calcAccountID(publicKey);
28 std::uint32_t const sequenceValue = 1;
29 auto const feeValue = canonical_AMOUNT();
30
31 // Transaction-specific field values
32 auto const vaultIDValue = canonical_UINT256();
33 auto const loanBrokerIDValue = canonical_UINT256();
34 auto const dataValue = canonical_VL();
35 auto const managementFeeRateValue = canonical_UINT16();
36 auto const debtMaximumValue = canonical_NUMBER();
37 auto const coverRateMinimumValue = canonical_UINT32();
38 auto const coverRateLiquidationValue = canonical_UINT32();
39 auto const domainIDValue = canonical_UINT256();
40
42 accountValue,
43 vaultIDValue,
44 sequenceValue,
45 feeValue
46 };
47
48 // Set optional fields
49 builder.setLoanBrokerID(loanBrokerIDValue);
50 builder.setData(dataValue);
51 builder.setManagementFeeRate(managementFeeRateValue);
52 builder.setDebtMaximum(debtMaximumValue);
53 builder.setCoverRateMinimum(coverRateMinimumValue);
54 builder.setCoverRateLiquidation(coverRateLiquidationValue);
55 builder.setDomainID(domainIDValue);
56
57 auto tx = builder.build(publicKey, secretKey);
58
59 std::string reason;
60 EXPECT_TRUE(tx.validate(reason)) << reason;
61
62 // Verify signing was applied
63 EXPECT_FALSE(tx.getSigningPubKey().empty());
64 EXPECT_TRUE(tx.hasTxnSignature());
65
66 // Verify common fields
67 EXPECT_EQ(tx.getAccount(), accountValue);
68 EXPECT_EQ(tx.getSequence(), sequenceValue);
69 EXPECT_EQ(tx.getFee(), feeValue);
70
71 // Verify required fields
72 {
73 auto const& expected = vaultIDValue;
74 auto const actual = tx.getVaultID();
75 expectEqualField(expected, actual, "sfVaultID");
76 }
77
78 // Verify optional fields
79 {
80 auto const& expected = loanBrokerIDValue;
81 auto const actualOpt = tx.getLoanBrokerID();
82 ASSERT_TRUE(actualOpt.has_value()) << "Optional field sfLoanBrokerID should be present";
83 expectEqualField(expected, *actualOpt, "sfLoanBrokerID");
84 EXPECT_TRUE(tx.hasLoanBrokerID());
85 }
86
87 {
88 auto const& expected = dataValue;
89 auto const actualOpt = tx.getData();
90 ASSERT_TRUE(actualOpt.has_value()) << "Optional field sfData should be present";
91 expectEqualField(expected, *actualOpt, "sfData");
92 EXPECT_TRUE(tx.hasData());
93 }
94
95 {
96 auto const& expected = managementFeeRateValue;
97 auto const actualOpt = tx.getManagementFeeRate();
98 ASSERT_TRUE(actualOpt.has_value()) << "Optional field sfManagementFeeRate should be present";
99 expectEqualField(expected, *actualOpt, "sfManagementFeeRate");
100 EXPECT_TRUE(tx.hasManagementFeeRate());
101 }
102
103 {
104 auto const& expected = debtMaximumValue;
105 auto const actualOpt = tx.getDebtMaximum();
106 ASSERT_TRUE(actualOpt.has_value()) << "Optional field sfDebtMaximum should be present";
107 expectEqualField(expected, *actualOpt, "sfDebtMaximum");
108 EXPECT_TRUE(tx.hasDebtMaximum());
109 }
110
111 {
112 auto const& expected = coverRateMinimumValue;
113 auto const actualOpt = tx.getCoverRateMinimum();
114 ASSERT_TRUE(actualOpt.has_value()) << "Optional field sfCoverRateMinimum should be present";
115 expectEqualField(expected, *actualOpt, "sfCoverRateMinimum");
116 EXPECT_TRUE(tx.hasCoverRateMinimum());
117 }
118
119 {
120 auto const& expected = coverRateLiquidationValue;
121 auto const actualOpt = tx.getCoverRateLiquidation();
122 ASSERT_TRUE(actualOpt.has_value()) << "Optional field sfCoverRateLiquidation should be present";
123 expectEqualField(expected, *actualOpt, "sfCoverRateLiquidation");
124 EXPECT_TRUE(tx.hasCoverRateLiquidation());
125 }
126
127 {
128 auto const& expected = domainIDValue;
129 auto const actualOpt = tx.getDomainID();
130 ASSERT_TRUE(actualOpt.has_value()) << "Optional field sfDomainID should be present";
131 expectEqualField(expected, *actualOpt, "sfDomainID");
132 EXPECT_TRUE(tx.hasDomainID());
133 }
134
135}
136
137// 2 & 4) Start from an STTx, construct a builder from it, build a new wrapper,
138// and verify all fields match.
139TEST(TransactionsLoanBrokerSetTests, BuilderFromStTxRoundTrip)
140{
141 // Generate a deterministic keypair for signing
142 auto const [publicKey, secretKey] =
143 generateKeyPair(KeyType::Secp256k1, generateSeed("testLoanBrokerSetFromTx"));
144
145 // Common transaction fields
146 auto const accountValue = calcAccountID(publicKey);
147 std::uint32_t const sequenceValue = 2;
148 auto const feeValue = canonical_AMOUNT();
149
150 // Transaction-specific field values
151 auto const vaultIDValue = canonical_UINT256();
152 auto const loanBrokerIDValue = canonical_UINT256();
153 auto const dataValue = canonical_VL();
154 auto const managementFeeRateValue = canonical_UINT16();
155 auto const debtMaximumValue = canonical_NUMBER();
156 auto const coverRateMinimumValue = canonical_UINT32();
157 auto const coverRateLiquidationValue = canonical_UINT32();
158 auto const domainIDValue = canonical_UINT256();
159
160 // Build an initial transaction
161 LoanBrokerSetBuilder initialBuilder{
162 accountValue,
163 vaultIDValue,
164 sequenceValue,
165 feeValue
166 };
167
168 initialBuilder.setLoanBrokerID(loanBrokerIDValue);
169 initialBuilder.setData(dataValue);
170 initialBuilder.setManagementFeeRate(managementFeeRateValue);
171 initialBuilder.setDebtMaximum(debtMaximumValue);
172 initialBuilder.setCoverRateMinimum(coverRateMinimumValue);
173 initialBuilder.setCoverRateLiquidation(coverRateLiquidationValue);
174 initialBuilder.setDomainID(domainIDValue);
175
176 auto initialTx = initialBuilder.build(publicKey, secretKey);
177
178 // Create builder from existing STTx
179 LoanBrokerSetBuilder builderFromTx{initialTx.getSTTx()};
180
181 auto rebuiltTx = builderFromTx.build(publicKey, secretKey);
182
183 std::string reason;
184 EXPECT_TRUE(rebuiltTx.validate(reason)) << reason;
185
186 // Verify common fields
187 EXPECT_EQ(rebuiltTx.getAccount(), accountValue);
188 EXPECT_EQ(rebuiltTx.getSequence(), sequenceValue);
189 EXPECT_EQ(rebuiltTx.getFee(), feeValue);
190
191 // Verify required fields
192 {
193 auto const& expected = vaultIDValue;
194 auto const actual = rebuiltTx.getVaultID();
195 expectEqualField(expected, actual, "sfVaultID");
196 }
197
198 // Verify optional fields
199 {
200 auto const& expected = loanBrokerIDValue;
201 auto const actualOpt = rebuiltTx.getLoanBrokerID();
202 ASSERT_TRUE(actualOpt.has_value()) << "Optional field sfLoanBrokerID should be present";
203 expectEqualField(expected, *actualOpt, "sfLoanBrokerID");
204 }
205
206 {
207 auto const& expected = dataValue;
208 auto const actualOpt = rebuiltTx.getData();
209 ASSERT_TRUE(actualOpt.has_value()) << "Optional field sfData should be present";
210 expectEqualField(expected, *actualOpt, "sfData");
211 }
212
213 {
214 auto const& expected = managementFeeRateValue;
215 auto const actualOpt = rebuiltTx.getManagementFeeRate();
216 ASSERT_TRUE(actualOpt.has_value()) << "Optional field sfManagementFeeRate should be present";
217 expectEqualField(expected, *actualOpt, "sfManagementFeeRate");
218 }
219
220 {
221 auto const& expected = debtMaximumValue;
222 auto const actualOpt = rebuiltTx.getDebtMaximum();
223 ASSERT_TRUE(actualOpt.has_value()) << "Optional field sfDebtMaximum should be present";
224 expectEqualField(expected, *actualOpt, "sfDebtMaximum");
225 }
226
227 {
228 auto const& expected = coverRateMinimumValue;
229 auto const actualOpt = rebuiltTx.getCoverRateMinimum();
230 ASSERT_TRUE(actualOpt.has_value()) << "Optional field sfCoverRateMinimum should be present";
231 expectEqualField(expected, *actualOpt, "sfCoverRateMinimum");
232 }
233
234 {
235 auto const& expected = coverRateLiquidationValue;
236 auto const actualOpt = rebuiltTx.getCoverRateLiquidation();
237 ASSERT_TRUE(actualOpt.has_value()) << "Optional field sfCoverRateLiquidation should be present";
238 expectEqualField(expected, *actualOpt, "sfCoverRateLiquidation");
239 }
240
241 {
242 auto const& expected = domainIDValue;
243 auto const actualOpt = rebuiltTx.getDomainID();
244 ASSERT_TRUE(actualOpt.has_value()) << "Optional field sfDomainID should be present";
245 expectEqualField(expected, *actualOpt, "sfDomainID");
246 }
247
248}
249
250// 3) Verify wrapper throws when constructed from wrong transaction type.
251TEST(TransactionsLoanBrokerSetTests, WrapperThrowsOnWrongTxType)
252{
253 // Build a valid transaction of a different type
254 auto const [pk, sk] =
256 auto const account = calcAccountID(pk);
257
258 AccountSetBuilder wrongBuilder{account, 1, canonical_AMOUNT()};
259 auto wrongTx = wrongBuilder.build(pk, sk);
260
261 EXPECT_THROW(LoanBrokerSet{wrongTx.getSTTx()}, std::runtime_error);
262}
263
264// 4) Verify builder throws when constructed from wrong transaction type.
265TEST(TransactionsLoanBrokerSetTests, BuilderThrowsOnWrongTxType)
266{
267 // Build a valid transaction of a different type
268 auto const [pk, sk] =
269 generateKeyPair(KeyType::Secp256k1, generateSeed("testWrongTypeBuilder"));
270 auto const account = calcAccountID(pk);
271
272 AccountSetBuilder wrongBuilder{account, 1, canonical_AMOUNT()};
273 auto wrongTx = wrongBuilder.build(pk, sk);
274
275 EXPECT_THROW(LoanBrokerSetBuilder{wrongTx.getSTTx()}, std::runtime_error);
276}
277
278// 5) Build with only required fields and verify optional fields return nullopt.
279TEST(TransactionsLoanBrokerSetTests, OptionalFieldsReturnNullopt)
280{
281 // Generate a deterministic keypair for signing
282 auto const [publicKey, secretKey] =
283 generateKeyPair(KeyType::Secp256k1, generateSeed("testLoanBrokerSetNullopt"));
284
285 // Common transaction fields
286 auto const accountValue = calcAccountID(publicKey);
287 std::uint32_t const sequenceValue = 3;
288 auto const feeValue = canonical_AMOUNT();
289
290 // Transaction-specific required field values
291 auto const vaultIDValue = canonical_UINT256();
292
293 LoanBrokerSetBuilder builder{
294 accountValue,
295 vaultIDValue,
296 sequenceValue,
297 feeValue
298 };
299
300 // Do NOT set optional fields
301
302 auto tx = builder.build(publicKey, secretKey);
303
304 // Verify optional fields are not present
305 EXPECT_FALSE(tx.hasLoanBrokerID());
306 EXPECT_FALSE(tx.getLoanBrokerID().has_value());
307 EXPECT_FALSE(tx.hasData());
308 EXPECT_FALSE(tx.getData().has_value());
309 EXPECT_FALSE(tx.hasManagementFeeRate());
310 EXPECT_FALSE(tx.getManagementFeeRate().has_value());
311 EXPECT_FALSE(tx.hasDebtMaximum());
312 EXPECT_FALSE(tx.getDebtMaximum().has_value());
313 EXPECT_FALSE(tx.hasCoverRateMinimum());
314 EXPECT_FALSE(tx.getCoverRateMinimum().has_value());
315 EXPECT_FALSE(tx.hasCoverRateLiquidation());
316 EXPECT_FALSE(tx.getCoverRateLiquidation().has_value());
317 EXPECT_FALSE(tx.hasDomainID());
318 EXPECT_FALSE(tx.getDomainID().has_value());
319}
320
321}
AccountSet build(PublicKey const &publicKey, SecretKey const &secretKey)
Build and return the AccountSet wrapper.
LoanBrokerSetBuilder & setLoanBrokerID(std::decay_t< typename SF_UINT256::type::value_type > const &value)
Set sfLoanBrokerID (SoeOptional).
LoanBrokerSetBuilder & setData(std::decay_t< typename SF_VL::type::value_type > const &value)
Set sfData (SoeOptional).
LoanBrokerSetBuilder & setCoverRateLiquidation(std::decay_t< typename SF_UINT32::type::value_type > const &value)
Set sfCoverRateLiquidation (SoeOptional).
LoanBrokerSetBuilder & setManagementFeeRate(std::decay_t< typename SF_UINT16::type::value_type > const &value)
Set sfManagementFeeRate (SoeOptional).
LoanBrokerSetBuilder & setDebtMaximum(std::decay_t< typename SF_NUMBER::type::value_type > const &value)
Set sfDebtMaximum (SoeOptional).
LoanBrokerSetBuilder & setDomainID(std::decay_t< typename SF_UINT256::type::value_type > const &value)
Set sfDomainID (SoeOptional).
LoanBrokerSet build(PublicKey const &publicKey, SecretKey const &secretKey)
Build and return the LoanBrokerSet wrapper.
LoanBrokerSetBuilder & setCoverRateMinimum(std::decay_t< typename SF_UINT32::type::value_type > const &value)
Set sfCoverRateMinimum (SoeOptional).
TEST(TransactionsAccountDeleteTests, BuilderSettersRoundTrip)
Seed generateSeed(std::string const &passPhrase)
Generate a seed deterministically.
Definition Seed.cpp:58
std::pair< PublicKey, SecretKey > generateKeyPair(KeyType type, Seed const &seed)
Generate a key pair deterministically.
AccountID calcAccountID(PublicKey const &pk)
void expectEqualField(T const &expected, T const &actual, char const *fieldName)