Branch data     Line data    Source code

       1                 :             : // Copyright (c) 2021-2022 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 <bitcoin-build-config.h> // IWYU pragma: keep
       9                 :             : 
      10                 :             : #include <addresstype.h>
      11                 :             : #include <wallet/db.h>
      12                 :             : 
      13                 :             : #include <memory>
      14                 :             : 
      15                 :             : class ArgsManager;
      16                 :             : class CChain;
      17                 :             : class CKey;
      18                 :             : enum class OutputType;
      19                 :             : namespace interfaces {
      20                 :             : class Chain;
      21                 :             : } // namespace interfaces
      22                 :             : 
      23                 :             : namespace wallet {
      24                 :             : class CWallet;
      25                 :             : class WalletDatabase;
      26                 :             : struct WalletContext;
      27                 :             : 
      28                 :             : static const DatabaseFormat DATABASE_FORMATS[] = {
      29                 :             : #ifdef USE_SQLITE
      30                 :             :        DatabaseFormat::SQLITE,
      31                 :             : #endif
      32                 :             : #ifdef USE_BDB
      33                 :             :        DatabaseFormat::BERKELEY,
      34                 :             : #endif
      35                 :             : };
      36                 :             : 
      37                 :             : const std::string ADDRESS_BCRT1_UNSPENDABLE = "bcrt1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq3xueyj";
      38                 :             : 
      39                 :             : std::unique_ptr<CWallet> CreateSyncedWallet(interfaces::Chain& chain, CChain& cchain, const CKey& key);
      40                 :             : 
      41                 :             : std::shared_ptr<CWallet> TestLoadWallet(WalletContext& context);
      42                 :             : std::shared_ptr<CWallet> TestLoadWallet(std::unique_ptr<WalletDatabase> database, WalletContext& context, uint64_t create_flags);
      43                 :             : void TestUnloadWallet(std::shared_ptr<CWallet>&& wallet);
      44                 :             : 
      45                 :             : // Creates a copy of the provided database
      46                 :             : std::unique_ptr<WalletDatabase> DuplicateMockDatabase(WalletDatabase& database);
      47                 :             : 
      48                 :             : /** Returns a new encoded destination from the wallet (hardcoded to BECH32) */
      49                 :             : std::string getnewaddress(CWallet& w);
      50                 :             : /** Returns a new destination, of an specific type, from the wallet */
      51                 :             : CTxDestination getNewDestination(CWallet& w, OutputType output_type);
      52                 :             : 
      53                 :             : using MockableData = std::map<SerializeData, SerializeData, std::less<>>;
      54                 :             : 
      55                 :             : class MockableCursor: public DatabaseCursor
      56                 :             : {
      57                 :             : public:
      58                 :             :     MockableData::const_iterator m_cursor;
      59                 :             :     MockableData::const_iterator m_cursor_end;
      60                 :             :     bool m_pass;
      61                 :             : 
      62                 :           6 :     explicit MockableCursor(const MockableData& records, bool pass) : m_cursor(records.begin()), m_cursor_end(records.end()), m_pass(pass) {}
      63                 :             :     MockableCursor(const MockableData& records, bool pass, Span<const std::byte> prefix);
      64                 :         977 :     ~MockableCursor() = default;
      65                 :             : 
      66                 :             :     Status Next(DataStream& key, DataStream& value) override;
      67                 :             : };
      68                 :             : 
      69                 :             : class MockableBatch : public DatabaseBatch
      70                 :             : {
      71                 :             : private:
      72                 :             :     MockableData& m_records;
      73                 :             :     bool m_pass;
      74                 :             : 
      75                 :             :     bool ReadKey(DataStream&& key, DataStream& value) override;
      76                 :             :     bool WriteKey(DataStream&& key, DataStream&& value, bool overwrite=true) override;
      77                 :             :     bool EraseKey(DataStream&& key) override;
      78                 :             :     bool HasKey(DataStream&& key) override;
      79                 :             :     bool ErasePrefix(Span<const std::byte> prefix) override;
      80                 :             : 
      81                 :             : public:
      82                 :       19734 :     explicit MockableBatch(MockableData& records, bool pass) : m_records(records), m_pass(pass) {}
      83                 :       19734 :     ~MockableBatch() = default;
      84                 :             : 
      85                 :       50107 :     void Flush() override {}
      86                 :           0 :     void Close() override {}
      87                 :             : 
      88                 :           6 :     std::unique_ptr<DatabaseCursor> GetNewCursor() override
      89                 :             :     {
      90                 :           6 :         return std::make_unique<MockableCursor>(m_records, m_pass);
      91                 :             :     }
      92                 :         971 :     std::unique_ptr<DatabaseCursor> GetNewPrefixCursor(Span<const std::byte> prefix) override {
      93                 :         971 :         return std::make_unique<MockableCursor>(m_records, m_pass, prefix);
      94                 :             :     }
      95                 :        6658 :     bool TxnBegin() override { return m_pass; }
      96                 :        6657 :     bool TxnCommit() override { return m_pass; }
      97                 :           0 :     bool TxnAbort() override { return m_pass; }
      98                 :           0 :     bool HasActiveTxn() override { return false; }
      99                 :             : };
     100                 :             : 
     101                 :             : /** A WalletDatabase whose contents and return values can be modified as needed for testing
     102                 :             :  **/
     103                 :             : class MockableDatabase : public WalletDatabase
     104                 :             : {
     105                 :             : public:
     106                 :             :     MockableData m_records;
     107                 :             :     bool m_pass{true};
     108                 :             : 
     109         [ +  - ]:         104 :     MockableDatabase(MockableData records = {}) : WalletDatabase(), m_records(records) {}
     110                 :         104 :     ~MockableDatabase() = default;
     111                 :             : 
     112                 :           0 :     void Open() override {}
     113                 :           0 :     void AddRef() override {}
     114                 :           0 :     void RemoveRef() override {}
     115                 :             : 
     116                 :           1 :     bool Rewrite(const char* pszSkip=nullptr) override { return m_pass; }
     117                 :           0 :     bool Backup(const std::string& strDest) const override { return m_pass; }
     118                 :           1 :     void Flush() override {}
     119                 :           0 :     void Close() override {}
     120                 :           0 :     bool PeriodicFlush() override { return m_pass; }
     121                 :       50107 :     void IncrementUpdateCounter() override {}
     122                 :           1 :     void ReloadDbEnv() override {}
     123                 :             : 
     124                 :           0 :     std::string Filename() override { return "mockable"; }
     125                 :          31 :     std::string Format() override { return "mock"; }
     126                 :       19734 :     std::unique_ptr<DatabaseBatch> MakeBatch(bool flush_on_close = true) override { return std::make_unique<MockableBatch>(m_records, m_pass); }
     127                 :             : };
     128                 :             : 
     129                 :             : std::unique_ptr<WalletDatabase> CreateMockableWalletDatabase(MockableData records = {});
     130                 :             : 
     131                 :             : MockableDatabase& GetMockableDatabase(CWallet& wallet);
     132                 :             : } // namespace wallet
     133                 :             : 
     134                 :             : #endif // BITCOIN_WALLET_TEST_UTIL_H