diff --git a/ietf/sync/rfceditor.py b/ietf/sync/rfceditor.py index dab5cb17c..ce0cf2da2 100644 --- a/ietf/sync/rfceditor.py +++ b/ietf/sync/rfceditor.py @@ -7,6 +7,7 @@ import datetime import re import requests +from typing import Iterator, Optional, Union from urllib.parse import urlencode from xml.dom import pulldom, Node @@ -17,7 +18,7 @@ from django.utils.encoding import smart_bytes, force_str import debug # pyflakes:ignore from ietf.doc.models import ( Document, DocAlias, State, StateType, DocEvent, DocRelationshipName, - DocTagName, DocTypeName, RelatedDocument ) + DocTagName, RelatedDocument ) from ietf.doc.expire import move_draft_files_to_archive from ietf.doc.utils import add_state_change_event, prettify_std_name, update_action_holders from ietf.group.models import Group @@ -332,17 +333,21 @@ def parse_index(response): return data -def update_docs_from_rfc_index(index_data, errata_data, skip_older_than_date=None): +def update_docs_from_rfc_index( + index_data, errata_data, skip_older_than_date=None +) -> Iterator[tuple[list[str], Document, bool]]: """Given parsed data from the RFC Editor index, update the documents in the database Yields a list of change descriptions for each document, if any. The skip_older_than_date is a bare date, not a datetime. """ - - errata = {} + # Create dict mapping doc-id to list of errata records that apply to it + errata: dict[str, list[dict]] = {} for item in errata_data: - name = item['doc-id'] + name = item["doc-id"] + if name.upper().startswith("RFC"): + name = f"RFC{int(name[3:])}" # removes leading 0s on the rfc number if not name in errata: errata[name] = [] errata[name].append(item) @@ -357,7 +362,7 @@ def update_docs_from_rfc_index(index_data, errata_data, skip_older_than_date=Non "Best Current Practice": StdLevelName.objects.get(slug="bcp"), "Historic": StdLevelName.objects.get(slug="hist"), "Unknown": StdLevelName.objects.get(slug="unkn"), - } + } stream_mapping = { "IETF": StreamName.objects.get(slug="ietf"), @@ -367,15 +372,33 @@ def update_docs_from_rfc_index(index_data, errata_data, skip_older_than_date=Non "Legacy": StreamName.objects.get(slug="legacy"), } - tag_has_errata = DocTagName.objects.get(slug='errata') - tag_has_verified_errata = DocTagName.objects.get(slug='verified-errata') + tag_has_errata = DocTagName.objects.get(slug="errata") + tag_has_verified_errata = DocTagName.objects.get(slug="verified-errata") relationship_obsoletes = DocRelationshipName.objects.get(slug="obs") relationship_updates = DocRelationshipName.objects.get(slug="updates") + rfc_published_state = State.objects.get(type_id="rfc", slug="published") system = Person.objects.get(name="(System)") - for rfc_number, title, authors, rfc_published_date, current_status, updates, updated_by, obsoletes, obsoleted_by, also, draft, has_errata, stream, wg, file_formats, pages, abstract in index_data: - + for ( + rfc_number, + title, + authors, + rfc_published_date, + current_status, + updates, + updated_by, + obsoletes, + obsoleted_by, + also, + draft_name, + has_errata, + stream, + wg, + file_formats, + pages, + abstract, + ) in index_data: if skip_older_than_date and rfc_published_date < skip_older_than_date: # speed up the process by skipping old entries continue @@ -383,64 +406,173 @@ def update_docs_from_rfc_index(index_data, errata_data, skip_older_than_date=Non # we assume two things can happen: we get a new RFC, or an # attribute has been updated at the RFC Editor (RFC Editor # attributes take precedence over our local attributes) - events = [] - changes = [] + rfc_events = [] + rfc_changes = [] rfc_published = False - # make sure we got the document and alias - doc = None - name = "rfc%s" % rfc_number - a = DocAlias.objects.filter(name=name) - if a: - doc = a[0].document - else: - if draft: - try: - doc = Document.objects.get(name=draft) - except Document.DoesNotExist: - pass + # Find the draft, if any + draft = None + if draft_name: + try: + draft = Document.objects.get(name=draft_name, type_id="draft") + except Document.DoesNotExist: + log(f"Warning: RFC index for {rfc_number} referred to unknown draft {draft_name}") - if not doc: - changes.append("created document %s" % prettify_std_name(name)) - doc = Document.objects.create(name=name, type=DocTypeName.objects.get(slug="draft")) - - # add alias - alias, __ = DocAlias.objects.get_or_create(name=name) + # Find or create the RFC document + creation_args: dict[str, Optional[Union[str, int]]] = {"name": f"rfc{rfc_number}"} + if draft: + creation_args.update( + { + "title": draft.title, + "stream": draft.stream, + "group": draft.group, + "abstract": draft.abstract, + "pages": draft.pages, + "words": draft.words, + "std_level": draft.std_level, + "ad": draft.ad, + "external_url": draft.external_url, + "uploaded_filename": draft.uploaded_filename, + "note": draft.note, + } + ) + doc, created_rfc = Document.objects.get_or_create( + rfc_number=rfc_number, type_id="rfc", defaults=creation_args + ) + if created_rfc: + rfc_changes.append(f"created document {prettify_std_name(doc.name)}") + # Create DocAlias (for consistency until we drop DocAlias altogether) + alias, _ = DocAlias.objects.get_or_create(name=doc.name) alias.docs.add(doc) - changes.append("created alias %s" % prettify_std_name(name)) + rfc_changes.append(f"created alias {prettify_std_name(doc.name)}") + doc.set_state(rfc_published_state) + if draft: + doc.formal_languages.set(draft.formal_languages.all()) + + if draft: + draft_events = [] + draft_changes = [] + + # Ensure the draft is in the "rfc" state and move its files to the archive + # if necessary. + if draft.get_state_slug() != "rfc": + draft.set_state( + State.objects.get(used=True, type="draft", slug="rfc") + ) + move_draft_files_to_archive(draft, draft.rev) + draft_changes.append(f"changed state to {draft.get_state()}") + + # Ensure the draft and rfc are linked with a "became_rfc" relationship + r, created_relateddoc = RelatedDocument.objects.get_or_create( + source=draft, target=doc, relationship_id="became_rfc" + ) + if created_relateddoc: + change = "created {rel_name} relationship between {pretty_draft_name} and {pretty_rfc_name}".format( + rel_name=r.relationship.name.lower(), + pretty_draft_name=prettify_std_name(draft_name), + pretty_rfc_name=prettify_std_name(doc.name), + ) + draft_changes.append(change) + rfc_changes.append(change) + + # Always set the "draft-iesg" state. This state should be set for all drafts, so + # log a warning if it is not set. What should happen here is that ietf stream + # RFCs come in as "rfcqueue" and are set to "pub" when they appear in the RFC index. + # Other stream documents should normally be "idexists" and be left that way. The + # code here *actually* leaves "draft-iesg" state alone if it is "idexists" or "pub", + # and changes any other state to "pub". If unset, it changes it to "idexists". + # This reflects historical behavior and should probably be updated, but a migration + # of existing drafts (and validation of the change) is needed before we change the + # handling. + prev_iesg_state = draft.get_state("draft-iesg") + if prev_iesg_state is None: + log(f'Warning while processing {doc.name}: {draft.name} has no "draft-iesg" state') + new_iesg_state = State.objects.get(type_id="draft-iesg", slug="idexists") + elif prev_iesg_state.slug not in ("pub", "idexists"): + if prev_iesg_state.slug != "rfcqueue": + log( + 'Warning while processing {}: {} is in "draft-iesg" state {} (expected "rfcqueue")'.format( + doc.name, draft.name, prev_iesg_state.slug + ) + ) + new_iesg_state = State.objects.get(type_id="draft-iesg", slug="pub") + else: + new_iesg_state = prev_iesg_state + + if new_iesg_state != prev_iesg_state: + draft.set_state(new_iesg_state) + draft_changes.append(f"changed {new_iesg_state.type.label} to {new_iesg_state}") + e = update_action_holders(draft, prev_iesg_state, new_iesg_state) + if e: + draft_events.append(e) + + # If the draft and RFC streams agree, move draft to "pub" stream state. If not, complain. + if draft.stream != doc.stream: + log("Warning while processing {}: draft {} stream is {} but RFC stream is {}".format( + doc.name, draft.name, draft.stream, doc.stream + )) + elif draft.stream.slug in ["iab", "irtf", "ise"]: + stream_slug = f"draft-stream-{draft.stream.slug}" + prev_state = draft.get_state(stream_slug) + if prev_state is None: + log(f"Warning while processing {doc.name}: draft {draft.name} stream state was not set") + if prev_state.slug != "pub": + new_state = State.objects.select_related("type").get(used=True, type__slug=stream_slug, slug="pub") + draft.set_state(new_state) + draft_changes.append( + f"changed {new_state.type.label} to {new_state}" + ) + e = update_action_holders(draft, prev_state, new_state) + if e: + draft_events.append(e) + if draft_changes: + draft_events.append( + DocEvent.objects.create( + doc=draft, + rev=doc.rev, + by=system, + type="sync_from_rfc_editor", + desc=f"Received changes through RFC Editor sync ({', '.join(draft_changes)})", + ) + ) + draft.save_with_history(draft_events) + yield draft_changes, draft, False # yield changes to the draft # check attributes + verbed = "set" if created_rfc else "changed" if title != doc.title: doc.title = title - changes.append("changed title to '%s'" % doc.title) + rfc_changes.append(f"{verbed} title to '{doc.title}'") if abstract and abstract != doc.abstract: doc.abstract = abstract - changes.append("changed abstract to '%s'" % doc.abstract) + rfc_changes.append(f"{verbed} abstract to '{doc.abstract}'") if pages and int(pages) != doc.pages: doc.pages = int(pages) - changes.append("changed pages to %s" % doc.pages) + rfc_changes.append(f"{verbed} pages to {doc.pages}") if std_level_mapping[current_status] != doc.std_level: doc.std_level = std_level_mapping[current_status] - changes.append("changed standardization level to %s" % doc.std_level) - - if doc.get_state_slug() != "rfc": - doc.set_state(State.objects.get(used=True, type="draft", slug="rfc")) - move_draft_files_to_archive(doc, doc.rev) - changes.append("changed state to %s" % doc.get_state()) + rfc_changes.append(f"{verbed} standardization level to {doc.std_level}") if doc.stream != stream_mapping[stream]: doc.stream = stream_mapping[stream] - changes.append("changed stream to %s" % doc.stream) + rfc_changes.append(f"{verbed} stream to {doc.stream}") - if not doc.group: # if we have no group assigned, check if RFC Editor has a suggestion + if doc.get_state() != rfc_published_state: + doc.set_state(rfc_published_state) + rfc_changes.append(f"{verbed} {rfc_published_state.type.label} to {rfc_published_state}") + + # if we have no group assigned, check if RFC Editor has a suggestion + if not doc.group: if wg: doc.group = Group.objects.get(acronym=wg) - changes.append("set group to %s" % doc.group) + rfc_changes.append(f"set group to {doc.group}") else: - doc.group = Group.objects.get(type="individ") # fallback for newly created doc + doc.group = Group.objects.get( + type="individ" + ) # fallback for newly created doc if not doc.latest_event(type="published_rfc"): e = DocEvent(doc=doc, rev=doc.rev, type="published_rfc") @@ -467,36 +599,25 @@ def update_docs_from_rfc_index(index_data, errata_data, skip_older_than_date=Non e.by = system e.desc = "RFC published" e.save() - events.append(e) + rfc_events.append(e) - changes.append("added RFC published event at %s" % e.time.strftime("%Y-%m-%d")) + rfc_changes.append( + f"added RFC published event at {e.time.strftime('%Y-%m-%d')}" + ) rfc_published = True - for t in ("draft-iesg", "draft-stream-iab", "draft-stream-irtf", "draft-stream-ise"): - prev_state = doc.get_state(t) - if prev_state is not None: - if prev_state.slug not in ("pub", "idexists"): - new_state = State.objects.select_related("type").get(used=True, type=t, slug="pub") - doc.set_state(new_state) - changes.append("changed %s to %s" % (new_state.type.label, new_state)) - e = update_action_holders(doc, prev_state, new_state) - if e: - events.append(e) - elif t == 'draft-iesg': - doc.set_state(State.objects.get(type_id='draft-iesg', slug='idexists')) - def parse_relation_list(l): res = [] for x in l: - # This lookup wasn't finding anything but maybe some STD and we know + # This lookup wasn't finding anything but maybe some STD and we know # if the STD had more than one RFC the wrong thing happens # - #if x[:3] in ("NIC", "IEN", "STD", "RTR"): + # if x[:3] in ("NIC", "IEN", "STD", "RTR"): # # try translating this to RFCs that we can handle # # sensibly; otherwise we'll have to ignore them # l = DocAlias.objects.filter(name__startswith="rfc", docs__docalias__name=x.lower()) - #else: - l = Document.objects.filter(name=x.lower()) + # else: + l = Document.objects.filter(name=x.lower(), type_id="rfc") for a in l: if a not in res: @@ -504,56 +625,82 @@ def update_docs_from_rfc_index(index_data, errata_data, skip_older_than_date=Non return res for x in parse_relation_list(obsoletes): - if not RelatedDocument.objects.filter(source=doc, target=x, relationship=relationship_obsoletes): - r = RelatedDocument.objects.create(source=doc, target=x, relationship=relationship_obsoletes) - changes.append("created %s relation between %s and %s" % (r.relationship.name.lower(), prettify_std_name(r.source.name), prettify_std_name(r.target.name))) + if not RelatedDocument.objects.filter( + source=doc, target=x, relationship=relationship_obsoletes + ): + r = RelatedDocument.objects.create( + source=doc, target=x, relationship=relationship_obsoletes + ) + rfc_changes.append( + "created {rel_name} relation between {src_name} and {tgt_name}".format( + rel_name=r.relationship.name.lower(), + src_name=prettify_std_name(r.source.name), + tgt_name=prettify_std_name(r.target.name), + ) + ) for x in parse_relation_list(updates): - if not RelatedDocument.objects.filter(source=doc, target=x, relationship=relationship_updates): - r = RelatedDocument.objects.create(source=doc, target=x, relationship=relationship_updates) - changes.append("created %s relation between %s and %s" % (r.relationship.name.lower(), prettify_std_name(r.source.name), prettify_std_name(r.target.name))) + if not RelatedDocument.objects.filter( + source=doc, target=x, relationship=relationship_updates + ): + r = RelatedDocument.objects.create( + source=doc, target=x, relationship=relationship_updates + ) + rfc_changes.append( + "created {rel_name} relation between {src_name} and {tgt_name}".format( + rel_name=r.relationship.name.lower(), + src_name=prettify_std_name(r.source.name), + tgt_name=prettify_std_name(r.target.name), + ) + ) if also: for a in also: a = a.lower() if not DocAlias.objects.filter(name=a): DocAlias.objects.create(name=a).docs.add(doc) - changes.append("created alias %s" % prettify_std_name(a)) + rfc_changes.append(f"created alias {prettify_std_name(a)}") - doc_errata = errata.get('RFC%04d'%rfc_number, []) - all_rejected = doc_errata and all( er['errata_status_code']=='Rejected' for er in doc_errata ) + doc_errata = errata.get(f"RFC{rfc_number}", []) + all_rejected = doc_errata and all( + er["errata_status_code"] == "Rejected" for er in doc_errata + ) if has_errata and not all_rejected: if not doc.tags.filter(pk=tag_has_errata.pk).exists(): doc.tags.add(tag_has_errata) - changes.append("added Errata tag") - has_verified_errata = any([ er['errata_status_code']=='Verified' for er in doc_errata ]) - if has_verified_errata and not doc.tags.filter(pk=tag_has_verified_errata.pk).exists(): + rfc_changes.append("added Errata tag") + has_verified_errata = any( + [er["errata_status_code"] == "Verified" for er in doc_errata] + ) + if ( + has_verified_errata + and not doc.tags.filter(pk=tag_has_verified_errata.pk).exists() + ): doc.tags.add(tag_has_verified_errata) - changes.append("added Verified Errata tag") + rfc_changes.append("added Verified Errata tag") else: if doc.tags.filter(pk=tag_has_errata.pk): doc.tags.remove(tag_has_errata) if all_rejected: - changes.append("removed Errata tag (all errata rejected)") + rfc_changes.append("removed Errata tag (all errata rejected)") else: - changes.append("removed Errata tag") + rfc_changes.append("removed Errata tag") if doc.tags.filter(pk=tag_has_verified_errata.pk): doc.tags.remove(tag_has_verified_errata) - changes.append("removed Verified Errata tag") + rfc_changes.append("removed Verified Errata tag") - if changes: - events.append(DocEvent.objects.create( - doc=doc, - rev=doc.rev, - by=system, - type="sync_from_rfc_editor", - desc="Received changes through RFC Editor sync (%s)" % ", ".join(changes), - )) - - doc.save_with_history(events) - - if changes: - yield changes, doc, rfc_published + if rfc_changes: + rfc_events.append( + DocEvent.objects.create( + doc=doc, + rev=doc.rev, + by=system, + type="sync_from_rfc_editor", + desc=f"Received changes through RFC Editor sync ({', '.join(rfc_changes)})", + ) + ) + doc.save_with_history(rfc_events) + yield rfc_changes, doc, rfc_published # yield changes to the RFC def post_approved_draft(url, name): diff --git a/ietf/sync/tests.py b/ietf/sync/tests.py index 4ad26e3e4..a3e857768 100644 --- a/ietf/sync/tests.py +++ b/ietf/sync/tests.py @@ -6,6 +6,7 @@ import os import io import json import datetime +import mock import quopri from django.conf import settings @@ -226,14 +227,14 @@ class RFCSyncTests(TestCase): def test_rfc_index(self): area = GroupFactory(type_id='area') - doc = WgDraftFactory( + draft_doc = WgDraftFactory( group__parent=area, - states=[('draft-iesg','rfcqueue'),('draft-stream-ise','rfc-edit')], + states=[('draft-iesg','rfcqueue')], ad=Person.objects.get(user__username='ad'), + external_url="http://my-external-url.example.com", + note="this is a note", ) - # it's a bit strange to have draft-stream-ise set when draft-iesg is set - # too, but for testing purposes ... - doc.action_holders.add(doc.ad) # not normally set, but add to be sure it's cleared + draft_doc.action_holders.add(draft_doc.ad) # not normally set, but add to be sure it's cleared RfcFactory(rfc_number=123) @@ -298,14 +299,14 @@ class RFCSyncTests(TestCase): ''' % dict(year=today.strftime("%Y"), month=today.strftime("%B"), - name=doc.name, - rev=doc.rev, - area=doc.group.parent.acronym, - group=doc.group.acronym) + name=draft_doc.name, + rev=draft_doc.rev, + area=draft_doc.group.parent.acronym, + group=draft_doc.group.acronym) errata = [{ "errata_id":1, - "doc-id":"RFC123", + "doc-id":"RFC123", # n.b. this is not the same RFC as in the above index XML! "errata_status_code":"Verified", "errata_type_code":"Editorial", "section": "4.1", @@ -321,7 +322,7 @@ class RFCSyncTests(TestCase): data = rfceditor.parse_index(io.StringIO(t)) self.assertEqual(len(data), 1) - + rfc_number, title, authors, rfc_published_date, current_status, updates, updated_by, obsoletes, obsoleted_by, also, draft, has_errata, stream, wg, file_formats, pages, abstract = data[0] # currently, we only check what we actually use @@ -332,44 +333,77 @@ class RFCSyncTests(TestCase): self.assertEqual(current_status, "Proposed Standard") self.assertEqual(updates, ["RFC123"]) self.assertEqual(set(also), set(["BCP1", "FYI1", "STD1"])) - self.assertEqual(draft, doc.name) - self.assertEqual(wg, doc.group.acronym) + self.assertEqual(draft, draft_doc.name) + self.assertEqual(wg, draft_doc.group.acronym) self.assertEqual(has_errata, True) self.assertEqual(stream, "IETF") self.assertEqual(pages, "42") self.assertEqual(abstract, "This is some interesting text.") - draft_filename = "%s-%s.txt" % (doc.name, doc.rev) + draft_filename = "%s-%s.txt" % (draft_doc.name, draft_doc.rev) self.write_draft_file(draft_filename, 5000) + event_count_before = draft_doc.docevent_set.count() + draft_title_before = draft_doc.title + draft_abstract_before = draft_doc.abstract + draft_pages_before = draft_doc.pages changes = [] - for cs, d, rfc_published in rfceditor.update_docs_from_rfc_index(data, errata, today - datetime.timedelta(days=30)): - changes.append(cs) - - doc = Document.objects.get(name=doc.name) - - events = doc.docevent_set.all() - self.assertEqual(events[0].type, "sync_from_rfc_editor") - self.assertEqual(events[1].type, "changed_action_holders") - self.assertEqual(events[2].type, "published_rfc") - self.assertEqual(events[2].time.astimezone(RPC_TZINFO).date(), today) - self.assertTrue("errata" in doc.tags.all().values_list("slug", flat=True)) - self.assertTrue(DocAlias.objects.filter(name="rfc1234", docs=doc)) - self.assertTrue(DocAlias.objects.filter(name="bcp1", docs=doc)) - self.assertTrue(DocAlias.objects.filter(name="fyi1", docs=doc)) - self.assertTrue(DocAlias.objects.filter(name="std1", docs=doc)) - self.assertTrue(RelatedDocument.objects.filter(source=doc, target__name="rfc123", relationship="updates").exists()) - self.assertEqual(doc.title, "A Testing RFC") - self.assertEqual(doc.abstract, "This is some interesting text.") - self.assertEqual(doc.get_state_slug(), "rfc") - self.assertEqual(doc.get_state_slug("draft-iesg"), "pub") - self.assertCountEqual(doc.action_holders.all(), []) - self.assertEqual(doc.get_state_slug("draft-stream-ise"), "pub") - self.assertEqual(doc.std_level_id, "ps") - self.assertEqual(doc.pages, 42) + with mock.patch("ietf.sync.rfceditor.log") as mock_log: + for _, d, rfc_published in rfceditor.update_docs_from_rfc_index(data, errata, today - datetime.timedelta(days=30)): + changes.append({"doc_pk": d.pk, "rfc_published": rfc_published}) # we ignore the actual change list + self.assertFalse(mock_log.called, "No log messages expected") + + draft_doc = Document.objects.get(name=draft_doc.name) + draft_events = draft_doc.docevent_set.all() + self.assertEqual(len(draft_events) - event_count_before, 2) + self.assertEqual(draft_events[0].type, "sync_from_rfc_editor") + self.assertEqual(draft_events[1].type, "changed_action_holders") + self.assertEqual(draft_doc.get_state_slug(), "rfc") + self.assertEqual(draft_doc.get_state_slug("draft-iesg"), "pub") + self.assertCountEqual(draft_doc.action_holders.all(), []) + self.assertEqual(draft_doc.title, draft_title_before) + self.assertEqual(draft_doc.abstract, draft_abstract_before) + self.assertEqual(draft_doc.pages, draft_pages_before) self.assertTrue(not os.path.exists(os.path.join(settings.INTERNET_DRAFT_PATH, draft_filename))) self.assertTrue(os.path.exists(os.path.join(settings.INTERNET_DRAFT_ARCHIVE_DIR, draft_filename))) + rfc_doc = Document.objects.filter(rfc_number=1234, type_id="rfc").first() + self.assertIsNotNone(rfc_doc, "RFC document should have been created") + rfc_events = rfc_doc.docevent_set.all() + self.assertEqual(len(rfc_events), 2) + self.assertEqual(rfc_events[0].type, "sync_from_rfc_editor") + self.assertEqual(rfc_events[1].type, "published_rfc") + self.assertEqual(rfc_events[1].time.astimezone(RPC_TZINFO).date(), today) + self.assertEqual(rfc_doc.get_state_slug(), "published") + # Should have an "errata" tag because there is an errata-url in the index XML, but no "verified-errata" tag + # because there is no verified item in the errata JSON with doc-id matching the RFC document. + tag_slugs = rfc_doc.tags.values_list("slug", flat=True) + self.assertTrue("errata" in tag_slugs) + self.assertFalse("verified-errata" in tag_slugs) + self.assertTrue(DocAlias.objects.filter(name="rfc1234", docs=rfc_doc)) + self.assertTrue(DocAlias.objects.filter(name="bcp1", docs=rfc_doc)) + self.assertTrue(DocAlias.objects.filter(name="fyi1", docs=rfc_doc)) + self.assertTrue(DocAlias.objects.filter(name="std1", docs=rfc_doc)) + self.assertTrue(RelatedDocument.objects.filter(source=rfc_doc, target__name="rfc123", relationship="updates").exists()) + self.assertTrue(RelatedDocument.objects.filter(source=draft_doc, target=rfc_doc, relationship="became_rfc").exists()) + self.assertEqual(rfc_doc.title, "A Testing RFC") + self.assertEqual(rfc_doc.abstract, "This is some interesting text.") + self.assertEqual(rfc_doc.std_level_id, "ps") + self.assertEqual(rfc_doc.pages, 42) + self.assertEqual(rfc_doc.stream, draft_doc.stream) + self.assertEqual(rfc_doc.group, draft_doc.group) + self.assertEqual(rfc_doc.words, draft_doc.words) + self.assertEqual(rfc_doc.ad, draft_doc.ad) + self.assertEqual(rfc_doc.external_url, draft_doc.external_url) + self.assertEqual(rfc_doc.note, draft_doc.note) + + # check that we got the expected changes + self.assertEqual(len(changes), 2) + self.assertEqual(changes[0]["doc_pk"], draft_doc.pk) + self.assertEqual(changes[0]["rfc_published"], False) + self.assertEqual(changes[1]["doc_pk"], rfc_doc.pk) + self.assertEqual(changes[1]["rfc_published"], True) + # make sure we can apply it again with no changes changed = list(rfceditor.update_docs_from_rfc_index(data, errata, today - datetime.timedelta(days=30))) self.assertEqual(len(changed), 0)