def testNodeControlResolvesDependencies(monkeypatch):
nct = NodeControlTool()
node_package = ('indy-node', '0.0.1')
anoncreds_package = ('indy-anoncreds', '0.0.2')
plenum_package = ('indy-plenum', '0.0.3')
node_package_with_version = '{}={}'.format(*node_package)
plenum_package_with_version = '{}={}'.format(*plenum_package)
anoncreds_package_with_version = '{}={}'.format(*anoncreds_package)
mock_info = {
node_package_with_version: '{}{} (= {}){}{} (= {}){}'.format(
randomText(100),
*plenum_package,
randomText(100),
*anoncreds_package,
randomText(100)),
plenum_package_with_version: '{}'.format(
randomText(100)),
anoncreds_package_with_version: '{}'.format(
randomText(100))}
def mock_get_info_from_package_manager(self, package):
return mock_info.get(package, None)
monkeypatch.setattr(nct.__class__, '_get_info_from_package_manager',
mock_get_info_from_package_manager)
monkeypatch.setattr(
nct.__class__, '_update_package_cache', lambda *x: None)
ret = nct._get_deps_list(node_package_with_version)
assert ret.split() == [
anoncreds_package_with_version,
plenum_package_with_version,
node_package_with_version]
def testPluginManagerFindsPlugins(monkeypatch, pluginManager):
validPackagesCnt = 5
invalidPackagesCnt = 10
validPackages = [pluginManager.prefix + randomText(10)
for _ in range(validPackagesCnt)]
invalidPackages = [randomText(10) for _ in range(invalidPackagesCnt)]
monkeypatch.setattr(
utils,
'get_installed_distributions',
partial(
mockGetInstalledDistributions,
packages=validPackages +
invalidPackages))
assert len(pluginManager._findPlugins()) == validPackagesCnt
def sdk_pool_data(txnPoolNodeSet):
p_name = "pool_name_" + randomText(13)
cfg = {"timeout": 20, "extended_timeout": 60, "conn_limit": 100000, "conn_active_timeout": 1000,
"preordered_nodes": [n.name for n in txnPoolNodeSet]}
yield p_name, json.dumps(cfg)
p_dir = os.path.join(os.path.expanduser("~/.indy_client/pool"), p_name)
if os.path.isdir(p_dir):
shutil.rmtree(p_dir, ignore_errors=True)
def sdk_wallet_data():
w_name = "wallet_name_" + randomText(13)
sdk_wallet_credentials = '{"key": "key"}'
sdk_wallet_config = json.dumps({"id": w_name})
yield sdk_wallet_config, sdk_wallet_credentials
w_dir = os.path.join(os.path.expanduser("~/.indy_client/wallet"), w_name)
if os.path.isdir(w_dir):
shutil.rmtree(w_dir, ignore_errors=True)
def sdk_wallet_data():
w_name = "wallet_name_" + randomText(13)
sdk_wallet_credentials = '{"key": "key"}'
sdk_wallet_config = json.dumps({"id": w_name})
yield sdk_wallet_config, sdk_wallet_credentials
w_dir = os.path.join(os.path.expanduser("~/.indy_client/wallet"), w_name)
if os.path.isdir(w_dir):
shutil.rmtree(w_dir, ignore_errors=True)
def patch_packet_mgr_output(monkeypatch, pkg_name, pkg_version, new_version):
if pkg_name != APP_NAME:
node_package = (APP_NAME, '0.0.1')
EXT_TOP_PKT_DEPS = [("aa", "1.1.1"), ("bb", "2.2.2")]
PACKAGE_MNG_EXT_PTK_OUTPUT = (
"Package: {}\nVersion: {}\n"
"Depends: {}, {} (= {}), {} (= {})\n".format(
pkg_name, pkg_version, APP_NAME, *EXT_TOP_PKT_DEPS[0],
*EXT_TOP_PKT_DEPS[1]))
top_level_package = (pkg_name, pkg_version)
plenum_package = ('indy-plenum', '0.0.3')
top_level_package_with_version = '{}={}'.format(*top_level_package)
top_level_package_dep1_with_version = '{}={}'.format(
*EXT_TOP_PKT_DEPS[0])
top_level_package_dep2_with_version = '{}={}'.format(
*EXT_TOP_PKT_DEPS[1])
node_package_with_version = '{}={}'.format(*node_package)
plenum_package_with_version = '{}={}'.format(*plenum_package)
mock_info = {
top_level_package_with_version:
"{}{} (= {}) {} (= {}), {} (= {})".format(randomText(100),
*node_package,
*EXT_TOP_PKT_DEPS[0],
*EXT_TOP_PKT_DEPS[1]),
node_package_with_version:
'{}{} (= {}){}{}'.format(randomText(100), *plenum_package,
randomText(100), randomText(100)),
plenum_package_with_version:
'{}'.format(randomText(100)),
top_level_package_dep1_with_version:
'{}{} (= {})'.format(randomText(100), *plenum_package),
top_level_package_dep2_with_version:
'{}{} (= {})'.format(randomText(100), *node_package)
}
def mock_get_info_from_package_manager(package):
if package.startswith(pkg_name):
return mock_info.get(top_level_package_with_version, "")
return mock_info.get(package, "")
#monkeypatch.setattr(NodeControlUtil, '_get_info_from_package_manager',
# lambda x: mock_get_info_from_package_manager(x))
monkeypatch.setattr(NodeControlUtil, '_get_curr_info',
lambda *x: PACKAGE_MNG_EXT_PTK_OUTPUT)
else:
#monkeypatch.setattr(
# NodeControlUtil, '_get_info_from_package_manager',
# lambda package: "Package: {}\nVersion: {}\n".format(APP_NAME, pkg_version) if package == APP_NAME else ""
#)
monkeypatch.setattr(
NodeControlUtil, '_get_curr_info',
lambda *x: "Package: {}\nVersion: {}\n".format(
APP_NAME, pkg_version))
monkeypatch.setattr(NodeControlUtil, 'update_package_cache',
lambda *x: None)
monkeypatch.setattr(
NodeControlUtil, 'get_latest_pkg_version',
lambda *x, **y: DebianVersion(new_version,
upstream_cls=src_version_cls(pkg_name)))
def patch_packet_mgr_output(monkeypatch, pkg_name, pkg_version):
if pkg_name != APP_NAME:
node_package = (APP_NAME, '0.0.1')
EXT_TOP_PKT_DEPS = [("aa", "1.1.1"), ("bb", "2.2.2")]
PACKAGE_MNG_EXT_PTK_OUTPUT = "Package: {}\nStatus: install ok installed\nPriority: extra\nSection: default\n" \
"Installed-Size: 21\nMaintainer: EXT_PKT_NAME-fond\nArchitecture: amd64\nVersion: {}\n" \
"Depends: {}, {} (= {}), {} (= {})\nDescription: EXT_PKT_DEPS-desc\n" \
"License: EXT_PKT_DEPS-lic\nVendor: none\n". \
format(pkg_name, pkg_version, APP_NAME, *EXT_TOP_PKT_DEPS[0], *EXT_TOP_PKT_DEPS[1])
top_level_package = (pkg_name, pkg_version)
plenum_package = ('indy-plenum', '0.0.3')
top_level_package_with_version = '{}={}'.format(*top_level_package)
top_level_package_dep1_with_version = '{}={}'.format(*EXT_TOP_PKT_DEPS[0])
top_level_package_dep2_with_version = '{}={}'.format(*EXT_TOP_PKT_DEPS[1])
node_package_with_version = '{}={}'.format(*node_package)
plenum_package_with_version = '{}={}'.format(*plenum_package)
mock_info = {
top_level_package_with_version: "{}{} (= {}) {} (= {}), {} (= {})".format(
randomText(100), *node_package, *EXT_TOP_PKT_DEPS[0], *EXT_TOP_PKT_DEPS[1]),
node_package_with_version: '{}{} (= {}){}{}'.format(
randomText(100), *plenum_package, randomText(100), randomText(100)),
plenum_package_with_version: '{}'.format(randomText(100)),
top_level_package_dep1_with_version: '{}{} (= {})'.format(randomText(100), *plenum_package),
top_level_package_dep2_with_version: '{}{} (= {})'.format(randomText(100), *node_package)
}
def mock_get_info_from_package_manager(package):
if package.startswith(pkg_name):
return mock_info.get(top_level_package_with_version, "")
return mock_info.get(package, "")
monkeypatch.setattr(NodeControlUtil, 'update_package_cache', lambda *x: None)
monkeypatch.setattr(NodeControlUtil, '_get_info_from_package_manager',
lambda x: mock_get_info_from_package_manager(x))
monkeypatch.setattr(NodeControlUtil, '_get_curr_info', lambda *x: PACKAGE_MNG_EXT_PTK_OUTPUT)
def testNode(pluginManager, tdir):
name = randomText(20)
nodeReg = genNodeReg(names=[name])
ha, cliname, cliha = nodeReg[name]
node = TestNode(name=name, ha=ha, cliname=cliname, cliha=cliha,
nodeRegistry=copy(nodeReg), basedirpath=tdir,
primaryDecider=None, pluginPaths=None, seed=randomSeed())
node.start(None)
yield node
node.stop()
def testPluginManagerSendMessageUponSuspiciousSpikeFailsOnboundsCoefficient(
pluginManagerWithImportedModules):
topic = randomText(10)
name = randomText(10)
historicalData = {
'value': 10,
'cnt': 10
}
newVal = 15
config = {
'bounds_coeff': 2,
'min_cnt': 10,
'min_activity_threshold': 0,
'use_weighted_bounds_coeff': True,
'enabled': True
}
assert pluginManagerWithImportedModules \
.sendMessageUponSuspiciousSpike(topic, historicalData,
newVal, config, name, enabled=True) is None
def test_suspicious_spike_check_disabled_func(pluginManagerWithImportedModules):
topic = randomText(10)
name = randomText(10)
hdata = {'value': 10, 'cnt': 10}
nval = 25
config = {'bounds_coeff': 2,
'min_cnt': 10,
'min_activity_threshold': 2,
'use_weighted_bounds_coeff': True,
'enabled': True}
sent, _ = pluginManagerWithImportedModules.sendMessageUponSuspiciousSpike(topic, hdata, nval,
config, name, enabled=True)
assert sent == 3
hdata['value'] = 10
hdata['cnt'] = 10
assert pluginManagerWithImportedModules.sendMessageUponSuspiciousSpike(topic, hdata, nval,
config, name, enabled=False) is None
def testPluginManagerImportsPlugins(monkeypatch, pluginManager):
packagesCnt = 3
packages = [
pluginManager.prefix + randomText(10) for _ in range(packagesCnt)
]
monkeypatch.setattr(importlib_metadata, 'distributions',
partial(mockDistributions, packages=packages))
monkeypatch.setattr(importlib, 'import_module', mockImportModule)
importedPlugins, foundPlugins = pluginManager.importPlugins()
assert importedPlugins == foundPlugins and importedPlugins == packagesCnt
def testNode(pluginManager, tdir):
name = randomText(20)
nodeReg = genNodeReg(names=[name])
ha, cliname, cliha = nodeReg[name]
return TestNode(name=name,
ha=ha,
cliname=cliname,
cliha=cliha,
nodeRegistry=copy(nodeReg),
basedirpath=tdir,
primaryDecider=None,
pluginPaths=None)
def testPluginManagerImportsPlugins(monkeypatch, pluginManager):
packagesCnt = 3
packages = [pluginManager.prefix + randomText(10)
for _ in range(packagesCnt)]
monkeypatch.setattr(utils, 'get_installed_distributions',
partial(mockGetInstalledDistributions,
packages=packages))
monkeypatch.setattr(importlib, 'import_module', mockImportModule)
importedPlugins, foundPlugins = pluginManager.importPlugins()
assert importedPlugins == foundPlugins and importedPlugins == packagesCnt
def testNode(pluginManager, tdir, tconf, node_config_helper_class):
name = randomText(20)
nodeReg = genNodeReg(names=[name])
ha, cliname, cliha = nodeReg[name]
config_helper = node_config_helper_class(name, tconf, chroot=tdir)
node = TestNode(name=name, ha=ha, cliname=cliname, cliha=cliha,
nodeRegistry=copy(nodeReg),
config_helper=config_helper,
config=tconf,
primaryDecider=None, pluginPaths=None, seed=randomSeed())
node.start(None)
yield node
node.stop()
def test_suspicious_spike_check_disabled_config(
pluginManagerWithImportedModules):
topic = randomText(10)
name = randomText(10)
hdata = {'value': 10, 'cnt': 10}
nval = 25
config = {
'coefficient': 2,
'minCnt': 10,
'minActivityThreshold': 2,
'enabled': True
}
sent, _ = pluginManagerWithImportedModules.sendMessageUponSuspiciousSpike(
topic, hdata, nval, config, name, enabled=True)
assert sent == 3
config['enabled'] = False
hdata['value'] = 10
hdata['cnt'] = 10
assert pluginManagerWithImportedModules.sendMessageUponSuspiciousSpike(
topic, hdata, nval, config, name, enabled=True) is None
def testNodeControlResolvesDependencies(monkeypatch, tconf):
nct = NodeControlTool(config=tconf)
node_package = ('indy-node', '0.0.1')
anoncreds_package = ('indy-anoncreds', '0.0.2')
plenum_package = ('indy-plenum', '0.0.3')
node_package_with_version = '{}={}'.format(*node_package)
plenum_package_with_version = '{}={}'.format(*plenum_package)
anoncreds_package_with_version = '{}={}'.format(*anoncreds_package)
mock_info = {node_package_with_version: '{}{} (= {}){}{} (= {}){}'.format(
randomText(100), *plenum_package, randomText(100), *anoncreds_package, randomText(100)),
plenum_package_with_version: '{}'.format(randomText(100)),
anoncreds_package_with_version: '{}'.format(randomText(100))
}
def mock_get_info_from_package_manager(self, package):
return mock_info.get(package, None)
monkeypatch.setattr(nct.__class__, '_get_info_from_package_manager', mock_get_info_from_package_manager)
monkeypatch.setattr(nct.__class__, '_update_package_cache', lambda *x: None)
ret = nct._get_deps_list(node_package_with_version)
nct.server.close()
assert ret.split() == [anoncreds_package_with_version, plenum_package_with_version, node_package_with_version]
def sdk_pool_data(txnPoolNodeSet):
p_name = "pool_name_" + randomText(13)
cfg = {
"timeout": 20,
"extended_timeout": 60,
"conn_limit": 100000,
"conn_active_timeout": 1000,
"preordered_nodes": [n.name for n in txnPoolNodeSet]
}
yield p_name, json.dumps(cfg)
p_dir = os.path.join(os.path.expanduser("~/.indy_client/pool"), p_name)
if os.path.isdir(p_dir):
shutil.rmtree(p_dir, ignore_errors=True)
def testNodeControlResolvesDependencies(monkeypatch, tconf):
nct = NodeControlTool(config=tconf)
node_package = ('indy-node', '0.0.1')
anoncreds_package = ('indy-anoncreds', '0.0.2')
plenum_package = ('indy-plenum', '0.0.3')
node_package_with_version = '{}={}'.format(*node_package)
plenum_package_with_version = '{}={}'.format(*plenum_package)
anoncreds_package_with_version = '{}={}'.format(*anoncreds_package)
mock_info = {
node_package_with_version:
'{}\nVersion: {}\nDepends:{} (= {}), {} (= {})\n'.format(
randomText(100), node_package[1], *plenum_package,
*anoncreds_package),
plenum_package_with_version:
'{}'.format(randomText(100)),
anoncreds_package_with_version:
'{}'.format(randomText(100))
}
def mock_get_info_from_package_manager(*package):
ret = ""
for p in package:
ret += mock_info.get(p, "")
return ret
monkeypatch.setattr(NodeControlUtil, 'update_package_cache',
lambda *x: None)
monkeypatch.setattr(
NodeControlUtil, 'get_sys_holds',
lambda *x: [node_package[0], anoncreds_package[0], plenum_package[0]])
monkeypatch.setattr(NodeControlUtil, '_get_info_from_package_manager',
lambda *x: mock_get_info_from_package_manager(*x))
ret = nct._get_deps_list(node_package_with_version)
nct.server.close()
assert sorted(ret.split()) == sorted([
anoncreds_package_with_version, plenum_package_with_version,
node_package_with_version
])
def test_node_as_depend(monkeypatch, tconf):
nct = NodeControlTool(config=tconf)
top_level_package = (EXT_PKT_NAME, EXT_PKT_VERSION)
anoncreds_package = ('indy-anoncreds', '0.0.2')
plenum_package = ('indy-plenum', '0.0.3')
top_level_package_with_version = '{}={}'.format(*top_level_package)
top_level_package_dep1_with_version = '{}={}'.format(*EXT_TOP_PKT_DEPS[0])
top_level_package_dep2_with_version = '{}={}'.format(*EXT_TOP_PKT_DEPS[1])
node_package_with_version = '{}={}'.format(*node_package)
plenum_package_with_version = '{}={}'.format(*plenum_package)
anoncreds_package_with_version = '{}={}'.format(*anoncreds_package)
mock_info = {
top_level_package_with_version:
"{}{} (= {}) {} (= {}), {} (= {})".format(randomText(100),
*node_package,
*EXT_TOP_PKT_DEPS[0],
*EXT_TOP_PKT_DEPS[1]),
node_package_with_version:
'{}{} (= {}){}{} (= {}){}'.format(randomText(100), *plenum_package,
randomText(100), *anoncreds_package,
randomText(100)),
plenum_package_with_version:
'{}'.format(randomText(100)),
anoncreds_package_with_version:
'{}'.format(randomText(100)),
top_level_package_dep1_with_version:
'{}{} (= {})'.format(randomText(100), *plenum_package),
top_level_package_dep2_with_version:
'{}{} (= {})'.format(randomText(100), *node_package)
}
def mock_get_info_from_package_manager(self, package):
return mock_info.get(package, None)
monkeypatch.setattr(nct.__class__, '_get_ext_info',
lambda *x: PACKAGE_MNG_EXT_PTK_OUTPUT)
monkeypatch.setattr(nct.__class__, '_get_info_from_package_manager',
mock_get_info_from_package_manager)
monkeypatch.setattr(nct.__class__, '_update_package_cache',
lambda *x: None)
nct._ext_init()
ret = nct._get_deps_list(top_level_package_with_version)
nct.server.close()
assert ret.split() == [
anoncreds_package_with_version, plenum_package_with_version,
node_package_with_version, top_level_package_dep2_with_version,
top_level_package_dep1_with_version, top_level_package_with_version
]
def validUpgrade(nodeIds, tconf, monkeypatch, pckg):
schedule = {}
unow = datetime.utcnow().replace(tzinfo=dateutil.tz.tzutc())
startAt = unow + timedelta(seconds=100)
acceptableDiff = tconf.MinSepBetweenNodeUpgrades + 1
for i in nodeIds:
schedule[i] = datetime.isoformat(startAt)
startAt = startAt + timedelta(seconds=acceptableDiff + 3)
patch_packet_mgr_output(monkeypatch, pckg[0], pckg[1])
return dict(name='upgrade-{}'.format(randomText(3)), version=bumpedVersion(pckg[1]),
action=START, schedule=schedule, timeout=1, package=pckg[0],
sha256='db34a72a90d026dae49c3b3f0436c8d3963476c77468ad955845a1ccf7b03f55')
def test_no_message_from_1_to_0(pluginManagerWithImportedModules):
topic = randomText(10)
name = randomText(10)
hdata = {'value': 1, 'cnt': 10}
nval = 0
config = {'bounds_coeff': 2,
'min_cnt': 10,
'min_activity_threshold': 0,
'use_weighted_bounds_coeff': True,
'enabled': True}
sent, _ = pluginManagerWithImportedModules.sendMessageUponSuspiciousSpike(topic, hdata, nval,
config, name, enabled=True)
assert sent == 3
hdata = {'value': 1, 'cnt': 10}
config = {'bounds_coeff': 2,
'min_cnt': 10,
'min_activity_threshold': 2,
'use_weighted_bounds_coeff': True,
'enabled': True}
assert pluginManagerWithImportedModules.sendMessageUponSuspiciousSpike(topic, hdata, nval,
config, name, enabled=True) is None
def pluginManager(monkeypatch):
pluginManager = PluginManager()
monkeypatch.setattr(importlib, 'import_module', mockImportModule)
packagesCnt = 3
packages = [pluginManager.prefix + randomText(10)
for _ in range(packagesCnt)]
monkeypatch.setattr(pip.utils, 'get_installed_distributions',
partial(mockGetInstalledDistributions,
packages=packages))
imported, found = pluginManager.importPlugins()
assert imported == 3
assert hasattr(pluginManager, 'prefix')
assert hasattr(pluginManager, '_sendMessage')
assert hasattr(pluginManager, '_findPlugins')
yield pluginManager
monkeypatch.undo()
def pluginManager(monkeypatch):
pluginManager = PluginManager()
monkeypatch.setattr(importlib, 'import_module', mockImportModule)
packagesCnt = 3
packages = [pluginManager.prefix + randomText(10)
for _ in range(packagesCnt)]
monkeypatch.setattr(pip.utils, 'get_installed_distributions',
partial(mockGetInstalledDistributions,
packages=packages))
imported, found = pluginManager.importPlugins()
assert imported == 3
assert hasattr(pluginManager, 'prefix')
assert hasattr(pluginManager, '_sendMessage')
assert hasattr(pluginManager, '_findPlugins')
yield pluginManager
monkeypatch.undo()
def pluginManagerWithImportedModules(pluginManager, monkeypatch):
monkeypatch.setattr(importlib_metadata, 'distributions',
partial(mockDistributions, packages=[]))
monkeypatch.setattr(importlib, 'import_module', mockImportModule)
imported, found = pluginManager.importPlugins()
assert imported == 0
packagesCnt = 3
packages = [
pluginManager.prefix + randomText(10) for _ in range(packagesCnt)
]
monkeypatch.setattr(importlib_metadata, 'distributions',
partial(mockDistributions, packages=packages))
imported, found = pluginManager.importPlugins()
assert imported == 3
yield pluginManager
monkeypatch.undo()
pluginManager.importPlugins()
def pluginManagerWithImportedModules(pluginManager, monkeypatch):
monkeypatch.setattr(pip.utils, 'get_installed_distributions',
partial(mockGetInstalledDistributions,
packages=[]))
monkeypatch.setattr(importlib, 'import_module', mockImportModule)
imported, found = pluginManager.importPlugins()
assert imported == 0
packagesCnt = 3
packages = [pluginManager.prefix + randomText(10)
for _ in range(packagesCnt)]
monkeypatch.setattr(pip.utils, 'get_installed_distributions',
partial(mockGetInstalledDistributions,
packages=packages))
imported, found = pluginManager.importPlugins()
assert imported == 3
yield pluginManager
monkeypatch.undo()
pluginManager.importPlugins()
def testPluginManagerSendsMessage(pluginManagerWithImportedModules):
topic = randomText(10)
message = randomText(20)
sent, pluginCnt = pluginManagerWithImportedModules._sendMessage(
topic, message)
assert sent == 3
def test_node_as_depend(monkeypatch, tconf):
nct = NodeControlTool(config=tconf)
top_level_package = (EXT_PKT_NAME, EXT_PKT_VERSION)
plenum_package = ('indy-plenum', '0.0.3')
python_crypto = ('python3-indy-crypto', '0.4.5')
libindy_crypto = ('libindy-crypto', '0.4.5')
top_level_package_with_version = '{}={}'.format(*top_level_package)
top_level_package_dep1_with_version = '{}={}'.format(*EXT_TOP_PKT_DEPS[0])
top_level_package_dep2_with_version = '{}={}'.format(*EXT_TOP_PKT_DEPS[1])
node_package_with_version = '{}={}'.format(*node_package)
plenum_package_with_version = '{}={}'.format(*plenum_package)
python_crypto_with_version = '{}={}'.format(*python_crypto)
libindy_crypto_with_version = '{}={}'.format(*libindy_crypto)
mock_info = {
top_level_package_with_version:
"{}\nVersion:{}\nDepends:{} (= {}), {} (= {}), {} (= {})\n".format(
randomText(100), top_level_package[1], *node_package,
*EXT_TOP_PKT_DEPS[0], *EXT_TOP_PKT_DEPS[1]),
node_package_with_version:
'{}\nVersion:{}\nDepends:{} (= {})\n'.format(randomText(100),
node_package[1],
*plenum_package),
plenum_package_with_version:
'{}\nVersion:{}\nDepends:{} (= {})\n'.format(randomText(100),
plenum_package[1],
*python_crypto),
top_level_package_dep1_with_version:
'{}\nVersion:{}\nDepends:{} (= {})\n'.format(randomText(100),
EXT_TOP_PKT_DEPS[0][1],
*plenum_package),
top_level_package_dep2_with_version:
'{}\nVersion:{}\nDepends:{} (= {})\n'.format(randomText(100),
EXT_TOP_PKT_DEPS[1][1],
*node_package),
python_crypto_with_version:
'{}\nVersion:{}\nDepends:{} (= {})\n'.format(randomText(100),
python_crypto[1],
*libindy_crypto),
libindy_crypto_with_version:
'{}\nVersion:{}\nDepends: \n{}'.format(randomText(100),
libindy_crypto[1],
randomText(100)),
}
def mock_get_info_from_package_manager(*package):
ret = ""
for p in package:
ret += mock_info.get(p, "")
return ret
monkeypatch.setattr(NodeControlUtil, 'update_package_cache',
lambda *x: None)
monkeypatch.setattr(NodeControlUtil, '_get_info_from_package_manager',
lambda *x: mock_get_info_from_package_manager(*x))
monkeypatch.setattr(
NodeControlUtil, 'get_sys_holds', lambda *x: [
top_level_package[0], plenum_package[0], node_package[0],
EXT_TOP_PKT_DEPS[0][0], EXT_TOP_PKT_DEPS[1][0], python_crypto[
0], libindy_crypto[0]
])
monkeypatch.setattr(NodeControlUtil, '_get_curr_info',
lambda *x: PACKAGE_MNG_EXT_PTK_OUTPUT)
ret = nct._get_deps_list(top_level_package_with_version)
nct.server.close()
assert sorted(ret.split()) == sorted([
libindy_crypto_with_version, python_crypto_with_version,
plenum_package_with_version, node_package_with_version,
top_level_package_dep2_with_version,
top_level_package_dep1_with_version, top_level_package_with_version
])
def sdk_wallet_name():
w_name = "wallet_name_" + randomText(13)
yield w_name
w_dir = os.path.join(os.path.expanduser("~/.indy_client/wallet"), w_name)
if os.path.isdir(w_dir):
shutil.rmtree(w_dir, ignore_errors=True)
def sdk_pool_name():
p_name = "pool_name_" + randomText(13)
yield p_name
p_dir = os.path.join(os.path.expanduser("~/.indy_client/pool"), p_name)
if os.path.isdir(p_dir):
shutil.rmtree(p_dir, ignore_errors=True)
def testPluginManagerSendsMessage(pluginManagerWithImportedModules):
topic = randomText(10)
message = randomText(20)
sent, pluginCnt = pluginManagerWithImportedModules._sendMessage(
topic, message)
assert sent == 3
