def test_base_dir_created(self):
# The base Juju GUI directory is correctly created.
config = self.make_config()
test_backend = backend.Backend(config=config)
with self.mock_all():
test_backend.install()
self.assertTrue(os.path.isdir(self.base_dir))
def interface():
label_and_setfile_names = collect_label_and_setfile_names()
if label_and_setfile_names:
engine = backend.Backend(**label_and_setfile_names)
msg = "ENTER 'done' to stop."
def apply_labels(count=0):
# was using recursion, but this will hit the recursion limit
while True:
print('\n{msg}\n\n{count}\n--\n{sent}\n--\n'.format(msg=msg,
sent=engine.sent,
count=count))
label = get_label(labelset=engine.labels)
if label in {'done', 'exit', 'quit'}:
return True
else:
if label != "skip":
engine.save_sent_matches(label=label)
try:
engine.next()
count += 1
except StopIteration:
print("Done!")
return True
apply_labels(0)
def test_start_insecure_ws_secure(self):
# It is possible to configure the service so that, even if the GUI
# server runs in insecure mode, the client still connects via a secure
# WebSocket connection. This is often used when proxying the GUI behind
# an SSL terminating service like Apache2.
config = self.make_config({'secure': False, 'ws-secure': True})
test_backend = backend.Backend(config=config)
with self.mock_all() as mocks:
with patch_environ(JUJU_MODEL_UUID='uuid'):
test_backend.start()
mocks.start_builtin_server.assert_called_once_with(
self.ssl_cert_path,
config['serve-tests'],
config['sandbox'],
config['builtin-server-logging'],
True, # insecure
config['charmworld-url'],
charmstore_url='http://charmstore.example.com/',
jem_location='',
env_uuid='uuid',
interactive_login=False,
juju_version=JUJU_VERSION,
debug=False,
jem_version='v1',
charmstore_version='v4',
gtm_enabled=False,
gisf_enabled=False,
gzip=True,
port=None,
env_password=None)
def test_connect():
global i
i = 0
# This function will test if client output is what it should be
def test_output(msg, logging=False):
global i
if i == 0:
assert(msg == tr("connected.to") + "('127.0.0.1', 1234)")
if i == 1:
assert(msg == tr("connexion.thread.start").format("('127.0.0.1', 1234)"))
i += 1
c = client.Client(backend.Backend(False), test_output, empty_func)
# We create a simple socket server
server = socket.socket()
server.bind(("127.0.0.1", 1234))
server.listen(1)
t = threading.Thread(target=server.accept)
t.start()
c.connect("127.0.0.1", 1234)
assert i >= 2 # There should have been 2 messages
# We close everything
t.join()
server.close()
c.close()
def test_start_insecure_ws_secure(self):
# It is possible to configure the service so that, even if the GUI
# server runs in insecure mode, the client still connects via a secure
# WebSocket connection. This is often used when proxying the GUI behind
# an SSL terminating service like Apache2.
config = self.make_config({'secure': False, 'ws-secure': True})
test_backend = backend.Backend(config=config)
with self.mock_all() as mocks:
test_backend.start()
mocks.write_gui_config.assert_called_once_with(
config['juju-gui-console-enabled'],
config['login-help'],
config['read-only'],
config['charmworld-url'],
config['charmstore-url'],
mocks.compute_build_dir(),
secure=True,
sandbox=config['sandbox'],
cached_fonts=config['cached-fonts'],
ga_key=config['ga-key'],
juju_core_version=config['juju-core-version'],
hide_login_button=config['hide-login-button'],
juju_env_uuid=None,
password=None)
mocks.start_builtin_server.assert_called_once_with(
mocks.compute_build_dir(),
self.ssl_cert_path,
config['serve-tests'],
config['sandbox'],
config['builtin-server-logging'],
True,
config['charmworld-url'],
port=None)
def __init__(self,
video_path,
message_type="raw",
export="",
bg_alpha=0.001):
"""Return a video processor.
Arguments:
* video_path (str): the path to video file.
* message_type (str): can be 'raw' or 'processed'. Default "raw"
* export (str): If "", don't export, if not empty, export as filename.
* bg_alpha: The background learning factor, its value should
be between 0 and 1. The higher the value, the more quickly
your program learns the changes in the background. Therefore,
for a static background use a lower value, like 0.001. But if
your background has moving trees and stuff, use a higher value,
maybe start with 0.01. Default 0.001. Only need for subtract2.
"""
self.cap = cv2.VideoCapture(video_path)
self.message_type = message_type
self.export = export
fourcc = cv2.VideoWriter_fourcc(*"mp4v")
if export != "":
self.writer = cv2.VideoWriter(export, fourcc, 20.0, (320, 200))
self._get_background()
self.backend = backend.Backend(self.background)
def test_start(self):
# Start the GUI server.
config = self.make_config()
test_backend = backend.Backend(config=config)
with self.mock_all() as mocks:
test_backend.start()
mocks.compute_build_dir.assert_called_with(config['juju-gui-debug'],
config['serve-tests'])
mocks.write_gui_config.assert_called_once_with(
config['juju-gui-console-enabled'],
config['login-help'],
config['read-only'],
config['charmworld-url'],
config['charmstore-url'],
mocks.compute_build_dir(),
secure=config['secure'],
sandbox=config['sandbox'],
cached_fonts=config['cached-fonts'],
ga_key=config['ga-key'],
juju_core_version=config['juju-core-version'],
hide_login_button=config['hide-login-button'],
juju_env_uuid=None,
password=None)
mocks.setup_ports.assert_called_once_with(None, None)
mocks.start_builtin_server.assert_called_once_with(
mocks.compute_build_dir(),
self.ssl_cert_path,
config['serve-tests'],
config['sandbox'],
config['builtin-server-logging'],
not config['secure'],
config['charmworld-url'],
port=None)
def setUp(self):
b = backend.Backend()
steps_dir = Config.get("steps_dir")
self.steps = b.load_sync_step_modules(steps_dir)
self.synchronizer = event_loop.XOSObserver(self.steps)
os.remove('/tmp/sync_ports')
os.remove('/tmp/delete_ports')
def setUp(self):
global mock_enumerator, event_loop
self.sys_path_save = sys.path
self.cwd_save = os.getcwd()
sys.path.append(xos_dir)
sys.path.append(os.path.join(xos_dir, 'synchronizers', 'new_base'))
sys.path.append(os.path.join(xos_dir, 'synchronizers', 'new_base', 'tests', 'steps'))
config = os.path.join(test_path, "test_config.yaml")
from xosconfig import Config
Config.clear()
Config.init(config, 'synchronizer-config-schema.yaml')
from synchronizers.new_base.mock_modelaccessor_build import build_mock_modelaccessor
build_mock_modelaccessor(xos_dir, services_dir=None, service_xprotos=[])
os.chdir(os.path.join(test_path, '..')) # config references tests/model-deps
import event_loop
reload(event_loop)
import backend
reload(backend)
from mock_modelaccessor import mock_enumerator
from modelaccessor import model_accessor
# import all class names to globals
for (k, v) in model_accessor.all_model_classes.items():
globals()[k] = v
b = backend.Backend()
steps_dir = Config.get("steps_dir")
self.steps = b.load_sync_step_modules(steps_dir)
self.synchronizer = event_loop.XOSObserver(self.steps)
def __init__(self, request, client_address, server):
self.__gobject_init__()
print("New Backend")
self.backend = backend.Backend()
self.backend.InitializeFolderList()
BaseHTTPServer.BaseHTTPRequestHandler.__init__(self, request,
client_address, server)
def test_gisf_enabled(self):
config = self.make_config({'gisf-enabled': True})
test_backend = backend.Backend(config=config)
with self.mock_all() as mocks:
with patch_environ(JUJU_MODEL_UUID='uuid'):
test_backend.start()
mocks.start_builtin_server.assert_called_once_with(
self.ssl_cert_path,
config['serve-tests'],
config['sandbox'],
config['builtin-server-logging'],
False, # insecure
config['charmworld-url'],
charmstore_url='http://charmstore.example.com/',
jem_location='',
env_uuid='uuid',
interactive_login=False,
juju_version=JUJU_VERSION,
debug=False,
jem_version='v1',
charmstore_version='v4',
gtm_enabled=False,
gisf_enabled=True,
gzip=True,
port=None,
env_password=None)
def test_base_dir_removed(self):
# The base Juju GUI directory is correctly removed.
config = self.make_config()
test_backend = backend.Backend(config=config)
with self.mock_all():
test_backend.install()
test_backend.destroy()
self.assertFalse(os.path.exists(utils.BASE_DIR), utils.BASE_DIR)
def turing():
turing = backend.Backend(False)
turing.key.key = {
'n': mpz(285931472310203125690528209113268809453),
'e': mpz(65537),
'd': mpz(47575258858455681275057020721522344913)
}
turing.fernetKey = b'NUEvViarzuYl4rJ_qPJRRV5YRTpAl0eCed4Vv6UPAp0='
return turing
def test_install(self):
# Install a stable release.
test_backend = backend.Backend(config=self.make_config())
with self.mock_all() as mocks:
test_backend.install()
mocks.install_missing_packages.assert_called_once_with(
set(EXPECTED_DEBS))
mocks.setup_gui.assert_called_once_with()
mocks.install_builtin_server.assert_called_once_with()
def test_start_uuid_error(self):
# A ValueError is raised if the model UUID cannot be found in the hook
# context.
config = self.make_config()
test_backend = backend.Backend(config=config)
with self.mock_all():
with self.assertRaises(ValueError) as ctx:
test_backend.start()
self.assertEqual('cannot retrieve model UUID from hook context',
ctx.exception.message)
def __init__(self, song=None):
#set backend
bl = backend.Backend().GetBackendList()
self.PlaybackSetBackend(bl[0])
#self.player = be.SetBackend(bl[0])
self.song = song
#self.player = backend.player.Player()
self.is_playing = False
self.is_plaused = False
self.playback_modes = ['normal', 'repeat', 'repeat_all', 'random']
self.playback_mode = self.playback_modes[0]
def main():
bk = backend.Backend('/dev/ttyAMA0')
userInterface = ui.UserInput(bk.tx, bk.tLock)
bk.UI = userInterface
bk.start()
userInterface.start()
userInterface.join()
bk.join()
def setUp(self):
# self.policy = TenantWithContainerPolicy()
# self.user = User(email="*****@*****.**")
# self.tenant = Tenant(creator=self.user)
# self.flavor = Flavor(name="m1.small")
# model_policy_tenantwithcontainer.Instance = Instance
# model_policy_tenantwithcontainer.Flavor = Flavor
b = backend.Backend()
steps_dir = Config.get("steps_dir")
self.steps = b.load_sync_step_modules(steps_dir)
self.synchronizer = event_loop.XOSObserver(self.steps)
def main():
LOG.info('Starting service!')
back = backend.Backend()
try:
LOG.info('Creating instance')
inst = instance.Instance.from_backend(back)
LOG.info('Running the AI')
algo.algo(inst)
LOG.info('AI is complete')
finally:
LOG.info('Deleting instance')
back.delete_instance()
def test_install_stable_release(self):
# Install a stable release.
test_backend = backend.Backend(config=self.make_config())
with self.mock_all() as mocks:
test_backend.install()
mocks.install_missing_packages.assert_called_once_with(
set(EXPECTED_DEBS))
mocks.parse_source.assert_called_once_with(self.juju_gui_source)
mocks.fetch_gui_release.assert_called_once_with(
*self.parse_source_return_value)
self.assertFalse(mocks.fetch_gui_from_branch.called)
mocks.setup_gui.assert_called_once_with(mocks.fetch_gui_release())
mocks.install_builtin_server.assert_called_once_with()
def test_different_config(self):
test_backend = backend.Backend(
config={
'sandbox': False,
'secure': False
},
prev_config={
'sandbox': True,
'secure': False
},
)
self.assertTrue(test_backend.different('sandbox'))
self.assertFalse(test_backend.different('secure'))
def setUp(self):
global mock_enumerator, event_loop
self.sys_path_save = sys.path
self.cwd_save = os.getcwd()
sys.path.append(xos_dir)
sys.path.append(os.path.join(xos_dir, "synchronizers", "new_base"))
sys.path.append(
os.path.join(xos_dir, "synchronizers", "new_base", "tests",
"steps"))
config = os.path.join(test_path, "test_config.yaml")
from xosconfig import Config
Config.clear()
Config.init(config, "synchronizer-config-schema.yaml")
from synchronizers.new_base.mock_modelaccessor_build import (
build_mock_modelaccessor, )
build_mock_modelaccessor(xos_dir,
services_dir=None,
service_xprotos=[])
os.chdir(os.path.join(test_path,
"..")) # config references tests/model-deps
import event_loop
reload(event_loop)
import backend
reload(backend)
from mock_modelaccessor import mock_enumerator
from modelaccessor import model_accessor
# import all class names to globals
for (k, v) in model_accessor.all_model_classes.items():
globals()[k] = v
# self.policy = TenantWithContainerPolicy()
# self.user = User(email="*****@*****.**")
# self.tenant = Tenant(creator=self.user)
# self.flavor = Flavor(name="m1.small")
# model_policy_tenantwithcontainer.Instance = Instance
# model_policy_tenantwithcontainer.Flavor = Flavor
b = backend.Backend()
steps_dir = Config.get("steps_dir")
self.steps = b.load_sync_step_modules(steps_dir)
self.synchronizer = event_loop.XOSObserver(self.steps)
def __init__(self):
locale.setlocale(locale.LC_ALL, '')
print('lala')
self.game_backend = backend.Backend()
self.game_dialog = Dialog(dialog='dialog')
user_input = []
for i in range(0, self.game_backend.code_length):
user_input.append([
self.get_input(i, user_input, True),
self.get_input(i, user_input, False)
])
print(user_input)
def test_connectWithoutServer():
global i
i = 0
# This function will test if client output is what it should be
def test_output(msg, logging=False):
global i
if i == 0:
assert msg == tr("error.connexion.refused")
i += 1
c = client.Client(backend.Backend(False), test_output, empty_func)
c.connect("127.0.0.1", 1234)
assert i == 1
c.close()
def setUp(self):
self.sys_path_save = sys.path
self.cwd_save = os.getcwd()
sys.path.append(xos_dir)
sys.path.append(os.path.join(xos_dir, "synchronizers", "new_base"))
sys.path.append(
os.path.join(xos_dir, "synchronizers", "new_base", "tests",
"steps"))
config = os.path.join(test_path, "test_config.yaml")
from xosconfig import Config
Config.clear()
Config.init(config, "synchronizer-config-schema.yaml")
from synchronizers.new_base.mock_modelaccessor_build import (
build_mock_modelaccessor, )
build_mock_modelaccessor(xos_dir,
services_dir=None,
service_xprotos=[])
os.chdir(os.path.join(test_path,
"..")) # config references tests/model-deps
import event_loop
reload(event_loop)
import backend
reload(backend)
from modelaccessor import model_accessor
# import all class names to globals
for (k, v) in model_accessor.all_model_classes.items():
globals()[k] = v
b = backend.Backend()
steps_dir = Config.get("steps_dir")
self.steps = b.load_sync_step_modules(steps_dir)
self.synchronizer = event_loop.XOSObserver(self.steps)
try:
os.remove("/tmp/sync_ports")
except OSError:
pass
try:
os.remove("/tmp/delete_ports")
except OSError:
pass
def test_start_user_provided_port(self):
# Start the GUI server with a user provided port.
config = self.make_config({'port': 8080})
test_backend = backend.Backend(config=config)
with self.mock_all() as mocks:
test_backend.start()
mocks.setup_ports.assert_called_once_with(None, 8080)
mocks.start_builtin_server.assert_called_once_with(
self.ssl_cert_path,
config['serve-tests'],
config['sandbox'],
config['builtin-server-logging'],
not config['secure'],
config['charmworld-url'],
port=8080)
def setUp(self):
self.outgoingMessages = []
def handleOutgoingMessage(msg):
self.outgoingMessages.append(msg)
self.bl4pIsConnected = True
def isBL4PConnected():
return self.bl4pIsConnected
self.client = Mock()
self.client.handleOutgoingMessage = handleOutgoingMessage
self.client.isBL4PConnected = isBL4PConnected
self.backend = backend.Backend(self.client)
def test_install_branch_release(self):
# Install a branch release.
self.parse_source_return_value = ('branch', ('lp:juju-gui', 42))
expected_calls = [
mock.call(set(EXPECTED_DEBS)),
mock.call(
utils.DEB_BUILD_DEPENDENCIES,
repository=self.repository_location,
),
]
test_backend = backend.Backend(config=self.make_config())
with self.mock_all() as mocks:
test_backend.install()
mocks.install_missing_packages.assert_has_calls(expected_calls)
mocks.parse_source.assert_called_once_with(self.juju_gui_source)
mocks.fetch_gui_from_branch.assert_called_once_with(
'lp:juju-gui', 42, self.command_log_file)
self.assertFalse(mocks.fetch_gui_release.called)
mocks.setup_gui.assert_called_once_with(mocks.fetch_gui_from_branch())
mocks.install_builtin_server.assert_called_once_with()
def __init__(self):
# start backend
self.be = backend.Backend()
# make layout
self.make_layout()
# initialise empty selection
self.selected_rows = []
self.selected_date = []
# populate date list from database
self.populate_dates()
# select first line
self.dates_list.select_set(0)
# show articles
self.date_select([])
#
self.update_narticles_label()
#
# start app
self.app.mainloop()
def setUp(self):
self.sys_path_save = sys.path
self.cwd_save = os.getcwd()
sys.path.append(xos_dir)
sys.path.append(os.path.join(xos_dir, 'synchronizers', 'new_base'))
sys.path.append(
os.path.join(xos_dir, 'synchronizers', 'new_base', 'tests',
'steps'))
config = os.path.join(test_path, "test_config.yaml")
from xosconfig import Config
Config.clear()
Config.init(config, 'synchronizer-config-schema.yaml')
from synchronizers.new_base.mock_modelaccessor_build import build_mock_modelaccessor
build_mock_modelaccessor(xos_dir,
services_dir=None,
service_xprotos=[])
os.chdir(os.path.join(test_path,
'..')) # config references tests/model-deps
import event_loop
reload(event_loop)
import backend
reload(backend)
# self.policy = TenantWithContainerPolicy()
# self.user = User(email="*****@*****.**")
# self.tenant = Tenant(creator=self.user)
# self.flavor = Flavor(name="m1.small")
# model_policy_tenantwithcontainer.Instance = Instance
# model_policy_tenantwithcontainer.Flavor = Flavor
b = backend.Backend()
steps_dir = Config.get("steps_dir")
self.steps = b.load_sync_step_modules(steps_dir)
self.synchronizer = event_loop.XOSObserver(self.steps)
