From a33efbe77241e7e63d763aa5fee621769455e14c Mon Sep 17 00:00:00 2001 From: zandercymatics <141044360+zandercymatics@users.noreply.github.com> Date: Mon, 30 Oct 2023 08:07:27 -0600 Subject: [PATCH] Ran black for linting --- .../commands/load_transition_domain.py | 3 +- .../commands/master_domain_migrations.py | 313 ++++++++++-------- .../commands/utility/terminal_helper.py | 13 +- .../test_transition_domain_migrations.py | 185 ++++++----- 4 files changed, 285 insertions(+), 229 deletions(-) diff --git a/src/registrar/management/commands/load_transition_domain.py b/src/registrar/management/commands/load_transition_domain.py index bd811d56d..687750ed8 100644 --- a/src/registrar/management/commands/load_transition_domain.py +++ b/src/registrar/management/commands/load_transition_domain.py @@ -100,8 +100,7 @@ class Command(BaseCommand): return domain_status_dictionary def get_user_emails_dict( - self, - contacts_filename: str, sep + self, contacts_filename: str, sep ) -> defaultdict[str, str]: """Creates mapping of userId -> emails""" user_emails_dictionary = defaultdict(str) diff --git a/src/registrar/management/commands/master_domain_migrations.py b/src/registrar/management/commands/master_domain_migrations.py index 1b0623b35..a5660b704 100644 --- a/src/registrar/management/commands/master_domain_migrations.py +++ b/src/registrar/management/commands/master_domain_migrations.py @@ -27,11 +27,12 @@ from registrar.models import ( from registrar.management.commands.utility.terminal_helper import ( TerminalColors, - TerminalHelper + TerminalHelper, ) logger = logging.getLogger(__name__) + class Command(BaseCommand): help = """ """ @@ -48,8 +49,8 @@ class Command(BaseCommand): > --migrationDirectory /app/tmp --migrationFilenames - The files used for load_transition_domain migration script. - Must appear IN ORDER and comma-delimiteds: + The files used for load_transition_domain migration script. + Must appear IN ORDER and comma-delimiteds: EXAMPLE USAGE: > --migrationFilenames domain_contacts_filename.txt,contacts_filename.txt,domain_statuses_filename.txt where... @@ -76,26 +77,30 @@ class Command(BaseCommand): purposes --resetTable - Used by the migration scripts to trigger a prompt for deleting all table entries. + Used by the migration scripts to trigger a prompt for deleting all table entries. Useful for testing purposes, but USE WITH CAUTION - """ + """ # noqa - line length, impacts readability - parser.add_argument("--runMigrations", + parser.add_argument( + "--runMigrations", help="Runs all scripts (in sequence) for transition domain migrations", - action=argparse.BooleanOptionalAction) - + action=argparse.BooleanOptionalAction, + ) + # --triggerLogins # A boolean (default to true), which triggers running # simulations of user logins for each user in domain invitation - parser.add_argument("--triggerLogins", + parser.add_argument( + "--triggerLogins", help="Simulates a user login for each user in domain invitation", - action=argparse.BooleanOptionalAction) - + action=argparse.BooleanOptionalAction, + ) + # The following file arguments have default values for running in the sandbox parser.add_argument( "--migrationDirectory", default="migrationData", - help="The location of the files used for load_transition_domain migration script" + help="The location of the files used for load_transition_domain migration script", ) parser.add_argument( "--migrationFilenames", @@ -107,10 +112,12 @@ class Command(BaseCommand): where... - domain_contacts_filename is the Data file with domain contact information - contacts_filename is the Data file with contact information - - domain_statuses_filename is the Data file with domain status information""" + - domain_statuses_filename is the Data file with domain status information""", ) - parser.add_argument("--sep", default="|", help="Delimiter character for the migration files") + parser.add_argument( + "--sep", default="|", help="Delimiter character for the migration files" + ) parser.add_argument("--debug", action=argparse.BooleanOptionalAction) @@ -127,19 +134,19 @@ class Command(BaseCommand): ) def compare_tables(self, debug_on: bool): - """Does a diff between the transition_domain and the following tables: - domain, domain_information and the domain_invitation. - + """Does a diff between the transition_domain and the following tables: + domain, domain_information and the domain_invitation. + Produces the following report (printed to the terminal): #1 - Print any domains that exist in the transition_domain table but not in their corresponding domain, domain information or domain invitation tables. #2 - Print which table this domain is missing from - #3- Check for duplicate entries in domain or - domain_information tables and print which are + #3- Check for duplicate entries in domain or + domain_information tables and print which are duplicates and in which tables - """ - + """ + logger.info( f"""{TerminalColors.OKCYAN} ============= BEGINNING ANALYSIS =============== @@ -147,13 +154,13 @@ class Command(BaseCommand): """ ) - #TODO: would filteredRelation be faster? + # TODO: would filteredRelation be faster? missing_domains = [] duplicate_domains = [] missing_domain_informations = [] missing_domain_invites = [] - for transition_domain in TransitionDomain.objects.all():# DEBUG: + for transition_domain in TransitionDomain.objects.all(): # DEBUG: transition_domain_name = transition_domain.domain_name transition_domain_email = transition_domain.username @@ -165,22 +172,38 @@ class Command(BaseCommand): # Check Domain table matching_domains = Domain.objects.filter(name=transition_domain_name) # Check Domain Information table - matching_domain_informations = DomainInformation.objects.filter(domain__name=transition_domain_name) + matching_domain_informations = DomainInformation.objects.filter( + domain__name=transition_domain_name + ) # Check Domain Invitation table - matching_domain_invitations = DomainInvitation.objects.filter(email=transition_domain_email.lower(), - domain__name=transition_domain_name) + matching_domain_invitations = DomainInvitation.objects.filter( + email=transition_domain_email.lower(), + domain__name=transition_domain_name, + ) if len(matching_domains) == 0: - TerminalHelper.print_conditional(debug_on, f"""{TerminalColors.YELLOW}Missing Domain{TerminalColors.ENDC}""") + TerminalHelper.print_conditional( + debug_on, + f"""{TerminalColors.YELLOW}Missing Domain{TerminalColors.ENDC}""", + ) missing_domains.append(transition_domain_name) elif len(matching_domains) > 1: - TerminalHelper.print_conditional(debug_on, f"""{TerminalColors.YELLOW}Duplicate Domain{TerminalColors.ENDC}""") + TerminalHelper.print_conditional( + debug_on, + f"""{TerminalColors.YELLOW}Duplicate Domain{TerminalColors.ENDC}""", + ) duplicate_domains.append(transition_domain_name) if len(matching_domain_informations) == 0: - TerminalHelper.print_conditional(debug_on, f"""{TerminalColors.YELLOW}Missing Domain Information{TerminalColors.ENDC}""") + TerminalHelper.print_conditional( + debug_on, + f"""{TerminalColors.YELLOW}Missing Domain Information{TerminalColors.ENDC}""", + ) missing_domain_informations.append(transition_domain_name) if len(matching_domain_invitations) == 0: - TerminalHelper.print_conditional(debug_on, f"""{TerminalColors.YELLOW}Missing Domain Invitation{TerminalColors.ENDC}""") + TerminalHelper.print_conditional( + debug_on, + f"""{TerminalColors.YELLOW}Missing Domain Invitation{TerminalColors.ENDC}""", + ) missing_domain_invites.append(transition_domain_name) total_missing_domains = len(missing_domains) @@ -189,10 +212,16 @@ class Command(BaseCommand): total_missing_domain_invitations = len(missing_domain_invites) missing_domains_as_string = "{}".format(", ".join(map(str, missing_domains))) - duplicate_domains_as_string = "{}".format(", ".join(map(str, duplicate_domains))) - missing_domain_informations_as_string = "{}".format(", ".join(map(str, missing_domain_informations))) - missing_domain_invites_as_string = "{}".format(", ".join(map(str, missing_domain_invites))) - + duplicate_domains_as_string = "{}".format( + ", ".join(map(str, duplicate_domains)) + ) + missing_domain_informations_as_string = "{}".format( + ", ".join(map(str, missing_domain_informations)) + ) + missing_domain_invites_as_string = "{}".format( + ", ".join(map(str, missing_domain_invites)) + ) + logger.info( f"""{TerminalColors.OKGREEN} ============= FINISHED ANALYSIS =============== @@ -215,18 +244,19 @@ class Command(BaseCommand): {TerminalColors.ENDC} """ ) - - def run_load_transition_domain_script(self, - file_location: str, - domain_contacts_filename: str, - contacts_filename: str, - domain_statuses_filename: str, - sep: str, - reset_table: bool, - debug_on: bool, - prompts_enabled: bool, - debug_max_entries_to_parse: int): - + + def run_load_transition_domain_script( + self, + file_location: str, + domain_contacts_filename: str, + contacts_filename: str, + domain_statuses_filename: str, + sep: str, + reset_table: bool, + debug_on: bool, + prompts_enabled: bool, + debug_max_entries_to_parse: int, + ): """Runs the load_transition_domain script""" # Create the command string command_script = "load_transition_domain" @@ -245,11 +275,14 @@ class Command(BaseCommand): if debug_max_entries_to_parse > 0: command_string += f"--limitParse {debug_max_entries_to_parse} " - # Execute the command string if prompts_enabled: system_exit_on_terminate = True - TerminalHelper.prompt_for_execution(system_exit_on_terminate, command_string, "Running load_transition_domain script") + TerminalHelper.prompt_for_execution( + system_exit_on_terminate, + command_string, + "Running load_transition_domain script", + ) # TODO: make this somehow run inside TerminalHelper prompt call_command( @@ -257,16 +290,13 @@ class Command(BaseCommand): f"{file_location+domain_contacts_filename}", f"{file_location+contacts_filename}", f"{file_location+domain_statuses_filename}", - sep = sep, - resetTable = reset_table, - debug = debug_on, - limitParse = debug_max_entries_to_parse - ) + sep=sep, + resetTable=reset_table, + debug=debug_on, + limitParse=debug_max_entries_to_parse, + ) - - - - def run_transfer_script(self, debug_on:bool, prompts_enabled: bool): + def run_transfer_script(self, debug_on: bool, prompts_enabled: bool): """Runs the transfer_transition_domains_to_domains script""" # Create the command string command_script = "transfer_transition_domains_to_domains" @@ -276,13 +306,15 @@ class Command(BaseCommand): # Execute the command string if prompts_enabled: system_exit_on_terminate = True - TerminalHelper.prompt_for_execution(system_exit_on_terminate,command_string, "Running transfer_transition_domains_to_domains script") - - # TODO: make this somehow run inside TerminalHelper prompt - call_command( - command_script + TerminalHelper.prompt_for_execution( + system_exit_on_terminate, + command_string, + "Running transfer_transition_domains_to_domains script", ) + # TODO: make this somehow run inside TerminalHelper prompt + call_command(command_script) + def run_send_invites_script(self, debug_on: bool, prompts_enabled: bool): """Runs the send_domain_invitations script""" # Create the command string... @@ -291,28 +323,31 @@ class Command(BaseCommand): # Execute the command string if prompts_enabled: system_exit_on_terminate = True - TerminalHelper.prompt_for_execution(system_exit_on_terminate,command_string, "Running send_domain_invitations script") - - # TODO: make this somehow run inside TerminalHelper prompt - call_command( - command_script, - send_emails=True + TerminalHelper.prompt_for_execution( + system_exit_on_terminate, + command_string, + "Running send_domain_invitations script", ) - def run_migration_scripts(self, - file_location, - domain_contacts_filename, - contacts_filename, - domain_statuses_filename, - sep, - reset_table, - debug_on, - prompts_enabled, - debug_max_entries_to_parse): - """Runs the following migration scripts (in order): - 1 - imports for trans domains - 2 - transfer to domain & domain invitation""" - + # TODO: make this somehow run inside TerminalHelper prompt + call_command(command_script, send_emails=True) + + def run_migration_scripts( + self, + file_location, + domain_contacts_filename, + contacts_filename, + domain_statuses_filename, + sep, + reset_table, + debug_on, + prompts_enabled, + debug_max_entries_to_parse, + ): + """Runs the following migration scripts (in order): + 1 - imports for trans domains + 2 - transfer to domain & domain invitation""" + if prompts_enabled: # Allow the user to inspect the filepath # data given in the arguments, and prompt @@ -335,32 +370,35 @@ class Command(BaseCommand): ) # If the user rejected the filepath information - # as incorrect, prompt the user to provide + # as incorrect, prompt the user to provide # correct file inputs in their original command # prompt and exit this subroutine if not files_are_correct: - logger.info(f""" + logger.info( + f""" {TerminalColors.YELLOW} PLEASE Re-Run the script with the correct file location and filenames: EXAMPLE: docker compose run -T app ./manage.py test_domain_migration --runMigrations --migrationDirectory /app/tmp --migrationFilenames escrow_domain_contacts.daily.gov.GOV.txt escrow_contacts.daily.gov.GOV.txt escrow_domain_statuses.daily.gov.GOV.txt - """) # noqa + """ + ) # noqa return - - # Proceed executing the migration scripts - self.run_load_transition_domain_script(file_location, - domain_contacts_filename, - contacts_filename, - domain_statuses_filename, - sep, - reset_table, - debug_on, - prompts_enabled, - debug_max_entries_to_parse) - self.run_transfer_script(debug_on, prompts_enabled) + # Proceed executing the migration scripts + self.run_load_transition_domain_script( + file_location, + domain_contacts_filename, + contacts_filename, + domain_statuses_filename, + sep, + reset_table, + debug_on, + prompts_enabled, + debug_max_entries_to_parse, + ) + self.run_transfer_script(debug_on, prompts_enabled) def simulate_user_logins(self, debug_on): """Simulates logins for users (this will add @@ -370,7 +408,7 @@ class Command(BaseCommand): # f"{TerminalColors.OKCYAN}" # f"================== SIMULATING LOGINS ==================" # f"{TerminalColors.ENDC}") - + # for invite in DomainInvitation.objects.all(): #TODO: move to unit test # #DEBUG: # TerminalHelper.print_conditional(debug_on, @@ -389,7 +427,6 @@ class Command(BaseCommand): # logger.info(f"""{TerminalColors.YELLOW}(Deleting temporary user object){TerminalColors.ENDC}""") # user.delete() - def handle( self, **options, @@ -400,7 +437,7 @@ class Command(BaseCommand): 2 - simulate logins 3 - send domain invitations (Emails should be sent to the appropriate users note that all moved domains should now be accessible - on django admin for an analyst) + on django admin for an analyst) 4 - analyze the data for transition domains and generate a report """ @@ -412,40 +449,40 @@ class Command(BaseCommand): # the terminal so the user knows what is # enabled. - # Get arguments debug_on = options.get("debug") prompts_enabled = options.get("prompt") run_migrations_enabled = options.get("runMigrations") - simulate_user_login_enabled = False # TODO: delete? Moving to unit test... options.get("triggerLogins") - + simulate_user_login_enabled = ( + False # TODO: delete? Moving to unit test... options.get("triggerLogins") + ) TerminalHelper.print_conditional( - debug_on, - f"""{TerminalColors.OKCYAN} + debug_on, + f"""{TerminalColors.OKCYAN} ----------DEBUG MODE ON---------- Detailed print statements activated. {TerminalColors.ENDC} - """ - ) + """, + ) TerminalHelper.print_conditional( - run_migrations_enabled, - f"""{TerminalColors.OKCYAN} + run_migrations_enabled, + f"""{TerminalColors.OKCYAN} ----------RUNNING MIGRATIONS ON---------- All migration scripts will be run before analyzing the data. {TerminalColors.ENDC} - """ - ) + """, + ) TerminalHelper.print_conditional( - run_migrations_enabled, - f"""{TerminalColors.OKCYAN} + run_migrations_enabled, + f"""{TerminalColors.OKCYAN} ----------TRIGGER LOGINS ON---------- Will be simulating user logins {TerminalColors.ENDC} - """ - ) - + """, + ) + # If a user decides to run all migration # scripts, they may or may not wish to # proceed with analysis of the data depending @@ -463,16 +500,15 @@ class Command(BaseCommand): # grab arguments for running migrations sep = options.get("sep") reset_table = options.get("resetTable") - debug_max_entries_to_parse = int( - options.get("limitParse") - ) + debug_max_entries_to_parse = int(options.get("limitParse")) # Grab filepath information from the arguments - file_location = options.get("migrationDirectory")+"/" + file_location = options.get("migrationDirectory") + "/" filenames = options.get("migrationFilenames").split(",") if len(filenames) < 3: filenames_as_string = "{}".format(", ".join(map(str, filenames))) - logger.info(f""" + logger.info( + f""" {TerminalColors.FAIL} --migrationFilenames expected 3 filenames to follow it, but only {len(filenames)} were given: @@ -481,24 +517,27 @@ class Command(BaseCommand): PLEASE MODIFY THE SCRIPT AND TRY RUNNING IT AGAIN ============= TERMINATING ============= {TerminalColors.ENDC} - """) + """ + ) sys.exit() domain_contacts_filename = filenames[0] contacts_filename = filenames[1] - domain_statuses_filename = filenames[2] + domain_statuses_filename = filenames[2] # Run migration scripts - self.run_migration_scripts(file_location, - domain_contacts_filename, - contacts_filename, - domain_statuses_filename, - sep, - reset_table, - debug_on, - prompts_enabled, - debug_max_entries_to_parse) + self.run_migration_scripts( + file_location, + domain_contacts_filename, + contacts_filename, + domain_statuses_filename, + sep, + reset_table, + debug_on, + prompts_enabled, + debug_max_entries_to_parse, + ) prompt_continuation_of_analysis = True - + # STEP 2 -- SIMULATE LOGINS # Simulate user login for each user in domain # invitation if specified by user OR if running @@ -513,7 +552,7 @@ class Command(BaseCommand): if run_migrations_enabled and simulate_user_login_enabled: if prompts_enabled: simulate_user_login_enabled = TerminalHelper.query_yes_no( - f"""{TerminalColors.FAIL} + f"""{TerminalColors.FAIL} Proceed with simulating user logins? {TerminalColors.ENDC}""" ) @@ -521,7 +560,7 @@ class Command(BaseCommand): return self.simulate_user_logins(debug_on) prompt_continuation_of_analysis = True - + # STEP 3 -- SEND INVITES proceed_with_sending_invites = run_migrations_enabled if prompts_enabled and run_migrations_enabled: @@ -530,7 +569,7 @@ class Command(BaseCommand): Proceed with sending user invites for all transition domains? (Y = proceed, N = skip) {TerminalColors.ENDC}""" - ) + ) if proceed_with_sending_invites: self.run_send_invites_script(debug_on, prompts_enabled) prompt_continuation_of_analysis = True @@ -546,5 +585,5 @@ class Command(BaseCommand): {TerminalColors.ENDC}""" ) if not analyze_tables: - return + return self.compare_tables(debug_on) diff --git a/src/registrar/management/commands/utility/terminal_helper.py b/src/registrar/management/commands/utility/terminal_helper.py index d56ca47f1..1bc2cbb33 100644 --- a/src/registrar/management/commands/utility/terminal_helper.py +++ b/src/registrar/management/commands/utility/terminal_helper.py @@ -61,14 +61,13 @@ class TerminalHelper: # DEBUG: if print_condition: logger.info(print_statement) - - def prompt_for_execution(system_exit_on_terminate: bool, - info_to_inspect: str, - prompt_title: str) -> bool: + def prompt_for_execution( + system_exit_on_terminate: bool, info_to_inspect: str, prompt_title: str + ) -> bool: """Create to reduce code complexity. Prompts the user to inspect the given string - and asks if they wish to execute it. + and asks if they wish to execute it. Returns true if the user responds (y), Returns false if the user responds (n)""" @@ -97,5 +96,5 @@ class TerminalHelper: if system_exit_on_terminate: sys.exit() return False - - return True \ No newline at end of file + + return True diff --git a/src/registrar/tests/test_transition_domain_migrations.py b/src/registrar/tests/test_transition_domain_migrations.py index 91c8c471e..4bd65ea9a 100644 --- a/src/registrar/tests/test_transition_domain_migrations.py +++ b/src/registrar/tests/test_transition_domain_migrations.py @@ -10,9 +10,12 @@ from registrar.models import ( UserDomainRole, ) -from registrar.management.commands.master_domain_migrations import Command as master_migration_command +from registrar.management.commands.master_domain_migrations import ( + Command as master_migration_command, +) from django.core.management import call_command + class TestLogins(TestCase): """ """ @@ -27,7 +30,7 @@ class TestLogins(TestCase): self.test_domain_contact_filename = "test_domain_contacts.txt" self.test_contact_filename = "test_contacts.txt" self.test_domain_status_filename = "test_domain_statuses.txt" - + def tearDown(self): super().tearDown() TransitionDomain.objects.all().delete() @@ -43,49 +46,57 @@ class TestLogins(TestCase): f"{self.test_data_file_location}/{self.test_domain_contact_filename}", f"{self.test_data_file_location}/{self.test_contact_filename}", f"{self.test_data_file_location}/{self.test_domain_status_filename}", - ) + ) def run_transfer_domains(self): call_command("transfer_transition_domains_to_domains") def run_master_script(self): command = call_command( - "master_domain_migrations", - runMigrations=True, - migrationDirectory=f"{self.test_data_file_location}", - migrationFilenames=(f"{self.test_domain_contact_filename}," - f"{self.test_contact_filename}," - f"{self.test_domain_status_filename}"), - ) + "master_domain_migrations", + runMigrations=True, + migrationDirectory=f"{self.test_data_file_location}", + migrationFilenames=( + f"{self.test_domain_contact_filename}," + f"{self.test_contact_filename}," + f"{self.test_domain_status_filename}" + ), + ) - def compare_tables(self, - expected_total_transition_domains, - expected_total_domains, - expected_total_domain_informations, - expected_total_domain_invitations, - expected_missing_domains, - expected_duplicate_domains, - expected_missing_domain_informations, - expected_missing_domain_invitations): - """Does a diff between the transition_domain and the following tables: - domain, domain_information and the domain_invitation. + def compare_tables( + self, + expected_total_transition_domains, + expected_total_domains, + expected_total_domain_informations, + expected_total_domain_invitations, + expected_missing_domains, + expected_duplicate_domains, + expected_missing_domain_informations, + expected_missing_domain_invitations, + ): + """Does a diff between the transition_domain and the following tables: + domain, domain_information and the domain_invitation. Verifies that the data loaded correctly.""" missing_domains = [] duplicate_domains = [] missing_domain_informations = [] missing_domain_invites = [] - for transition_domain in TransitionDomain.objects.all():# DEBUG: + for transition_domain in TransitionDomain.objects.all(): # DEBUG: transition_domain_name = transition_domain.domain_name transition_domain_email = transition_domain.username # Check Domain table matching_domains = Domain.objects.filter(name=transition_domain_name) # Check Domain Information table - matching_domain_informations = DomainInformation.objects.filter(domain__name=transition_domain_name) + matching_domain_informations = DomainInformation.objects.filter( + domain__name=transition_domain_name + ) # Check Domain Invitation table - matching_domain_invitations = DomainInvitation.objects.filter(email=transition_domain_email.lower(), - domain__name=transition_domain_name) + matching_domain_invitations = DomainInvitation.objects.filter( + email=transition_domain_email.lower(), + domain__name=transition_domain_name, + ) if len(matching_domains) == 0: missing_domains.append(transition_domain_name) @@ -106,7 +117,8 @@ class TestLogins(TestCase): total_domain_informations = len(DomainInformation.objects.all()) total_domain_invitations = len(DomainInvitation.objects.all()) - print(f""" + print( + f""" total_missing_domains = {len(missing_domains)} total_duplicate_domains = {len(duplicate_domains)} total_missing_domain_informations = {len(missing_domain_informations)} @@ -116,26 +128,30 @@ class TestLogins(TestCase): total_domains = {len(Domain.objects.all())} total_domain_informations = {len(DomainInformation.objects.all())} total_domain_invitations = {len(DomainInvitation.objects.all())} - """) + """ + ) self.assertTrue(total_missing_domains == expected_missing_domains) self.assertTrue(total_duplicate_domains == expected_duplicate_domains) - self.assertTrue(total_missing_domain_informations == expected_missing_domain_informations) - self.assertTrue(total_missing_domain_invitations == expected_missing_domain_invitations) + self.assertTrue( + total_missing_domain_informations == expected_missing_domain_informations + ) + self.assertTrue( + total_missing_domain_invitations == expected_missing_domain_invitations + ) self.assertTrue(total_transition_domains == expected_total_transition_domains) self.assertTrue(total_domains == expected_total_domains) self.assertTrue(total_domain_informations == expected_total_domain_informations) self.assertTrue(total_domain_invitations == expected_total_domain_invitations) - - + def test_master_migration_functions(self): - """ Run the full master migration script using local test data. - NOTE: This is more of an integration test and so far does not - follow best practice of limiting the number of assertions per test. - But for now, this will double-check that the script - works as intended. """ - + """Run the full master migration script using local test data. + NOTE: This is more of an integration test and so far does not + follow best practice of limiting the number of assertions per test. + But for now, this will double-check that the script + works as intended.""" + self.run_master_script() # # TODO: instead of patching....there has got to be a way of making sure subsequent commands use the django database @@ -162,22 +178,22 @@ class TestLogins(TestCase): expected_missing_domains = 0 expected_duplicate_domains = 0 - # we expect 8 missing domain invites since the migration does not auto-login new users + # we expect 8 missing domain invites since the migration does not auto-login new users expected_missing_domain_informations = 8 # we expect 1 missing invite from anomaly.gov (an injected error) expected_missing_domain_invitations = 1 - self.compare_tables(expected_total_transition_domains, - expected_total_domains, - expected_total_domain_informations, - expected_total_domain_invitations, - expected_missing_domains, - expected_duplicate_domains, - expected_missing_domain_informations, - expected_missing_domain_invitations, - ) - + self.compare_tables( + expected_total_transition_domains, + expected_total_domains, + expected_total_domain_informations, + expected_total_domain_invitations, + expected_missing_domains, + expected_duplicate_domains, + expected_missing_domain_informations, + expected_missing_domain_invitations, + ) + def test_load_transition_domain(self): - self.run_load_domains() # STEP 2: (analyze the tables just like the migration script does, but add assert statements) @@ -190,18 +206,18 @@ class TestLogins(TestCase): expected_duplicate_domains = 0 expected_missing_domain_informations = 8 expected_missing_domain_invitations = 8 - self.compare_tables(expected_total_transition_domains, - expected_total_domains, - expected_total_domain_informations, - expected_total_domain_invitations, - expected_missing_domains, - expected_duplicate_domains, - expected_missing_domain_informations, - expected_missing_domain_invitations, - ) - + self.compare_tables( + expected_total_transition_domains, + expected_total_domains, + expected_total_domain_informations, + expected_total_domain_invitations, + expected_missing_domains, + expected_duplicate_domains, + expected_missing_domain_informations, + expected_missing_domain_invitations, + ) + def test_transfer_transition_domains_to_domains(self): - # TODO: setup manually instead of calling other script self.run_load_domains() self.run_transfer_domains() @@ -216,28 +232,30 @@ class TestLogins(TestCase): expected_duplicate_domains = 0 expected_missing_domain_informations = 8 expected_missing_domain_invitations = 1 - self.compare_tables(expected_total_transition_domains, - expected_total_domains, - expected_total_domain_informations, - expected_total_domain_invitations, - expected_missing_domains, - expected_duplicate_domains, - expected_missing_domain_informations, - expected_missing_domain_invitations, - ) - + self.compare_tables( + expected_total_transition_domains, + expected_total_domains, + expected_total_domain_informations, + expected_total_domain_invitations, + expected_missing_domains, + expected_duplicate_domains, + expected_missing_domain_informations, + expected_missing_domain_invitations, + ) def test_logins(self): - # TODO: setup manually instead of calling other scripts + # TODO: setup manually instead of calling other scripts self.run_load_domains() self.run_transfer_domains() - + # Simluate Logins for invite in DomainInvitation.objects.all(): # get a user with this email address - user, user_created = User.objects.get_or_create(email=invite.email, username=invite.email) + user, user_created = User.objects.get_or_create( + email=invite.email, username=invite.email + ) user.first_login() - + # Analyze the tables expected_total_transition_domains = 8 expected_total_domains = 4 @@ -248,12 +266,13 @@ class TestLogins(TestCase): expected_duplicate_domains = 0 expected_missing_domain_informations = 1 expected_missing_domain_invitations = 1 - self.compare_tables(expected_total_transition_domains, - expected_total_domains, - expected_total_domain_informations, - expected_total_domain_invitations, - expected_missing_domains, - expected_duplicate_domains, - expected_missing_domain_informations, - expected_missing_domain_invitations, - ) \ No newline at end of file + self.compare_tables( + expected_total_transition_domains, + expected_total_domains, + expected_total_domain_informations, + expected_total_domain_invitations, + expected_missing_domains, + expected_duplicate_domains, + expected_missing_domain_informations, + expected_missing_domain_invitations, + )