def _parse_openvz_hosting(cls, page):
table = page.find('div', {'class': 'uds-pricing-table'})
thead = page.find('thead')
tfoot = page.find('tfoot')
number_of_entries = len(
table.find('tr', {
'class': 'even'
}).find_all('td'))
for idx in range(1, number_of_entries + 1):
header_elements = thead.find_all('tr')[1].find(
'th', {
'class': 'column-' + str(idx)
}).find_all('p')
list_elements = table.find_all('td',
{'class': 'column-' + str(idx)})
link_element = tfoot.find('th', {'class': 'column-' + str(idx)})
yield VpsOption(
name=header_elements[0].text,
storage=list_elements[2].text.strip().split('GB')[0],
cores=list_elements[0].text.strip().split(' ')[0].split('\xa0')
[0],
memory=list_elements[1].text.strip().split(' ')[0],
bandwidth=list_elements[3].text.replace('TB', '').strip(),
connection=list_elements[4].text.strip().split('Gbps')[0],
price=float(header_elements[1].text[1:]),
purchase_url=link_element.find('a')['href'],
)
def get_options(cls):
"""
Linux (OpenVZ) and Windows (KVM) pages are slightly different, therefore their pages are parsed by different
methods. Windows configurations allow a selection of Linux distributions, but not vice-versa.
:return: possible configurations.
"""
context = ssl._create_unverified_context()
url = ProxHost.BASE_URL + '/options'
response = request.urlopen(url, context=context)
response_json = json.loads(response.read().decode('utf-8'))
options = []
for joption in response_json:
options.append(VpsOption(
name=joption['name'],
storage=joption['storage'],
cores=joption['cores'],
memory=joption['memory'],
bandwidth='unmetered',
connection=joption['connection'],
price=joption['price'],
purchase_url=str(joption['vmid'])
))
return list(options)
def _parse_openvz_hosting(cls, page):
openvz = page.find('div', {'id': 'tab1'})
options = openvz.find_all('aside', {'class': 'plan1'})
for option in options:
first_price_option = option.find('select', {
'class': 'field2'
}).find('option')
yield VpsOption(
name=option.find('h3').text.strip(),
storage=int(
option.find('li', {
'class': 'icon3'
}).text.split(' ')[0]),
cores=int(
option.find('li', {
'class': 'icon2'
}).text.split(' ')[0]),
memory=int(
option.find('li', {
'class': 'icon6'
}).text.split(' ')[0]),
bandwidth=int(
option.find('li', {
'class': 'icon4'
}).text.split(' ')[0]),
connection=int(
option.find('li', {
'class': 'icon5'
}).text.split(' ')[0]),
price=float(
first_price_option.text.split('$')[1].split('/')[0]),
purchase_url=first_price_option['value'])
def _parse_row(row):
details = row.findAll('td')
name = details[0].text
price = details[6].text
if 'yearly only' in price:
return None # Only yearly price possible
try:
i = price.index('/')
except ValueError:
return None # Invalid price string
price = int(price[1:i])
cores = int(details[3].text[0])
memory = float(details[1].text[0:4]) / 1000
storage = details[2].text.split(' GB')
storage = int(storage[0])
bandwidth = details[4].text.split(' GB')
bandwidth = bandwidth[0]
connection = details[4].text
i = connection.index('Gbps')
connection = int(connection[i - 1])
purchase_url = details[7].find('a')['href']
return VpsOption(name, cores, memory, storage, bandwidth, connection,
price, purchase_url)
def _parse_linux_option(package):
option = {
'name':
package.find('h3').text,
'price':
package.find('div', {
'class': 'price'
}).text.split('$')[1].split('USD/mo')[0],
'purchase_url':
'https://ua.2sync.org/' + package.find('a').get('href')
}
for entry in package.find_all('li'):
key, value = entry.text.replace('\n', '').split(' ')[:2]
option[key] = value
return VpsOption(
name=option['name'],
storage=option['Space'].split('GB')[0],
cores=option['CPU'],
memory=option['RAM'].split('GB')[0],
bandwidth=maxsize,
connection=int(option['Port'].split('Gbit')[0]),
price=float(option['price']),
purchase_url=option['purchase_url'],
)
def _parse_openvz_hosting(cls, page):
# table = page.find_all('div', {'class': 'wpb_wrapper'})[2]
table = page.find('table')
options = table.find_all('tr')
options.pop(0)
for idx, option in enumerate(options, start=1):
list_elements = option.find_all('td')
# price_eur = float(option.find('div', {'class', 'price'}).span.text[1:])
# c = CurrencyConverter()
# price_usd = float(option.find('', {'class', 'price'}).span.text[1:])
# list_elements[2].text.strip().split(' ')[0],
yield VpsOption(
name=list_elements[0].text.strip().split('\xa0')[0],
storage=list_elements[2].text.strip().split('GB')[0],
cores=list_elements[1].text.strip().split(' ')[0].split('\xa0')
[0],
memory=list_elements[0].text.strip().split('\xa0')[0],
bandwidth=list_elements[4].text.strip().split(' ')[0].replace(
'TB', ''),
connection=list_elements[3].text.strip().split('Gbps')[0],
price=float(
list_elements[6].text.split("\"")[0].split("/")[0][1:]),
purchase_url=list_elements[7].find('a',
{'class': 'w-btn'})['href'],
)
def _parse_blue_options(column, is_kvm=False):
if is_kvm:
split_char = ' '
else:
split_char = ':'
price = column.find('div', {'class': 'plan_price_m'}).text.strip()
price = price.split('$')[1].split('/')[0]
planinfo = column.find('ul', {'class': 'plan_info_list'})
info = planinfo.findAll('li')
cpu = info[0].text.split(split_char)[1].strip()
ram = info[1].text.split(split_char)[1].strip()
storage = info[2].text.split(split_char)[1].strip()
connection = info[3].text.split(split_char)[1].strip()
bandwidth = info[4].text.split("h")[1].strip()
return VpsOption(
name=column.find('div', {'class': 'plan_title'}).find('h4').text,
price=float(price),
cores=int(cpu.split('C')[0].strip()),
memory=float(ram.split('G')[0].strip()),
storage=float(storage.split('G')[0].strip()),
connection=int(connection.split('G')[0].strip()) * 1000,
bandwidth=float(bandwidth.split('T')[0].strip()),
purchase_url=column.find('a')['href']
)
def _create_option():
return VpsOption(name="Option name",
memory="Option ram",
cores="Option cpu",
storage="Option storage",
bandwidth="Option bandwidth",
price=12,
connection="Option connection",
purchase_url="Option url")
def _parse_kvm_option(plan, name):
elements = plan.findAll("div", {'class': 'info'})
eur = float(plan.find('div', {'class': 'plans-price'}).span.text.replace('\u20AC', ''))
option = VpsOption(
name=name,
storage=elements[0].text.split(' GB')[0],
cores=elements[1].text.split(' vCore')[0],
memory=elements[3].text.split(' GB')[0],
bandwidth='unmetered',
connection=int(elements[4].text.split(' GB')[0]) * 1000,
price=round(CurrencyRates().convert("EUR", "USD", eur), 2),
purchase_url=plan.a['href'],
)
return option
def _parse_cci_options(column):
header = column.find('div', class_='phead')
price = column.find('span', class_='starting-price')
info = column.find('ul').findAll('li')
return VpsOption(
name=header.find('h2').contents[0],
price=float(price.contents[0]),
cores=int(info[1].find('strong').contents[0]),
memory=float(info[2].find('strong').contents[0]),
storage=float(info[3].find('strong').contents[0]),
bandwidth=sys.maxsize,
connection=
0.01, # See FAQ at https://www.ccihosting.com/offshore-vps.html
purchase_url=column.find('a')['href'])
def _parse_linux_option(url, table, name, i):
option = VpsOption(
name=name,
storage=str(table[3 + (i * 8)]).split('g>')[1].split('<')[0],
cores=str(table[1 + (i * 8)]).split('g>')[1].split('<')[0],
memory=str(table[2 + (i * 8)]).split('g>')[1].split('GB')[0],
bandwidth='unmetered',
connection=int(
str(table[5 + (i * 8)]).split('g>')[1].split('Gbps')[0]) *
1000,
price=float(str(table[7 + (i * 8)]).split('$')[1].split('/mo')[0]),
purchase_url=url,
)
return option
def _parse_linux_option(price, name, info, url, storage):
elements = str(info).split('<br/>')
price = price.replace(',', '.')
c = CurrencyConverter()
option = VpsOption(
name=str(name).strip(),
storage=storage,
cores=float(
(elements[0].split('>')[1].split(' CPU-Cores')[0]).strip()),
memory=float((elements[2].split('GB Arbeitsspeicher')[0]).strip()),
bandwidth='unmetered',
connection=(int(elements[3].split('GB')[0]) * 1000),
price=round(c.convert(price, 'EUR', 'USD'), 2),
purchase_url=str(url).strip(),
)
return option
def _parse_openvz_ssd_hosting(cls, page):
options = page.find_all('div',
{'class': 'crumina-pricing-tables-item'})
for option in options:
price_usd = float(option.find('h2', {'class': 'rate'}).text[1:])
list_elements = option.find_all('li', {'class': 'position-item'})
yield VpsOption(
name=option.find('h5', {
'class': 'pricing-title'
}).text.strip(),
storage=list_elements[2].text.strip().split(' ')[2],
cores=list_elements[5].text.strip().split(' ')[1],
memory=cls.parse_memory(list_elements[0]),
bandwidth=cls.parse_bandwidth(list_elements[8]),
connection=list_elements[9].text.strip().split(' ')[2].replace(
'Gbit', ''),
price=price_usd,
purchase_url=option.find('a', {'class', 'btn'})['href'])
def _parse_openvz_hosting(cls, page):
options = page.find_all('li', {'class': 'virtual'})
for idx, option in enumerate(options, start=1):
list_elements = option.find_all('span', {"class": "right"})
price_eur = float(
option.find('span', {'class', 'price_figure'}).text[1:])
c = CurrencyConverter()
price_usd = round(c.convert(price_eur, 'EUR', 'USD'), 2)
yield VpsOption(
name=option.find('h3').text.strip().replace(
"Virtual Server - ", ""),
storage=list_elements[1].text.strip().split(' ')[0][:-2],
cores=list_elements[2].text.strip().split(' ')[0],
memory=float(list_elements[0].text.strip().split(' ')[0][:-2])
/ 1024,
bandwidth=cls.parse_bandwidth(list_elements[3]),
connection=1,
price=price_usd,
purchase_url=option.find_all(
'a', {'class': 'action_button'})[1]['href'],
)
def _parse_openvz_hosting(cls, page):
options = page.find_all('div', {'class': 'price-table'})
for idx, option in enumerate(options, start=1):
list_elements = option.find_all('li')
price_eur = float(
option.find('div', {'class', 'price'}).span.text[1:])
c = CurrencyConverter()
price_usd = round(c.convert(price_eur, 'EUR', 'USD'), 2)
yield VpsOption(
name=option.find('div', {
'class': 'top-area'
}).text.strip(),
storage=list_elements[2].text.strip().split(' ')[0].split(
'GB')[0],
cores=list_elements[0].text.strip().split(' ')[0],
memory=list_elements[1].text.strip().split(' ')[0],
bandwidth=sys.maxsize,
connection=1,
price=price_usd,
purchase_url='https://panel.linevast.de' +
option.find('a', {'class': 'order-button'})['href'],
)
import jsonpickle
import copy
import sys
import cloudomate.hoster.vps.blueangelhost as blueAngel
import cloudomate.hoster.vps.linevast as lineVast
from typing import Tuple, List
from CaseInsensitiveDict import CaseInsensitiveDict
default_messaging_channel = 'learning'
vps_options = [
VpsOption(name='Option 1',
storage=2,
cores=2,
memory=2,
bandwidth="mock",
connection="1",
price=11.5,
purchase_url="mock"),
VpsOption(name='Option 2',
storage=2,
cores=2,
memory=2,
bandwidth="mock",
connection="1",
price=8.0,
purchase_url="mock"),
VpsOption(name='Option 3',
storage=2,
cores=2,
memory=2,
class TestCore(unittest.TestCase):
def test_create_wallet_testnet(self):
self.settings = plebnet_settings.Init.wallets_testnet
self.logger = logger.log
self.wallet = wallet_controller.create_wallet
self.wallet_created = plebnet_settings.Init.wallets_testnet_created
self.initiated = plebnet_settings.Init.wallets_initiate_once
self.write = plebnet_settings.write
plebnet_settings.Init.wallets_testnet = MagicMock(return_value=True)
logger.log = MagicMock()
wallet_controller.create_wallet = MagicMock(return_value=True)
plebnet_settings.Init.wallets_testnet_created = MagicMock()
plebnet_settings.Init.wallets_initiate_once = MagicMock()
plebnet_settings.write = MagicMock()
Core.create_wallet()
self.assertEqual(os.environ.get('TESTNET'), '1')
os.environ['TESTNET'] = '0'
plebnet_settings.Init.wallets_testnet = self.settings
logger.log = self.logger
wallet_controller.create_wallet = self.wallet
plebnet_settings.Init.wallets_testnet_created = self.wallet_created
plebnet_settings.Init.wallets_initiate_once = self.initiated
plebnet_settings.write = self.write
def test_create_wallet_bitcoin(self):
self.settings = plebnet_settings.Init.wallets_testnet
self.logger = logger.log
self.wallet = wallet_controller.create_wallet
self.initiated = plebnet_settings.Init.wallets_initiate_once
self.write = plebnet_settings.setting.Settings.write
plebnet_settings.Init.wallets_testnet = MagicMock(return_value=False)
logger.log = MagicMock()
wallet_controller.create_wallet = MagicMock(return_value=True)
plebnet_settings.Init.wallets_initiate_once = MagicMock()
plebnet_settings.setting.Settings.write = MagicMock()
Core.create_wallet()
plebnet_settings.Init.wallets_initiate_once.assert_called_once()
plebnet_settings.setting.Settings.write.assert_called_once()
plebnet_settings.Init.wallets_testnet = self.settings
logger.log = self.logger
wallet_controller.create_wallet = self.wallet
plebnet_settings.Init.wallets_initiate_once = self.initiated
plebnet_settings.setting.Settings.write = self.write
def test_check_tribler_true(self):
self.running = tribler_controller.running
self.logger = logger.log
tribler_controller.running = MagicMock(return_value=True)
logger.log = MagicMock()
assert Core.check_tribler()
tribler_controller.running = self.running
logger.log = self.logger
def test_check_tribler_false(self):
self.running = tribler_controller.running
self.start = tribler_controller.start
self.logger = logger.log
tribler_controller.start = MagicMock()
tribler_controller.running = MagicMock(return_value=False)
logger.log = MagicMock()
self.assertFalse(Core.check_tribler())
tribler_controller.running = self.running
logger.log = self.logger
tribler_controller.start = self.start
def test_setup(self):
self.logger = logger.log
self.provider = cloudomate_controller.get_vps_providers
self.settings = plebnet_settings.Init.wallets_testnet
self.fake = fake_generator.generate_child_account
self.irc_nic = plebnet_settings.Init.irc_nick
self.irc_def = plebnet_settings.Init.irc_nick_def
self.save = PlebNetConfig.save
self.init_client = irc_handler.init_irc_client
self.start_client = irc_handler.start_irc_client
self.success = logger.success
self.load = PlebNetConfig.load
self.exit = plebnet_settings.Init.tribler_exitnode
args = MagicMock()
args.testnet = True
logger.log = MagicMock()
fake_generator.generate_child_account = MagicMock()
plebnet_settings.Init.wallets_testnet = MagicMock()
cloudomate_controller.get_vps_providers = MagicMock()
plebnet_settings.Init.irc_nick = MagicMock()
plebnet_settings.Init.irc_nick_def = MagicMock()
PlebNetConfig.save = MagicMock()
PlebNetConfig.load = MagicMock()
irc_handler.init_irc_client = MagicMock()
irc_handler.start_irc_client = MagicMock()
logger.success = MagicMock()
plebnet_settings.Init.tribler_exitnode = MagicMock()
Core.setup(args)
logger.success.assert_called_once()
logger.log = self.logger
cloudomate_controller.get_vps_providers = self.provider
plebnet_settings.Init.wallets_testnet = self.settings
fake_generator.generate_child_account = self.fake
plebnet_settings.Init.irc_nick = self.irc_nic
plebnet_settings.Init.irc_nick_def = self.irc_def
PlebNetConfig.save = self.save
PlebNetConfig.load = self.load
irc_handler.init_irc_client = self.init_client
irc_handler.start_irc_client = self.start_client
logger.success = self.success
plebnet_settings.Init.tribler_exitnode = self.exit
@mock.patch('plebnet.agent.core.attempt_purchase')
@mock.patch('plebnet.settings.plebnet_settings.Init.wallets_initiate_once',
return_value=False)
@mock.patch(
'plebnet.settings.plebnet_settings.Init.wallets_testnet_created',
return_value=True)
@mock.patch('plebnet.agent.core.check_tribler', return_value=False)
@mock.patch('plebnet.agent.core.vpn_is_running', return_value=True)
@mock.patch('plebnet.agent.core.create_wallet')
@mock.patch('plebnet.agent.core.select_provider')
@mock.patch('plebnet.agent.core.strategies')
@mock.patch('plebnet.agent.core.install_vps')
@mock.patch('plebnet.controllers.market_controller.has_matchmakers',
return_value=True)
@mock.patch('plebnet.agent.config.PlebNetConfig.load', return_value=False)
def test_check(self, mock1, mock2, mock3, mock4, mock5, mock6, mock7,
mock8, mock9, mock10, mock11):
self.logger = logger.log
logger.log = MagicMock()
Core.strategies['test']().apply = MagicMock()
Core.check()
os.environ['TESTNET'] = '0'
plebnet_settings.Init.wallets_testnet_created = MagicMock(
return_value=False)
Core.check_tribler = MagicMock(return_value=True)
Core.check()
Core.install_vps.assert_called_once()
Core.strategies['test']().apply.assert_called_once()
Core.create_wallet.assert_called_once()
logger.log = self.logger
@mock.patch('plebnet.controllers.cloudomate_controller.get_vps_providers',
return_value=CaseInsensitiveDict(
{'blueangelhost': blueAngel.BlueAngelHost}))
@mock.patch('plebnet.controllers.cloudomate_controller.options',
return_value=[
VpsOption(name='Advanced',
storage=2,
cores=2,
memory=2,
bandwidth="4.0",
connection="1",
price=100.0,
purchase_url="mock"),
VpsOption(name='Basic Plan',
storage=2,
cores=2,
memory=2,
bandwidth="1.0",
connection="1",
price=10.0,
purchase_url="mock")
])
def test_attempt_purchase(self, mock1, mock2):
self.log = logger.log
self.testnet = plebnet_settings.Init.wallets_testnet
self.get = PlebNetConfig.get
self.get_balance = market_controller.get_balance
self.calculate_price = cloudomate_controller.calculate_price
self.purchase_choice = cloudomate_controller.purchase_choice
self.set = PlebNetConfig.set
self.save = PlebNetConfig.save
self.vpn = Core.attempt_purchase_vpn
self.new = PlebNetConfig.increment_child_index
self.provider = cloudomate_controller.get_vps_providers
self.fg = fake_generator.generate_child_account
self.qtable = QTable()
self.providers = cloudomate_controller.get_vps_providers()
providers = cloudomate_controller.get_vps_providers()
self.qtable.init_qtable_and_environment(providers)
self.qtable.set_self_state(VPSState("blueangelhost", "Basic Plan"))
logger.log = MagicMock()
plebnet_settings.Init.wallets_testnet = MagicMock(return_value=False)
PlebNetConfig.get = MagicMock(
return_value=['blueangelhost', 'Basic Plan', 0])
market_controller.get_balance = MagicMock(return_value=100000000)
Core.qtable = self.qtable
Core.attempt_purchase_vpn = MagicMock(return_value=False)
cloudomate_controller.calculate_price = MagicMock(return_value=0.01)
cloudomate_controller.purchase_choice = MagicMock(
return_value=plebnet_settings.SUCCESS)
PlebNetConfig.set = MagicMock()
PlebNetConfig.save = MagicMock()
PlebNetConfig.increment_child_index = MagicMock()
cloudomate_controller.get_vps_providers = MagicMock()
fake_generator.generate_child_account = MagicMock()
Core.config = PlebNetConfig
qtable_copy = copy.deepcopy(Core.qtable.qtable)
Core.attempt_purchase()
self.assertLess(
qtable_copy['blueangelhost_basic plan']
['blueangelhost_basic plan'],
Core.qtable.qtable['blueangelhost_basic plan']
['blueangelhost_basic plan'])
qtable_copy = copy.deepcopy(Core.qtable.qtable)
cloudomate_controller.purchase_choice = MagicMock(
return_value=plebnet_settings.FAILURE)
Core.attempt_purchase()
self.assertGreater(
qtable_copy['blueangelhost_basic plan']
['blueangelhost_basic plan'],
Core.qtable.qtable['blueangelhost_basic plan']
['blueangelhost_basic plan'])
logger.log = self.log
plebnet_settings.Init.wallets_testnet = self.testnet
PlebNetConfig.get = self.get
market_controller.get_balance = self.get_balance
cloudomate_controller.calculate_price = self.calculate_price
cloudomate_controller.purchase_choice = self.purchase_choice
Core.attempt_purchase_vpn = self.vpn
PlebNetConfig.set = self.set
PlebNetConfig.save = self.save
PlebNetConfig.increment_child_index = self.new
cloudomate_controller.get_vps_providers = self.provider
fake_generator.generate_child_account = self.fg
def test_install_vps(self):
self.ias = server_installer.install_available_servers
server_installer.install_available_servers = MagicMock()
Core.install_vps()
server_installer.install_available_servers.assert_called_once()
server_installer.install_available_servers = self.ias
def test_attempt_purchase_vpn(self):
self.vpnset = plebnet_settings.Init.vpn_host
self.vpnpro = cloudomate_controller.get_vpn_providers
self.wall = plebnet_settings.Init.wallets_testnet
self.bal = market_controller.get_balance
self.price = cloudomate_controller.calculate_price_vpn
self.pur = cloudomate_controller.purchase_choice_vpn
self.suc = logger.success
self.log = logger.log
self.err = logger.error
cloudomate_controller.purchase_choice_vpn = MagicMock(
return_value=plebnet_settings.SUCCESS)
plebnet_settings.Init.vpn_host = MagicMock()
cloudomate_controller.get_vpn_providers = MagicMock(
return_value='String')
plebnet_settings.Init.wallets_testnet = MagicMock(return_value=True)
market_controller.get_balance = MagicMock(return_value=1100000)
cloudomate_controller.calculate_price_vpn = MagicMock(
return_value=0.01)
logger.success = MagicMock()
logger.log = MagicMock()
logger.error = MagicMock()
Core.attempt_purchase_vpn()
logger.success.assert_called_once()
cloudomate_controller.purchase_choice_vpn = MagicMock(
return_value=plebnet_settings.FAILURE)
plebnet_settings.Init.wallets_testnet = MagicMock(return_value=False)
Core.attempt_purchase_vpn()
logger.error.assert_called_once()
plebnet_settings.Init.vpn_host = self.vpnset
cloudomate_controller.get_vpn_providers = self.vpnpro
plebnet_settings.Init.wallets_testnet = self.wall
market_controller.get_balance = self.bal
cloudomate_controller.calculate_price_vpn = self.price
cloudomate_controller.purchase_choice_vpn = self.pur
logger.success = self.suc
logger.log = self.log
logger.error = self.err
def test_vpn_is_running(self):
self.pid = plebnet_settings.Init.vpn_pid
self.run = plebnet_settings.Init.vpn_running
self.call = subprocess.call
plebnet_settings.Init.vpn_pid = MagicMock(return_value='String')
plebnet_settings.Init.vpn_running = MagicMock()
subprocess.call = MagicMock(return_value=0)
assert Core.vpn_is_running()
subprocess.call = MagicMock(return_value=1)
self.assertFalse(Core.vpn_is_running())
plebnet_settings.Init.vpn_pid = self.pid
plebnet_settings.Init.vpn_running = self.run
subprocess.call = self.call
def test_check_vpn_install(self):
self.vpn_installed = plebnet_settings.Init.vpn_installed
self.log = logger.log
self.ospath = os.path.join
self.path = plebnet_settings.Init.vpn_config_path
self.pre = plebnet_settings.Init.vpn_own_prefix
self.cre = plebnet_settings.Init.vpn_credentials_name
self.nam = plebnet_settings.Init.vpn_config_name
self.lis = os.listdir
self.isf = os.path.isfile
self.civ = Core.install_vpn
self.cpr = plebnet_settings.Init.vpn_child_prefix
self.usr = os.path.expanduser
self.vpn_running = Core.vpn_is_running
plebnet_settings.Init.vpn_installed = MagicMock(return_value=True)
logger.log = MagicMock()
os.path.join = MagicMock(return_value='String')
Core.vpn_is_running = MagicMock(return_value=True)
plebnet_settings.Init.vpn_config_path = MagicMock()
plebnet_settings.Init.vpn_own_prefix = MagicMock()
plebnet_settings.Init.vpn_credentials_name = MagicMock(
return_value='cred_name')
plebnet_settings.Init.vpn_config_name = MagicMock(
return_value='config_name')
os.listdir = MagicMock(return_value=[])
os.path.isfile = MagicMock(return_value=False)
os.path.expanduser = MagicMock()
assert Core.check_vpn_install()
Core.vpn_is_running = MagicMock(return_value=False)
os.path.isfile = MagicMock(return_value=True)
Core.install_vpn = MagicMock(return_value=False)
plebnet_settings.Init.vpn_installed = MagicMock(return_value=False)
self.assertFalse(Core.check_vpn_install())
Core.install_vpn = MagicMock(return_value=True)
assert Core.check_vpn_install()
os.listdir = MagicMock(
return_value=['child_pre0config_name', 'child_pre0cred_name'])
plebnet_settings.Init.vpn_child_prefix = MagicMock(
return_value='child_pre')
os.path.isfile = MagicMock(return_value=False)
self.assertFalse(Core.check_vpn_install())
plebnet_settings.Init.vpn_installed = self.vpn_installed
logger.log = self.log
os.path.join = self.ospath
plebnet_settings.Init.vpn_config_path = self.path
plebnet_settings.Init.vpn_own_prefix = self.pre
plebnet_settings.Init.vpn_credentials_name = self.cre
plebnet_settings.Init.vpn_config_name = self.nam
os.listdir = self.lis
os.path.isfile = self.isf
Core.install_vpn = self.civ
plebnet_settings.Init.vpn_child_prefix = self.cpr
os.path.expanduser = self.usr
Core.vpn_is_running = self.vpn_running
class TestQTable(unittest.TestCase):
qtable = {}
providers = {}
option = {}
@mock.patch('plebnet.controllers.cloudomate_controller.get_vps_providers',
return_value=CaseInsensitiveDict(
{'blueangelhost': blueAngel.BlueAngelHost}))
@mock.patch('plebnet.controllers.cloudomate_controller.options',
return_value=[
VpsOption(name='Advanced',
storage=2,
cores=2,
memory=2,
bandwidth="mock",
connection="1",
price=100.0,
purchase_url="mock"),
VpsOption(name='Basic Plan',
storage=2,
cores=2,
memory=2,
bandwidth="mock",
connection="1",
price=10.0,
purchase_url="mock")
])
def setUp(self, mock1, mock2):
self.qtable = QTable()
self.providers = cloudomate_controller.get_vps_providers()
def tearDown(self):
del self.qtable
del self.providers
@mock.patch('plebnet.controllers.cloudomate_controller.get_vps_providers',
return_value=CaseInsensitiveDict(
{'blueangelhost': blueAngel.BlueAngelHost}))
@mock.patch('plebnet.controllers.cloudomate_controller.options',
return_value=[
VpsOption(name='Advanced',
storage=2,
cores=2,
memory=2,
bandwidth="mock",
connection="1",
price=100.0,
purchase_url="mock"),
VpsOption(name='Basic Plan',
storage=2,
cores=2,
memory=2,
bandwidth="mock",
connection="1",
price=10.0,
purchase_url="mock")
])
def test_init_providers(self, mock1, mock2):
assert (len(self.qtable.providers_offers) == 0)
self.qtable.init_providers_offers(self.providers)
assert (len(self.qtable.providers_offers) > 0)
@mock.patch('plebnet.controllers.cloudomate_controller.get_vps_providers',
return_value=CaseInsensitiveDict(
{'blueangelhost': blueAngel.BlueAngelHost}))
@mock.patch('plebnet.controllers.cloudomate_controller.options',
return_value=[
VpsOption(name='Advanced',
storage=2,
cores=2,
memory=2,
bandwidth="mock",
connection="1",
price=100.0,
purchase_url="mock"),
VpsOption(name='Basic Plan',
storage=2,
cores=2,
memory=2,
bandwidth="mock",
connection="1",
price=10.0,
purchase_url="mock")
])
def test_init_qtable_and_environment(self, mock1, mock2):
assert (len(self.qtable.environment) == 0)
self.qtable.init_qtable_and_environment(self.providers)
assert (len(self.qtable.environment) > 0)
assert (len(self.qtable.qtable) > 0)
@mock.patch('plebnet.controllers.cloudomate_controller.get_vps_providers',
return_value=CaseInsensitiveDict(
{'blueangelhost': blueAngel.BlueAngelHost}))
@mock.patch('plebnet.controllers.cloudomate_controller.options',
return_value=[
VpsOption(name='Advanced',
storage=2,
cores=2,
memory=2,
bandwidth="mock",
connection="1",
price=100.0,
purchase_url="mock"),
VpsOption(name='Basic Plan',
storage=2,
cores=2,
memory=2,
bandwidth="mock",
connection="1",
price=10.0,
purchase_url="mock")
])
def test_calculate_measure(self, mock1, mock2):
provider_offer = ProviderOffer(provider_name="mock provider",
name="mock name",
bandwidth=3,
price=5,
memory=2)
assert (self.qtable.calculate_measure(provider_offer) == 0.024)
@mock.patch('plebnet.controllers.cloudomate_controller.get_vps_providers',
return_value=CaseInsensitiveDict(
{'blueangelhost': blueAngel.BlueAngelHost}))
@mock.patch('plebnet.controllers.cloudomate_controller.options',
return_value=[
VpsOption(name='Advanced',
storage=2,
cores=2,
memory=2,
bandwidth="mock",
connection="1",
price=100.0,
purchase_url="mock"),
VpsOption(name='Basic Plan',
storage=2,
cores=2,
memory=2,
bandwidth="mock",
connection="1",
price=10.0,
purchase_url="mock")
])
def test_calculate_measure_unmetric_bandwidth(self, mock1, mock2):
self.qtable.init_qtable_and_environment(self.providers)
assert (self.qtable.calculate_measure(
self.qtable.providers_offers[1]) == 0.01)
@mock.patch('plebnet.controllers.cloudomate_controller.get_vps_providers',
return_value=CaseInsensitiveDict(
{'blueangelhost': blueAngel.BlueAngelHost}))
@mock.patch('plebnet.controllers.cloudomate_controller.options',
return_value=[
VpsOption(name='Advanced',
storage=2,
cores=2,
memory=2,
bandwidth="mock",
connection="1",
price=100.0,
purchase_url="mock"),
VpsOption(name='Basic Plan',
storage=2,
cores=2,
memory=2,
bandwidth="mock",
connection="1",
price=10.0,
purchase_url="mock")
])
def test_update_environment_positive(self, mock1, mock2):
blue_angel_offers = cloudomate_controller.options(
self.providers["blueangelhost"])
self.qtable.self_state = VPSState("blueangelhost",
blue_angel_offers[0].name)
self.qtable.init_qtable_and_environment(self.providers)
environment_copy = copy.deepcopy(self.qtable.environment)
vps_options_list = cloudomate_controller.options(self.providers)
vps_option = vps_options_list[0]
provider_offer_ID = str(self.providers.keys()[0]).lower() + "_" + str(
vps_option.name).lower()
provider_offer_ID_other = str(
self.providers.keys()[0]).lower() + "_" + str(
vps_options_list[1].name).lower()
self.qtable.update_environment(provider_offer_ID, True, 0)
assert (environment_copy != self.qtable.environment)
assert (environment_copy[provider_offer_ID_other]
[provider_offer_ID_other] == self.qtable.
environment[provider_offer_ID_other][provider_offer_ID_other])
assert (environment_copy[provider_offer_ID][provider_offer_ID] <
self.qtable.environment[provider_offer_ID][provider_offer_ID])
assert (self.qtable.environment[provider_offer_ID][provider_offer_ID]
== 0.4)
@mock.patch('plebnet.controllers.cloudomate_controller.get_vps_providers',
return_value=CaseInsensitiveDict(
{'blueangelhost': blueAngel.BlueAngelHost}))
@mock.patch('plebnet.controllers.cloudomate_controller.options',
return_value=[
VpsOption(name='Advanced',
storage=2,
cores=2,
memory=2,
bandwidth="mock",
connection="1",
price=100.0,
purchase_url="mock"),
VpsOption(name='Basic Plan',
storage=2,
cores=2,
memory=2,
bandwidth="mock",
connection="1",
price=10.0,
purchase_url="mock")
])
def test_update_environment_negative(self, mock1, mock2):
blue_angel_offers = cloudomate_controller.options(
self.providers["blueangelhost"])
self.qtable.self_state = VPSState("blueangelhost",
blue_angel_offers[0].name)
self.qtable.init_qtable_and_environment(self.providers)
environment_copy = copy.deepcopy(self.qtable.environment)
vps_options_list = cloudomate_controller.options(self.providers)
vps_option = vps_options_list[0]
provider_offer_ID = str(self.providers.keys()[0]).lower() + "_" + str(
vps_option.name).lower()
provider_offer_ID_other = str(
self.providers.keys()[0]).lower() + "_" + str(
vps_options_list[1].name).lower()
self.qtable.update_environment(provider_offer_ID, False, 0)
assert (environment_copy != self.qtable.environment)
assert (environment_copy[provider_offer_ID][provider_offer_ID] >
self.qtable.environment[provider_offer_ID][provider_offer_ID])
assert (environment_copy[provider_offer_ID][provider_offer_ID_other] ==
self.qtable.environment[provider_offer_ID]
[provider_offer_ID_other])
assert (self.qtable.environment[provider_offer_ID][provider_offer_ID]
== -0.4)
@mock.patch('plebnet.controllers.cloudomate_controller.get_vps_providers',
return_value=CaseInsensitiveDict(
{'blueangelhost': blueAngel.BlueAngelHost}))
@mock.patch('plebnet.controllers.cloudomate_controller.options',
return_value=[
VpsOption(name='Advanced',
storage=2,
cores=2,
memory=2,
bandwidth="mock",
connection="1",
price=100.0,
purchase_url="mock"),
VpsOption(name='Basic Plan',
storage=2,
cores=2,
memory=2,
bandwidth="mock",
connection="1",
price=10.0,
purchase_url="mock")
])
def test_update_values_positive(self, mock1, mock2):
blue_angel_offers = cloudomate_controller.options(
self.providers["blueangelhost"])
self.qtable.self_state = VPSState("blueangelhost",
blue_angel_offers[0].name)
self.qtable.init_qtable_and_environment(self.providers)
self.qtable.init_alpha_and_beta()
qtable_copy = copy.deepcopy(self.qtable.qtable)
vps_options_list = cloudomate_controller.options(self.providers)
vps_option = vps_options_list[0]
provider_offer_ID = str(self.providers.keys()[0]).lower() + "_" + str(
vps_option.name).lower()
provider_offer_ID_other = str(
self.providers.keys()[0]).lower() + "_" + str(
vps_options_list[1].name).lower()
self.qtable.update_qtable([], provider_offer_ID, True, 0)
assert (qtable_copy != self.qtable.qtable)
assert (qtable_copy[provider_offer_ID_other][provider_offer_ID] <
self.qtable.qtable[provider_offer_ID_other][provider_offer_ID])
assert (round(
self.qtable.qtable[provider_offer_ID_other][provider_offer_ID],
2) == 0.64)
@mock.patch('plebnet.controllers.cloudomate_controller.get_vps_providers',
return_value=CaseInsensitiveDict(
{'blueangelhost': blueAngel.BlueAngelHost}))
@mock.patch('plebnet.controllers.cloudomate_controller.options',
return_value=[
VpsOption(name='Advanced',
storage=2,
cores=2,
memory=2,
bandwidth="mock",
connection="1",
price=100.0,
purchase_url="mock"),
VpsOption(name='Basic Plan',
storage=2,
cores=2,
memory=2,
bandwidth="mock",
connection="1",
price=10.0,
purchase_url="mock")
])
def test_update_qtable_from_remote_qtable(self, mock1, mock2):
blue_angel_offers = cloudomate_controller.options(
self.providers["blueangelhost"])
self.qtable.self_state = VPSState("blueangelhost",
blue_angel_offers[0].name)
self.qtable.init_qtable_and_environment(self.providers)
self.qtable.init_alpha_and_beta()
qtable2 = QTable()
qtable2.self_state = VPSState("blueangelhost",
blue_angel_offers[1].name)
qtable2.init_qtable_and_environment(self.providers)
qtable2.init_alpha_and_beta()
vps_options_list = cloudomate_controller.options(self.providers)
vps_option = vps_options_list[0]
provider_offer_ID = str(self.providers.keys()[0]).lower() + "_" + str(
vps_option.name).lower()
provider_offer_ID_other = str(
self.providers.keys()[0]).lower() + "_" + str(
vps_options_list[1].name).lower()
self.qtable.update_qtable([], provider_offer_ID_other, True, 0.5)
self.qtable.set_self_state(
VPSState("blueangelhost", blue_angel_offers[1].name))
qtable2.update_qtable([], provider_offer_ID_other, True, 0.6)
qtable2.set_self_state(
VPSState("blueangelhost", blue_angel_offers[1].name))
self.qtable.update_qtable([qtable2.qtable], provider_offer_ID, True,
0.3)
assert (qtable2.qtable != self.qtable.qtable)
assert (qtable2.qtable[provider_offer_ID_other][provider_offer_ID] <
self.qtable.qtable[provider_offer_ID_other][provider_offer_ID])
@mock.patch('plebnet.controllers.cloudomate_controller.get_vps_providers',
return_value=CaseInsensitiveDict(
{'blueangelhost': blueAngel.BlueAngelHost}))
@mock.patch('plebnet.controllers.cloudomate_controller.options',
return_value=[
VpsOption(name='Advanced',
storage=2,
cores=2,
memory=2,
bandwidth="mock",
connection="1",
price=100.0,
purchase_url="mock"),
VpsOption(name='Basic Plan',
storage=2,
cores=2,
memory=2,
bandwidth="mock",
connection="1",
price=10.0,
purchase_url="mock")
])
def test_init_alphatable(self, mock1, mock2):
blue_angel_offers = cloudomate_controller.options(
self.providers["blueangelhost"])
self.qtable.self_state = VPSState("blueangelhost",
blue_angel_offers[0].name)
self.qtable.init_qtable_and_environment(self.providers)
self.qtable.init_alpha_and_beta()
vps_options_list = cloudomate_controller.options(self.providers)
vps_option = vps_options_list[0]
provider_offer_ID = str(self.providers.keys()[0]).lower() + "_" + str(
vps_option.name).lower()
provider_offer_ID_other = str(
self.providers.keys()[0]).lower() + "_" + str(
vps_options_list[1].name).lower()
assert (self.qtable.alphatable[provider_offer_ID_other]
[provider_offer_ID] == 0.8)
assert (self.qtable.betatable[provider_offer_ID_other]
[provider_offer_ID] == 0.2)
assert (self.qtable.number_of_updates[provider_offer_ID_other]
[provider_offer_ID] == 0)
@mock.patch('plebnet.controllers.cloudomate_controller.get_vps_providers',
return_value=CaseInsensitiveDict(
{'blueangelhost': blueAngel.BlueAngelHost}))
@mock.patch('plebnet.controllers.cloudomate_controller.options',
return_value=[
VpsOption(name='Advanced',
storage=2,
cores=2,
memory=2,
bandwidth="mock",
connection="1",
price=100.0,
purchase_url="mock"),
VpsOption(name='Basic Plan',
storage=2,
cores=2,
memory=2,
bandwidth="mock",
connection="1",
price=10.0,
purchase_url="mock")
])
def test_update_values_negative(self, mock1, mock2):
blue_angel_offers = cloudomate_controller.options(
self.providers["blueangelhost"])
self.qtable.self_state = VPSState("blueangelhost",
blue_angel_offers[0].name)
self.qtable.init_qtable_and_environment(self.providers)
self.qtable.init_alpha_and_beta()
qtable_copy = copy.deepcopy(self.qtable.qtable)
vps_options_list = cloudomate_controller.options(self.providers)
vps_option = vps_options_list[1]
provider_offer_ID = str(self.providers.keys()[0]).lower() + "_" + str(
vps_option.name).lower()
provider_offer_ID_other = str(
self.providers.keys()[0]).lower() + "_" + str(
vps_options_list[1].name).lower()
self.qtable.update_qtable([], provider_offer_ID_other, False)
assert (qtable_copy != self.qtable.qtable)
assert (qtable_copy[provider_offer_ID_other][provider_offer_ID_other] >
self.qtable.qtable[provider_offer_ID_other]
[provider_offer_ID_other])
assert (round(
self.qtable.qtable[provider_offer_ID_other][provider_offer_ID],
2) == -0.32)
@mock.patch('plebnet.controllers.cloudomate_controller.get_vps_providers',
return_value=CaseInsensitiveDict(
{'blueangelhost': blueAngel.BlueAngelHost}))
@mock.patch('plebnet.controllers.cloudomate_controller.options',
return_value=[
VpsOption(name='Advanced',
storage=2,
cores=2,
memory=2,
bandwidth="mock",
connection="1",
price=100.0,
purchase_url="mock"),
VpsOption(name='Basic Plan',
storage=2,
cores=2,
memory=2,
bandwidth="mock",
connection="1",
price=10.0,
purchase_url="mock")
])
def test_find_provider(self, mock1, mock2):
self.qtable.init_qtable_and_environment(self.providers)
self.qtable.set_self_state(VPSState("blueangelhost", "Advanced"))
provider_name = self.qtable.find_provider("blueangelhost_basic plan")
assert (provider_name == "blueangelhost")
@mock.patch('plebnet.controllers.cloudomate_controller.get_vps_providers',
return_value=CaseInsensitiveDict(
{'blueangelhost': blueAngel.BlueAngelHost}))
@mock.patch('plebnet.controllers.cloudomate_controller.options',
return_value=[
VpsOption(name='Advanced',
storage=2,
cores=2,
memory=2,
bandwidth="mock",
connection="1",
price=100.0,
purchase_url="mock"),
VpsOption(name='Basic Plan',
storage=2,
cores=2,
memory=2,
bandwidth="mock",
connection="1",
price=10.0,
purchase_url="mock")
])
def test_kth_score(self, mock1, mock2):
self.qtable.init_qtable_and_environment(self.providers)
self.qtable.set_self_state(VPSState("blueangelhost", "Advanced"))
self.qtable.init_alpha_and_beta()
vps_options_list = cloudomate_controller.options(self.providers)
vps_option = vps_options_list[0]
provider_offer_ID = str(self.providers.keys()[0]).lower() + "_" + str(
vps_option.name).lower()
self.qtable.update_qtable([], provider_offer_ID, True, 0)
assert (self.qtable.get_kth_score(self.providers, 1) == 0)
@mock.patch('plebnet.controllers.cloudomate_controller.get_vps_providers',
return_value=CaseInsensitiveDict(
{'blueangelhost': blueAngel.BlueAngelHost}))
@mock.patch('plebnet.controllers.cloudomate_controller.options',
return_value=[
VpsOption(name='Advanced',
storage=2,
cores=2,
memory=2,
bandwidth="mock",
connection="1",
price=100.0,
purchase_url="mock"),
VpsOption(name='Basic Plan',
storage=2,
cores=2,
memory=2,
bandwidth="mock",
connection="1",
price=10.0,
purchase_url="mock")
])
def test_choose_k_option(self, mock1, mock2):
self.qtable.init_qtable_and_environment(self.providers)
self.qtable.set_self_state(VPSState("blueangelhost", "Advanced"))
self.qtable.init_alpha_and_beta()
vps_options_list = cloudomate_controller.options(self.providers)
vps_option = vps_options_list[0]
provider_offer_ID = str(self.providers.keys()[0]).lower() + "_" + str(
vps_option.name).lower()
self.qtable.update_qtable([], provider_offer_ID, True, 0)
option = self.qtable.choose_k_option(self.providers, 0)
assert (option["option_name"] == "Advanced")
assert (option["price"] == 100.0)
@mock.patch('plebnet.settings.plebnet_settings.Init.irc_nick',
return_value="plebbot1")
@mock.patch('plebnet.controllers.cloudomate_controller.get_vps_providers',
return_value=CaseInsensitiveDict(
{'blueangelhost': blueAngel.BlueAngelHost}))
@mock.patch('plebnet.controllers.cloudomate_controller.options',
return_value=[
VpsOption(name='Advanced',
storage=2,
cores=2,
memory=2,
bandwidth="mock",
connection="1",
price=100.0,
purchase_url="mock"),
VpsOption(name='Basic Plan',
storage=2,
cores=2,
memory=2,
bandwidth="mock",
connection="1",
price=10.0,
purchase_url="mock")
])
def test_choose_option(self, mock1, mock2, mock3):
self.qtable.init_qtable_and_environment(self.providers)
self.qtable.set_self_state(VPSState("blueangelhost", "Advanced"))
random.expovariate = MagicMock(return_value=0.55)
option = self.qtable.choose_option(self.providers)
assert (option["option_name"] == "Basic Plan")
assert (option["price"] == 10.0)
@mock.patch('plebnet.settings.plebnet_settings.Init.irc_nick',
return_value="plebbot1")
def test_create_initial_tree(self, mock1):
self.qtable.set_self_state(VPSState("blueangelhost", "Advanced"))
self.qtable.create_initial_tree()
assert (self.qtable.tree == "plebbot1")
def test_get_no_replications(self):
self.qtable.tree = "plebbot1.2.3"
self.assertEqual(self.qtable.get_no_replications(), 3)
def get_ID(self, provider_offer):
return str(provider_offer.provider_name).lower() + "_" + str(
provider_offer.name).lower()
