cst1/kpsul
1
0
Fork 0
forked from DGNum/gestioCOF
Code Pull requests Activity
kpsul/kfet/tests/test_views.py
Aurélien Delobelle b69f1b6dbc kfet.tests -- Add tests for cancel_operations view
2018-10-21 13:07:44 +02:00

4463 lines
142 KiB
Python
Raw Blame History

import json
from datetime import datetime, timedelta
from decimal import Decimal
from unittest import mock
from django.contrib.auth.models import Group
from django.core.urlresolvers import reverse
from django.test import Client, TestCase
from django.utils import timezone
from ..config import kfet_config
from ..models import (
Account,
AccountNegative,
Article,
ArticleCategory,
Checkout,
CheckoutStatement,
Inventory,
InventoryArticle,
Operation,
OperationGroup,
Order,
OrderArticle,
Supplier,
SupplierArticle,
Transfer,
TransferGroup,
)
from .testcases import ViewTestCaseMixin
from .utils import (
create_checkout,
create_checkout_statement,
create_inventory_article,
create_operation_group,
create_team,
create_user,
get_perms,
user_add_perms,
)
class AccountListViewTests(ViewTestCaseMixin, TestCase):
url_name = "kfet.account"
url_expected = "/k-fet/accounts/"
auth_user = "team"
auth_forbidden = [None, "user"]
def test_ok(self):
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
class AccountValidFreeTests(ViewTestCaseMixin, TestCase):
url_name = "kfet.account.is_validandfree.ajax"
url_expected = "/k-fet/accounts/is_validandfree"
auth_user = "team"
auth_forbidden = [None, "user"]
def test_ok_isvalid_isfree(self):
"""Upper case trigramme not taken is valid and free."""
r = self.client.get(self.url, {"trigramme": "AAA"})
self.assertDictEqual(
json.loads(r.content.decode("utf-8")), {"is_valid": True, "is_free": True}
)
def test_ok_isvalid_notfree(self):
"""Already taken trigramme is not free, but valid."""
r = self.client.get(self.url, {"trigramme": "000"})
self.assertDictEqual(
json.loads(r.content.decode("utf-8")), {"is_valid": True, "is_free": False}
)
def test_ok_notvalid_isfree(self):
"""Lower case if forbidden but free."""
r = self.client.get(self.url, {"trigramme": "aaa"})
self.assertDictEqual(
json.loads(r.content.decode("utf-8")), {"is_valid": False, "is_free": True}
)
class AccountCreateViewTests(ViewTestCaseMixin, TestCase):
url_name = "kfet.account.create"
url_expected = "/k-fet/accounts/new"
http_methods = ["GET", "POST"]
auth_user = "team"
auth_forbidden = [None, "user"]
post_data = {
"trigramme": "AAA",
"username": "plopplopplop",
"first_name": "first",
"last_name": "last",
"email": "email@domain.net",
}
def get_users_extra(self):
return {"team1": create_team("team1", "101", perms=["kfet.add_account"])}
def test_get_ok(self):
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
def test_post_ok(self):
client = Client()
client.login(username="team1", password="team1")
r = client.post(self.url, self.post_data)
self.assertRedirects(r, reverse("kfet.account.create"))
account = Account.objects.get(trigramme="AAA")
self.assertInstanceExpected(
account,
{"username": "plopplopplop", "first_name": "first", "last_name": "last"},
)
def test_post_forbidden(self):
r = self.client.post(self.url, self.post_data)
self.assertForbiddenKfet(r)
class AccountCreateAjaxViewTests(ViewTestCaseMixin, TestCase):
urls_conf = [
{
"name": "kfet.account.create.fromuser",
"kwargs": {"username": "user"},
"expected": "/k-fet/accounts/new/user/user",
},
{
"name": "kfet.account.create.fromclipper",
"kwargs": {"login_clipper": "myclipper", "fullname": "first last1 last2"},
"expected": ("/k-fet/accounts/new/clipper/myclipper/first%20last1%20last2"),
},
{"name": "kfet.account.create.empty", "expected": "/k-fet/accounts/new/empty"},
]
auth_user = "team"
auth_forbidden = [None, "user"]
def test_fromuser(self):
r = self.client.get(self.t_urls[0])
self.assertEqual(r.status_code, 200)
user = self.users["user"]
self.assertEqual(r.context["user_form"].instance, user)
self.assertEqual(r.context["cof_form"].instance, user.profile)
self.assertIn("account_form", r.context)
def test_fromclipper(self):
r = self.client.get(self.t_urls[1])
self.assertEqual(r.status_code, 200)
self.assertIn("user_form", r.context)
self.assertIn("cof_form", r.context)
self.assertIn("account_form", r.context)
def test_empty(self):
r = self.client.get(self.t_urls[2])
self.assertEqual(r.status_code, 200)
self.assertIn("user_form", r.context)
self.assertIn("cof_form", r.context)
self.assertIn("account_form", r.context)
class AccountCreateAutocompleteViewTests(ViewTestCaseMixin, TestCase):
url_name = "kfet.account.create.autocomplete"
url_expected = "/k-fet/autocomplete/account_new"
auth_user = "team"
auth_forbidden = [None, "user"]
def test_ok(self):
r = self.client.get(self.url, {"q": "first"})
self.assertEqual(r.status_code, 200)
self.assertEqual(len(r.context["users_notcof"]), 0)
self.assertEqual(len(r.context["users_cof"]), 0)
self.assertSetEqual(
set(r.context["kfet"]), set([(self.accounts["user"], self.users["user"])])
)
class AccountSearchViewTests(ViewTestCaseMixin, TestCase):
url_name = "kfet.account.search.autocomplete"
url_expected = "/k-fet/autocomplete/account_search"
auth_user = "team"
auth_forbidden = [None, "user"]
def test_ok(self):
r = self.client.get(self.url, {"q": "first"})
self.assertEqual(r.status_code, 200)
self.assertSetEqual(set(r.context["accounts"]), set([("000", "first last")]))
class AccountReadViewTests(ViewTestCaseMixin, TestCase):
url_name = "kfet.account.read"
url_kwargs = {"trigramme": "001"}
url_expected = "/k-fet/accounts/001"
auth_user = "team"
auth_forbidden = [None, "user"]
def get_users_extra(self):
return {"user1": create_user("user1", "001")}
def setUp(self):
super().setUp()
user1_acc = self.accounts["user1"]
team_acc = self.accounts["team"]
# Dummy operations and operation groups
checkout = Checkout.objects.create(
created_by=team_acc,
name="checkout",
valid_from=timezone.now(),
valid_to=timezone.now() + timezone.timedelta(days=365),
)
opeg_data = [
(timezone.now(), Decimal("10")),
(timezone.now() - timezone.timedelta(days=3), Decimal("3")),
]
OperationGroup.objects.bulk_create(
[
OperationGroup(
on_acc=user1_acc,
checkout=checkout,
at=at,
is_cof=False,
amount=amount,
)
for (at, amount) in opeg_data
]
)
self.operation_groups = OperationGroup.objects.order_by("-amount")
Operation.objects.create(
group=self.operation_groups[0],
type=Operation.PURCHASE,
amount=Decimal("10"),
)
Operation.objects.create(
group=self.operation_groups[1], type=Operation.PURCHASE, amount=Decimal("3")
)
def test_ok(self):
"""We can query the "Account - Read" page."""
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
def test_ok_self(self):
client = Client()
client.login(username="user1", password="user1")
r = client.get(self.url)
self.assertEqual(r.status_code, 200)
class AccountUpdateViewTests(ViewTestCaseMixin, TestCase):
url_name = "kfet.account.update"
url_kwargs = {"trigramme": "001"}
url_expected = "/k-fet/accounts/001/edit"
http_methods = ["GET", "POST"]
auth_user = "team"
auth_forbidden = [None, "user"]
post_data = {
# User
"first_name": "The first",
"last_name": "The last",
"email": "",
# Group
"groups[]": [],
# Account
"trigramme": "051",
"nickname": "",
"promo": "",
# 'is_frozen': not checked
# Account password
"pwd1": "",
"pwd2": "",
}
def get_users_extra(self):
return {
"user1": create_user("user1", "001"),
"team1": create_team("team1", "101", perms=["kfet.change_account"]),
}
def test_get_ok(self):
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
def test_get_ok_self(self):
client = Client()
client.login(username="user1", password="user1")
r = client.get(self.url)
self.assertEqual(r.status_code, 200)
def test_post_ok(self):
client = Client()
client.login(username="team1", password="team1")
r = client.post(self.url, self.post_data)
self.assertRedirects(r, reverse("kfet.account.read", args=["051"]))
self.accounts["user1"].refresh_from_db()
self.users["user1"].refresh_from_db()
self.assertInstanceExpected(
self.accounts["user1"],
{"first_name": "The first", "last_name": "The last", "trigramme": "051"},
)
def test_post_ok_self(self):
client = Client()
client.login(username="user1", password="user1")
post_data = {"first_name": "The first", "last_name": "The last"}
r = client.post(self.url, post_data)
self.assertRedirects(r, reverse("kfet.account.read", args=["001"]))
self.accounts["user1"].refresh_from_db()
self.users["user1"].refresh_from_db()
self.assertInstanceExpected(
self.accounts["user1"], {"first_name": "The first", "last_name": "The last"}
)
def test_post_forbidden(self):
r = self.client.post(self.url, self.post_data)
self.assertForbiddenKfet(r)
class AccountGroupListViewTests(ViewTestCaseMixin, TestCase):
url_name = "kfet.account.group"
url_expected = "/k-fet/accounts/groups"
auth_user = "team1"
auth_forbidden = [None, "user", "team"]
def get_users_extra(self):
return {"team1": create_team("team1", "101", perms=["kfet.manage_perms"])}
def setUp(self):
super().setUp()
self.group1 = Group.objects.create(name="K-Fêt - Group1")
self.group2 = Group.objects.create(name="K-Fêt - Group2")
def test_ok(self):
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
self.assertQuerysetEqual(
r.context["groups"], map(repr, [self.group1, self.group2]), ordered=False
)
class AccountGroupCreateViewTests(ViewTestCaseMixin, TestCase):
url_name = "kfet.account.group.create"
url_expected = "/k-fet/accounts/groups/new"
http_methods = ["GET", "POST"]
auth_user = "team1"
auth_forbidden = [None, "user", "team"]
def get_users_extra(self):
return {"team1": create_team("team1", "101", perms=["kfet.manage_perms"])}
@property
def post_data(self):
return {
"name": "The Group",
"permissions": [
str(self.perms["kfet.is_team"].pk),
str(self.perms["kfet.manage_perms"].pk),
],
}
def setUp(self):
super().setUp()
self.perms = get_perms("kfet.is_team", "kfet.manage_perms")
def test_get_ok(self):
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
def test_post_ok(self):
r = self.client.post(self.url, self.post_data)
self.assertRedirects(r, reverse("kfet.account.group"))
group = Group.objects.get(name="K-Fêt The Group")
self.assertQuerysetEqual(
group.permissions.all(),
map(repr, [self.perms["kfet.is_team"], self.perms["kfet.manage_perms"]]),
ordered=False,
)
class AccountGroupUpdateViewTests(ViewTestCaseMixin, TestCase):
url_name = "kfet.account.group.update"
http_methods = ["GET", "POST"]
auth_user = "team1"
auth_forbidden = [None, "user", "team"]
@property
def url_kwargs(self):
return {"pk": self.group.pk}
@property
def url_expected(self):
return "/k-fet/accounts/groups/{}/edit".format(self.group.pk)
def get_users_extra(self):
return {"team1": create_team("team1", "101", perms=["kfet.manage_perms"])}
@property
def post_data(self):
return {
"name": "The Group",
"permissions": [
str(self.perms["kfet.is_team"].pk),
str(self.perms["kfet.manage_perms"].pk),
],
}
def setUp(self):
super().setUp()
self.perms = get_perms("kfet.is_team", "kfet.manage_perms")
self.group = Group.objects.create(name="K-Fêt - Group")
self.group.permissions.set(self.perms.values())
def test_get_ok(self):
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
def test_post_ok(self):
r = self.client.post(self.url, self.post_data)
self.assertRedirects(r, reverse("kfet.account.group"))
self.group.refresh_from_db()
self.assertEqual(self.group.name, "K-Fêt The Group")
self.assertQuerysetEqual(
self.group.permissions.all(),
map(repr, [self.perms["kfet.is_team"], self.perms["kfet.manage_perms"]]),
ordered=False,
)
class AccountNegativeListViewTests(ViewTestCaseMixin, TestCase):
url_name = "kfet.account.negative"
url_expected = "/k-fet/accounts/negatives"
auth_user = "team1"
auth_forbidden = [None, "user", "team"]
def get_users_extra(self):
return {"team1": create_team("team1", "101", perms=["kfet.view_negs"])}
def setUp(self):
super().setUp()
account = self.accounts["user"]
account.balance = -5
account.save()
account.update_negative()
def test_ok(self):
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
self.assertQuerysetEqual(
r.context["negatives"],
map(repr, [self.accounts["user"].negative]),
ordered=False,
)
class AccountStatOperationListViewTests(ViewTestCaseMixin, TestCase):
url_name = "kfet.account.stat.operation.list"
url_kwargs = {"trigramme": "001"}
url_expected = "/k-fet/accounts/001/stat/operations/list"
auth_user = "user1"
auth_forbidden = [None, "user", "team"]
def get_users_extra(self):
return {"user1": create_user("user1", "001")}
def test_ok(self):
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
content = json.loads(r.content.decode("utf-8"))
base_url = reverse("kfet.account.stat.operation", args=["001"])
expected_stats = [
{
"label": "Derniers mois",
"url": {
"path": base_url,
"query": {
"scale_n_steps": ["7"],
"scale_name": ["month"],
"types": ["['purchase']"],
"scale_last": ["True"],
},
},
},
{
"label": "Dernières semaines",
"url": {
"path": base_url,
"query": {
"scale_n_steps": ["7"],
"scale_name": ["week"],
"types": ["['purchase']"],
"scale_last": ["True"],
},
},
},
{
"label": "Derniers jours",
"url": {
"path": base_url,
"query": {
"scale_n_steps": ["7"],
"scale_name": ["day"],
"types": ["['purchase']"],
"scale_last": ["True"],
},
},
},
]
for stat, expected in zip(content["stats"], expected_stats):
expected_url = expected.pop("url")
self.assertUrlsEqual(stat["url"], expected_url)
self.assertDictContainsSubset(expected, stat)
class AccountStatOperationViewTests(ViewTestCaseMixin, TestCase):
url_name = "kfet.account.stat.operation"
url_kwargs = {"trigramme": "001"}
url_expected = "/k-fet/accounts/001/stat/operations"
auth_user = "user1"
auth_forbidden = [None, "user", "team"]
def get_users_extra(self):
return {"user1": create_user("user1", "001")}
def test_ok(self):
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
class AccountStatBalanceListViewTests(ViewTestCaseMixin, TestCase):
url_name = "kfet.account.stat.balance.list"
url_kwargs = {"trigramme": "001"}
url_expected = "/k-fet/accounts/001/stat/balance/list"
auth_user = "user1"
auth_forbidden = [None, "user", "team"]
def get_users_extra(self):
return {"user1": create_user("user1", "001")}
def test_ok(self):
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
content = json.loads(r.content.decode("utf-8"))
base_url = reverse("kfet.account.stat.balance", args=["001"])
expected_stats = [
{"label": "Tout le temps", "url": base_url},
{
"label": "1 an",
"url": {"path": base_url, "query": {"last_days": ["365"]}},
},
{
"label": "6 mois",
"url": {"path": base_url, "query": {"last_days": ["183"]}},
},
{
"label": "3 mois",
"url": {"path": base_url, "query": {"last_days": ["90"]}},
},
{
"label": "30 jours",
"url": {"path": base_url, "query": {"last_days": ["30"]}},
},
]
for stat, expected in zip(content["stats"], expected_stats):
expected_url = expected.pop("url")
self.assertUrlsEqual(stat["url"], expected_url)
self.assertDictContainsSubset(expected, stat)
class AccountStatBalanceViewTests(ViewTestCaseMixin, TestCase):
url_name = "kfet.account.stat.balance"
url_kwargs = {"trigramme": "001"}
url_expected = "/k-fet/accounts/001/stat/balance"
auth_user = "user1"
auth_forbidden = [None, "user", "team"]
def get_users_extra(self):
return {"user1": create_user("user1", "001")}
def test_ok(self):
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
class CheckoutListViewTests(ViewTestCaseMixin, TestCase):
url_name = "kfet.checkout"
url_expected = "/k-fet/checkouts/"
auth_user = "team"
auth_forbidden = [None, "user"]
def setUp(self):
super().setUp()
self.checkout1 = Checkout.objects.create(
name="Checkout 1",
created_by=self.accounts["team"],
valid_from=self.now,
valid_to=self.now + timedelta(days=5),
)
self.checkout2 = Checkout.objects.create(
name="Checkout 2",
created_by=self.accounts["team"],
valid_from=self.now + timedelta(days=10),
valid_to=self.now + timedelta(days=15),
)
def test_ok(self):
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
self.assertQuerysetEqual(
r.context["checkouts"],
map(repr, [self.checkout1, self.checkout2]),
ordered=False,
)
class CheckoutCreateViewTests(ViewTestCaseMixin, TestCase):
url_name = "kfet.checkout.create"
url_expected = "/k-fet/checkouts/new"
http_methods = ["GET", "POST"]
auth_user = "team"
auth_forbidden = [None, "user"]
post_data = {
"name": "Checkout",
"valid_from": "2017-10-08 17:45:00",
"valid_to": "2017-11-08 16:00:00",
"balance": "3.14",
# 'is_protected': not checked
}
def get_users_extra(self):
return {"team1": create_team("team1", "101", perms=["kfet.add_checkout"])}
def test_get_ok(self):
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
def test_post_ok(self):
client = Client()
client.login(username="team1", password="team1")
r = client.post(self.url, self.post_data)
checkout = Checkout.objects.get(name="Checkout")
self.assertRedirects(r, checkout.get_absolute_url())
self.assertInstanceExpected(
checkout,
{
"name": "Checkout",
"valid_from": timezone.make_aware(datetime(2017, 10, 8, 17, 45)),
"valid_to": timezone.make_aware(datetime(2017, 11, 8, 16, 00)),
"balance": Decimal("3.14"),
"is_protected": False,
},
)
def test_post_forbidden(self):
r = self.client.post(self.url, self.post_data)
self.assertForbiddenKfet(r)
class CheckoutReadViewTests(ViewTestCaseMixin, TestCase):
url_name = "kfet.checkout.read"
auth_user = "team"
auth_forbidden = [None, "user"]
@property
def url_kwargs(self):
return {"pk": self.checkout.pk}
@property
def url_expected(self):
return "/k-fet/checkouts/{}".format(self.checkout.pk)
def setUp(self):
super().setUp()
with mock.patch("django.utils.timezone.now") as mock_now:
mock_now.return_value = self.now
self.checkout = Checkout.objects.create(
name="Checkout",
balance=Decimal("10"),
created_by=self.accounts["team"],
valid_from=self.now,
valid_to=self.now + timedelta(days=1),
)
def test_ok(self):
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
self.assertEqual(r.context["checkout"], self.checkout)
class CheckoutUpdateViewTests(ViewTestCaseMixin, TestCase):
url_name = "kfet.checkout.update"
http_methods = ["GET", "POST"]
auth_user = "team"
auth_forbidden = [None, "user"]
post_data = {
"name": "Checkout updated",
"valid_from": "2018-01-01 08:00:00",
"valid_to": "2018-07-01 16:00:00",
}
@property
def url_kwargs(self):
return {"pk": self.checkout.pk}
@property
def url_expected(self):
return "/k-fet/checkouts/{}/edit".format(self.checkout.pk)
def get_users_extra(self):
return {"team1": create_team("team1", "101", perms=["kfet.change_checkout"])}
def setUp(self):
super().setUp()
self.checkout = Checkout.objects.create(
name="Checkout",
valid_from=self.now,
valid_to=self.now + timedelta(days=5),
balance=Decimal("3.14"),
is_protected=False,
created_by=self.accounts["team"],
)
def test_get_ok(self):
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
def test_post_ok(self):
client = Client()
client.login(username="team1", password="team1")
r = client.post(self.url, self.post_data)
self.assertRedirects(r, self.checkout.get_absolute_url())
self.checkout.refresh_from_db()
self.assertInstanceExpected(
self.checkout,
{
"name": "Checkout updated",
"valid_from": timezone.make_aware(datetime(2018, 1, 1, 8, 0, 0)),
"valid_to": timezone.make_aware(datetime(2018, 7, 1, 16, 0, 0)),
},
)
def test_post_forbidden(self):
r = self.client.post(self.url, self.post_data)
self.assertForbiddenKfet(r)
class CheckoutStatementListViewTests(ViewTestCaseMixin, TestCase):
url_name = "kfet.checkoutstatement"
url_expected = "/k-fet/checkouts/statements/"
auth_user = "team"
auth_forbidden = [None, "user"]
def setUp(self):
super().setUp()
self.checkout1 = Checkout.objects.create(
created_by=self.accounts["team"],
name="Checkout 1",
valid_from=self.now,
valid_to=self.now + timedelta(days=5),
)
self.checkout2 = Checkout.objects.create(
created_by=self.accounts["team"],
name="Checkout 2",
valid_from=self.now + timedelta(days=10),
valid_to=self.now + timedelta(days=15),
)
self.statement1 = CheckoutStatement.objects.create(
checkout=self.checkout1,
by=self.accounts["team"],
balance_old=5,
balance_new=0,
amount_taken=5,
)
def test_ok(self):
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
expected_statements = list(self.checkout1.statements.all()) + list(
self.checkout2.statements.all()
)
self.assertQuerysetEqual(
r.context["checkoutstatements"],
map(repr, expected_statements),
ordered=False,
)
class CheckoutStatementCreateViewTests(ViewTestCaseMixin, TestCase):
url_name = "kfet.checkoutstatement.create"
http_methods = ["GET", "POST"]
auth_user = "team"
auth_forbidden = [None, "user"]
post_data = {
# Let
"balance_001": 0,
"balance_002": 0,
"balance_005": 0,
"balance_01": 0,
"balance_02": 0,
"balance_05": 0,
"balance_1": 1,
"balance_2": 0,
"balance_5": 0,
"balance_10": 1,
"balance_20": 0,
"balance_50": 0,
"balance_100": 1,
"balance_200": 0,
"balance_500": 0,
# Taken
"taken_001": 0,
"taken_002": 0,
"taken_005": 0,
"taken_01": 0,
"taken_02": 0,
"taken_05": 0,
"taken_1": 2,
"taken_2": 0,
"taken_5": 0,
"taken_10": 2,
"taken_20": 0,
"taken_50": 0,
"taken_100": 2,
"taken_200": 0,
"taken_500": 0,
"taken_cheque": 0,
# 'not_count': not checked
}
@property
def url_kwargs(self):
return {"pk_checkout": self.checkout.pk}
@property
def url_expected(self):
return "/k-fet/checkouts/{}/statements/add".format(self.checkout.pk)
def get_users_extra(self):
return {
"team1": create_team("team1", "001", perms=["kfet.add_checkoutstatement"])
}
def setUp(self):
super().setUp()
self.checkout = Checkout.objects.create(
name="Checkout",
created_by=self.accounts["team"],
balance=5,
valid_from=self.now,
valid_to=self.now + timedelta(days=5),
)
def test_get_ok(self):
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
@mock.patch("django.utils.timezone.now")
def test_post_ok(self, mock_now):
self.now += timedelta(days=2)
mock_now.return_value = self.now
client = Client()
client.login(username="team1", password="team1")
r = client.post(self.url, self.post_data)
self.assertRedirects(r, self.checkout.get_absolute_url())
statement = CheckoutStatement.objects.get(at=self.now)
self.assertInstanceExpected(
statement,
{
"by": self.accounts["team1"],
"checkout": self.checkout,
"balance_old": Decimal("5"),
"balance_new": Decimal("111"),
"amount_taken": Decimal("222"),
"amount_error": Decimal("328"),
"at": self.now,
"not_count": False,
},
)
def test_post_forbidden(self):
r = self.client.post(self.url, self.post_data)
self.assertForbiddenKfet(r)
class CheckoutStatementUpdateViewTests(ViewTestCaseMixin, TestCase):
url_name = "kfet.checkoutstatement.update"
http_methods = ["GET", "POST"]
auth_user = "team"
auth_forbidden = [None, "user"]
post_data = {
"amount_taken": 3,
"amount_error": 2,
"balance_old": 8,
"balance_new": 5,
# Taken
"taken_001": 0,
"taken_002": 0,
"taken_005": 0,
"taken_01": 0,
"taken_02": 0,
"taken_05": 0,
"taken_1": 1,
"taken_2": 1,
"taken_5": 0,
"taken_10": 0,
"taken_20": 0,
"taken_50": 0,
"taken_100": 0,
"taken_200": 0,
"taken_500": 0,
"taken_cheque": 0,
}
@property
def url_kwargs(self):
return {"pk_checkout": self.checkout.pk, "pk": self.statement.pk}
@property
def url_expected(self):
return "/k-fet/checkouts/{pk_checkout}/statements/{pk}/edit".format(
pk_checkout=self.checkout.pk, pk=self.statement.pk
)
def get_users_extra(self):
return {
"team1": create_team(
"team1", "101", perms=["kfet.change_checkoutstatement"]
)
}
def setUp(self):
super().setUp()
self.checkout = Checkout.objects.create(
name="Checkout",
created_by=self.accounts["team"],
balance=5,
valid_from=self.now,
valid_to=self.now + timedelta(days=5),
)
self.statement = CheckoutStatement.objects.create(
by=self.accounts["team"],
checkout=self.checkout,
balance_new=5,
balance_old=8,
amount_error=2,
amount_taken=5,
)
def test_get_ok(self):
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
@mock.patch("django.utils.timezone.now")
def test_post_ok(self, mock_now):
self.now += timedelta(days=2)
mock_now.return_value = self.now
client = Client()
client.login(username="team1", password="team1")
r = client.post(self.url, self.post_data)
self.assertRedirects(r, self.checkout.get_absolute_url())
self.statement.refresh_from_db()
self.assertInstanceExpected(
self.statement,
{
"taken_1": 1,
"taken_2": 1,
"balance_new": 5,
"balance_old": 8,
"amount_error": 0,
"amount_taken": 3,
},
)
def test_post_forbidden(self):
r = self.client.post(self.url, self.post_data)
self.assertForbiddenKfet(r)
class ArticleCategoryListViewTests(ViewTestCaseMixin, TestCase):
url_name = "kfet.category"
url_expected = "/k-fet/categories/"
auth_user = "team"
auth_forbidden = [None, "user"]
def setUp(self):
super().setUp()
self.category1 = ArticleCategory.objects.create(name="Category 1")
self.category2 = ArticleCategory.objects.create(name="Category 2")
def test_ok(self):
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
self.assertQuerysetEqual(
r.context["categories"], map(repr, [self.category1, self.category2])
)
class ArticleCategoryUpdateViewTests(ViewTestCaseMixin, TestCase):
url_name = "kfet.category.update"
http_methods = ["GET", "POST"]
auth_user = "team"
auth_forbidden = [None, "user"]
@property
def url_kwargs(self):
return {"pk": self.category.pk}
@property
def url_expected(self):
return "/k-fet/categories/{}/edit".format(self.category.pk)
def get_users_extra(self):
return {
"team1": create_team("team1", "101", perms=["kfet.change_articlecategory"])
}
@property
def post_data(self):
return {
"name": "The Category",
# 'has_addcost': not checked
}
def setUp(self):
super().setUp()
self.category = ArticleCategory.objects.create(name="Category")
def test_get_ok(self):
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
def test_post_ok(self):
client = Client()
client.login(username="team1", password="team1")
r = client.post(self.url, self.post_data)
self.assertRedirects(r, reverse("kfet.category"))
self.category.refresh_from_db()
self.assertInstanceExpected(
self.category, {"name": "The Category", "has_addcost": False}
)
def test_post_forbidden(self):
r = self.client.post(self.url, self.post_data)
self.assertForbiddenKfet(r)
class ArticleListViewTests(ViewTestCaseMixin, TestCase):
url_name = "kfet.article"
url_expected = "/k-fet/articles/"
auth_user = "team"
auth_forbidden = [None, "user"]
def setUp(self):
super().setUp()
category = ArticleCategory.objects.create(name="Category")
self.article1 = Article.objects.create(name="Article 1", category=category)
self.article2 = Article.objects.create(name="Article 2", category=category)
def test_ok(self):
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
self.assertQuerysetEqual(
r.context["articles"], map(repr, [self.article1, self.article2])
)
class ArticleCreateViewTests(ViewTestCaseMixin, TestCase):
url_name = "kfet.article.create"
url_expected = "/k-fet/articles/new"
http_methods = ["GET", "POST"]
auth_user = "team"
auth_forbidden = [None, "user"]
def get_users_extra(self):
return {"team1": create_team("team1", "101", perms=["kfet.add_article"])}
@property
def post_data(self):
return {
"name": "Article",
"category": self.category.pk,
"stock": 5,
"price": "2.5",
}
def setUp(self):
super().setUp()
self.category = ArticleCategory.objects.create(name="Category")
def test_get_ok(self):
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
def test_post_ok(self):
client = Client()
client.login(username="team1", password="team1")
r = client.post(self.url, self.post_data)
article = Article.objects.get(name="Article")
self.assertRedirects(r, article.get_absolute_url())
self.assertInstanceExpected(
article, {"name": "Article", "category": self.category}
)
def test_post_forbidden(self):
r = self.client.post(self.url, self.post_data)
self.assertForbiddenKfet(r)
class ArticleReadViewTests(ViewTestCaseMixin, TestCase):
url_name = "kfet.article.read"
auth_user = "team"
auth_forbidden = [None, "user"]
@property
def url_kwargs(self):
return {"pk": self.article.pk}
@property
def url_expected(self):
return "/k-fet/articles/{}".format(self.article.pk)
def setUp(self):
super().setUp()
self.article = Article.objects.create(
name="Article",
category=ArticleCategory.objects.create(name="Category"),
stock=5,
price=Decimal("2.5"),
)
def test_ok(self):
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
self.assertEqual(r.context["article"], self.article)
class ArticleUpdateViewTests(ViewTestCaseMixin, TestCase):
url_name = "kfet.article.update"
http_methods = ["GET", "POST"]
auth_user = "team"
auth_forbidden = [None, "user"]
@property
def url_kwargs(self):
return {"pk": self.article.pk}
@property
def url_expected(self):
return "/k-fet/articles/{}/edit".format(self.article.pk)
def get_users_extra(self):
return {"team1": create_team("team1", "101", perms=["kfet.change_article"])}
@property
def post_data(self):
return {
"name": "The Article",
"category": self.article.category.pk,
"is_sold": "1",
"price": "3.5",
"box_type": "carton",
# 'hidden': not checked
}
def setUp(self):
super().setUp()
self.category = ArticleCategory.objects.create(name="Category")
self.article = Article.objects.create(
name="Article", category=self.category, stock=5, price=Decimal("2.5")
)
def test_get_ok(self):
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
def test_post_ok(self):
client = Client()
client.login(username="team1", password="team1")
r = client.post(self.url, self.post_data)
self.assertRedirects(r, self.article.get_absolute_url())
self.article.refresh_from_db()
self.assertInstanceExpected(
self.article, {"name": "The Article", "price": Decimal("3.5")}
)
def test_post_forbidden(self):
r = self.client.post(self.url, self.post_data)
self.assertForbiddenKfet(r)
class ArticleStatSalesListViewTests(ViewTestCaseMixin, TestCase):
url_name = "kfet.article.stat.sales.list"
auth_user = "team"
auth_forbidden = [None, "user"]
@property
def url_kwargs(self):
return {"pk": self.article.pk}
@property
def url_expected(self):
return "/k-fet/articles/{}/stat/sales/list".format(self.article.pk)
def setUp(self):
super().setUp()
self.article = Article.objects.create(
name="Article", category=ArticleCategory.objects.create(name="Category")
)
def test_ok(self):
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
content = json.loads(r.content.decode("utf-8"))
base_url = reverse("kfet.article.stat.sales", args=[self.article.pk])
expected_stats = [
{
"label": "Derniers mois",
"url": {
"path": base_url,
"query": {
"scale_n_steps": ["7"],
"scale_name": ["month"],
"scale_last": ["True"],
},
},
},
{
"label": "Dernières semaines",
"url": {
"path": base_url,
"query": {
"scale_n_steps": ["7"],
"scale_name": ["week"],
"scale_last": ["True"],
},
},
},
{
"label": "Derniers jours",
"url": {
"path": base_url,
"query": {
"scale_n_steps": ["7"],
"scale_name": ["day"],
"scale_last": ["True"],
},
},
},
]
for stat, expected in zip(content["stats"], expected_stats):
expected_url = expected.pop("url")
self.assertUrlsEqual(stat["url"], expected_url)
self.assertDictContainsSubset(expected, stat)
class ArticleStatSalesViewTests(ViewTestCaseMixin, TestCase):
url_name = "kfet.article.stat.sales"
auth_user = "team"
auth_forbidden = [None, "user"]
@property
def url_kwargs(self):
return {"pk": self.article.pk}
@property
def url_expected(self):
return "/k-fet/articles/{}/stat/sales".format(self.article.pk)
def setUp(self):
super().setUp()
self.article = Article.objects.create(
name="Article", category=ArticleCategory.objects.create(name="Category")
)
def test_ok(self):
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
class KPsulViewTests(ViewTestCaseMixin, TestCase):
url_name = "kfet.kpsul"
url_expected = "/k-fet/k-psul/"
auth_user = "team"
auth_forbidden = [None, "user"]
def test_ok(self):
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
class KPsulCheckoutDataViewTests(ViewTestCaseMixin, TestCase):
url_name = "kfet.kpsul.checkout_data"
url_expected = "/k-fet/k-psul/checkout_data"
http_methods = ["POST"]
auth_user = "team"
auth_forbidden = [None, "user"]
def setUp(self):
super().setUp()
self.checkout = Checkout.objects.create(
name="Checkout",
balance=Decimal("10"),
created_by=self.accounts["team"],
valid_from=self.now,
valid_to=self.now + timedelta(days=5),
)
def test_ok(self):
r = self.client.post(self.url, {"pk": self.checkout.pk})
self.assertEqual(r.status_code, 200)
content = json.loads(r.content.decode("utf-8"))
expected = {"name": "Checkout", "balance": "10.00"}
self.assertDictContainsSubset(expected, content)
self.assertSetEqual(
set(content.keys()),
set(
[
"balance",
"id",
"name",
"valid_from",
"valid_to",
"last_statement_at",
"last_statement_balance",
"last_statement_by_first_name",
"last_statement_by_last_name",
"last_statement_by_trigramme",
]
),
)
class KPsulPerformOperationsViewTests(ViewTestCaseMixin, TestCase):
"""
Test cases for kpsul_perform_operations view.
Below is the test ordering, try to keep this organized ;-)
* OperationGroup:
- test_group...
- test_invalid_group...
* Operation:
- test_purchase...
- test_invalid_purchase...
- test_deposit...
- test_invalid_deposit...
- test_withdraw...
- test_invalid_withdraw...
- test_edit...
- test_invalid_edit...
* Addcost:
- test_addcost...
* Negative:
- test_negative...
- test_invalid_negative...
* More concrete examples:
- test_multi...
To test valid requests, one should use '_assertResponseOk(response)' to get
hints about failure reasons, if any.
At least one test per operation type should test the complete response and
behavior (HTTP, WebSocket, object updates, and object creations)
Other tests of the same operation type can only assert the specific
behavior differences.
For invalid requests, response errors should be tested.
"""
url_name = "kfet.kpsul.perform_operations"
url_expected = "/k-fet/k-psul/perform_operations"
http_methods = ["POST"]
auth_user = "team"
auth_forbidden = [None, "user"]
with_liq = True
def setUp(self):
super(KPsulPerformOperationsViewTests, self).setUp()
# A Checkout, curently usable, balance=100
self.checkout = Checkout.objects.create(
created_by=self.accounts["team"],
name="Checkout",
valid_from=timezone.now() - timedelta(days=7),
valid_to=timezone.now() + timedelta(days=7),
balance=Decimal("100.00"),
)
# An Article, price=2.5, stock=20
self.article = Article.objects.create(
category=ArticleCategory.objects.create(name="Category"),
name="Article",
price=Decimal("2.5"),
stock=20,
)
# An Account, trigramme=000, balance=50
# Do not assume user is cof, nor not cof.
self.account = self.accounts["user"]
self.account.balance = Decimal("50.00")
self.account.save()
# Mock consumer of K-Psul websocket to catch what we're sending
kpsul_consumer_patcher = mock.patch("kfet.consumers.KPsul")
self.kpsul_consumer_mock = kpsul_consumer_patcher.start()
self.addCleanup(kpsul_consumer_patcher.stop)
# Reset cache of kfet config
kfet_config._conf_init = False
def _assertResponseOk(self, response):
"""
Asserts that status code of 'response' is 200, and returns the
deserialized content of the JSONResponse.
In case status code is not 200, it prints the content of "errors" of
the response.
"""
json_data = json.loads(getattr(response, "content", b"{}").decode("utf-8"))
try:
self.assertEqual(response.status_code, 200)
except AssertionError as exc:
msg = "Expected response is 200, got {}. Errors: {}".format(
response.status_code, json_data.get("errors")
)
raise AssertionError(msg) from exc
return json_data
def get_base_post_data(self):
return {
# OperationGroup form
"on_acc": str(self.account.pk),
"checkout": str(self.checkout.pk),
# Operation formset
"form-TOTAL_FORMS": "0",
"form-INITIAL_FORMS": "0",
"form-MIN_NUM_FORMS": "1",
"form-MAX_NUM_FORMS": "1000",
}
base_post_data = property(get_base_post_data)
def test_invalid_group_on_acc(self):
data = dict(self.base_post_data, **{"on_acc": "GNR"})
resp = self.client.post(self.url, data)
self.assertEqual(resp.status_code, 400)
json_data = json.loads(resp.content.decode("utf-8"))
self.assertEqual(json_data["errors"]["operation_group"], ["on_acc"])
def test_group_on_acc_expects_comment(self):
user_add_perms(self.users["team"], ["kfet.perform_commented_operations"])
self.account.trigramme = "#13"
self.account.save()
self.assertTrue(self.account.need_comment)
data = dict(
self.base_post_data,
**{
"comment": "A comment to explain it",
"form-TOTAL_FORMS": "1",
"form-0-type": "purchase",
"form-0-amount": "",
"form-0-article": str(self.article.pk),
"form-0-article_nb": "2",
}
)
resp = self.client.post(self.url, data)
self._assertResponseOk(resp)
def test_invalid_group_on_acc_expects_comment(self):
user_add_perms(self.users["team"], ["kfet.perform_commented_operations"])
self.account.trigramme = "#13"
self.account.save()
self.assertTrue(self.account.need_comment)
data = dict(
self.base_post_data,
**{
"form-TOTAL_FORMS": "1",
"form-0-type": "purchase",
"form-0-amount": "",
"form-0-article": str(self.article.pk),
"form-0-article_nb": "2",
}
)
resp = self.client.post(self.url, data)
self.assertEqual(resp.status_code, 400)
json_data = json.loads(resp.content.decode("utf-8"))
self.assertEqual(json_data["errors"]["need_comment"], True)
def test_invalid_group_on_acc_needs_comment_requires_perm(self):
self.account.trigramme = "#13"
self.account.save()
self.assertTrue(self.account.need_comment)
data = dict(
self.base_post_data,
**{
"comment": "A comment to explain it",
"form-TOTAL_FORMS": "1",
"form-0-type": "purchase",
"form-0-amount": "",
"form-0-article": str(self.article.pk),
"form-0-article_nb": "2",
}
)
resp = self.client.post(self.url, data)
self.assertEqual(resp.status_code, 403)
json_data = json.loads(resp.content.decode("utf-8"))
self.assertEqual(
json_data["errors"]["missing_perms"],
["Enregistrer des commandes avec commentaires"],
)
def test_group_on_acc_frozen(self):
user_add_perms(self.users["team"], ["kfet.override_frozen_protection"])
self.account.is_frozen = True
self.account.save()
data = dict(
self.base_post_data,
**{
"comment": "A comment to explain it",
"form-TOTAL_FORMS": "1",
"form-0-type": "purchase",
"form-0-amount": "",
"form-0-article": str(self.article.pk),
"form-0-article_nb": "2",
}
)
resp = self.client.post(self.url, data)
self._assertResponseOk(resp)
def test_invalid_group_on_acc_frozen_requires_perm(self):
self.account.is_frozen = True
self.account.save()
data = dict(
self.base_post_data,
**{
"comment": "A comment to explain it",
"form-TOTAL_FORMS": "1",
"form-0-type": "purchase",
"form-0-amount": "",
"form-0-article": str(self.article.pk),
"form-0-article_nb": "2",
}
)
resp = self.client.post(self.url, data)
self.assertEqual(resp.status_code, 403)
json_data = json.loads(resp.content.decode("utf-8"))
self.assertEqual(
json_data["errors"]["missing_perms"], ["Forcer le gel d'un compte"]
)
def test_invalid_group_checkout(self):
self.checkout.valid_from -= timedelta(days=300)
self.checkout.valid_to -= timedelta(days=300)
self.checkout.save()
data = dict(self.base_post_data)
resp = self.client.post(self.url, data)
self.assertEqual(resp.status_code, 400)
json_data = json.loads(resp.content.decode("utf-8"))
self.assertEqual(json_data["errors"]["operation_group"], ["checkout"])
def test_invalid_group_expects_one_operation(self):
data = dict(self.base_post_data)
resp = self.client.post(self.url, data)
self.assertEqual(resp.status_code, 400)
json_data = json.loads(resp.content.decode("utf-8"))
self.assertEqual(json_data["errors"]["operations"], [])
def test_purchase_with_user_is_nof_cof(self):
self.account.cofprofile.is_cof = False
self.account.cofprofile.save()
data = dict(
self.base_post_data,
**{
"form-TOTAL_FORMS": "1",
"form-0-type": "purchase",
"form-0-amount": "",
"form-0-article": str(self.article.pk),
"form-0-article_nb": "2",
}
)
resp = self.client.post(self.url, data)
# Check response status
json_data = self._assertResponseOk(resp)
# Check object creations
operation_group = OperationGroup.objects.get()
self.assertDictEqual(
operation_group.__dict__,
{
"_state": mock.ANY,
"at": mock.ANY,
"amount": Decimal("-5.00"),
"checkout_id": self.checkout.pk,
"comment": "",
"id": mock.ANY,
"is_cof": False,
"on_acc_id": self.account.pk,
"valid_by_id": None,
},
)
operation = Operation.objects.get()
self.assertDictEqual(
operation.__dict__,
{
"_state": mock.ANY,
"addcost_amount": None,
"addcost_for_id": None,
"amount": Decimal("-5.00"),
"article_id": self.article.pk,
"article_nb": 2,
"canceled_at": None,
"canceled_by_id": None,
"group_id": operation_group.pk,
"id": mock.ANY,
"type": "purchase",
},
)
# Check response content
self.assertDictEqual(
json_data,
{
"operationgroup": operation_group.pk,
"operations": [operation.pk],
"warnings": {},
"errors": {},
},
)
# Check object updates
self.account.refresh_from_db()
self.assertEqual(self.account.balance, Decimal("45.00"))
self.checkout.refresh_from_db()
self.assertEqual(self.checkout.balance, Decimal("100.00"))
self.article.refresh_from_db()
self.assertEqual(self.article.stock, 18)
# Check websocket data
self.kpsul_consumer_mock.group_send.assert_called_once_with(
"kfet.kpsul",
{
"opegroups": [
{
"add": True,
"at": mock.ANY,
"amount": Decimal("-5.00"),
"checkout__name": "Checkout",
"comment": "",
"id": operation_group.pk,
"is_cof": False,
"on_acc__trigramme": "000",
"valid_by__trigramme": None,
"opes": [
{
"id": operation.pk,
"addcost_amount": None,
"addcost_for__trigramme": None,
"amount": Decimal("-5.00"),
"article__name": "Article",
"article_nb": 2,
"canceled_at": None,
"canceled_by__trigramme": None,
"group_id": operation_group.pk,
"type": "purchase",
}
],
}
],
"checkouts": [{"id": self.checkout.pk, "balance": Decimal("100.00")}],
"articles": [{"id": self.article.pk, "stock": 18}],
},
)
def test_purchase_with_user_is_cof(self):
kfet_config.set(kfet_reduction_cof=Decimal("20"))
self.account.cofprofile.is_cof = True
self.account.cofprofile.save()
data = dict(
self.base_post_data,
**{
"form-TOTAL_FORMS": "1",
"form-0-type": "purchase",
"form-0-amount": "",
"form-0-article": str(self.article.pk),
"form-0-article_nb": "2",
}
)
resp = self.client.post(self.url, data)
self._assertResponseOk(resp)
operation_group = OperationGroup.objects.get()
self.assertEqual(operation_group.amount, Decimal("-4.00"))
self.assertEqual(operation_group.is_cof, True)
operation = Operation.objects.get()
self.assertEqual(operation.amount, Decimal("-4.00"))
self.account.refresh_from_db()
self.assertEqual(self.account.balance, Decimal("46.00"))
self.checkout.refresh_from_db()
self.assertEqual(self.checkout.balance, Decimal("100.00"))
self.article.refresh_from_db()
self.assertEqual(self.article.stock, 18)
def test_purchase_with_cash(self):
data = dict(
self.base_post_data,
**{
"on_acc": str(self.accounts["liq"].pk),
"form-TOTAL_FORMS": "1",
"form-0-type": "purchase",
"form-0-amount": "",
"form-0-article": str(self.article.pk),
"form-0-article_nb": "2",
}
)
resp = self.client.post(self.url, data)
self._assertResponseOk(resp)
operation_group = OperationGroup.objects.get()
self.assertEqual(operation_group.on_acc, self.accounts["liq"])
self.assertEqual(operation_group.is_cof, False)
self.accounts["liq"].refresh_from_db()
self.assertEqual(self.accounts["liq"].balance, 0)
self.checkout.refresh_from_db()
self.assertEqual(self.checkout.balance, Decimal("105.00"))
self.article.refresh_from_db()
self.assertEqual(self.article.stock, 18)
def test_invalid_purchase_expects_article(self):
data = dict(
self.base_post_data,
**{
"form-TOTAL_FORMS": "1",
"form-0-type": "purchase",
"form-0-amount": "",
"form-0-article": "",
"form-0-article_nb": "1",
}
)
resp = self.client.post(self.url, data)
self.assertEqual(resp.status_code, 400)
json_data = json.loads(resp.content.decode("utf-8"))
self.assertEqual(
json_data["errors"]["operations"],
[{"__all__": ["Un achat nécessite un article et une quantité"]}],
)
def test_invalid_purchase_expects_article_nb(self):
data = dict(
self.base_post_data,
**{
"form-TOTAL_FORMS": "1",
"form-0-type": "purchase",
"form-0-amount": "",
"form-0-article": str(self.article.pk),
"form-0-article_nb": "",
}
)
resp = self.client.post(self.url, data)
self.assertEqual(resp.status_code, 400)
json_data = json.loads(resp.content.decode("utf-8"))
self.assertEqual(
json_data["errors"]["operations"],
[{"__all__": ["Un achat nécessite un article et une quantité"]}],
)
def test_invalid_purchase_expects_article_nb_greater_than_1(self):
data = dict(
self.base_post_data,
**{
"form-TOTAL_FORMS": "1",
"form-0-type": "purchase",
"form-0-amount": "",
"form-0-article": str(self.article.pk),
"form-0-article_nb": "-1",
}
)
resp = self.client.post(self.url, data)
self.assertEqual(resp.status_code, 400)
json_data = json.loads(resp.content.decode("utf-8"))
self.assertEqual(
json_data["errors"]["operations"],
[
{
"__all__": ["Un achat nécessite un article et une quantité"],
"article_nb": [
"Assurez-vous que cette valeur est supérieure ou " "égale à 1."
],
}
],
)
def test_invalid_operation_not_purchase_with_cash(self):
data = dict(
self.base_post_data,
**{
"on_acc": str(self.accounts["liq"].pk),
"form-TOTAL_FORMS": "1",
"form-0-type": "deposit",
"form-0-amount": "10.00",
"form-0-article": "",
"form-0-article_nb": "",
}
)
resp = self.client.post(self.url, data)
self.assertEqual(resp.status_code, 400)
json_data = json.loads(resp.content.decode("utf-8"))
self.assertEqual(json_data["errors"]["account"], "LIQ")
def test_deposit(self):
user_add_perms(self.users["team"], ["kfet.perform_deposit"])
data = dict(
self.base_post_data,
**{
"form-TOTAL_FORMS": "1",
"form-0-type": "deposit",
"form-0-amount": "10.75",
"form-0-article": "",
"form-0-article_nb": "",
}
)
resp = self.client.post(self.url, data)
json_data = self._assertResponseOk(resp)
operation_group = OperationGroup.objects.get()
self.assertDictEqual(
operation_group.__dict__,
{
"_state": mock.ANY,
"at": mock.ANY,
"amount": Decimal("10.75"),
"checkout_id": self.checkout.pk,
"comment": "",
"id": mock.ANY,
"is_cof": False,
"on_acc_id": self.account.pk,
"valid_by_id": self.accounts["team"].pk,
},
)
operation = Operation.objects.get()
self.assertDictEqual(
operation.__dict__,
{
"_state": mock.ANY,
"addcost_amount": None,
"addcost_for_id": None,
"amount": Decimal("10.75"),
"article_id": None,
"article_nb": None,
"canceled_at": None,
"canceled_by_id": None,
"group_id": operation_group.pk,
"id": mock.ANY,
"type": "deposit",
},
)
self.assertDictEqual(
json_data,
{
"operationgroup": operation_group.pk,
"operations": [operation.pk],
"warnings": {},
"errors": {},
},
)
self.account.refresh_from_db()
self.assertEqual(self.account.balance, Decimal("60.75"))
self.checkout.refresh_from_db()
self.assertEqual(self.checkout.balance, Decimal("110.75"))
self.kpsul_consumer_mock.group_send.assert_called_once_with(
"kfet.kpsul",
{
"opegroups": [
{
"add": True,
"at": mock.ANY,
"amount": Decimal("10.75"),
"checkout__name": "Checkout",
"comment": "",
"id": operation_group.pk,
"is_cof": False,
"on_acc__trigramme": "000",
"valid_by__trigramme": "100",
"opes": [
{
"id": operation.pk,
"addcost_amount": None,
"addcost_for__trigramme": None,
"amount": Decimal("10.75"),
"article__name": None,
"article_nb": None,
"canceled_at": None,
"canceled_by__trigramme": None,
"group_id": operation_group.pk,
"type": "deposit",
}
],
}
],
"checkouts": [{"id": self.checkout.pk, "balance": Decimal("110.75")}],
"articles": [],
},
)
def test_invalid_deposit_expects_amount(self):
data = dict(
self.base_post_data,
**{
"form-TOTAL_FORMS": "1",
"form-0-type": "deposit",
"form-0-amount": "",
"form-0-article": "",
"form-0-article_nb": "",
}
)
resp = self.client.post(self.url, data)
self.assertEqual(resp.status_code, 400)
json_data = json.loads(resp.content.decode("utf-8"))
self.assertEqual(
json_data["errors"]["operations"], [{"__all__": ["Bad request"]}]
)
def test_invalid_deposit_too_many_params(self):
data = dict(
self.base_post_data,
**{
"form-TOTAL_FORMS": "1",
"form-0-type": "deposit",
"form-0-amount": "10",
"form-0-article": str(self.article.pk),
"form-0-article_nb": "3",
}
)
resp = self.client.post(self.url, data)
self.assertEqual(resp.status_code, 400)
json_data = json.loads(resp.content.decode("utf-8"))
self.assertEqual(
json_data["errors"]["operations"], [{"__all__": ["Bad request"]}]
)
def test_invalid_deposit_expects_positive_amount(self):
data = dict(
self.base_post_data,
**{
"form-TOTAL_FORMS": "1",
"form-0-type": "deposit",
"form-0-amount": "-10",
"form-0-article": "",
"form-0-article_nb": "",
}
)
resp = self.client.post(self.url, data)
self.assertEqual(resp.status_code, 400)
json_data = json.loads(resp.content.decode("utf-8"))
self.assertEqual(
json_data["errors"]["operations"], [{"__all__": ["Charge non positive"]}]
)
def test_invalid_deposit_requires_perm(self):
data = dict(
self.base_post_data,
**{
"form-TOTAL_FORMS": "1",
"form-0-type": "deposit",
"form-0-amount": "10.75",
"form-0-article": "",
"form-0-article_nb": "",
}
)
resp = self.client.post(self.url, data)
self.assertEqual(resp.status_code, 403)
json_data = json.loads(resp.content.decode("utf-8"))
self.assertEqual(json_data["errors"]["missing_perms"], ["Effectuer une charge"])
def test_withdraw(self):
data = dict(
self.base_post_data,
**{
"form-TOTAL_FORMS": "1",
"form-0-type": "withdraw",
"form-0-amount": "-10.75",
"form-0-article": "",
"form-0-article_nb": "",
}
)
resp = self.client.post(self.url, data)
json_data = self._assertResponseOk(resp)
operation_group = OperationGroup.objects.get()
self.assertDictEqual(
operation_group.__dict__,
{
"_state": mock.ANY,
"at": mock.ANY,
"amount": Decimal("-10.75"),
"checkout_id": self.checkout.pk,
"comment": "",
"id": mock.ANY,
"is_cof": False,
"on_acc_id": self.account.pk,
"valid_by_id": None,
},
)
operation = Operation.objects.get()
self.assertDictEqual(
operation.__dict__,
{
"_state": mock.ANY,
"addcost_amount": None,
"addcost_for_id": None,
"amount": Decimal("-10.75"),
"article_id": None,
"article_nb": None,
"canceled_at": None,
"canceled_by_id": None,
"group_id": operation_group.pk,
"id": mock.ANY,
"type": "withdraw",
},
)
self.assertDictEqual(
json_data,
{
"operationgroup": operation_group.pk,
"operations": [operation.pk],
"warnings": {},
"errors": {},
},
)
self.account.refresh_from_db()
self.assertEqual(self.account.balance, Decimal("39.25"))
self.checkout.refresh_from_db()
self.assertEqual(self.checkout.balance, Decimal("89.25"))
self.kpsul_consumer_mock.group_send.assert_called_once_with(
"kfet.kpsul",
{
"opegroups": [
{
"add": True,
"at": mock.ANY,
"amount": Decimal("-10.75"),
"checkout__name": "Checkout",
"comment": "",
"id": operation_group.pk,
"is_cof": False,
"on_acc__trigramme": "000",
"valid_by__trigramme": None,
"opes": [
{
"id": operation.pk,
"addcost_amount": None,
"addcost_for__trigramme": None,
"amount": Decimal("-10.75"),
"article__name": None,
"article_nb": None,
"canceled_at": None,
"canceled_by__trigramme": None,
"group_id": operation_group.pk,
"type": "withdraw",
}
],
}
],
"checkouts": [{"id": self.checkout.pk, "balance": Decimal("89.25")}],
"articles": [],
},
)
def test_invalid_withdraw_expects_amount(self):
data = dict(
self.base_post_data,
**{
"form-TOTAL_FORMS": "1",
"form-0-type": "withdraw",
"form-0-amount": "",
"form-0-article": "",
"form-0-article_nb": "",
}
)
resp = self.client.post(self.url, data)
self.assertEqual(resp.status_code, 400)
json_data = json.loads(resp.content.decode("utf-8"))
self.assertEqual(
json_data["errors"]["operations"], [{"__all__": ["Bad request"]}]
)
def test_invalid_withdraw_too_many_params(self):
data = dict(
self.base_post_data,
**{
"form-TOTAL_FORMS": "1",
"form-0-type": "withdraw",
"form-0-amount": "-10",
"form-0-article": str(self.article.pk),
"form-0-article_nb": "3",
}
)
resp = self.client.post(self.url, data)
self.assertEqual(resp.status_code, 400)
json_data = json.loads(resp.content.decode("utf-8"))
self.assertEqual(
json_data["errors"]["operations"], [{"__all__": ["Bad request"]}]
)
def test_invalid_withdraw_expects_negative_amount(self):
data = dict(
self.base_post_data,
**{
"form-TOTAL_FORMS": "1",
"form-0-type": "withdraw",
"form-0-amount": "10",
"form-0-article": "",
"form-0-article_nb": "",
}
)
resp = self.client.post(self.url, data)
self.assertEqual(resp.status_code, 400)
json_data = json.loads(resp.content.decode("utf-8"))
self.assertEqual(
json_data["errors"]["operations"], [{"__all__": ["Retrait non négatif"]}]
)
def test_edit(self):
user_add_perms(self.users["team"], ["kfet.edit_balance_account"])
data = dict(
self.base_post_data,
**{
"comment": "A comment to explain it",
"form-TOTAL_FORMS": "1",
"form-0-type": "edit",
"form-0-amount": "10.75",
"form-0-article": "",
"form-0-article_nb": "",
}
)
resp = self.client.post(self.url, data)
json_data = self._assertResponseOk(resp)
operation_group = OperationGroup.objects.get()
self.assertDictEqual(
operation_group.__dict__,
{
"_state": mock.ANY,
"at": mock.ANY,
"amount": Decimal("10.75"),
"checkout_id": self.checkout.pk,
"comment": "A comment to explain it",
"id": mock.ANY,
"is_cof": False,
"on_acc_id": self.account.pk,
"valid_by_id": self.accounts["team"].pk,
},
)
operation = Operation.objects.get()
self.assertDictEqual(
operation.__dict__,
{
"_state": mock.ANY,
"addcost_amount": None,
"addcost_for_id": None,
"amount": Decimal("10.75"),
"article_id": None,
"article_nb": None,
"canceled_at": None,
"canceled_by_id": None,
"group_id": operation_group.pk,
"id": mock.ANY,
"type": "edit",
},
)
self.assertDictEqual(
json_data,
{
"operationgroup": operation_group.pk,
"operations": [operation.pk],
"warnings": {},
"errors": {},
},
)
self.account.refresh_from_db()
self.assertEqual(self.account.balance, Decimal("60.75"))
self.checkout.refresh_from_db()
self.assertEqual(self.checkout.balance, Decimal("100.00"))
self.kpsul_consumer_mock.group_send.assert_called_once_with(
"kfet.kpsul",
{
"opegroups": [
{
"add": True,
"at": mock.ANY,
"amount": Decimal("10.75"),
"checkout__name": "Checkout",
"comment": "A comment to explain it",
"id": operation_group.pk,
"is_cof": False,
"on_acc__trigramme": "000",
"valid_by__trigramme": "100",
"opes": [
{
"id": operation.pk,
"addcost_amount": None,
"addcost_for__trigramme": None,
"amount": Decimal("10.75"),
"article__name": None,
"article_nb": None,
"canceled_at": None,
"canceled_by__trigramme": None,
"group_id": operation_group.pk,
"type": "edit",
}
],
}
],
"checkouts": [{"id": self.checkout.pk, "balance": Decimal("100.00")}],
"articles": [],
},
)
def test_invalid_edit_requires_perm(self):
data = dict(
self.base_post_data,
**{
"comment": "A comment to explain it",
"form-TOTAL_FORMS": "1",
"form-0-type": "edit",
"form-0-amount": "10.75",
"form-0-article": "",
"form-0-article_nb": "",
}
)
resp = self.client.post(self.url, data)
self.assertEqual(resp.status_code, 403)
json_data = json.loads(resp.content.decode("utf-8"))
self.assertEqual(
json_data["errors"]["missing_perms"], ["Modifier la balance d'un compte"]
)
def test_invalid_edit_expects_comment(self):
user_add_perms(self.users["team"], ["kfet.edit_balance_account"])
data = dict(
self.base_post_data,
**{
"form-TOTAL_FORMS": "1",
"form-0-type": "edit",
"form-0-amount": "10.75",
"form-0-article": "",
"form-0-article_nb": "",
}
)
resp = self.client.post(self.url, data)
self.assertEqual(resp.status_code, 400)
json_data = json.loads(resp.content.decode("utf-8"))
self.assertEqual(json_data["errors"]["need_comment"], True)
def _setup_addcost(self):
self.register_user("addcost", create_user("addcost", "ADD"))
kfet_config.set(
addcost_amount=Decimal("0.50"), addcost_for=self.accounts["addcost"]
)
def test_addcost_user_is_not_cof(self):
self.account.cofprofile.is_cof = False
self.account.cofprofile.save()
self._setup_addcost()
data = dict(
self.base_post_data,
**{
"form-TOTAL_FORMS": "1",
"form-0-type": "purchase",
"form-0-amount": "",
"form-0-article": str(self.article.pk),
"form-0-article_nb": "2",
}
)
resp = self.client.post(self.url, data)
self._assertResponseOk(resp)
operation_group = OperationGroup.objects.get()
self.assertEqual(operation_group.amount, Decimal("-6.00"))
operation = Operation.objects.get()
self.assertEqual(operation.addcost_for, self.accounts["addcost"])
self.assertEqual(operation.addcost_amount, Decimal("1.00"))
self.assertEqual(operation.amount, Decimal("-6.00"))
self.account.refresh_from_db()
self.assertEqual(self.account.balance, Decimal("44.00"))
self.accounts["addcost"].refresh_from_db()
self.assertEqual(self.accounts["addcost"].balance, Decimal("1.00"))
self.checkout.refresh_from_db()
self.assertEqual(self.checkout.balance, Decimal("100.00"))
ws_data_ope = self.kpsul_consumer_mock.group_send.call_args[0][1]["opegroups"][
0
]["opes"][0]
self.assertEqual(ws_data_ope["addcost_amount"], Decimal("1.00"))
self.assertEqual(ws_data_ope["addcost_for__trigramme"], "ADD")
def test_addcost_user_is_cof(self):
kfet_config.set(reduction_cof=Decimal("20"))
self.account.cofprofile.is_cof = True
self.account.cofprofile.save()
self._setup_addcost()
data = dict(
self.base_post_data,
**{
"form-TOTAL_FORMS": "1",
"form-0-type": "purchase",
"form-0-amount": "",
"form-0-article": str(self.article.pk),
"form-0-article_nb": "2",
}
)
resp = self.client.post(self.url, data)
self._assertResponseOk(resp)
operation_group = OperationGroup.objects.get()
self.assertEqual(operation_group.amount, Decimal("-4.80"))
operation = Operation.objects.get()
self.assertEqual(operation.addcost_for, self.accounts["addcost"])
self.assertEqual(operation.addcost_amount, Decimal("0.80"))
self.assertEqual(operation.amount, Decimal("-4.80"))
self.account.refresh_from_db()
self.assertEqual(self.account.balance, Decimal("45.20"))
self.accounts["addcost"].refresh_from_db()
self.assertEqual(self.accounts["addcost"].balance, Decimal("0.80"))
self.checkout.refresh_from_db()
self.assertEqual(self.checkout.balance, Decimal("100.00"))
ws_data_ope = self.kpsul_consumer_mock.group_send.call_args[0][1]["opegroups"][
0
]["opes"][0]
self.assertEqual(ws_data_ope["addcost_amount"], Decimal("0.80"))
self.assertEqual(ws_data_ope["addcost_for__trigramme"], "ADD")
def test_addcost_user_is_cash(self):
self.account.cofprofile.is_cof = True
self.account.cofprofile.save()
self._setup_addcost()
data = dict(
self.base_post_data,
**{
"on_acc": str(self.accounts["liq"].pk),
"form-TOTAL_FORMS": "1",
"form-0-type": "purchase",
"form-0-amount": "",
"form-0-article": str(self.article.pk),
"form-0-article_nb": "2",
}
)
resp = self.client.post(self.url, data)
self._assertResponseOk(resp)
operation_group = OperationGroup.objects.get()
self.assertEqual(operation_group.amount, Decimal("-6.00"))
operation = Operation.objects.get()
self.assertEqual(operation.addcost_for, self.accounts["addcost"])
self.assertEqual(operation.addcost_amount, Decimal("1.00"))
self.assertEqual(operation.amount, Decimal("-6.00"))
self.accounts["addcost"].refresh_from_db()
self.assertEqual(self.accounts["addcost"].balance, Decimal("1.00"))
self.checkout.refresh_from_db()
self.assertEqual(self.checkout.balance, Decimal("106.00"))
ws_data_ope = self.kpsul_consumer_mock.group_send.call_args[0][1]["opegroups"][
0
]["opes"][0]
self.assertEqual(ws_data_ope["addcost_amount"], Decimal("1.00"))
self.assertEqual(ws_data_ope["addcost_for__trigramme"], "ADD")
def test_addcost_to_self(self):
self._setup_addcost()
self.accounts["addcost"].balance = Decimal("20.00")
self.accounts["addcost"].save()
data = dict(
self.base_post_data,
**{
"on_acc": str(self.accounts["addcost"].pk),
"form-TOTAL_FORMS": "1",
"form-0-type": "purchase",
"form-0-amount": "",
"form-0-article": str(self.article.pk),
"form-0-article_nb": "2",
}
)
resp = self.client.post(self.url, data)
self._assertResponseOk(resp)
operation_group = OperationGroup.objects.get()
self.assertEqual(operation_group.amount, Decimal("-5.00"))
operation = Operation.objects.get()
self.assertEqual(operation.addcost_for, None)
self.assertEqual(operation.addcost_amount, None)
self.assertEqual(operation.amount, Decimal("-5.00"))
self.accounts["addcost"].refresh_from_db()
self.assertEqual(self.accounts["addcost"].balance, Decimal("15.00"))
ws_data_ope = self.kpsul_consumer_mock.group_send.call_args[0][1]["opegroups"][
0
]["opes"][0]
self.assertEqual(ws_data_ope["addcost_amount"], None)
self.assertEqual(ws_data_ope["addcost_for__trigramme"], None)
def test_addcost_category_disabled(self):
self._setup_addcost()
self.article.category.has_addcost = False
self.article.category.save()
data = dict(
self.base_post_data,
**{
"form-TOTAL_FORMS": "1",
"form-0-type": "purchase",
"form-0-amount": "",
"form-0-article": str(self.article.pk),
"form-0-article_nb": "2",
}
)
resp = self.client.post(self.url, data)
self._assertResponseOk(resp)
operation_group = OperationGroup.objects.get()
self.assertEqual(operation_group.amount, Decimal("-5.00"))
operation = Operation.objects.get()
self.assertEqual(operation.addcost_for, None)
self.assertEqual(operation.addcost_amount, None)
self.assertEqual(operation.amount, Decimal("-5.00"))
self.accounts["addcost"].refresh_from_db()
self.assertEqual(self.accounts["addcost"].balance, Decimal("0.00"))
ws_data_ope = self.kpsul_consumer_mock.group_send.call_args[0][1]["opegroups"][
0
]["opes"][0]
self.assertEqual(ws_data_ope["addcost_amount"], None)
self.assertEqual(ws_data_ope["addcost_for__trigramme"], None)
def test_negative_new(self):
user_add_perms(self.users["team"], ["kfet.perform_negative_operations"])
self.account.balance = Decimal("1.00")
self.account.save()
data = dict(
self.base_post_data,
**{
"form-TOTAL_FORMS": "1",
"form-0-type": "purchase",
"form-0-amount": "",
"form-0-article": str(self.article.pk),
"form-0-article_nb": "2",
}
)
resp = self.client.post(self.url, data)
self._assertResponseOk(resp)
self.account.refresh_from_db()
self.assertEqual(self.account.balance, Decimal("-4.00"))
def test_negative_exists(self):
user_add_perms(self.users["team"], ["kfet.perform_negative_operations"])
self.account.balance = Decimal("-10.00")
self.account.save()
self.account.update_negative()
data = dict(
self.base_post_data,
**{
"form-TOTAL_FORMS": "1",
"form-0-type": "purchase",
"form-0-amount": "",
"form-0-article": str(self.article.pk),
"form-0-article_nb": "2",
}
)
resp = self.client.post(self.url, data)
self._assertResponseOk(resp)
self.account.refresh_from_db()
self.assertEqual(self.account.balance, Decimal("-15.00"))
def test_negative_exists_balance_higher_than_initial(self):
user_add_perms(self.users["team"], ["kfet.perform_deposit"])
self.account.balance = Decimal("-10.00")
self.account.save()
self.account.update_negative()
data = dict(
self.base_post_data,
**{
"form-TOTAL_FORMS": "2",
"form-0-type": "purchase",
"form-0-amount": "",
"form-0-article": str(self.article.pk),
"form-0-article_nb": "1",
"form-1-type": "deposit",
"form-1-amount": "5.00",
"form-1-article": "",
"form-1-article_nb": "",
}
)
resp = self.client.post(self.url, data)
self._assertResponseOk(resp)
self.account.refresh_from_db()
self.assertEqual(self.account.balance, Decimal("-7.50"))
def test_invalid_negative_new_requires_perm(self):
self.account.balance = Decimal("1.00")
self.account.save()
data = dict(
self.base_post_data,
**{
"form-TOTAL_FORMS": "1",
"form-0-type": "purchase",
"form-0-amount": "",
"form-0-article": str(self.article.pk),
"form-0-article_nb": "2",
}
)
resp = self.client.post(self.url, data)
self.assertEqual(resp.status_code, 403)
json_data = json.loads(resp.content.decode("utf-8"))
self.assertEqual(
json_data["errors"],
{"missing_perms": ["Enregistrer des commandes en négatif"]},
)
def test_invalid_negative_exceeds_allowed_duration_from_config(self):
user_add_perms(self.users["team"], ["kfet.perform_negative_operations"])
kfet_config.set(overdraft_duration=timedelta(days=5))
self.account.balance = Decimal("1.00")
self.account.save()
self.account.negative = AccountNegative.objects.create(
account=self.account, start=timezone.now() - timedelta(days=5, minutes=1)
)
data = dict(
self.base_post_data,
**{
"form-TOTAL_FORMS": "1",
"form-0-type": "purchase",
"form-0-amount": "",
"form-0-article": str(self.article.pk),
"form-0-article_nb": "2",
}
)
resp = self.client.post(self.url, data)
self.assertEqual(resp.status_code, 403)
json_data = json.loads(resp.content.decode("utf-8"))
self.assertEqual(json_data["errors"], {"negative": ["000"]})
def test_invalid_negative_exceeds_allowed_duration_from_account(self):
user_add_perms(self.users["team"], ["kfet.perform_negative_operations"])
kfet_config.set(overdraft_duration=timedelta(days=5))
self.account.balance = Decimal("1.00")
self.account.save()
self.account.negative = AccountNegative.objects.create(
account=self.account,
start=timezone.now() - timedelta(days=3),
authz_overdraft_until=timezone.now() - timedelta(seconds=1),
)
data = dict(
self.base_post_data,
**{
"form-TOTAL_FORMS": "1",
"form-0-type": "purchase",
"form-0-amount": "",
"form-0-article": str(self.article.pk),
"form-0-article_nb": "2",
}
)
resp = self.client.post(self.url, data)
self.assertEqual(resp.status_code, 403)
json_data = json.loads(resp.content.decode("utf-8"))
self.assertEqual(json_data["errors"], {"negative": ["000"]})
def test_invalid_negative_exceeds_amount_allowed_from_config(self):
user_add_perms(self.users["team"], ["kfet.perform_negative_operations"])
kfet_config.set(overdraft_amount=Decimal("-1.00"))
self.account.balance = Decimal("1.00")
self.account.save()
self.account.update_negative()
data = dict(
self.base_post_data,
**{
"form-TOTAL_FORMS": "1",
"form-0-type": "purchase",
"form-0-amount": "",
"form-0-article": str(self.article.pk),
"form-0-article_nb": "2",
}
)
resp = self.client.post(self.url, data)
self.assertEqual(resp.status_code, 403)
json_data = json.loads(resp.content.decode("utf-8"))
self.assertEqual(json_data["errors"], {"negative": ["000"]})
def test_invalid_negative_exceeds_amount_allowed_from_account(self):
user_add_perms(self.users["team"], ["kfet.perform_negative_operations"])
kfet_config.set(overdraft_amount=Decimal("10.00"))
self.account.balance = Decimal("1.00")
self.account.save()
self.account.update_negative()
self.account.negative = AccountNegative.objects.create(
account=self.account,
start=timezone.now() - timedelta(days=3),
authz_overdraft_amount=Decimal("1.00"),
)
data = dict(
self.base_post_data,
**{
"form-TOTAL_FORMS": "1",
"form-0-type": "purchase",
"form-0-amount": "",
"form-0-article": str(self.article.pk),
"form-0-article_nb": "2",
}
)
resp = self.client.post(self.url, data)
self.assertEqual(resp.status_code, 403)
json_data = json.loads(resp.content.decode("utf-8"))
self.assertEqual(json_data["errors"], {"negative": ["000"]})
def test_multi_0(self):
article2 = Article.objects.create(
name="Article 2",
price=Decimal("4"),
stock=-5,
category=ArticleCategory.objects.first(),
)
self.account.cofprofile.is_cof = False
self.account.cofprofile.save()
data = dict(
self.base_post_data,
**{
"form-TOTAL_FORMS": "2",
"form-0-type": "purchase",
"form-0-amount": "",
"form-0-article": str(self.article.pk),
"form-0-article_nb": "2",
"form-1-type": "purchase",
"form-1-amount": "",
"form-1-article": str(article2.pk),
"form-1-article_nb": "1",
}
)
resp = self.client.post(self.url, data)
# Check response status
json_data = self._assertResponseOk(resp)
# Check object creations
operation_group = OperationGroup.objects.get()
self.assertDictEqual(
operation_group.__dict__,
{
"_state": mock.ANY,
"at": mock.ANY,
"amount": Decimal("-9.00"),
"checkout_id": self.checkout.pk,
"comment": "",
"id": mock.ANY,
"is_cof": False,
"on_acc_id": self.account.pk,
"valid_by_id": None,
},
)
operation_list = Operation.objects.all()
self.assertEqual(len(operation_list), 2)
self.assertDictEqual(
operation_list[0].__dict__,
{
"_state": mock.ANY,
"addcost_amount": None,
"addcost_for_id": None,
"amount": Decimal("-5.00"),
"article_id": self.article.pk,
"article_nb": 2,
"canceled_at": None,
"canceled_by_id": None,
"group_id": operation_group.pk,
"id": mock.ANY,
"type": "purchase",
},
)
self.assertDictEqual(
operation_list[1].__dict__,
{
"_state": mock.ANY,
"addcost_amount": None,
"addcost_for_id": None,
"amount": Decimal("-4.00"),
"article_id": article2.pk,
"article_nb": 1,
"canceled_at": None,
"canceled_by_id": None,
"group_id": operation_group.pk,
"id": mock.ANY,
"type": "purchase",
},
)
# Check response content
self.assertDictEqual(
json_data,
{
"operationgroup": operation_group.pk,
"operations": [operation_list[0].pk, operation_list[1].pk],
"warnings": {},
"errors": {},
},
)
# Check object updates
self.account.refresh_from_db()
self.assertEqual(self.account.balance, Decimal("41.00"))
self.checkout.refresh_from_db()
self.assertEqual(self.checkout.balance, Decimal("100.00"))
self.article.refresh_from_db()
self.assertEqual(self.article.stock, 18)
article2.refresh_from_db()
self.assertEqual(article2.stock, -6)
# Check websocket data
self.kpsul_consumer_mock.group_send.assert_called_once_with(
"kfet.kpsul",
{
"opegroups": [
{
"add": True,
"at": mock.ANY,
"amount": Decimal("-9.00"),
"checkout__name": "Checkout",
"comment": "",
"id": operation_group.pk,
"is_cof": False,
"on_acc__trigramme": "000",
"valid_by__trigramme": None,
"opes": [
{
"id": operation_list[0].pk,
"addcost_amount": None,
"addcost_for__trigramme": None,
"amount": Decimal("-5.00"),
"article__name": "Article",
"article_nb": 2,
"canceled_at": None,
"canceled_by__trigramme": None,
"group_id": operation_group.pk,
"type": "purchase",
},
{
"id": operation_list[1].pk,
"addcost_amount": None,
"addcost_for__trigramme": None,
"amount": Decimal("-4.00"),
"article__name": "Article 2",
"article_nb": 1,
"canceled_at": None,
"canceled_by__trigramme": None,
"group_id": operation_group.pk,
"type": "purchase",
},
],
}
],
"checkouts": [{"id": self.checkout.pk, "balance": Decimal("100.00")}],
"articles": [
{"id": self.article.pk, "stock": 18},
{"id": article2.pk, "stock": -6},
],
},
)
class KPsulCancelOperationsViewTests(ViewTestCaseMixin, TestCase):
"""
Test cases for kpsul_cancel_operations view.
To test valid requests, one should use '_assertResponseOk(response)' to get
hints about failure reasons, if any.
At least one test per operation type should test the complete response and
behavior (HTTP, WebSocket, object updates, and object creations)
Other tests of the same operation type can only assert the specific
behavior differences.
For invalid requests, response errors should be tested.
"""
url_name = "kfet.kpsul.cancel_operations"
url_expected = "/k-fet/k-psul/cancel_operations"
http_methods = ["POST"]
auth_user = "team"
auth_forbidden = [None, "user"]
with_liq = True
def setUp(self):
super(KPsulCancelOperationsViewTests, self).setUp()
self.checkout = create_checkout(balance=Decimal("100.00"))
# An Article, price=2.5, stock=20
self.article = Article.objects.create(
category=ArticleCategory.objects.create(name="Category"),
name="Article",
price=Decimal("2.5"),
stock=20,
)
# An Account, trigramme=000, balance=50
# Do not assume user is cof, nor not cof.
self.account = self.accounts["user"]
self.account.balance = Decimal("50.00")
self.account.save()
# Mock consumer of K-Psul websocket to catch what we're sending
kpsul_consumer_patcher = mock.patch("kfet.consumers.KPsul")
self.kpsul_consumer_mock = kpsul_consumer_patcher.start()
self.addCleanup(kpsul_consumer_patcher.stop)
def _assertResponseOk(self, response):
"""
Asserts that status code of 'response' is 200, and returns the
deserialized content of the JSONResponse.
In case status code is not 200, it prints the content of "errors" of
the response.
"""
json_data = json.loads(getattr(response, "content", b"{}").decode("utf-8"))
try:
self.assertEqual(response.status_code, 200)
except AssertionError as exc:
msg = "Expected response is 200, got {}. Errors: {}".format(
response.status_code, json_data.get("errors")
)
raise AssertionError(msg) from exc
return json_data
def test_invalid_operation_not_int(self):
data = {"operations[]": ["a"]}
resp = self.client.post(self.url, data)
self.assertEqual(resp.status_code, 400)
json_data = json.loads(resp.content.decode("utf-8"))
self.assertEqual(json_data["errors"], {})
def test_invalid_operation_not_exist(self):
data = {"operations[]": ["1000"]}
resp = self.client.post(self.url, data)
self.assertEqual(resp.status_code, 400)
json_data = json.loads(resp.content.decode("utf-8"))
self.assertEqual(json_data["errors"], {"opes_notexisting": [1000]})
@mock.patch("django.utils.timezone.now")
def test_purchase(self, now_mock):
now_mock.return_value = self.now
group = create_operation_group(
on_acc=self.account,
checkout=self.checkout,
content=[
{"type": Operation.PURCHASE, "article": self.article, "article_nb": 2}
],
)
operation = group.opes.get()
now_mock.return_value += timedelta(seconds=15)
data = {"operations[]": [str(operation.pk)]}
resp = self.client.post(self.url, data)
json_data = self._assertResponseOk(resp)
group = OperationGroup.objects.get()
self.assertDictEqual(
group.__dict__,
{
"_state": mock.ANY,
"amount": Decimal("0.00"),
"at": mock.ANY,
"checkout_id": self.checkout.pk,
"comment": "",
"id": mock.ANY,
"is_cof": False,
"on_acc_id": self.account.pk,
"valid_by_id": None,
},
)
operation = Operation.objects.get()
self.assertDictEqual(
operation.__dict__,
{
"_state": mock.ANY,
"addcost_amount": None,
"addcost_for_id": None,
"amount": Decimal("-5.00"),
"article_id": self.article.pk,
"article_nb": 2,
"canceled_at": self.now + timedelta(seconds=15),
"canceled_by_id": None,
"group_id": group.pk,
"id": mock.ANY,
"type": Operation.PURCHASE,
},
)
self.assertDictEqual(
json_data, {"canceled": [operation.pk], "errors": {}, "warnings": {}}
)
self.account.refresh_from_db()
self.assertEqual(self.account.balance, Decimal("55.00"))
self.article.refresh_from_db()
self.assertEqual(self.article.stock, 22)
self.checkout.refresh_from_db()
self.assertEqual(self.checkout.balance, Decimal("100.00"))
self.kpsul_consumer_mock.group_send.assert_called_with(
"kfet.kpsul",
{
"opegroups": [
{
"cancellation": True,
"id": group.pk,
"amount": Decimal("0.00"),
"is_cof": False,
}
],
"opes": [
{
"cancellation": True,
"id": operation.pk,
"canceled_by__trigramme": None,
"canceled_at": self.now + timedelta(seconds=15),
}
],
"checkouts": [],
"articles": [{"id": self.article.pk, "stock": 22}],
},
)
def test_purchase_with_addcost(self):
# TODO(AD): L'état de la balance du compte destinataire de la majoration ne
# devrait pas empêcher l'annulation d'une opération.
addcost_user = create_user(
"addcost", "ADD", account_attrs={"balance": Decimal("10.00")}
)
addcost_account = addcost_user.profile.account_kfet
group = create_operation_group(
on_acc=self.account,
checkout=self.checkout,
content=[
{
"type": Operation.PURCHASE,
"article": self.article,
"article_nb": 2,
"amount": Decimal("-6.00"),
"addcost_amount": Decimal("1.00"),
"addcost_for": addcost_account,
}
],
)
operation = group.opes.get()
data = {"operations[]": [str(operation.pk)]}
resp = self.client.post(self.url, data)
self._assertResponseOk(resp)
self.account.refresh_from_db()
self.assertEqual(self.account.balance, Decimal("56.00"))
addcost_account.refresh_from_db()
self.assertEqual(addcost_account.balance, Decimal("9.00"))
def test_purchase_cash(self):
group = create_operation_group(
on_acc=self.accounts["liq"],
checkout=self.checkout,
content=[
{
"type": Operation.PURCHASE,
"article": self.article,
"article_nb": 2,
"amount": Decimal("-5.00"),
}
],
)
operation = group.opes.get()
data = {"operations[]": [str(operation.pk)]}
resp = self.client.post(self.url, data)
self._assertResponseOk(resp)
self.assertEqual(self.accounts["liq"].balance, Decimal("0.00"))
self.checkout.refresh_from_db()
self.assertEqual(self.checkout.balance, Decimal("95.00"))
ws_data_checkouts = self.kpsul_consumer_mock.group_send.call_args[0][1][
"checkouts"
]
self.assertListEqual(
ws_data_checkouts, [{"id": self.checkout.pk, "balance": Decimal("95.00")}]
)
def test_purchase_cash_with_addcost(self):
# TODO(AD): L'état de la balance du compte destinataire de la majoration ne
# devrait pas empêcher l'annulation d'une opération.
addcost_user = create_user(
"addcost", "ADD", account_attrs={"balance": Decimal("10.00")}
)
addcost_account = addcost_user.profile.account_kfet
group = create_operation_group(
on_acc=self.accounts["liq"],
checkout=self.checkout,
content=[
{
"type": Operation.PURCHASE,
"article": self.article,
"article_nb": 2,
"amount": Decimal("-6.00"),
"addcost_amount": Decimal("1.00"),
"addcost_for": addcost_account,
}
],
)
operation = group.opes.get()
data = {"operations[]": [str(operation.pk)]}
resp = self.client.post(self.url, data)
self._assertResponseOk(resp)
self.checkout.refresh_from_db()
self.assertEqual(self.checkout.balance, Decimal("94.00"))
addcost_account.refresh_from_db()
self.assertEqual(addcost_account.balance, Decimal("9.00"))
ws_data_checkouts = self.kpsul_consumer_mock.group_send.call_args[0][1][
"checkouts"
]
self.assertListEqual(
ws_data_checkouts, [{"id": self.checkout.pk, "balance": Decimal("94.00")}]
)
@mock.patch("django.utils.timezone.now")
def test_deposit(self, now_mock):
now_mock.return_value = self.now
group = create_operation_group(
on_acc=self.account,
checkout=self.checkout,
content=[{"type": Operation.DEPOSIT, "amount": Decimal("10.75")}],
)
operation = group.opes.get()
now_mock.return_value += timedelta(seconds=15)
data = {"operations[]": [str(operation.pk)]}
resp = self.client.post(self.url, data)
json_data = self._assertResponseOk(resp)
group = OperationGroup.objects.get()
self.assertDictEqual(
group.__dict__,
{
"_state": mock.ANY,
"amount": Decimal("0.00"),
"at": mock.ANY,
"checkout_id": self.checkout.pk,
"comment": "",
"id": mock.ANY,
"is_cof": False,
"on_acc_id": self.account.pk,
"valid_by_id": None,
},
)
operation = Operation.objects.get()
self.assertDictEqual(
operation.__dict__,
{
"_state": mock.ANY,
"addcost_amount": None,
"addcost_for_id": None,
"amount": Decimal("10.75"),
"article_id": None,
"article_nb": None,
"canceled_at": self.now + timedelta(seconds=15),
"canceled_by_id": None,
"group_id": group.pk,
"id": mock.ANY,
"type": Operation.DEPOSIT,
},
)
self.assertDictEqual(
json_data, {"canceled": [operation.pk], "errors": {}, "warnings": {}}
)
self.account.refresh_from_db()
self.assertEqual(self.account.balance, Decimal("39.25"))
self.article.refresh_from_db()
self.assertEqual(self.article.stock, 20)
self.checkout.refresh_from_db()
self.assertEqual(self.checkout.balance, Decimal("89.25"))
self.kpsul_consumer_mock.group_send.assert_called_with(
"kfet.kpsul",
{
"opegroups": [
{
"cancellation": True,
"id": group.pk,
"amount": Decimal("0.00"),
"is_cof": False,
}
],
"opes": [
{
"cancellation": True,
"id": operation.pk,
"canceled_by__trigramme": None,
"canceled_at": self.now + timedelta(seconds=15),
}
],
"checkouts": [{"id": self.checkout.pk, "balance": Decimal("89.25")}],
"articles": [],
},
)
@mock.patch("django.utils.timezone.now")
def test_withdraw(self, now_mock):
now_mock.return_value = self.now
group = create_operation_group(
on_acc=self.account,
checkout=self.checkout,
content=[{"type": Operation.WITHDRAW, "amount": Decimal("-10.75")}],
)
operation = group.opes.get()
now_mock.return_value += timedelta(seconds=15)
data = {"operations[]": [str(operation.pk)]}
resp = self.client.post(self.url, data)
json_data = self._assertResponseOk(resp)
group = OperationGroup.objects.get()
self.assertDictEqual(
group.__dict__,
{
"_state": mock.ANY,
"amount": Decimal("0.00"),
"at": mock.ANY,
"checkout_id": self.checkout.pk,
"comment": "",
"id": mock.ANY,
"is_cof": False,
"on_acc_id": self.account.pk,
"valid_by_id": None,
},
)
operation = Operation.objects.get()
self.assertDictEqual(
operation.__dict__,
{
"_state": mock.ANY,
"addcost_amount": None,
"addcost_for_id": None,
"amount": Decimal("-10.75"),
"article_id": None,
"article_nb": None,
"canceled_at": self.now + timedelta(seconds=15),
"canceled_by_id": None,
"group_id": group.pk,
"id": mock.ANY,
"type": Operation.WITHDRAW,
},
)
self.assertDictEqual(
json_data, {"canceled": [operation.pk], "errors": {}, "warnings": {}}
)
self.account.refresh_from_db()
self.assertEqual(self.account.balance, Decimal("60.75"))
self.article.refresh_from_db()
self.assertEqual(self.article.stock, 20)
self.checkout.refresh_from_db()
self.assertEqual(self.checkout.balance, Decimal("110.75"))
self.kpsul_consumer_mock.group_send.assert_called_with(
"kfet.kpsul",
{
"opegroups": [
{
"cancellation": True,
"id": group.pk,
"amount": Decimal("0.00"),
"is_cof": False,
}
],
"opes": [
{
"cancellation": True,
"id": operation.pk,
"canceled_by__trigramme": None,
"canceled_at": self.now + timedelta(seconds=15),
}
],
"checkouts": [{"id": self.checkout.pk, "balance": Decimal("110.75")}],
"articles": [],
},
)
@mock.patch("django.utils.timezone.now")
def test_edit(self, now_mock):
now_mock.return_value = self.now
group = create_operation_group(
on_acc=self.account,
checkout=self.checkout,
content=[{"type": Operation.EDIT, "amount": Decimal("-10.75")}],
)
operation = group.opes.get()
now_mock.return_value += timedelta(seconds=15)
data = {"operations[]": [str(operation.pk)]}
resp = self.client.post(self.url, data)
json_data = self._assertResponseOk(resp)
group = OperationGroup.objects.get()
self.assertDictEqual(
group.__dict__,
{
"_state": mock.ANY,
"amount": Decimal("0.00"),
"at": mock.ANY,
"checkout_id": self.checkout.pk,
"comment": "",
"id": mock.ANY,
"is_cof": False,
"on_acc_id": self.account.pk,
"valid_by_id": None,
},
)
operation = Operation.objects.get()
self.assertDictEqual(
operation.__dict__,
{
"_state": mock.ANY,
"addcost_amount": None,
"addcost_for_id": None,
"amount": Decimal("-10.75"),
"article_id": None,
"article_nb": None,
"canceled_at": self.now + timedelta(seconds=15),
"canceled_by_id": None,
"group_id": group.pk,
"id": mock.ANY,
"type": Operation.EDIT,
},
)
self.assertDictEqual(
json_data, {"canceled": [operation.pk], "errors": {}, "warnings": {}}
)
self.account.refresh_from_db()
self.assertEqual(self.account.balance, Decimal("60.75"))
self.article.refresh_from_db()
self.assertEqual(self.article.stock, 20)
self.checkout.refresh_from_db()
self.assertEqual(self.checkout.balance, Decimal("100.00"))
self.kpsul_consumer_mock.group_send.assert_called_with(
"kfet.kpsul",
{
"opegroups": [
{
"cancellation": True,
"id": group.pk,
"amount": Decimal("0.00"),
"is_cof": False,
}
],
"opes": [
{
"cancellation": True,
"id": operation.pk,
"canceled_by__trigramme": None,
"canceled_at": self.now + timedelta(seconds=15),
}
],
"checkouts": [],
"articles": [],
},
)
@mock.patch("django.utils.timezone.now")
def test_old_operations(self, now_mock):
kfet_config.set(cancel_duration=timedelta(minutes=10))
user_add_perms(self.users["team"], ["kfet.cancel_old_operations"])
now_mock.return_value = self.now
group = create_operation_group(
at=self.now,
on_acc=self.account,
checkout=self.checkout,
content=[{"type": Operation.WITHDRAW, "amount": Decimal("-10.75")}],
)
operation = group.opes.get()
now_mock.return_value += timedelta(minutes=10, seconds=1)
data = {"operations[]": [str(operation.pk)]}
resp = self.client.post(self.url, data)
json_data = self._assertResponseOk(resp)
self.assertEqual(len(json_data["canceled"]), 1)
@mock.patch("django.utils.timezone.now")
def test_invalid_old_operations_requires_perm(self, now_mock):
kfet_config.set(cancel_duration=timedelta(minutes=10))
now_mock.return_value = self.now
group = create_operation_group(
at=self.now,
on_acc=self.account,
checkout=self.checkout,
content=[{"type": Operation.WITHDRAW, "amount": Decimal("-10.75")}],
)
operation = group.opes.get()
now_mock.return_value += timedelta(minutes=10, seconds=1)
data = {"operations[]": [str(operation.pk)]}
resp = self.client.post(self.url, data)
self.assertEqual(resp.status_code, 403)
json_data = json.loads(resp.content.decode("utf-8"))
self.assertEqual(
json_data["errors"],
{"missing_perms": ["Annuler des commandes non récentes"]},
)
def test_already_canceled(self):
group = create_operation_group(
on_acc=self.account,
checkout=self.checkout,
content=[
{
"type": Operation.WITHDRAW,
"amount": Decimal("-10.75"),
"canceled_at": timezone.now(),
}
],
)
operation = group.opes.get()
data = {"operations[]": [str(operation.pk)]}
resp = self.client.post(self.url, data)
json_data = self._assertResponseOk(resp)
self.assertDictEqual(
json_data["warnings"], {"already_canceled": [operation.pk]}
)
self.account.refresh_from_db()
self.assertEqual(self.account.balance, Decimal("50.00"))
self.checkout.refresh_from_db()
self.assertEqual(self.checkout.balance, Decimal("100.00"))
@mock.patch("django.utils.timezone.now")
def test_checkout_before_last_statement(self, now_mock):
now_mock.return_value = self.now
group = create_operation_group(
at=self.now,
on_acc=self.account,
checkout=self.checkout,
content=[{"type": Operation.WITHDRAW, "amount": Decimal("-10.75")}],
)
operation = group.opes.get()
now_mock.return_value += timedelta(seconds=30)
create_checkout_statement(checkout=self.checkout)
now_mock.return_value += timedelta(seconds=30)
data = {"operations[]": [str(operation.pk)]}
resp = self.client.post(self.url, data)
json_data = self._assertResponseOk(resp)
self.assertEqual(len(json_data["canceled"]), 1)
self.account.refresh_from_db()
self.assertEqual(self.account.balance, Decimal("60.75"))
self.checkout.refresh_from_db()
self.assertEqual(self.checkout.balance, Decimal("100.00"))
@mock.patch("django.utils.timezone.now")
def test_article_before_last_inventory(self, now_mock):
now_mock.return_value = self.now
group = create_operation_group(
at=self.now,
on_acc=self.account,
checkout=self.checkout,
content=[
{"type": Operation.PURCHASE, "article": self.article, "article_nb": 2}
],
)
operation = group.opes.get()
now_mock.return_value += timedelta(seconds=30)
create_inventory_article(article=self.article)
now_mock.return_value += timedelta(seconds=30)
data = {"operations[]": [str(operation.pk)]}
resp = self.client.post(self.url, data)
json_data = self._assertResponseOk(resp)
self.assertEqual(len(json_data["canceled"]), 1)
self.account.refresh_from_db()
self.assertEqual(self.account.balance, Decimal("55.00"))
self.article.refresh_from_db()
self.assertEqual(self.article.stock, 20)
def test_negative(self):
kfet_config.set(overdraft_amount=Decimal("40.00"))
user_add_perms(self.users["team"], ["kfet.perform_negative_operations"])
self.account.balance = Decimal("-20.00")
self.account.save()
group = create_operation_group(
on_acc=self.account,
checkout=self.checkout,
content=[{"type": Operation.DEPOSIT, "amount": Decimal("10.75")}],
)
operation = group.opes.get()
data = {"operations[]": [str(operation.pk)]}
resp = self.client.post(self.url, data)
json_data = self._assertResponseOk(resp)
self.assertEqual(len(json_data["canceled"]), 1)
self.account.refresh_from_db()
self.assertEqual(self.account.balance, Decimal("-30.75"))
self.checkout.refresh_from_db()
self.assertEqual(self.checkout.balance, Decimal("89.25"))
def test_invalid_negative_above_thresholds(self):
kfet_config.set(overdraft_amount=Decimal("5.00"))
user_add_perms(self.users["team"], ["kfet.perform_negative_operations"])
self.account.balance = Decimal("-20.00")
self.account.save()
group = create_operation_group(
on_acc=self.account,
checkout=self.checkout,
content=[{"type": Operation.DEPOSIT, "amount": Decimal("10.75")}],
)
operation = group.opes.get()
data = {"operations[]": [str(operation.pk)]}
resp = self.client.post(self.url, data)
self.assertEqual(resp.status_code, 403)
json_data = json.loads(resp.content.decode("utf-8"))
self.assertEqual(json_data["errors"], {"negative": [self.account.trigramme]})
def test_invalid_negative_requires_perms(self):
kfet_config.set(overdraft_amount=Decimal("40.00"))
self.account.balance = Decimal("-20.00")
self.account.save()
group = create_operation_group(
on_acc=self.account,
checkout=self.checkout,
content=[{"type": Operation.DEPOSIT, "amount": Decimal("10.75")}],
)
operation = group.opes.get()
data = {"operations[]": [str(operation.pk)]}
resp = self.client.post(self.url, data)
self.assertEqual(resp.status_code, 403)
json_data = json.loads(resp.content.decode("utf-8"))
self.assertEqual(
json_data["errors"],
{"missing_perms": ["Enregistrer des commandes en négatif"]},
)
def test_partial_0(self):
group = create_operation_group(
on_acc=self.account,
checkout=self.checkout,
content=[
{"type": Operation.PURCHASE, "article": self.article, "article_nb": 2},
{"type": Operation.DEPOSIT, "amount": Decimal("10.75")},
{"type": Operation.EDIT, "amount": Decimal("-6.00")},
{
"type": Operation.WITHDRAW,
"amount": Decimal("-10.75"),
"canceled_at": timezone.now(),
},
],
)
operation1 = group.opes.get(type=Operation.PURCHASE)
operation2 = group.opes.get(type=Operation.EDIT)
operation3 = group.opes.get(type=Operation.WITHDRAW)
data = {
"operations[]": [str(operation1.pk), str(operation2.pk), str(operation3.pk)]
}
resp = self.client.post(self.url, data)
json_data = self._assertResponseOk(resp)
group.refresh_from_db()
self.assertEqual(group.amount, Decimal("10.75"))
self.assertEqual(group.opes.exclude(canceled_at=None).count(), 3)
self.assertDictEqual(
json_data,
{
"canceled": [operation1.pk, operation2.pk],
"warnings": {"already_canceled": [operation3.pk]},
"errors": {},
},
)
self.account.refresh_from_db()
self.assertEqual(self.account.balance, Decimal("61.00"))
self.article.refresh_from_db()
self.assertEqual(self.article.stock, 22)
self.checkout.refresh_from_db()
self.assertEqual(self.checkout.balance, Decimal("100.00"))
def test_multi_0(self):
group1 = create_operation_group(
on_acc=self.account,
checkout=self.checkout,
content=[
{"type": Operation.PURCHASE, "article": self.article, "article_nb": 2},
{"type": Operation.DEPOSIT, "amount": Decimal("10.75")},
{"type": Operation.EDIT, "amount": Decimal("-6.00")},
],
)
operation11 = group1.opes.get(type=Operation.PURCHASE)
group2 = create_operation_group(
on_acc=self.account,
checkout=self.checkout,
content=[
{"type": Operation.PURCHASE, "article": self.article, "article_nb": 5},
{"type": Operation.DEPOSIT, "amount": Decimal("3.00")},
],
)
operation21 = group2.opes.get(type=Operation.PURCHASE)
operation22 = group2.opes.get(type=Operation.DEPOSIT)
data = {
"operations[]": [
str(operation11.pk),
str(operation21.pk),
str(operation22.pk),
]
}
resp = self.client.post(self.url, data)
json_data = self._assertResponseOk(resp)
group1.refresh_from_db()
self.assertEqual(group1.amount, Decimal("4.75"))
self.assertEqual(group1.opes.exclude(canceled_at=None).count(), 1)
group2.refresh_from_db()
self.assertEqual(group2.amount, Decimal(0))
self.assertEqual(group2.opes.exclude(canceled_at=None).count(), 2)
self.assertEqual(len(json_data["canceled"]), 3)
self.account.refresh_from_db()
self.assertEqual(self.account.balance, Decimal("64.50"))
self.article.refresh_from_db()
self.assertEqual(self.article.stock, 27)
self.checkout.refresh_from_db()
self.assertEqual(self.checkout.balance, Decimal("97.00"))
class KPsulArticlesData(ViewTestCaseMixin, TestCase):
url_name = "kfet.kpsul.articles_data"
url_expected = "/k-fet/k-psul/articles_data"
auth_user = "team"
auth_forbidden = [None, "user"]
def setUp(self):
super().setUp()
category = ArticleCategory.objects.create(name="Catégorie")
self.article1 = Article.objects.create(category=category, name="Article 1")
self.article2 = Article.objects.create(
category=category, name="Article 2", price=Decimal("2.5")
)
def test_ok(self):
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
content = json.loads(r.content.decode("utf-8"))
articles = content["articles"]
expected_list = [
{"category__name": "Catégorie", "name": "Article 1", "price": "0.00"},
{"category__name": "Catégorie", "name": "Article 2", "price": "2.50"},
]
for expected, article in zip(expected_list, articles):
self.assertDictContainsSubset(expected, article)
self.assertSetEqual(
set(article.keys()),
set(
[
"id",
"name",
"price",
"stock",
"category_id",
"category__name",
"category__has_addcost",
]
),
)
class KPsulUpdateAddcost(ViewTestCaseMixin, TestCase):
url_name = "kfet.kpsul.update_addcost"
url_expected = "/k-fet/k-psul/update_addcost"
http_methods = ["POST"]
auth_user = "team"
auth_forbidden = [None, "user"]
post_data = {"trigramme": "000", "amount": "0.5"}
def get_users_extra(self):
return {"team1": create_team("team1", "101", perms=["kfet.manage_addcosts"])}
def test_ok(self):
client = Client()
client.login(username="team1", password="team1")
r = client.post(self.url, self.post_data)
self.assertEqual(r.status_code, 200)
self.assertEqual(kfet_config.addcost_for, Account.objects.get(trigramme="000"))
self.assertEqual(kfet_config.addcost_amount, Decimal("0.5"))
def test_post_forbidden(self):
r = self.client.post(self.url, self.post_data)
self.assertForbidden(r)
class KPsulGetSettings(ViewTestCaseMixin, TestCase):
url_name = "kfet.kpsul.get_settings"
url_expected = "/k-fet/k-psul/get_settings"
auth_user = "team"
auth_forbidden = [None, "user"]
def test_ok(self):
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
class HistoryJSONViewTests(ViewTestCaseMixin, TestCase):
url_name = "kfet.history.json"
url_expected = "/k-fet/history.json"
auth_user = "user"
auth_forbidden = [None]
def test_ok(self):
r = self.client.post(self.url)
self.assertEqual(r.status_code, 200)
class AccountReadJSONViewTests(ViewTestCaseMixin, TestCase):
url_name = "kfet.account.read.json"
url_expected = "/k-fet/accounts/read.json"
http_methods = ["POST"]
auth_user = "team"
auth_forbidden = [None, "user"]
def test_ok(self):
r = self.client.post(self.url, {"trigramme": "000"})
self.assertEqual(r.status_code, 200)
content = json.loads(r.content.decode("utf-8"))
expected = {"name": "first last", "trigramme": "000", "balance": "0.00"}
self.assertDictContainsSubset(expected, content)
self.assertSetEqual(
set(content.keys()),
set(
[
"balance",
"departement",
"email",
"id",
"is_cof",
"is_frozen",
"name",
"nickname",
"promo",
"trigramme",
]
),
)
class SettingsListViewTests(ViewTestCaseMixin, TestCase):
url_name = "kfet.settings"
url_expected = "/k-fet/settings/"
auth_user = "team1"
auth_forbidden = [None, "user", "team"]
def get_users_extra(self):
return {"team1": create_team("team1", "101", perms=["kfet.see_config"])}
def test_ok(self):
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
class SettingsUpdateViewTests(ViewTestCaseMixin, TestCase):
url_name = "kfet.settings.update"
url_expected = "/k-fet/settings/edit"
http_methods = ["GET", "POST"]
auth_user = "team1"
auth_forbidden = [None, "user", "team"]
@property
def post_data(self):
return {
"kfet_reduction_cof": "25",
"kfet_addcost_amount": "0.5",
"kfet_addcost_for": self.accounts["user"].pk,
"kfet_overdraft_duration": "2 00:00:00",
"kfet_overdraft_amount": "25",
"kfet_cancel_duration": "00:20:00",
}
def get_users_extra(self):
return {"team1": create_team("team1", "101", perms=["kfet.change_config"])}
def test_get_ok(self):
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
def test_post_ok(self):
r = self.client.post(self.url, self.post_data)
# Redirect is skipped because client may lack permissions.
self.assertRedirects(r, reverse("kfet.settings"), fetch_redirect_response=False)
expected_config = {
"reduction_cof": Decimal("25"),
"addcost_amount": Decimal("0.5"),
"addcost_for": self.accounts["user"],
"overdraft_duration": timedelta(days=2),
"overdraft_amount": Decimal("25"),
"cancel_duration": timedelta(minutes=20),
}
for key, expected in expected_config.items():
self.assertEqual(getattr(kfet_config, key), expected)
class TransferListViewTests(ViewTestCaseMixin, TestCase):
url_name = "kfet.transfers"
url_expected = "/k-fet/transfers/"
auth_user = "team"
auth_forbidden = [None, "user"]
def test_ok(self):
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
class TransferCreateViewTests(ViewTestCaseMixin, TestCase):
url_name = "kfet.transfers.create"
url_expected = "/k-fet/transfers/new"
auth_user = "team"
auth_forbidden = [None, "user"]
def test_ok(self):
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
class TransferPerformViewTests(ViewTestCaseMixin, TestCase):
url_name = "kfet.transfers.perform"
url_expected = "/k-fet/transfers/perform"
http_methods = ["POST"]
auth_user = "team1"
auth_forbidden = [None, "user", "team"]
def get_users_extra(self):
return {
"team1": create_team(
"team1",
"101",
perms=[
# Required
"kfet.add_transfer",
# Convenience
"kfet.perform_negative_operations",
],
)
}
@property
def post_data(self):
return {
# General
"comment": "",
# Formset management
"form-TOTAL_FORMS": "10",
"form-INITIAL_FORMS": "0",
"form-MIN_NUM_FORMS": "1",
"form-MAX_NUM_FORMS": "1000",
# Transfer 1
"form-0-from_acc": str(self.accounts["user"].pk),
"form-0-to_acc": str(self.accounts["team"].pk),
"form-0-amount": "3.5",
# Transfer 2
"form-1-from_acc": str(self.accounts["team"].pk),
"form-1-to_acc": str(self.accounts["team1"].pk),
"form-1-amount": "2.4",
}
def test_ok(self):
r = self.client.post(self.url, self.post_data)
self.assertEqual(r.status_code, 200)
user = self.accounts["user"]
user.refresh_from_db()
self.assertEqual(user.balance, Decimal("-3.5"))
team = self.accounts["team"]
team.refresh_from_db()
self.assertEqual(team.balance, Decimal("1.1"))
team1 = self.accounts["team1"]
team1.refresh_from_db()
self.assertEqual(team1.balance, Decimal("2.4"))
class TransferCancelViewTests(ViewTestCaseMixin, TestCase):
url_name = "kfet.transfers.cancel"
url_expected = "/k-fet/transfers/cancel"
http_methods = ["POST"]
auth_user = "team1"
auth_forbidden = [None, "user", "team"]
def get_users_extra(self):
return {
"team1": create_team(
"team1",
"101",
perms=[
# Convenience
"kfet.perform_negative_operations"
],
)
}
@property
def post_data(self):
return {"transfers[]": [self.transfer1.pk, self.transfer2.pk]}
def setUp(self):
super().setUp()
group = TransferGroup.objects.create()
self.transfer1 = Transfer.objects.create(
group=group,
from_acc=self.accounts["user"],
to_acc=self.accounts["team"],
amount="3.5",
)
self.transfer2 = Transfer.objects.create(
group=group,
from_acc=self.accounts["team"],
to_acc=self.accounts["root"],
amount="2.4",
)
def test_ok(self):
r = self.client.post(self.url, self.post_data)
self.assertEqual(r.status_code, 200)
user = self.accounts["user"]
user.refresh_from_db()
self.assertEqual(user.balance, Decimal("3.5"))
team = self.accounts["team"]
team.refresh_from_db()
self.assertEqual(team.balance, Decimal("-1.1"))
root = self.accounts["root"]
root.refresh_from_db()
self.assertEqual(root.balance, Decimal("-2.4"))
class InventoryListViewTests(ViewTestCaseMixin, TestCase):
url_name = "kfet.inventory"
url_expected = "/k-fet/inventaires/"
auth_user = "team"
auth_forbidden = [None, "user"]
def setUp(self):
super().setUp()
self.inventory = Inventory.objects.create(by=self.accounts["team"])
category = ArticleCategory.objects.create(name="Category")
article = Article.objects.create(name="Article", category=category)
InventoryArticle.objects.create(
inventory=self.inventory, article=article, stock_old=5, stock_new=0
)
def test_ok(self):
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
inventories = r.context["inventories"]
self.assertQuerysetEqual(inventories, map(repr, [self.inventory]))
class InventoryCreateViewTests(ViewTestCaseMixin, TestCase):
url_name = "kfet.inventory.create"
url_expected = "/k-fet/inventaires/new"
http_methods = ["GET", "POST"]
auth_user = "team"
auth_forbidden = [None, "user"]
def get_users_extra(self):
return {"team1": create_team("team1", "101", perms=["kfet.add_inventory"])}
@property
def post_data(self):
return {
# Formset management
"form-TOTAL_FORMS": "2",
"form-INITIAL_FORMS": "2",
"form-MIN_NUM_FORMS": "0",
"form-MAX_NUM_FORMS": "1000",
# Article 1
"form-0-article": str(self.article1.pk),
"form-0-stock_new": "5",
# Article 2
"form-1-article": str(self.article2.pk),
"form-1-stock_new": "10",
}
def setUp(self):
super().setUp()
category = ArticleCategory.objects.create(name="Category")
self.article1 = Article.objects.create(category=category, name="Article 1")
self.article2 = Article.objects.create(category=category, name="Article 2")
def test_get_ok(self):
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
def test_post_ok(self):
client = Client()
client.login(username="team1", password="team1")
r = client.post(self.url, self.post_data)
self.assertRedirects(r, reverse("kfet.inventory"))
def test_post_forbidden(self):
r = self.client.post(self.url, self.post_data)
self.assertForbiddenKfet(r)
class InventoryReadViewTests(ViewTestCaseMixin, TestCase):
url_name = "kfet.inventory.read"
auth_user = "team"
auth_forbidden = [None, "user"]
@property
def url_kwargs(self):
return {"pk": self.inventory.pk}
@property
def url_expected(self):
return "/k-fet/inventaires/{}".format(self.inventory.pk)
def setUp(self):
super().setUp()
self.inventory = Inventory.objects.create(by=self.accounts["team"])
category = ArticleCategory.objects.create(name="Category")
article = Article.objects.create(name="Article", category=category)
InventoryArticle.objects.create(
inventory=self.inventory, article=article, stock_old=5, stock_new=0
)
def test_ok(self):
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
class OrderListViewTests(ViewTestCaseMixin, TestCase):
url_name = "kfet.order"
url_expected = "/k-fet/orders/"
auth_user = "team"
auth_forbidden = [None, "user"]
def setUp(self):
super().setUp()
category = ArticleCategory.objects.create(name="Category")
article = Article.objects.create(name="Article", category=category)
supplier = Supplier.objects.create(name="Supplier")
SupplierArticle.objects.create(supplier=supplier, article=article)
self.order = Order.objects.create(supplier=supplier)
OrderArticle.objects.create(
order=self.order, article=article, quantity_ordered=24
)
def test_ok(self):
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
orders = r.context["orders"]
self.assertQuerysetEqual(orders, map(repr, [self.order]))
class OrderReadViewTests(ViewTestCaseMixin, TestCase):
url_name = "kfet.order.read"
auth_user = "team"
auth_forbidden = [None, "user"]
@property
def url_kwargs(self):
return {"pk": self.order.pk}
@property
def url_expected(self):
return "/k-fet/orders/{}".format(self.order.pk)
def setUp(self):
super().setUp()
category = ArticleCategory.objects.create(name="Category")
article = Article.objects.create(name="Article", category=category)
supplier = Supplier.objects.create(name="Supplier")
SupplierArticle.objects.create(supplier=supplier, article=article)
self.order = Order.objects.create(supplier=supplier)
OrderArticle.objects.create(
order=self.order, article=article, quantity_ordered=24
)
def test_ok(self):
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
class SupplierUpdateViewTests(ViewTestCaseMixin, TestCase):
url_name = "kfet.order.supplier.update"
http_methods = ["GET", "POST"]
auth_user = "team"
auth_forbidden = [None, "user"]
@property
def url_kwargs(self):
return {"pk": self.supplier.pk}
@property
def url_expected(self):
return "/k-fet/orders/suppliers/{}/edit".format(self.supplier.pk)
def get_users_extra(self):
return {"team1": create_team("team1", "101", perms=["kfet.change_supplier"])}
@property
def post_data(self):
return {
"name": "The Supplier",
"phone": "",
"comment": "",
"address": "",
"email": "",
}
def setUp(self):
super().setUp()
self.supplier = Supplier.objects.create(name="Supplier")
def test_get_ok(self):
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
def test_post_ok(self):
client = Client()
client.login(username="team1", password="team1")
r = client.post(self.url, self.post_data)
self.assertRedirects(r, reverse("kfet.order"))
self.supplier.refresh_from_db()
self.assertEqual(self.supplier.name, "The Supplier")
def test_post_forbidden(self):
r = self.client.post(self.url, self.post_data)
self.assertForbiddenKfet(r)
class OrderCreateViewTests(ViewTestCaseMixin, TestCase):
url_name = "kfet.order.new"
auth_user = "team"
auth_forbidden = [None, "user"]
@property
def url_kwargs(self):
return {"pk": self.supplier.pk}
@property
def url_expected(self):
return "/k-fet/orders/suppliers/{}/new-order".format(self.supplier.pk)
def get_users_extra(self):
return {"team1": create_team("team1", "101", perms=["kfet.add_order"])}
@property
def post_data(self):
return {
# Formset management
"form-TOTAL_FORMS": "1",
"form-INITIAL_FORMS": "1",
"form-MIN_NUM_FORMS": "0",
"form-MAX_NUM_FORMS": "1000",
# Article
"form-0-article": self.article.pk,
"form-0-quantity_ordered": "20",
}
def setUp(self):
super().setUp()
category = ArticleCategory.objects.create(name="Category")
self.article = Article.objects.create(name="Article", category=category)
self.supplier = Supplier.objects.create(name="Supplier")
SupplierArticle.objects.create(supplier=self.supplier, article=self.article)
def test_get_ok(self):
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
@mock.patch("django.utils.timezone.now")
def test_post_ok(self, mock_now):
mock_now.return_value = self.now
client = Client()
client.login(username="team1", password="team1")
r = client.post(self.url, self.post_data)
order = Order.objects.get(at=self.now)
self.assertRedirects(r, reverse("kfet.order.read", args=[order.pk]))
def test_post_forbidden(self):
r = self.client.post(self.url, self.post_data)
self.assertForbiddenKfet(r)
class OrderToInventoryViewTests(ViewTestCaseMixin, TestCase):
url_name = "kfet.order.to_inventory"
http_methods = ["GET", "POST"]
auth_user = "team"
auth_forbidden = [None, "user"]
@property
def url_kwargs(self):
return {"pk": self.order.pk}
@property
def url_expected(self):
return "/k-fet/orders/{}/to_inventory".format(self.order.pk)
def get_users_extra(self):
return {"team1": create_team("team1", "101", perms=["kfet.order_to_inventory"])}
@property
def post_data(self):
return {
# Formset mangaement
"form-TOTAL_FORMS": "1",
"form-INITIAL_FORMS": "1",
"form-MIN_NUM_FORMS": "0",
"form-MAX_NUM_FORMS": "1000",
# Article 1
"form-0-article": self.article.pk,
"form-0-quantity_received": "20",
"form-0-price_HT": "",
"form-0-TVA": "",
"form-0-rights": "",
}
def setUp(self):
super().setUp()
category = ArticleCategory.objects.create(name="Category")
self.article = Article.objects.create(name="Article", category=category)
supplier = Supplier.objects.create(name="Supplier")
SupplierArticle.objects.create(supplier=supplier, article=self.article)
self.order = Order.objects.create(supplier=supplier)
OrderArticle.objects.create(
order=self.order, article=self.article, quantity_ordered=24
)
def test_get_ok(self):
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
@mock.patch("django.utils.timezone.now")
def test_post_ok(self, mock_now):
mock_now.return_value = self.now
client = Client()
client.login(username="team1", password="team1")
r = client.post(self.url, self.post_data)
self.assertRedirects(r, reverse("kfet.order"))
inventory = Inventory.objects.first()
self.assertInstanceExpected(
inventory,
{"by": self.accounts["team1"], "at": self.now, "order": self.order},
)
self.assertQuerysetEqual(inventory.articles.all(), map(repr, [self.article]))
compte = InventoryArticle.objects.get(article=self.article)
self.assertInstanceExpected(
compte, {"stock_old": 0, "stock_new": 20, "stock_error": 0}
)
def test_post_forbidden(self):
r = self.client.post(self.url, self.post_data)
self.assertForbiddenKfet(r)
View git blame Copy permalink