def test_leave_match(self):
faker = Faker()
mocked_user = {
"userId": 192,
"ptToken": faker.pystr(),
"nickName": faker.name(),
"userHeadPicUrl": faker.url()
}
mocked_parteam = mock.Mock(spec=ParteamMixin.get_session,
return_value=mocked_user)
ParteamMixin.get_session = mocked_parteam
team_order = mixer.blend(TeamOrder,
order_no=TeamOrder.get_new_order_no(),
total_fee=0.01)
mixer.blend(MatchMember,
match_id=self.match.id,
user_id=mocked_user["userId"],
group_id=0,
order_id=team_order.id,
total_fee=0.01)
mocked_refund = mock.Mock(spec=Parteam.order_refund, return_value=True)
Parteam.order_refund = mocked_refund
url = self.LEAVE_MATCH.format(match_id=self.match.id)
body = {}
self.auth_user = ParteamUser(mocked_user)
response = self.fetch(url, method="POST", body=json.dumps(body))
self.assertEqual(204, response.code, response.body.decode())
def test_get_members(self):
total = random.randint(1, 10)
fake_users = {}
for i in range(1, total + 1):
parteam_user = self.parteam_user_generator(i)
fake_users[i] = parteam_user
order = mixer.blend(TeamOrder,
order_no=TeamOrder.get_new_order_no(),
total_fee=0.01)
mixer.blend(MatchMember,
match_id=self.match.id,
user_id=parteam_user.id,
order_id=order.id,
extra_attrs={},
total_fee=0.01)
mocked_parteam_user = mock.Mock(Parteam.parteam_user,
return_value=fake_users)
Parteam.parteam_user = mocked_parteam_user
url = self.MEMBERS_PATH.format(match_id=self.match.id)
response = self.fetch(url, method="GET")
self.assertEqual(200, response.code, response.body.decode())
result = json.loads(response.body.decode())
self.assertEqual(total, len(result["members"]), result)
def test_new_application_approved(self):
user = mixer.blend(User)
match = mixer.blend(Match)
application = mixer.blend(SettlementApplication,
match_id=match.id,
user_id=user.id)
with self.assertRaises(SettlementApplicationExist):
MatchService.settlement_application(user, match)
def test_disapprove_processing_error(self):
admin = mixer.blend(Admin)
application = mixer.blend(SettlementApplication,
processing=ApplicationState.finished.value)
with self.assertRaises(ApplicationProcessingException):
SettlementService.disapprove(application, admin)
approved = SettlementApplication.get(id=application.id)
self.assertEqual(approved.processing, approved.processing,
"申请驳回报错后, 申请状态发生变化")
def test_disapprove(self):
admin = mixer.blend(Admin)
application = mixer.blend(SettlementApplication,
processing=ApplicationState.requesting.value)
SettlementService.disapprove(application, admin)
approved = SettlementApplication.get(id=application.id)
self.assertEqual(ApplicationState.disapproved.value,
approved.processing, "申请驳回失败")
self.assertEqual(admin.id, approved.admin_id, "审核人 ID 错误")
def test_get_article_obj(self):
category = mixer.blend(ArticleCategory)
article = mixer.blend(Article,
category=category.id,
state=Article.PUBLISHED,
approved=True)
url = self.DETAIL_PATH.format(article=article)
response = self.fetch(url)
self.assertEqual(200, response.code, response.body.decode())
def test_approve_processing_error(self):
admin = mixer.blend(Admin)
application = mixer.blend(SettlementApplication,
processing=ApplicationState.approved.value)
with self.assertRaises(ApplicationProcessingException):
SettlementService.approve(application, admin)
approved = SettlementApplication.get(id=application.id)
self.assertEqual(application.processing, approved.processing,
"审核报错后, 申请状态发生变化")
self.assertEqual(None, approved.admin_id, "审核人 ID 错误")
def test_approve(self):
mocked_settlement = mock.Mock(spec=settlement.delay, return_value=1)
settlement.delay = mocked_settlement
admin = mixer.blend(Admin)
application = mixer.blend(SettlementApplication,
processing=ApplicationState.requesting.value)
SettlementService.approve(application, admin)
approved = SettlementApplication.get(id=application.id)
self.assertEqual(ApplicationState.approved.value, approved.processing,
"审核后状态错误")
self.assertEqual(admin.id, approved.admin_id, "审核人 ID 错误")
def test_list_articles(self):
total_count = randint(1, 10)
for _ in range(0, total_count):
mixer.blend(Article, state=Article.PUBLISHED, approved=True)
response = self.fetch(self.ARTICLES_LIST)
self.assertEqual(200, response.code, response.body.decode())
result = json.loads(response.body.decode())
for article in result["articles"]:
self.assertEqual(article["state"], Article.PUBLISHED, "未发布文章不应该输出")
self.assertTrue(article["approved"], "未审核的文章不应该输出")
def test_get_article_obj_not_published(self):
category = mixer.blend(ArticleCategory)
article = mixer.blend(Article,
category=category.id,
state=Article.DRAFT)
url = self.DETAIL_PATH.format(article=article)
response = self.fetch(url)
self.assertEqual(422, response.code, "获取到未发布文章")
article = mixer.blend(Article, category=category.id, approved=False)
url = self.DETAIL_PATH.format(article=article)
response = self.fetch(url)
self.assertEqual(422, response.code, "获取到审核中的文章")
def test_mixer(mixer):
person = mixer.blend(Person)
assert person.name
assert person.id
assert person.birthday
pet = mixer.blend(Pet)
assert pet.name
assert pet.animal_type
assert pet.owner
with mixer.ctx(commit=True):
person = mixer.blend(Person)
assert person.id == 1
def _init_db(db):
tables = get_models_from_module(mod)
db.create_tables(tables)
user1 = mixer.blend(mod.User, email=mixer.RANDOM)
user2 = mixer.blend(mod.User, email=mixer.RANDOM)
mixer.cycle(5).blend(mod.Post,
author=user1,
title=mixer.RANDOM,
content=mixer.RANDOM)
mixer.cycle(5).blend(mod.Post,
author=user2,
title=mixer.RANDOM,
content=mixer.RANDOM)
mod.Followers.create(following_user=user2, followed_user=user1)
def test_members_function(self):
faker = Faker()
match = mixer.blend(Match)
mixer.blend(MatchMember,
match_id=match.id,
user_id=faker.random_int(),
total_fee=0.01)
mixer.blend(MatchMember,
match_id=match.id,
user_id=faker.random_int(),
total_fee=0.01)
members = MatchService.members(match)
self.assertEqual(2, len(members))
for row in members:
self.assertEqual(match.id, row.match_id)
def test_mixer(mixer):
person = mixer.blend(Person)
assert person.name
assert person.id
assert person.birthday
assert person.status in ("user", "moderator", "admin")
pet = mixer.blend(Pet)
assert pet.name
assert pet.animal_type
assert pet.owner
with mixer.ctx(commit=True):
person = mixer.blend(Person)
assert person.id == 1
def test_mixer(mixer):
person = mixer.blend(Person)
assert person.name
assert person.id
assert person.birthday
assert person.status in ('user', 'moderator', 'admin')
pet = mixer.blend(Pet)
assert pet.name
assert pet.animal_type
assert pet.owner
with mixer.ctx(commit=False):
person = mixer.blend(Person)
assert person.id
def test_mixer(mixer):
person = mixer.blend(Person)
assert person.name
assert person.id
assert person.birthday
assert person.status in ('user', 'moderator', 'admin')
pet = mixer.blend(Pet)
assert pet.name
assert pet.animal_type
assert pet.owner
with mixer.ctx(commit=False):
person = mixer.blend(Person)
assert person.id
def test_mixer():
from mixer.backend.peewee import mixer
person = mixer.blend(Person)
assert person.name
assert person.id
assert person.birthday
pet = mixer.blend(Pet)
assert pet.name
assert pet.animal_type
assert pet.owner
with mixer.ctx(commit=True):
person = mixer.blend(Person)
assert person.id == 1
def test_get_articles_with_category(self):
total_count = randint(1, 10)
category = mixer.blend(ArticleCategory, name="test_category")
for _ in range(0, total_count):
mixer.blend(Article,
state=Article.PUBLISHED,
approved=True,
category=category.id)
response = self.fetch(self.ARTICLES_LIST,
params={"category": category.name})
self.assertEqual(200, response.code, response.body.decode())
result = json.loads(response.body.decode())
self.assertTrue(len(result["articles"]) > 0, "返回文章列表为空")
for article in result["articles"]:
_category = article["category"]
self.assertRegex(_category["name"], r"{0}".format(category.name),
"获取到非指定分类")
def test_cancel(self):
faker = Faker()
user = mixer.blend(User)
team = mixer.blend(Team, sport=self.sport)
match = mixer.blend(Match,
state=Match.MatchState.opening.value,
team_id=team.id)
total_fee = 10.01
total_members = randint(1, 10)
for _ in range(0, total_members):
order = mixer.blend(TeamOrder,
team=team,
user=user,
order_no=TeamOrder.get_new_order_no(),
total_fee=total_fee,
payment_fee=total_fee)
mixer.blend(MatchMember,
match_id=match.id,
total_fee=total_fee,
order_id=order.id,
pt_order_no=faker.pystr())
MatchService.cancel(match, user)
def test_reload(mixer):
person = mixer.blend(Person, name='true')
person.name = 'wrong'
person = mixer.reload(person)
assert person.name == 'true'
def test_guard(mixer):
person = mixer.blend(Person)
person2 = mixer.guard(Person.name == person.name).blend(Person)
assert person.id == person2.id
def test_select(mixer):
person = mixer.blend(Person)
pet = mixer.blend(Pet, owner=mixer.SELECT)
assert person == pet.owner
def test_select(mixer):
person = mixer.blend(Person)
pet = mixer.blend(Pet, owner=mixer.SELECT)
assert person == pet.owner
def test_reload(mixer):
person = mixer.blend(Person, name='true')
person.name = 'wrong'
person = mixer.reload(person)
assert person.name == 'true'
def test_guard(mixer):
person = mixer.blend(Person)
person2 = mixer.guard(Person.name == person.name).blend(Person)
assert person.id == person2.id
def user():
return mixer.blend(mod.User,
username='******',
email='*****@*****.**',
password='******')
def initial_data(self):
faker = Faker()
self.sport = mixer.blend(Sport, name=faker.pystr())
def test_cancel_already_canceled(self):
user = mixer.blend(User)
match = mixer.blend(Match, state=Match.MatchState.cancelled)
with self.assertRaises(MatchStateError):
MatchService.cancel(match, user)
def test_new_application(self):
match = mixer.blend(Match)
user = mixer.blend(User)
MatchService.settlement_application(user=user, match=match)
def test_reload(mixer):
person = mixer.blend(Person, name="true")
person.name = "wrong"
person = mixer.reload(person)
assert person.name == "true"
