From 85f8bbbccb8bbf14cd16eb2bd20efe9429206701 Mon Sep 17 00:00:00 2001 From: selsta Date: Wed, 24 Jun 2026 23:08:36 +0200 Subject: [PATCH] tests: make libwallet_api_tests work under ctest, add tests --- .github/workflows/build.yml | 2 +- src/wallet/api/wallet.cpp | 10 + src/wallet/api/wallet.h | 2 + src/wallet/api/wallet2_api.h | 2 + tests/README.md | 14 +- tests/libwallet_api_tests/CMakeLists.txt | 6 +- .../libwallet_api_tests.py | 258 +++++++++ tests/libwallet_api_tests/main.cpp | 494 ++++++++++-------- tests/libwallet_api_tests/scripts/README.md | 24 - .../scripts/create_wallets.sh | 18 - .../scripts/mining_start.sh | 4 - .../scripts/mining_stop.sh | 4 - .../scripts/open_wallet_1.sh | 5 - .../scripts/open_wallet_2.sh | 5 - .../scripts/open_wallet_3.sh | 4 - .../scripts/open_wallet_4.sh | 4 - .../scripts/open_wallet_5.sh | 4 - .../scripts/open_wallet_miner.sh | 4 - .../libwallet_api_tests/scripts/send_funds.sh | 32 -- 19 files changed, 574 insertions(+), 322 deletions(-) create mode 100644 tests/libwallet_api_tests/libwallet_api_tests.py delete mode 100644 tests/libwallet_api_tests/scripts/README.md delete mode 100755 tests/libwallet_api_tests/scripts/create_wallets.sh delete mode 100755 tests/libwallet_api_tests/scripts/mining_start.sh delete mode 100755 tests/libwallet_api_tests/scripts/mining_stop.sh delete mode 100755 tests/libwallet_api_tests/scripts/open_wallet_1.sh delete mode 100755 tests/libwallet_api_tests/scripts/open_wallet_2.sh delete mode 100755 tests/libwallet_api_tests/scripts/open_wallet_3.sh delete mode 100755 tests/libwallet_api_tests/scripts/open_wallet_4.sh delete mode 100755 tests/libwallet_api_tests/scripts/open_wallet_5.sh delete mode 100755 tests/libwallet_api_tests/scripts/open_wallet_miner.sh delete mode 100755 tests/libwallet_api_tests/scripts/send_funds.sh diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 7c0be646f..c93ddfbcc 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -14,7 +14,7 @@ on: env: REMOVE_BUNDLED_PACKAGES : sudo rm -rf /usr/local # ARCH="default" (not "native") ensures, that a different execution host can execute binaries compiled elsewhere. - BUILD_DEFAULT: 'cmake -S . -B build -D ARCH="default" -D BUILD_TESTS=ON -D ENABLE_FUZZ_TEST=ON -D CMAKE_BUILD_TYPE=Release && cmake --build build --target all && cmake --build build --target wallet_api' + BUILD_DEFAULT: 'cmake -S . -B build -D ARCH="default" -D BUILD_TESTS=ON -D BUILD_GUI_DEPS=ON -D ENABLE_FUZZ_TEST=ON -D CMAKE_BUILD_TYPE=Release && cmake --build build --target all' APT_INSTALL_LINUX: 'apt -y install build-essential cmake libboost-all-dev libunbound-dev graphviz doxygen libunwind8-dev pkg-config libssl-dev libzmq3-dev libsodium-dev libhidapi-dev libusb-1.0-0-dev libprotobuf-dev protobuf-compiler ccache curl git' APT_SET_CONF: | tee -a /etc/apt/apt.conf.d/80-custom << EOF diff --git a/src/wallet/api/wallet.cpp b/src/wallet/api/wallet.cpp index fa98635c5..3e3a27167 100644 --- a/src/wallet/api/wallet.cpp +++ b/src/wallet/api/wallet.cpp @@ -975,6 +975,16 @@ bool WalletImpl::init(const std::string &daemon_address, uint64_t upper_transact return doInit(daemon_address, proxy_address, upper_transaction_size_limit, use_ssl); } +void WalletImpl::allowMismatchedDaemonVersion(bool allow_mismatch) +{ + m_wallet->allow_mismatched_daemon_version(allow_mismatch); +} + +void WalletImpl::setRingDatabase(const std::string &path) +{ + m_wallet->set_ring_database(path); +} + void WalletImpl::setRefreshFromBlockHeight(uint64_t refresh_from_block_height) { if (checkBackgroundSync("cannot change refresh height")) diff --git a/src/wallet/api/wallet.h b/src/wallet/api/wallet.h index a5f1d9120..931f31dd5 100644 --- a/src/wallet/api/wallet.h +++ b/src/wallet/api/wallet.h @@ -106,6 +106,8 @@ public: std::string filename() const override; std::string keysFilename() const override; bool init(const std::string &daemon_address, uint64_t upper_transaction_size_limit = 0, const std::string &daemon_username = "", const std::string &daemon_password = "", bool use_ssl = false, bool lightWallet = false, const std::string &proxy_address = "") override; + void allowMismatchedDaemonVersion(bool allow_mismatch) override; + void setRingDatabase(const std::string &path) override; bool connectToDaemon() override; ConnectionStatus connected() const override; void setTrustedDaemon(bool arg) override; diff --git a/src/wallet/api/wallet2_api.h b/src/wallet/api/wallet2_api.h index cf241b22d..73438e089 100644 --- a/src/wallet/api/wallet2_api.h +++ b/src/wallet/api/wallet2_api.h @@ -546,6 +546,8 @@ struct Wallet * \return - true on success */ virtual bool init(const std::string &daemon_address, uint64_t upper_transaction_size_limit = 0, const std::string &daemon_username = "", const std::string &daemon_password = "", bool use_ssl = false, bool lightWallet = false, const std::string &proxy_address = "") = 0; + virtual void allowMismatchedDaemonVersion(bool allow_mismatch) = 0; + virtual void setRingDatabase(const std::string &path) = 0; /*! * \brief createWatchOnly - Creates a watch only wallet diff --git a/tests/README.md b/tests/README.md index ee275affe..7099f8561 100644 --- a/tests/README.md +++ b/tests/README.md @@ -209,7 +209,19 @@ ctest -R hash-blake2b # Libwallet API tests -[TODO] +The libwallet API tests are located under `tests/libwallet_api_tests/`. +They are run through `ctest` like the functional tests and do not require a +pre-existing testnet blockchain or manually created wallets. The CTest wrapper +starts a temporary fakechain daemon, creates temporary wallets and ring database +directories, mines the required blocks, and removes the process when the test +finishes. + +These tests are added to CTest when the build is configured with +`BUILD_GUI_DEPS=ON`. To run only this test from such a build directory: + +```bash +ctest --test-dir build -R libwallet_api_tests --output-on-failure +``` # Net Load tests diff --git a/tests/libwallet_api_tests/CMakeLists.txt b/tests/libwallet_api_tests/CMakeLists.txt index 2b69cc85e..aee0a08df 100644 --- a/tests/libwallet_api_tests/CMakeLists.txt +++ b/tests/libwallet_api_tests/CMakeLists.txt @@ -33,6 +33,8 @@ set(libwallet_api_tests_sources set(libwallet_api_tests_headers ) +find_package(Python3 REQUIRED) + monero_add_minimal_executable(libwallet_api_tests ${libwallet_api_tests_sources} ${libwallet_api_tests_headers}) @@ -67,4 +69,6 @@ set_property(TARGET libwallet_api_tests add_test( NAME libwallet_api_tests - COMMAND libwallet_api_tests) + COMMAND ${Python3_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/libwallet_api_tests.py" "${CMAKE_BINARY_DIR}" "$" "$") + +set_tests_properties(libwallet_api_tests PROPERTIES TIMEOUT 240) diff --git a/tests/libwallet_api_tests/libwallet_api_tests.py b/tests/libwallet_api_tests/libwallet_api_tests.py new file mode 100644 index 000000000..54724e545 --- /dev/null +++ b/tests/libwallet_api_tests/libwallet_api_tests.py @@ -0,0 +1,258 @@ +#!/usr/bin/env python3 + +# Copyright (c) 2014-2024, The Monero Project +# +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without modification, are +# permitted provided that the following conditions are met: +# +# 1. Redistributions of source code must retain the above copyright notice, this list of +# conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright notice, this list +# of conditions and the following disclaimer in the documentation and/or other +# materials provided with the distribution. +# +# 3. Neither the name of the copyright holder nor the names of its contributors may be +# used to endorse or promote products derived from this software without specific +# prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY +# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL +# THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, +# STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF +# THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +import json +import os +import shutil +import socket +import subprocess +import sys +import threading +import time +import urllib.error +import urllib.request +from signal import SIGTERM + + +USAGE = "usage: libwallet_api_tests.py " +MINED_BLOCKS = 90 + + +def reserve_ports(count): + sockets = [] + ports = [] + try: + for _ in range(count): + s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + s.bind(("127.0.0.1", 0)) + sockets.append(s) + ports.append(s.getsockname()[1]) + finally: + for s in sockets: + s.close() + return ports + + +def wait_for_port(port, timeout=20): + deadline = time.monotonic() + timeout + while time.monotonic() < deadline: + with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: + s.settimeout(0.2) + if s.connect_ex(("127.0.0.1", port)) == 0: + return + time.sleep(0.1) + raise RuntimeError("timed out waiting for port {}".format(port)) + + +def rpc_json(rpc_port, path, payload, timeout=30): + data = json.dumps(payload).encode("utf-8") + request = urllib.request.Request( + "http://127.0.0.1:{}{}".format(rpc_port, path), + data=data, + headers={"Content-Type": "application/json"}, + ) + with urllib.request.urlopen(request, timeout=timeout) as response: + return json.loads(response.read().decode("utf-8")) + + +def get_height(rpc_port): + response = rpc_json(rpc_port, "/get_height", {}) + return int(response["height"]) + + +def wait_for_height(rpc_port, height, timeout=180): + deadline = time.monotonic() + timeout + while time.monotonic() < deadline: + try: + current_height = get_height(rpc_port) + if current_height >= height: + return current_height + except (urllib.error.URLError, TimeoutError, KeyError): + pass + time.sleep(0.5) + raise RuntimeError("timed out waiting for regtest height {}".format(height)) + + +def generate_blocks(rpc_port, address, blocks): + response = rpc_json( + rpc_port, + "/json_rpc", + { + "jsonrpc": "2.0", + "id": "0", + "method": "generateblocks", + "params": { + "wallet_address": address, + "amount_of_blocks": blocks, + }, + }, + ) + if "error" in response: + raise RuntimeError("generateblocks failed: {}".format(response["error"])) + return response + + +def pulse_blocks(stop_event, rpc_port, address): + while not stop_event.wait(1.0): + try: + generate_blocks(rpc_port, address, 1) + except Exception as e: + print("Failed to generate regtest block: {}".format(e)) + sys.stdout.flush() + return + + +def stop_process(process): + if process.poll() is not None: + return + try: + process.send_signal(SIGTERM) + process.wait(timeout=20) + except subprocess.TimeoutExpired: + process.kill() + process.wait() + + +def main(): + if len(sys.argv) != 4: + print(USAGE) + return 1 + + builddir = os.path.abspath(sys.argv[1]) + monerod = os.path.abspath(sys.argv[2]) + test_exe = os.path.abspath(sys.argv[3]) + + for executable in (monerod, test_exe): + if not os.path.exists(executable): + print("missing executable: {}".format(executable)) + return 1 + + run_dir = os.path.join(builddir, "libwallet-api-tests-directory") + wallets_dir = os.path.join(run_dir, "wallets") + ringdb_dir = os.path.join(run_dir, "ringdb") + data_dir = os.path.join(run_dir, "regtest") + log_dir = os.path.join(builddir, "tests", "libwallet_api_tests") + + shutil.rmtree(run_dir, ignore_errors=True) + os.makedirs(wallets_dir) + os.makedirs(ringdb_dir) + os.makedirs(data_dir) + os.makedirs(log_dir, exist_ok=True) + + rpc_port, p2p_port, zmq_rpc_port, zmq_pub_port = reserve_ports(4) + daemon_log_path = os.path.join(log_dir, "monerod-regtest.log") + daemon_log = open(daemon_log_path, "ab") + daemon = None + block_pulse_stop = threading.Event() + block_pulse = None + + try: + daemon = subprocess.Popen( + [ + monerod, + "--regtest", + "--fixed-difficulty", + "1", + "--p2p-bind-ip", + "127.0.0.1", + "--p2p-bind-port", + str(p2p_port), + "--rpc-bind-ip", + "127.0.0.1", + "--rpc-bind-port", + str(rpc_port), + "--zmq-rpc-bind-ip", + "127.0.0.1", + "--zmq-rpc-bind-port", + str(zmq_rpc_port), + "--zmq-pub", + "tcp://127.0.0.1:{}".format(zmq_pub_port), + "--non-interactive", + "--offline", + "--disable-dns-checkpoints", + "--check-updates", + "disabled", + "--rpc-ssl", + "disabled", + "--data-dir", + data_dir, + "--log-level", + "1", + ], + stdout=daemon_log, + stderr=subprocess.STDOUT, + ) + wait_for_port(rpc_port) + + env = os.environ.copy() + env["WALLETS_ROOT_DIR"] = wallets_dir + env["DAEMON_ADDRESS"] = "127.0.0.1:{}".format(rpc_port) + env["LIBWALLET_API_TESTS_RINGDB_DIR"] = ringdb_dir + + generated = subprocess.check_output( + [test_exe, "--generate-test-wallets"], + cwd=run_dir, + env=env, + text=True, + ) + generated_values = dict( + line.split("=", 1) + for line in generated.splitlines() + if line.startswith(("miner_address=", "pulse_miner_address=")) + ) + miner_address = generated_values["miner_address"].strip() + pulse_miner_address = generated_values["pulse_miner_address"].strip() + response = generate_blocks(rpc_port, miner_address, MINED_BLOCKS) + print("Generated regtest blocks to {}: {}".format(miner_address, response)) + print("Current regtest height: {}".format(get_height(rpc_port))) + sys.stdout.flush() + wait_for_height(rpc_port, MINED_BLOCKS) + + env.setdefault("GTEST_COLOR", "yes") + gtest_filter = env.get("LIBWALLET_API_TESTS_GTEST_FILTER", "*") + + block_pulse = threading.Thread(target=pulse_blocks, args=(block_pulse_stop, rpc_port, pulse_miner_address)) + block_pulse.start() + return subprocess.call( + [test_exe, "--gtest_filter={}".format(gtest_filter)], + cwd=run_dir, + env=env, + ) + finally: + block_pulse_stop.set() + if block_pulse is not None: + block_pulse.join(timeout=10) + if daemon is not None: + stop_process(daemon) + daemon_log.close() + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/tests/libwallet_api_tests/main.cpp b/tests/libwallet_api_tests/main.cpp index e803e9150..f256ea5b2 100644 --- a/tests/libwallet_api_tests/main.cpp +++ b/tests/libwallet_api_tests/main.cpp @@ -45,6 +45,8 @@ #include #include +#include +#include #include #include #include @@ -59,10 +61,9 @@ namespace Consts // TODO: get rid of hardcoded paths const char * WALLET_NAME = "testwallet"; -const char * WALLET_NAME_MAINNET = "testwallet_mainnet"; const char * WALLET_NAME_COPY = "testwallet_copy"; const char * WALLET_NAME_WITH_DIR = "walletdir/testwallet_test"; -const char * WALLET_NAME_WITH_DIR_NON_WRITABLE = "/var/walletdir/testwallet_test"; +const char * WALLET_NAME_WITH_DIR_NON_WRITABLE = "not_a_directory/testwallet_test"; const char * WALLET_PASS = "password"; const char * WALLET_PASS2 = "password22"; const char * WALLET_LANG = "English"; @@ -86,8 +87,9 @@ const uint64_t AMOUNT_1XMR = 1000000000000L; const std::string PAYMENT_ID_EMPTY = ""; -std::string TESTNET_DAEMON_ADDRESS = "localhost:38081"; -std::string MAINNET_DAEMON_ADDRESS = "localhost:18081"; +std::string DAEMON_ADDRESS; +Monero::NetworkType WALLET_NETWORK_TYPE = Monero::NetworkType::MAINNET; +std::string RING_DATABASE_DIR; } @@ -96,6 +98,32 @@ std::string MAINNET_DAEMON_ADDRESS = "localhost:18081"; using namespace Consts; +static void configure_wallet(Monero::Wallet *wallet) +{ + if (!wallet) + return; + wallet->allowMismatchedDaemonVersion(true); + wallet->setRefreshFromBlockHeight(1); + if (!RING_DATABASE_DIR.empty()) + wallet->setRingDatabase(RING_DATABASE_DIR); +} + +static bool init_wallet(Monero::Wallet *wallet, const std::string &daemon_address) +{ + configure_wallet(wallet); + if (!wallet || !wallet->init(daemon_address, 0)) + return false; + // init() applies the new-wallet fast-sync height, so restore the fixture's + // explicit height afterwards to scan its pre-mined funding outputs. + wallet->setRefreshFromBlockHeight(1); + return true; +} + +static bool init_wallet(Monero::Wallet *wallet) +{ + return init_wallet(wallet, DAEMON_ADDRESS); +} + struct Utils { static void deleteWallet(const std::string & walletname) @@ -129,7 +157,7 @@ struct Utils static std::string get_wallet_address(const std::string &filename, const std::string &password) { Monero::WalletManager *wmgr = Monero::WalletManagerFactory::getWalletManager(); - Monero::Wallet * w = wmgr->openWallet(filename, password, Monero::NetworkType::TESTNET); + Monero::Wallet * w = wmgr->openWallet(filename, password, WALLET_NETWORK_TYPE); std::string result = w->mainAddress(); wmgr->closeWallet(w); return result; @@ -149,6 +177,7 @@ struct WalletManagerTest : public testing::Test // Monero::WalletManagerFactory::setLogLevel(Monero::WalletManagerFactory::LogLevel_4); Utils::deleteWallet(WALLET_NAME); Utils::deleteDir(boost::filesystem::path(WALLET_NAME_WITH_DIR).parent_path().string()); + Utils::deleteDir(boost::filesystem::path(WALLET_NAME_WITH_DIR_NON_WRITABLE).parent_path().string()); } @@ -160,25 +189,45 @@ struct WalletManagerTest : public testing::Test }; -struct WalletManagerMainnetTest : public testing::Test +static int generate_test_wallets() { - Monero::WalletManager * wmgr; + boost::filesystem::create_directories(WALLETS_ROOT_DIR); + Monero::WalletManager *wmgr = Monero::WalletManagerFactory::getWalletManager(); + std::string miner_address; + std::string pulse_miner_address; - - WalletManagerMainnetTest() + for (int i = 1; i <= 6; ++i) { - std::cout << __FUNCTION__ << std::endl; - wmgr = Monero::WalletManagerFactory::getWalletManager(); - Utils::deleteWallet(WALLET_NAME_MAINNET); + const std::string wallet_name = WALLETS_ROOT_DIR + "/wallet_0" + std::to_string(i) + ".bin"; + Utils::deleteWallet(wallet_name); + Monero::Wallet *wallet = wmgr->createWallet(wallet_name, TESTNET_WALLET_PASS, WALLET_LANG, WALLET_NETWORK_TYPE); + if (!wallet || wallet->status() != Monero::Wallet::Status_Ok) + { + std::cerr << "Failed to create wallet " << wallet_name; + if (wallet) + { + std::cerr << ": " << wallet->errorString(); + wmgr->closeWallet(wallet); + } + std::cerr << std::endl; + return 1; + } + configure_wallet(wallet); + if (i == 5) + miner_address = wallet->mainAddress(); + if (i == 6) + pulse_miner_address = wallet->mainAddress(); + if (!wmgr->closeWallet(wallet)) + { + std::cerr << "Failed to close wallet " << wallet_name << std::endl; + return 1; + } } - - ~WalletManagerMainnetTest() - { - std::cout << __FUNCTION__ << std::endl; - } - -}; + std::cout << "miner_address=" << miner_address << std::endl; + std::cout << "pulse_miner_address=" << pulse_miner_address << std::endl; + return miner_address.empty() || pulse_miner_address.empty() ? 1 : 0; +} struct WalletTest1 : public testing::Test { @@ -207,7 +256,7 @@ struct WalletTest2 : public testing::Test TEST_F(WalletManagerTest, WalletManagerCreatesWallet) { - Monero::Wallet * wallet = wmgr->createWallet(WALLET_NAME, WALLET_PASS, WALLET_LANG, Monero::NetworkType::MAINNET); + Monero::Wallet * wallet = wmgr->createWallet(WALLET_NAME, WALLET_PASS, WALLET_LANG, WALLET_NETWORK_TYPE); ASSERT_TRUE(wallet->status() == Monero::Wallet::Status_Ok); ASSERT_TRUE(!wallet->seed().empty()); std::vector words; @@ -224,13 +273,14 @@ TEST_F(WalletManagerTest, WalletManagerCreatesWallet) TEST_F(WalletManagerTest, WalletManagerOpensWallet) { - Monero::Wallet * wallet1 = wmgr->createWallet(WALLET_NAME, WALLET_PASS, WALLET_LANG, Monero::NetworkType::MAINNET); + Monero::Wallet * wallet1 = wmgr->createWallet(WALLET_NAME, WALLET_PASS, WALLET_LANG, WALLET_NETWORK_TYPE); std::string seed1 = wallet1->seed(); ASSERT_TRUE(wmgr->closeWallet(wallet1)); - Monero::Wallet * wallet2 = wmgr->openWallet(WALLET_NAME, WALLET_PASS, Monero::NetworkType::MAINNET); + Monero::Wallet * wallet2 = wmgr->openWallet(WALLET_NAME, WALLET_PASS, WALLET_NETWORK_TYPE); ASSERT_TRUE(wallet2->status() == Monero::Wallet::Status_Ok); ASSERT_TRUE(wallet2->seed() == seed1); std::cout << "** seed: " << wallet2->seed() << std::endl; + ASSERT_TRUE(wmgr->closeWallet(wallet2)); } @@ -260,9 +310,12 @@ void open_wallet_helper(Monero::WalletManager *wmgr, Monero::Wallet **wallet, co if (mutex) mutex->lock(); LOG_PRINT_L3("opening wallet in thread: " << boost::this_thread::get_id()); - *wallet = wmgr->openWallet(WALLET_NAME, pass, Monero::NetworkType::TESTNET); - LOG_PRINT_L3("wallet address: " << (*wallet)->mainAddress()); - LOG_PRINT_L3("wallet status: " << (*wallet)->status()); + *wallet = wmgr->openWallet(WALLET_NAME, pass, WALLET_NETWORK_TYPE); + if (*wallet) + { + LOG_PRINT_L3("wallet address: " << (*wallet)->mainAddress()); + LOG_PRINT_L3("wallet status: " << (*wallet)->status()); + } LOG_PRINT_L3("closing wallet in thread: " << boost::this_thread::get_id()); if (mutex) mutex->unlock(); @@ -276,7 +329,7 @@ void open_wallet_helper(Monero::WalletManager *wmgr, Monero::Wallet **wallet, co // // create password protected wallet // std::string wallet_pass = "password"; // std::string wrong_wallet_pass = "1111"; -// Monero::Wallet * wallet1 = wmgr->createWallet(WALLET_NAME, wallet_pass, WALLET_LANG, Monero::NetworkType::TESTNET); +// Monero::Wallet * wallet1 = wmgr->createWallet(WALLET_NAME, wallet_pass, WALLET_LANG, WALLET_NETWORK_TYPE); // std::string seed1 = wallet1->seed(); // ASSERT_TRUE(wmgr->closeWallet(wallet1)); @@ -302,7 +355,7 @@ TEST_F(WalletManagerTest, WalletManagerOpensWalletWithPasswordAndReopen) // create password protected wallet std::string wallet_pass = "password"; std::string wrong_wallet_pass = "1111"; - Monero::Wallet * wallet1 = wmgr->createWallet(WALLET_NAME, wallet_pass, WALLET_LANG, Monero::NetworkType::TESTNET); + Monero::Wallet * wallet1 = wmgr->createWallet(WALLET_NAME, wallet_pass, WALLET_LANG, WALLET_NETWORK_TYPE); std::string seed1 = wallet1->seed(); ASSERT_TRUE(wmgr->closeWallet(wallet1)); @@ -325,57 +378,63 @@ TEST_F(WalletManagerTest, WalletManagerOpensWalletWithPasswordAndReopen) TEST_F(WalletManagerTest, WalletManagerStoresWallet) { - Monero::Wallet * wallet1 = wmgr->createWallet(WALLET_NAME, WALLET_PASS, WALLET_LANG, Monero::NetworkType::MAINNET); + Monero::Wallet * wallet1 = wmgr->createWallet(WALLET_NAME, WALLET_PASS, WALLET_LANG, WALLET_NETWORK_TYPE); std::string seed1 = wallet1->seed(); wallet1->store(""); ASSERT_TRUE(wmgr->closeWallet(wallet1)); - Monero::Wallet * wallet2 = wmgr->openWallet(WALLET_NAME, WALLET_PASS, Monero::NetworkType::MAINNET); + Monero::Wallet * wallet2 = wmgr->openWallet(WALLET_NAME, WALLET_PASS, WALLET_NETWORK_TYPE); ASSERT_TRUE(wallet2->status() == Monero::Wallet::Status_Ok); ASSERT_TRUE(wallet2->seed() == seed1); + ASSERT_TRUE(wmgr->closeWallet(wallet2)); } TEST_F(WalletManagerTest, WalletManagerMovesWallet) { - Monero::Wallet * wallet1 = wmgr->createWallet(WALLET_NAME, WALLET_PASS, WALLET_LANG, Monero::NetworkType::MAINNET); - std::string WALLET_NAME_MOVED = std::string("/tmp/") + WALLET_NAME + ".moved"; + Monero::Wallet * wallet1 = wmgr->createWallet(WALLET_NAME, WALLET_PASS, WALLET_LANG, WALLET_NETWORK_TYPE); + const std::string WALLET_NAME_MOVED = + (boost::filesystem::temp_directory_path() / (std::string(WALLET_NAME) + ".moved")).string(); + Utils::deleteWallet(WALLET_NAME_MOVED); std::string seed1 = wallet1->seed(); ASSERT_TRUE(wallet1->store(WALLET_NAME_MOVED)); + ASSERT_TRUE(wmgr->closeWallet(wallet1)); - Monero::Wallet * wallet2 = wmgr->openWallet(WALLET_NAME_MOVED, WALLET_PASS, Monero::NetworkType::MAINNET); + Monero::Wallet * wallet2 = wmgr->openWallet(WALLET_NAME_MOVED, WALLET_PASS, WALLET_NETWORK_TYPE); ASSERT_TRUE(wallet2->filename() == WALLET_NAME_MOVED); ASSERT_TRUE(wallet2->keysFilename() == WALLET_NAME_MOVED + ".keys"); ASSERT_TRUE(wallet2->status() == Monero::Wallet::Status_Ok); ASSERT_TRUE(wallet2->seed() == seed1); + ASSERT_TRUE(wmgr->closeWallet(wallet2)); } TEST_F(WalletManagerTest, WalletManagerChangesPassword) { - Monero::Wallet * wallet1 = wmgr->createWallet(WALLET_NAME, WALLET_PASS, WALLET_LANG, Monero::NetworkType::MAINNET); + Monero::Wallet * wallet1 = wmgr->createWallet(WALLET_NAME, WALLET_PASS, WALLET_LANG, WALLET_NETWORK_TYPE); std::string seed1 = wallet1->seed(); ASSERT_TRUE(wallet1->setPassword(WALLET_PASS2)); ASSERT_TRUE(wmgr->closeWallet(wallet1)); - Monero::Wallet * wallet2 = wmgr->openWallet(WALLET_NAME, WALLET_PASS2, Monero::NetworkType::MAINNET); + Monero::Wallet * wallet2 = wmgr->openWallet(WALLET_NAME, WALLET_PASS2, WALLET_NETWORK_TYPE); ASSERT_TRUE(wallet2->status() == Monero::Wallet::Status_Ok); ASSERT_TRUE(wallet2->seed() == seed1); ASSERT_TRUE(wmgr->closeWallet(wallet2)); - Monero::Wallet * wallet3 = wmgr->openWallet(WALLET_NAME, WALLET_PASS, Monero::NetworkType::MAINNET); + Monero::Wallet * wallet3 = wmgr->openWallet(WALLET_NAME, WALLET_PASS, WALLET_NETWORK_TYPE); ASSERT_FALSE(wallet3->status() == Monero::Wallet::Status_Ok); + ASSERT_TRUE(wmgr->closeWallet(wallet3)); } TEST_F(WalletManagerTest, WalletManagerRecoversWallet) { - Monero::Wallet * wallet1 = wmgr->createWallet(WALLET_NAME, WALLET_PASS, WALLET_LANG, Monero::NetworkType::MAINNET); + Monero::Wallet * wallet1 = wmgr->createWallet(WALLET_NAME, WALLET_PASS, WALLET_LANG, WALLET_NETWORK_TYPE); std::string seed1 = wallet1->seed(); std::string address1 = wallet1->mainAddress(); ASSERT_FALSE(address1.empty()); ASSERT_TRUE(wmgr->closeWallet(wallet1)); Utils::deleteWallet(WALLET_NAME); - Monero::Wallet * wallet2 = wmgr->recoveryWallet(WALLET_NAME, seed1, Monero::NetworkType::MAINNET); + Monero::Wallet * wallet2 = wmgr->recoveryWallet(WALLET_NAME, seed1, WALLET_NETWORK_TYPE); ASSERT_TRUE(wallet2->status() == Monero::Wallet::Status_Ok); ASSERT_TRUE(wallet2->seed() == seed1); ASSERT_TRUE(wallet2->mainAddress() == address1); @@ -422,14 +481,14 @@ TEST_F(WalletManagerTest, WalletManagerStoresPasswordOfWalletRecoveredFromKeys) TEST_F(WalletManagerTest, WalletManagerStoresWallet1) { - Monero::Wallet * wallet1 = wmgr->createWallet(WALLET_NAME, WALLET_PASS, WALLET_LANG, Monero::NetworkType::MAINNET); + Monero::Wallet * wallet1 = wmgr->createWallet(WALLET_NAME, WALLET_PASS, WALLET_LANG, WALLET_NETWORK_TYPE); std::string seed1 = wallet1->seed(); std::string address1 = wallet1->mainAddress(); ASSERT_TRUE(wallet1->store("")); ASSERT_TRUE(wallet1->store(WALLET_NAME_COPY)); ASSERT_TRUE(wmgr->closeWallet(wallet1)); - Monero::Wallet * wallet2 = wmgr->openWallet(WALLET_NAME_COPY, WALLET_PASS, Monero::NetworkType::MAINNET); + Monero::Wallet * wallet2 = wmgr->openWallet(WALLET_NAME_COPY, WALLET_PASS, WALLET_NETWORK_TYPE); ASSERT_TRUE(wallet2->status() == Monero::Wallet::Status_Ok); ASSERT_TRUE(wallet2->seed() == seed1); ASSERT_TRUE(wallet2->mainAddress() == address1); @@ -439,14 +498,14 @@ TEST_F(WalletManagerTest, WalletManagerStoresWallet1) TEST_F(WalletManagerTest, WalletManagerStoresWallet2) { - Monero::Wallet * wallet1 = wmgr->createWallet(WALLET_NAME, WALLET_PASS, WALLET_LANG, Monero::NetworkType::MAINNET); + Monero::Wallet * wallet1 = wmgr->createWallet(WALLET_NAME, WALLET_PASS, WALLET_LANG, WALLET_NETWORK_TYPE); std::string seed1 = wallet1->seed(); std::string address1 = wallet1->mainAddress(); ASSERT_TRUE(wallet1->store(WALLET_NAME_WITH_DIR)); ASSERT_TRUE(wmgr->closeWallet(wallet1)); - wallet1 = wmgr->openWallet(WALLET_NAME_WITH_DIR, WALLET_PASS, Monero::NetworkType::MAINNET); + wallet1 = wmgr->openWallet(WALLET_NAME_WITH_DIR, WALLET_PASS, WALLET_NETWORK_TYPE); ASSERT_TRUE(wallet1->status() == Monero::Wallet::Status_Ok); ASSERT_TRUE(wallet1->seed() == seed1); ASSERT_TRUE(wallet1->mainAddress() == address1); @@ -456,20 +515,23 @@ TEST_F(WalletManagerTest, WalletManagerStoresWallet2) TEST_F(WalletManagerTest, WalletManagerStoresWallet3) { - Monero::Wallet * wallet1 = wmgr->createWallet(WALLET_NAME, WALLET_PASS, WALLET_LANG, Monero::NetworkType::MAINNET); + Monero::Wallet * wallet1 = wmgr->createWallet(WALLET_NAME, WALLET_PASS, WALLET_LANG, WALLET_NETWORK_TYPE); std::string seed1 = wallet1->seed(); std::string address1 = wallet1->mainAddress(); + const boost::filesystem::path parent = boost::filesystem::path(WALLET_NAME_WITH_DIR_NON_WRITABLE).parent_path(); + boost::filesystem::remove_all(parent); + std::ofstream(parent.string()).close(); ASSERT_FALSE(wallet1->store(WALLET_NAME_WITH_DIR_NON_WRITABLE)); - ASSERT_TRUE(wmgr->closeWallet(wallet1)); + ASSERT_TRUE(wmgr->closeWallet(wallet1, false)); - wallet1 = wmgr->openWallet(WALLET_NAME_WITH_DIR_NON_WRITABLE, WALLET_PASS, Monero::NetworkType::MAINNET); + wallet1 = wmgr->openWallet(WALLET_NAME_WITH_DIR_NON_WRITABLE, WALLET_PASS, WALLET_NETWORK_TYPE); ASSERT_FALSE(wallet1->status() == Monero::Wallet::Status_Ok); // "close" always returns true; ASSERT_TRUE(wmgr->closeWallet(wallet1)); - wallet1 = wmgr->openWallet(WALLET_NAME, WALLET_PASS, Monero::NetworkType::MAINNET); + wallet1 = wmgr->openWallet(WALLET_NAME, WALLET_PASS, WALLET_NETWORK_TYPE); ASSERT_TRUE(wallet1->status() == Monero::Wallet::Status_Ok); ASSERT_TRUE(wallet1->seed() == seed1); ASSERT_TRUE(wallet1->mainAddress() == address1); @@ -480,7 +542,7 @@ TEST_F(WalletManagerTest, WalletManagerStoresWallet3) TEST_F(WalletManagerTest, WalletManagerStoresWallet4) { - Monero::Wallet * wallet1 = wmgr->createWallet(WALLET_NAME, WALLET_PASS, WALLET_LANG, Monero::NetworkType::MAINNET); + Monero::Wallet * wallet1 = wmgr->createWallet(WALLET_NAME, WALLET_PASS, WALLET_LANG, WALLET_NETWORK_TYPE); std::string seed1 = wallet1->seed(); std::string address1 = wallet1->mainAddress(); @@ -492,7 +554,7 @@ TEST_F(WalletManagerTest, WalletManagerStoresWallet4) ASSERT_TRUE(wmgr->closeWallet(wallet1)); - wallet1 = wmgr->openWallet(WALLET_NAME, WALLET_PASS, Monero::NetworkType::MAINNET); + wallet1 = wmgr->openWallet(WALLET_NAME, WALLET_PASS, WALLET_NETWORK_TYPE); ASSERT_TRUE(wallet1->status() == Monero::Wallet::Status_Ok); ASSERT_TRUE(wallet1->seed() == seed1); ASSERT_TRUE(wallet1->mainAddress() == address1); @@ -512,6 +574,56 @@ TEST_F(WalletManagerTest, WalletManagerFindsWallet) } } +TEST_F(WalletManagerTest, WalletSubaddresses) +{ + Monero::Wallet * wallet = wmgr->createWallet( + WALLET_NAME, WALLET_PASS, WALLET_LANG, WALLET_NETWORK_TYPE); + ASSERT_TRUE(wallet != nullptr); + ASSERT_TRUE(wallet->status() == Monero::Wallet::Status_Ok); + + ASSERT_TRUE(wallet->numSubaddressAccounts() == 1); + ASSERT_TRUE(wallet->numSubaddresses(0) == 1); + ASSERT_TRUE(wallet->address(0, 0) == wallet->mainAddress()); + + wallet->addSubaddress(0, "Savings"); + ASSERT_TRUE(wallet->numSubaddresses(0) == 2); + ASSERT_TRUE(wallet->getSubaddressLabel(0, 1) == "Savings"); + ASSERT_TRUE(wallet->address(0, 1) != wallet->mainAddress()); + ASSERT_TRUE(Monero::Wallet::addressValid(wallet->address(0, 1), WALLET_NETWORK_TYPE)); + + wallet->addSubaddressAccount("Account 1"); + ASSERT_TRUE(wallet->numSubaddressAccounts() == 2); + ASSERT_TRUE(wallet->numSubaddresses(1) == 1); + ASSERT_TRUE(wallet->getSubaddressLabel(1, 0) == "Account 1"); + ASSERT_TRUE(Monero::Wallet::addressValid(wallet->address(1, 0), WALLET_NETWORK_TYPE)); + + Monero::Subaddress * subaddresses = wallet->subaddress(); + subaddresses->refresh(0); + ASSERT_TRUE(subaddresses->getAll().size() == 2); + ASSERT_TRUE(subaddresses->getAll()[1]->getAddress() == wallet->address(0, 1)); + ASSERT_TRUE(subaddresses->getAll()[1]->getLabel() == "Savings"); + + subaddresses->setLabel(0, 1, "Spending"); + ASSERT_TRUE(wallet->getSubaddressLabel(0, 1) == "Spending"); + subaddresses->addRow(0, "Donations"); + ASSERT_TRUE(wallet->numSubaddresses(0) == 3); + ASSERT_TRUE(subaddresses->getAll()[2]->getLabel() == "Donations"); + + Monero::SubaddressAccount * accounts = wallet->subaddressAccount(); + accounts->refresh(); + ASSERT_TRUE(accounts->getAll().size() == 2); + ASSERT_TRUE(accounts->getAll()[1]->getAddress() == wallet->address(1, 0)); + ASSERT_TRUE(accounts->getAll()[1]->getLabel() == "Account 1"); + + accounts->setLabel(1, "Secondary"); + ASSERT_TRUE(wallet->getSubaddressLabel(1, 0) == "Secondary"); + accounts->addRow("Account 2"); + ASSERT_TRUE(wallet->numSubaddressAccounts() == 3); + ASSERT_TRUE(accounts->getAll()[2]->getLabel() == "Account 2"); + + ASSERT_TRUE(wmgr->closeWallet(wallet)); +} + TEST_F(WalletTest1, WalletGeneratesPaymentId) { @@ -524,22 +636,26 @@ TEST_F(WalletTest1, WalletGeneratesIntegratedAddress) { std::string payment_id = Monero::Wallet::genPaymentId(); - Monero::Wallet * wallet1 = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, Monero::NetworkType::TESTNET); + Monero::Wallet * wallet1 = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, WALLET_NETWORK_TYPE); std::string integrated_address = wallet1->integratedAddress(payment_id); ASSERT_TRUE(integrated_address.length() == 106); + ASSERT_TRUE(wmgr->closeWallet(wallet1)); } TEST_F(WalletTest1, WalletShowsBalance) { - Monero::Wallet * wallet1 = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, Monero::NetworkType::TESTNET); + Monero::Wallet * wallet1 = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, WALLET_NETWORK_TYPE); + ASSERT_TRUE(init_wallet(wallet1)); + ASSERT_TRUE(wallet1->refresh()); ASSERT_TRUE(wallet1->balance(0) > 0); ASSERT_TRUE(wallet1->unlockedBalance(0) > 0); uint64_t balance1 = wallet1->balance(0); uint64_t unlockedBalance1 = wallet1->unlockedBalance(0); ASSERT_TRUE(wmgr->closeWallet(wallet1)); - Monero::Wallet * wallet2 = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, Monero::NetworkType::TESTNET); + Monero::Wallet * wallet2 = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, WALLET_NETWORK_TYPE); + configure_wallet(wallet2); ASSERT_TRUE(balance1 == wallet2->balance(0)); std::cout << "wallet balance: " << wallet2->balance(0) << std::endl; @@ -550,7 +666,7 @@ TEST_F(WalletTest1, WalletShowsBalance) TEST_F(WalletTest1, WalletReturnsCurrentBlockHeight) { - Monero::Wallet * wallet1 = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, Monero::NetworkType::TESTNET); + Monero::Wallet * wallet1 = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, WALLET_NETWORK_TYPE); ASSERT_TRUE(wallet1->blockChainHeight() > 0); wmgr->closeWallet(wallet1); } @@ -558,16 +674,17 @@ TEST_F(WalletTest1, WalletReturnsCurrentBlockHeight) TEST_F(WalletTest1, WalletReturnsDaemonBlockHeight) { - Monero::Wallet * wallet1 = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, Monero::NetworkType::TESTNET); + Monero::Wallet * wallet1 = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, WALLET_NETWORK_TYPE); // wallet not connected to daemon + configure_wallet(wallet1); ASSERT_TRUE(wallet1->daemonBlockChainHeight() == 0); - ASSERT_TRUE(wallet1->status() != Monero::Wallet::Status_Ok); - ASSERT_FALSE(wallet1->errorString().empty()); + ASSERT_TRUE(wallet1->status() == Monero::Wallet::Status_Ok); wmgr->closeWallet(wallet1); - wallet1 = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, Monero::NetworkType::TESTNET); + wallet1 = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, WALLET_NETWORK_TYPE); // wallet connected to daemon - wallet1->init(TESTNET_DAEMON_ADDRESS, 0); + init_wallet(wallet1); + ASSERT_TRUE(wallet1->refresh()); ASSERT_TRUE(wallet1->daemonBlockChainHeight() > 0); std::cout << "daemonBlockChainHeight: " << wallet1->daemonBlockChainHeight() << std::endl; wmgr->closeWallet(wallet1); @@ -578,10 +695,10 @@ TEST_F(WalletTest1, WalletRefresh) { std::cout << "Opening wallet: " << CURRENT_SRC_WALLET << std::endl; - Monero::Wallet * wallet1 = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, Monero::NetworkType::TESTNET); + Monero::Wallet * wallet1 = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, WALLET_NETWORK_TYPE); // make sure testnet daemon is running - std::cout << "connecting to daemon: " << TESTNET_DAEMON_ADDRESS << std::endl; - ASSERT_TRUE(wallet1->init(TESTNET_DAEMON_ADDRESS, 0)); + std::cout << "connecting to daemon: " << DAEMON_ADDRESS << std::endl; + ASSERT_TRUE(init_wallet(wallet1)); ASSERT_TRUE(wallet1->refresh()); ASSERT_TRUE(wmgr->closeWallet(wallet1)); } @@ -602,9 +719,9 @@ TEST_F(WalletTest1, WalletConvertsToString) TEST_F(WalletTest1, WalletTransaction) { - Monero::Wallet * wallet1 = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, Monero::NetworkType::TESTNET); + Monero::Wallet * wallet1 = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, WALLET_NETWORK_TYPE); // make sure testnet daemon is running - ASSERT_TRUE(wallet1->init(TESTNET_DAEMON_ADDRESS, 0)); + ASSERT_TRUE(init_wallet(wallet1)); ASSERT_TRUE(wallet1->refresh()); uint64_t balance = wallet1->balance(0); ASSERT_TRUE(wallet1->status() == Monero::PendingTransaction::Status_Ok); @@ -644,11 +761,11 @@ TEST_F(WalletTest1, WalletTransactionWithMixin) std::string payment_id = ""; - Monero::Wallet * wallet1 = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, Monero::NetworkType::TESTNET); + Monero::Wallet * wallet1 = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, WALLET_NETWORK_TYPE); // make sure testnet daemon is running - ASSERT_TRUE(wallet1->init(TESTNET_DAEMON_ADDRESS, 0)); + ASSERT_TRUE(init_wallet(wallet1)); ASSERT_TRUE(wallet1->refresh()); uint64_t balance = wallet1->balance(0); ASSERT_TRUE(wallet1->status() == Monero::PendingTransaction::Status_Ok); @@ -678,10 +795,10 @@ TEST_F(WalletTest1, WalletTransactionWithPriority) std::string payment_id = ""; - Monero::Wallet * wallet1 = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, Monero::NetworkType::TESTNET); + Monero::Wallet * wallet1 = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, WALLET_NETWORK_TYPE); // make sure testnet daemon is running - ASSERT_TRUE(wallet1->init(TESTNET_DAEMON_ADDRESS, 0)); + ASSERT_TRUE(init_wallet(wallet1)); ASSERT_TRUE(wallet1->refresh()); uint64_t balance = wallet1->balance(0); ASSERT_TRUE(wallet1->status() == Monero::PendingTransaction::Status_Ok); @@ -718,9 +835,9 @@ TEST_F(WalletTest1, WalletTransactionWithPriority) TEST_F(WalletTest1, WalletHistory) { - Monero::Wallet * wallet1 = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, Monero::NetworkType::TESTNET); + Monero::Wallet * wallet1 = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, WALLET_NETWORK_TYPE); // make sure testnet daemon is running - ASSERT_TRUE(wallet1->init(TESTNET_DAEMON_ADDRESS, 0)); + ASSERT_TRUE(init_wallet(wallet1)); ASSERT_TRUE(wallet1->refresh()); Monero::TransactionHistory * history = wallet1->history(); history->refresh(); @@ -731,14 +848,15 @@ TEST_F(WalletTest1, WalletHistory) ASSERT_TRUE(t != nullptr); Utils::print_transaction(t); } + ASSERT_TRUE(wmgr->closeWallet(wallet1)); } TEST_F(WalletTest1, WalletTransactionAndHistory) { return; - Monero::Wallet * wallet_src = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, Monero::NetworkType::TESTNET); + Monero::Wallet * wallet_src = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, WALLET_NETWORK_TYPE); // make sure testnet daemon is running - ASSERT_TRUE(wallet_src->init(TESTNET_DAEMON_ADDRESS, 0)); + ASSERT_TRUE(init_wallet(wallet_src)); ASSERT_TRUE(wallet_src->refresh()); Monero::TransactionHistory * history = wallet_src->history(); history->refresh(); @@ -775,9 +893,9 @@ TEST_F(WalletTest1, WalletTransactionAndHistory) TEST_F(WalletTest1, WalletTransactionWithPaymentId) { - Monero::Wallet * wallet_src = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, Monero::NetworkType::TESTNET); + Monero::Wallet * wallet_src = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, WALLET_NETWORK_TYPE); // make sure testnet daemon is running - ASSERT_TRUE(wallet_src->init(TESTNET_DAEMON_ADDRESS, 0)); + ASSERT_TRUE(init_wallet(wallet_src)); ASSERT_TRUE(wallet_src->refresh()); Monero::TransactionHistory * history = wallet_src->history(); history->refresh(); @@ -790,16 +908,21 @@ TEST_F(WalletTest1, WalletTransactionWithPaymentId) Utils::print_transaction(t); } - std::string wallet4_addr = Utils::get_wallet_address(CURRENT_DST_WALLET, TESTNET_WALLET_PASS); - std::string payment_id = Monero::Wallet::genPaymentId(); ASSERT_TRUE(payment_id.length() == 16); + Monero::Wallet * wallet_dst = wmgr->openWallet(CURRENT_DST_WALLET, TESTNET_WALLET_PASS, WALLET_NETWORK_TYPE); + ASSERT_TRUE(wallet_dst != nullptr); + std::string integrated_address = wallet_dst->integratedAddress(payment_id); + ASSERT_FALSE(integrated_address.empty()); + ASSERT_TRUE(wmgr->closeWallet(wallet_dst)); - - Monero::PendingTransaction * tx = wallet_src->createTransaction(wallet4_addr, - payment_id, + Monero::PendingTransaction * tx = wallet_src->createTransaction(integrated_address, + PAYMENT_ID_EMPTY, AMOUNT_1XMR, 1, Monero::PendingTransaction::Priority_Medium, 0, std::set{}); + std::cerr << "Transaction status: " << tx->status() << std::endl; + std::cerr << "Transaction fee: " << Monero::Wallet::displayAmount(tx->fee()) << std::endl; + std::cerr << "Transaction error: " << tx->errorString() << std::endl; ASSERT_TRUE(tx->status() == Monero::PendingTransaction::Status_Ok); ASSERT_TRUE(tx->commit()); history = wallet_src->history(); @@ -818,6 +941,49 @@ TEST_F(WalletTest1, WalletTransactionWithPaymentId) } ASSERT_TRUE(payment_id_in_history); + ASSERT_TRUE(wmgr->closeWallet(wallet_src)); +} + +TEST_F(WalletTest1, WalletTransactionMultDestWithPaymentId) +{ + Monero::Wallet * wallet_src = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, WALLET_NETWORK_TYPE); + ASSERT_TRUE(init_wallet(wallet_src)); + ASSERT_TRUE(wallet_src->refresh()); + Monero::TransactionHistory * history = wallet_src->history(); + history->refresh(); + size_t count = history->count(); + + std::string payment_id = Monero::Wallet::genPaymentId(); + ASSERT_TRUE(payment_id.length() == 16); + Monero::Wallet * wallet_dst = wmgr->openWallet(CURRENT_DST_WALLET, TESTNET_WALLET_PASS, WALLET_NETWORK_TYPE); + ASSERT_TRUE(wallet_dst != nullptr); + std::string integrated_address = wallet_dst->integratedAddress(payment_id); + ASSERT_FALSE(integrated_address.empty()); + ASSERT_TRUE(wmgr->closeWallet(wallet_dst)); + + const std::vector destinations{integrated_address, wallet_src->mainAddress()}; + const std::vector amounts{AMOUNT_1XMR, AMOUNT_1XMR}; + Monero::PendingTransaction * tx = wallet_src->createTransactionMultDest( + destinations, PAYMENT_ID_EMPTY, amounts, 1, + Monero::PendingTransaction::Priority_Medium, 0, std::set{}); + + std::cerr << "Transaction status: " << tx->status() << std::endl; + std::cerr << "Transaction fee: " << Monero::Wallet::displayAmount(tx->fee()) << std::endl; + std::cerr << "Transaction error: " << tx->errorString() << std::endl; + ASSERT_TRUE(tx->status() == Monero::PendingTransaction::Status_Ok); + ASSERT_TRUE(tx->commit()); + history->refresh(); + ASSERT_TRUE(count != history->count()); + + bool payment_id_in_history = false; + for (auto t: history->getAll()) { + ASSERT_TRUE(t != nullptr); + if (t->paymentId() == payment_id) { + payment_id_in_history = true; + } + } + ASSERT_TRUE(payment_id_in_history); + ASSERT_TRUE(wmgr->closeWallet(wallet_src)); } @@ -917,14 +1083,13 @@ struct MyWalletListener : public Monero::WalletListener TEST_F(WalletTest2, WalletCallBackRefreshedSync) { - Monero::Wallet * wallet_src = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, Monero::NetworkType::TESTNET); + Monero::Wallet * wallet_src = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, WALLET_NETWORK_TYPE); MyWalletListener * wallet_src_listener = new MyWalletListener(wallet_src); - ASSERT_TRUE(wallet_src->init(TESTNET_DAEMON_ADDRESS, 0)); - ASSERT_TRUE(wallet_src_listener->refresh_triggered); + ASSERT_TRUE(init_wallet(wallet_src)); ASSERT_TRUE(wallet_src->connected()); - boost::chrono::seconds wait_for = boost::chrono::seconds(60*3); - boost::unique_lock lock (wallet_src_listener->mutex); - wallet_src_listener->cv_refresh.wait_for(lock, wait_for); + wallet_src_listener->reset(); + ASSERT_TRUE(wallet_src->refresh()); + ASSERT_TRUE(wallet_src_listener->refresh_triggered); wmgr->closeWallet(wallet_src); } @@ -934,12 +1099,12 @@ TEST_F(WalletTest2, WalletCallBackRefreshedSync) TEST_F(WalletTest2, WalletCallBackRefreshedAsync) { - Monero::Wallet * wallet_src = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, Monero::NetworkType::TESTNET); + Monero::Wallet * wallet_src = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, WALLET_NETWORK_TYPE); MyWalletListener * wallet_src_listener = new MyWalletListener(wallet_src); boost::chrono::seconds wait_for = boost::chrono::seconds(20); boost::unique_lock lock (wallet_src_listener->mutex); - wallet_src->init(MAINNET_DAEMON_ADDRESS, 0); + init_wallet(wallet_src); wallet_src->startRefresh(); std::cerr << "TEST: waiting on refresh lock...\n"; wallet_src_listener->cv_refresh.wait_for(lock, wait_for); @@ -956,14 +1121,14 @@ TEST_F(WalletTest2, WalletCallBackRefreshedAsync) TEST_F(WalletTest2, WalletCallbackSent) { - Monero::Wallet * wallet_src = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, Monero::NetworkType::TESTNET); + Monero::Wallet * wallet_src = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, WALLET_NETWORK_TYPE); // make sure testnet daemon is running - ASSERT_TRUE(wallet_src->init(TESTNET_DAEMON_ADDRESS, 0)); + ASSERT_TRUE(init_wallet(wallet_src)); ASSERT_TRUE(wallet_src->refresh()); MyWalletListener * wallet_src_listener = new MyWalletListener(wallet_src); uint64_t balance = wallet_src->balance(0); std::cout << "** Balance: " << wallet_src->displayAmount(wallet_src->balance(0)) << std::endl; - Monero::Wallet * wallet_dst = wmgr->openWallet(CURRENT_DST_WALLET, TESTNET_WALLET_PASS, Monero::NetworkType::TESTNET); + Monero::Wallet * wallet_dst = wmgr->openWallet(CURRENT_DST_WALLET, TESTNET_WALLET_PASS, WALLET_NETWORK_TYPE); uint64_t amount = AMOUNT_1XMR * 5; std::cout << "** Sending " << Monero::Wallet::displayAmount(amount) << " to " << wallet_dst->mainAddress(); @@ -978,7 +1143,8 @@ TEST_F(WalletTest2, WalletCallbackSent) ASSERT_TRUE(tx->status() == Monero::PendingTransaction::Status_Ok); ASSERT_TRUE(tx->commit()); - boost::chrono::seconds wait_for = boost::chrono::seconds(60*3); + wallet_src->startRefresh(); + boost::chrono::seconds wait_for = boost::chrono::seconds(20); boost::unique_lock lock (wallet_src_listener->mutex); std::cerr << "TEST: waiting on send lock...\n"; wallet_src_listener->cv_send.wait_for(lock, wait_for); @@ -995,14 +1161,14 @@ TEST_F(WalletTest2, WalletCallbackSent) TEST_F(WalletTest2, WalletCallbackReceived) { - Monero::Wallet * wallet_src = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, Monero::NetworkType::TESTNET); + Monero::Wallet * wallet_src = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, WALLET_NETWORK_TYPE); // make sure testnet daemon is running - ASSERT_TRUE(wallet_src->init(TESTNET_DAEMON_ADDRESS, 0)); + ASSERT_TRUE(init_wallet(wallet_src)); ASSERT_TRUE(wallet_src->refresh()); std::cout << "** Balance src1: " << wallet_src->displayAmount(wallet_src->balance(0)) << std::endl; - Monero::Wallet * wallet_dst = wmgr->openWallet(CURRENT_DST_WALLET, TESTNET_WALLET_PASS, Monero::NetworkType::TESTNET); - ASSERT_TRUE(wallet_dst->init(TESTNET_DAEMON_ADDRESS, 0)); + Monero::Wallet * wallet_dst = wmgr->openWallet(CURRENT_DST_WALLET, TESTNET_WALLET_PASS, WALLET_NETWORK_TYPE); + ASSERT_TRUE(init_wallet(wallet_dst)); ASSERT_TRUE(wallet_dst->refresh()); uint64_t balance = wallet_dst->balance(0); std::cout << "** Balance dst1: " << wallet_dst->displayAmount(wallet_dst->balance(0)) << std::endl; @@ -1020,7 +1186,8 @@ TEST_F(WalletTest2, WalletCallbackReceived) ASSERT_TRUE(tx->status() == Monero::PendingTransaction::Status_Ok); ASSERT_TRUE(tx->commit()); - boost::chrono::seconds wait_for = boost::chrono::seconds(60*4); + wallet_dst->startRefresh(); + boost::chrono::seconds wait_for = boost::chrono::seconds(20); boost::unique_lock lock (wallet_dst_listener->mutex); std::cerr << "TEST: waiting on receive lock...\n"; wallet_dst_listener->cv_receive.wait_for(lock, wait_for); @@ -1042,9 +1209,9 @@ TEST_F(WalletTest2, WalletCallbackReceived) TEST_F(WalletTest2, WalletCallbackNewBlock) { - Monero::Wallet * wallet_src = wmgr->openWallet(TESTNET_WALLET5_NAME, TESTNET_WALLET_PASS, Monero::NetworkType::TESTNET); + Monero::Wallet * wallet_src = wmgr->openWallet(TESTNET_WALLET5_NAME, TESTNET_WALLET_PASS, WALLET_NETWORK_TYPE); // make sure testnet daemon is running - ASSERT_TRUE(wallet_src->init(TESTNET_DAEMON_ADDRESS, 0)); + ASSERT_TRUE(init_wallet(wallet_src)); ASSERT_TRUE(wallet_src->refresh()); uint64_t bc1 = wallet_src->blockChainHeight(); std::cout << "** Block height: " << bc1 << std::endl; @@ -1052,8 +1219,8 @@ TEST_F(WalletTest2, WalletCallbackNewBlock) std::unique_ptr wallet_listener (new MyWalletListener(wallet_src)); - // wait max 4 min for new block - boost::chrono::seconds wait_for = boost::chrono::seconds(60*4); + wallet_src->startRefresh(); + boost::chrono::seconds wait_for = boost::chrono::seconds(20); boost::unique_lock lock (wallet_listener->mutex); std::cerr << "TEST: waiting on newblock lock...\n"; wallet_listener->cv_newblock.wait_for(lock, wait_for); @@ -1066,128 +1233,27 @@ TEST_F(WalletTest2, WalletCallbackNewBlock) } -TEST_F(WalletManagerMainnetTest, CreateOpenAndRefreshWalletMainNetSync) -{ - - Monero::Wallet * wallet = wmgr->createWallet(WALLET_NAME_MAINNET, "", WALLET_LANG, Monero::NetworkType::MAINNET); - std::unique_ptr wallet_listener (new MyWalletListener(wallet)); - wallet->init(MAINNET_DAEMON_ADDRESS, 0); - std::cerr << "TEST: waiting on refresh lock...\n"; - //wallet_listener->cv_refresh.wait_for(lock, wait_for); - std::cerr << "TEST: refresh lock acquired...\n"; - ASSERT_TRUE(wallet_listener->refresh_triggered); - ASSERT_TRUE(wallet->connected()); - ASSERT_TRUE(wallet->blockChainHeight() == wallet->daemonBlockChainHeight()); - std::cerr << "TEST: closing wallet...\n"; - wmgr->closeWallet(wallet); -} - - -TEST_F(WalletManagerMainnetTest, CreateAndRefreshWalletMainNetAsync) -{ - // supposing 120 seconds should be enough for fast refresh - int SECONDS_TO_REFRESH = 120; - - Monero::Wallet * wallet = wmgr->createWallet(WALLET_NAME_MAINNET, "", WALLET_LANG, Monero::NetworkType::MAINNET); - std::unique_ptr wallet_listener (new MyWalletListener(wallet)); - - boost::chrono::seconds wait_for = boost::chrono::seconds(SECONDS_TO_REFRESH); - boost::unique_lock lock (wallet_listener->mutex); - wallet->init(MAINNET_DAEMON_ADDRESS, 0); - wallet->startRefresh(); - std::cerr << "TEST: waiting on refresh lock...\n"; - wallet_listener->cv_refresh.wait_for(lock, wait_for); - std::cerr << "TEST: refresh lock acquired...\n"; - ASSERT_TRUE(wallet->status() == Monero::Wallet::Status_Ok); - ASSERT_TRUE(wallet_listener->refresh_triggered); - ASSERT_TRUE(wallet->connected()); - ASSERT_TRUE(wallet->blockChainHeight() == wallet->daemonBlockChainHeight()); - std::cerr << "TEST: closing wallet...\n"; - wmgr->closeWallet(wallet); -} - -TEST_F(WalletManagerMainnetTest, OpenAndRefreshWalletMainNetAsync) -{ - - // supposing 120 seconds should be enough for fast refresh - int SECONDS_TO_REFRESH = 120; - Monero::Wallet * wallet = wmgr->createWallet(WALLET_NAME_MAINNET, "", WALLET_LANG, Monero::NetworkType::MAINNET); - wmgr->closeWallet(wallet); - wallet = wmgr->openWallet(WALLET_NAME_MAINNET, "", Monero::NetworkType::MAINNET); - - std::unique_ptr wallet_listener (new MyWalletListener(wallet)); - - boost::chrono::seconds wait_for = boost::chrono::seconds(SECONDS_TO_REFRESH); - boost::unique_lock lock (wallet_listener->mutex); - wallet->init(MAINNET_DAEMON_ADDRESS, 0); - wallet->startRefresh(); - std::cerr << "TEST: waiting on refresh lock...\n"; - wallet_listener->cv_refresh.wait_for(lock, wait_for); - std::cerr << "TEST: refresh lock acquired...\n"; - ASSERT_TRUE(wallet->status() == Monero::Wallet::Status_Ok); - ASSERT_TRUE(wallet_listener->refresh_triggered); - ASSERT_TRUE(wallet->connected()); - ASSERT_TRUE(wallet->blockChainHeight() == wallet->daemonBlockChainHeight()); - std::cerr << "TEST: closing wallet...\n"; - wmgr->closeWallet(wallet); - -} - -TEST_F(WalletManagerMainnetTest, RecoverAndRefreshWalletMainNetAsync) -{ - - // supposing 120 seconds should be enough for fast refresh - int SECONDS_TO_REFRESH = 120; - Monero::Wallet * wallet = wmgr->createWallet(WALLET_NAME_MAINNET, "", WALLET_LANG, Monero::NetworkType::MAINNET); - std::string seed = wallet->seed(); - std::string address = wallet->mainAddress(); - wmgr->closeWallet(wallet); - - // deleting wallet files - Utils::deleteWallet(WALLET_NAME_MAINNET); - // ..and recovering wallet from seed - - wallet = wmgr->recoveryWallet(WALLET_NAME_MAINNET, seed, Monero::NetworkType::MAINNET); - ASSERT_TRUE(wallet->status() == Monero::Wallet::Status_Ok); - ASSERT_TRUE(wallet->mainAddress() == address); - std::unique_ptr wallet_listener (new MyWalletListener(wallet)); - boost::chrono::seconds wait_for = boost::chrono::seconds(SECONDS_TO_REFRESH); - boost::unique_lock lock (wallet_listener->mutex); - wallet->init(MAINNET_DAEMON_ADDRESS, 0); - wallet->startRefresh(); - std::cerr << "TEST: waiting on refresh lock...\n"; - - // here we wait for 120 seconds and test if wallet doesn't syncrnonize blockchain completely, - // as it needs much more than 120 seconds for mainnet - - wallet_listener->cv_refresh.wait_for(lock, wait_for); - ASSERT_TRUE(wallet->status() == Monero::Wallet::Status_Ok); - ASSERT_FALSE(wallet_listener->refresh_triggered); - ASSERT_TRUE(wallet->connected()); - ASSERT_FALSE(wallet->blockChainHeight() == wallet->daemonBlockChainHeight()); - std::cerr << "TEST: closing wallet...\n"; - wmgr->closeWallet(wallet); - std::cerr << "TEST: wallet closed\n"; - -} - - - int main(int argc, char** argv) { TRY_ENTRY(); tools::on_startup(); - // we can override default values for "TESTNET_DAEMON_ADDRESS" and "WALLETS_ROOT_DIR" + // The CTest wrapper runs these tests against a fresh fakechain daemon. - const char * testnet_daemon_addr = std::getenv("TESTNET_DAEMON_ADDRESS"); - if (testnet_daemon_addr) { - TESTNET_DAEMON_ADDRESS = testnet_daemon_addr; + const char *daemon_addr = std::getenv("DAEMON_ADDRESS"); + if (daemon_addr && daemon_addr[0]) + { + DAEMON_ADDRESS = daemon_addr; + } + else + { + std::cerr << "DAEMON_ADDRESS must be set" << std::endl; + return 1; } - const char * mainnet_daemon_addr = std::getenv("MAINNET_DAEMON_ADDRESS"); - if (mainnet_daemon_addr) { - MAINNET_DAEMON_ADDRESS = mainnet_daemon_addr; + const char * ring_database_dir = std::getenv("LIBWALLET_API_TESTS_RINGDB_DIR"); + if (ring_database_dir) { + RING_DATABASE_DIR = ring_database_dir; } @@ -1208,6 +1274,12 @@ int main(int argc, char** argv) CURRENT_SRC_WALLET = TESTNET_WALLET5_NAME; CURRENT_DST_WALLET = TESTNET_WALLET1_NAME; + for (int i = 1; i < argc; ++i) + { + if (strcmp(argv[i], "--generate-test-wallets") == 0) + return generate_test_wallets(); + } + ::testing::InitGoogleTest(&argc, argv); Monero::WalletManagerFactory::setLogLevel(Monero::WalletManagerFactory::LogLevel_Max); return RUN_ALL_TESTS(); diff --git a/tests/libwallet_api_tests/scripts/README.md b/tests/libwallet_api_tests/scripts/README.md deleted file mode 100644 index 2ea622302..000000000 --- a/tests/libwallet_api_tests/scripts/README.md +++ /dev/null @@ -1,24 +0,0 @@ -# Running libwallet_api tests - -## Environment for the tests -* Running monero node, linked to private/public testnet. - By default, tests expect daemon running at ```localhost:38081```, - can be overridden with environment variable ```TESTNET_DAEMON_ADDRESS=``` - [Manual](https://github.com/moneroexamples/private-testnet) explaining how to run private testnet. - -* Directory with pre-generated wallets - (wallet_01.bin, wallet_02.bin,...,wallet_06.bin, some of these wallets might not be used in the tests currently). - By default, tests expect these wallets to be in ```/var/monero/testnet_pvt```. - Directory can be overridden with environment variable ```WALLETS_ROOT_DIR=```. - Directory and files should be writable for the user running tests. - - -## Generating test wallets -* ```create_wallets.sh``` - this script will create wallets (wallet_01.bin, wallet_02.bin,...,wallet_06.bin) in current directory. - when running first time, please uncomment line ```#create_wallet wallet_m``` to create miner wallet as well. - This wallet should be used for mining and all test wallets supposed to be seed from this miner wallet - -* ```mining_start.sh``` and ```mining_stop.sh``` - helper scripts to start and stop mining on miner wallet - -* ```send_funds.sh``` - script for seeding test wallets. Please run this script when you have enough money on miner wallet - diff --git a/tests/libwallet_api_tests/scripts/create_wallets.sh b/tests/libwallet_api_tests/scripts/create_wallets.sh deleted file mode 100755 index f33564e7f..000000000 --- a/tests/libwallet_api_tests/scripts/create_wallets.sh +++ /dev/null @@ -1,18 +0,0 @@ -#!/bin/bash - -function create_wallet { - wallet_name=$1 - echo 0 | monero-wallet-cli --testnet --trusted-daemon --daemon-address localhost:38081 --generate-new-wallet $wallet_name --password "" --restore-height=1 -} - - -create_wallet wallet_01.bin -create_wallet wallet_02.bin -create_wallet wallet_03.bin -create_wallet wallet_04.bin -create_wallet wallet_05.bin -create_wallet wallet_06.bin - -# create_wallet wallet_m - - diff --git a/tests/libwallet_api_tests/scripts/mining_start.sh b/tests/libwallet_api_tests/scripts/mining_start.sh deleted file mode 100755 index 30e3b7fbb..000000000 --- a/tests/libwallet_api_tests/scripts/mining_start.sh +++ /dev/null @@ -1,4 +0,0 @@ -#!/bin/bash - -rlwrap monero-wallet-cli --wallet-file wallet_m --password "" --testnet --trusted-daemon --daemon-address localhost:38081 --log-file wallet_m.log start_mining - diff --git a/tests/libwallet_api_tests/scripts/mining_stop.sh b/tests/libwallet_api_tests/scripts/mining_stop.sh deleted file mode 100755 index fadd68085..000000000 --- a/tests/libwallet_api_tests/scripts/mining_stop.sh +++ /dev/null @@ -1,4 +0,0 @@ -#!/bin/bash - -rlwrap monero-wallet-cli --wallet-file wallet_m --password "" --testnet --trusted-daemon --daemon-address localhost:38081 --log-file wallet_miner.log stop_mining - diff --git a/tests/libwallet_api_tests/scripts/open_wallet_1.sh b/tests/libwallet_api_tests/scripts/open_wallet_1.sh deleted file mode 100755 index 6e5a373d8..000000000 --- a/tests/libwallet_api_tests/scripts/open_wallet_1.sh +++ /dev/null @@ -1,5 +0,0 @@ -#!/bin/bash - - -rlwrap monero-wallet-cli --wallet-file wallet_01.bin --password "" --testnet --trusted-daemon --daemon-address localhost:38081 --log-file wallet_01.log - diff --git a/tests/libwallet_api_tests/scripts/open_wallet_2.sh b/tests/libwallet_api_tests/scripts/open_wallet_2.sh deleted file mode 100755 index 305af2f11..000000000 --- a/tests/libwallet_api_tests/scripts/open_wallet_2.sh +++ /dev/null @@ -1,5 +0,0 @@ -#!/bin/bash - - -rlwrap monero-wallet-cli --wallet-file wallet_02.bin --password "" --testnet --trusted-daemon --daemon-address localhost:38081 --log-file wallet_01.log - diff --git a/tests/libwallet_api_tests/scripts/open_wallet_3.sh b/tests/libwallet_api_tests/scripts/open_wallet_3.sh deleted file mode 100755 index 43df4a906..000000000 --- a/tests/libwallet_api_tests/scripts/open_wallet_3.sh +++ /dev/null @@ -1,4 +0,0 @@ -#!/bin/bash - -rlwrap monero-wallet-cli --wallet-file wallet_03.bin --password "" --testnet --trusted-daemon --daemon-address localhost:38081 --log-file wallet_03.log - diff --git a/tests/libwallet_api_tests/scripts/open_wallet_4.sh b/tests/libwallet_api_tests/scripts/open_wallet_4.sh deleted file mode 100755 index c48dd5636..000000000 --- a/tests/libwallet_api_tests/scripts/open_wallet_4.sh +++ /dev/null @@ -1,4 +0,0 @@ -#!/bin/bash - -rlwrap monero-wallet-cli --wallet-file wallet_04.bin --password "" --testnet --trusted-daemon --daemon-address localhost:38081 --log-file wallet_04.log - diff --git a/tests/libwallet_api_tests/scripts/open_wallet_5.sh b/tests/libwallet_api_tests/scripts/open_wallet_5.sh deleted file mode 100755 index 820114d48..000000000 --- a/tests/libwallet_api_tests/scripts/open_wallet_5.sh +++ /dev/null @@ -1,4 +0,0 @@ -#!/bin/bash - -rlwrap monero-wallet-cli --wallet-file wallet_05.bin --password "" --testnet --trusted-daemon --daemon-address localhost:38081 --log-file wallet_05.log - diff --git a/tests/libwallet_api_tests/scripts/open_wallet_miner.sh b/tests/libwallet_api_tests/scripts/open_wallet_miner.sh deleted file mode 100755 index 633e2519c..000000000 --- a/tests/libwallet_api_tests/scripts/open_wallet_miner.sh +++ /dev/null @@ -1,4 +0,0 @@ -#!/bin/bash - -rlwrap monero-wallet-cli --wallet-file wallet_m --password "" --testnet --trusted-daemon --daemon-address 127.0.0.1:38081 --log-file wallet_m.log - diff --git a/tests/libwallet_api_tests/scripts/send_funds.sh b/tests/libwallet_api_tests/scripts/send_funds.sh deleted file mode 100755 index 3ce923353..000000000 --- a/tests/libwallet_api_tests/scripts/send_funds.sh +++ /dev/null @@ -1,32 +0,0 @@ -#!/bin/bash - -function send_funds { - local amount=$1 - local dest=$(cat "$2.address.txt") - - monero-wallet-cli --wallet-file wallet_m --password "" \ - --testnet --trusted-daemon --daemon-address localhost:38081 --log-file wallet_m.log \ - --command transfer $dest $amount -} - - -function seed_wallets { - local amount=$1 - send_funds $amount wallet_01.bin - send_funds $amount wallet_02.bin - send_funds $amount wallet_03.bin - send_funds $amount wallet_04.bin - send_funds $amount wallet_05.bin - send_funds $amount wallet_06.bin -} - -seed_wallets 1 -seed_wallets 2 -seed_wallets 5 -seed_wallets 10 -seed_wallets 20 -seed_wallets 50 -seed_wallets 100 - - -