def test_get_uncached_files(self, mock_os): file_path = os.path.join(self.caching_test_dir, 'test.c') cache = FileCache(self.log_printer, 'coala_test3', flush_cache=True) # Since this is a new FileCache object, the return must be the full set cache.current_time = 0 mock_os.path.getmtime.return_value = 0 self.assertEqual(cache.get_uncached_files({file_path}), {file_path}) cache.track_files({file_path}) self.assertEqual(cache.get_uncached_files({file_path}), {file_path}) cache.write() self.assertEqual(cache.get_uncached_files({file_path}), set()) # Simulate changing the file and then getting uncached files # Since the file has been edited since the last run it's returned cache.current_time = 1 mock_os.path.getmtime.return_value = 1 cache.track_files({file_path}) self.assertEqual(cache.get_uncached_files({file_path}), {file_path}) cache.write() # Not changing the file should NOT return it the next time cache.current_time = 2 self.assertEqual(cache.get_uncached_files({file_path}), set())
def test_get_uncached_files(self, mock_os): file_path = os.path.join(self.caching_test_dir, 'test.c') cache = FileCache(self.log_printer, 'coala_test3', flush_cache=True) # Since this is a new FileCache object, the return must be the full set cache.current_time = 0 mock_os.path.getmtime.return_value = 0 self.assertEqual(cache.get_uncached_files({file_path}), {file_path}) cache.track_files({file_path}) self.assertEqual(cache.get_uncached_files({file_path}), {file_path}) cache.write() self.assertEqual(cache.get_uncached_files({file_path}), set()) # Simulate changing the file and then getting uncached files # Since the file has been edited since the last run it's returned cache.current_time = 1 mock_os.path.getmtime.return_value = 1 cache.track_files({file_path}) self.assertEqual(cache.get_uncached_files({file_path}), {file_path}) cache.write() # Not changing the file should NOT return it the next time cache.current_time = 2 self.assertEqual(cache.get_uncached_files({file_path}), set())
def test_time_travel(self): cache = FileCache(self.log_printer, 'coala_test2', flush_cache=True) cache.track_files({'file.c'}) cache.write() self.assertTrue('file.c' in cache.data) cache_data = pickle_load(self.log_printer, 'coala_test2', {}) # Back to the future :) cache_data['time'] = 2000000000 pickle_dump(self.log_printer, 'coala_test2', cache_data) cache = FileCache(self.log_printer, 'coala_test2', flush_cache=False) self.assertFalse('file.c' in cache.data)
def test_time_travel(self): cache = FileCache(self.log_printer, 'coala_test2', flush_cache=True) cache.track_files({'file.c'}) cache.write() self.assertTrue('file.c' in cache.data) cache_data = pickle_load(self.log_printer, 'coala_test2', {}) # Back to the future :) cache_data['time'] = 2000000000 pickle_dump(self.log_printer, 'coala_test2', cache_data) cache = FileCache(self.log_printer, 'coala_test2', flush_cache=False) self.assertFalse('file.c' in cache.data)
def test_time_travel(self): cache = FileCache(self.log_printer, "coala_test2", flush_cache=True) cache.track_files({"file.c"}) cache.write() self.assertTrue("file.c" in cache.data) cache_data = pickle_load(self.log_printer, "coala_test2", {}) # Back to the future :) cache_data["time"] = 2000000000 pickle_dump(self.log_printer, "coala_test2", cache_data) cache = FileCache(self.log_printer, "coala_test2", flush_cache=False) self.assertFalse("file.c" in cache.data)
def test_time_travel(self): cache = FileCache(self.log_printer, "coala_test2", flush_cache=True) cache.track_files({"file.c"}) cache.write() self.assertTrue("file.c" in cache.data) cache_data = pickle_load(self.log_printer, "coala_test2", {}) # Back to the future :) cache_data["time"] = 2000000000 pickle_dump(self.log_printer, "coala_test2", cache_data) cache = FileCache(self.log_printer, "coala_test2", flush_cache=False) self.assertFalse("file.c" in cache.data)
class CachingTest(unittest.TestCase): def setUp(self): current_dir = os.path.split(__file__)[0] self.caching_test_dir = os.path.join(current_dir, 'caching_testfiles') self.log_printer = LogPrinter(NullPrinter()) self.cache = FileCache(self.log_printer, 'coala_test', flush_cache=True) def test_file_tracking(self): self.cache.track_files({'test.c', 'file.py'}) self.assertEqual(self.cache.data, {'test.c': -1, 'file.py': -1}) self.cache.untrack_files({'test.c'}) self.cache.track_files({'test.c'}) self.cache.write() self.assertFalse('test.c' in self.cache.data) self.assertTrue('file.py' in self.cache.data) self.cache.untrack_files({'test.c', 'file.py'}) self.cache.write() self.assertFalse('test.c' in self.cache.data) self.assertFalse('file.py' in self.cache.data) def test_write(self): self.cache.track_files({'test2.c'}) self.assertEqual(self.cache.data['test2.c'], -1) self.cache.write() self.assertNotEqual(self.cache.data['test2.c'], -1) @patch('coalib.misc.Caching.os') def test_get_uncached_files(self, mock_os): file_path = os.path.join(self.caching_test_dir, 'test.c') cache = FileCache(self.log_printer, 'coala_test3', flush_cache=True) # Since this is a new FileCache object, the return must be the full set cache.current_time = 0 mock_os.path.getmtime.return_value = 0 self.assertEqual(cache.get_uncached_files({file_path}), {file_path}) cache.track_files({file_path}) self.assertEqual(cache.get_uncached_files({file_path}), {file_path}) cache.write() self.assertEqual(cache.get_uncached_files({file_path}), set()) # Simulate changing the file and then getting uncached files # Since the file has been edited since the last run it's returned cache.current_time = 1 mock_os.path.getmtime.return_value = 1 cache.track_files({file_path}) self.assertEqual(cache.get_uncached_files({file_path}), {file_path}) cache.write() # Not changing the file should NOT return it the next time cache.current_time = 2 self.assertEqual(cache.get_uncached_files({file_path}), set()) def test_persistence(self): with FileCache(self.log_printer, 'test3', flush_cache=True) as cache: cache.track_files({'file.c'}) self.assertTrue('file.c' in cache.data) with FileCache(self.log_printer, 'test3', flush_cache=False) as cache: self.assertTrue('file.c' in cache.data) def test_time_travel(self): cache = FileCache(self.log_printer, 'coala_test2', flush_cache=True) cache.track_files({'file.c'}) cache.write() self.assertTrue('file.c' in cache.data) cache_data = pickle_load(self.log_printer, 'coala_test2', {}) # Back to the future :) cache_data['time'] = 2000000000 pickle_dump(self.log_printer, 'coala_test2', cache_data) cache = FileCache(self.log_printer, 'coala_test2', flush_cache=False) self.assertFalse('file.c' in cache.data) def test_caching_results(self): """ A simple integration test to assert that results are not dropped when coala is ran multiple times with caching enabled. """ with bear_test_module(), \ prepare_file(['a=(5,6)'], None) as (lines, filename): with simulate_console_inputs('n'): retval, stdout, stderr = execute_coala( coala.main, 'coala', '-c', os.devnull, '--disable-caching', '--flush-cache', '-f', filename, '-b', 'LineCountTestBear', '-L', 'DEBUG') self.assertIn('This file has', stdout) self.assertIn('Running bear LineCountTestBear', stderr) # Due to the change in configuration from the removal of # ``--flush-cache`` this run will not be sufficient to # assert this behavior. retval, stdout, stderr = execute_coala(coala.main, 'coala', '--non-interactive', '--no-color', '-c', os.devnull, '-f', filename, '-b', 'LineCountTestBear') self.assertIn('This file has', stdout) self.assertEqual(1, len(stderr.splitlines())) self.assertIn( 'LineCountTestBear: This result has no patch attached.', stderr) retval, stdout, stderr = execute_coala(coala.main, 'coala', '--non-interactive', '--no-color', '-c', os.devnull, '-f', filename, '-b', 'LineCountTestBear') self.assertIn('This file has', stdout) self.assertEqual(1, len(stderr.splitlines())) self.assertIn( 'LineCountTestBear: This result has no patch attached.', stderr) def test_caching_multi_results(self): """ Integration test to assert that results are not dropped when coala is ran multiple times with caching enabled and one section yields a result and second one doesn't. """ filename = 'tests/misc/test_caching_multi_results/' with bear_test_module(): with simulate_console_inputs('n'): retval, stdout, stderr = execute_coala(coala.main, 'coala', '-c', filename + '.coafile', '-f', filename + 'test.py') self.assertIn('This file has', stdout) self.assertIn( 'Implicit \'Default\' section inheritance is deprecated', stderr) retval, stdout, stderr = execute_coala(coala.main, 'coala', '--non-interactive', '--no-color', '-c', filename + '.coafile', '-f', filename + 'test.py') self.assertIn('This file has', stdout) self.assertEqual(2, len(stderr.splitlines())) self.assertIn( 'LineCountTestBear: This result has no patch attached.', stderr) self.assertIn( 'Implicit \'Default\' section inheritance is deprecated', stderr)
class CachingTest(unittest.TestCase): def setUp(self): current_dir = os.path.split(__file__)[0] self.caching_test_dir = os.path.join( current_dir, 'caching_testfiles') self.log_printer = LogPrinter(NullPrinter()) self.cache = FileCache(self.log_printer, 'coala_test', flush_cache=True) def test_file_tracking(self): self.cache.track_files({'test.c', 'file.py'}) self.assertEqual(self.cache.data, {'test.c': -1, 'file.py': -1}) self.cache.untrack_files({'test.c'}) self.cache.track_files({'test.c'}) self.cache.write() self.assertFalse('test.c' in self.cache.data) self.assertTrue('file.py' in self.cache.data) self.cache.untrack_files({'test.c', 'file.py'}) self.cache.write() self.assertFalse('test.c' in self.cache.data) self.assertFalse('file.py' in self.cache.data) def test_write(self): self.cache.track_files({'test2.c'}) self.assertEqual(self.cache.data['test2.c'], -1) self.cache.write() self.assertNotEqual(self.cache.data['test2.c'], -1) @patch('coalib.misc.Caching.os') def test_get_uncached_files(self, mock_os): file_path = os.path.join(self.caching_test_dir, 'test.c') cache = FileCache(self.log_printer, 'coala_test3', flush_cache=True) # Since this is a new FileCache object, the return must be the full set cache.current_time = 0 mock_os.path.getmtime.return_value = 0 self.assertEqual(cache.get_uncached_files({file_path}), {file_path}) cache.track_files({file_path}) self.assertEqual(cache.get_uncached_files({file_path}), {file_path}) cache.write() self.assertEqual(cache.get_uncached_files({file_path}), set()) # Simulate changing the file and then getting uncached files # Since the file has been edited since the last run it's returned cache.current_time = 1 mock_os.path.getmtime.return_value = 1 cache.track_files({file_path}) self.assertEqual(cache.get_uncached_files({file_path}), {file_path}) cache.write() # Not changing the file should NOT return it the next time cache.current_time = 2 self.assertEqual(cache.get_uncached_files({file_path}), set()) def test_persistence(self): with FileCache(self.log_printer, 'test3', flush_cache=True) as cache: cache.track_files({'file.c'}) self.assertTrue('file.c' in cache.data) with FileCache(self.log_printer, 'test3', flush_cache=False) as cache: self.assertTrue('file.c' in cache.data) def test_time_travel(self): cache = FileCache(self.log_printer, 'coala_test2', flush_cache=True) cache.track_files({'file.c'}) cache.write() self.assertTrue('file.c' in cache.data) cache_data = pickle_load(self.log_printer, 'coala_test2', {}) # Back to the future :) cache_data['time'] = 2000000000 pickle_dump(self.log_printer, 'coala_test2', cache_data) cache = FileCache(self.log_printer, 'coala_test2', flush_cache=False) self.assertFalse('file.c' in cache.data) def test_caching_results(self): """ A simple integration test to assert that results are not dropped when coala is ran multiple times with caching enabled. """ with bear_test_module(): with prepare_file(['a=(5,6)'], None) as (lines, filename): with simulate_console_inputs('n'): retval, stdout, stderr = execute_coala( coala.main, 'coala', '-c', os.devnull, '--disable-caching', '--flush-cache', '-f', filename, '-b', 'LineCountTestBear', '-L', 'DEBUG') self.assertIn('This file has', stdout) self.assertIn('Running bear LineCountTestBear', stderr) # Due to the change in configuration from the removal of # ``--flush-cache`` this run will not be sufficient to # assert this behavior. retval, stdout, stderr = execute_coala( coala.main, 'coala', '--non-interactive', '--no-color', '-c', os.devnull, '-f', filename, '-b', 'LineCountTestBear') self.assertIn('This file has', stdout) self.assertEqual(1, len(stderr.splitlines())) self.assertIn( 'LineCountTestBear: This result has no patch attached.', stderr) retval, stdout, stderr = execute_coala( coala.main, 'coala', '--non-interactive', '--no-color', '-c', os.devnull, '-f', filename, '-b', 'LineCountTestBear') self.assertIn('This file has', stdout) self.assertEqual(1, len(stderr.splitlines())) self.assertIn( 'LineCountTestBear: This result has no patch attached.', stderr) def test_caching_multi_results(self): """ Integration test to assert that results are not dropped when coala is ran multiple times with caching enabled and one section yields a result and second one doesn't. """ filename = 'tests/misc/test_caching_multi_results/' with bear_test_module(): with simulate_console_inputs('n'): retval, stdout, stderr = execute_coala( coala.main, 'coala', '-c', filename + '.coafile', '-f', filename + 'test.py') self.assertIn('This file has', stdout) self.assertIn( 'Implicit \'Default\' section inheritance is deprecated', stderr) retval, stdout, stderr = execute_coala( coala.main, 'coala', '--non-interactive', '--no-color', '-c', filename + '.coafile', '-f', filename + 'test.py') self.assertIn('This file has', stdout) self.assertEqual(2, len(stderr.splitlines())) self.assertIn( 'LineCountTestBear: This result has no patch attached.', stderr) self.assertIn( 'Implicit \'Default\' section inheritance is deprecated', stderr)
class CachingTest(unittest.TestCase): def setUp(self): current_dir = os.path.split(__file__)[0] self.caching_test_dir = os.path.join(current_dir, "caching_testfiles") self.log_printer = LogPrinter(NullPrinter()) self.cache = FileCache(self.log_printer, "coala_test", flush_cache=True) def test_file_tracking(self): self.cache.track_files({"test.c", "file.py"}) self.assertEqual(self.cache.data, {"test.c": -1, "file.py": -1}) self.cache.untrack_files({"test.c"}) self.assertFalse("test.c" in self.cache.data) self.assertTrue("file.py" in self.cache.data) self.cache.untrack_files({"test.c", "file.py"}) self.assertFalse("test.c" in self.cache.data) self.assertFalse("file.py" in self.cache.data) def test_write(self): self.cache.track_files({"test2.c"}) self.assertEqual(self.cache.data["test2.c"], -1) self.cache.write() self.assertNotEqual(self.cache.data["test2.c"], -1) @patch('coalib.misc.Caching.os') def test_get_uncached_files(self, mock_os): file_path = os.path.join(self.caching_test_dir, "test.c") cache = FileCache(self.log_printer, "coala_test3", flush_cache=True) # Since this is a new FileCache object, the return must be the full set cache.current_time = 0 mock_os.path.getmtime.return_value = 0 self.assertEqual(cache.get_uncached_files({file_path}), {file_path}) cache.track_files({file_path}) self.assertEqual(cache.get_uncached_files({file_path}), {file_path}) cache.write() self.assertEqual(cache.get_uncached_files({file_path}), set()) # Simulate changing the file and then getting uncached files # Since the file has been edited since the last run it's returned cache.current_time = 1 mock_os.path.getmtime.return_value = 1 cache.track_files({file_path}) self.assertEqual(cache.get_uncached_files({file_path}), {file_path}) cache.write() # Not changing the file should NOT return it the next time cache.current_time = 2 self.assertEqual(cache.get_uncached_files({file_path}), set()) def test_persistence(self): with FileCache(self.log_printer, "test3", flush_cache=True) as cache: cache.track_files({"file.c"}) self.assertTrue("file.c" in cache.data) with FileCache(self.log_printer, "test3", flush_cache=False) as cache: self.assertTrue("file.c" in cache.data) def test_time_travel(self): cache = FileCache(self.log_printer, "coala_test2", flush_cache=True) cache.track_files({"file.c"}) cache.write() self.assertTrue("file.c" in cache.data) cache_data = pickle_load(self.log_printer, "coala_test2", {}) # Back to the future :) cache_data["time"] = 2000000000 pickle_dump(self.log_printer, "coala_test2", cache_data) cache = FileCache(self.log_printer, "coala_test2", flush_cache=False) self.assertFalse("file.c" in cache.data) def test_caching_results(self): """ A simple integration test to assert that results are not dropped when coala is ran multiple times with caching enabled. """ with bear_test_module(), \ prepare_file(["a=(5,6)"], None) as (lines, filename): with simulate_console_inputs("0"): retval, output = execute_coala(coala.main, "coala", "-c", os.devnull, "--disable-caching", "--flush-cache", "-f", re.escape(filename), "-b", "LineCountTestBear", "-L", "DEBUG") self.assertIn("This file has", output) # Due to the change in configuration from the removal of # ``--flush-cache`` this run will not be sufficient to # assert this behavior. retval, output = execute_coala(coala.main, "coala", "-c", os.devnull, "-f", re.escape(filename), "-b", "LineCountTestBear") self.assertIn("This file has", output) retval, output = execute_coala(coala.main, "coala", "-c", os.devnull, "-f", re.escape(filename), "-b", "LineCountTestBear") self.assertIn("This file has", output)
class CachingTest(unittest.TestCase): def setUp(self): current_dir = os.path.split(__file__)[0] self.caching_test_dir = os.path.join( current_dir, "caching_testfiles") self.log_printer = LogPrinter(NullPrinter()) self.cache = FileCache(self.log_printer, "coala_test", flush_cache=True) def test_file_tracking(self): self.cache.track_files({"test.c", "file.py"}) self.assertEqual(self.cache.data, {"test.c": -1, "file.py": -1}) self.cache.untrack_files({"test.c"}) self.cache.track_files({"test.c"}) self.cache.write() self.assertFalse("test.c" in self.cache.data) self.assertTrue("file.py" in self.cache.data) self.cache.untrack_files({"test.c", "file.py"}) self.cache.write() self.assertFalse("test.c" in self.cache.data) self.assertFalse("file.py" in self.cache.data) def test_write(self): self.cache.track_files({"test2.c"}) self.assertEqual(self.cache.data["test2.c"], -1) self.cache.write() self.assertNotEqual(self.cache.data["test2.c"], -1) @patch('coalib.misc.Caching.os') def test_get_uncached_files(self, mock_os): file_path = os.path.join(self.caching_test_dir, "test.c") cache = FileCache(self.log_printer, "coala_test3", flush_cache=True) # Since this is a new FileCache object, the return must be the full set cache.current_time = 0 mock_os.path.getmtime.return_value = 0 self.assertEqual(cache.get_uncached_files({file_path}), {file_path}) cache.track_files({file_path}) self.assertEqual(cache.get_uncached_files({file_path}), {file_path}) cache.write() self.assertEqual(cache.get_uncached_files({file_path}), set()) # Simulate changing the file and then getting uncached files # Since the file has been edited since the last run it's returned cache.current_time = 1 mock_os.path.getmtime.return_value = 1 cache.track_files({file_path}) self.assertEqual(cache.get_uncached_files({file_path}), {file_path}) cache.write() # Not changing the file should NOT return it the next time cache.current_time = 2 self.assertEqual(cache.get_uncached_files({file_path}), set()) def test_persistence(self): with FileCache(self.log_printer, "test3", flush_cache=True) as cache: cache.track_files({"file.c"}) self.assertTrue("file.c" in cache.data) with FileCache(self.log_printer, "test3", flush_cache=False) as cache: self.assertTrue("file.c" in cache.data) def test_time_travel(self): cache = FileCache(self.log_printer, "coala_test2", flush_cache=True) cache.track_files({"file.c"}) cache.write() self.assertTrue("file.c" in cache.data) cache_data = pickle_load(self.log_printer, "coala_test2", {}) # Back to the future :) cache_data["time"] = 2000000000 pickle_dump(self.log_printer, "coala_test2", cache_data) cache = FileCache(self.log_printer, "coala_test2", flush_cache=False) self.assertFalse("file.c" in cache.data) def test_caching_results(self): """ A simple integration test to assert that results are not dropped when coala is ran multiple times with caching enabled. """ with bear_test_module(), \ prepare_file(["a=(5,6)"], None) as (lines, filename): with simulate_console_inputs("0"): retval, output = execute_coala( coala.main, "coala", "-c", os.devnull, "--disable-caching", "--flush-cache", "-f", re.escape(filename), "-b", "LineCountTestBear", "-L", "DEBUG") self.assertIn("This file has", output) # Due to the change in configuration from the removal of # ``--flush-cache`` this run will not be sufficient to # assert this behavior. retval, output = execute_coala( coala.main, "coala", "-c", os.devnull, "-f", re.escape(filename), "-b", "LineCountTestBear") self.assertIn("This file has", output) retval, output = execute_coala( coala.main, "coala", "-c", os.devnull, "-f", re.escape(filename), "-b", "LineCountTestBear") self.assertIn("This file has", output) def test_caching_multi_results(self): """ Integration test to assert that results are not dropped when coala is ran multiple times with caching enabled and one section yields a result and second one doesn't. """ filename = "tests/misc/test_caching_multi_results/" with bear_test_module(): with simulate_console_inputs("0"): retval, output = execute_coala( coala.main, "coala", "-c", filename + ".coafile", "-f", filename + "test.py") self.assertIn("This file has", output) retval, output = execute_coala( coala.main, "coala", "-c", filename + ".coafile", "-f", filename + "test.py") self.assertIn("This file has", output)