j3d1/toolshed
2
1
Fork 0
Code Issues 9 Pull requests 1 Projects Releases Packages Wiki Activity

refactor tests for better composability
All checks were successful
continuous-integration/drone/push Build is passing
Details

Browse source
This commit is contained in:
j3d1 2023-07-01 20:42:57 +02:00
parent 816543a0ab
commit 68a9d520f2
10 changed files with 316 additions and 301 deletions
Download patch file Download diff file Expand all files Collapse all files

1
backend/toolshed/tests/__init__.py
View file

@ -0,0 +1 @@
from .fixtures import *

25
backend/toolshed/tests/fixtures.py Normal file
View file

@ -0,0 +1,25 @@
from toolshed.models import Category, Tag, Property, InventoryItem, ItemProperty
class InventoryTestMixin:
def prepare_inventory(self):
self.f['local_user1'].friends.add(self.f['local_user2'].public_identity)
self.f['cat1'] = Category.objects.create(name='cat1')
self.f['cat2'] = Category.objects.create(name='cat2')
self.f['tag1'] = Tag.objects.create(name='tag1', category=self.f['cat1'])
self.f['tag2'] = Tag.objects.create(name='tag2', category=self.f['cat1'])
self.f['tag3'] = Tag.objects.create(name='tag3')
self.f['prop1'] = Property.objects.create(name='prop1')
self.f['prop2'] = Property.objects.create(name='prop2')
self.f['prop3'] = Property.objects.create(name='prop3', category=self.f['cat1'])
self.f['item1'] = InventoryItem.objects.create(owner=self.f['local_user1'], owned_quantity=1, name='test1',
description='test',
category=self.f['cat1'], availability_policy='friends')
self.f['item2'] = InventoryItem.objects.create(owner=self.f['local_user1'], owned_quantity=1, name='test2',
description='test2',
category=self.f['cat1'], availability_policy='friends')
self.f['item2'].tags.add(self.f['tag1'], through_defaults={})
self.f['item2'].tags.add(self.f['tag2'], through_defaults={})
ItemProperty.objects.create(inventory_item=self.f['item2'], property=self.f['prop1'], value='value1').save()
ItemProperty.objects.create(inventory_item=self.f['item2'], property=self.f['prop2'], value='value2').save()

33
backend/toolshed/tests/test_api.py
View file

@ -1,25 +1,25 @@
from django.test import TestCase, Client
from authentication.tests import UserTestCase, SignatureAuthClient
from django.test import Client
from authentication.tests import UserTestMixin, SignatureAuthClient, ToolshedTestCase
from toolshed.models import Category, Tag, Property
anonymous_client = Client()
client = SignatureAuthClient()
class CombinedApiTestCase(UserTestCase):
class CombinedApiTestCase(UserTestMixin, ToolshedTestCase):
def setUp(self):
super().setUp()
self.cat1 = Category.objects.create(name='cat1')
self.cat2 = Category.objects.create(name='cat2')
self.cat3 = Category.objects.create(name='cat3')
self.tag1 = Tag.objects.create(name='tag1')
self.tag2 = Tag.objects.create(name='tag2')
self.tag3 = Tag.objects.create(name='tag3')
self.prop1 = Property.objects.create(name='prop1')
self.prop2 = Property.objects.create(name='prop2')
self.prop3 = Property.objects.create(name='prop3')
self.prepare_users()
self.f['cat1'] = Category.objects.create(name='cat1')
self.f['cat2'] = Category.objects.create(name='cat2')
self.f['cat3'] = Category.objects.create(name='cat3')
self.f['tag1'] = Tag.objects.create(name='tag1')
self.f['tag2'] = Tag.objects.create(name='tag2')
self.f['tag3'] = Tag.objects.create(name='tag3')
self.f['prop1'] = Property.objects.create(name='prop1')
self.f['prop2'] = Property.objects.create(name='prop2')
self.f['prop3'] = Property.objects.create(name='prop3')
def test_domains_anonymous(self):
response = anonymous_client.get('/api/domains/')
@ -27,7 +27,7 @@ class CombinedApiTestCase(UserTestCase):
self.assertEqual(response.json(), ['example.com'])
def test_domains_authenticated(self):
response = client.get('/api/domains/', self.local_user1)
response = client.get('/api/domains/', self.f['local_user1'])
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json(), ['example.com'])
@ -36,7 +36,7 @@ class CombinedApiTestCase(UserTestCase):
self.assertEqual(response.status_code, 403)
def test_combined_api(self):
response = client.get('/api/info/', self.local_user1)
response = client.get('/api/info/', self.f['local_user1'])
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json()['policies'], ['private', 'friends', 'internal', 'public'])
self.assertEqual(response.json()['categories'], ['cat1', 'cat2', 'cat3'])
@ -48,7 +48,6 @@ class CombinedApiTestCase(UserTestCase):
self.assertEqual(response.status_code, 403)
def test_policy_api(self):
response = client.get('/api/availability_policies/', self.local_user1)
response = client.get('/api/availability_policies/', self.f['local_user1'])
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json(), ['private', 'friends', 'internal', 'public'])

48
backend/toolshed/tests/test_category.py
View file

@ -1,51 +1,53 @@
from authentication.tests import UserTestCase, SignatureAuthClient
from authentication.tests import SignatureAuthClient, UserTestMixin, ToolshedTestCase
from toolshed.models import Category
client = SignatureAuthClient()
class CategoryTestCase(UserTestCase):
class CategoryTestCase(UserTestMixin, ToolshedTestCase):
def setUp(self):
super().setUp()
self.cat1 = Category.objects.create(name='cat1')
self.cat1.save()
self.cat2 = Category.objects.create(name='cat2')
self.cat2.save()
self.cat3 = Category.objects.create(name='cat3')
self.cat3.save()
self.prepare_users()
self.f['cat1'] = Category.objects.create(name='cat1')
self.f['cat1'].save()
self.f['cat2'] = Category.objects.create(name='cat2')
self.f['cat2'].save()
self.f['cat3'] = Category.objects.create(name='cat3')
self.f['cat3'].save()
def test_get_categories(self):
subcat1 = Category.objects.create(name='subcat1', parent=self.cat1)
subcat1 = Category.objects.create(name='subcat1', parent=self.f['cat1'])
subcat1.save()
subcat2 = Category.objects.create(name='subcat2', parent=self.cat1)
subcat2 = Category.objects.create(name='subcat2', parent=self.f['cat1'])
subcat2.save()
subcat3 = Category.objects.create(name='subcat3', parent=subcat1)
subcat3.save()
self.assertEqual(self.cat1.children.count(), 2)
self.assertEqual(self.cat1.children.first(), subcat1)
self.assertEqual(self.cat1.children.last(), subcat2)
self.assertEqual(subcat1.parent, self.cat1)
self.assertEqual(subcat2.parent, self.cat1)
self.assertEqual(self.f['cat1'].children.count(), 2)
self.assertEqual(self.f['cat1'].children.first(), subcat1)
self.assertEqual(self.f['cat1'].children.last(), subcat2)
self.assertEqual(subcat1.parent, self.f['cat1'])
self.assertEqual(subcat2.parent, self.f['cat1'])
self.assertEqual(subcat3.parent, subcat1)
self.assertEqual(str(subcat1), 'cat1/subcat1')
self.assertEqual(str(subcat2), 'cat1/subcat2')
self.assertEqual(str(subcat3), 'cat1/subcat1/subcat3')
class CategoryApiTestCase(UserTestCase):
class CategoryApiTestCase(UserTestMixin, ToolshedTestCase):
def setUp(self):
super().setUp()
self.cat1 = Category.objects.create(name='cat1')
self.cat1.save()
self.cat2 = Category.objects.create(name='cat2')
self.cat2.save()
self.cat3 = Category.objects.create(name='cat3')
self.cat3.save()
self.prepare_users()
self.f['cat1'] = Category.objects.create(name='cat1')
self.f['cat1'].save()
self.f['cat2'] = Category.objects.create(name='cat2')
self.f['cat2'].save()
self.f['cat3'] = Category.objects.create(name='cat3')
self.f['cat3'].save()
def test_get_categories(self):
reply = client.get('/api/categories/', self.local_user1)
reply = client.get('/api/categories/', self.f['local_user1'])
self.assertEqual(reply.status_code, 200)
self.assertEqual(len(reply.json()), 3)
self.assertEqual(reply.json()[0], 'cat1')

94
backend/toolshed/tests/test_friend.py
View file

@ -1,75 +1,77 @@
from authentication.tests import UserTestCase, SignatureAuthClient
from authentication.tests import SignatureAuthClient, UserTestMixin, ToolshedTestCase
client = SignatureAuthClient()
class FriendTestCase(UserTestCase):
class FriendTestCase(UserTestMixin, ToolshedTestCase):
def setUp(self):
super().setUp()
self.prepare_users()
def test_friendship_iternal(self):
self.assertEqual(self.local_user1.friends.count(), 0)
self.assertEqual(self.local_user2.friends.count(), 0)
self.assertEqual(self.ext_user1.friends.count(), 0)
self.assertEqual(self.ext_user2.friends.count(), 0)
self.local_user1.friends.add(self.local_user2.public_identity)
self.assertEqual(self.local_user1.friends.count(), 1)
self.assertEqual(self.local_user2.friends.count(), 1)
self.assertEqual(self.ext_user1.friends.count(), 0)
self.assertEqual(self.ext_user2.friends.count(), 0)
self.assertEqual(self.local_user1.friends.first(), self.local_user2.public_identity)
self.assertEqual(self.local_user2.friends.first(), self.local_user1.public_identity)
self.assertEqual(self.f['local_user1'].friends.count(), 0)
self.assertEqual(self.f['local_user2'].friends.count(), 0)
self.assertEqual(self.f['ext_user1'].friends.count(), 0)
self.assertEqual(self.f['ext_user2'].friends.count(), 0)
self.f['local_user1'].friends.add(self.f['local_user2'].public_identity)
self.assertEqual(self.f['local_user1'].friends.count(), 1)
self.assertEqual(self.f['local_user2'].friends.count(), 1)
self.assertEqual(self.f['ext_user1'].friends.count(), 0)
self.assertEqual(self.f['ext_user2'].friends.count(), 0)
self.assertEqual(self.f['local_user1'].friends.first(), self.f['local_user2'].public_identity)
self.assertEqual(self.f['local_user2'].friends.first(), self.f['local_user1'].public_identity)
def test_friendship_external(self):
self.assertEqual(self.local_user1.friends.count(), 0)
self.assertEqual(self.local_user2.friends.count(), 0)
self.assertEqual(self.ext_user1.friends.count(), 0)
self.assertEqual(self.ext_user2.friends.count(), 0)
self.local_user1.friends.add(self.ext_user1.public_identity)
self.assertEqual(self.local_user1.friends.count(), 1)
self.assertEqual(self.local_user2.friends.count(), 0)
self.assertEqual(self.ext_user1.friends.count(), 1)
self.assertEqual(self.ext_user2.friends.count(), 0)
self.assertEqual(self.local_user1.friends.first(), self.ext_user1.public_identity)
self.assertEqual(self.ext_user1.friends.first(), self.local_user1.public_identity)
self.assertEqual(self.f['local_user1'].friends.count(), 0)
self.assertEqual(self.f['local_user2'].friends.count(), 0)
self.assertEqual(self.f['ext_user1'].friends.count(), 0)
self.assertEqual(self.f['ext_user2'].friends.count(), 0)
self.f['local_user1'].friends.add(self.f['ext_user1'].public_identity)
self.assertEqual(self.f['local_user1'].friends.count(), 1)
self.assertEqual(self.f['local_user2'].friends.count(), 0)
self.assertEqual(self.f['ext_user1'].friends.count(), 1)
self.assertEqual(self.f['ext_user2'].friends.count(), 0)
self.assertEqual(self.f['local_user1'].friends.first(), self.f['ext_user1'].public_identity)
self.assertEqual(self.f['ext_user1'].friends.first(), self.f['local_user1'].public_identity)
def test_friend_from_external(self):
self.assertEqual(self.local_user1.friends.count(), 0)
self.assertEqual(self.local_user2.friends.count(), 0)
self.assertEqual(self.ext_user1.friends.count(), 0)
self.assertEqual(self.ext_user2.friends.count(), 0)
self.ext_user1.friends.add(self.local_user1.public_identity)
self.assertEqual(self.local_user1.friends.count(), 1)
self.assertEqual(self.local_user2.friends.count(), 0)
self.assertEqual(self.ext_user1.friends.count(), 1)
self.assertEqual(self.ext_user2.friends.count(), 0)
self.assertEqual(self.local_user1.friends.first(), self.ext_user1.public_identity)
self.assertEqual(self.ext_user1.friends.first(), self.local_user1.public_identity)
self.assertEqual(self.f['local_user1'].friends.count(), 0)
self.assertEqual(self.f['local_user2'].friends.count(), 0)
self.assertEqual(self.f['ext_user1'].friends.count(), 0)
self.assertEqual(self.f['ext_user2'].friends.count(), 0)
self.f['ext_user1'].friends.add(self.f['local_user1'].public_identity)
self.assertEqual(self.f['local_user1'].friends.count(), 1)
self.assertEqual(self.f['local_user2'].friends.count(), 0)
self.assertEqual(self.f['ext_user1'].friends.count(), 1)
self.assertEqual(self.f['ext_user2'].friends.count(), 0)
self.assertEqual(self.f['local_user1'].friends.first(), self.f['ext_user1'].public_identity)
self.assertEqual(self.f['ext_user1'].friends.first(), self.f['local_user1'].public_identity)
class FriendApiTestCase(UserTestCase):
class FriendApiTestCase(UserTestMixin, ToolshedTestCase):
def setUp(self):
super().setUp()
self.local_user1.friends.add(self.local_user2.public_identity)
self.local_user1.friends.add(self.ext_user1.public_identity)
self.ext_user1.friends.add(self.local_user1.public_identity)
self.prepare_users()
self.f['local_user1'].friends.add(self.f['local_user2'].public_identity)
self.f['local_user1'].friends.add(self.f['ext_user1'].public_identity)
self.f['ext_user1'].friends.add(self.f['local_user1'].public_identity)
def test_friend_list_internal1(self):
reply = client.get('/api/friends/', self.local_user1)
reply = client.get('/api/friends/', self.f['local_user1'])
self.assertEqual(reply.status_code, 200)
self.assertEqual(len(reply.json()), 2)
self.assertEqual(reply.json()[0]['username'], str(self.local_user2))
self.assertEqual(reply.json()[1]['username'], str(self.ext_user1))
self.assertEqual(reply.json()[0]['username'], str(self.f['local_user2']))
self.assertEqual(reply.json()[1]['username'], str(self.f['ext_user1']))
def test_friend_list_internal2(self):
reply = client.get('/api/friends/', self.local_user2)
reply = client.get('/api/friends/', self.f['local_user2'])
self.assertEqual(reply.status_code, 200)
self.assertEqual(len(reply.json()), 1)
self.assertEqual(reply.json()[0]['username'], str(self.local_user1))
self.assertEqual(reply.json()[0]['username'], str(self.f['local_user1']))
def test_friend_list_external(self):
reply = client.get('/api/friends/', self.ext_user1)
reply = client.get('/api/friends/', self.f['ext_user1'])
self.assertEqual(reply.status_code, 200)
self.assertEqual(len(reply.json()), 1)
self.assertEqual(reply.json()[0]['username'], str(self.local_user1))
self.assertEqual(reply.json()[0]['username'], str(self.f['local_user1']))

76
backend/toolshed/tests/test_inventory.py
View file

@ -1,47 +1,19 @@
from authentication.models import ToolshedUser
from authentication.tests import UserTestCase, SignatureAuthClient
from toolshed.models import InventoryItem, Tag, Property, ItemProperty, Category
from authentication.tests import SignatureAuthClient, UserTestMixin, ToolshedTestCase
from toolshed.models import InventoryItem, Category
from toolshed.tests import InventoryTestMixin
client = SignatureAuthClient()
class InventoryTestCase(UserTestCase):
class InventoryTestCase(UserTestMixin, InventoryTestMixin, ToolshedTestCase):
def setUp(self):
super().setUp()
self.user1 = ToolshedUser.objects.get(username="testuser")
self.user2 = ToolshedUser.objects.get(username="testuser2")
self.user1.friends.add(self.user2.public_identity)
self.user2.friends.add(self.user1.public_identity)
self.cat1 = Category.objects.create(name='cat1')
self.cat1.save()
self.cat2 = Category.objects.create(name='cat2')
self.cat2.save()
self.tag1 = Tag.objects.create(name='tag1', category=self.cat1)
self.tag1.save()
self.tag2 = Tag.objects.create(name='tag2', category=self.cat1)
self.tag2.save()
self.tag3 = Tag.objects.create(name='tag3')
self.tag3.save()
self.prop1 = Property.objects.create(name='prop1')
self.prop1.save()
self.prop2 = Property.objects.create(name='prop2')
self.prop2.save()
self.prop3 = Property.objects.create(name='prop3', category=self.cat1)
self.prop3.save()
InventoryItem.objects.create(owner=self.user1, owned_quantity=1, name='test1', description='test',
category=self.cat1, availability_policy='friends').save()
item2 = InventoryItem.objects.create(owner=self.user1, owned_quantity=1, name='test2', description='test2',
category=self.cat1, availability_policy='friends')
item2.save()
item2.tags.add(self.tag1, through_defaults={})
item2.tags.add(self.tag2, through_defaults={})
ItemProperty.objects.create(inventory_item=item2, property=self.prop1, value='value1').save()
ItemProperty.objects.create(inventory_item=item2, property=self.prop2, value='value2').save()
self.prepare_users()
self.prepare_inventory()
def test_get_inventory(self):
reply = client.get('/api/inventory_items/', self.user1)
reply = client.get('/api/inventory_items/', self.f['local_user1'])
self.assertEqual(reply.status_code, 200)
self.assertEqual(len(reply.json()), 2)
self.assertEqual(reply.json()[0]['name'], 'test1')
@ -61,7 +33,7 @@ class InventoryTestCase(UserTestCase):
self.assertEqual(reply.json()[1]['availability_policy'], 'friends')
def test_post_new_item(self):
reply = client.post('/api/inventory_items/', self.user1, {
reply = client.post('/api/inventory_items/', self.f['local_user1'], {
'availability_policy': 'friends',
'category': 'cat2',
'name': 'test3',
@ -79,12 +51,12 @@ class InventoryTestCase(UserTestCase):
self.assertEqual(item.name, 'test3')
self.assertEqual(item.description, 'test')
self.assertEqual(item.owned_quantity, 1)
self.assertEqual([t for t in item.tags.all()], [self.tag1, self.tag2])
self.assertEqual([p for p in item.properties.all()], [self.prop1, self.prop2])
self.assertEqual([t for t in item.tags.all()], [self.f['tag1'], self.f['tag2']])
self.assertEqual([p for p in item.properties.all()], [self.f['prop1'], self.f['prop2']])
self.assertEqual([p.value for p in item.itemproperty_set.all()], ['value3', 'value4'])
def test_post_new_item2(self):
reply = client.post('/api/inventory_items/', self.user1, {
reply = client.post('/api/inventory_items/', self.f['local_user1'], {
'availability_policy': 'friends',
'name': 'test3',
'description': 'test',
@ -103,7 +75,7 @@ class InventoryTestCase(UserTestCase):
self.assertEqual([p for p in item.properties.all()], [])
def test_post_new_item3(self):
reply = client.post('/api/inventory_items/', self.user1, {
reply = client.post('/api/inventory_items/', self.f['local_user1'], {
'availability_policy': 'friends',
'name': 'test3',
'description': 'test',
@ -123,7 +95,7 @@ class InventoryTestCase(UserTestCase):
self.assertEqual([p for p in item.properties.all()], [])
def test_put_item(self):
reply = client.put('/api/inventory_items/1/', self.user1, {
reply = client.put('/api/inventory_items/1/', self.f['local_user1'], {
'availability_policy': 'friends',
'name': 'test4',
'description': 'new description',
@ -141,12 +113,12 @@ class InventoryTestCase(UserTestCase):
self.assertEqual(item.name, 'test4')
self.assertEqual(item.description, 'new description')
self.assertEqual(item.owned_quantity, 100)
self.assertEqual([t for t in item.tags.all()], [self.tag1, self.tag2, self.tag3])
self.assertEqual([p for p in item.properties.all()], [self.prop1, self.prop2, self.prop3])
self.assertEqual([t for t in item.tags.all()], [self.f['tag1'], self.f['tag2'], self.f['tag3']])
self.assertEqual([p for p in item.properties.all()], [self.f['prop1'], self.f['prop2'], self.f['prop3']])
self.assertEqual([p.value for p in item.itemproperty_set.all()], ['value5', 'value6', 'value7'])
def test_patch_item(self):
reply = client.patch('/api/inventory_items/1/', self.user1, {
reply = client.patch('/api/inventory_items/1/', self.f['local_user1'], {
'description': 'new description2',
'category': 'cat1',
'owned_quantity': 100,
@ -161,12 +133,12 @@ class InventoryTestCase(UserTestCase):
self.assertEqual(item.name, 'test1')
self.assertEqual(item.description, 'new description2')
self.assertEqual(item.owned_quantity, 100)
self.assertEqual([t for t in item.tags.all()], [self.tag3])
self.assertEqual([p for p in item.properties.all()], [self.prop3])
self.assertEqual([t for t in item.tags.all()], [self.f['tag3']])
self.assertEqual([p for p in item.properties.all()], [self.f['prop3']])
self.assertEqual([p.value for p in item.itemproperty_set.all()], ['value8'])
def test_patch_item2(self):
reply = client.patch('/api/inventory_items/1/', self.user1, {
reply = client.patch('/api/inventory_items/1/', self.f['local_user1'], {
'description': 'new description2',
'category': None,
'owned_quantity': 100,
@ -185,14 +157,14 @@ class InventoryTestCase(UserTestCase):
self.assertEqual([p for p in item.properties.all()], [])
def test_delete_item(self):
reply = client.delete('/api/inventory_items/1/', self.user1)
reply = client.delete('/api/inventory_items/1/', self.f['local_user1'])
self.assertEqual(reply.status_code, 204)
self.assertEqual(InventoryItem.objects.count(), 1)
self.assertEqual(InventoryItem.objects.get(id=2).name, 'test2')
self.assertEqual(InventoryItem.objects.filter(name='test1').count(), 0)
def test_search_items(self):
reply = client.get('/api/search/?query=test', self.user1)
reply = client.get('/api/search/?query=test', self.f['local_user1'])
self.assertEqual(reply.status_code, 200)
self.assertEqual(len(reply.json()), 2)
self.assertEqual(reply.json()[0]['name'], 'test1')
@ -212,18 +184,18 @@ class InventoryTestCase(UserTestCase):
self.assertEqual(reply.json()[1]['availability_policy'], 'friends')
def test_search_items2(self):
reply = client.get('/api/search/?query=test', self.user2)
reply = client.get('/api/search/?query=test', self.f['local_user2'])
self.assertEqual(reply.status_code, 200)
self.assertEqual(len(reply.json()), 2)
self.assertEqual(reply.json()[0]['name'], 'test1')
self.assertEqual(reply.json()[1]['name'], 'test2')
def test_search_items_fail(self):
reply = client.get('/api/search/', self.user1)
reply = client.get('/api/search/', self.f['local_user1'])
self.assertEqual(reply.status_code, 400)
self.assertEqual(reply.json()['error'], 'No query provided.')
def test_search_items_fail2(self):
reply = client.get('/api/search/?query=test', self.ext_user1)
reply = client.get('/api/search/?query=test', self.f['ext_user1'])
self.assertEqual(reply.status_code, 200)
self.assertEqual(len(reply.json()), 0)

68
backend/toolshed/tests/test_property.py
View file

@ -1,54 +1,56 @@
from authentication.tests import UserTestCase, SignatureAuthClient
from authentication.tests import SignatureAuthClient, UserTestMixin, ToolshedTestCase
from toolshed.models import Property, Category
client = SignatureAuthClient()
class PropertyTestCase(UserTestCase):
class PropertyTestCase(UserTestMixin, ToolshedTestCase):
def setUp(self):
super().setUp()
self.cat1 = Category.objects.create(name='cat1')
self.cat1.save()
self.prop1 = Property.objects.create(name='prop1')
self.prop1.save()
self.prop2 = Property.objects.create(name='prop2', description='prop2 description', category=self.cat1)
self.prop2.save()
self.prop3 = Property.objects.create(name='prop3', description='prop3 description', category=self.cat1)
self.prop3.save()
self.prepare_users()
self.f['cat1'] = Category.objects.create(name='cat1')
self.f['cat1'].save()
self.f['prop1'] = Property.objects.create(name='prop1')
self.f['prop1'].save()
self.f['prop2'] = Property.objects.create(name='prop2', description='prop2 description', category=self.f['cat1'])
self.f['prop2'].save()
self.f['prop3'] = Property.objects.create(name='prop3', description='prop3 description', category=self.f['cat1'])
self.f['prop3'].save()
def test_properties(self):
self.assertEqual(len(Property.objects.all()), 3)
self.assertEqual(self.prop1.name, 'prop1')
self.assertEqual(self.prop1.description, None)
self.assertEqual(self.prop1.category, None)
self.assertEqual(self.prop2.name, 'prop2')
self.assertEqual(self.prop2.description, 'prop2 description')
self.assertEqual(self.prop2.category, self.cat1)
self.assertEqual(self.prop3.name, 'prop3')
self.assertEqual(self.prop3.description, 'prop3 description')
self.assertEqual(self.prop3.category, self.cat1)
self.assertEqual(str(self.prop1), 'prop1')
self.assertEqual(str(self.prop2), 'prop2')
self.assertEqual(str(self.prop3), 'prop3')
self.assertEqual(self.cat1.properties.count(), 2)
self.assertEqual(self.cat1.properties.first(), self.prop2)
self.assertEqual(self.cat1.properties.last(), self.prop3)
self.assertEqual(self.f['prop1'].name, 'prop1')
self.assertEqual(self.f['prop1'].description, None)
self.assertEqual(self.f['prop1'].category, None)
self.assertEqual(self.f['prop2'].name, 'prop2')
self.assertEqual(self.f['prop2'].description, 'prop2 description')
self.assertEqual(self.f['prop2'].category, self.f['cat1'])
self.assertEqual(self.f['prop3'].name, 'prop3')
self.assertEqual(self.f['prop3'].description, 'prop3 description')
self.assertEqual(self.f['prop3'].category, self.f['cat1'])
self.assertEqual(str(self.f['prop1']), 'prop1')
self.assertEqual(str(self.f['prop2']), 'prop2')
self.assertEqual(str(self.f['prop3']), 'prop3')
self.assertEqual(self.f['cat1'].properties.count(), 2)
self.assertEqual(self.f['cat1'].properties.first(), self.f['prop2'])
self.assertEqual(self.f['cat1'].properties.last(), self.f['prop3'])
class PropertyApiTestCase(UserTestCase):
class PropertyApiTestCase(UserTestMixin, ToolshedTestCase):
def setUp(self):
super().setUp()
self.cat1 = Category.objects.create(name='cat1')
self.cat1.save()
self.cat2 = Category.objects.create(name='cat2')
self.cat2.save()
self.cat3 = Category.objects.create(name='cat3')
self.cat3.save()
self.prepare_users()
self.f['cat1'] = Category.objects.create(name='cat1')
self.f['cat1'].save()
self.f['cat2'] = Category.objects.create(name='cat2')
self.f['cat2'].save()
self.f['cat3'] = Category.objects.create(name='cat3')
self.f['cat3'].save()
def test_get_properties(self):
reply = client.get('/api/properties/', self.local_user1)
reply = client.get('/api/properties/', self.f['local_user1'])
self.assertEqual(reply.status_code, 200)
self.assertEqual(len(reply.json()), 0)
prop1 = Property.objects.create(name='prop1')

72
backend/toolshed/tests/test_tag.py
View file

@ -1,56 +1,58 @@
from authentication.tests import UserTestCase, SignatureAuthClient
from authentication.tests import SignatureAuthClient, UserTestMixin, ToolshedTestCase
from toolshed.models import Tag, Category
client = SignatureAuthClient()
class TagTestCase(UserTestCase):
class TagTestCase(UserTestMixin, ToolshedTestCase):
def setUp(self):
super().setUp()
self.cat1 = Category.objects.create(name='cat1')
self.cat1.save()
self.tag1 = Tag.objects.create(name='tag1', description='tag1 description', category=self.cat1)
self.tag1.save()
self.tag2 = Tag.objects.create(name='tag2', description='tag2 description', category=self.cat1)
self.tag2.save()
self.tag3 = Tag.objects.create(name='tag3')
self.tag3.save()
self.prepare_users()
self.f['cat1'] = Category.objects.create(name='cat1')
self.f['cat1'].save()
self.f['tag1'] = Tag.objects.create(name='tag1', description='tag1 description', category=self.f['cat1'])
self.f['tag1'].save()
self.f['tag2'] = Tag.objects.create(name='tag2', description='tag2 description', category=self.f['cat1'])
self.f['tag2'].save()
self.f['tag3'] = Tag.objects.create(name='tag3')
self.f['tag3'].save()
def test_tags(self):
self.assertEqual(len(Tag.objects.all()), 3)
self.assertEqual(self.tag1.name, 'tag1')
self.assertEqual(self.tag1.description, 'tag1 description')
self.assertEqual(self.tag1.category, self.cat1)
self.assertEqual(self.tag2.name, 'tag2')
self.assertEqual(self.tag2.description, 'tag2 description')
self.assertEqual(self.tag2.category, self.cat1)
self.assertEqual(self.tag3.name, 'tag3')
self.assertEqual(self.tag3.description, None)
self.assertEqual(self.tag3.category, None)
self.assertEqual(str(self.tag1), 'tag1')
self.assertEqual(str(self.tag2), 'tag2')
self.assertEqual(str(self.tag3), 'tag3')
self.assertEqual(self.cat1.tags.count(), 2)
self.assertEqual(self.cat1.tags.first(), self.tag1)
self.assertEqual(self.cat1.tags.last(), self.tag2)
self.assertEqual(self.f['tag1'].name, 'tag1')
self.assertEqual(self.f['tag1'].description, 'tag1 description')
self.assertEqual(self.f['tag1'].category, self.f['cat1'])
self.assertEqual(self.f['tag2'].name, 'tag2')
self.assertEqual(self.f['tag2'].description, 'tag2 description')
self.assertEqual(self.f['tag2'].category, self.f['cat1'])
self.assertEqual(self.f['tag3'].name, 'tag3')
self.assertEqual(self.f['tag3'].description, None)
self.assertEqual(self.f['tag3'].category, None)
self.assertEqual(str(self.f['tag1']), 'tag1')
self.assertEqual(str(self.f['tag2']), 'tag2')
self.assertEqual(str(self.f['tag3']), 'tag3')
self.assertEqual(self.f['cat1'].tags.count(), 2)
self.assertEqual(self.f['cat1'].tags.first(), self.f['tag1'])
self.assertEqual(self.f['cat1'].tags.last(), self.f['tag2'])
class TagApiTestCase(UserTestCase):
class TagApiTestCase(UserTestMixin, ToolshedTestCase):
def setUp(self):
super().setUp()
self.cat1 = Category.objects.create(name='cat1')
self.cat1.save()
self.tag1 = Tag.objects.create(name='tag1', description='tag1 description', category=self.cat1)
self.tag1.save()
self.tag2 = Tag.objects.create(name='tag2', description='tag2 description', category=self.cat1)
self.tag2.save()
self.tag3 = Tag.objects.create(name='tag3')
self.tag3.save()
self.prepare_users()
self.f['cat1'] = Category.objects.create(name='cat1')
self.f['cat1'].save()
self.f['tag1'] = Tag.objects.create(name='tag1', description='tag1 description', category=self.f['cat1'])
self.f['tag1'].save()
self.f['tag2'] = Tag.objects.create(name='tag2', description='tag2 description', category=self.f['cat1'])
self.f['tag2'].save()
self.f['tag3'] = Tag.objects.create(name='tag3')
self.f['tag3'].save()
def test_get_tags(self):
reply = client.get('/api/tags/', self.local_user1)
reply = client.get('/api/tags/', self.f['local_user1'])
self.assertEqual(reply.status_code, 200)
self.assertEqual(len(reply.json()), 3)
self.assertEqual(reply.json()[0], 'tag1')