def async_server(standard_graph, tmpdir): proxy_port = _get_unused_port() fe_port = _get_unused_port() cmds = [[ src_path("bin", "grouper-ctl"), "-vvc", src_path("config", "dev.yaml"), "user_proxy", "-P", str(fe_port), "-p", str(proxy_port), "*****@*****.**" ], [ src_path("bin", "grouper-fe"), "-c", src_path("config", "dev.yaml"), "-p", str(fe_port), "-d", db_url(tmpdir), ]] subprocesses = [] for cmd in cmds: p = subprocess.Popen(cmd) subprocesses.append(p) wait_until_accept(proxy_port) yield "http://localhost:{}".format(proxy_port) for p in subprocesses: p.kill()
def session(request, tmpdir): # type: (FixtureRequest, LocalPath) -> None settings = Settings() set_global_settings(settings) # Reinitialize plugins in case a previous test configured some. set_global_plugin_proxy(PluginProxy([])) db_engine = get_db_engine(db_url(tmpdir)) # Clean up from previous tests if using a persistent database. if "MEROU_TEST_DATABASE" in os.environ: Model.metadata.drop_all(db_engine) # Create the database schema and the corresponding session. Model.metadata.create_all(db_engine) Session.configure(bind=db_engine) session = Session() def fin(): # type: () -> None """Explicitly close the session to avoid any dangling transactions.""" session.close() request.addfinalizer(fin) return session
def api_server(tmpdir): # type: (LocalPath) -> Iterator[str] api_socket = _bind_socket() api_port = api_socket.getsockname()[1] cmd = [ sys.executable, src_path("bin", "grouper-api"), "-vvc", src_path("config", "dev.yaml"), "-d", db_url(tmpdir), "--listen-stdin", ] logging.info("Starting server with command: %s", " ".join(cmd)) p = subprocess.Popen(cmd, env=bin_env(), stdin=api_socket.fileno()) api_socket.close() logging.info("Waiting on server to come online") _wait_until_accept(api_port) logging.info("Connection established") yield "localhost:{}".format(api_port) p.kill()
def frontend_server(tmpdir, user): # type: (LocalPath, str) -> Iterator[str] proxy_socket = _bind_socket() proxy_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) proxy_port = proxy_socket.getsockname()[1] fe_socket = _bind_socket() fe_port = fe_socket.getsockname()[1] proxy_cmd = [ sys.executable, src_path("bin", "grouper-ctl"), "-vvc", src_path("config", "dev.yaml"), "user_proxy", "-P", str(fe_port), "-p", str(proxy_port), user, ] fe_cmd = [ sys.executable, src_path("bin", "grouper-fe"), "-vvc", src_path("config", "dev.yaml"), "-d", db_url(tmpdir), "--listen-stdin", ] subprocesses = [] logging.info("Starting command: %s", " ".join(fe_cmd)) fe_process = subprocess.Popen(fe_cmd, env=bin_env(), stdin=fe_socket.fileno()) subprocesses.append(fe_process) fe_socket.close() # TODO(rra): There is a race condition here because grouper-ctl user_proxy doesn't implement # --listen-stdin yet, which in turn is because the built-in Python HTTPServer doesn't support # wrapping a pre-existing socket. Since we have to close the socket so that grouper-ctl # user_proxy can re-open it, something else might grab it in the interim. Once it is rewritten # using Tornado, it can use the same approach as the frontend and API servers and take an open # socket on standard input. At that point, we can also drop the SO_REUSEADDR above, which is # there to protect against the race condition. logging.info("Starting command: %s", " ".join(proxy_cmd)) proxy_socket.close() proxy_process = subprocess.Popen(proxy_cmd, env=bin_env()) subprocesses.append(proxy_process) logging.info("Waiting on server to come online") _wait_until_accept(fe_port) _wait_until_accept(proxy_port) logging.info("Connection established") yield "http://localhost:{}".format(proxy_port) for p in subprocesses: p.kill()
def __init__(self, tmpdir): # type: (LocalPath) -> None self.session = self.create_session(tmpdir) self.graph = GroupGraph() self.settings = Settings({"database": db_url(tmpdir)}) self.repository_factory = GraphRepositoryFactory( self.settings, self.session, self.graph) self.service_factory = ServiceFactory(self.repository_factory) self.usecase_factory = UseCaseFactory(self.service_factory) self._transaction_service = self.service_factory.create_transaction_service( )
def create_session(self, tmpdir): # type: (LocalPath) -> Session db_engine = get_db_engine(db_url(tmpdir)) # If using a persistent database, clear the database first. if "MEROU_TEST_DATABASE" in os.environ: Model.metadata.drop_all(db_engine) # Create the database schema and the corresponding session. Model.metadata.create_all(db_engine) Session.configure(bind=db_engine) return Session()
def __init__(self, tmpdir): # type: (LocalPath) -> None self.settings = Settings() self.settings.database = db_url(tmpdir) self.plugins = PluginProxy([]) self.graph = GroupGraph() # Reinitialize the global plugin proxy with an empty set of plugins in case a previous test # initialized plugins. This can go away once a plugin proxy is injected into everything # that needs it instead of maintained as a global. set_global_plugin_proxy(self.plugins) self.initialize_database() self.open_database()
def session(request, tmpdir): db_engine = get_db_engine(db_url(tmpdir)) # Create the database schema and the corresponding session. Model.metadata.create_all(db_engine) Session.configure(bind=db_engine) session = Session() def fin(): # type: () -> None """Explicitly close the session and clean up if using a persistent database.""" session.close() if "MEROU_TEST_DATABASE" in os.environ: Model.metadata.drop_all(db_engine) request.addfinalizer(fin) return session
def __init__(self, tmpdir): # type: (LocalPath) -> None self.settings = Settings() self.settings.database = db_url(tmpdir) self.plugin_proxy = PluginProxy([]) # Reinitialize the global plugin proxy with an empty set of plugins in case a previous test # initialized plugins. This can go away once a plugin proxy is injected into everything # that needs it instead of maintained as a global. set_global_plugin_proxy(self.plugin_proxy) self.initialize_database() self.session = SessionFactory(self.settings).create_session() self.graph = GroupGraph() self.repository_factory = GraphRepositoryFactory( self.settings, self.plugin_proxy, SingletonSessionFactory(self.session), self.graph ) self.service_factory = ServiceFactory(self.repository_factory) self.usecase_factory = UseCaseFactory(self.settings, self.service_factory) self._transaction_service = self.service_factory.create_transaction_service()
def async_api_server(standard_graph, tmpdir): api_port = _get_unused_port() cmd = [ src_path("bin", "grouper-api"), "-c", src_path("config", "dev.yaml"), "-p", str(api_port), "-d", db_url(tmpdir), ] p = subprocess.Popen(cmd) wait_until_accept(api_port) yield "localhost:{}".format(api_port) p.kill()