Say a little more in the README about why this is useful

[git-cache] / test_git_cache.py

diff --git a/test_git_cache.py b/test_git_cache.py
index 7cd232d7d8be6c4893b1812c71945ff7f4effe22..1845c010af8e33434e4218fa5a9fc33ff972b8d4 100644 (file)
--- a/test_git_cache.py
+++ b/test_git_cache.py
@@ -1,3 +1,10 @@
+# git-cache: Cache git content locally
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the
+# Free Software Foundation, version 3.
+
+

 import os.path
 import tempfile
 import shutil
 import os.path
 import tempfile
 import shutil


@@ -27,7 +34,7 @@ def _commit_file(
         filename: str,
         contents: str,
         commit_message: str) -> None:
         filename: str,
         contents: str,
         commit_message: str) -> None:

-    with open(os.path.join(directory, filename), 'w') as f:
+    with open(os.path.join(directory, filename), 'w', encoding='utf-8') as f:

         f.write(contents)
     _git(directory, 'add', filename)
     _git(directory, 'commit', '-m', commit_message)
         f.write(contents)
     _git(directory, 'add', filename)
     _git(directory, 'commit', '-m', commit_message)


@@ -37,9 +44,9 @@ def _commit_file(
 class TestGitCache(unittest.TestCase):
 
     def setUp(self) -> None:
 class TestGitCache(unittest.TestCase):
 
     def setUp(self) -> None:

-        self.xdgcache = tempfile.TemporaryDirectory(
+        self.xdgcache = tempfile.TemporaryDirectory(  # pylint: disable=consider-using-with

             prefix='git_cache_test-cache-')
             prefix='git_cache_test-cache-')

-        self.xdgdata = tempfile.TemporaryDirectory(
+        self.xdgdata = tempfile.TemporaryDirectory(  # pylint: disable=consider-using-with

             prefix='git_cache_test-data-')
         self.old_XDG_CACHE_HOME = os.environ.get('XDG_CACHE_HOME')
         self.old_XDG_DATA_HOME = os.environ.get('XDG_DATA_HOME')
             prefix='git_cache_test-data-')
         self.old_XDG_CACHE_HOME = os.environ.get('XDG_CACHE_HOME')
         self.old_XDG_DATA_HOME = os.environ.get('XDG_DATA_HOME')


@@ -54,9 +61,10 @@ class TestGitCache(unittest.TestCase):
         os.environ['BACKOFF_MAX_TIME'] = '0'
         os.environ['FORCE_WARNING_TIME'] = '0'  # ONLY FOR TEST USE!
 
         os.environ['BACKOFF_MAX_TIME'] = '0'
         os.environ['FORCE_WARNING_TIME'] = '0'  # ONLY FOR TEST USE!
 

-        self.tempdir = tempfile.TemporaryDirectory(prefix='git_cache_test-')
+        self.tempdir = tempfile.TemporaryDirectory(  # pylint: disable=consider-using-with
+            prefix='git_cache_test-')

         self.upstream = os.path.join(self.tempdir.name, 'upstream')
         self.upstream = os.path.join(self.tempdir.name, 'upstream')

-        subprocess.run(['git', '-c', 'init.defaultBranch=master',
+        subprocess.run(['git', '-c', 'init.defaultBranch=main',

                        'init', self.upstream], check=True)
         _commit_file(self.upstream, 'file', 'Contents', 'First commit')
 
                        'init', self.upstream], check=True)
         _commit_file(self.upstream, 'file', 'Contents', 'First commit')
 


@@ -68,80 +76,80 @@ class TestGitCache(unittest.TestCase):
         self.xdgcache.cleanup()
 
     def test_fetch(self) -> None:
         self.xdgcache.cleanup()
 
     def test_fetch(self) -> None:

-        d, rev = git_cache.fetch(self.upstream, 'master')
-        self.assertEqual(_git(d, 'show', '%s:file' % rev), b'Contents')
+        d, rev = git_cache.fetch(self.upstream, 'main')
+        self.assertEqual(_git(d, 'show', f'{rev}:file'), b'Contents')

 
     def test_fetch_twice(self) -> None:
 
     def test_fetch_twice(self) -> None:

-        d1, rev1 = git_cache.fetch(self.upstream, 'master')
-        self.assertEqual(_git(d1, 'show', '%s:file' % rev1), b'Contents')
-        d2, rev2 = git_cache.fetch(self.upstream, 'master')
+        d1, rev1 = git_cache.fetch(self.upstream, 'main')
+        self.assertEqual(_git(d1, 'show', f'{rev1}:file'), b'Contents')
+        d2, rev2 = git_cache.fetch(self.upstream, 'main')

         self.assertEqual(d1, d2)
         self.assertEqual(rev1, rev2)
         self.assertEqual(d1, d2)
         self.assertEqual(rev1, rev2)

-        self.assertEqual(_git(d2, 'show', '%s:file' % rev2), b'Contents')
+        self.assertEqual(_git(d2, 'show', f'{rev2}:file'), b'Contents')

 
     def test_fetch_then_ensure(self) -> None:
 
     def test_fetch_then_ensure(self) -> None:

-        d1, rev = git_cache.fetch(self.upstream, 'master')
-        self.assertEqual(_git(d1, 'show', '%s:file' % rev), b'Contents')
-        d2 = git_cache.ensure_rev_available(self.upstream, 'master', rev)
+        d1, rev = git_cache.fetch(self.upstream, 'main')
+        self.assertEqual(_git(d1, 'show', f'{rev}:file'), b'Contents')
+        d2 = git_cache.ensure_rev_available(self.upstream, 'main', rev)

         self.assertEqual(d1, d2)
         self.assertEqual(d1, d2)

-        self.assertEqual(_git(d2, 'show', '%s:file' % rev), b'Contents')
+        self.assertEqual(_git(d2, 'show', f'{rev}:file'), b'Contents')

 
     def test_ensure_then_fetch(self) -> None:
         rev1 = _git(
             self.upstream, 'log', '--format=%H', '-n1').strip().decode()
 
     def test_ensure_then_fetch(self) -> None:
         rev1 = _git(
             self.upstream, 'log', '--format=%H', '-n1').strip().decode()

-        d1 = git_cache.ensure_rev_available(self.upstream, 'master', rev1)
-        self.assertEqual(_git(d1, 'show', '%s:file' % rev1), b'Contents')
-        d2, rev2 = git_cache.fetch(self.upstream, 'master')
+        d1 = git_cache.ensure_rev_available(self.upstream, 'main', rev1)
+        self.assertEqual(_git(d1, 'show', f'{rev1}:file'), b'Contents')
+        d2, rev2 = git_cache.fetch(self.upstream, 'main')

         self.assertEqual(d1, d2)
         self.assertEqual(rev1, rev2)
         self.assertEqual(d1, d2)
         self.assertEqual(rev1, rev2)

-        self.assertEqual(_git(d2, 'show', '%s:file' % rev2), b'Contents')
+        self.assertEqual(_git(d2, 'show', f'{rev2}:file'), b'Contents')

 
     def test_fetch_new_file(self) -> None:
 
     def test_fetch_new_file(self) -> None:

-        d1, rev1 = git_cache.fetch(self.upstream, 'master')
+        d1, rev1 = git_cache.fetch(self.upstream, 'main')

         _commit_file(self.upstream, 'foofile', 'foo', 'Foo')
         _commit_file(self.upstream, 'foofile', 'foo', 'Foo')

-        d2, rev2 = git_cache.fetch(self.upstream, 'master')
+        d2, rev2 = git_cache.fetch(self.upstream, 'main')

         self.assertEqual(d1, d2)
         self.assertNotEqual(rev1, rev2)
         self.assertEqual(d1, d2)
         self.assertNotEqual(rev1, rev2)

-        self.assertEqual(_git(d2, 'show', '%s:foofile' % rev2), b'foo')
+        self.assertEqual(_git(d2, 'show', f'{rev2}:foofile'), b'foo')

 
     def test_ensure_doesnt_fetch_new_file(self) -> None:
 
     def test_ensure_doesnt_fetch_new_file(self) -> None:

-        d1, rev1 = git_cache.fetch(self.upstream, 'master')
+        d1, rev1 = git_cache.fetch(self.upstream, 'main')

         _commit_file(self.upstream, 'foofile', 'foo', 'Foo')
         rev2 = _git(
             self.upstream, 'log', '--format=%H', '-n1').strip().decode()
         self.assertNotEqual(rev1, rev2)
         _commit_file(self.upstream, 'foofile', 'foo', 'Foo')
         rev2 = _git(
             self.upstream, 'log', '--format=%H', '-n1').strip().decode()
         self.assertNotEqual(rev1, rev2)

-        d2 = git_cache.ensure_rev_available(self.upstream, 'master', rev1)
+        d2 = git_cache.ensure_rev_available(self.upstream, 'main', rev1)

         self.assertEqual(d1, d2)
         p = subprocess.run(
         self.assertEqual(d1, d2)
         p = subprocess.run(

-            ['git', '-C', d2, 'show', '%s:foofile' % rev2], check=False)
+            ['git', '-C', d2, 'show', f'{rev2}:foofile'], check=False)

         self.assertNotEqual(p.returncode, 0)
 
     def test_ensure_doesnt_fetch_from_deleted_upstream(self) -> None:
         self.assertNotEqual(p.returncode, 0)
 
     def test_ensure_doesnt_fetch_from_deleted_upstream(self) -> None:

-        d1, rev = git_cache.fetch(self.upstream, 'master')
+        d1, rev = git_cache.fetch(self.upstream, 'main')

         self.tempdir.cleanup()
         self.tempdir.cleanup()

-        d2 = git_cache.ensure_rev_available(self.upstream, 'master', rev)
+        d2 = git_cache.ensure_rev_available(self.upstream, 'main', rev)

         self.assertEqual(d1, d2)
 
     def test_ensure_fetches_new_file(self) -> None:
         self.assertEqual(d1, d2)
 
     def test_ensure_fetches_new_file(self) -> None:

-        d1, rev1 = git_cache.fetch(self.upstream, 'master')
+        d1, rev1 = git_cache.fetch(self.upstream, 'main')

         _commit_file(self.upstream, 'foofile', 'foo', 'Foo')
         rev2 = _git(
             self.upstream, 'log', '--format=%H', '-n1').strip().decode()
         self.assertNotEqual(rev1, rev2)
         _commit_file(self.upstream, 'foofile', 'foo', 'Foo')
         rev2 = _git(
             self.upstream, 'log', '--format=%H', '-n1').strip().decode()
         self.assertNotEqual(rev1, rev2)

-        d2 = git_cache.ensure_rev_available(self.upstream, 'master', rev2)
+        d2 = git_cache.ensure_rev_available(self.upstream, 'main', rev2)

         self.assertEqual(d1, d2)
         self.assertEqual(d1, d2)

-        self.assertEqual(_git(d2, 'show', '%s:foofile' % rev2), b'foo')
+        self.assertEqual(_git(d2, 'show', f'{rev2}:foofile'), b'foo')

 
     def test_fetch_raises_on_invalid_repo(self) -> None:
         self.tempdir.cleanup()
         with self.assertRaises(Exception):
 
     def test_fetch_raises_on_invalid_repo(self) -> None:
         self.tempdir.cleanup()
         with self.assertRaises(Exception):

-            git_cache.fetch(self.upstream, 'master')
+            git_cache.fetch(self.upstream, 'main')

 
     def test_ensure_raises_on_invalid_repo(self) -> None:
         rev = _git(self.upstream, 'log', '--format=%H', '-n1').strip().decode()
         self.tempdir.cleanup()
         with self.assertRaises(Exception):
 
     def test_ensure_raises_on_invalid_repo(self) -> None:
         rev = _git(self.upstream, 'log', '--format=%H', '-n1').strip().decode()
         self.tempdir.cleanup()
         with self.assertRaises(Exception):

-            git_cache.ensure_rev_available(self.upstream, 'master', rev)
+            git_cache.ensure_rev_available(self.upstream, 'main', rev)

 
     def test_fetch_raises_on_invalid_ref(self) -> None:
         with self.assertRaises(Exception):
 
     def test_fetch_raises_on_invalid_ref(self) -> None:
         with self.assertRaises(Exception):


@@ -164,94 +172,94 @@ class TestGitCache(unittest.TestCase):
         _commit_file(self.upstream, 'foofile', 'foo', 'Foo')
         rev = _git(self.upstream, 'log', '--format=%H', '-n1').strip().decode()
         with self.assertRaises(Exception):
         _commit_file(self.upstream, 'foofile', 'foo', 'Foo')
         rev = _git(self.upstream, 'log', '--format=%H', '-n1').strip().decode()
         with self.assertRaises(Exception):

-            git_cache.ensure_rev_available(self.upstream, 'master', rev)
+            git_cache.ensure_rev_available(self.upstream, 'main', rev)

 
     def test_ensure_other_branch(self) -> None:
         _git(self.upstream, 'checkout', '-b', 'otherbranch')
         _commit_file(self.upstream, 'foofile', 'foo', 'Foo')
         rev = _git(self.upstream, 'log', '--format=%H', '-n1').strip().decode()
         d = git_cache.ensure_rev_available(self.upstream, 'otherbranch', rev)
 
     def test_ensure_other_branch(self) -> None:
         _git(self.upstream, 'checkout', '-b', 'otherbranch')
         _commit_file(self.upstream, 'foofile', 'foo', 'Foo')
         rev = _git(self.upstream, 'log', '--format=%H', '-n1').strip().decode()
         d = git_cache.ensure_rev_available(self.upstream, 'otherbranch', rev)

-        self.assertEqual(_git(d, 'show', '%s:foofile' % rev), b'foo')
+        self.assertEqual(_git(d, 'show', f'{rev}:foofile'), b'foo')

 
     def test_catch_up(self) -> None:
         _git(self.upstream, 'checkout', '-b', 'otherbranch')
         _commit_file(self.upstream, 'foofile', 'foo', 'Foo')
         rev = _git(self.upstream, 'log', '--format=%H', '-n1').strip().decode()
         d = git_cache.ensure_rev_available(self.upstream, 'otherbranch', rev)
 
     def test_catch_up(self) -> None:
         _git(self.upstream, 'checkout', '-b', 'otherbranch')
         _commit_file(self.upstream, 'foofile', 'foo', 'Foo')
         rev = _git(self.upstream, 'log', '--format=%H', '-n1').strip().decode()
         d = git_cache.ensure_rev_available(self.upstream, 'otherbranch', rev)

-        self.assertEqual(_git(d, 'show', '%s:foofile' % rev), b'foo')
-        _git(self.upstream, 'checkout', 'master')
+        self.assertEqual(_git(d, 'show', f'{rev}:foofile'), b'foo')
+        _git(self.upstream, 'checkout', 'main')

         _git(self.upstream, 'merge', '--ff-only', 'otherbranch')
         _git(self.upstream, 'merge', '--ff-only', 'otherbranch')

-        d = git_cache.ensure_rev_available(self.upstream, 'master', rev)
-        self.assertEqual(_git(d, 'show', '%s:foofile' % rev), b'foo')
+        d = git_cache.ensure_rev_available(self.upstream, 'main', rev)
+        self.assertEqual(_git(d, 'show', f'{rev}:foofile'), b'foo')

 
     def test_fetch_after_cache_deleted(self) -> None:
 
     def test_fetch_after_cache_deleted(self) -> None:

-        d1, rev1 = git_cache.fetch(self.upstream, 'master')
+        d1, rev1 = git_cache.fetch(self.upstream, 'main')

         shutil.rmtree(d1)
         shutil.rmtree(d1)

-        d2, rev2 = git_cache.fetch(self.upstream, 'master')
+        d2, rev2 = git_cache.fetch(self.upstream, 'main')

         self.assertEqual(d1, d2)
         self.assertEqual(rev1, rev2)
         self.assertEqual(d1, d2)
         self.assertEqual(rev1, rev2)

-        self.assertEqual(_git(d2, 'show', '%s:file' % rev2), b'Contents')
+        self.assertEqual(_git(d2, 'show', f'{rev2}:file'), b'Contents')

 
     def test_ensure_after_cache_deleted(self) -> None:
 
     def test_ensure_after_cache_deleted(self) -> None:

-        d1, rev = git_cache.fetch(self.upstream, 'master')
+        d1, rev = git_cache.fetch(self.upstream, 'main')

         shutil.rmtree(d1)
         shutil.rmtree(d1)

-        d2 = git_cache.ensure_rev_available(self.upstream, 'master', rev)
+        d2 = git_cache.ensure_rev_available(self.upstream, 'main', rev)

         self.assertEqual(d1, d2)
         self.assertEqual(d1, d2)

-        self.assertEqual(_git(d2, 'show', '%s:file' % rev), b'Contents')
+        self.assertEqual(_git(d2, 'show', f'{rev}:file'), b'Contents')

 
     def test_fetch_raises_on_amend(self) -> None:
 
     def test_fetch_raises_on_amend(self) -> None:

-        git_cache.fetch(self.upstream, 'master')
+        git_cache.fetch(self.upstream, 'main')

         _git(self.upstream, 'commit', '--amend', '-m', 'Amended')
         with self.assertRaises(Exception):
         _git(self.upstream, 'commit', '--amend', '-m', 'Amended')
         with self.assertRaises(Exception):

-            git_cache.fetch(self.upstream, 'master')
+            git_cache.fetch(self.upstream, 'main')

 
     def test_ensure_raises_on_amend(self) -> None:
 
     def test_ensure_raises_on_amend(self) -> None:

-        git_cache.fetch(self.upstream, 'master')
+        git_cache.fetch(self.upstream, 'main')

         _git(self.upstream, 'commit', '--amend', '-m', 'Amended')
         rev = _git(self.upstream, 'log', '--format=%H', '-n1').strip().decode()
         with self.assertRaises(Exception):
         _git(self.upstream, 'commit', '--amend', '-m', 'Amended')
         rev = _git(self.upstream, 'log', '--format=%H', '-n1').strip().decode()
         with self.assertRaises(Exception):

-            git_cache.ensure_rev_available(self.upstream, 'master', rev)
+            git_cache.ensure_rev_available(self.upstream, 'main', rev)

 
     def test_fetch_raises_on_amend_after_cache_deleted(self) -> None:
 
     def test_fetch_raises_on_amend_after_cache_deleted(self) -> None:

-        d, _ = git_cache.fetch(self.upstream, 'master')
+        d, _ = git_cache.fetch(self.upstream, 'main')

         shutil.rmtree(d)
         _git(self.upstream, 'commit', '--amend', '-m', 'Amended')
         with self.assertRaises(Exception):
         shutil.rmtree(d)
         _git(self.upstream, 'commit', '--amend', '-m', 'Amended')
         with self.assertRaises(Exception):

-            git_cache.fetch(self.upstream, 'master')
+            git_cache.fetch(self.upstream, 'main')

 
     def test_ensure_raises_on_amend_after_cache_deleted(self) -> None:
 
     def test_ensure_raises_on_amend_after_cache_deleted(self) -> None:

-        d, _ = git_cache.fetch(self.upstream, 'master')
+        d, _ = git_cache.fetch(self.upstream, 'main')

         shutil.rmtree(d)
         _git(self.upstream, 'commit', '--amend', '-m', 'Amended')
         rev = _git(self.upstream, 'log', '--format=%H', '-n1').strip().decode()
         with self.assertRaises(Exception):
         shutil.rmtree(d)
         _git(self.upstream, 'commit', '--amend', '-m', 'Amended')
         rev = _git(self.upstream, 'log', '--format=%H', '-n1').strip().decode()
         with self.assertRaises(Exception):

-            git_cache.ensure_rev_available(self.upstream, 'master', rev)
+            git_cache.ensure_rev_available(self.upstream, 'main', rev)

 
     def test_force_fetch_after_amend(self) -> None:
 
     def test_force_fetch_after_amend(self) -> None:

-        git_cache.fetch(self.upstream, 'master')
+        git_cache.fetch(self.upstream, 'main')

         _git(self.upstream, 'commit', '--amend', '-m', 'Amended')
         _git(self.upstream, 'commit', '--amend', '-m', 'Amended')

-        git_cache.fetch(self.upstream, 'master', force=True)
+        git_cache.fetch(self.upstream, 'main', force=True)

 
     def test_force_ensure_after_amend(self) -> None:
 
     def test_force_ensure_after_amend(self) -> None:

-        git_cache.fetch(self.upstream, 'master')
+        git_cache.fetch(self.upstream, 'main')

         _git(self.upstream, 'commit', '--amend', '-m', 'Amended')
         rev = _git(self.upstream, 'log', '--format=%H', '-n1').strip().decode()
         git_cache.ensure_rev_available(
         _git(self.upstream, 'commit', '--amend', '-m', 'Amended')
         rev = _git(self.upstream, 'log', '--format=%H', '-n1').strip().decode()
         git_cache.ensure_rev_available(

-            self.upstream, 'master', rev, force=True)
+            self.upstream, 'main', rev, force=True)

 
     def test_force_fetch_after_amend_and_cache_delete(self) -> None:
 
     def test_force_fetch_after_amend_and_cache_delete(self) -> None:

-        d, _ = git_cache.fetch(self.upstream, 'master')
+        d, _ = git_cache.fetch(self.upstream, 'main')

         shutil.rmtree(d)
         _git(self.upstream, 'commit', '--amend', '-m', 'Amended')
         shutil.rmtree(d)
         _git(self.upstream, 'commit', '--amend', '-m', 'Amended')

-        git_cache.fetch(self.upstream, 'master', force=True)
+        git_cache.fetch(self.upstream, 'main', force=True)

 
     def test_force_ensure_after_amend_and_cache_delete(self) -> None:
 
     def test_force_ensure_after_amend_and_cache_delete(self) -> None:

-        d, _ = git_cache.fetch(self.upstream, 'master')
+        d, _ = git_cache.fetch(self.upstream, 'main')

         shutil.rmtree(d)
         _git(self.upstream, 'commit', '--amend', '-m', 'Amended')
         rev = _git(self.upstream, 'log', '--format=%H', '-n1').strip().decode()
         git_cache.ensure_rev_available(
         shutil.rmtree(d)
         _git(self.upstream, 'commit', '--amend', '-m', 'Amended')
         rev = _git(self.upstream, 'log', '--format=%H', '-n1').strip().decode()
         git_cache.ensure_rev_available(

-            self.upstream, 'master', rev, force=True)
+            self.upstream, 'main', rev, force=True)

 
 
 if __name__ == '__main__':
 
 
 if __name__ == '__main__':