From 8fbded1c0ab108a9b323f9de99f1eb3566e75a7d Mon Sep 17 00:00:00 2001 From: David Kennedy Date: Fri, 19 Jul 2024 10:32:17 -0400 Subject: [PATCH] made some updates to test adding less_noise decorator and fixing federalagency object handling --- src/epplibwrapper/tests/test_client.py | 513 +++++++++--------- src/registrar/tests/common.py | 3 +- src/registrar/tests/test_admin.py | 4 - .../tests/test_management_scripts.py | 5 +- src/registrar/tests/test_reports.py | 2 + .../test_transition_domain_migrations.py | 16 +- 6 files changed, 272 insertions(+), 271 deletions(-) diff --git a/src/epplibwrapper/tests/test_client.py b/src/epplibwrapper/tests/test_client.py index 6c3c2a2f6..2772ab428 100644 --- a/src/epplibwrapper/tests/test_client.py +++ b/src/epplibwrapper/tests/test_client.py @@ -3,6 +3,7 @@ from dateutil.tz import tzlocal # type: ignore from unittest.mock import MagicMock, patch from pathlib import Path from django.test import TestCase +from api.tests.common import less_console_noise_decorator from gevent.exceptions import ConcurrentObjectUseError from epplibwrapper.client import EPPLibWrapper from epplibwrapper.errors import RegistryError, LoginError @@ -24,100 +25,101 @@ logger = logging.getLogger(__name__) class TestClient(TestCase): """Test the EPPlibwrapper client""" + @less_console_noise_decorator def fake_result(self, code, msg): """Helper function to create a fake Result object""" - with less_console_noise(): - return Result(code=code, msg=msg, res_data=[], cl_tr_id="cl_tr_id", sv_tr_id="sv_tr_id") + return Result(code=code, msg=msg, res_data=[], cl_tr_id="cl_tr_id", sv_tr_id="sv_tr_id") + @less_console_noise_decorator @patch("epplibwrapper.client.Client") def test_initialize_client_success(self, mock_client): """Test when the initialize_client is successful""" - with less_console_noise(): - # Mock the Client instance and its methods - mock_connect = MagicMock() - # Create a mock Result instance - mock_result = MagicMock(spec=Result) - mock_result.code = 200 - mock_result.msg = "Success" - mock_result.res_data = ["data1", "data2"] - mock_result.cl_tr_id = "client_id" - mock_result.sv_tr_id = "server_id" - mock_send = MagicMock(return_value=mock_result) - mock_client.return_value.connect = mock_connect - mock_client.return_value.send = mock_send + # Mock the Client instance and its methods + mock_connect = MagicMock() + # Create a mock Result instance + mock_result = MagicMock(spec=Result) + mock_result.code = 200 + mock_result.msg = "Success" + mock_result.res_data = ["data1", "data2"] + mock_result.cl_tr_id = "client_id" + mock_result.sv_tr_id = "server_id" + mock_send = MagicMock(return_value=mock_result) + mock_client.return_value.connect = mock_connect + mock_client.return_value.send = mock_send - # Create EPPLibWrapper instance and initialize client - wrapper = EPPLibWrapper() + # Create EPPLibWrapper instance and initialize client + wrapper = EPPLibWrapper() - # Assert that connect method is called once - mock_connect.assert_called_once() - # Assert that _client is not None after initialization - self.assertIsNotNone(wrapper._client) + # Assert that connect method is called once + mock_connect.assert_called_once() + # Assert that _client is not None after initialization + self.assertIsNotNone(wrapper._client) + @less_console_noise_decorator @patch("epplibwrapper.client.Client") def test_initialize_client_transport_error(self, mock_client): """Test when the send(login) step of initialize_client raises a TransportError.""" - with less_console_noise(): - # Mock the Client instance and its methods - mock_connect = MagicMock() - mock_send = MagicMock(side_effect=TransportError("Transport error")) - mock_client.return_value.connect = mock_connect - mock_client.return_value.send = mock_send + # Mock the Client instance and its methods + mock_connect = MagicMock() + mock_send = MagicMock(side_effect=TransportError("Transport error")) + mock_client.return_value.connect = mock_connect + mock_client.return_value.send = mock_send - with self.assertRaises(RegistryError): - # Create EPPLibWrapper instance and initialize client - # if functioning as expected, initial __init__ should except - # and log any Exception raised - wrapper = EPPLibWrapper() - # so call _initialize_client a second time directly to test - # the raised exception - wrapper._initialize_client() + with self.assertRaises(RegistryError): + # Create EPPLibWrapper instance and initialize client + # if functioning as expected, initial __init__ should except + # and log any Exception raised + wrapper = EPPLibWrapper() + # so call _initialize_client a second time directly to test + # the raised exception + wrapper._initialize_client() + @less_console_noise_decorator @patch("epplibwrapper.client.Client") def test_initialize_client_login_error(self, mock_client): """Test when the send(login) step of initialize_client returns (2400) comamnd failed code.""" - with less_console_noise(): - # Mock the Client instance and its methods - mock_connect = MagicMock() - # Create a mock Result instance - mock_result = MagicMock(spec=Result) - mock_result.code = 2400 - mock_result.msg = "Login failed" - mock_result.res_data = ["data1", "data2"] - mock_result.cl_tr_id = "client_id" - mock_result.sv_tr_id = "server_id" - mock_send = MagicMock(return_value=mock_result) - mock_client.return_value.connect = mock_connect - mock_client.return_value.send = mock_send + # Mock the Client instance and its methods + mock_connect = MagicMock() + # Create a mock Result instance + mock_result = MagicMock(spec=Result) + mock_result.code = 2400 + mock_result.msg = "Login failed" + mock_result.res_data = ["data1", "data2"] + mock_result.cl_tr_id = "client_id" + mock_result.sv_tr_id = "server_id" + mock_send = MagicMock(return_value=mock_result) + mock_client.return_value.connect = mock_connect + mock_client.return_value.send = mock_send - with self.assertRaises(LoginError): - # Create EPPLibWrapper instance and initialize client - # if functioning as expected, initial __init__ should except - # and log any Exception raised - wrapper = EPPLibWrapper() - # so call _initialize_client a second time directly to test - # the raised exception - wrapper._initialize_client() + with self.assertRaises(LoginError): + # Create EPPLibWrapper instance and initialize client + # if functioning as expected, initial __init__ should except + # and log any Exception raised + wrapper = EPPLibWrapper() + # so call _initialize_client a second time directly to test + # the raised exception + wrapper._initialize_client() + @less_console_noise_decorator @patch("epplibwrapper.client.Client") def test_initialize_client_unknown_exception(self, mock_client): """Test when the send(login) step of initialize_client raises an unexpected Exception.""" - with less_console_noise(): - # Mock the Client instance and its methods - mock_connect = MagicMock() - mock_send = MagicMock(side_effect=Exception("Unknown exception")) - mock_client.return_value.connect = mock_connect - mock_client.return_value.send = mock_send + # Mock the Client instance and its methods + mock_connect = MagicMock() + mock_send = MagicMock(side_effect=Exception("Unknown exception")) + mock_client.return_value.connect = mock_connect + mock_client.return_value.send = mock_send - with self.assertRaises(RegistryError): - # Create EPPLibWrapper instance and initialize client - # if functioning as expected, initial __init__ should except - # and log any Exception raised - wrapper = EPPLibWrapper() - # so call _initialize_client a second time directly to test - # the raised exception - wrapper._initialize_client() + with self.assertRaises(RegistryError): + # Create EPPLibWrapper instance and initialize client + # if functioning as expected, initial __init__ should except + # and log any Exception raised + wrapper = EPPLibWrapper() + # so call _initialize_client a second time directly to test + # the raised exception + wrapper._initialize_client() + @less_console_noise_decorator @patch("epplibwrapper.client.Client") def test_initialize_client_fails_recovers_with_send_command(self, mock_client): """Test when the initialize_client fails on the connect() step. And then a subsequent @@ -127,56 +129,56 @@ class TestClient(TestCase): Initialization step fails at app init Send command fails (with 2400 code) prompting retry Client closes and re-initializes, and command is sent successfully""" - with less_console_noise(): - # Mock the Client instance and its methods - # close() should return successfully - mock_close = MagicMock() - mock_client.return_value.close = mock_close - # Create success and failure results - command_success_result = self.fake_result(1000, "Command completed successfully") - command_failure_result = self.fake_result(2400, "Command failed") - # side_effect for the connect() calls - # first connect() should raise an Exception - # subsequent connect() calls should return success - connect_call_count = 0 + # Mock the Client instance and its methods + # close() should return successfully + mock_close = MagicMock() + mock_client.return_value.close = mock_close + # Create success and failure results + command_success_result = self.fake_result(1000, "Command completed successfully") + command_failure_result = self.fake_result(2400, "Command failed") + # side_effect for the connect() calls + # first connect() should raise an Exception + # subsequent connect() calls should return success + connect_call_count = 0 - def connect_side_effect(*args, **kwargs): - nonlocal connect_call_count - connect_call_count += 1 - if connect_call_count == 1: - raise Exception("Connection failed") - else: - return command_success_result + def connect_side_effect(*args, **kwargs): + nonlocal connect_call_count + connect_call_count += 1 + if connect_call_count == 1: + raise Exception("Connection failed") + else: + return command_success_result - mock_connect = MagicMock(side_effect=connect_side_effect) - mock_client.return_value.connect = mock_connect - # side_effect for the send() calls - # first send will be the send("InfoDomainCommand") and should fail - # subsequend send() calls should return success - send_call_count = 0 + mock_connect = MagicMock(side_effect=connect_side_effect) + mock_client.return_value.connect = mock_connect + # side_effect for the send() calls + # first send will be the send("InfoDomainCommand") and should fail + # subsequend send() calls should return success + send_call_count = 0 - def send_side_effect(*args, **kwargs): - nonlocal send_call_count - send_call_count += 1 - if send_call_count == 1: - return command_failure_result - else: - return command_success_result + def send_side_effect(*args, **kwargs): + nonlocal send_call_count + send_call_count += 1 + if send_call_count == 1: + return command_failure_result + else: + return command_success_result - mock_send = MagicMock(side_effect=send_side_effect) - mock_client.return_value.send = mock_send - # Create EPPLibWrapper instance and call send command - wrapper = EPPLibWrapper() - wrapper.send("InfoDomainCommand", cleaned=True) - # two connect() calls should be made, the initial failed connect() - # and the successful connect() during retry() - self.assertEquals(mock_connect.call_count, 2) - # close() should only be called once, during retry() - mock_close.assert_called_once() - # send called 4 times: failed send("InfoDomainCommand"), passed send(logout), - # passed send(login), passed send("InfoDomainCommand") - self.assertEquals(mock_send.call_count, 4) + mock_send = MagicMock(side_effect=send_side_effect) + mock_client.return_value.send = mock_send + # Create EPPLibWrapper instance and call send command + wrapper = EPPLibWrapper() + wrapper.send("InfoDomainCommand", cleaned=True) + # two connect() calls should be made, the initial failed connect() + # and the successful connect() during retry() + self.assertEquals(mock_connect.call_count, 2) + # close() should only be called once, during retry() + mock_close.assert_called_once() + # send called 4 times: failed send("InfoDomainCommand"), passed send(logout), + # passed send(login), passed send("InfoDomainCommand") + self.assertEquals(mock_send.call_count, 4) + @less_console_noise_decorator @patch("epplibwrapper.client.Client") def test_send_command_failed_retries_and_fails_again(self, mock_client): """Test when the send("InfoDomainCommand) call fails with a 2400, prompting a retry @@ -186,42 +188,42 @@ class TestClient(TestCase): Initialization succeeds Send command fails (with 2400 code) prompting retry Client closes and re-initializes, and command fails again with 2400""" - with less_console_noise(): - # Mock the Client instance and its methods - # connect() and close() should succeed throughout - mock_connect = MagicMock() - mock_close = MagicMock() - # Create a mock Result instance - send_command_success_result = self.fake_result(1000, "Command completed successfully") - send_command_failure_result = self.fake_result(2400, "Command failed") + # Mock the Client instance and its methods + # connect() and close() should succeed throughout + mock_connect = MagicMock() + mock_close = MagicMock() + # Create a mock Result instance + send_command_success_result = self.fake_result(1000, "Command completed successfully") + send_command_failure_result = self.fake_result(2400, "Command failed") - # side_effect for send command, passes for all other sends (login, logout), but - # fails for send("InfoDomainCommand") - def side_effect(*args, **kwargs): - if args[0] == "InfoDomainCommand": - return send_command_failure_result - else: - return send_command_success_result + # side_effect for send command, passes for all other sends (login, logout), but + # fails for send("InfoDomainCommand") + def side_effect(*args, **kwargs): + if args[0] == "InfoDomainCommand": + return send_command_failure_result + else: + return send_command_success_result - mock_send = MagicMock(side_effect=side_effect) - mock_client.return_value.connect = mock_connect - mock_client.return_value.close = mock_close - mock_client.return_value.send = mock_send + mock_send = MagicMock(side_effect=side_effect) + mock_client.return_value.connect = mock_connect + mock_client.return_value.close = mock_close + mock_client.return_value.send = mock_send - with self.assertRaises(RegistryError): - # Create EPPLibWrapper instance and initialize client - wrapper = EPPLibWrapper() - # call send, which should throw a RegistryError (after retry) - wrapper.send("InfoDomainCommand", cleaned=True) - # connect() should be called twice, once during initialization, second time - # during retry - self.assertEquals(mock_connect.call_count, 2) - # close() is called once during retry - mock_close.assert_called_once() - # send() is called 5 times: send(login), send(command) fails, send(logout) - # send(login), send(command) - self.assertEquals(mock_send.call_count, 5) + with self.assertRaises(RegistryError): + # Create EPPLibWrapper instance and initialize client + wrapper = EPPLibWrapper() + # call send, which should throw a RegistryError (after retry) + wrapper.send("InfoDomainCommand", cleaned=True) + # connect() should be called twice, once during initialization, second time + # during retry + self.assertEquals(mock_connect.call_count, 2) + # close() is called once during retry + mock_close.assert_called_once() + # send() is called 5 times: send(login), send(command) fails, send(logout) + # send(login), send(command) + self.assertEquals(mock_send.call_count, 5) + @less_console_noise_decorator @patch("epplibwrapper.client.Client") def test_send_command_failure_prompts_successful_retry(self, mock_client): """Test when the send("InfoDomainCommand) call fails with a 2400, prompting a retry @@ -230,48 +232,47 @@ class TestClient(TestCase): Initialization succeeds Send command fails (with 2400 code) prompting retry Client closes and re-initializes, and command succeeds""" - with less_console_noise(): - # Mock the Client instance and its methods - # connect() and close() should succeed throughout - mock_connect = MagicMock() - mock_close = MagicMock() - # create success and failure result messages - send_command_success_result = self.fake_result(1000, "Command completed successfully") - send_command_failure_result = self.fake_result(2400, "Command failed") - # side_effect for send call, initial send(login) succeeds during initialization, next send(command) - # fails, subsequent sends (logout, login, command) all succeed - send_call_count = 0 + # Mock the Client instance and its methods + # connect() and close() should succeed throughout + mock_connect = MagicMock() + mock_close = MagicMock() + # create success and failure result messages + send_command_success_result = self.fake_result(1000, "Command completed successfully") + send_command_failure_result = self.fake_result(2400, "Command failed") + # side_effect for send call, initial send(login) succeeds during initialization, next send(command) + # fails, subsequent sends (logout, login, command) all succeed + send_call_count = 0 - def side_effect(*args, **kwargs): - nonlocal send_call_count - send_call_count += 1 - if send_call_count == 2: - return send_command_failure_result - else: - return send_command_success_result + def side_effect(*args, **kwargs): + nonlocal send_call_count + send_call_count += 1 + if send_call_count == 2: + return send_command_failure_result + else: + return send_command_success_result - mock_send = MagicMock(side_effect=side_effect) - mock_client.return_value.connect = mock_connect - mock_client.return_value.close = mock_close - mock_client.return_value.send = mock_send - # Create EPPLibWrapper instance and initialize client - wrapper = EPPLibWrapper() - wrapper.send("InfoDomainCommand", cleaned=True) - # connect() is called twice, once during initialization of app, once during retry - self.assertEquals(mock_connect.call_count, 2) - # close() is called once, during retry - mock_close.assert_called_once() - # send() is called 5 times: send(login), send(command) fail, send(logout), send(login), send(command) - self.assertEquals(mock_send.call_count, 5) + mock_send = MagicMock(side_effect=side_effect) + mock_client.return_value.connect = mock_connect + mock_client.return_value.close = mock_close + mock_client.return_value.send = mock_send + # Create EPPLibWrapper instance and initialize client + wrapper = EPPLibWrapper() + wrapper.send("InfoDomainCommand", cleaned=True) + # connect() is called twice, once during initialization of app, once during retry + self.assertEquals(mock_connect.call_count, 2) + # close() is called once, during retry + mock_close.assert_called_once() + # send() is called 5 times: send(login), send(command) fail, send(logout), send(login), send(command) + self.assertEquals(mock_send.call_count, 5) + @less_console_noise_decorator def fake_failure_send_concurrent_threads(self, command=None, cleaned=None): """ Raises a ConcurrentObjectUseError, which gevent throws when accessing the same thread from two different locations. """ - with less_console_noise(): - # This error is thrown when two threads are being used concurrently - raise ConcurrentObjectUseError("This socket is already used by another greenlet") + # This error is thrown when two threads are being used concurrently + raise ConcurrentObjectUseError("This socket is already used by another greenlet") def do_nothing(self, command=None): """ @@ -279,70 +280,71 @@ class TestClient(TestCase): """ pass # noqa + @less_console_noise_decorator def fake_success_send(self, command=None, cleaned=None): """ Simulates receiving a success response from EPP. """ - with less_console_noise(): - mock = MagicMock( - code=1000, - msg="Command completed successfully", - res_data=None, - cl_tr_id="xkw1uo#2023-10-17T15:29:09.559376", - sv_tr_id="5CcH4gxISuGkq8eqvr1UyQ==-35a", - extensions=[], - msg_q=None, - ) - return mock + mock = MagicMock( + code=1000, + msg="Command completed successfully", + res_data=None, + cl_tr_id="xkw1uo#2023-10-17T15:29:09.559376", + sv_tr_id="5CcH4gxISuGkq8eqvr1UyQ==-35a", + extensions=[], + msg_q=None, + ) + return mock + @less_console_noise_decorator def fake_info_domain_received(self, command=None, cleaned=None): """ Simulates receiving a response by reading from a predefined XML file. """ - with less_console_noise(): - location = Path(__file__).parent / "utility" / "infoDomain.xml" - xml = (location).read_bytes() - return xml + location = Path(__file__).parent / "utility" / "infoDomain.xml" + xml = (location).read_bytes() + return xml + @less_console_noise_decorator def get_fake_epp_result(self): """Mimics a return from EPP by returning a dictionary in the same format""" - with less_console_noise(): - result = { - "cl_tr_id": None, - "code": 1000, - "extensions": [], - "msg": "Command completed successfully", - "msg_q": None, - "res_data": [ - info.InfoDomainResultData( - roid="DF1340360-GOV", - statuses=[ - common.Status( - state="serverTransferProhibited", - description=None, - lang="en", - ), - common.Status(state="inactive", description=None, lang="en"), - ], - cl_id="gov2023-ote", - cr_id="gov2023-ote", - cr_date=datetime.datetime(2023, 8, 15, 23, 56, 36, tzinfo=tzlocal()), - up_id="gov2023-ote", - up_date=datetime.datetime(2023, 8, 17, 2, 3, 19, tzinfo=tzlocal()), - tr_date=None, - name="test3.gov", - registrant="TuaWnx9hnm84GCSU", - admins=[], - nsset=None, - keyset=None, - ex_date=datetime.date(2024, 8, 15), - auth_info=info.DomainAuthInfo(pw="2fooBAR123fooBaz"), - ) - ], - "sv_tr_id": "wRRNVhKhQW2m6wsUHbo/lA==-29a", - } - return result + result = { + "cl_tr_id": None, + "code": 1000, + "extensions": [], + "msg": "Command completed successfully", + "msg_q": None, + "res_data": [ + info.InfoDomainResultData( + roid="DF1340360-GOV", + statuses=[ + common.Status( + state="serverTransferProhibited", + description=None, + lang="en", + ), + common.Status(state="inactive", description=None, lang="en"), + ], + cl_id="gov2023-ote", + cr_id="gov2023-ote", + cr_date=datetime.datetime(2023, 8, 15, 23, 56, 36, tzinfo=tzlocal()), + up_id="gov2023-ote", + up_date=datetime.datetime(2023, 8, 17, 2, 3, 19, tzinfo=tzlocal()), + tr_date=None, + name="test3.gov", + registrant="TuaWnx9hnm84GCSU", + admins=[], + nsset=None, + keyset=None, + ex_date=datetime.date(2024, 8, 15), + auth_info=info.DomainAuthInfo(pw="2fooBAR123fooBaz"), + ) + ], + "sv_tr_id": "wRRNVhKhQW2m6wsUHbo/lA==-29a", + } + return result + @less_console_noise_decorator def test_send_command_close_failure_recovers(self): """ Validates the resilience of the connection handling mechanism @@ -355,28 +357,27 @@ class TestClient(TestCase): - Subsequently, the client re-initializes the connection. - A retry of the command execution post-reinitialization succeeds. """ - with less_console_noise(): - expected_result = self.get_fake_epp_result() - wrapper = None - # Trigger a retry - # Do nothing on connect, as we aren't testing it and want to connect while - # mimicking the rest of the client as closely as possible (which is not entirely possible with MagicMock) - with patch.object(EPPLibWrapper, "_connect", self.do_nothing): - with patch.object(SocketTransport, "send", self.fake_failure_send_concurrent_threads): - wrapper = EPPLibWrapper() - tested_command = commands.InfoDomain(name="test.gov") - try: - wrapper.send(tested_command, cleaned=True) - except RegistryError as err: - expected_error = "InfoDomain failed to execute due to an unknown error." - self.assertEqual(err.args[0], expected_error) - else: - self.fail("Registry error was not thrown") + expected_result = self.get_fake_epp_result() + wrapper = None + # Trigger a retry + # Do nothing on connect, as we aren't testing it and want to connect while + # mimicking the rest of the client as closely as possible (which is not entirely possible with MagicMock) + with patch.object(EPPLibWrapper, "_connect", self.do_nothing): + with patch.object(SocketTransport, "send", self.fake_failure_send_concurrent_threads): + wrapper = EPPLibWrapper() + tested_command = commands.InfoDomain(name="test.gov") + try: + wrapper.send(tested_command, cleaned=True) + except RegistryError as err: + expected_error = "InfoDomain failed to execute due to an unknown error." + self.assertEqual(err.args[0], expected_error) + else: + self.fail("Registry error was not thrown") - # After a retry, try sending again to see if the connection recovers - with patch.object(EPPLibWrapper, "_connect", self.do_nothing): - with patch.object(SocketTransport, "send", self.fake_success_send), patch.object( - SocketTransport, "receive", self.fake_info_domain_received - ): - result = wrapper.send(tested_command, cleaned=True) - self.assertEqual(expected_result, result.__dict__) + # After a retry, try sending again to see if the connection recovers + with patch.object(EPPLibWrapper, "_connect", self.do_nothing): + with patch.object(SocketTransport, "send", self.fake_success_send), patch.object( + SocketTransport, "receive", self.fake_info_domain_received + ): + result = wrapper.send(tested_command, cleaned=True) + self.assertEqual(expected_result, result.__dict__) diff --git a/src/registrar/tests/common.py b/src/registrar/tests/common.py index d2e4c31bc..0d46b2e13 100644 --- a/src/registrar/tests/common.py +++ b/src/registrar/tests/common.py @@ -793,7 +793,8 @@ class MockDb(TestCase): User.objects.all().delete() UserDomainRole.objects.all().delete() DomainInvitation.objects.all().delete() - FederalAgency.objects.all().delete() + cls.federal_agency_1.delete() + cls.federal_agency_2.delete() class MockDbForSharedTests(MockDb): diff --git a/src/registrar/tests/test_admin.py b/src/registrar/tests/test_admin.py index b591f14f8..1ca02aec0 100644 --- a/src/registrar/tests/test_admin.py +++ b/src/registrar/tests/test_admin.py @@ -1909,10 +1909,6 @@ class TestFederalAgency(TestCase): def setUp(self): self.client = Client(HTTP_HOST="localhost:8080") - def tearDown(self): - super().tearDown() - FederalAgency.objects.all().delete() - @classmethod def tearDownClass(cls): super().tearDownClass() diff --git a/src/registrar/tests/test_management_scripts.py b/src/registrar/tests/test_management_scripts.py index 9ff1dbe04..c54b29f6a 100644 --- a/src/registrar/tests/test_management_scripts.py +++ b/src/registrar/tests/test_management_scripts.py @@ -1184,7 +1184,10 @@ class TestTransferFederalAgencyType(TestCase): User.objects.all().delete() Contact.objects.all().delete() Website.objects.all().delete() - FederalAgency.objects.all().delete() + self.amtrak.delete() + self.legislative_branch.delete() + self.library_of_congress.delete() + self.gov_admin.delete() def run_transfer_federal_agency_type(self): """ diff --git a/src/registrar/tests/test_reports.py b/src/registrar/tests/test_reports.py index e3f13d85f..bc96a7085 100644 --- a/src/registrar/tests/test_reports.py +++ b/src/registrar/tests/test_reports.py @@ -252,6 +252,7 @@ class ExportDataTest(MockDbForIndividualTests, MockEppLib): # spaces and leading/trailing whitespace csv_content = csv_content.replace(",,", "").replace(",", "").replace(" ", "").replace("\r\n", "\n").strip() expected_content = expected_content.replace(",,", "").replace(",", "").replace(" ", "").strip() + self.maxDiff = None self.assertEqual(csv_content, expected_content) @less_console_noise_decorator @@ -432,6 +433,7 @@ class ExportDataTest(MockDbForIndividualTests, MockEppLib): # spaces and leading/trailing whitespace csv_content = csv_content.replace(",,", "").replace(",", "").replace(" ", "").replace("\r\n", "\n").strip() expected_content = expected_content.replace(",,", "").replace(",", "").replace(" ", "").strip() + self.maxDiff = None self.assertEqual(csv_content, expected_content) @less_console_noise_decorator diff --git a/src/registrar/tests/test_transition_domain_migrations.py b/src/registrar/tests/test_transition_domain_migrations.py index c7f916976..b674dedcd 100644 --- a/src/registrar/tests/test_transition_domain_migrations.py +++ b/src/registrar/tests/test_transition_domain_migrations.py @@ -43,7 +43,6 @@ class TestProcessedMigrations(TestCase): DomainInformation.objects.all().delete() DomainInvitation.objects.all().delete() TransitionDomain.objects.all().delete() - FederalAgency.objects.all().delete() # Delete users User.objects.all().delete() @@ -185,6 +184,7 @@ class TestOrganizationMigration(TestCase): """Defines the file name of migration_json and the folder its contained in""" self.test_data_file_location = "registrar/tests/data" self.migration_json_filename = "test_migrationFilepaths.json" + self.federal_agency, _ = FederalAgency.objects.get_or_create(agency="Department of Commerce") def tearDown(self): """Deletes all DB objects related to migrations""" @@ -197,6 +197,7 @@ class TestOrganizationMigration(TestCase): # Delete users User.objects.all().delete() UserDomainRole.objects.all().delete() + self.federal_agency.delete() def run_load_domains(self): """ @@ -331,7 +332,6 @@ class TestOrganizationMigration(TestCase): # Lets test the first one transition = transition_domains.first() - federal_agency, _ = FederalAgency.objects.get_or_create(agency="Department of Commerce") expected_transition_domain = TransitionDomain( username="alexandra.bobbitt5@test.com", domain_name="fakewebsite2.gov", @@ -340,7 +340,7 @@ class TestOrganizationMigration(TestCase): generic_org_type="Federal", organization_name="Fanoodle", federal_type="Executive", - federal_agency=federal_agency, + federal_agency=self.federal_agency, epp_creation_date=datetime.date(2004, 5, 7), epp_expiration_date=datetime.date(2023, 9, 30), first_name="Seline", @@ -395,8 +395,7 @@ class TestOrganizationMigration(TestCase): # == Third, test that we've loaded data as we expect == # _domain = Domain.objects.filter(name="fakewebsite2.gov").get() domain_information = DomainInformation.objects.filter(domain=_domain).get() - federal_agency, _ = FederalAgency.objects.get_or_create(agency="Department of Commerce") - + expected_creator = User.objects.filter(username="System").get() expected_so = Contact.objects.filter( first_name="Seline", middle_name="testmiddle2", last_name="Tower" @@ -404,7 +403,7 @@ class TestOrganizationMigration(TestCase): expected_domain_information = DomainInformation( creator=expected_creator, generic_org_type="federal", - federal_agency=federal_agency, + federal_agency=self.federal_agency, federal_type="executive", organization_name="Fanoodle", address_line1="93001 Arizona Drive", @@ -451,8 +450,7 @@ class TestOrganizationMigration(TestCase): # == Fourth, test that no data is overwritten as we expect == # _domain = Domain.objects.filter(name="fakewebsite2.gov").get() domain_information = DomainInformation.objects.filter(domain=_domain).get() - federal_agency, _ = FederalAgency.objects.get_or_create(agency="Department of Commerce") - + expected_creator = User.objects.filter(username="System").get() expected_so = Contact.objects.filter( first_name="Seline", middle_name="testmiddle2", last_name="Tower" @@ -460,7 +458,7 @@ class TestOrganizationMigration(TestCase): expected_domain_information = DomainInformation( creator=expected_creator, generic_org_type="federal", - federal_agency=federal_agency, + federal_agency=self.federal_agency, federal_type="executive", organization_name="Fanoodle", address_line1="93001 Galactic Way",