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)