def test_selecting_two_servers(self):
entry = DomainServerConnectionFactory()
entry.static_server = ServerHistoryFactory()
entry.transient_server = TransientServerFactory()
with self.assertRaises(IntegrityError):
entry.save()
def test_valid_data(self):
checkout = ServerHistoryFactory(client=self.project.client,
project=self.project,
server=self.server)
form = self.form_data(**checkout.__dict__)
self.assertTrue(form.is_valid())
def test_unavailable_server(self):
checkout = ServerHistoryFactory(
client=self.project.client,
project=self.project,
server=self.unavailable_server,
)
form = self.form_data(**checkout.__dict__)
errors = form["server"].errors.as_data()
self.assertEqual(len(errors), 1)
self.assertEqual(errors[0].code, "unavailable")
def setUpTestData(cls):
cls.project = ProjectFactory()
cls.domain = HistoryFactory(project=cls.project)
cls.server = ServerHistoryFactory(project=cls.project)
cls.vps = TransientServerFactory(project=cls.project)
cls.link = DomainServerConnectionFactory(
project=cls.project,
domain=cls.domain,
static_server=cls.server,
transient_server=None,
)
cls.link_dict = cls.link.__dict__
def test_property_server_name(self):
entry = ServerHistoryFactory(server=StaticServerFactory(
name="teamserver.local"))
try:
self.assertEqual(entry.server_name, "teamserver.local")
entry.server.name = "new-server.local"
entry.server.save()
self.assertEqual(entry.server_name, "new-server.local")
except Exception:
self.fail(
"ServerHistory model `server_name` property failed unexpectedly!"
)
def test_property_ip_address(self):
entry = ServerHistoryFactory(server=StaticServerFactory(
ip_address="192.168.1.100"))
try:
self.assertEqual(entry.ip_address, "192.168.1.100")
entry.server.ip_address = "192.168.2.200"
entry.server.save()
self.assertEqual(entry.ip_address, "192.168.2.200")
except Exception:
self.fail(
"ServerHistory model `ip_address` property failed unexpectedly!"
)
def test_invalid_dates(self):
end_date = date.today()
start_date = date.today() + timedelta(days=20)
checkout = ServerHistoryFactory(
client=self.project.client,
project=self.project,
server=self.server,
start_date=start_date,
end_date=end_date,
)
form = self.form_data(**checkout.__dict__)
errors = form["end_date"].errors.as_data()
self.assertEqual(len(errors), 1)
self.assertEqual(errors[0].code, "invalid")
def test_method_will_be_released(self):
start_date = date.today() - timedelta(days=20)
end_date = date.today() + timedelta(days=7)
entry = ServerHistoryFactory(start_date=start_date, end_date=end_date)
try:
self.assertEqual(False, entry.will_be_released())
entry.end_date = date.today()
entry.save()
self.assertEqual(True, entry.will_be_released())
except Exception:
self.fail(
"ServerHistory model `will_be_released` method failed unexpectedly!"
)
def test_checkout_adjustment_signal(self):
yesterday = date.today() - timedelta(days=1)
project = ProjectFactory(
start_date=date.today() - timedelta(days=14),
end_date=date.today() + timedelta(days=14),
)
domain_checkout = HistoryFactory(start_date=project.start_date,
end_date=project.end_date,
project=project)
exp_domain_checkout = HistoryFactory(start_date=project.start_date,
end_date=yesterday,
project=project)
server_checkout = ServerHistoryFactory(start_date=project.start_date,
end_date=project.end_date,
project=project)
exp_server_checkout = ServerHistoryFactory(
start_date=project.start_date, end_date=yesterday, project=project)
new_start = project.start_date - timedelta(days=7)
new_end = project.end_date + timedelta(days=7)
project.start_date = new_start
project.end_date = new_end
project.save()
domain_checkout.refresh_from_db()
exp_domain_checkout.refresh_from_db()
server_checkout.refresh_from_db()
exp_server_checkout.refresh_from_db()
self.assertEqual(domain_checkout.start_date, new_start)
self.assertEqual(server_checkout.start_date, new_start)
self.assertEqual(domain_checkout.end_date, new_end)
self.assertEqual(server_checkout.end_date, new_end)
self.assertEqual(exp_domain_checkout.end_date, yesterday)
self.assertEqual(exp_server_checkout.end_date, yesterday)
def test_delete_signal(self):
server = StaticServerFactory(server_status=self.unavailable_status)
today = date.today()
tomorrow = today + timedelta(days=1)
next_week = today + timedelta(days=7)
two_weeks = today + timedelta(days=14)
history_1 = ServerHistoryFactory(start_date=today,
end_date=tomorrow,
server=server)
history_2 = ServerHistoryFactory(start_date=next_week,
end_date=two_weeks,
server=server)
# Deleting this older checkout should not impact the server's status
history_1.delete()
server.refresh_from_db()
self.assertTrue(server.server_status == self.unavailable_status)
# Deleting this newer checkout should impact the server's status
history_2.delete()
server.refresh_from_db()
self.assertTrue(server.server_status == self.available_status)
def test_crud(self):
# Create
entry = ServerHistoryFactory(server=StaticServerFactory(
name="teamserver.local"))
# Read
self.assertEqual(entry.server.name, "teamserver.local")
self.assertEqual(entry.pk, entry.id)
self.assertQuerysetEqual(
self.ServerHistory.objects.all(),
[
f"<ServerHistory: {entry.server.ip_address} ({entry.server.name}) [{entry.activity_type}]>"
],
)
# Update
entry.end_date = date.today()
entry.save()
self.assertEqual(entry.end_date, date.today())
# Delete
entry.delete()
assert not self.ServerHistory.objects.all().exists()
def test_get_absolute_url(self):
checkout = ServerHistoryFactory()
try:
checkout.get_absolute_url()
except:
self.fail("ServerHistory.get_absolute_url() raised an exception")
