Close files opened by Scanner, Loader
We're seeing noise like the following in doc builds:
/foo/.tox/docs/lib/python3.9/site-packages/docutils/statemachine.py:707:
ResourceWarning: unclosed file <_io.BufferedReader name='/foo/.git/objects/pack/pack-dd69481843ca1b7377f2f109b0022221437aca20.pack'>
if not hasattr(pattern, 'match'):
ResourceWarning: Enable tracemalloc to get the object allocation traceback
Enable tracemalloc for Sphinx gives us the 'Loader' as the root cause:
$ python -W all::ResourceWarning -X tracemalloc=100 -m sphinx.cmd.build ...
...
File "/foo/.tox/docs/lib/python3.9/site-packages/reno/sphinxext.py", lineno 114
ldr = loader.Loader(conf)
File "/foo/.tox/docs/lib/python3.9/site-packages/reno/loader.py", lineno 63
self._load_data()
...
(you could also use PYTHONTRACEMALLOC and PYTHONWARNINGS env vars)
Following this thread, it appears 'reno.scanner.Scanner' creates an
instance of 'dulwich.repo.Repo', however, it fails to close it [1]. The
'reno.loader.Loader' uses 'Scanner', meaning this also leaves around
open files.
The solution is simple: add a 'close()' method to both the 'Scanner' and
'Loader', and provide the necessary '__enter__' and '__exit__' magic
methods to use it as a context manager, like the 'Repo' object itself
supports.
[1] https://www.dulwich.io/docs/api/dulwich.repo.html#dulwich.repo.Repo.close
Change-Id: I0b9776f431cf902a9ace5d52961eb77caaae8eaa
Signed-off-by: Stephen Finucane <stephenfin@redhat.com>
This commit is contained in:
Stephen Finucane
parent
8a80087d92
commit
cd31b907c3
@ -0,0 +1,31 @@
|
||||
---
|
||||
fixes:
|
||||
- |
|
||||
Instances of ``reno.scanner.Scanner`` and ``reno.loader.Loader`` will now
|
||||
corectly close all open files related to the scanned Git repo when the
|
||||
``close()`` method is called. Alternatively, these classes may be used as
|
||||
a context manager. Previously, Python would attempt to close these files
|
||||
itself, resulting in a ``ResourceWarning`` warning being emitted.
|
||||
features:
|
||||
- |
|
||||
The ``reno.scanner.Scanner`` and ``reno.loader.Loader`` classes can now
|
||||
be used as context managers. For example::
|
||||
|
||||
import reno.scannner
|
||||
|
||||
with reno.scanner.Scanner(...) as scanner:
|
||||
pass
|
||||
|
||||
This will ensure any open files pertaining to the scanned Git repo are
|
||||
correctly closed, avoiding ``ResourceWarning`` instances otherwise seen.
|
||||
|
||||
A ``close()`` method is also provided for both, allowing use outside of
|
||||
context managers. For example::
|
||||
|
||||
import reno.loader
|
||||
|
||||
loader = reno.loader.Loader(...)
|
||||
try:
|
||||
pass
|
||||
finally:
|
||||
loader.close()
|
||||
@ -21,50 +21,48 @@ from reno import scanner
|
||||
|
||||
|
||||
def build_cache_db(conf, versions_to_include):
|
||||
s = scanner.Scanner(conf)
|
||||
with scanner.Scanner(conf) as s:
|
||||
branches = [conf.branch]
|
||||
if not conf.branch: # if no branch requested, scan all
|
||||
branches += s.get_series_branches()
|
||||
|
||||
branches = [conf.branch]
|
||||
if not conf.branch: # if no branch requested, scan all
|
||||
branches += s.get_series_branches()
|
||||
notes = collections.OrderedDict()
|
||||
for branch in branches:
|
||||
notes.update(s.get_notes_by_version(branch))
|
||||
|
||||
notes = collections.OrderedDict()
|
||||
for branch in branches:
|
||||
notes.update(s.get_notes_by_version(branch))
|
||||
# Default to including all versions returned by the scanner.
|
||||
if not versions_to_include:
|
||||
versions_to_include = list(notes.keys())
|
||||
|
||||
# Default to including all versions returned by the scanner.
|
||||
if not versions_to_include:
|
||||
versions_to_include = list(notes.keys())
|
||||
# Build a cache data structure including the file contents as well
|
||||
# as the basic data returned by the scanner.
|
||||
file_contents = {}
|
||||
for version in versions_to_include:
|
||||
for filename, sha in notes[version]:
|
||||
body = s.get_file_at_commit(filename, sha)
|
||||
# We want to save the contents of the file, which is YAML,
|
||||
# inside another YAML file. That looks terribly ugly with
|
||||
# all of the escapes needed to format it properly as
|
||||
# embedded YAML, so parse the input and convert it to a
|
||||
# data structure that can be serialized cleanly.
|
||||
y = yaml.safe_load(body)
|
||||
file_contents[filename] = y
|
||||
|
||||
# Build a cache data structure including the file contents as well
|
||||
# as the basic data returned by the scanner.
|
||||
file_contents = {}
|
||||
for version in versions_to_include:
|
||||
for filename, sha in notes[version]:
|
||||
body = s.get_file_at_commit(filename, sha)
|
||||
# We want to save the contents of the file, which is YAML,
|
||||
# inside another YAML file. That looks terribly ugly with
|
||||
# all of the escapes needed to format it properly as
|
||||
# embedded YAML, so parse the input and convert it to a
|
||||
# data structure that can be serialized cleanly.
|
||||
y = yaml.safe_load(body)
|
||||
file_contents[filename] = y
|
||||
|
||||
cache = {
|
||||
'notes': [
|
||||
{'version': k, 'files': v}
|
||||
for k, v in notes.items()
|
||||
],
|
||||
'dates': [
|
||||
{'version': k, 'date': v}
|
||||
for k, v in s.get_version_dates().items()
|
||||
],
|
||||
'file-contents': file_contents,
|
||||
}
|
||||
return cache
|
||||
cache = {
|
||||
'notes': [
|
||||
{'version': k, 'files': v}
|
||||
for k, v in notes.items()
|
||||
],
|
||||
'dates': [
|
||||
{'version': k, 'date': v}
|
||||
for k, v in s.get_version_dates().items()
|
||||
],
|
||||
'file-contents': file_contents,
|
||||
}
|
||||
return cache
|
||||
|
||||
|
||||
def write_cache_db(conf, versions_to_include,
|
||||
outfilename=None):
|
||||
def write_cache_db(conf, versions_to_include, outfilename=None):
|
||||
"""Create a cache database file for the release notes data.
|
||||
|
||||
Build the cache database from scanning the project history and
|
||||
|
||||
@ -27,22 +27,24 @@ def lint_cmd(args, conf):
|
||||
notes = glob.glob(os.path.join(notesdir, '*.yaml'))
|
||||
|
||||
error = 0
|
||||
load = loader.Loader(conf, ignore_cache=True)
|
||||
allowed_section_names = [conf.prelude_section_name] + \
|
||||
[s[0] for s in conf.sections]
|
||||
|
||||
uids = {}
|
||||
for f in notes:
|
||||
LOG.debug('examining %s', f)
|
||||
uid = scanner._get_unique_id(f)
|
||||
uids.setdefault(uid, []).append(f)
|
||||
with loader.Loader(conf, ignore_cache=True) as ldr:
|
||||
for f in notes:
|
||||
LOG.debug('examining %s', f)
|
||||
uid = scanner._get_unique_id(f)
|
||||
uids.setdefault(uid, []).append(f)
|
||||
|
||||
content = load.parse_note_file(f, None)
|
||||
for section_name in content.keys():
|
||||
if section_name not in allowed_section_names:
|
||||
LOG.warning('unrecognized section name %s in %s',
|
||||
section_name, f)
|
||||
error = 1
|
||||
content = ldr.parse_note_file(f, None)
|
||||
for section_name in content.keys():
|
||||
if section_name not in allowed_section_names:
|
||||
LOG.warning(
|
||||
'unrecognized section name %s in %s',
|
||||
section_name, f,
|
||||
)
|
||||
error = 1
|
||||
|
||||
for uid, names in sorted(uids.items()):
|
||||
if len(names) > 1:
|
||||
|
||||
@ -21,16 +21,16 @@ def list_cmd(args, conf):
|
||||
"List notes files based on query arguments"
|
||||
LOG.debug('starting list')
|
||||
reporoot = conf.reporoot
|
||||
ldr = loader.Loader(conf)
|
||||
if args.version:
|
||||
versions = args.version
|
||||
else:
|
||||
versions = ldr.versions
|
||||
for version in versions:
|
||||
notefiles = ldr[version]
|
||||
print(version)
|
||||
for n, sha in notefiles:
|
||||
if n.startswith(reporoot):
|
||||
n = n[len(reporoot):]
|
||||
print('\t%s (%s)' % (n, sha))
|
||||
with loader.Loader(conf) as ldr:
|
||||
if args.version:
|
||||
versions = args.version
|
||||
else:
|
||||
versions = ldr.versions
|
||||
for version in versions:
|
||||
notefiles = ldr[version]
|
||||
print(version)
|
||||
for n, sha in notefiles:
|
||||
if n.startswith(reporoot):
|
||||
n = n[len(reporoot):]
|
||||
print('\t%s (%s)' % (n, sha))
|
||||
return
|
||||
|
||||
@ -30,8 +30,7 @@ def get_cache_filename(conf):
|
||||
class Loader(object):
|
||||
"Load the release notes for a given repository."
|
||||
|
||||
def __init__(self, conf,
|
||||
ignore_cache=False):
|
||||
def __init__(self, conf, ignore_cache=False):
|
||||
"""Initialize a Loader.
|
||||
|
||||
The versions are presented in reverse chronological order.
|
||||
@ -70,24 +69,37 @@ class Loader(object):
|
||||
|
||||
if (not self._ignore_cache) and cache_file_exists:
|
||||
LOG.debug('loading cache file %s', self._cache_filename)
|
||||
|
||||
with open(self._cache_filename, 'r', encoding=self._encoding) as f:
|
||||
self._cache = yaml.safe_load(f.read())
|
||||
# Save the cached scanner output to the same attribute
|
||||
# it would be in if we had loaded it "live". This
|
||||
# simplifies some of the logic in the other methods.
|
||||
self._scanner_output = collections.OrderedDict(
|
||||
(n['version'], n['files'])
|
||||
for n in self._cache['notes']
|
||||
)
|
||||
self._tags_to_dates = collections.OrderedDict(
|
||||
(n['version'], n['date'])
|
||||
for n in self._cache['dates']
|
||||
)
|
||||
|
||||
# Save the cached scanner output to the same attribute
|
||||
# it would be in if we had loaded it "live". This
|
||||
# simplifies some of the logic in the other methods.
|
||||
self._scanner_output = collections.OrderedDict(
|
||||
(n['version'], n['files'])
|
||||
for n in self._cache['notes']
|
||||
)
|
||||
self._tags_to_dates = collections.OrderedDict(
|
||||
(n['version'], n['date'])
|
||||
for n in self._cache['dates']
|
||||
)
|
||||
else:
|
||||
self._scanner = scanner.Scanner(self._config)
|
||||
self._scanner_output = self._scanner.get_notes_by_version()
|
||||
self._tags_to_dates = self._scanner.get_version_dates()
|
||||
|
||||
def close(self):
|
||||
"""Close any files opened by this loader."""
|
||||
if self._scanner is not None:
|
||||
self._scanner.close()
|
||||
|
||||
def __enter__(self):
|
||||
return self
|
||||
|
||||
def __exit__(self, exc_type, exc_val, exc_tb):
|
||||
self.close()
|
||||
|
||||
@property
|
||||
def versions(self):
|
||||
"A list of all of the versions found."
|
||||
|
||||
@ -16,20 +16,22 @@ from reno import loader
|
||||
|
||||
def report_cmd(args, conf):
|
||||
"Generates a release notes report"
|
||||
ldr = loader.Loader(conf)
|
||||
encoding = conf.options['encoding']
|
||||
if args.version:
|
||||
versions = args.version
|
||||
else:
|
||||
versions = ldr.versions
|
||||
text = formatter.format_report(
|
||||
ldr,
|
||||
conf,
|
||||
versions,
|
||||
title=args.title,
|
||||
show_source=args.show_source,
|
||||
branch=args.branch,
|
||||
)
|
||||
|
||||
with loader.Loader(conf) as ldr:
|
||||
if args.version:
|
||||
versions = args.version
|
||||
else:
|
||||
versions = ldr.versions
|
||||
text = formatter.format_report(
|
||||
ldr,
|
||||
conf,
|
||||
versions,
|
||||
title=args.title,
|
||||
show_source=args.show_source,
|
||||
branch=args.branch,
|
||||
)
|
||||
|
||||
if args.output:
|
||||
with open(args.output, 'w', encoding=encoding) as f:
|
||||
f.write(text)
|
||||
|
||||
@ -533,6 +533,16 @@ class Scanner(object):
|
||||
)
|
||||
self._encoding = conf.options['encoding']
|
||||
|
||||
def close(self):
|
||||
"""Close any files opened by this scanner."""
|
||||
self._repo.close()
|
||||
|
||||
def __enter__(self):
|
||||
return self
|
||||
|
||||
def __exit__(self, exc_type, exc_val, exc_tb):
|
||||
self.close()
|
||||
|
||||
def _get_ref(self, name):
|
||||
if name:
|
||||
candidates = [
|
||||
|
||||
117
reno/semver.py
117
reno/semver.py
@ -22,76 +22,85 @@ LOG = logging.getLogger(__name__)
|
||||
def compute_next_version(conf):
|
||||
"Compute the next semantic version based on the available release notes."
|
||||
LOG.debug('starting semver-next')
|
||||
ldr = loader.Loader(conf, ignore_cache=True)
|
||||
LOG.debug('known versions: %s', ldr.versions)
|
||||
with loader.Loader(conf, ignore_cache=True) as ldr:
|
||||
LOG.debug('known versions: %s', ldr.versions)
|
||||
|
||||
# We want to include any notes in the local working directory or
|
||||
# in any commits that came after the last tag. We should never end
|
||||
# up with more than 2 entries in to_include.
|
||||
to_include = []
|
||||
for to_consider in ldr.versions:
|
||||
if to_consider == '*working-copy*':
|
||||
to_include.append(to_consider)
|
||||
continue
|
||||
# This check relies on PEP 440 versioning
|
||||
parsed = version.Version(to_consider)
|
||||
if parsed.post:
|
||||
to_include.append(to_consider)
|
||||
continue
|
||||
break
|
||||
# We want to include any notes in the local working directory or
|
||||
# in any commits that came after the last tag. We should never end
|
||||
# up with more than 2 entries in to_include.
|
||||
to_include = []
|
||||
for to_consider in ldr.versions:
|
||||
if to_consider == '*working-copy*':
|
||||
to_include.append(to_consider)
|
||||
continue
|
||||
|
||||
# If we found no commits then we're sitting on a real tag and
|
||||
# there is nothing to do to update the version.
|
||||
if not to_include:
|
||||
LOG.debug('found no staged notes and no post-release commits')
|
||||
return ldr.versions[0]
|
||||
# This check relies on PEP 440 versioning
|
||||
parsed = version.Version(to_consider)
|
||||
if parsed.post:
|
||||
to_include.append(to_consider)
|
||||
continue
|
||||
|
||||
LOG.debug('including notes from %s', to_include)
|
||||
break
|
||||
|
||||
candidate_bases = to_include[:]
|
||||
if candidate_bases[0] == '*working-copy*':
|
||||
candidate_bases = candidate_bases[1:]
|
||||
# If we found no commits then we're sitting on a real tag and
|
||||
# there is nothing to do to update the version.
|
||||
if not to_include:
|
||||
LOG.debug('found no staged notes and no post-release commits')
|
||||
return ldr.versions[0]
|
||||
|
||||
if not candidate_bases:
|
||||
# We have a real tag and some locally modified files. Use the
|
||||
# real tag as the basis of the next version.
|
||||
base_version = version.Version(ldr.versions[1])
|
||||
else:
|
||||
base_version = version.Version(candidate_bases[0])
|
||||
LOG.debug('including notes from %s', to_include)
|
||||
|
||||
LOG.debug('base version %s', base_version)
|
||||
candidate_bases = to_include[:]
|
||||
if candidate_bases[0] == '*working-copy*':
|
||||
candidate_bases = candidate_bases[1:]
|
||||
|
||||
inc_minor = False
|
||||
inc_patch = False
|
||||
for ver in to_include:
|
||||
for filename, sha in ldr[ver]:
|
||||
notes = ldr.parse_note_file(filename, sha)
|
||||
for section in conf.semver_major:
|
||||
if notes.get(section, []):
|
||||
LOG.debug('found breaking change in %r section of %s',
|
||||
section, filename)
|
||||
return '{}.0.0'.format(base_version.major + 1)
|
||||
for section in conf.semver_minor:
|
||||
if notes.get(section, []):
|
||||
LOG.debug('found feature in %r section of %s',
|
||||
section, filename)
|
||||
inc_minor = True
|
||||
break
|
||||
for section in conf.semver_patch:
|
||||
if notes.get(section, []):
|
||||
LOG.debug('found bugfix in %r section of %s',
|
||||
section, filename)
|
||||
inc_patch = True
|
||||
break
|
||||
if not candidate_bases:
|
||||
# We have a real tag and some locally modified files. Use the
|
||||
# real tag as the basis of the next version.
|
||||
base_version = version.Version(ldr.versions[1])
|
||||
else:
|
||||
base_version = version.Version(candidate_bases[0])
|
||||
|
||||
LOG.debug('base version %s', base_version)
|
||||
|
||||
inc_minor = False
|
||||
inc_patch = False
|
||||
|
||||
for ver in to_include:
|
||||
for filename, sha in ldr[ver]:
|
||||
notes = ldr.parse_note_file(filename, sha)
|
||||
|
||||
for section in conf.semver_major:
|
||||
if notes.get(section, []):
|
||||
LOG.debug('found breaking change in %r section of %s',
|
||||
section, filename)
|
||||
return '{}.0.0'.format(base_version.major + 1)
|
||||
|
||||
for section in conf.semver_minor:
|
||||
if notes.get(section, []):
|
||||
LOG.debug('found feature in %r section of %s',
|
||||
section, filename)
|
||||
inc_minor = True
|
||||
break
|
||||
|
||||
for section in conf.semver_patch:
|
||||
if notes.get(section, []):
|
||||
LOG.debug('found bugfix in %r section of %s',
|
||||
section, filename)
|
||||
inc_patch = True
|
||||
break
|
||||
|
||||
major = base_version.major
|
||||
minor = base_version.minor
|
||||
patch = base_version.micro
|
||||
|
||||
if inc_patch:
|
||||
patch += 1
|
||||
|
||||
if inc_minor:
|
||||
minor += 1
|
||||
patch = 0
|
||||
|
||||
return '{}.{}.{}'.format(major, minor, patch)
|
||||
|
||||
|
||||
|
||||
@ -127,13 +127,15 @@ class BuildReno(cmd.Command):
|
||||
)
|
||||
log.info('wrote cache file to %s', cache_filename)
|
||||
|
||||
ldr = loader.Loader(conf)
|
||||
text = formatter.format_report(
|
||||
ldr,
|
||||
conf,
|
||||
ldr.versions,
|
||||
title=self.distribution.metadata.name,
|
||||
)
|
||||
with loader.Loader(conf) as ldr:
|
||||
text = formatter.format_report(
|
||||
ldr,
|
||||
conf,
|
||||
ldr.versions,
|
||||
title=self.distribution.metadata.name,
|
||||
)
|
||||
|
||||
with open(self.output_file, 'w') as f:
|
||||
f.write(text)
|
||||
|
||||
log.info('wrote release notes to %s', self.output_file)
|
||||
|
||||
@ -111,22 +111,23 @@ class ReleaseNotesDirective(rst.Directive):
|
||||
os.path.join(conf.reporoot, notesdir),
|
||||
branch or 'current branch'))
|
||||
|
||||
ldr = loader.Loader(conf)
|
||||
if version_opt is not None:
|
||||
versions = [
|
||||
v.strip()
|
||||
for v in version_opt.split(',')
|
||||
]
|
||||
else:
|
||||
versions = ldr.versions
|
||||
LOG.info('got versions %s' % (versions,))
|
||||
text = formatter.format_report(
|
||||
ldr,
|
||||
conf,
|
||||
versions,
|
||||
title=title,
|
||||
branch=branch,
|
||||
)
|
||||
with loader.Loader(conf) as ldr:
|
||||
if version_opt is not None:
|
||||
versions = [
|
||||
v.strip()
|
||||
for v in version_opt.split(',')
|
||||
]
|
||||
else:
|
||||
versions = ldr.versions
|
||||
LOG.info('got versions %s' % (versions,))
|
||||
text = formatter.format_report(
|
||||
ldr,
|
||||
conf,
|
||||
versions,
|
||||
title=title,
|
||||
branch=branch,
|
||||
)
|
||||
|
||||
source_name = '<%s %s>' % (__name__, branch or 'current branch')
|
||||
result = statemachine.ViewList()
|
||||
for line_num, line in enumerate(text.splitlines(), 1):
|
||||
|
||||
@ -49,6 +49,13 @@ class TestFormatterBase(base.TestCase):
|
||||
ignore_cache=False,
|
||||
)
|
||||
|
||||
def tearDown(self):
|
||||
# we don't need to worry about closing this after since we're not
|
||||
# actually using a real Git repo here (see the mock above), but we'll
|
||||
# do so to enforce the contract
|
||||
self.ldr.close()
|
||||
super().tearDown()
|
||||
|
||||
|
||||
class TestFormatter(TestFormatterBase):
|
||||
|
||||
|
||||
@ -65,8 +65,8 @@ class TestValidate(base.TestCase):
|
||||
This is a single string. It should be converted to a list.
|
||||
"""))
|
||||
self.assertIsInstance(note_bodies['issues'], str)
|
||||
ldr = self._make_loader(note_bodies)
|
||||
parse_results = ldr.parse_note_file('note1', None)
|
||||
with self._make_loader(note_bodies) as ldr:
|
||||
parse_results = ldr.parse_note_file('note1', None)
|
||||
self.assertIsInstance(parse_results['issues'], list)
|
||||
|
||||
def test_invalid_note_with_prelude_as_list(self):
|
||||
@ -75,8 +75,8 @@ class TestValidate(base.TestCase):
|
||||
- The prelude should not be a list.
|
||||
'''))
|
||||
self.assertIsInstance(note_bodies['prelude'], list)
|
||||
ldr = self._make_loader(note_bodies)
|
||||
ldr.parse_note_file('note1', None)
|
||||
with self._make_loader(note_bodies) as ldr:
|
||||
ldr.parse_note_file('note1', None)
|
||||
self.assertIn('does not parse as a single string', self.logger.output)
|
||||
|
||||
def test_invalid_note_with_colon_as_dict(self):
|
||||
@ -86,8 +86,8 @@ class TestValidate(base.TestCase):
|
||||
- dict: But this is parsed as a mapping (dictionary), which is bad.
|
||||
'''))
|
||||
self.assertIsInstance(note_bodies['issues'][-1], dict)
|
||||
ldr = self._make_loader(note_bodies)
|
||||
ldr.parse_note_file('note1', None)
|
||||
with self._make_loader(note_bodies) as ldr:
|
||||
ldr.parse_note_file('note1', None)
|
||||
self.assertIn('instead of a string', self.logger.output)
|
||||
|
||||
def test_invalid_note_with_unrecognized_key(self):
|
||||
@ -98,8 +98,8 @@ class TestValidate(base.TestCase):
|
||||
This is an issue but we're using an unrecognized section key.
|
||||
'''))
|
||||
self.assertIsInstance(note_bodies, dict)
|
||||
ldr = self._make_loader(note_bodies)
|
||||
ldr.parse_note_file('note1', None)
|
||||
with self._make_loader(note_bodies) as ldr:
|
||||
ldr.parse_note_file('note1', None)
|
||||
self.assertIn(
|
||||
'The foobar section of note1 is not a recognized section.',
|
||||
self.logger.output)
|
||||
@ -114,8 +114,8 @@ class TestValidate(base.TestCase):
|
||||
This is an issue but we're missing the top-level 'issues' key.
|
||||
'''))
|
||||
self.assertIsInstance(note_bodies, list)
|
||||
ldr = self._make_loader(note_bodies)
|
||||
self.assertRaises(ValueError, ldr.parse_note_file, 'note1', None)
|
||||
with self._make_loader(note_bodies) as ldr:
|
||||
self.assertRaises(ValueError, ldr.parse_note_file, 'note1', None)
|
||||
self.assertIn(
|
||||
'does not appear to be structured as a YAML mapping',
|
||||
self.logger.output)
|
||||
|
||||
@ -217,8 +217,8 @@ class BasicTest(Base):
|
||||
|
||||
def test_non_python_no_tags(self):
|
||||
filename = self._add_notes_file()
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
results = {
|
||||
k: [f for (f, n) in v]
|
||||
for (k, v) in raw_results.items()
|
||||
@ -231,8 +231,8 @@ class BasicTest(Base):
|
||||
def test_python_no_tags(self):
|
||||
self._make_python_package()
|
||||
filename = self._add_notes_file()
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
results = {
|
||||
k: [f for (f, n) in v]
|
||||
for (k, v) in raw_results.items()
|
||||
@ -246,8 +246,8 @@ class BasicTest(Base):
|
||||
filename = self._add_notes_file()
|
||||
self.repo.add_file('not-a-release-note.txt')
|
||||
self.repo.git('tag', '-s', '-m', 'first tag', '1.0.0')
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
results = {
|
||||
k: [f for (f, n) in v]
|
||||
for (k, v) in raw_results.items()
|
||||
@ -260,8 +260,8 @@ class BasicTest(Base):
|
||||
def test_note_commit_tagged(self):
|
||||
filename = self._add_notes_file()
|
||||
self.repo.git('tag', '-s', '-m', 'first tag', '1.0.0')
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
results = {
|
||||
k: [f for (f, n) in v]
|
||||
for (k, v) in raw_results.items()
|
||||
@ -274,8 +274,8 @@ class BasicTest(Base):
|
||||
def test_tag_with_v_prefix(self):
|
||||
filename = self._add_notes_file()
|
||||
self.repo.git('tag', '-s', '-m', 'tag with v prefix', 'v1.0.0')
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
results = {
|
||||
k: [f for (f, n) in v]
|
||||
for (k, v) in raw_results.items()
|
||||
@ -289,8 +289,8 @@ class BasicTest(Base):
|
||||
self._make_python_package()
|
||||
self.repo.git('tag', '-s', '-m', 'first tag', '1.0.0')
|
||||
filename = self._add_notes_file()
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
results = {
|
||||
k: [f for (f, n) in v]
|
||||
for (k, v) in raw_results.items()
|
||||
@ -305,8 +305,8 @@ class BasicTest(Base):
|
||||
self.repo.git('tag', '-s', '-m', 'first tag', '1.0.0rc1')
|
||||
self.repo.git('tag', '-s', '-m', 'first tag', '1.0.0')
|
||||
filename = self._add_notes_file()
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
results = {
|
||||
k: [f for (f, n) in v]
|
||||
for (k, v) in raw_results.items()
|
||||
@ -321,8 +321,8 @@ class BasicTest(Base):
|
||||
self.repo.add_file('ignore-1.txt')
|
||||
self.repo.git('tag', '-s', '-m', 'first tag', '1.0.0')
|
||||
self.repo.add_file('ignore-2.txt')
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
results = {
|
||||
k: [f for (f, n) in v]
|
||||
for (k, v) in raw_results.items()
|
||||
@ -337,8 +337,8 @@ class BasicTest(Base):
|
||||
self.repo.git('tag', '-s', '-m', 'first tag', '1.0.0')
|
||||
f1 = self._add_notes_file()
|
||||
f2 = self._add_notes_file()
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
results = {
|
||||
k: [f for (f, n) in v]
|
||||
for (k, v) in raw_results.items()
|
||||
@ -353,8 +353,8 @@ class BasicTest(Base):
|
||||
f1 = self._add_notes_file(commit=False)
|
||||
f2 = self._add_notes_file()
|
||||
self.repo.git('tag', '-s', '-m', 'first tag', '1.0.0')
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
results = {
|
||||
k: [f for (f, n) in v]
|
||||
for (k, v) in raw_results.items()
|
||||
@ -370,8 +370,8 @@ class BasicTest(Base):
|
||||
f1 = self._add_notes_file()
|
||||
self.repo.git('tag', '-s', '-m', 'first tag', '2.0.0')
|
||||
f2 = self._add_notes_file()
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
results = {
|
||||
k: [f for (f, n) in v]
|
||||
for (k, v) in raw_results.items()
|
||||
@ -391,8 +391,8 @@ class BasicTest(Base):
|
||||
f2 = f1.replace('slug1', 'slug2')
|
||||
self.repo.git('mv', f1, f2)
|
||||
self.repo.commit('rename note file')
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
results = {
|
||||
k: [f for (f, n) in v]
|
||||
for (k, v) in raw_results.items()
|
||||
@ -411,8 +411,8 @@ class BasicTest(Base):
|
||||
f2 = f1.replace('slug1', 'slug0')
|
||||
self.repo.git('mv', f1, f2)
|
||||
self.repo.commit('rename note file')
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
results = {
|
||||
k: [f for (f, n) in v]
|
||||
for (k, v) in raw_results.items()
|
||||
@ -431,8 +431,8 @@ class BasicTest(Base):
|
||||
with open(os.path.join(self.reporoot, f1), 'w') as f:
|
||||
f.write('---\npreamble: new contents for file')
|
||||
self.repo.commit('edit note file')
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
results = {
|
||||
k: [f for (f, n) in v]
|
||||
for (k, v) in raw_results.items()
|
||||
@ -451,8 +451,8 @@ class BasicTest(Base):
|
||||
f2 = f1.replace('slug1', 'slug2')
|
||||
self.repo.git('mv', f1, f2)
|
||||
self.repo.commit('rename note file')
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
results = {
|
||||
k: [f for (f, n) in v]
|
||||
for (k, v) in raw_results.items()
|
||||
@ -474,8 +474,8 @@ class BasicTest(Base):
|
||||
'slug1-0000000000000001')
|
||||
self.repo.git('mv', f1, f2)
|
||||
self.repo.commit('rename note file')
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
results = {
|
||||
k: [f for (f, n) in v]
|
||||
for (k, v) in raw_results.items()
|
||||
@ -497,8 +497,8 @@ class BasicTest(Base):
|
||||
self.c.override(
|
||||
earliest_version='2.0.0',
|
||||
)
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
results = {
|
||||
k: [f for (f, n) in v]
|
||||
for (k, v) in raw_results.items()
|
||||
@ -518,8 +518,8 @@ class BasicTest(Base):
|
||||
self.repo.git('rm', f1)
|
||||
self.repo.commit('remove note file')
|
||||
self.repo.git('tag', '-s', '-m', 'first tag', '2.0.0')
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
results = {
|
||||
k: [f for (f, n) in v]
|
||||
for (k, v) in raw_results.items()
|
||||
@ -546,8 +546,8 @@ class BasicTest(Base):
|
||||
'--pretty=%H %d',
|
||||
'--name-only')
|
||||
self.addDetail('git log', text_content(log_results))
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
results = {
|
||||
k: [f for (f, n) in v]
|
||||
for (k, v) in raw_results.items()
|
||||
@ -573,8 +573,8 @@ class BasicTest(Base):
|
||||
status_results = self.repo.git('status')
|
||||
self.addDetail('git status', text_content(status_results))
|
||||
# Now run the scanner
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
self.assertEqual(
|
||||
{'*working-copy*': [
|
||||
(os.path.join('releasenotes', 'notes', basename),
|
||||
@ -598,8 +598,8 @@ class BasicTest(Base):
|
||||
status_results = self.repo.git('status')
|
||||
self.addDetail('git status', text_content(status_results))
|
||||
# Now run the scanner
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
# Take the staged version of the file, but associate it with
|
||||
# tagged version 1.0.0 because the file was added before that
|
||||
# version.
|
||||
@ -623,8 +623,8 @@ class BasicTest(Base):
|
||||
status_results = self.repo.git('status')
|
||||
self.addDetail('git status', text_content(status_results))
|
||||
# Now run the scanner
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
# Take the staged version of the file, but associate it with
|
||||
# tagged version 1.0.0 because the file was added before that
|
||||
# version.
|
||||
@ -647,8 +647,8 @@ class BasicTest(Base):
|
||||
self.c.override(
|
||||
earliest_version=None,
|
||||
)
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
results = {
|
||||
k: [f for (f, n) in v]
|
||||
for (k, v) in raw_results.items()
|
||||
@ -672,8 +672,8 @@ class BasicTest(Base):
|
||||
self.c.override(
|
||||
earliest_version=None,
|
||||
)
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
results = {
|
||||
k: [f for (f, n) in v]
|
||||
for (k, v) in raw_results.items()
|
||||
@ -698,8 +698,8 @@ class IgnoreTest(Base):
|
||||
self.c.override(
|
||||
ignore_notes=[f1],
|
||||
)
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
results = {
|
||||
k: [f for (f, n) in v]
|
||||
for (k, v) in raw_results.items()
|
||||
@ -717,8 +717,8 @@ class IgnoreTest(Base):
|
||||
self.c.override(
|
||||
ignore_notes=[os.path.basename(f1)],
|
||||
)
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
results = {
|
||||
k: [f for (f, n) in v]
|
||||
for (k, v) in raw_results.items()
|
||||
@ -736,8 +736,8 @@ class IgnoreTest(Base):
|
||||
self.c.override(
|
||||
ignore_notes=[scanner._get_unique_id(f1)],
|
||||
)
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
results = {
|
||||
k: [f for (f, n) in v]
|
||||
for (k, v) in raw_results.items()
|
||||
@ -758,8 +758,8 @@ class IgnoreTest(Base):
|
||||
scanner._get_unique_id(f2),
|
||||
],
|
||||
)
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
results = {
|
||||
k: [f for (f, n) in v]
|
||||
for (k, v) in raw_results.items()
|
||||
@ -775,8 +775,8 @@ class FileContentsTest(Base):
|
||||
def test_basic_file(self):
|
||||
# Prove that we can get a file we have committed.
|
||||
f1 = self._add_notes_file(contents='well-known-contents')
|
||||
r = scanner.RenoRepo(self.reporoot)
|
||||
contents = r.get_file_at_commit(f1, 'HEAD')
|
||||
with scanner.RenoRepo(self.reporoot) as r:
|
||||
contents = r.get_file_at_commit(f1, 'HEAD')
|
||||
self.assertEqual(
|
||||
b'well-known-contents',
|
||||
contents,
|
||||
@ -786,8 +786,8 @@ class FileContentsTest(Base):
|
||||
# Returns None when the file does not exist at all.
|
||||
# (we have to commit something, otherwise there is no HEAD)
|
||||
self._add_notes_file(contents='well-known-contents')
|
||||
r = scanner.RenoRepo(self.reporoot)
|
||||
contents = r.get_file_at_commit('no-such-dir/no-such-file', 'HEAD')
|
||||
with scanner.RenoRepo(self.reporoot) as r:
|
||||
contents = r.get_file_at_commit('no-such-dir/no-such-file', 'HEAD')
|
||||
self.assertEqual(
|
||||
None,
|
||||
contents,
|
||||
@ -799,8 +799,8 @@ class FileContentsTest(Base):
|
||||
with open(os.path.join(self.reporoot, f1), 'w') as f:
|
||||
f.write('new contents for file')
|
||||
self.repo.commit('edit note file')
|
||||
r = scanner.RenoRepo(self.reporoot)
|
||||
contents = r.get_file_at_commit(f1, 'HEAD')
|
||||
with scanner.RenoRepo(self.reporoot) as r:
|
||||
contents = r.get_file_at_commit(f1, 'HEAD')
|
||||
self.assertEqual(
|
||||
b'new contents for file',
|
||||
contents,
|
||||
@ -813,12 +813,11 @@ class FileContentsTest(Base):
|
||||
with open(os.path.join(self.reporoot, f1), 'w') as f:
|
||||
f.write('new contents for file')
|
||||
self.repo.commit('edit note file')
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
r = scanner.RenoRepo(self.reporoot)
|
||||
head = r.head()
|
||||
parent = r.get_parents(head)[0]
|
||||
parent = parent.decode('ascii')
|
||||
contents = r.get_file_at_commit(f1, parent)
|
||||
with scanner.RenoRepo(self.reporoot) as r:
|
||||
head = r.head()
|
||||
parent = r.get_parents(head)[0]
|
||||
parent = parent.decode('ascii')
|
||||
contents = r.get_file_at_commit(f1, parent)
|
||||
self.assertEqual(
|
||||
b'initial-contents',
|
||||
contents,
|
||||
@ -830,8 +829,8 @@ class FileContentsTest(Base):
|
||||
f1 = self._add_notes_file(contents='initial-contents')
|
||||
with open(os.path.join(self.reporoot, f1), 'w') as f:
|
||||
f.write('new contents for file')
|
||||
r = scanner.RenoRepo(self.reporoot)
|
||||
contents = r.get_file_at_commit(f1, 'HEAD')
|
||||
with scanner.RenoRepo(self.reporoot) as r:
|
||||
contents = r.get_file_at_commit(f1, 'HEAD')
|
||||
self.assertEqual(
|
||||
b'initial-contents',
|
||||
contents,
|
||||
@ -843,8 +842,8 @@ class FileContentsTest(Base):
|
||||
f1 = self._add_notes_file(contents='initial-contents')
|
||||
with open(os.path.join(self.reporoot, f1), 'w') as f:
|
||||
f.write('new contents for file')
|
||||
r = scanner.RenoRepo(self.reporoot)
|
||||
contents = r.get_file_at_commit(f1, None)
|
||||
with scanner.RenoRepo(self.reporoot) as r:
|
||||
contents = r.get_file_at_commit(f1, None)
|
||||
self.assertEqual(
|
||||
'new contents for file',
|
||||
contents,
|
||||
@ -858,8 +857,8 @@ class PreReleaseTest(Base):
|
||||
self.repo.git('tag', '-s', '-m', 'first tag', '1.0.0.0a1')
|
||||
f1 = self._add_notes_file('slug1')
|
||||
self.repo.git('tag', '-s', '-m', 'first tag', '1.0.0.0a2')
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
results = {
|
||||
k: [f for (f, n) in v]
|
||||
for (k, v) in raw_results.items()
|
||||
@ -875,8 +874,8 @@ class PreReleaseTest(Base):
|
||||
self.repo.git('tag', '-s', '-m', 'first tag', '1.0.0.0b1')
|
||||
f1 = self._add_notes_file('slug1')
|
||||
self.repo.git('tag', '-s', '-m', 'first tag', '1.0.0.0b2')
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
results = {
|
||||
k: [f for (f, n) in v]
|
||||
for (k, v) in raw_results.items()
|
||||
@ -892,8 +891,8 @@ class PreReleaseTest(Base):
|
||||
self.repo.git('tag', '-s', '-m', 'first tag', '1.0.0.0rc1')
|
||||
f1 = self._add_notes_file('slug1')
|
||||
self.repo.git('tag', '-s', '-m', 'first tag', '1.0.0.0rc2')
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
results = {
|
||||
k: [f for (f, n) in v]
|
||||
for (k, v) in raw_results.items()
|
||||
@ -909,8 +908,8 @@ class PreReleaseTest(Base):
|
||||
self.repo.git('tag', '-s', '-m', 'first tag', 'v1.0.0.0a1')
|
||||
f1 = self._add_notes_file('slug1')
|
||||
self.repo.git('tag', '-s', '-m', 'first tag', 'v1.0.0.0a2')
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
results = {
|
||||
k: [f for (f, n) in v]
|
||||
for (k, v) in raw_results.items()
|
||||
@ -935,8 +934,8 @@ class PreReleaseTest(Base):
|
||||
self.c.override(
|
||||
collapse_pre_releases=True,
|
||||
)
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
results = {
|
||||
k: [f for (f, n) in v]
|
||||
for (k, v) in raw_results.items()
|
||||
@ -958,8 +957,8 @@ class PreReleaseTest(Base):
|
||||
self.c.override(
|
||||
collapse_pre_releases=True,
|
||||
)
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
results = {
|
||||
k: [f for (f, n) in v]
|
||||
for (k, v) in raw_results.items()
|
||||
@ -984,8 +983,8 @@ class PreReleaseTest(Base):
|
||||
self.c.override(
|
||||
collapse_pre_releases=True,
|
||||
)
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
results = {
|
||||
k: [f for (f, n) in v]
|
||||
for (k, v) in raw_results.items()
|
||||
@ -1015,8 +1014,8 @@ class MergeCommitTest(Base):
|
||||
time.sleep(0.1) # force a delay between commits
|
||||
self.repo.add_file('ignore-2.txt')
|
||||
self.repo.git('tag', '-s', '-m', 'second tag', '2.0.0')
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
results = {
|
||||
k: [f for (f, n) in v]
|
||||
for (k, v) in raw_results.items()
|
||||
@ -1047,8 +1046,8 @@ class MergeCommitTest(Base):
|
||||
self.repo.git('show')
|
||||
self.repo.add_file('ignore-2.txt')
|
||||
self.repo.git('tag', '-s', '-m', 'second tag', '2.0.0')
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
results = {
|
||||
k: [f for (f, n) in v]
|
||||
for (k, v) in raw_results.items()
|
||||
@ -1081,8 +1080,8 @@ class MergeCommitTest(Base):
|
||||
self.repo.add_file('ignore-2.txt')
|
||||
self.repo.git('tag', '-s', '-m', 'third tag', '2.0.0')
|
||||
self.repo.add_file('ignore-3.txt')
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
results = {
|
||||
k: [f for (f, n) in v]
|
||||
for (k, v) in raw_results.items()
|
||||
@ -1119,8 +1118,8 @@ class MergeCommitTest(Base):
|
||||
self.repo.add_file('ignore-2.txt')
|
||||
self.repo.git('tag', '-s', '-m', 'third tag', '2.0.0')
|
||||
self.repo.add_file('ignore-3.txt')
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
results = {
|
||||
k: [f for (f, n) in v]
|
||||
for (k, v) in raw_results.items()
|
||||
@ -1181,8 +1180,8 @@ class NullMergeTest(Base):
|
||||
# The scanner should skip over the null-merge and include the
|
||||
# notes that come before the version being merged in, up to
|
||||
# the base of the previous branch.
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
results = {
|
||||
k: [f for (f, n) in v]
|
||||
for (k, v) in raw_results.items()
|
||||
@ -1200,8 +1199,8 @@ class NullMergeTest(Base):
|
||||
self.c.override(
|
||||
ignore_null_merges=False,
|
||||
)
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
results = {
|
||||
k: [f for (f, n) in v]
|
||||
for (k, v) in raw_results.items()
|
||||
@ -1245,6 +1244,10 @@ class BranchBaseTest(Base):
|
||||
self.repo.git('checkout', 'master')
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
|
||||
def tearDown(self):
|
||||
self.scanner.close()
|
||||
super().tearDown()
|
||||
|
||||
def test_current_branch_no_extra_commits(self):
|
||||
# checkout the branch and then ask for its base
|
||||
self.repo.git('checkout', 'not-master')
|
||||
@ -1317,8 +1320,8 @@ class BranchTest(Base):
|
||||
f21 = self._add_notes_file('slug21')
|
||||
log_text = self.repo.git('log', '--decorate')
|
||||
self.addDetail('git log', text_content(log_text))
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
results = {
|
||||
k: [f for (f, n) in v]
|
||||
for (k, v) in raw_results.items()
|
||||
@ -1342,8 +1345,8 @@ class BranchTest(Base):
|
||||
self.c.override(
|
||||
branch='stable/2',
|
||||
)
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
results = {
|
||||
k: [f for (f, n) in v]
|
||||
for (k, v) in raw_results.items()
|
||||
@ -1370,8 +1373,8 @@ class BranchTest(Base):
|
||||
self.c.override(
|
||||
stop_at_branch_base=False,
|
||||
)
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
results = {
|
||||
k: [f for (f, n) in v]
|
||||
for (k, v) in raw_results.items()
|
||||
@ -1407,8 +1410,8 @@ class BranchTest(Base):
|
||||
branch='stable/4',
|
||||
collapse_pre_releases=False,
|
||||
)
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
results = {
|
||||
k: [f for (f, n) in v]
|
||||
for (k, v) in raw_results.items()
|
||||
@ -1444,8 +1447,8 @@ class BranchTest(Base):
|
||||
branch='stable/4',
|
||||
collapse_pre_releases=True,
|
||||
)
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
results = {
|
||||
k: [f for (f, n) in v]
|
||||
for (k, v) in raw_results.items()
|
||||
@ -1482,8 +1485,8 @@ class BranchTest(Base):
|
||||
branch='stable/4',
|
||||
collapse_pre_releases=True,
|
||||
)
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
results = {
|
||||
k: [f for (f, n) in v]
|
||||
for (k, v) in raw_results.items()
|
||||
@ -1516,8 +1519,8 @@ class BranchTest(Base):
|
||||
self.c.override(
|
||||
branch='stable/4',
|
||||
)
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
results = {
|
||||
k: [f for (f, n) in v]
|
||||
for (k, v) in raw_results.items()
|
||||
@ -1550,8 +1553,8 @@ class BranchTest(Base):
|
||||
self.c.override(
|
||||
branch='stable/4',
|
||||
)
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
results = {
|
||||
k: [f for (f, n) in v]
|
||||
for (k, v) in raw_results.items()
|
||||
@ -1582,8 +1585,8 @@ class BranchTest(Base):
|
||||
self.c.override(
|
||||
branch='stable/4',
|
||||
)
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
results = {
|
||||
k: [f for (f, n) in v]
|
||||
for (k, v) in raw_results.items()
|
||||
@ -1599,8 +1602,8 @@ class BranchTest(Base):
|
||||
self.repo.git('checkout', '2.0.0')
|
||||
self.repo.git('checkout', '-b', 'stable/2')
|
||||
self.repo.git('checkout', 'master')
|
||||
scanner1 = scanner.Scanner(self.c)
|
||||
head1 = scanner1._get_ref('stable/2')
|
||||
with scanner.Scanner(self.c) as scanner1:
|
||||
head1 = scanner1._get_ref('stable/2')
|
||||
self.assertIsNotNone(head1)
|
||||
print('head1', head1)
|
||||
# Create a second repository by cloning the first.
|
||||
@ -1626,8 +1629,8 @@ class BranchTest(Base):
|
||||
cwd=reporoot2,
|
||||
))
|
||||
c2 = config.Config(reporoot2)
|
||||
scanner2 = scanner.Scanner(c2)
|
||||
head2 = scanner2._get_ref('origin/stable/2')
|
||||
with scanner.Scanner(c2) as scanner2:
|
||||
head2 = scanner2._get_ref('origin/stable/2')
|
||||
self.assertIsNotNone(head2)
|
||||
self.assertEqual(head1, head2)
|
||||
|
||||
@ -1635,8 +1638,8 @@ class BranchTest(Base):
|
||||
self.repo.git('checkout', '2.0.0')
|
||||
self.repo.git('checkout', '-b', 'stable/2')
|
||||
self.repo.git('checkout', 'master')
|
||||
scanner1 = scanner.Scanner(self.c)
|
||||
head1 = scanner1._get_ref('stable/2')
|
||||
with scanner.Scanner(self.c) as scanner1:
|
||||
head1 = scanner1._get_ref('stable/2')
|
||||
self.assertIsNotNone(head1)
|
||||
print('head1', head1)
|
||||
# Create a second repository by cloning the first.
|
||||
@ -1662,8 +1665,8 @@ class BranchTest(Base):
|
||||
cwd=reporoot2,
|
||||
))
|
||||
c2 = config.Config(reporoot2)
|
||||
scanner2 = scanner.Scanner(c2)
|
||||
head2 = scanner2._get_ref('stable/2')
|
||||
with scanner.Scanner(c2) as scanner2:
|
||||
head2 = scanner2._get_ref('stable/2')
|
||||
self.assertIsNotNone(head2)
|
||||
self.assertEqual(head1, head2)
|
||||
|
||||
@ -1680,8 +1683,8 @@ class BranchTest(Base):
|
||||
self.c.override(
|
||||
earliest_version=None,
|
||||
)
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
raw_results = self.scanner.get_notes_by_version()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
raw_results = s.get_notes_by_version()
|
||||
results = {
|
||||
k: [f for (f, n) in v]
|
||||
for (k, v) in raw_results.items()
|
||||
@ -1720,6 +1723,10 @@ class ScanStopPointPrereleaseVersionsTest(Base):
|
||||
self.repo.git('tag', '-s', '-m', 'third tag', '2.0.0')
|
||||
self.repo.git('checkout', 'master')
|
||||
|
||||
def tearDown(self):
|
||||
self.scanner.close()
|
||||
super().tearDown()
|
||||
|
||||
def test_beta_collapse(self):
|
||||
self.assertEqual(
|
||||
'1.0.0.0rc1',
|
||||
@ -1808,6 +1815,10 @@ class ScanStopPointRegularVersionsTest(Base):
|
||||
self.repo.git('tag', '-s', '-m', 'third tag', '2.0.2')
|
||||
self.repo.git('checkout', 'master')
|
||||
|
||||
def tearDown(self):
|
||||
self.scanner.close()
|
||||
super().tearDown()
|
||||
|
||||
def test_invalid_earliest_version(self):
|
||||
self.assertIsNone(
|
||||
self.scanner._find_scan_stop_point(
|
||||
@ -1850,45 +1861,43 @@ class GetRefTest(Base):
|
||||
self.repo.git('tag', '-s', '-m', 'first tag', '1.0.0')
|
||||
self.repo.git('branch', 'stable/foo')
|
||||
self.repo.git('tag', 'bar-eol')
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
|
||||
def tearDown(self):
|
||||
self.scanner.close()
|
||||
super().tearDown()
|
||||
|
||||
def test_signed_tag(self):
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
ref = self.scanner._get_ref('1.0.0')
|
||||
expected = self.scanner._repo.head()
|
||||
self.assertEqual(expected, ref)
|
||||
|
||||
def test_unsigned_tag(self):
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
ref = self.scanner._get_ref('bar-eol')
|
||||
expected = self.scanner._repo.head()
|
||||
self.assertEqual(expected, ref)
|
||||
|
||||
def test_eol_tag_from_branch(self):
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
ref = self.scanner._get_ref('stable/bar')
|
||||
expected = self.scanner._repo.head()
|
||||
self.assertEqual(expected, ref)
|
||||
|
||||
def test_head(self):
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
ref = self.scanner._get_ref(None)
|
||||
expected = self.scanner._repo.head()
|
||||
self.assertEqual(expected, ref)
|
||||
|
||||
def test_stable_branch(self):
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
ref = self.scanner._get_ref('stable/foo')
|
||||
expected = self.scanner._repo.head()
|
||||
self.assertEqual(expected, ref)
|
||||
|
||||
def test_stable_branch_with_origin_prefix(self):
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
ref = self.scanner._get_ref('origin/stable/foo')
|
||||
expected = self.scanner._repo.head()
|
||||
self.assertEqual(expected, ref)
|
||||
|
||||
def test_no_such_value(self):
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
self.assertRaises(
|
||||
ValueError,
|
||||
self.scanner._get_ref,
|
||||
@ -1909,17 +1918,17 @@ class TagsTest(Base):
|
||||
self.repo.git('tag', '-s', '-m', 'first tag', '3.0.0')
|
||||
|
||||
def test_master(self):
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
results = self.scanner._get_tags_on_branch(None)
|
||||
with scanner.Scanner(self.c) as s:
|
||||
results = s._get_tags_on_branch(None)
|
||||
self.assertEqual(
|
||||
['3.0.0', '2.0.0', '1.0.0'],
|
||||
results,
|
||||
)
|
||||
|
||||
def test_get_ref(self):
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
ref = self.scanner._get_ref('3.0.0')
|
||||
expected = self.scanner._repo.head()
|
||||
with scanner.Scanner(self.c) as s:
|
||||
ref = s._get_ref('3.0.0')
|
||||
expected = s._repo.head()
|
||||
self.assertEqual(expected, ref)
|
||||
|
||||
def test_not_master(self):
|
||||
@ -1928,8 +1937,8 @@ class TagsTest(Base):
|
||||
self._add_notes_file('slug4')
|
||||
self.repo.git('tag', '-s', '-m', 'not on master', '2.0.1')
|
||||
self.repo.git('checkout', 'master')
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
results = self.scanner._get_tags_on_branch('not-master')
|
||||
with scanner.Scanner(self.c) as s:
|
||||
results = s._get_tags_on_branch('not-master')
|
||||
self.assertEqual(
|
||||
['2.0.1', '2.0.0', '1.0.0'],
|
||||
results,
|
||||
@ -1938,8 +1947,8 @@ class TagsTest(Base):
|
||||
def test_unsigned(self):
|
||||
self._add_notes_file('slug4')
|
||||
self.repo.git('tag', '-m', 'first tag', '4.0.0')
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
results = self.scanner._get_tags_on_branch(None)
|
||||
with scanner.Scanner(self.c) as s:
|
||||
results = s._get_tags_on_branch(None)
|
||||
self.assertEqual(
|
||||
['4.0.0', '3.0.0', '2.0.0', '1.0.0'],
|
||||
results,
|
||||
@ -1948,8 +1957,8 @@ class TagsTest(Base):
|
||||
def test_tagged_tag_annotated(self):
|
||||
time.sleep(1)
|
||||
self.repo.git('tag', '-s', '-m', 'fourth tag', '4.0.0', '3.0.0')
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
results = self.scanner._get_tags_on_branch(None)
|
||||
with scanner.Scanner(self.c) as s:
|
||||
results = s._get_tags_on_branch(None)
|
||||
self.assertEqual(
|
||||
['3.0.0', '4.0.0', '2.0.0', '1.0.0'],
|
||||
results,
|
||||
@ -1958,8 +1967,8 @@ class TagsTest(Base):
|
||||
def test_tagged_tag_lightweight(self):
|
||||
time.sleep(1)
|
||||
self.repo.git('tag', '-m', 'fourth tag', '4.0.0', '3.0.0')
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
results = self.scanner._get_tags_on_branch(None)
|
||||
with scanner.Scanner(self.c) as s:
|
||||
results = s._get_tags_on_branch(None)
|
||||
self.assertEqual(
|
||||
['3.0.0', '4.0.0', '2.0.0', '1.0.0'],
|
||||
results,
|
||||
@ -1979,8 +1988,8 @@ class VersionTest(Base):
|
||||
self.repo.git('tag', '-s', '-m', 'third tag', '3.0.0')
|
||||
|
||||
def test_tagged_head(self):
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
results = self.scanner._get_current_version(None)
|
||||
with scanner.Scanner(self.c) as s:
|
||||
results = s._get_current_version(None)
|
||||
self.assertEqual(
|
||||
'3.0.0',
|
||||
results,
|
||||
@ -1988,8 +1997,8 @@ class VersionTest(Base):
|
||||
|
||||
def test_head_after_tag(self):
|
||||
self._add_notes_file('slug4')
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
results = self.scanner._get_current_version(None)
|
||||
with scanner.Scanner(self.c) as s:
|
||||
results = s._get_current_version(None)
|
||||
self.assertEqual(
|
||||
'3.0.0-1',
|
||||
results,
|
||||
@ -2002,8 +2011,8 @@ class VersionTest(Base):
|
||||
# single second (certainly not a person).
|
||||
time.sleep(1)
|
||||
self.repo.git('tag', '-s', '-m', 'fourth tag', '4.0.0')
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
results = self.scanner._get_current_version(None)
|
||||
with scanner.Scanner(self.c) as s:
|
||||
results = s._get_current_version(None)
|
||||
self.assertEqual(
|
||||
'4.0.0',
|
||||
results,
|
||||
@ -2452,11 +2461,9 @@ class GetSeriesBranchesTest(Base):
|
||||
self.repo.add_file('test.txt')
|
||||
|
||||
def test_none(self):
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
self.assertEqual(
|
||||
[],
|
||||
self.scanner.get_series_branches(),
|
||||
)
|
||||
with scanner.Scanner(self.c) as s:
|
||||
branches = s.get_series_branches()
|
||||
self.assertEqual([], branches)
|
||||
|
||||
def test_real_branches_sorted_names(self):
|
||||
self.repo.git(
|
||||
@ -2465,21 +2472,17 @@ class GetSeriesBranchesTest(Base):
|
||||
self.repo.git(
|
||||
'checkout', '-b', 'stable/b',
|
||||
)
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
self.assertEqual(
|
||||
['stable/a', 'stable/b'],
|
||||
self.scanner.get_series_branches(),
|
||||
)
|
||||
with scanner.Scanner(self.c) as s:
|
||||
branches = s.get_series_branches()
|
||||
self.assertEqual(['stable/a', 'stable/b'], branches)
|
||||
|
||||
def test_eol_tag(self):
|
||||
self.repo.git(
|
||||
'tag', '-s', '-m', 'closed branch', 'a-eol',
|
||||
)
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
self.assertEqual(
|
||||
['stable/a'],
|
||||
self.scanner.get_series_branches(),
|
||||
)
|
||||
with scanner.Scanner(self.c) as s:
|
||||
branches = s.get_series_branches()
|
||||
self.assertEqual(['stable/a'], branches)
|
||||
|
||||
def test_mix_tag_and_branch(self):
|
||||
self.repo.git(
|
||||
@ -2488,8 +2491,6 @@ class GetSeriesBranchesTest(Base):
|
||||
self.repo.git(
|
||||
'checkout', '-b', 'stable/b',
|
||||
)
|
||||
self.scanner = scanner.Scanner(self.c)
|
||||
self.assertEqual(
|
||||
['stable/a', 'stable/b'],
|
||||
self.scanner.get_series_branches(),
|
||||
)
|
||||
with scanner.Scanner(self.c) as s:
|
||||
branches = s.get_series_branches()
|
||||
self.assertEqual(['stable/a', 'stable/b'], branches)
|
||||
|
||||
Loading…
Reference in New Issue
Block a user