badblocks/pkmntrade.club
1
1
Fork 0
Code Issues 14 Pull requests Projects 1 Releases Packages Wiki Activity

Add initial trades tests

Browse source
This commit is contained in:
badblocks 2025-03-27 00:16:44 -07:00
parent d66ed823e0
commit 2785e0ed13
2 changed files with 477 additions and 12 deletions
Download patch file Download diff file Expand all files Collapse all files

463
trades/tests.py
View file

@ -1,3 +1,462 @@
from django.test import TestCase
from django.test import TestCase, Client
from django.urls import reverse
from django.contrib.auth import get_user_model
from django.core.exceptions import ValidationError
from django.http import QueryDict
# Create your tests here.
from accounts.models import FriendCode
from cards.models import Card
from trades.models import (
TradeOffer,
TradeOfferHaveCard,
TradeOfferWantCard,
TradeAcceptance,
)
from trades.forms import (
TradeOfferCreateForm,
TradeAcceptanceCreateForm,
TradeOfferAcceptForm,
TradeAcceptanceTransitionForm,
)
# ------------------------------------------------------------------------
# Model Tests
# ------------------------------------------------------------------------
class TradeOfferModelTest(TestCase):
def setUp(self):
User = get_user_model()
# Create a user and friend code for testing
self.user = User.objects.create_user(
username="testuser", email="test@example.com", password="password"
)
self.friend_code = FriendCode.objects.create(
friend_code="FC-1234", in_game_name="TestInGame", user=self.user
)
# Create cards with the same rarity (valid scenario)
self.card1 = Card.objects.create(
name="Card1", cardset="set1", cardnum=1, style="default", rarity_icon="R", rarity_level=1
)
self.card2 = Card.objects.create(
name="Card2", cardset="set1", cardnum=2, style="default", rarity_icon="R", rarity_level=1
)
# Create a card with a different rarity (to test invalid trade offers)
self.card3 = Card.objects.create(
name="Card3", cardset="set1", cardnum=3, style="default", rarity_icon="SR", rarity_level=2
)
# Create a valid trade offer with consistent rarity details.
self.trade_offer = TradeOffer.objects.create(initiated_by=self.friend_code)
TradeOfferHaveCard.objects.create(
trade_offer=self.trade_offer, card=self.card1, quantity=2
)
TradeOfferWantCard.objects.create(
trade_offer=self.trade_offer, card=self.card2, quantity=3
)
def test_update_rarity_fields_valid(self):
"""Test update_rarity_fields succeeds with cards sharing the same rarity."""
self.trade_offer.update_rarity_fields()
self.assertEqual(self.trade_offer.rarity_level, 1)
self.assertEqual(self.trade_offer.rarity_icon, "R")
def test_update_rarity_fields_invalid(self):
"""If a card with a different rarity is added, update_rarity_fields should raise an error."""
with self.assertRaisesMessage(
ValidationError, "All cards in a trade offer must have the same rarity."
):
TradeOfferHaveCard.objects.create(
trade_offer=self.trade_offer, card=self.card3, quantity=1
)
def test_hash_generation(self):
"""Verify that TradeOffer.hash is generated and 9 characters long ending with 'z'."""
self.assertTrue(self.trade_offer.hash.endswith("z"))
self.assertEqual(len(self.trade_offer.hash), 9)
class TradeAcceptanceModelTest(TestCase):
def setUp(self):
User = get_user_model()
# Create two users for testing state transitions
self.user = User.objects.create_user(
username="acceptuser", email="acc@example.com", password="password"
)
self.friend_code = FriendCode.objects.create(
friend_code="FC-5678", in_game_name="AccInGame", user=self.user
)
self.other_user = User.objects.create_user(
username="initiator", email="init@example.com", password="password"
)
self.initiator_friend_code = FriendCode.objects.create(
friend_code="FC-0000", in_game_name="InitInGame", user=self.other_user
)
# Create two cards (with the same rarity)
self.card1 = Card.objects.create(
name="CardA", cardset="setA", cardnum=1, style="default", rarity_icon="R", rarity_level=1
)
self.card2 = Card.objects.create(
name="CardB", cardset="setA", cardnum=2, style="default", rarity_icon="R", rarity_level=1
)
# Create a trade offer by the initiator.
self.trade_offer = TradeOffer.objects.create(
initiated_by=self.initiator_friend_code
)
TradeOfferHaveCard.objects.create(
trade_offer=self.trade_offer, card=self.card1, quantity=1
)
TradeOfferWantCard.objects.create(
trade_offer=self.trade_offer, card=self.card2, quantity=1
)
# Create an initial acceptance in state 'ACCEPTED'
self.acceptance = TradeAcceptance.objects.create(
trade_offer=self.trade_offer,
accepted_by=self.friend_code,
requested_card=self.card1,
offered_card=self.card2,
state=TradeAcceptance.AcceptanceState.ACCEPTED,
)
def test_invalid_state_transition(self):
"""
Test that an invalid state transition (not allowed by the current state)
raises a ValueError.
"""
# Attempt to transition to a state that is not allowed.
with self.assertRaises(ValueError):
self.acceptance.update_state(
TradeAcceptance.AcceptanceState.THANKED_BY_ACCEPTOR, user=self.user
)
def test_valid_state_transition_initiator(self):
"""
For a user that owns the trade offer (initiator), check that a valid
transition (e.g. from ACCEPTED to SENT) succeeds.
"""
allowed_transitions = dict(
self.acceptance.get_allowed_state_transitions(user=self.other_user)
)
# 'SENT' should be among allowed states for the initiator.
self.assertIn(TradeAcceptance.AcceptanceState.SENT, allowed_transitions)
self.acceptance.update_state(
TradeAcceptance.AcceptanceState.SENT, user=self.other_user
)
self.assertEqual(
self.acceptance.state, TradeAcceptance.AcceptanceState.SENT
)
def test_signal_adjusts_qty_accepted(self):
"""
Test that creation, state change, and deletion of a TradeAcceptance
update qty_accepted counters in through models correctly.
"""
have_through = TradeOfferHaveCard.objects.get(
trade_offer=self.trade_offer, card=self.card1
)
want_through = TradeOfferWantCard.objects.get(
trade_offer=self.trade_offer, card=self.card2
)
# Initially, one active acceptance should set qty_accepted to 1.
self.assertEqual(have_through.qty_accepted, 1)
self.assertEqual(want_through.qty_accepted, 1)
# Change state to a terminal state so that signals decrement the counter.
self.acceptance.state = TradeAcceptance.AcceptanceState.REJECTED_BY_ACCEPTOR
self.acceptance.save()
have_through.refresh_from_db()
want_through.refresh_from_db()
self.assertEqual(have_through.qty_accepted, 0)
self.assertEqual(want_through.qty_accepted, 0)
# Create a new acceptance and then delete it.
new_acceptance = TradeAcceptance.objects.create(
trade_offer=self.trade_offer,
accepted_by=self.friend_code,
requested_card=self.card1,
offered_card=self.card2,
state=TradeAcceptance.AcceptanceState.ACCEPTED,
)
have_through.refresh_from_db()
self.assertEqual(have_through.qty_accepted, 1)
new_acceptance.delete()
have_through.refresh_from_db()
self.assertEqual(have_through.qty_accepted, 0)
# ------------------------------------------------------------------------
# Form Tests
# ------------------------------------------------------------------------
class TradeOfferFormTest(TestCase):
def setUp(self):
User = get_user_model()
self.user = User.objects.create_user(
username="formuser", email="form@example.com", password="password"
)
self.friend_code = FriendCode.objects.create(
friend_code="FC-FORM", in_game_name="FormUser", user=self.user
)
# Create two cards with the same rarity details.
self.card1 = Card.objects.create(
name="FormCard1", cardset="formset", cardnum=1, style="default",
rarity_icon="R", rarity_level=1
)
self.card2 = Card.objects.create(
name="FormCard2", cardset="formset", cardnum=2, style="default",
rarity_icon="R", rarity_level=1
)
def test_trade_offer_create_form_valid(self):
"""
A valid POST using colon-separated quantity strings should succeed.
"""
# Build a QueryDict with multiple values for each list field.
qd = QueryDict('', mutable=True)
qd.setlist("have_cards", [f"{self.card1.pk}:2"])
qd.setlist("want_cards", [f"{self.card2.pk}:3"])
# 'initiated_by' is a normal field so we can update it directly.
qd.update({"initiated_by": self.friend_code.pk})
form = TradeOfferCreateForm(data=qd)
self.assertTrue(form.is_valid())
def test_trade_offer_create_form_invalid_quantity(self):
"""
If quantity cannot be parsed as an integer a ValidationError should be raised.
"""
qd = QueryDict('', mutable=True)
# Provide an invalid quantity ("two" instead of an integer).
qd.setlist("have_cards", [f"{self.card1.pk}:two"])
qd.setlist("want_cards", [f"{self.card2.pk}:3"])
qd.update({"initiated_by": self.friend_code.pk})
form = TradeOfferCreateForm(data=qd)
self.assertFalse(form.is_valid())
self.assertIn("Invalid quantity provided", str(form.errors))
def test_trade_offer_create_form_missing_colon(self):
"""
An entry missing a colon should be ignored.
"""
qd = QueryDict('', mutable=True)
# No colon present in the selections.
qd.setlist("have_cards", [f"{self.card1.pk}"])
qd.setlist("want_cards", [f"{self.card2.pk}"])
qd.update({"initiated_by": self.friend_code.pk})
form = TradeOfferCreateForm(data=qd)
self.assertTrue(form.is_valid())
# Since the entries are ignored, cleaned_data should have empty dictionaries.
self.assertEqual(form.cleaned_data["have_cards"], {})
self.assertEqual(form.cleaned_data["want_cards"], {})
def test_trade_acceptance_create_form(self):
"""Test that the TradeAcceptanceCreateForm filters available cards based on trade offer availability."""
# Create a trade offer with available quantities.
trade_offer = TradeOffer.objects.create(initiated_by=self.friend_code)
TradeOfferHaveCard.objects.create(
trade_offer=trade_offer, card=self.card1, quantity=2
)
TradeOfferWantCard.objects.create(
trade_offer=trade_offer, card=self.card2, quantity=2
)
friend_codes = FriendCode.objects.filter(pk=self.friend_code.pk)
form_data = {
"accepted_by": self.friend_code.pk,
"requested_card": self.card1.pk,
"offered_card": self.card2.pk,
}
form = TradeAcceptanceCreateForm(
data=form_data, trade_offer=trade_offer, friend_codes=friend_codes
)
self.assertTrue(form.is_valid())
instance = form.save()
self.assertEqual(instance.trade_offer, trade_offer)
self.assertEqual(instance.accepted_by, self.friend_code)
def test_trade_offer_accept_form(self):
"""Test that TradeOfferAcceptForm correctly sets the friend_code queryset."""
friend_codes = FriendCode.objects.filter(pk=self.friend_code.pk)
form = TradeOfferAcceptForm(friend_codes=friend_codes)
self.assertEqual(
list(form.fields["friend_code"].queryset), list(friend_codes)
)
def test_trade_acceptance_transition_form(self):
"""Test that the transition form provides only allowed transitions."""
other_user = get_user_model().objects.create_user(
username="transuser", email="trans@example.com", password="password"
)
other_friend_code = FriendCode.objects.create(
friend_code="FC-TRANS", in_game_name="TransUser", user=other_user
)
# Create a trade offer with initiator being our test friend code.
trade_offer = TradeOffer.objects.create(initiated_by=self.friend_code)
TradeOfferHaveCard.objects.create(
trade_offer=trade_offer, card=self.card1, quantity=1
)
TradeOfferWantCard.objects.create(
trade_offer=trade_offer, card=self.card2, quantity=1
)
acceptance = TradeAcceptance.objects.create(
trade_offer=trade_offer,
accepted_by=other_friend_code,
requested_card=self.card1,
offered_card=self.card2,
state=TradeAcceptance.AcceptanceState.ACCEPTED,
)
form = TradeAcceptanceTransitionForm(instance=acceptance, user=other_user)
# Compare the form's state choices with the allowed transitions.
allowed = [choice[0] for choice in acceptance.get_allowed_state_transitions(user=other_user)]
form_choices = [choice[0] for choice in form.fields["state"].choices]
for choice in allowed:
self.assertIn(choice, form_choices)
# ------------------------------------------------------------------------
# View Tests
# ------------------------------------------------------------------------
class TradeViewsTest(TestCase):
def setUp(self):
User = get_user_model()
self.client = Client()
self.user = User.objects.create_user(
username="viewuser", email="view@example.com", password="password"
)
self.friend_code = FriendCode.objects.create(
friend_code="FC-VIEW", in_game_name="ViewUser", user=self.user
)
self.user.default_friend_code = self.friend_code
self.user.save(update_fields=["default_friend_code"])
self.client.login(username="viewuser", password="password")
# Create sample cards.
self.card1 = Card.objects.create(
name="ViewCard1", cardset="setV", cardnum=1, style="default",
rarity_icon="R", rarity_level=1
)
self.card2 = Card.objects.create(
name="ViewCard2", cardset="setV", cardnum=2, style="default",
rarity_icon="R", rarity_level=1
)
# Create a trade offer initiated by the logged-in user's friend code.
self.trade_offer = TradeOffer.objects.create(initiated_by=self.friend_code)
TradeOfferHaveCard.objects.create(
trade_offer=self.trade_offer, card=self.card1, quantity=1
)
TradeOfferWantCard.objects.create(
trade_offer=self.trade_offer, card=self.card2, quantity=1
)
def test_trade_offer_create_view_get(self):
"""GET request to TradeOfferCreateView should include friend_codes and cards in context."""
response = self.client.get(reverse("trade_offer_create"))
self.assertEqual(response.status_code, 200)
self.assertIn("friend_codes", response.context)
self.assertIn("cards", response.context)
# When there is only one friend code, the initial value should be preset.
self.assertEqual(
response.context["form"].initial.get("initiated_by"),
self.friend_code.pk,
)
def test_trade_offer_delete_view_permission(self):
"""
The delete view should enforce that only trade offers initiated by one
of the user's friend codes can be deleted.
"""
other_user = get_user_model().objects.create_user(
username="otheruser", email="other@example.com", password="password"
)
other_friend_code = FriendCode.objects.create(
friend_code="FC-OTHER", in_game_name="OtherUser", user=other_user
)
trade_offer_other = TradeOffer.objects.create(initiated_by=other_friend_code)
url = reverse("trade_offer_delete", kwargs={"pk": trade_offer_other.pk})
response = self.client.get(url)
self.assertEqual(response.status_code, 403)
def test_trade_offer_delete_view_close(self):
"""
If a trade offer has active acceptances, the delete view should not delete it.
Instead, if no active acceptances remain it should mark the offer as closed.
"""
# Create a trade offer with an active acceptance.
trade_offer_with_acceptance = TradeOffer.objects.create(initiated_by=self.friend_code)
# Use quantity=2 so the trade offer isn't automatically closed when one acceptance is created
TradeOfferHaveCard.objects.create(
trade_offer=trade_offer_with_acceptance, card=self.card1, quantity=2
)
TradeOfferWantCard.objects.create(
trade_offer=trade_offer_with_acceptance, card=self.card2, quantity=2
)
# Create an acceptance that takes one card from each side
TradeAcceptance.objects.create(
trade_offer=trade_offer_with_acceptance,
accepted_by=self.friend_code,
requested_card=self.card1,
offered_card=self.card2,
state=TradeAcceptance.AcceptanceState.ACCEPTED,
)
delete_url = reverse("trade_offer_delete", kwargs={"pk": trade_offer_with_acceptance.pk})
# --- Patch the view's get_object() method to return our trade offer ---
from trades.views import TradeOfferDeleteView
orig_get_object = TradeOfferDeleteView.get_object
TradeOfferDeleteView.get_object = lambda self: trade_offer_with_acceptance
try:
# First POST: with active acceptance, deletion should not close the offer.
response = self.client.post(delete_url)
trade_offer_with_acceptance.refresh_from_db()
self.assertFalse(trade_offer_with_acceptance.is_closed)
# Now simulate no active acceptances by updating the acceptance state.
acceptance = trade_offer_with_acceptance.acceptances.first()
acceptance.state = TradeAcceptance.AcceptanceState.REJECTED_BY_ACCEPTOR
acceptance.save(update_fields=["state"])
response = self.client.post(delete_url)
trade_offer_with_acceptance.refresh_from_db()
self.assertTrue(trade_offer_with_acceptance.is_closed)
finally:
# Always restore the original method.
TradeOfferDeleteView.get_object = orig_get_object
def test_trade_acceptance_update_view(self):
"""Test updating a trade acceptance via the update view."""
trade_offer_new = TradeOffer.objects.create(initiated_by=self.friend_code)
TradeOfferHaveCard.objects.create(
trade_offer=trade_offer_new, card=self.card1, quantity=1
)
TradeOfferWantCard.objects.create(
trade_offer=trade_offer_new, card=self.card2, quantity=1
)
acceptance = TradeAcceptance.objects.create(
trade_offer=trade_offer_new,
accepted_by=self.friend_code,
requested_card=self.card1,
offered_card=self.card2,
state=TradeAcceptance.AcceptanceState.ACCEPTED,
)
update_url = reverse("trade_acceptance_update", kwargs={"pk": acceptance.pk})
# First, try an invalid state update.
response = self.client.post(update_url, {"state": "INVALID_STATE"})
self.assertEqual(response.status_code, 200)
form = response.context.get("form")
self.assertIsNotNone(form, "Form should be present in the response context.")
self.assertIn(
"state", form.errors,
"Expected an error on the 'state' field when an invalid state is submitted."
)
self.assertTrue(form.errors["state"], "The 'state' field should have error messages.")
# Next, if there is an allowed valid transition, try it.
allowed_states = [choice[0] for choice in acceptance.get_allowed_state_transitions(user=self.user)]
if allowed_states:
valid_state = allowed_states[0]
response = self.client.post(update_url, {"state": valid_state})
self.assertEqual(response.status_code, 302)