Branch data     Line data    Source code

       1                 :             : // Copyright (c) 2021-present The Bitcoin Core developers
       2                 :             : // Distributed under the MIT software license, see the accompanying
       3                 :             : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
       4                 :             : 
       5                 :             : #ifndef BITCOIN_WALLET_TEST_UTIL_H
       6                 :             : #define BITCOIN_WALLET_TEST_UTIL_H
       7                 :             : 
       8                 :             : #include <addresstype.h>
       9                 :             : #include <wallet/db.h>
      10                 :             : #include <wallet/scriptpubkeyman.h>
      11                 :             : 
      12                 :             : #include <memory>
      13                 :             : 
      14                 :             : class ArgsManager;
      15                 :             : class CChain;
      16                 :             : class CKey;
      17                 :             : enum class OutputType;
      18                 :             : namespace interfaces {
      19                 :             : class Chain;
      20                 :             : } // namespace interfaces
      21                 :             : 
      22                 :             : namespace wallet {
      23                 :             : class CWallet;
      24                 :             : class WalletDatabase;
      25                 :             : struct WalletContext;
      26                 :             : 
      27                 :             : static const DatabaseFormat DATABASE_FORMATS[] = {
      28                 :             :        DatabaseFormat::SQLITE,
      29                 :             : };
      30                 :             : 
      31                 :             : const std::string ADDRESS_BCRT1_UNSPENDABLE = "bcrt1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq3xueyj";
      32                 :             : 
      33                 :             : std::unique_ptr<CWallet> CreateSyncedWallet(interfaces::Chain& chain, CChain& cchain, const CKey& key);
      34                 :             : 
      35                 :             : std::shared_ptr<CWallet> TestLoadWallet(WalletContext& context);
      36                 :             : std::shared_ptr<CWallet> TestLoadWallet(std::unique_ptr<WalletDatabase> database, WalletContext& context, uint64_t create_flags);
      37                 :             : void TestUnloadWallet(std::shared_ptr<CWallet>&& wallet);
      38                 :             : 
      39                 :             : // Creates a copy of the provided database
      40                 :             : std::unique_ptr<WalletDatabase> DuplicateMockDatabase(WalletDatabase& database);
      41                 :             : 
      42                 :             : /** Returns a new encoded destination from the wallet (hardcoded to BECH32) */
      43                 :             : std::string getnewaddress(CWallet& w);
      44                 :             : /** Returns a new destination, of an specific type, from the wallet */
      45                 :             : CTxDestination getNewDestination(CWallet& w, OutputType output_type);
      46                 :             : 
      47                 :             : using MockableData = std::map<SerializeData, SerializeData, std::less<>>;
      48                 :             : 
      49                 :             : class MockableCursor: public DatabaseCursor
      50                 :             : {
      51                 :             : public:
      52                 :             :     MockableData::const_iterator m_cursor;
      53                 :             :     MockableData::const_iterator m_cursor_end;
      54                 :             :     bool m_pass;
      55                 :             : 
      56                 :           0 :     explicit MockableCursor(const MockableData& records, bool pass) : m_cursor(records.begin()), m_cursor_end(records.end()), m_pass(pass) {}
      57                 :             :     MockableCursor(const MockableData& records, bool pass, std::span<const std::byte> prefix);
      58                 :           0 :     ~MockableCursor() = default;
      59                 :             : 
      60                 :             :     Status Next(DataStream& key, DataStream& value) override;
      61                 :             : };
      62                 :             : 
      63                 :             : class MockableBatch : public DatabaseBatch
      64                 :             : {
      65                 :             : private:
      66                 :             :     MockableData& m_records;
      67                 :             :     bool m_pass;
      68                 :             : 
      69                 :             :     bool ReadKey(DataStream&& key, DataStream& value) override;
      70                 :             :     bool WriteKey(DataStream&& key, DataStream&& value, bool overwrite=true) override;
      71                 :             :     bool EraseKey(DataStream&& key) override;
      72                 :             :     bool HasKey(DataStream&& key) override;
      73                 :             :     bool ErasePrefix(std::span<const std::byte> prefix) override;
      74                 :             : 
      75                 :             : public:
      76                 :     1381961 :     explicit MockableBatch(MockableData& records, bool pass) : m_records(records), m_pass(pass) {}
      77                 :     1381961 :     ~MockableBatch() = default;
      78                 :             : 
      79                 :           0 :     void Close() override {}
      80                 :             : 
      81                 :           0 :     std::unique_ptr<DatabaseCursor> GetNewCursor() override
      82                 :             :     {
      83                 :           0 :         return std::make_unique<MockableCursor>(m_records, m_pass);
      84                 :             :     }
      85                 :           0 :     std::unique_ptr<DatabaseCursor> GetNewPrefixCursor(std::span<const std::byte> prefix) override {
      86                 :           0 :         return std::make_unique<MockableCursor>(m_records, m_pass, prefix);
      87                 :             :     }
      88                 :      618566 :     bool TxnBegin() override { return m_pass; }
      89                 :      618566 :     bool TxnCommit() override { return m_pass; }
      90                 :           0 :     bool TxnAbort() override { return m_pass; }
      91                 :           0 :     bool HasActiveTxn() override { return false; }
      92                 :             : };
      93                 :             : 
      94                 :             : /** A WalletDatabase whose contents and return values can be modified as needed for testing
      95                 :             :  **/
      96                 :             : class MockableDatabase : public WalletDatabase
      97                 :             : {
      98                 :             : public:
      99                 :             :     MockableData m_records;
     100                 :             :     bool m_pass{true};
     101                 :             : 
     102         [ +  - ]:        7830 :     MockableDatabase(MockableData records = {}) : WalletDatabase(), m_records(records) {}
     103                 :        7830 :     ~MockableDatabase() = default;
     104                 :             : 
     105                 :           0 :     void Open() override {}
     106                 :             : 
     107                 :           0 :     bool Rewrite(const char* pszSkip=nullptr) override { return m_pass; }
     108                 :           0 :     bool Backup(const std::string& strDest) const override { return m_pass; }
     109                 :           0 :     void Close() override {}
     110                 :             : 
     111                 :           0 :     std::string Filename() override { return "mockable"; }
     112                 :           0 :     std::string Format() override { return "mock"; }
     113                 :     1381961 :     std::unique_ptr<DatabaseBatch> MakeBatch() override { return std::make_unique<MockableBatch>(m_records, m_pass); }
     114                 :             : };
     115                 :             : 
     116                 :             : std::unique_ptr<WalletDatabase> CreateMockableWalletDatabase(MockableData records = {});
     117                 :             : MockableDatabase& GetMockableDatabase(CWallet& wallet);
     118                 :             : 
     119                 :             : ScriptPubKeyMan* CreateDescriptor(CWallet& keystore, const std::string& desc_str, const bool success);
     120                 :             : } // namespace wallet
     121                 :             : 
     122                 :             : #endif // BITCOIN_WALLET_TEST_UTIL_H