def write_after_flock(self, pid_file): inst = ApplicationInstance(os.path.abspath(pid_file), auto_exit = False, flock = True) with open(self.temp_file, 'wt') as f: f.write('foo') inst.flockUnlock()
def write_after_flock(self, pid_file): inst = ApplicationInstance(os.path.abspath(pid_file), autoExit=False, flock=True) with open(self.temp_file, 'wt') as f: f.write('foo') inst.flockUnlock()
def write_after_flock( self, pid_file, ): inst = ApplicationInstance(os.path.abspath(pid_file), False) inst.flockExclusiv() with open(self.temp_file, 'wt') as f: f.write('foo') inst.flockUnlock()
class TestApplicationInstance(generic.TestCase): def setUp(self): super(TestApplicationInstance, self).setUp() self.temp_file = '/tmp/temp.txt' self.file_name = "/tmp/file_with_pid" self.inst = ApplicationInstance(os.path.abspath(self.file_name), False) self.subproc = None def tearDown(self): super(TestApplicationInstance, self).tearDown() for f in (self.temp_file, self.file_name): if os.path.exists(f): os.remove(f) self.killProcess() def createProcess(self): dummyPath = os.path.join(os.path.dirname(__file__), generic.DUMMY) self.subproc = subprocess.Popen(dummyPath) return self.subproc.pid def killProcess(self): if self.subproc: self.subproc.kill() self.subproc.wait() self.subproc = None def test_create_and_remove_pid_file(self): #create pid file self.inst.startApplication() self.assertTrue(os.path.isfile(self.file_name)) #remove pid file self.inst.exitApplication() self.assertFalse(os.path.isfile(self.file_name)) def test_write_pid_file(self): self.inst.startApplication() #get pid/procname of current process this_pid = os.getpid() this_procname = tools.processName(this_pid) with open(self.file_name, 'rt') as file_with_pid: self.assertEqual(file_with_pid.read(), '{}\n{}'.format(this_pid, this_procname)) @patch('builtins.open') def test_write_pid_fail(self, mock_open): mock_open.side_effect = OSError() self.inst.startApplication() def test_existing_process_with_correct_procname(self): """ Test the check function with an existing process with correct process name """ pid = self.createProcess() procname = tools.processName(pid) # create file with pid and process name with open(self.file_name, "wt") as file_with_pid: file_with_pid.write(str(pid) + "\n") file_with_pid.write(procname) # Execute test self.assertFalse(self.inst.check()) self.assertTrue(self.inst.busy()) def test_existing_process_with_correct_proc_cmdline(self): """ Test the check function with an existing process with correct process cmdline (for backwards compatibility) """ pid = self.createProcess() procname = tools.processCmdline(pid) # create file with pid and process name with open(self.file_name, "wt") as file_with_pid: file_with_pid.write(str(pid) + "\n") file_with_pid.write(procname) # Execute test self.assertFalse(self.inst.check()) def test_no_pid_file(self): self.assertTrue(self.inst.check()) def test_existing_process_with_wrong_procname(self): """ Test the check function with an existing process with wrong process name """ pid = self.createProcess() procname = tools.processName(pid) # create file with pid and process name with open(self.file_name, "wt") as file_with_pid: file_with_pid.write(str(pid) + "\n") file_with_pid.write(procname + "DELETE") # Execute test self.assertTrue(self.inst.check()) def test_existing_process_with_wrong_pid(self): """ Test the check function with an existing process with wrong pid """ pid = self.createProcess() procname = tools.processName(pid) # create file with pid and process name with open(self.file_name, "wt") as file_with_pid: file_with_pid.write("987654321\n") file_with_pid.write(procname) # Execute test self.assertTrue(self.inst.check()) def test_killing_existing_process(self): """ Test the check function with an existing process with correct process name """ pid = self.createProcess() procname = tools.processName(pid) # create file with pid and process name with open(self.file_name, "wt") as file_with_pid: file_with_pid.write(str(pid) + "\n") file_with_pid.write(procname) self.assertFalse(self.inst.check()) self.killProcess() # Execute test self.assertTrue(self.inst.check()) def test_non_existing_process(self): """ Test the check function with a non existing process """ # GIVE # # create file with fake pid and process name with open(self.file_name, "wt") as file_with_pid: file_with_pid.write("987654321\n") file_with_pid.write("FAKE_PROCNAME") # Execute test self.assertTrue(self.inst.check()) def test_leftover_empty_lockfile(self): with open(self.file_name, 'wt') as f: pass self.assertTrue(self.inst.check()) def write_after_flock(self, pid_file): inst = ApplicationInstance(os.path.abspath(pid_file), autoExit=False, flock=True) with open(self.temp_file, 'wt') as f: f.write('foo') inst.flockUnlock() def test_thread_write_without_flock(self): thread = Thread(target=self.write_after_flock, args=(self.file_name, )) thread.start() #wait for the thread to finish thread.join() self.assertTrue(os.path.exists(self.temp_file)) with open(self.temp_file, 'rt') as f: self.assertEqual(f.read(), 'foo') def test_flock_exclusive(self): self.inst.flockExclusiv() thread = Thread(target=self.write_after_flock, args=(self.file_name, )) thread.start() #give the thread some time thread.join(0.01) self.assertFalse(os.path.exists(self.temp_file)) self.inst.flockUnlock() #wait for the thread to finish thread.join() self.assertTrue(os.path.exists(self.temp_file)) with open(self.temp_file, 'rt') as f: self.assertEqual(f.read(), 'foo') @patch('builtins.open') def test_flock_exclusive_fail(self, mock_open): mock_open.side_effect = OSError() self.inst.flockExclusiv() def test_auto_flock(self): self.inst = ApplicationInstance(os.path.abspath(self.file_name), autoExit=False, flock=True) thread = Thread(target=self.write_after_flock, args=(self.file_name, )) thread.start() #give the thread some time thread.join(0.01) self.assertFalse(os.path.exists(self.temp_file)) self.inst.startApplication() #wait for the thread to finish thread.join() self.assertTrue(os.path.exists(self.temp_file)) with open(self.temp_file, 'rt') as f: self.assertEqual(f.read(), 'foo') def test_autoExit_unique_process(self): self.inst = ApplicationInstance(os.path.abspath(self.file_name), autoExit=True) self.assertTrue(os.path.exists(self.file_name)) this_pid = os.getpid() this_procname = tools.processName(this_pid) with open(self.file_name, 'rt') as file_with_pid: self.assertEqual(file_with_pid.read(), '{}\n{}'.format(this_pid, this_procname)) def test_autoExit_other_running_process(self): pid = self.createProcess() procname = tools.processName(pid) # create file with pid and process name with open(self.file_name, "wt") as file_with_pid: file_with_pid.write(str(pid) + "\n") file_with_pid.write(procname) with self.assertRaises(SystemExit): self.inst = ApplicationInstance(os.path.abspath(self.file_name), autoExit=True) def test_readPidFile(self): with open(self.file_name, "wt") as f: f.write('123\nfoo') self.assertEqual(self.inst.readPidFile(), (123, 'foo')) # ValueError with open(self.file_name, "wt") as f: f.write('foo\nbar') self.assertEqual(self.inst.readPidFile(), (0, 'bar')) @patch('builtins.open') def test_readPidFile_fail(self, mock_open): mock_open.side_effect = OSError() self.assertEqual(self.inst.readPidFile(), (0, ''))
class TestApplicationInstance(unittest.TestCase): def setUp(self): logger.DEBUG = '-v' in sys.argv self.temp_file = '/tmp/temp.txt' self.file_name = "/tmp/file_with_pid" self.inst = ApplicationInstance(os.path.abspath(self.file_name), False) self.subproc = None def tearDown(self): for f in (self.temp_file, self.file_name): if os.path.exists(f): os.remove(f) self.killProcess() def createProcess(self): dummy = 'dummy_proc.sh' dummyPath = os.path.join(os.path.dirname(__file__), dummy) self.subproc = subprocess.Popen(dummyPath) return self.subproc.pid def killProcess(self): if self.subproc: self.subproc.kill() self.subproc.wait() self.subproc = None def test_create_and_remove_pid_file(self): #create pid file self.inst.start_application() self.assertTrue(os.path.isfile(self.file_name)) #remove pid file self.inst.exit_application() self.assertFalse(os.path.isfile(self.file_name)) def test_write_pid_file(self): self.inst.start_application() #get pid/procname of current process this_pid = os.getpid() this_procname = tools.process_name(this_pid) with open(self.file_name, 'rt') as file_with_pid: self.assertEqual(file_with_pid.read(), '{}\n{}'.format(this_pid, this_procname)) def test_existing_process_with_correct_procname(self): """ Test the check function with an existing process with correct process name """ pid = self.createProcess() procname = tools.process_name(pid) # create file with pid and process name with open(self.file_name, "wt") as file_with_pid: file_with_pid.write(str(pid) + "\n") file_with_pid.write(procname) # Execute test self.assertFalse(self.inst.check()) def test_existing_process_with_correct_proc_cmdline(self): """ Test the check function with an existing process with correct process cmdline (for backwards compatibility) """ pid = self.createProcess() procname = tools.process_cmdline(pid) # create file with pid and process name with open(self.file_name, "wt") as file_with_pid: file_with_pid.write(str(pid) + "\n") file_with_pid.write(procname) # Execute test self.assertFalse(self.inst.check()) def test_no_pid_file(self): self.assertTrue(self.inst.check()) def test_existing_process_with_wrong_procname(self): """ Test the check function with an existing process with wrong process name """ pid = self.createProcess() procname = tools.process_name(pid) # create file with pid and process name with open(self.file_name, "wt") as file_with_pid: file_with_pid.write(str(pid) + "\n") file_with_pid.write(procname + "DELETE") # Execute test self.assertTrue(self.inst.check()) def test_existing_process_with_wrong_pid(self): """ Test the check function with an existing process with wrong pid """ pid = self.createProcess() procname = tools.process_name(pid) # create file with pid and process name with open(self.file_name, "wt") as file_with_pid: file_with_pid.write("987654321\n") file_with_pid.write(procname) # Execute test self.assertTrue(self.inst.check()) def test_killing_existing_process(self): """ Test the check function with an existing process with correct process name """ pid = self.createProcess() procname = tools.process_name(pid) # create file with pid and process name with open(self.file_name, "wt") as file_with_pid: file_with_pid.write(str(pid) + "\n") file_with_pid.write(procname) self.assertFalse(self.inst.check()) self.killProcess() # Execute test self.assertTrue(self.inst.check()) def test_non_existing_process(self): """ Test the check function with a non existing process """ # GIVE # # create file with fake pid and process name with open(self.file_name, "wt") as file_with_pid: file_with_pid.write("987654321\n") file_with_pid.write("FAKE_PROCNAME") # Execute test self.assertTrue(self.inst.check()) def test_leftover_empty_lockfile(self): with open(self.file_name, 'wt')as f: pass self.assertTrue(self.inst.check()) def write_after_flock(self, pid_file): inst = ApplicationInstance(os.path.abspath(pid_file), auto_exit = False, flock = True) with open(self.temp_file, 'wt') as f: f.write('foo') inst.flockUnlock() def test_thread_write_without_flock(self): thread = Thread(target = self.write_after_flock, args = (self.file_name, )) thread.start() #wait for the thread to finish thread.join() self.assertTrue(os.path.exists(self.temp_file)) with open(self.temp_file, 'rt') as f: self.assertEqual(f.read(), 'foo') def test_flock_exclusive(self): self.inst.flockExclusiv() thread = Thread(target = self.write_after_flock, args = (self.file_name, )) thread.start() #give the thread some time thread.join(0.01) self.assertFalse(os.path.exists(self.temp_file)) self.inst.flockUnlock() #wait for the thread to finish thread.join() self.assertTrue(os.path.exists(self.temp_file)) with open(self.temp_file, 'rt') as f: self.assertEqual(f.read(), 'foo') def test_auto_flock(self): self.inst = ApplicationInstance(os.path.abspath(self.file_name), auto_exit = False, flock = True) thread = Thread(target = self.write_after_flock, args = (self.file_name, )) thread.start() #give the thread some time thread.join(0.01) self.assertFalse(os.path.exists(self.temp_file)) self.inst.start_application() #wait for the thread to finish thread.join() self.assertTrue(os.path.exists(self.temp_file)) with open(self.temp_file, 'rt') as f: self.assertEqual(f.read(), 'foo') def test_auto_exit_unique_process(self): self.inst = ApplicationInstance(os.path.abspath(self.file_name), auto_exit = True) self.assertTrue(os.path.exists(self.file_name)) this_pid = os.getpid() this_procname = tools.process_name(this_pid) with open(self.file_name, 'rt') as file_with_pid: self.assertEqual(file_with_pid.read(), '{}\n{}'.format(this_pid, this_procname)) def test_auto_exit_other_running_process(self): pid = self.createProcess() procname = tools.process_name(pid) # create file with pid and process name with open(self.file_name, "wt") as file_with_pid: file_with_pid.write(str(pid) + "\n") file_with_pid.write(procname) with self.assertRaises(SystemExit): self.inst = ApplicationInstance(os.path.abspath(self.file_name), auto_exit = True)
class TestApplicationInstance(unittest.TestCase): def setUp(self): logger.DEBUG = '-v' in sys.argv self.temp_file = '/tmp/temp.txt' self.file_name = "/tmp/file_with_pid" self.inst = ApplicationInstance(os.path.abspath(self.file_name), False) self.subproc = None def tearDown(self): for f in (self.temp_file, self.file_name): if os.path.exists(f): os.remove(f) if self.subproc: self.subproc.kill() self.subproc = None def createProcess(self): with open(self.temp_file, 'wt') as output: self.subproc = subprocess.Popen("top", stdout=output) return self.subproc.pid def getProcName(self, pid): with open('/proc/%s/cmdline' % pid, 'r') as file: return file.read().strip('\n') def test_create_and_remove_pid_file(self): #create pid file self.inst.start_application() self.assertTrue(os.path.isfile(self.file_name)) #remove pid file self.inst.exit_application() self.assertFalse(os.path.isfile(self.file_name)) def test_write_pid_file(self): self.inst.start_application() #get pid/procname of current process this_pid = os.getpid() this_procname = self.getProcName(this_pid) with open(self.file_name, 'rt') as file_with_pid: self.assertEqual(file_with_pid.read(), '%s\n%s' % (this_pid, this_procname)) def test_existing_process_with_correct_procname(self): """ Test the check function with an existing process with correct process name """ pid = self.createProcess() procname = self.getProcName(pid) # create file with pid and process name with open(self.file_name, "wt") as file_with_pid: file_with_pid.write(str(pid) + "\n") file_with_pid.write(procname) # Execute test self.assertFalse(self.inst.check()) def test_existing_process_with_wrong_procname(self): """ Test the check function with an existing process with wrong process name """ pid = self.createProcess() procname = self.getProcName(pid) # create file with pid and process name with open(self.file_name, "wt") as file_with_pid: file_with_pid.write(str(pid) + "\n") file_with_pid.write(procname + "DELETE") # Execute test self.assertTrue(self.inst.check()) def test_existing_process_with_wrong_pid(self): """ Test the check function with an existing process with wrong pid """ pid = self.createProcess() procname = self.getProcName(pid) # create file with pid and process name with open(self.file_name, "wt") as file_with_pid: file_with_pid.write("987654321\n") file_with_pid.write(procname) # Execute test self.assertTrue(self.inst.check()) def test_killing_existing_process(self): """ Test the check function with an existing process with correct process name """ pid = self.createProcess() procname = self.getProcName(pid) # create file with pid and process name with open(self.file_name, "wt") as file_with_pid: file_with_pid.write(str(pid) + "\n") file_with_pid.write(procname) #kill process self.subproc.kill() self.subproc.wait() self.subproc = None # Execute test self.assertTrue(self.inst.check()) def test_non_existing_process(self): """ Test the check function with a non existing process """ # GIVE # # create file with fake pid and process name with open(self.file_name, "wt") as file_with_pid: file_with_pid.write("987654321\n") file_with_pid.write("FAKE_PROCNAME") # Execute test self.assertTrue(self.inst.check()) def test_leftover_empty_lockfile(self): with open(self.file_name, 'wt') as f: pass self.assertTrue(self.inst.check()) def write_after_flock( self, pid_file, ): inst = ApplicationInstance(os.path.abspath(pid_file), False) inst.flockExclusiv() with open(self.temp_file, 'wt') as f: f.write('foo') inst.flockUnlock() def test_thread_write_without_flock(self): thread = Thread(target=self.write_after_flock, args=(self.file_name, )) thread.start() #wait for the thread to finish thread.join() self.assertTrue(os.path.exists(self.temp_file)) with open(self.temp_file, 'rt') as f: self.assertEqual(f.read(), 'foo') def test_flock_exclusive(self): self.inst.flockExclusiv() thread = Thread(target=self.write_after_flock, args=(self.file_name, )) thread.start() #give the thread some time sleep(0.01) self.assertFalse(os.path.exists(self.temp_file)) self.inst.flockUnlock() #wait for the thread to finish thread.join() self.assertTrue(os.path.exists(self.temp_file)) with open(self.temp_file, 'rt') as f: self.assertEqual(f.read(), 'foo')
class TestApplicationInstance(unittest.TestCase): def setUp(self): logger.DEBUG = '-v' in sys.argv self.temp_file = '/tmp/temp.txt' self.file_name = "/tmp/file_with_pid" self.inst = ApplicationInstance(os.path.abspath(self.file_name), False) self.subproc = None def tearDown(self): for f in (self.temp_file, self.file_name): if os.path.exists(f): os.remove(f) if self.subproc: self.subproc.kill() self.subproc = None def createProcess(self): with open(self.temp_file, 'wt') as output: self.subproc = subprocess.Popen("top", stdout=output) return self.subproc.pid def getProcName(self, pid): with open('/proc/%s/cmdline' % pid, 'r') as file: return file.read().strip('\n') def test_create_and_remove_pid_file(self): #create pid file self.inst.start_application() self.assertTrue(os.path.isfile(self.file_name)) #remove pid file self.inst.exit_application() self.assertFalse(os.path.isfile(self.file_name)) def test_write_pid_file(self): self.inst.start_application() #get pid/procname of current process this_pid = os.getpid() this_procname = self.getProcName(this_pid) with open(self.file_name, 'rt') as file_with_pid: self.assertEqual(file_with_pid.read(), '%s\n%s' %(this_pid, this_procname)) def test_existing_process_with_correct_procname(self): """ Test the check function with an existing process with correct process name """ pid = self.createProcess() procname = self.getProcName(pid) # create file with pid and process name with open(self.file_name, "wt") as file_with_pid: file_with_pid.write(str(pid) + "\n") file_with_pid.write(procname) # Execute test self.assertFalse(self.inst.check()) def test_existing_process_with_wrong_procname(self): """ Test the check function with an existing process with wrong process name """ pid = self.createProcess() procname = self.getProcName(pid) # create file with pid and process name with open(self.file_name, "wt") as file_with_pid: file_with_pid.write(str(pid) + "\n") file_with_pid.write(procname + "DELETE") # Execute test self.assertTrue(self.inst.check()) def test_existing_process_with_wrong_pid(self): """ Test the check function with an existing process with wrong pid """ pid = self.createProcess() procname = self.getProcName(pid) # create file with pid and process name with open(self.file_name, "wt") as file_with_pid: file_with_pid.write("987654321\n") file_with_pid.write(procname) # Execute test self.assertTrue(self.inst.check()) def test_killing_existing_process(self): """ Test the check function with an existing process with correct process name """ pid = self.createProcess() procname = self.getProcName(pid) # create file with pid and process name with open(self.file_name, "wt") as file_with_pid: file_with_pid.write(str(pid) + "\n") file_with_pid.write(procname) #kill process self.subproc.kill() self.subproc.wait() self.subproc = None # Execute test self.assertTrue(self.inst.check()) def test_non_existing_process(self): """ Test the check function with a non existing process """ # GIVE # # create file with fake pid and process name with open(self.file_name, "wt") as file_with_pid: file_with_pid.write("987654321\n") file_with_pid.write("FAKE_PROCNAME") # Execute test self.assertTrue(self.inst.check()) def test_leftover_empty_lockfile(self): with open(self.file_name, 'wt')as f: pass self.assertTrue(self.inst.check()) def write_after_flock(self, pid_file,): inst = ApplicationInstance(os.path.abspath(pid_file), False) inst.flockExclusiv() with open(self.temp_file, 'wt') as f: f.write('foo') inst.flockUnlock() def test_thread_write_without_flock(self): thread = Thread(target = self.write_after_flock, args = (self.file_name, )) thread.start() #wait for the thread to finish thread.join() self.assertTrue(os.path.exists(self.temp_file)) with open(self.temp_file, 'rt') as f: self.assertEqual(f.read(), 'foo') def test_flock_exclusive(self): self.inst.flockExclusiv() thread = Thread(target = self.write_after_flock, args = (self.file_name, )) thread.start() #give the thread some time sleep(0.01) self.assertFalse(os.path.exists(self.temp_file)) self.inst.flockUnlock() #wait for the thread to finish thread.join() self.assertTrue(os.path.exists(self.temp_file)) with open(self.temp_file, 'rt') as f: self.assertEqual(f.read(), 'foo')
def write_after_flock(self, pid_file,): inst = ApplicationInstance(os.path.abspath(pid_file), False) inst.flockExclusiv() with open(self.temp_file, 'wt') as f: f.write('foo') inst.flockUnlock()