def runTest(self): env = os.environ.copy() env['WATCHMAN_SOCK'] = WatchmanInstance.getSharedInstance().getSockPath() dotted = os.path.normpath(self.id()).replace(os.sep, '.').replace( 'tests.integration.', '').replace('.php', '') env['TMPDIR'] = os.path.join(TempDir.get_temp_dir().get_dir(), dotted) os.mkdir(env['TMPDIR']) # build the node module with npm node_dir = os.path.join(env['TMPDIR'], 'fb-watchman') shutil.copytree(os.path.join(WATCHMAN_SRC_DIR, 'node'), node_dir) subprocess.check_call(['npm', 'install'], cwd=node_dir) env['TMP'] = env['TMPDIR'] env['TEMP'] = env['TMPDIR'] env['IN_PYTHON_HARNESS'] = '1' env['NODE_PATH'] = '%s:%s' % (env['TMPDIR'], env.get('NODE_PATH', '')) proc = subprocess.Popen( self.getCommandArgs(), env=env, stdout=subprocess.PIPE, stderr=subprocess.PIPE) (stdout, stderr) = proc.communicate() status = proc.poll() if status == -signal.SIGINT: Interrupt.setInterrupted() self.fail('Interrupted by SIGINT') return if status != 0: self.fail("Exit status %d\n%s\n%s\n" % (status, stdout.decode('utf-8'), stderr.decode('utf-8'))) return self.assertTrue(True, self.getCommandArgs())
def runTest(self): env = os.environ.copy() env['WATCHMAN_SOCK'] = WatchmanInstance.getSharedInstance( ).getSockPath() dotted = os.path.normpath(self.id()).replace(os.sep, '.').replace( 'tests.integration.', '').replace('.php', '') env['TMPDIR'] = os.path.join(tempfile.tempdir, dotted) os.mkdir(env['TMPDIR']) env['TMP'] = env['TMPDIR'] env['TEMP'] = env['TMPDIR'] env['IN_PYTHON_HARNESS'] = '1' proc = subprocess.Popen(self.getCommandArgs(), env=env, stdout=subprocess.PIPE, stderr=subprocess.PIPE) (stdout, stderr) = proc.communicate() status = proc.poll() if status == -signal.SIGINT: Interrupt.setInterrupted() self.fail('Interrupted by SIGINT') return if status != 0: self.fail("Exit status %d\n%s\n%s\n" % (status, stdout, stderr)) return self.assertTrue(True, self.jsfile)
def runTest(self): env = os.environ.copy() env["WATCHMAN_SOCK"] = WatchmanInstance.getSharedInstance( ).getSockPath() env["TMPDIR"] = self.tempdir # build the node module with npm node_dir = os.path.join(env["TMPDIR"], "fb-watchman") shutil.copytree(os.path.join(WATCHMAN_SRC_DIR, "node"), node_dir) subprocess.check_call(["npm", "install"], cwd=node_dir) env["TMP"] = env["TMPDIR"] env["TEMP"] = env["TMPDIR"] env["IN_PYTHON_HARNESS"] = "1" env["NODE_PATH"] = "%s:%s" % (env["TMPDIR"], env.get("NODE_PATH", "")) proc = subprocess.Popen( self.getCommandArgs(), env=env, stdout=subprocess.PIPE, stderr=subprocess.PIPE, ) (stdout, stderr) = proc.communicate() status = proc.poll() if status == -signal.SIGINT: Interrupt.setInterrupted() self.fail("Interrupted by SIGINT") return if status != 0: self.fail("Exit status %d\n%s\n%s\n" % (status, stdout.decode("utf-8"), stderr.decode("utf-8"))) return self.assertTrue(True, self.getCommandArgs())
def getServerLogContents(self): """ Returns the contents of the server log file as an array that has already been split by line. """ return WatchmanInstance.getSharedInstance().getServerLogContents( ).split("\n")
def test_wait(self): root = self.mkdtemp() self.touchRelative(root, 'foo') a_dir = os.path.join(root, 'a') os.mkdir(a_dir) self.touchRelative(a_dir, 'foo') wi = WatchmanWaitInstance.Instance( sock_path=WatchmanInstance.getSharedInstance().getSockPath() ) wi.start(paths=[root], cmdArgs=['--relative', root]) self.assertSyncWatchmanWait(wi, root) self.touchRelative(root, 'bar') self.removeRelative(root, 'foo') self.assertWaitedFileList(wi, ['foo', 'bar'], msg="wait, create files") self.touchRelative(a_dir, 'bar') self.removeRelative(a_dir, 'foo') self.assertWaitedFileList( wi, ['a/bar', 'a/foo', 'a'], msg="wait, create dir") b_dir = os.path.join(root, 'b') os.mkdir(b_dir) self.touchRelative(b_dir, 'foo') self.assertWaitedFileList(wi, ['b', 'b/foo'], msg=None)
def test_sock_name(self): resp = self.watchmanCommand("get-sockname") self.assertEqual( resp["sockname"], WatchmanInstance.getSharedInstance().getSockPath().legacy_sockpath( ), )
def test_scmHgRequestId(self): if not is_hg_installed(): self.skipTest("Hg not installed") self.skipIfNoHgRequestIdSupport() root = self.mkdtemp() # In this test, the repo does not necessarily need fsmonitor enabled, # since watchman calls HGREQUESTID=... hg status and that would also # have request_id logged without fsmonitor. env = os.environ.copy() env["HGPLAIN"] = "1" env["WATCHMAN_SOCK"] = (WatchmanInstance.getSharedInstance(). getSockPath().legacy_sockpath()) subprocess.call(["hg", "init"], env=env, cwd=root) subprocess.call( [ "hg", "commit", "-mempty", "-utest", "-d0 0", "--config=ui.allowemptycommit=1", ], env=env, cwd=root, ) commit_hash = subprocess.check_output(["hg", "log", "-r.", "-T{node}"], env=env, cwd=root).decode("utf-8") # Must watch the directory after it's an HG repo to perform scm-aware # queries. self.watchmanCommand("watch", root) request_id = "4c05a798ea1acc7c97b75e61fec5f640d90f8209" params = { "fields": ["name"], "request_id": request_id, "since": { "scm": { "mergebase-with": commit_hash } }, } self.watchmanCommand("query", root, params) blackbox_path = os.path.join(root, ".hg", "blackbox.log") def try_read_blackbox(): try: with open(blackbox_path) as f: return f.read() except IOError: return "" self.assertWaitFor( lambda: request_id in try_read_blackbox(), message="request_id passed to and logged by hg", )
def hg(self, args, cwd=None): env = dict(os.environ) env["HGPLAIN"] = "1" env["HGUSER"] = "******" env["NOSCMLOG"] = "1" # disable some instrumentation at FB sockpath = WatchmanInstance.getSharedInstance().getSockPath() env["WATCHMAN_SOCK"] = sockpath.legacy_sockpath() p = subprocess.Popen( [ env.get("EDEN_HG_BINARY", "hg"), # we force the extension on. This is a soft error for # mercurial if it is not available, so we also employ # the skipIfNoFSMonitor() test above to make sure the # environment is sane. "--config", "extensions.fsmonitor=", # Deployed versions of mercurial regressed and stopped # respecting the WATCHMAN_SOCK environment override, so # we have to reach in and force their hardcoded sockpath here. "--config", "fsmonitor.sockpath=%s" % sockpath.legacy_sockpath(), ] + args, env=env, cwd=cwd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, ) out, err = p.communicate() if p.returncode != 0: raise Exception("hg %r failed: %s, %s" % (args, out, err)) return out, err
def runTest(self): env = os.environ.copy() env['WATCHMAN_SOCK'] = WatchmanInstance.getSharedInstance( ).getSockPath() dotted = os.path.normpath(self.id()).replace(os.sep, '.').replace( 'tests.integration.', '').replace('.php', '') env['TMPDIR'] = os.path.join(tempfile.tempdir, dotted) os.mkdir(env['TMPDIR']) # build the node module with npm node_dir = os.path.join(env['TMPDIR'], 'fb-watchman') shutil.copytree('node', node_dir) subprocess.check_call(['npm', 'install'], cwd=node_dir) env['TMP'] = env['TMPDIR'] env['TEMP'] = env['TMPDIR'] env['IN_PYTHON_HARNESS'] = '1' env['NODE_PATH'] = '%s:%s' % (env['TMPDIR'], env.get('NODE_PATH', '')) proc = subprocess.Popen(self.getCommandArgs(), env=env, stdout=subprocess.PIPE, stderr=subprocess.PIPE) (stdout, stderr) = proc.communicate() status = proc.poll() if status == -signal.SIGINT: Interrupt.setInterrupted() self.fail('Interrupted by SIGINT') return if status != 0: self.fail("Exit status %d\n%s\n%s\n" % (status, stdout.decode('utf-8'), stderr.decode('utf-8'))) return self.assertTrue(True, self.jsfile)
def hg(self, args=None, cwd=None): env = dict(os.environ) env["HGPLAIN"] = "1" env["HGUSER"] = "******" env["NOSCMLOG"] = "1" # disable some instrumentation at FB env["WATCHMAN_SOCK"] = WatchmanInstance.getSharedInstance( ).getSockPath() p = subprocess.Popen( # we force the extension on. This is a soft error for # mercurial if it is not available, so we also employ # the skipIfNoFSMonitor() test above to make sure the # environment is sane. [ env.get("EDEN_HG_BINARY", "hg"), "--config", "extensions.fsmonitor=" ] + args, env=env, cwd=cwd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, ) out, err = p.communicate() if p.returncode != 0: raise Exception("hg %r failed: %s, %s" % (args, out, err)) return out, err
def test_cppclient(self): env = os.environ.copy() env["WATCHMAN_SOCK"] = (WatchmanInstance.getSharedInstance(). getSockPath().legacy_sockpath()) proc = subprocess.Popen( TEST_BINARY, env=env, stdout=subprocess.PIPE, stderr=subprocess.PIPE, cwd=self.tmpDir, ) (stdout, stderr) = proc.communicate() status = proc.poll() if status == -signal.SIGINT: Interrupt.setInterrupted() self.fail("Interrupted by SIGINT") return if status != 0: self.fail("Exit status %d\n%s\n%s\n" % (status, stdout.decode("utf-8"), stderr.decode("utf-8"))) return self.assertTrue(True, TEST_BINARY)
def runTest(self): env = os.environ.copy() env['WATCHMAN_SOCK'] = WatchmanInstance.getSharedInstance().getSockPath() dotted = os.path.normpath(self.id()).replace(os.sep, '.').replace( 'tests.integration.', '').replace('.php', '') env['TMPDIR'] = os.path.join(tempfile.tempdir, dotted) os.mkdir(env['TMPDIR']) env['TMP'] = env['TMPDIR'] env['TEMP'] = env['TMPDIR'] env['IN_PYTHON_HARNESS'] = '1' proc = subprocess.Popen( self.getCommandArgs(), env=env, stdout=subprocess.PIPE, stderr=subprocess.PIPE) (stdout, stderr) = proc.communicate() status = proc.poll() if status == -signal.SIGINT: Interrupt.setInterrupted() self.fail('Interrupted by SIGINT') return if status != 0: self.fail("Exit status %d\n%s\n%s\n" % (status, stdout.decode('utf-8'), stderr.decode('utf-8'))) return self.assertTrue(True, self.jsfile)
def test_rel_root(self): root = self.mkdtemp() a_dir = os.path.join(root, 'a') os.mkdir(a_dir) b_dir = os.path.join(root, 'b') os.mkdir(b_dir) wi = WatchmanWaitInstance.Instance( sock_path=WatchmanInstance.getSharedInstance().getSockPath() ) wi.start(paths=[a_dir, b_dir], cmdArgs=['--relative', b_dir]) self.assertSyncWatchmanWait(wi, a_dir) self.touchRelative(a_dir, 'afoo') self.touchRelative(b_dir, 'bfoo') self.assertWaitedFileList( wi, ['../a/afoo', 'bfoo'], msg="wait, relative create files") a_sub_dir = os.path.join(a_dir, 'asub') os.mkdir(a_sub_dir) b_sub_dir = os.path.join(b_dir, 'bsub') os.mkdir(b_sub_dir) self.assertWaitedFileList( wi, ['../a/asub', 'bsub'], msg="wait, relative create directories")
def getServerLogContents(self): ''' Returns the contents of the server log file as an array that has already been split by line. ''' return WatchmanInstance.getSharedInstance().\ getServerLogContents().split('\n')
def runTest(self): env = os.environ.copy() env["WATCHMAN_SOCK"] = WatchmanInstance.getSharedInstance().getSockPath() env["TMPDIR"] = self.tempdir # build the node module with npm node_dir = os.path.join(env["TMPDIR"], "fb-watchman") shutil.copytree(os.path.join(WATCHMAN_SRC_DIR, "node"), node_dir) subprocess.check_call(["npm", "install"], cwd=node_dir) env["TMP"] = env["TMPDIR"] env["TEMP"] = env["TMPDIR"] env["IN_PYTHON_HARNESS"] = "1" env["NODE_PATH"] = "%s:%s" % (env["TMPDIR"], env.get("NODE_PATH", "")) proc = subprocess.Popen( self.getCommandArgs(), env=env, stdout=subprocess.PIPE, stderr=subprocess.PIPE, ) (stdout, stderr) = proc.communicate() status = proc.poll() if status == -signal.SIGINT: Interrupt.setInterrupted() self.fail("Interrupted by SIGINT") return if status != 0: self.fail( "Exit status %d\n%s\n%s\n" % (status, stdout.decode("utf-8"), stderr.decode("utf-8")) ) return self.assertTrue(True, self.getCommandArgs())
def getClient(self): if not hasattr(self, 'client'): self.client = pywatchman.client( transport=self.transport, sendEncoding=self.encoding, recvEncoding=self.encoding, sockpath=WatchmanInstance.getSharedInstance().getSockPath()) return self.client
def dumpLogs(self): ''' used in travis CI to show the hopefully relevant log snippets ''' inst = WatchmanInstance.getSharedInstance() def tail(logstr, n): lines = logstr.split('\n')[-n:] return '\n'.join(lines) print(self.getLogSample())
def getClient(self): if not hasattr(self, 'client'): self.client = pywatchman.client( # ASAN-enabled builds can be slower enough that we hit timeouts # with the default of 1 second timeout=3.0, transport=self.transport, sendEncoding=self.encoding, recvEncoding=self.encoding, sockpath=WatchmanInstance.getSharedInstance().getSockPath()) return self.client
def dumpLogs(self): ''' used in travis CI to show the hopefully relevant log snippets ''' inst = WatchmanInstance.getSharedInstance() def tail(logstr, n): lines = logstr.split('\n')[-n:] return '\n'.join(lines) print('CLI logs') print(tail(inst.getCLILogContents(), 500)) print('Server logs') print(tail(inst.getServerLogContents(), 500))
def runTest(self): env = os.environ.copy() env["WATCHMAN_SOCK"] = ( WatchmanInstance.getSharedInstance().getSockPath().legacy_sockpath() ) env["TMPDIR"] = self.tempdir offline_mirror = env.get("YARN_OFFLINE_MIRROR_PATH_POINTER", None) if offline_mirror: with open(offline_mirror, "r") as f: mirror = f.read().strip() env["YARN_YARN_OFFLINE_MIRROR"] = mirror offline = "YARN_YARN_OFFLINE_MIRROR" in env # build the node module with yarn node_dir = os.path.join(env["TMPDIR"], "fb-watchman") shutil.copytree(os.path.join(WATCHMAN_SRC_DIR, "node"), node_dir) install_args = [yarn_bin, "install"] if offline: install_args.append("--offline") bser_dir = os.path.join(node_dir, "bser") subprocess.check_call(install_args, cwd=bser_dir, env=env) env["TMP"] = env["TMPDIR"] env["TEMP"] = env["TMPDIR"] env["IN_PYTHON_HARNESS"] = "1" env["NODE_PATH"] = "%s:%s" % (node_dir, env["TMPDIR"]) proc = subprocess.Popen( self.getCommandArgs(), env=env, stdout=subprocess.PIPE, stderr=subprocess.PIPE, ) (stdout, stderr) = proc.communicate() status = proc.poll() if status == -signal.SIGINT: Interrupt.setInterrupted() self.fail("Interrupted by SIGINT") return if status != 0: self.fail( "Exit status %d\n%s\n%s\n" % (status, stdout.decode("utf-8"), stderr.decode("utf-8")) ) return self.assertTrue(True, self.getCommandArgs())
def getClient(self, inst=None, replace_cached=False, no_cache=False): if inst or not hasattr(self, "client") or no_cache: client = pywatchman.client( timeout=self.socketTimeout, transport=self.transport, sendEncoding=self.encoding, recvEncoding=self.encoding, sockpath=(inst or WatchmanInstance.getSharedInstance()).getSockPath(), ) if (not inst or replace_cached) and not no_cache: # only cache the client if it points to the shared instance self.client = client return client return self.client
def getLogSample(self): ''' used in CI to show the hopefully relevant log snippets ''' inst = WatchmanInstance.getSharedInstance() def tail(logstr, n): lines = logstr.split('\n')[-n:] return '\n'.join(lines) return '\n'.join([ 'CLI logs', tail(inst.getCLILogContents(), 500), 'Server logs', tail(inst.getServerLogContents(), 500), ])
def getLogSample(self): """ used in CI to show the hopefully relevant log snippets """ inst = WatchmanInstance.getSharedInstance() def tail(logstr, n): lines = logstr.split("\n")[-n:] return "\n".join(lines) return "\n".join([ "CLI logs", tail(inst.getCLILogContents(), 500), "Server logs", tail(inst.getServerLogContents(), 500), ])
def getClient(self, inst=None, replace_cached=False, no_cache=False): if inst or not hasattr(self, "client") or no_cache: client = pywatchman.client( timeout=self.socketTimeout, transport=self.transport, sendEncoding=self.encoding, recvEncoding=self.encoding, sockpath=(inst or WatchmanInstance.getSharedInstance()).getSockPath(), ) if (not inst or replace_cached) and not no_cache: # only cache the client if it points to the shared instance self.client = client self.addCleanup(lambda: self.__clearClient()) return client return self.client
def getClient(self, inst=None): if inst or not hasattr(self, 'client'): client = pywatchman.client( # ASAN-enabled builds can be slower enough that we hit timeouts # with the default of 1 second timeout=3.0, transport=self.transport, sendEncoding=self.encoding, recvEncoding=self.encoding, sockpath=(inst or WatchmanInstance.getSharedInstance()).getSockPath()) if not inst: # only cache the client if it points to the shared instance self.client = client return client return self.client
def getLogSample(self): """ used in CI to show the hopefully relevant log snippets """ inst = WatchmanInstance.getSharedInstance() def tail(logstr, n): lines = logstr.split("\n")[-n:] return "\n".join(lines) return "\n".join( [ "CLI logs", tail(inst.getCLILogContents(), 500), "Server logs", tail(inst.getServerLogContents(), 500), ] )
def is_hg_installed(): with open(os.devnull, "wb") as devnull: try: env = os.environ.copy() env["HGPLAIN"] = "1" env["WATCHMAN_SOCK"] = ( WatchmanInstance.getSharedInstance().getSockPath().legacy_sockpath() ) exit_code = subprocess.call( ["hg", "--version"], stdout=devnull, stderr=devnull, env=env ) return exit_code == 0 except OSError as e: if e.errno == errno.ENOENT: return False raise
def spawnWatchmanWait(self, cmdArgs): wait_script = os.environ.get("WATCHMAN_WAIT_PATH") if wait_script: args = [wait_script] else: args = [ sys.executable, os.path.join(os.environ["WATCHMAN_PYTHON_BIN"], "watchman-wait"), ] args.extend(cmdArgs) env = os.environ.copy() sock_path = WatchmanInstance.getSharedInstance().getSockPath() env["WATCHMAN_SOCK"] = sock_path env["PYTHONPATH"] = env["PYWATCHMAN_PATH"] return subprocess.Popen( args, env=env, stdin=None, stdout=subprocess.PIPE, stderr=subprocess.PIPE )
def skipIfNoHgRequestIdSupport(self): root = self.mkdtemp() request_id = "bf8a47014bd1b66103a8ab0aece4be7ada871660" env = os.environ.copy() env["HGPLAIN"] = "1" env["HGREQUESTID"] = request_id env["WATCHMAN_SOCK"] = WatchmanInstance.getSharedInstance( ).getSockPath() subprocess.call(["hg", "init"], env=env, cwd=root) subprocess.call(["hg", "log"], env=env, cwd=root) try: with open(os.path.join(root, ".hg/blackbox.log")) as f: if request_id in f.read(): return except IOError: pass self.skipTest("HGREQUESTID is not supported")
def test_cppclient(self): env = os.environ.copy() env["WATCHMAN_SOCK"] = WatchmanInstance.getSharedInstance().getSockPath() proc = subprocess.Popen( TEST_BINARY, env=env, stdout=subprocess.PIPE, stderr=subprocess.PIPE ) (stdout, stderr) = proc.communicate() status = proc.poll() if status == -signal.SIGINT: Interrupt.setInterrupted() self.fail("Interrupted by SIGINT") return if status != 0: self.fail( "Exit status %d\n%s\n%s\n" % (status, stdout.decode("utf-8"), stderr.decode("utf-8")) ) return self.assertTrue(True, TEST_BINARY)
def hg(self, args=None, cwd=None): env = dict(os.environ) env['HGPLAIN'] = '1' env['HGUSER'] = '******' env['NOSCMLOG'] = '1' # disable some instrumentation at FB env['WATCHMAN_SOCK'] = \ WatchmanInstance.getSharedInstance().getSockPath() p = subprocess.Popen( # we force the extension on. This is a soft error for # mercurial if it is not available, so we also employ # the skipIfNoFSMonitor() test above to make sure the # environment is sane. ['hg', '--config', 'extensions.fsmonitor='] + args, env=env, cwd=cwd, stdout=subprocess.PIPE, stderr=subprocess.PIPE) out, err = p.communicate() if p.returncode != 0: raise Exception("hg %r failed: %s, %s" % (args, out, err)) return out, err
def hg(self, args=None, cwd=None): env = dict(os.environ) env["HGPLAIN"] = "1" env["HGUSER"] = "******" env["NOSCMLOG"] = "1" # disable some instrumentation at FB env["WATCHMAN_SOCK"] = WatchmanInstance.getSharedInstance().getSockPath() p = subprocess.Popen( # we force the extension on. This is a soft error for # mercurial if it is not available, so we also employ # the skipIfNoFSMonitor() test above to make sure the # environment is sane. [env.get("EDEN_HG_BINARY", "hg"), "--config", "extensions.fsmonitor="] + args, env=env, cwd=cwd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, ) out, err = p.communicate() if p.returncode != 0: raise Exception("hg %r failed: %s, %s" % (args, out, err)) return out, err
def resumeWatchman(self): WatchmanInstance.getSharedInstance().resume()
def setUp(self): self.loop = asyncio.get_event_loop() sockpath = WatchmanInstance.getSharedInstance().getSockPath() self.client = self.loop.run_until_complete(WatchmanClient.from_socket(sockpath))
def getSockPath(self): return WatchmanInstance.getSharedInstance().getSockPath()
def runTest(self): env = os.environ.copy() env['WATCHMAN_SOCK'] = WatchmanInstance.getSharedInstance().getSockPath() proc = subprocess.Popen( self.getCommandArgs(), stdout=subprocess.PIPE, stderr=subprocess.PIPE) (stdout, stderr) = proc.communicate() status = proc.poll() if status == -signal.SIGINT: Interrupt.setInterrupted() self.fail('Interrupted by SIGINT') return if status != 0: self.fail("Exit status %d\n%s\n%s\n" % (status, stdout, stderr)) return res_pat = re.compile('^(not )?ok (\d+) (.*)$') diag_pat = re.compile('^# (.*)$') # Now parse the TAP output lines = stdout.split('\n') # first line is the plan try: plan = int(lines.pop(0).split('..')[1]) except Exception as e: self.fail(stdout + '\n' + stderr) return last_test = 0 diags = None for line in lines: res = res_pat.match(line) if res: this_test = int(res.group(2)) if this_test != last_test + 1: print(stdout, stderr) self.fail('Expected test number %d, got %d' % ( last_test + 1, this_test)) last_test = this_test if res.group(1) == 'not ': # Failed msg = line if diags is not None: msg = msg + '\n'.join(diags) self.fail(msg) failed diags = None continue res = diag_pat.match(line) if res: if diags is None: diags = [] diags.append(res.group(1)) continue if line != '': print('Invalid tap output from %s: %s' % (self.id(), line)) self.assertEqual(last_test, plan, '%s planned %d but executed %d tests' % ( self.id(), plan, last_test))
def runTest(self): env = os.environ.copy() env['WATCHMAN_SOCK'] = WatchmanInstance.getSharedInstance( ).getSockPath() dotted = os.path.normpath(self.id()).replace(os.sep, '.').replace( 'tests.integration.', '').replace('.php', '') env['TMPDIR'] = os.path.join(tempfile.tempdir, dotted) if os.name != 'nt' and len(env['TMPDIR']) > 94: self.fail('temp dir name %s is too long for unix domain sockets' % env['TMPDIR']) os.mkdir(env['TMPDIR']) env['TMP'] = env['TMPDIR'] env['TEMP'] = env['TMPDIR'] env['IN_PYTHON_HARNESS'] = '1' proc = subprocess.Popen(self.getCommandArgs(), env=env, stdout=subprocess.PIPE, stderr=subprocess.PIPE) (stdout, stderr) = proc.communicate() status = proc.poll() if status == -signal.SIGINT: Interrupt.setInterrupted() self.fail('Interrupted by SIGINT') return if status != 0: self.fail("Exit status %d\n%s\n%s\n" % (status, stdout, stderr)) return res_pat = re.compile('^(not )?ok (\d+) (.*)$') diag_pat = re.compile('^# (.*)$') plan_pat = re.compile('^1\.\.(\d+)$') # Now parse the TAP output lines = stdout.replace('\r\n', '\n').split('\n') last_test = 0 diags = None plan = None for line in lines: res = plan_pat.match(line) if res: plan = int(res.group(1)) continue res = res_pat.match(line) if res: this_test = int(res.group(2)) if this_test != last_test + 1: print(stdout, stderr) self.fail('Expected test number %d, got %d' % (last_test + 1, this_test)) last_test = this_test if res.group(1) == 'not ': # Failed msg = line if diags is not None: msg = msg + '\n' + '\n'.join(diags) self.fail(msg) failed diags = None continue res = diag_pat.match(line) if res: if diags is None: diags = [] diags.append(res.group(1)) continue if line != '': print('Invalid tap output from %s: %s' % (self.id(), line)) if plan is None: self.fail('no plan was observed') else: self.assertEqual( last_test, plan, '%s planned %d but executed %s tests' % (self.id(), plan, last_test))
def getServerLogContents(self): """ Returns the contents of the server log file as an array that has already been split by line. """ return WatchmanInstance.getSharedInstance().getServerLogContents().split("\n")
def suspendWatchman(self): WatchmanInstance.getSharedInstance().suspend()
def runTest(self): env = os.environ.copy() env["WATCHMAN_SOCK"] = WatchmanInstance.getSharedInstance().getSockPath() dotted = os.path.normpath(self.id()).replace(os.sep, ".").replace("tests.integration.", "").replace(".php", "") env["TMPDIR"] = os.path.join(tempfile.tempdir, dotted) if os.name != "nt" and len(env["TMPDIR"]) > 94: self.fail("temp dir name %s is too long for unix domain sockets" % env["TMPDIR"]) os.mkdir(env["TMPDIR"]) env["IN_PYTHON_HARNESS"] = "1" proc = subprocess.Popen(self.getCommandArgs(), env=env, stdout=subprocess.PIPE, stderr=subprocess.PIPE) (stdout, stderr) = proc.communicate() status = proc.poll() if status == -signal.SIGINT: Interrupt.setInterrupted() self.fail("Interrupted by SIGINT") return if status != 0: self.fail("Exit status %d\n%s\n%s\n" % (status, stdout, stderr)) return res_pat = re.compile("^(not )?ok (\d+) (.*)$") diag_pat = re.compile("^# (.*)$") plan_pat = re.compile("^1\.\.(\d+)$") # Now parse the TAP output lines = stdout.split("\n") last_test = 0 diags = None plan = None for line in lines: res = plan_pat.match(line) if res: plan = int(res.group(1)) continue res = res_pat.match(line) if res: this_test = int(res.group(2)) if this_test != last_test + 1: print(stdout, stderr) self.fail("Expected test number %d, got %d" % (last_test + 1, this_test)) last_test = this_test if res.group(1) == "not ": # Failed msg = line if diags is not None: msg = msg + "\n".join(diags) self.fail(msg) failed diags = None continue res = diag_pat.match(line) if res: if diags is None: diags = [] diags.append(res.group(1)) continue if line != "": print("Invalid tap output from %s: %s" % (self.id(), line)) self.assertEqual(last_test, plan, "%s planned %d but executed %s tests" % (self.id(), plan, last_test))
def runTest(self): env = os.environ.copy() env['WATCHMAN_SOCK'] = WatchmanInstance.getSharedInstance().getSockPath() def clean_file_name(name): name = name.replace(os.sep, '') name = name.replace('tests.integration', '') name = name.replace('.php', '') name = name.replace('_php', '') name = name.replace('.runTest', '') return name dotted = clean_file_name(os.path.normpath(self.id())) env['TMPDIR'] = os.path.join(TempDir.get_temp_dir().get_dir(), dotted) if os.name != 'nt' and len(env['TMPDIR']) > 94: self.fail('temp dir name %s is too long for unix domain sockets' % env['TMPDIR']) os.mkdir(env['TMPDIR']) env['TMP'] = env['TMPDIR'] env['TEMP'] = env['TMPDIR'] env['IN_PYTHON_HARNESS'] = '1' env['WATCHMAN_PYTHON_BINARY'] = sys.executable proc = subprocess.Popen( self.getCommandArgs(), cwd=env.get('WATCHMAN_SRC_DIR', os.getcwd()), env=env, stdout=subprocess.PIPE, stderr=subprocess.PIPE) (stdout, stderr) = proc.communicate() status = proc.poll() if status == -signal.SIGINT: Interrupt.setInterrupted() self.fail('Interrupted by SIGINT') return if status != 0: self.fail("Exit status %d\n%s\n%s\n" % (status, stdout, stderr)) return res_pat = re.compile(b'^(not )?ok (\d+) (.*)$') diag_pat = re.compile(b'^# (.*)$') plan_pat = re.compile(b'^1\.\.(\d+)$') # Now parse the TAP output lines = stdout.replace(b'\r\n', b'\n').split(b'\n') last_test = 0 diags = None plan = None for line in lines: res = plan_pat.match(line) if res: plan = int(res.group(1)) continue res = res_pat.match(line) if res: this_test = int(res.group(2)) if this_test != last_test + 1: print(stdout, stderr) self.fail('Expected test number %d, got %d' % ( last_test + 1, this_test)) last_test = this_test if res.group(1) == b'not ': # Failed msg = line if diags is not None: msg = msg + b'\n' + b'\n'.join(diags) self.fail(msg.decode('utf-8')) failed diags = None continue res = diag_pat.match(line) if res: if diags is None: diags = [] diags.append(res.group(1)) continue if line != b'': print('Invalid tap output from %s: %s' % (self.id(), line)) if plan is None: self.fail('no plan was observed') else: self.assertEqual(last_test, plan, '%s planned %d but executed %s tests' % ( self.id(), plan, last_test))