def test_get_member_edit(self):
url = reverse('member_edit', kwargs=dict(member_id=self.member.id))
c = Client()
c.force_login(self.user)
response = c.get(url)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.context['form'].instance, self.member)
class BacklogDetailViewTest(TestCase):
def setUp(self):
self.user = User.objects.create_user(
username='******',
email='*****@*****.**',
password='******'
)
self.name = "My first Backlog with User Stories"
self.description = "That is the description for my Backlog. It's optional tough."
self.backlog = Backlog.objects.create(
user=self.user,
name=self.name,
description=self.description
)
self.client = Client()
def tearDown(self):
pass
def test_backlog_detail_view_works(self):
#backlogs is protected by username and pw
response = self.client.get(reverse('backlog_detail_view',
kwargs={'uuid': str(self.backlog.uuid)}))
self.assertEqual(response.status_code, 302)
self.client.force_login(user=self.user)
response = self.client.get(reverse('backlog_detail_view',
kwargs={'uuid': str(self.backlog.uuid)}))
self.assertEqual(response.status_code, 200)
def test_process_all(self):
user = User.objects.create_user('test user')
c = Client()
c.force_login(user)
crash = self._create_uploaded_crash('some new id')
response = c.post('/process/all')
self.assertEqual(response.status_code, 200)
class WordAPITests(TestCase):
def setUp(self):
self.client = Client()
self.user = User.objects.create_user("user", "", "password")
self.word = Word(content="word", description="des_word")
self.word.save()
def test_word_api(self):
u"""单词 API 测试"""
response = self.client.get("/api/v1/word/"+str(self.word.id)) # 未登录
self.assertEqual(response.status_code, 401)
response = self.client.get("/api/v1/word/13213")
self.assertEqual(response.status_code, 401)
self.client.force_login(self.user)
response = self.client.get("/api/v1/word/"+str(self.word.id)) # 正常查询
self.assertEqual(response.status_code, 200)
ret_data = { "success": True, "word": self.word.information() }
self.assertEqual(json.loads(response.content), ret_data)
response = self.client.get("/api/v1/word/13213") # 查询不存在的 ID
self.assertEqual(response.status_code, 404)
def test_search_api(self):
u"""单词查询 API 测试"""
response = self.client.get("/api/v1/search?word=word")
self.assertEqual(response.status_code, 200)
ret_data = { "success": True, "word": self.word.information() }
self.assertEqual(json.loads(response.content), ret_data)
response = self.client.get("/api/v1/search?word=test")
self.assertEqual(response.status_code, 404)
response = self.client.get("/api/v1/search?word=123")
self.assertEqual(response.status_code, 404)
def create_client(self):
patcher = mocked_relations(User, Session)
patcher.start()
self.addCleanup(patcher.stop)
user = User(pk=users.KIVE_USER_PK)
User.objects.add(user)
User.objects.model = User
# noinspection PyUnresolvedReferences
patcher = patch.object(User._meta, 'default_manager', User.objects)
patcher.start()
self.addCleanup(patcher.stop)
dummy_session_key = 'dummysession'
dummy_session = Session(
session_key=dummy_session_key,
expire_date=now() + timedelta(days=1),
session_data=SessionStore().encode({
SESSION_KEY: users.KIVE_USER_PK,
HASH_SESSION_KEY: user.get_session_auth_hash(),
BACKEND_SESSION_KEY: 'django.contrib.auth.backends.ModelBackend'}))
Session.objects.add(dummy_session)
client = Client()
client.cookies[settings.SESSION_COOKIE_NAME] = dummy_session_key
client.force_login(kive_user())
return client
class SettingsWebdriver(BaseTestStaticLiveServerTestCase):
@classmethod
def setUpClass(cls):
cls.username = '******'
cls.email = '*****@*****.**'
cls.password = '******'
cls.live_server_url = 'http://web:8081'
super(SettingsWebdriver, cls).setUpClass()
def setUp(self):
self.user_object = get_user_model().objects.create_user(
username=self.username,
email=self.email,
password=self.password,
is_active=1
)
self.client = Client()
self.client.force_login(self.user_object)
self.cookie = self.client.cookies['sessionid']
self.driver.get(self.live_server_url + '/act/new/')
self.driver.add_cookie({
'name': 'sessionid',
'value': self.cookie.value,
'secure': False, 'path': '/'})
def tearDown(self):
pass
def test_set_details_settings(self):
self.driver.get(
self.live_server_url + '/' + self.username + '/settings/')
details = self.driver.find_element_by_id('user-details')
details.send_keys('just_for_test_details')
settings_btn = self.driver.find_element_by_id('setting-btn')
settings_btn.send_keys(Keys.ENTER)
self.wait_element_text('success-span', 'SUCCESS', 'class')
self.driver.get(
self.live_server_url + '/' + self.username + '/settings/')
new_details = self.driver.find_element_by_id(
'user-details').get_attribute('value')
self.assertEqual('just_for_test_details', new_details)
def test_set_gender_settings(self):
self.driver.get(
self.live_server_url + '/' + self.username + '/settings/')
details = self.driver.find_element_by_id('user-details')
details.send_keys('just_for_test_details')
element = Select(self.driver.find_element_by_id('id_user_gender'))
for i in element.options:
if i.text == 'MAIE':
i.click()
settings_btn = self.driver.find_element_by_id('setting-btn')
settings_btn.send_keys(Keys.ENTER)
self.wait_element_text('success-span', 'SUCCESS', 'class')
self.driver.get(
self.live_server_url + '/' + self.username + '/settings/')
gender = self.driver.find_element_by_id('id_user_gender')
self.assertEqual(gender.text, 'MAIE')
class GlimpseViewTests(TestCase):
def setUp(self):
user = User.objects.create(username='******', password='******')
# Every test needs a client.
self.client = Client()
self.client.force_login(user)
with open(os.path.join(os.path.dirname(__file__), 'resources/model.json')) as fin:
data = json.load(fin)
save_imported_model(data['model'])
def test_search_view(self):
version = Version.objects.first()
url = reverse('version_search', args=(version.model.id, version.id))
resp = self.client.post(url, data={'query': 'Product'})
self.assertEqual(200, resp.status_code)
self.assertEqual(2, len(resp.context['results']))
def test_search_view_uauthorized(self):
version = Version.objects.first()
url = reverse('version_search', args=(version.model.id, version.id))
expected_redirect = "{0}?next={1}".format(settings.LOGIN_URL, url)
resp = Client().post(url, data={'query': 'Product'})
self.assertEqual(302, resp.status_code)
self.assertEqual(expected_redirect, resp.url)
class TestNewProject(TestCase):
def setUp(self):
self.group = models.Group.objects.create(slug='mygroup')
self.user = models.User.objects.create(username='******')
self.group.add_admin(self.user)
self.client = Client()
self.client.force_login(self.user)
def test_create_project(self):
response = self.client.post(
'/_/group-settings/mygroup/new-project/',
{
'slug': 'myproject'
}
)
self.assertEqual(302, response.status_code)
self.assertTrue(self.group.projects.filter(slug='myproject').exists())
def test_create_group_validates_uniqueness(self):
self.group.projects.create(slug='myproject')
response = self.client.post(
'/_/group-settings/mygroup/new-project/',
{
'slug': 'myproject'
}
)
self.assertEqual(200, response.status_code)
self.assertIn('already exists', str(response.content))
class DashboardTestCase(TestCase):
def setUp(self):
self.client = Client()
self.developer_group = Group.objects.create(name='Developer')
self.first_developer = User.objects.create_user('first_developer')
self.first_developer.groups.add(self.developer_group)
self.first_normal_user = User.objects.create_user('first_normal_user')
def test_access_to_dashboard_as_developer(self):
"""
Developers should be able to access the dashboard.
Should return HTTP 200 - OK.
"""
self.client.force_login(self.first_developer)
response = self.client.get('/dashboard/')
self.assertEqual(response.status_code, 200)
def test_access_to_dashboard_as_normal_user(self):
"""
Normal users should not be able to access the the dashboard.
Should return HTTP 403 - Forbidden.
"""
self.client.force_login(self.first_normal_user)
response = self.client.post('/dashboard/')
self.assertEqual(response.status_code, 403)
def create_comment(data=None, parent=None, target=None, user=None):
from django.test import Client
import django_comments as comments
from django.contrib.sites.models import Site
Comment = comments.get_model()
body = {
'name': 'user_anonymous_name',
'email': '*****@*****.**',
'comment': 'test_comment',
}
if data:
body.update(data)
url = comments.get_form_target()
args = [target if target else Site.objects.all()[0]]
kwargs = {}
if parent is not None:
kwargs['parent'] = str(parent.pk)
body['parent'] = str(parent.pk)
form = comments.get_form()(*args, **kwargs)
body.update(form.generate_security_data())
client = Client()
if user:
client.force_login(user)
client.post(url, body, follow=True)
return Comment.objects.last()
class TestMissingSymbols(TestCase):
def setUp(self):
self.signature = Signature()
self.signature.signature = 'test'
self.signature.first_observed = timezone.now()
self.signature.last_observed = timezone.now()
self.crash = ProcessedCrash()
self.crash.modules = "Module|passwd|0|passwd|000000000000000000000000000000000|0x010d0000|0x01178fff|1\nModule|soffice.bin|5.3.0.0|soffice.bin|4B253D6CB7E740A997444A61FE6E511C2|0x010d0000|0x01178fff|1\nModule|mergedlo.dll|5.3.0.0|mergedlo.pdb|6C797FEC36EF447699D43D58FE1486102|0x66290000|0x6a401fff|0\nModule|actxprxy.dll|6.1.7601.17514|ActXPrxy.pdb|C674D3ABFBB34B75BC59063E6B68ABA12|0x6a710000|0x6a75dfff|0"
self.crash.upload_time = timezone.now()
self.crash.signature = self.signature
self.crash.save()
self.tmp_dir = tempfile.mkdtemp()
user = User.objects.create_user('test user')
self.c = Client()
self.c.force_login(user)
def tearDwon(self):
remove_dir(self.tmp_dir)
def test_get_missing_symbols(self):
with self.settings(SYMBOL_DIR=self.tmp_dir):
response = self.c.get('/upload/missing')
content = response.content;
content_split = content.splitlines()
self.assertIn("ActXPrxy.pdb,C674D3ABFBB34B75BC59063E6B68ABA12", content_split)
self.assertIn("soffice.bin,4B253D6CB7E740A997444A61FE6E511C2", content_split)
self.assertIn("mergedlo.pdb,6C797FEC36EF447699D43D58FE1486102", content_split)
self.assertEqual(len(content_split), 3)
def test_instantiation():
c = Client()
c.force_login(User.objects.first())
print c.post('/game/app-instantiate/24/', {u'solutionPathColor':
{u'type': u'color', u'value': u'#072a1f', u'parsing': False},
u'cellSize': {u'type': u'number', u'value': 35, u'parsing': False}})
def test_new_character_created(self):
"""
Test that new character gets created.
"""
csrf_client = Client(enforce_csrf_checks=True)
try:
csrf_client.force_login(self.test_user)
except AttributeError:
# For Django 1.8
csrf_client.login(username="******", password="******")
response = csrf_client.get(reverse('new_character'))
csrf_token = csrf_client.cookies['csrftoken'].value
response = csrf_client.post(reverse('new_character'),
{'character_name': ['Hrothgar'],
'alignment': ['CG'],
'strength-value': [9],
'dexterity-value': [9],
'constitution-value': [9],
'intelligence-value': [9],
'wisdom-value': [9],
'charisma-value': [9],
'csrfmiddlewaretoken': csrf_token})
self.assertIsInstance(response, HttpResponseRedirect)
character = Character.objects.get(character_name="Hrothgar")
self.assertEqual(AbilityScores.objects.filter(
character=character).count(), 6)
response = csrf_client.get(response.url).render()
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'Hrothgar')
self.assertNotContains(response, escape("['Hrothgar']"))
self.assertContains(response, AbilityScores.ability_score_mod(9))
def test_when_score_sheet(self):
self.tutor.person.global_id = self.global_id
self.tutor.person.save()
c = Client()
c.force_login(self.tutor.person.user)
url = reverse('scores_download')
response = c.get(url)
self.assertEqual(response.content, score_encoding.print_scores(None, self.global_id))
def test_land_create_password(self):
client = Client()
user = User.objects.get(username='******')
client.force_login(user)
response = client.get(reverse(views.create_password))
self.assertEqual(response.status_code, 200)
context = response.context
self.assertIsNotNone(context['form'])
def test_when_no_score_sheet(self):
self.tutor.person.global_id = "0124"
self.tutor.person.save()
c = Client()
c.force_login(self.tutor.person.user)
url = reverse('scores_download')
response = c.get(url)
self.assertContains(response, html.escape(_('no_score_to_encode')))
class TestSimpleSymbolsUpload(TestCase):
def setUp(self):
user = User.objects.create_user('test user')
self.c = Client()
self.c.force_login(user)
self.tmp_dir = tempfile.mkdtemp()
def tearDown(self):
remove_dir(self.tmp_dir)
def test_symbols_upload_valid_zip(self):
version = '1.2.3.4'
platform = 'linux'
with self.settings(SYMBOL_UPLOAD_DIR=self.tmp_dir, SYMBOL_LOCATION=self.tmp_dir):
with open(get_test_file_path("valid.zip")) as f:
response = self.c.post('/upload/', {'symbols':f, 'version': version, 'platform':platform})
self.assertEqual(response.status_code, 200)
uploaded_symbols = SymbolsUpload.objects.all()
self.assertEqual(len(uploaded_symbols), 1)
uploaded_symbol = uploaded_symbols[0]
self.assertListEqual(uploaded_symbol.files.splitlines(), ['file1', 'file2'])
def test_delete_symbols(self):
version = '1.2.3.4'
platform = 'linux'
with self.settings(SYMBOL_UPLOAD_DIR=self.tmp_dir, SYMBOL_LOCATION=self.tmp_dir):
with open(get_test_file_path("valid.zip")) as f:
response = self.c.post('/upload/', {'symbols':f, 'version': version, 'platform':platform})
self.assertEqual(response.status_code, 200)
symbol_file1 = os.path.join(self.tmp_dir, 'file1')
symbol_file2 = os.path.join(self.tmp_dir, 'file2')
self.assertTrue(os.path.exists(symbol_file1))
self.assertTrue(os.path.exists(symbol_file2))
SymbolsUpload.objects.all().delete()
self.assertFalse(os.path.exists(symbol_file1))
self.assertFalse(os.path.exists(symbol_file2))
def test_sybols_upload_invalid_zip(self):
with self.settings(SYMBOL_UPLOAD_DIR=self.tmp_dir):
with open(get_test_file_path("invalid.zip")) as f:
with self.assertRaises(zipfile.BadZipfile):
response = self.c.post('/upload/', {'symbols': f, 'version': '1.2.3.4', 'platform': 'linux'})
def test_missing_comment(self):
with self.settings(SYMBOL_UPLOAD_DIR=self.tmp_dir):
with open(get_test_file_path("valid.zip")) as f:
response = self.c.post('/upload/', {'symbols':f})
self.assertEqual(response.status_code, 405)
def test_missing_file(self):
with self.settings(SYMBOL_UPLOAD_DIR=self.tmp_dir):
response = self.c.post('/upload/', {'comment': 'test comment'})
self.assertEqual(response.status_code, 405)
class SmokeTest(TestCase):
def setUp(self):
self.client = Client()
self.user = User.objects.create(username="******",)
def test__profile_list_url__GET(self):
# SETUP
# TEST
response = self.client.get(reverse_lazy('profiles:list'), follow=True)
# CHECK
self.assertEqual(response.status_code, 200)
def test__profile_edit_url__GET_annon(self):
# SETUP
# TEST
response = self.client.get(reverse_lazy('profiles:edit'), follow=True)
# CHECK
self.assertEqual(response.status_code, 200)
@pytest.mark.skipif(
django.VERSION < (1, 9, 0),
reason="Django 1.9 introduces force_login")
def test__profile_edit_url__GET_auth(self):
# SETUP
self.client.force_login(self.user)
# TEST
response = self.client.get(reverse_lazy('profiles:edit'), follow=True)
# CHECK
self.assertEqual(response.status_code, 200)
@pytest.mark.skipif(
django.VERSION < (1, 9, 0),
reason="Django 1.9 introduces force_login")
def test__profile_edit_url__POST_auth(self):
# SETUP
display_name = "ChiPy"
self.client.force_login(self.user)
# TEST
response = self.client.post(
reverse_lazy('profiles:edit'),
{'display_name': display_name, 'show': True}, follow=True)
# CHECK
self.user.profile.refresh_from_db()
self.assertEqual(response.status_code, 302)
self.assertEqual(
self.user.profile.display_name,
display_name)
self.assertTrue(self.user.profile.show)
def test_list(self):
user = User.objects.get(pk = 1)
c = Client()
c.force_login(user)
response = c.get(self.url_list)
projects = response.context["object_list"]
self.assertEqual(len(projects), 2)
self.assertEqual(projects[0].title, "Algebra")
self.assertEqual(projects[1].title, "Algorithms")
def test_post_no_member(self):
""" A non-existent member should produce a 404.
"""
url = reverse('member_signin')
c = Client()
c.force_login(self.user)
response = c.post(url, data={'id': 343})
self.assertTrue(response.status_code, 404)
def test_unknown_page(self):
""" Testing if user will get consistent code in case he'll try to access
page that does not exist
"""
u1 = User.objects.create_user(username='******', password='******')
client = Client()
client.force_login(u1)
response = client.get('/some_non_existing_link')
self.assertEqual(response.status_code, 404)
def test_signin_visit(self):
"""
Sign-in with 'BUILD' works.
"""
url = reverse('member_signin')
c = Client()
c.force_login(self.user)
response = c.post(url, data={'id': self.members[0].id, 'purpose': 'BUILD'})
self.assertEqual(response.status_code, 201)
def test_create_player_non_existent_game(self):
"""
Test that players cannot join non-existent games
"""
user = User.objects.create(username='******')
client = Client()
client.force_login(user)
response = client.post('/api/games/999/players/')
self.assertEquals(response.status_code, status.HTTP_404_NOT_FOUND)
def test_post_member_edit(self):
url = reverse('member_edit', kwargs=dict(member_id=self.member.id))
c = Client()
c.force_login(self.user)
member_data = {
'first_name': 'First2',
'last_name': 'Last',
'post_code': 'H0H0H0',
}
response = c.post(url, member_data, follow=True)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.context['form'].instance.first_name, 'First2')
def test_post_member_new(self):
url = reverse('member_new')
c = Client()
c.force_login(self.user)
member_data = {
'first_name': 'First',
'last_name': 'Last',
'post_code': 'H0H0H0',
}
c.post(url, data=member_data)
new_member = Member.objects.get(first_name='First', last_name='Last')
self.assertTrue(new_member)
class TestViews(TestCase):
def setUp(self):
self.user = create_user("user1")
self.user.set_password("password")
self.user.save()
create_profile(self.user, "some_key", 5)
# create a piece of vocab with one reading.
self.vocabulary = create_vocab("radioactive bat")
self.cat_reading = create_reading(self.vocabulary, "ねこ", "猫", 5)
# setup a review with two synonyms
self.review = create_review(self.vocabulary, self.user)
self.client = Client()
self.client.login(username="******", password="******")
def test_removing_synonym_removes_synonym(self):
dummy_kana = "whatever"
dummy_characters = "somechar"
synonym, created = self.review.add_answer_synonym(dummy_kana, dummy_characters)
self.client.delete(reverse("api:reading-synonym-detail", args=(synonym.id,)))
self.review.refresh_from_db()
self.assertListEqual(self.review.reading_synonyms_list(), [])
def test_reviewing_that_does_not_need_to_be_reviewed_fails(self):
self.review.needs_review = False
self.review.save()
response = self.client.post(
reverse("api:review-correct", args=(self.review.id,)),
data={"wrong_before": "false"},
)
self.assertEqual(response.status_code, 403)
self.assertIsNotNone(response.data["detail"])
response = self.client.post(
reverse("api:review-incorrect", args=(self.review.id,))
)
self.assertEqual(response.status_code, 403)
self.assertIsNotNone(response.data["detail"])
def test_sending_contact_email_returns_json_response(self):
self.client.force_login(self.user)
response = self.client.post(
reverse("api:contact-list"),
data={"name": "test", "email": "*****@*****.**", "body": "test"},
)
json = response.content
self.assertIsNotNone(json)
def test_create_password_passwords_different(self):
client = Client()
user = User.objects.get(username='******')
client.force_login(user)
response = client.post(reverse(views.create_password), {
'new_password1': 'maiev_shadowsong', 'new_password2': 'maiev SHADOWSONG'})
self.assertEqual(response.status_code, 200)
context = response.context
print(str(context['form'].errors['new_password2']))
self.assertIsNotNone(context['form'])
self.assertTrue('The two password fields didn't match.' in
str(context['form'].errors['new_password2']))
class RestrictedAccessConnectedMaraudeurTestCase(TestCase):
modules = ["maraudes", "notes/sujets"]
def setUp(self):
m = Maraudeur.objects.create(first_name="Astérix", last_name="LeGaulois")
self.client = Client()
self.client.force_login(m)
def test_access_restricted_modules(self):
for mod in self.modules:
url = "/%s/" % mod
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
def test_create_password_too_short(self):
client = Client()
user = User.objects.get(username='******')
client.force_login(user)
response = client.post(reverse(views.create_password), {'new_password1': 'a', 'new_password2': 'a'})
self.assertEqual(response.status_code, 200)
context = response.context
self.assertIsNotNone(context['form'])
self.assertTrue('Ensure this value has at least 5 characters (it has 1).' in
str(context['form'].errors['new_password1']))
self.assertTrue('Ensure this value has at least 5 characters (it has 1)' in
str(context['form'].errors['new_password2']))
def test_if_login_changes_content(self):
""" Testing if user that is logged in now can see "Logout" button
"""
user = User.objects.create_user('Tester', '*****@*****.**', 'qwerty')
some_client = Client()
some_client.force_login(user)
response = some_client.get('/index')
self.assertNotEqual(response.status_code, 404)
if response.status_code == 200:
self.assertContains(response, "Logout")
class TestCase(_TestCase):
user_permissions = ()
def setUp(self):
# Create the test user and assign permissions
self.user = User.objects.create_user(username="******")
self.add_permissions(*self.user_permissions)
# Initialize the test client
self.client = Client()
# Force login explicitly with the first-available backend
self.client.force_login(self.user)
def prepare_instance(self, instance):
"""
Test cases can override this method to perform any necessary manipulation of an instance prior to its evaluation
against test data. For example, it can be used to decrypt a Secret's plaintext attribute.
"""
return instance
def model_to_dict(self, instance, fields, api=False):
"""
Return a dictionary representation of an instance.
"""
# Prepare the instance and call Django's model_to_dict() to extract all fields
model_dict = model_to_dict(self.prepare_instance(instance), fields=fields)
# Map any additional (non-field) instance attributes that were specified
for attr in fields:
if hasattr(instance, attr) and attr not in model_dict:
model_dict[attr] = getattr(instance, attr)
for key, value in list(model_dict.items()):
try:
field = instance._meta.get_field(key)
except FieldDoesNotExist:
# Attribute is not a model field, but may be a computed field,
# so allow `field` checks to pass through.
field = None
# Handle ManyToManyFields
if value and type(field) in (ManyToManyField, TaggableManager):
# Only convert ContentType to <app_label>.<model> for API serializers/views
if api and field.related_model is ContentType:
model_dict[key] = sorted([f"{ct.app_label}.{ct.model}" for ct in value])
# Otherwise always convert object instances to pk
else:
model_dict[key] = sorted([obj.pk for obj in value])
if api:
# Replace ContentType primary keys with <app_label>.<model>
if type(getattr(instance, key)) is ContentType:
ct = ContentType.objects.get(pk=value)
model_dict[key] = f"{ct.app_label}.{ct.model}"
# Convert IPNetwork instances to strings
elif type(value) is IPNetwork:
model_dict[key] = str(value)
else:
# Convert ArrayFields to CSV strings
if type(field) is JSONArrayField:
model_dict[key] = ",".join([str(v) for v in value])
# Convert JSONField dict values to JSON strings
if type(field) is JSONField and isinstance(value, dict):
model_dict[key] = json.dumps(value)
return model_dict
#
# Permissions management
#
def add_permissions(self, *names):
"""
Assign a set of permissions to the test user. Accepts permission names in the form <app>.<action>_<model>.
"""
for name in names:
ct, action = resolve_permission_ct(name)
obj_perm = ObjectPermission(name=name, actions=[action])
obj_perm.save()
obj_perm.users.add(self.user)
obj_perm.object_types.add(ct)
#
# Custom assertions
#
def assertHttpStatus(self, response, expected_status):
"""
TestCase method. Provide more detail in the event of an unexpected HTTP response.
"""
err_message = None
# Construct an error message only if we know the test is going to fail
if response.status_code != expected_status:
if hasattr(response, "data"):
# REST API response; pass the response data through directly
err = response.data
else:
# Attempt to extract form validation errors from the response HTML
form_errors = extract_form_failures(response.content.decode(response.charset))
err = form_errors or response.content.decode(response.charset) or "No data"
err_message = f"Expected HTTP status {expected_status}; received {response.status_code}: {err}"
self.assertEqual(response.status_code, expected_status, err_message)
def assertInstanceEqual(self, instance, data, exclude=None, api=False):
"""
Compare a model instance to a dictionary, checking that its attribute values match those specified
in the dictionary.
:param instance: Python object instance
:param data: Dictionary of test data used to define the instance
:param exclude: List of fields to exclude from comparison (e.g. passwords, which get hashed)
:param api: Set to True is the data is a JSON representation of the instance
"""
if exclude is None:
exclude = []
fields = [k for k in data.keys() if k not in exclude]
model_dict = self.model_to_dict(instance, fields=fields, api=api)
new_model_dict = {}
for k, v in model_dict.items():
if isinstance(v, list):
# Sort lists of values. This includes items like tags, or other M2M fields
new_model_dict[k] = sorted(v)
else:
new_model_dict[k] = v
# Omit any dictionary keys which are not instance attributes or have been excluded
relevant_data = {}
for k, v in data.items():
if hasattr(instance, k) and k not in exclude:
if isinstance(v, list):
# Sort lists of values. This includes items like tags, or other M2M fields
relevant_data[k] = sorted(v)
else:
relevant_data[k] = v
self.assertEqual(new_model_dict, relevant_data)
#
# Convenience methods
#
@classmethod
def create_tags(cls, *names):
"""
Create and return a Tag instance for each name given.
"""
return [Tag.objects.create(name=name, slug=slugify(name)) for name in names]
class AdminSiteTests(TestCase):
def setUp(self):
"""
create a test client,
create an admin user,
log the admin_user in,
create a normal user
force_login(), client helper function that allows to log a
user in using django authentication, no longer need to manually
log the user in.
name='Test user full name' for create_user() is an **extra_field
"""
self.client = Client()
self.admin_user = get_user_model().objects.create_superuser(
email='*****@*****.**', password='******')
self.client.force_login(self.admin_user)
self.user = get_user_model().objects.create_user(
email='*****@*****.**',
password='******',
name='Test user full name',
)
def test_users_listed(self):
""" users are listed on user admin page
reverse was used in here becuase if we wanted to change
the url in the furture, we dont have to go through and
change it everywhere in our test.
"""
# generate a url for our list user page
# 'app_name : url '
url = reverse('admin:core_user_changelist')
# run a http get on the url we have defined above
response = self.client.get(url)
# assertContains() checks the content of the response
# it also checks the satus_codes 200
# check to see if the reponse contains user name and email
self.assertContains(response, self.user.name)
self.assertContains(response, self.user.email)
def test_user_change_page(self):
""" Test that the user edit page is accessible"""
# /admin/core/user/3 3 being the user id
url = reverse('admin:core_user_change', args=[self.user.id])
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
def test_create_user_page(self):
""" test that the create user page works """
url = reverse('admin:core_user_add')
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
class SprintSixTest(TestCase):
def setUp(self):
cache.clear()
self.client = Client()
self.user = User.objects.create_user(username='******',
email='*****@*****.**',
password='******')
self.follower = User.objects.create_user(username='******',
email='*****@*****.**',
password='******')
self.following = User.objects.create_user(
username='******',
email='*****@*****.**',
password='******')
self.group = Group.objects.create(title='test',
slug='test',
description='test_group')
def test_image(self):
self.client.force_login(self.user)
small_gif = (
b"\x47\x49\x46\x38\x39\x61\x01\x00\x01\x00\x00\x00\x00\x21\xf9\x04"
b"\x01\x0a\x00\x01\x00\x2c\x00\x00\x00\x00\x01\x00\x01\x00\x00\x02"
b"\x02\x4c\x01\x00\x3b")
img = SimpleUploadedFile("small.gif",
small_gif,
content_type="image/gif")
post = Post.objects.create(text='Test post with img',
author=self.user,
group=self.group,
image=img)
urls = (
reverse('index'),
reverse('profile', args=[post.author.username]),
reverse('post', args=[post.author.username, post.pk]),
reverse('group_posts', args=[self.group.slug]),
)
for url in urls:
with self.subTest(url=url):
response = self.client.get(url)
paginator = response.context.get('paginator')
if paginator is not None:
post = response.context['page'][0]
else:
post = response.context['post']
self.assertContains(response, '<img', status_code=200)
def test_no_image(self):
self.client.force_login(self.user)
small_gif = (b"1")
fake_img = SimpleUploadedFile("small.gif",
small_gif,
content_type="image/gif")
response = self.client.post(
reverse('new_post'), {
'text': 'post with no imag',
'author': self.user,
'group': self.group,
'image': fake_img
})
self.assertFormError(
response, 'form', 'image',
('Загрузите правильное изображение. '
'Файл, который вы загрузили, поврежден или не является'
' изображением.'))
def test_edit_image(self):
cache.clear()
self.client.force_login(self.user)
post = Post.objects.create(text="Post for edit image",
group=self.group,
author=self.user)
small_gif = (
b'\x47\x49\x46\x38\x39\x61\x01\x00\x01\x00\x00\x00\x00\x21\xf9\x04'
b'\x01\x0a\x00\x01\x00\x2c\x00\x00\x00\x00\x01\x00\x01\x00\x00\x02'
b'\x02\x4c\x01\x00\x3b')
img = SimpleUploadedFile('small.gif',
small_gif,
content_type='image/gif')
self.client.post(
reverse("post_edit",
kwargs={
'username': self.user.username,
'post_id': post.id
}), {
'text': "Post after edit image",
'image': img
})
self.assertEqual(Post.objects.count(), 1)
comment = Post.objects.all().first()
self.assertNotEqual(comment.text, "Post for edit image")
self.assertEqual(comment.text, "Post after edit image")
self.assertEqual(comment.author, self.user)
def test_cache(self):
cache.clear()
self.client.force_login(self.user)
first_response = self.client.get(reverse('index'))
post_cache = Post.objects.create(text='Post to check cache',
group=self.group,
author=self.user)
second_response = self.client.get(reverse('index'))
self.assertEqual(first_response.content, second_response.content)
key = make_template_fragment_key('index_page')
cache.delete(key)
third_response = self.client.get(reverse('index'))
self.assertNotEqual(second_response.content, third_response.content)
def test_follow(self):
self.client.force_login(self.follower)
self.client.post(
reverse('profile_follow',
kwargs={'username': self.following.username}))
self.assertEqual(Follow.objects.count(), 1)
follow = Follow.objects.first()
self.assertEqual(follow.author, self.following)
self.assertEqual(follow.user, self.follower)
def test_self_follow(self):
self.client.force_login(self.follower)
url_profile_follow = reverse(
'profile_follow', kwargs={'username': self.follower.username})
self.assertEqual(Follow.objects.all().count(), 0)
self.client.get(url_profile_follow, follow=True)
self.assertEqual(Follow.objects.all().count(), 0)
def test_unfollow(self):
self.client.force_login(self.follower)
follow = Follow.objects.create(user=self.follower,
author=self.following)
post = Post.objects.create(text='Post for unfollow',
author=self.following,
group=self.group)
self.assertEqual(Follow.objects.all().count(), 1)
self.client.get(
reverse('profile_unfollow',
kwargs={'username': self.following.username}))
self.assertEqual(Follow.objects.all().count(), 0)
def test_follow_index(self):
self.client.force_login(self.follower)
self.post = Post.objects.create(text='TEST_POST',
author=self.following)
url_follow_index = reverse('follow_index')
response = self.client.get(url_follow_index)
self.assertEqual(response.context.get('post'), None)
Follow.objects.create(user_id=self.follower.id,
author_id=self.following.id)
response = self.client.get(url_follow_index)
self.assertEqual(response.context.get('post').text, self.post.text)
self.assertEqual(response.context.get('post').author, self.post.author)
def test_unauth_comments(self):
self.text = 'Test comments'
post = Post.objects.create(text=self.text,
group=self.group,
author=self.user)
response = self.client.get(
reverse("add_comment",
kwargs={
'username': self.user.username,
'post_id': post.id
}), {'text': 'Comment'})
self.assertEqual(response.status_code, 302)
self.assertEqual(Comment.objects.count(), 0)
def test_auth_comments(self):
self.text = 'Test comments'
self.client.force_login(self.user)
post = Post.objects.create(text=self.text,
group=self.group,
author=self.user)
self.client.post(
reverse("add_comment",
kwargs={
'username': self.user.username,
'post_id': post.id
}), {'text': 'Comment'})
comment = post.comments.select_related('author').first()
self.assertEqual(Comment.objects.count(), 1)
self.assertEqual(comment.text, 'Comment')
self.assertEqual(comment.post, post)
self.assertEqual(comment.author, self.user)
class FlatpageCSRFTests(TestCase):
@classmethod
def setUpTestData(cls):
# don't use the manager because we want to ensure the site exists
# with pk=1, regardless of whether or not it already exists.
cls.site1 = Site(pk=1, domain='example.com', name='example.com')
cls.site1.save()
cls.fp1 = FlatPage.objects.create(url='/flatpage/',
title='A Flatpage',
content="Isn't it flat!",
enable_comments=False,
template_name='',
registration_required=False)
cls.fp2 = FlatPage.objects.create(url='/location/flatpage/',
title='A Nested Flatpage',
content="Isn't it flat and deep!",
enable_comments=False,
template_name='',
registration_required=False)
cls.fp3 = FlatPage.objects.create(url='/sekrit/',
title='Sekrit Flatpage',
content="Isn't it sekrit!",
enable_comments=False,
template_name='',
registration_required=True)
cls.fp4 = FlatPage.objects.create(url='/location/sekrit/',
title='Sekrit Nested Flatpage',
content="Isn't it sekrit and deep!",
enable_comments=False,
template_name='',
registration_required=True)
cls.fp1.sites.add(cls.site1)
cls.fp2.sites.add(cls.site1)
cls.fp3.sites.add(cls.site1)
cls.fp4.sites.add(cls.site1)
def setUp(self):
self.client = Client(enforce_csrf_checks=True)
def test_view_flatpage(self):
"A flatpage can be served through a view, even when the middleware is in use"
response = self.client.get('/flatpage_root/flatpage/')
self.assertContains(response, "<p>Isn't it flat!</p>")
def test_view_non_existent_flatpage(self):
"A non-existent flatpage raises 404 when served through a view, even when the middleware is in use"
response = self.client.get('/flatpage_root/no_such_flatpage/')
self.assertEqual(response.status_code, 404)
def test_view_authenticated_flatpage(self):
"A flatpage served through a view can require authentication"
response = self.client.get('/flatpage_root/sekrit/')
self.assertRedirects(response,
'/accounts/login/?next=/flatpage_root/sekrit/')
user = User.objects.create_user('testuser', '*****@*****.**',
's3krit')
self.client.force_login(user)
response = self.client.get('/flatpage_root/sekrit/')
self.assertContains(response, "<p>Isn't it sekrit!</p>")
def test_fallback_flatpage(self):
"A flatpage can be served by the fallback middleware"
response = self.client.get('/flatpage/')
self.assertContains(response, "<p>Isn't it flat!</p>")
def test_fallback_non_existent_flatpage(self):
"A non-existent flatpage raises a 404 when served by the fallback middleware"
response = self.client.get('/no_such_flatpage/')
self.assertEqual(response.status_code, 404)
def test_post_view_flatpage(self):
"POSTing to a flatpage served through a view will raise a CSRF error if no token is provided (Refs #14156)"
response = self.client.post('/flatpage_root/flatpage/')
self.assertEqual(response.status_code, 403)
def test_post_fallback_flatpage(self):
"POSTing to a flatpage served by the middleware will raise a CSRF error if no token is provided (Refs #14156)"
response = self.client.post('/flatpage/')
self.assertEqual(response.status_code, 403)
def test_post_unknown_page(self):
"POSTing to an unknown page isn't caught as a 403 CSRF error"
response = self.client.post('/no_such_page/')
self.assertEqual(response.status_code, 404)
def home_resp_with_user(django_user_model, client: Client):
user = mommy.make(django_user_model)
client.force_login(user)
return _resp(client)
class TestMethods(TestCase):
def setUp(self):
self.unauth = Client()
self.auth = Client()
self.user = User.objects.create_user(username='******',
email='*****@*****.**',
password='******')
self.auth.force_login(self.user)
self.group = Group.objects.create(title='sarah',
slug='sarah',
description='Sarahs')
self.text1 = 'there is no fate'
self.john = User.objects.create_user(username='******',
email='*****@*****.**',
password='******')
def test_page_is_created(self):
response = self.auth.get(
reverse('profile', kwargs={'username': self.user.username}))
self.assertEquals(response.status_code, 200)
def test_auth_can_create_post(self):
self.auth.post(reverse('new_post'), {
'text': self.text1,
'group': self.group.id
})
post = Post.objects.first()
self.assertEquals(post.text, self.text1)
self.assertEquals(post.group, self.group)
response = self.auth.get(reverse('index'))
self.assertContains(response, self.text1)
self.assertContains(response, self.group.title)
def test_unauth_is_redirected(self):
reverse_login = reverse('login')
reverse_new_post = reverse('new_post')
response = self.unauth.post(reverse('new_post'))
self.assertRedirects(response,
f'{reverse_login}?next={reverse_new_post}')
def test_new_post(self):
self.auth.post(reverse('new_post'), {'text': self.text1})
cache.clear()
self.compare(self.text1)
def test_auth_can_update(self):
response = self.auth.post(reverse('new_post'), {'text': self.text1})
self.assertRedirects(response, reverse('index'))
post = Post.objects.filter(author_id=self.user.id).get(text=self.text1)
text2 = 'skynet my love'
cache.clear()
response = self.auth.post(
reverse('post_edit',
kwargs={
'username': self.user.username,
'post_id': post.id
}), {'text': text2})
self.assertRedirects(
response,
reverse('post_view',
kwargs={
'username': self.user.username,
'post_id': post.id
}))
self.compare(text2)
def compare(self, text):
post = Post.objects.filter(author_id=self.user.id).get(text=text)
paths = [
reverse('index'),
reverse('profile', kwargs={'username': self.user.username}),
reverse('post_view',
kwargs={
'username': self.user.username,
'post_id': post.id
})
]
for path in paths:
response = self.auth.get(path)
with self.subTest(path=path):
self.assertContains(response, text)
def test_404(self):
response = self.unauth.get(
reverse('profile', kwargs={'username': '******'}))
self.assertEquals(response.status_code, 404)
def test_page_includes_img(self):
image = SimpleUploadedFile('small.gif',
small_gif,
content_type='image/gif')
self.auth.post(reverse('new_post'), {
'text': self.text1,
'group': self.group.id,
'image': image
})
post = Post.objects.filter(author_id=self.user.id).get(text=self.text1)
response = self.auth.get(
reverse('post_view',
kwargs={
'username': self.user.username,
'post_id': post.id
}))
self.assertContains(response, '<img class=')
response = self.auth.get(reverse('index'))
self.assertContains(response, '<img class=')
response = self.auth.get(
reverse('group_posts', kwargs={'slug': self.group.slug}))
self.assertContains(response, '<img class=')
def test_extension_protection(self):
with tempfile.NamedTemporaryFile(suffix='.md') as image:
response = self.auth.post(reverse('new_post'), {
'text': self.text1,
'image': image
})
form = response.context['form']
self.assertFormError(response, 'form', 'image', form.errors['image'])
def test_cache(self):
self.auth.post(reverse('new_post'), {'text': self.text1})
response = self.auth.get(reverse('index'))
self.assertNotContains(response, self.text1)
cache.clear()
response = self.auth.get(reverse('index'))
self.assertContains(response, self.text1)
def test_auth_can_sub(self):
self.auth.post(
reverse('profile_follow', kwargs={'username': self.john.username}))
self.assertIsInstance(self.user.follower.first(), Follow)
def test_auth_can_unsub(self):
Follow.objects.create(user=self.user, author=self.john)
self.assertTrue(self.user.follower.all())
self.auth.post(
reverse('profile_unfollow',
kwargs={'username': self.john.username}))
self.assertFalse(self.user.follower.all())
def test_news_subscribed(self):
self.auth.post(reverse('new_post'), {'text': self.text1})
cache.clear()
self.auth.logout()
self.auth.force_login(self.john)
self.auth.post(reverse('profile_follow', kwargs={'username': '******'}))
response = self.auth.get(reverse('follow_index'))
self.assertContains(response, self.text1)
def test_news_not_subscribed(self):
self.auth.post(reverse('new_post'), {'text': self.text1})
cache.clear()
self.auth.logout()
arnie = User.objects.create_user(username='******',
email='*****@*****.**',
password='******')
self.auth.force_login(arnie)
response = self.auth.get(reverse('follow_index'))
self.assertNotContains(response, self.text1)
def test_auth_can_comment(self):
text2 = 'sure about this'
post = Post.objects.create(text=self.text1, author=self.user)
self.auth.post(
reverse('add_comment',
kwargs={
'username': self.user.username,
'post_id': post.id
}), {'text': text2})
response = self.auth.get(
reverse('post_view',
kwargs={
'username': self.user.username,
'post_id': post.id
}))
self.assertContains(response, text2)
def test_unauth_cant_comment(self):
text2 = 'where is my comment?'
post = Post.objects.create(text=self.text1, author=self.user)
self.unauth.post(
reverse('add_comment',
kwargs={
'username': self.user.username,
'post_id': post.id
}), {'text': text2})
response = self.unauth.get(
reverse('post_view',
kwargs={
'username': self.user.username,
'post_id': post.id
}))
self.assertNotContains(response, text2)
def test_menu_item_localization(self):
"""
Menu Item Localization API
"""
req = Client()
user = ContextUnitTest.create_user()
user2 = ContextUnitTest.create_user(username='******', is_staff=True)
menu_item = MenuUnitTest.create_menu_item()
menu = menu_item.menu
# menu item localization list
url = reverse('unicms_api:menu-item-localizations',
kwargs={
'menu_id': menu.pk,
'menu_item_id': menu_item.pk
})
# accessible to staff users only
res = req.get(url)
assert res.status_code == 403
user.is_staff = True
user.is_superuser = True
user.save()
req.force_login(user)
res = req.get(url)
assert isinstance(res.json(), dict)
# POST
data = {
'item': menu_item.pk,
'language': 'en',
'name': 'english',
'is_active': 0
}
# user hasn't permission
req.force_login(user2)
res = req.post(url, data=data, follow=1)
assert res.status_code == 403
# user has permission
req.force_login(user)
# wrong carousel item
menu_item_2 = MenuUnitTest.create_menu_item(menu=menu)
data['item'] = menu_item_2.pk
res = req.post(url, data=data, follow=1)
assert res.status_code == 400
# wrong carousel_item
data['item'] = 11121
res = req.post(url, data=data, follow=1)
assert res.status_code == 400
data['item'] = menu_item.pk
# wrong parent menu
url = reverse('unicms_api:menu-item-localizations',
kwargs={
'menu_id': 12321321,
'menu_item_id': menu_item.pk
})
res = req.post(url, data=data, follow=1)
assert res.status_code == 400
url = reverse('unicms_api:menu-item-localizations',
kwargs={
'menu_id': menu.pk,
'menu_item_id': menu_item.pk
})
res = req.post(url, data=data, follow=1)
localization = NavigationBarItemLocalization.objects.filter(
name='english').first()
assert localization
# GET LOGS
url = reverse('unicms_api:menu-item-localization-logs',
kwargs={
'menu_id': menu.pk,
'menu_item_id': menu_item.pk,
'pk': localization.pk
})
res = req.get(
url,
content_type='application/json',
)
assert isinstance(res.json(), dict)
# redis lock set
ct = ContentType.objects.get_for_model(localization)
url = reverse('unicms_api:editorial-board-redis-lock-set')
data = {'content_type_id': ct.pk, 'object_id': localization.pk}
res = req.post(url, data, content_type='application/json', follow=1)
assert isinstance(res.json(), dict)
# GET, patch, put, delete
url = reverse('unicms_api:menu-item-localization',
kwargs={
'menu_id': menu.pk,
'menu_item_id': menu_item.pk,
'pk': localization.pk
})
# GET
res = req.get(
url,
content_type='application/json',
)
assert isinstance(res.json(), dict)
# PATCH
# wrong parent menu item
data = {'item': 11121}
res = req.patch(url,
data=data,
content_type='application/json',
follow=1)
assert res.status_code == 400
# correct data
data = {'name': 'patched'}
# user hasn't permission
req.force_login(user2)
res = req.patch(url, data, content_type='application/json', follow=1)
assert res.status_code == 403
# user has permission
menu.created_by = user2
menu.save()
content_type = ContentType.objects.get_for_model(NavigationBar)
edit_perm = Permission.objects.get(content_type=content_type,
codename='change_navigationbar')
user2.user_permissions.add(edit_perm)
user2.refresh_from_db()
req.force_login(user2)
res = req.patch(url, data, content_type='application/json', follow=1)
localization.refresh_from_db()
assert localization.name == 'patched'
# PUT
menu.created_by = None
menu.save()
data = {
'item': menu_item.pk,
'language': 'en',
'name': 'putted',
'is_active': 0
}
# user hasn't permission
req.force_login(user2)
res = req.put(url, data, content_type='application/json')
assert res.status_code == 403
# user has permission
req.force_login(user)
res = req.put(url, data, content_type='application/json')
localization.refresh_from_db()
assert localization.name == 'putted'
assert not localization.is_active
# DELETE
# user hasn't permission
req.force_login(user2)
res = req.delete(url)
assert res.status_code == 403
# user has permission
req.force_login(user)
res = req.delete(url)
try:
localization.refresh_from_db()
except ObjectDoesNotExist:
assert True
# form
url = reverse('unicms_api:menu-item-localization-form',
kwargs={
'menu_id': menu.pk,
'menu_item_id': menu_item.pk
})
res = req.get(url)
assert isinstance(res.json(), list)
class ViewEventEditTestCase(TestCase):
def setUp(self):
self.client = Client()
self.request_factory = RequestFactory()
#create club owner
self.owner = get_user_model().objects.create(first_name="Owner",
last_name="McPerson",
email="*****@*****.**")
self.owner.set_password("clubsuite")
self.owner.save()
#Create club
self.club = Club.objects.create(club_name="club",
club_type="PUB",
club_description="a club")
self.club._create_permissions()
self.club._set_owner(self.owner)
#create division
self.division = Division.objects.create(name="Expenses", cid=self.club)
#create event
self.event = Event.objects.create(cid=self.club,
event_name="Event1",
start_date="2020-03-29",
start_time="00:00:00",
end_date="2020-03-29",
end_time="23:59:59",
event_location="Library",
event_description="Lots of testing!",
event_cost=1000,
event_fee=10,
accessibility=False,
required=True,
did=self.division)
def test_get_login(self):
self.client.force_login(
get_user_model().objects.get(first_name='Owner'))
response = self.client.get(
reverse('suite:event_edit',
kwargs={
'club_id': self.club.pk,
'event_id': self.event.pk
}))
self.assertEquals(response.status_code, 200)
def test_get_not_logged_in(self):
response = self.client.get(
reverse('suite:event_edit',
kwargs={
'club_id': self.club.pk,
'event_id': self.event.pk
}))
self.assertEquals(response.status_code, 403)
def test_post(self):
#login
self.client.force_login(
get_user_model().objects.get(first_name='Owner'))
data = {
'edit': "1",
'start_date': "03/05/2027",
'end_date': "03/06/2027",
'event_name': "Event",
'start_time': "00:00:00",
'end_time': "23:59:59",
'event_location': "Library",
'event_description': "So much fun",
'event_cost': 100,
'event_fee': 100,
'accessibility': True,
'required': False,
'did': self.division.pk
}
request = self.request_factory.post(reverse('suite:event_edit',
kwargs={
'club_id':
self.club.pk,
'event_id':
self.event.pk
}),
data,
follow=True)
request.user = self.owner
setattr(request, 'session', 'session')
messages = FallbackStorage(request)
setattr(request, '_messages', messages)
response = EventEdit.as_view()(request,
club_id=self.club.pk,
event_id=self.event.pk)
response.client = self.client
#Assert that it redirects to club manage page
self.assertRedirects(
response,
reverse('suite:club_view', kwargs={'club_id': self.club.pk}))
#self.event's strings are still pointing to old information, need get() to refresh
newEvent = Event.objects.get(event_name="Event")
self.assertEqual(newEvent, self.event)
self.assertEqual(newEvent.event_name, "Event")
self.assertEqual(newEvent.event_description, "So much fun")
class ViewsTests(TestCase):
def setUp(self):
self.client = Client()
self.user = User.objects.create_user(username='******',
email='*****@*****.**',
password='******')
self.post = Post.objects.create(text="Привет, давно не виделись!",
author=self.user)
def test_profile_view(self):
response = self.client.get('/pupa/')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.context['post_count'], 1)
self.assertIsInstance(response.context['user_profile'], User)
self.assertEqual(response.context['user_profile'].username,
self.user.username)
def test_new_post(self):
self.client.login(username='******', password='******')
response = self.client.post('/new/', {'text': 'Создаю Новый пост!'},
follow=True)
self.assertRedirects(response, '/')
response = self.client.get(
reverse('profile', kwargs={'username': self.user.username}))
self.assertEqual(response.status_code, 200)
self.assertEqual(response.context['post_count'], 2)
self.assertIsInstance(response.context['user_profile'], User)
self.assertEqual(response.context['user_profile'].username,
self.user.username)
def test_new_post_no_auth(self):
response = self.client.post(reverse('new_post'), follow=True)
self.assertRedirects(response, '/auth/login/?next=%2Fnew%2F')
def test_tripple_post_index(self):
self.client.login(username='******', password='******')
response = self.client.get('/')
self.assertContains(response, self.post.text, count=1)
def test_tripple_post_profile(self):
self.client.force_login(self.user)
response = self.client.get(
reverse('profile', kwargs={'username': self.user.username}))
self.assertContains(response, self.post.text, count=1)
def test_tripple_post_post_view(self):
self.client.force_login(self.user)
response = self.client.get(
reverse('posts',
kwargs={
'username': self.user.username,
'post_id': self.post.id
}))
self.assertContains(response, self.post.text, count=1)
@override_settings(CACHES=TEST_CACHE)
def test_tripple_post_edit_index(self):
self.client.login(username='******', password='******')
self.client.post(f'/{self.user.username}/{self.post.id}/edit/',
{'text': 'О, это снова Вы!'},
follow=False)
response = self.client.get('/')
self.assertContains(response, 'О, это снова Вы!', count=1)
@override_settings(CACHES=TEST_CACHE)
def test_tripple_post_edit_profile(self):
self.client.force_login(self.user)
self.client.post(f'/{self.user.username}/{self.post.id}/edit/',
{'text': 'О, это снова Вы!'},
follow=False)
response = self.client.get(
reverse('profile', kwargs={'username': self.user.username}))
self.assertContains(response, 'О, это снова Вы!', count=1)
@override_settings(CACHES=TEST_CACHE)
def test_tripple_post_edit_post_view(self):
self.client.force_login(self.user)
self.client.post(f'/{self.user.username}/{self.post.id}/edit/',
{'text': 'О, это снова Вы!'},
follow=False)
response = self.client.get(
reverse('posts',
kwargs={
'username': self.user.username,
'post_id': self.post.id
}))
self.assertContains(response, 'О, это снова Вы!', count=1)
class Command(BaseCommand): # pragma: no cover
help = "Runs performance tests on a database generated with make_test_db"
def add_arguments(self, parser):
parser.add_argument(
"--include",
type=str,
action="store",
dest="include_pattern",
default=None,
help="Only test URLs matching this pattern.",
)
parser.add_argument(
"--orgs",
type=str,
action="store",
dest="org_ids",
default=None,
help=
"Comma separated database ids of orgs to test. Defaults to first and last org.",
)
parser.add_argument(
"--org-limits",
type=str,
action="store",
dest="org_limits",
default=None,
help=
"Comma separated hard time limits for each org in milliseconds.",
)
parser.add_argument(
"--num-requests",
type=int,
action="store",
dest="num_requests",
default=DEFAULT_NUM_REQUESTS,
help="Number of requests to make for each URL. Default is %d." %
DEFAULT_NUM_REQUESTS,
)
parser.add_argument(
"--results-file",
type=str,
action="store",
dest="results_file",
default=DEFAULT_RESULTS_FILE,
help="Path of file to write results to. Default is '%s'." %
DEFAULT_RESULTS_FILE,
)
parser.add_argument(
"--results-html",
type=str,
action="store",
dest="results_html",
default=None,
help="Path of file to write HTML results to. Default is none.",
)
def handle(self, include_pattern, org_ids, org_limits, num_requests,
results_file, results_html, *args, **options):
self.client = Client()
started = datetime.utcnow()
prev_times = self.load_previous_times(results_file)
if not prev_times:
self.stdout.write(
self.style.WARNING(
"No previous results found for change calculation"))
# gather which orgs will be tested
if org_ids:
test_orgs = list(
Org.objects.filter(id__in=org_ids.split(",")).order_by("id"))
else:
test_orgs = [Org.objects.first(), Org.objects.last()]
# gather org specific maximum time limits
if org_limits:
org_allowed_maximums = [int(l) for l in org_limits.split(",")]
if len(org_allowed_maximums) != len(test_orgs):
raise CommandError("%d time limits provided for %d orgs" %
(len(org_limits), len(test_orgs)))
else:
org_allowed_maximums = [DEFAULT_ALLOWED_MAXIMUM] * len(test_orgs)
test_urls = [
u for u in TEST_URLS
if not include_pattern or fnmatch.fnmatch(u, include_pattern)
]
results = []
for o, org in enumerate(test_orgs):
org.allowed_max = org_allowed_maximums[o]
# look for previous times for this org
prev_org_times = prev_times.get(org.id, {})
results.append(
self.test_org(org, test_urls, num_requests, prev_org_times))
self.save_results(results_file, started, results)
if results_html:
self.save_html_results(results_html, results)
# exit with no-zero code if any test for any org failed
for result in results:
for test in result["tests"]:
if not test.is_pass():
sys.exit(1)
def test_org(self, org, urls, num_requests, prev_times):
"""
Tests the given URLs for the given org
"""
self.stdout.write(
self.style.MIGRATE_HEADING(
"Org #%d (%d contacts, %dms max allowed)" %
(org.id, org.contacts.count(), org.allowed_max)))
# build a URL context for this org
url_context = {}
for key, value in URL_CONTEXT_TEMPLATE.items():
url_context[key] = value(org) if callable(value) else value
# login in as an org administrator
self.client.force_login(org.administrators.first())
tests = []
for url in urls:
formatted_url = url.format(**url_context)
prev_url_times = prev_times.get(formatted_url)
tests.append(
self.test_url(formatted_url, num_requests, org.allowed_max,
prev_url_times))
return {"org": org, "tests": tests}
def test_url(self, url, num_requests, allowed_max, prev_times):
"""
Test a single URL
"""
self.stdout.write(" > %s " % url, ending="")
url_times = []
for r in range(num_requests):
start_time = time.time()
response = self.client.get(url)
if response.status_code != 200:
raise CommandError(
"URL %s returned an unexpected %d response" %
(url, response.status_code))
url_times.append(int(1000 * (time.time() - start_time)))
result = URLResult(url, url_times, allowed_max, prev_times)
self.stdout.write(self.format_result(result))
return result
def format_result(self, result):
"""
Formats a result like 24...370 (▼ -1, -3%)
"""
range_str = "%d...%d" % (result.min, result.max)
if result.exceeds_maximum:
range_str = self.style.ERROR(range_str)
else:
range_str = self.style.SUCCESS(range_str)
if result.change:
arrow = "\u25b2" if result.change > 0 else "\u25bc"
style = self.style.ERROR if result.exceeds_change else self.style.SUCCESS
change_str = style(
"%s %d, %d%%" %
(arrow, result.change, result.percentage_change))
elif result.change == 0:
change_str = "no change"
else:
change_str = "change unknown"
return "%s (%s)" % (range_str, change_str)
def load_previous_times(self, results_file):
"""
Extracts URL times from a previous results file so they can be compared with current times
"""
try:
with open(results_file, "r") as f:
org_times = {}
for result in json.load(f)["results"]:
org_times[result["org"]] = {}
for test in result["tests"]:
org_times[result["org"]][test["url"]] = test["times"]
return org_times
except (IOError, ValueError, KeyError):
return {}
def save_results(self, path, started, results):
with open(path, "w") as f:
json.dump(
{
"started":
started.isoformat(),
"results": [{
"org": r["org"].id,
"tests": [t.as_json() for t in r["tests"]]
} for r in results],
},
f,
indent=4,
)
def save_html_results(self, path, results):
header = """<table style="font-family: Arial, Helvetica, sans-serif; border-spacing: 0; border-collapse: separate;">"""
footer = """</table>"""
with open(path, "w") as f:
f.write(header)
for result in results:
self.write_org_html(f, result["org"], result["tests"])
f.write(footer)
def write_org_html(self, f, org, tests):
f.write("""
<tr style="background-color: #2f4970; color: white">
<th style="padding: 5px" colspan="5">Org #%d (%d contacts, %dms max allowed)</th>
</tr>
<tr style="background-color: #f2f6fc; color: #2f4970">
<th style="padding: 5px; text-align: left">URL</th>
<th style="padding: 5px">Min (ms)</th>
<th style="padding: 5px">Max (ms)</th>
<th style="padding: 5px">Change (ms)</th>
<th style="padding: 5px">Change (%%)</th>
</tr>
""" % (org.id, org.contacts.count(), org.allowed_max))
for test in tests:
if test.change:
arrow = "↑ " if test.change > 0 else "↓ "
change = "%s %d" % (arrow, test.change)
percentage_change = "%d" % test.percentage_change
else:
change = ""
percentage_change = ""
row_bg = "dbffe3" if test.is_pass() else "ffe0e0"
max_bg = "ffafaf" if test.exceeds_maximum else row_bg
change_bg = "ffafaf" if test.exceeds_change else row_bg
f.write('<tr style="background-color: #%s">' % row_bg)
f.write('<td style="padding: 5px">%s</td>' % test.url)
f.write('<td style="padding: 5px">%d</td>' % test.min)
f.write('<td style="padding: 5px; background-color: #%s">%d</td>' %
(max_bg, test.max))
f.write('<td style="padding: 5px">%s</td>' % change)
f.write(
'<td style="padding: 5px; background-color: #%s"">%s</td>' %
(change_bg, percentage_change))
f.write("</tr>")
class RecommendationTestCase(TestCase):
def setUp(self):
self.test_user = User.objects.create()
seuss = Author.objects.create(name="Dr. Seuss")
cat = Book.objects.create(title="The Cat in the Hat")
seuss.book_set.add(cat)
places = Book.objects.create(title="Oh the Places We'll Go",
amazon_link="https://amazon.com")
seuss.book_set.add(places)
seuss.save()
dani = Author.objects.create(name="Dani Kollin")
unincorp = Book.objects.create(title="The Unincorporated Man")
dani.book_set.add(unincorp)
dani.save()
rec1 = Recommendation.objects.create(book=cat)
rec2 = Recommendation.objects.create(book=cat)
rec3 = Recommendation.objects.create(book=places)
u_list = UserList.objects.create()
u_list.user = self.test_user
u_list.books.add(unincorp)
u_list.save()
self.client = Client()
self.client.force_login(self.test_user)
def test_api_gets_author_books(self):
response = self.client.get('/recommendations/',
{'author': 'Dr. Seuss'})
self.assertEqual(response.json()["data"], [{
"title": "The Cat in the Hat",
"author": "Dr. Seuss",
"url": "#"
}, {
"title": "Oh the Places We\'ll Go",
"author": "Dr. Seuss",
"url": "https://amazon.com"
}])
def test_api_get_blank(self):
response = self.client.get('/recommendations/',
{'author': 'Calvin and Hobbes'})
self.assertEqual(response.json()["data"], [])
def test_api_gets_recommendation_count(self):
response = self.client.get('/recommendations/', {'count': '2'})
self.assertEqual(response.json()['data'], [{
"title": "The Cat in the Hat",
"author": "Dr. Seuss",
"url": "#"
}])
response = self.client.get('/recommendations/', {'count': '1'})
self.assertEqual(response.json()['data'], [{
"title": "Oh the Places We\'ll Go",
"author": "Dr. Seuss",
"url": "https://amazon.com"
}])
response = self.client.get('/recommendations/', {'count': '5'})
self.assertEqual(response.json()['data'], [])
def test_api_get_authors(self):
response = self.client.get('/authors/')
self.assertEqual(response.json()['data'], ['Dr. Seuss', 'Dani Kollin'])
def test_get_user_list(self):
response = self.client.get('/user_list/')
self.assertEqual(response.json()['data'], [{
'author': 'Dani Kollin',
'selected': False,
'title': 'The Unincorporated Man',
'url': ''
}])
def test_save_user_list(self):
response = self.client.put(
'/save/',
json.dumps({
'data': [{
'title': 'The Unincorporated Man',
'author': 'Dani Kollin',
'url': '',
'selected': False
}]
}))
self.assertEqual(response.status_code, 200)
# No need for except, since that would throw an error for the test anyways
added_book = Book.objects.get(title="The Unincorporated Man")
self.assertTrue(added_book)
def check_status_code(self, response):
self.assertNotEqual(response.status_code, 200)
self.assertEqual(response.status_code, 302)
# Test if it redirects to login
def test_login_required(self):
nologin = Client()
response = nologin.get('/recommendations/',
{'author': 'Calvin and Hobbes'})
self.check_status_code(response)
response = nologin.get('/authors/')
self.check_status_code(response)
response = nologin.get('/recommendations/', {'count': '2'})
self.check_status_code(response)
response = nologin.put(
'/save/',
json.dumps({
'data': [{
'title': 'The Unincorporated Man',
'author': 'Dani Kollin',
'url': '',
'selected': False
}]
}))
self.check_status_code(response)
response = nologin.get('/user_list/')
self.check_status_code(response)
class DataSourceApiPermissionsTest(TestCase):
@classmethod
def setUpTestData(cls):
cls.user = get_user_model().objects.create_user('Test API User')
cls.owner = get_user_model().objects.create_user('Test API Owner')
def setUp(self):
self.client = APIClient()
self.client.force_authenticate(self.user)
self.owner_client = Client()
self.owner_client.force_login(self.owner)
self.test_name = 'Permissions'
# TODO don't rely on external URL for testing
self.test_url = 'https://api.iotuk.org.uk/iotOrganisation'
def tearDown(self):
try:
self.model.delete()
except AttributeError:
pass
def _grant_permission(self, level: models.UserPermissionLevels):
response = self.owner_client.post(
'/datasources/{}/access/grant'.format(self.model.pk),
data={
'user': self.user.pk,
'granted': level.value,
},
headers={'Accept': 'application/json'})
# TODO make this return a proper response code for AJAX-like requests
self.assertEqual(response.status_code, 302)
self.assertNotIn('login', response.url)
def test_datasource_permission_view(self):
"""
Test that permissions are correctly handled when attempting to view a data source.
"""
self.model = models.DataSource.objects.create(
name=self.test_name,
owner=self.owner,
url=self.test_url,
plugin_name='DataSetConnector',
public_permission_level=models.UserPermissionLevels.NONE)
url = '/api/datasources/{}/'.format(self.model.pk)
response = self.client.get(url)
self.assertEqual(response.status_code, 403)
self._grant_permission(models.UserPermissionLevels.VIEW)
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self._grant_permission(models.UserPermissionLevels.META)
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self._grant_permission(models.UserPermissionLevels.DATA)
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self._grant_permission(models.UserPermissionLevels.PROV)
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
def test_datasource_permission_meta(self):
"""
Test that permissions are correctly handled when attempting to get metadata from a data source.
"""
self.model = models.DataSource.objects.create(
name=self.test_name,
owner=self.owner,
url=self.test_url,
plugin_name='DataSetConnector',
public_permission_level=models.UserPermissionLevels.NONE)
url = '/api/datasources/{}/metadata/'.format(self.model.pk)
response = self.client.get(url)
self.assertEqual(response.status_code, 403)
self._grant_permission(models.UserPermissionLevels.VIEW)
response = self.client.get(url)
self.assertEqual(response.status_code, 403)
self._grant_permission(models.UserPermissionLevels.META)
response = self.client.get(url)
# This data connector does not provide metadata
self.assertEqual(response.status_code, 400)
self._grant_permission(models.UserPermissionLevels.DATA)
response = self.client.get(url)
self.assertEqual(response.status_code, 400)
self._grant_permission(models.UserPermissionLevels.PROV)
response = self.client.get(url)
self.assertEqual(response.status_code, 400)
def test_datasource_permission_data(self):
"""
Test that permissions are correctly handled when attempting to get data from a data source.
"""
self.model = models.DataSource.objects.create(
name=self.test_name,
owner=self.owner,
url=self.test_url,
plugin_name='DataSetConnector',
public_permission_level=models.UserPermissionLevels.NONE)
url = '/api/datasources/{}/data/?year=2018'.format(self.model.pk)
response = self.client.get(url)
self.assertEqual(response.status_code, 403)
self._grant_permission(models.UserPermissionLevels.VIEW)
response = self.client.get(url)
self.assertEqual(response.status_code, 403)
self._grant_permission(models.UserPermissionLevels.META)
response = self.client.get(url)
self.assertEqual(response.status_code, 403)
self._grant_permission(models.UserPermissionLevels.DATA)
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self._grant_permission(models.UserPermissionLevels.PROV)
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
def test_datasource_permission_prov(self):
"""
Test that permissions are correctly handled when attempting to get PROV data from a data source.
"""
self.model = models.DataSource.objects.create(
name=self.test_name,
owner=self.owner,
url=self.test_url,
plugin_name='DataSetConnector',
public_permission_level=models.UserPermissionLevels.NONE)
url = '/api/datasources/{}/prov/'.format(self.model.pk)
response = self.client.get(url)
self.assertEqual(response.status_code, 403)
self._grant_permission(models.UserPermissionLevels.VIEW)
response = self.client.get(url)
self.assertEqual(response.status_code, 403)
self._grant_permission(models.UserPermissionLevels.META)
response = self.client.get(url)
self.assertEqual(response.status_code, 403)
self._grant_permission(models.UserPermissionLevels.DATA)
response = self.client.get(url)
self.assertEqual(response.status_code, 403)
self._grant_permission(models.UserPermissionLevels.PROV)
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
class TestViews(TestCase):
def setUp(self):
self.client = Client()
self.home_url = reverse('home')
self.feed_url = reverse('feed')
self.login_url = reverse('login')
self.account_url = reverse('account', args=[1])
self.myaccount_url = reverse('myaccount', args=[1])
self.parameter_url = reverse('parameter')
self.search_url = reverse('search')
self.legal_notice_url = reverse('legal_notice')
def test_get_home(self):
response = self.client.get(self.home_url)
self.assertEquals(response.status_code, 200)
self.assertTemplateUsed(response, 'user/home.html')
def test_post_home(self):
form_data = {
'username': '******',
'email': '*****@*****.**',
'password1': 'Secret123456',
'password2': 'Secret123456',
}
response = self.client.post(self.home_url, form_data)
self.assertRedirects(response, self.feed_url, status_code=302)
def test_bad_post_home(self):
form_data = {
'username': '',
'email': '',
'password1': '',
'password2': '',
}
response = self.client.post(self.home_url, form_data)
self.assertTemplateUsed(response, 'user/home.html')
def test_get_login(self):
response = self.client.get(self.login_url)
self.assertEquals(response.status_code, 200)
self.assertTemplateUsed(response, 'user/login.html')
def test_get_home_unauthenticated(self):
self.client.force_login(CustomUser.objects.get_or_create(username='******')[0])
response = self.client.get(self.home_url)
self.assertRedirects(response, self.feed_url, status_code=302)
def test_get_account_authenticated(self):
self.client.force_login(CustomUser.objects.get_or_create(username='******')[0])
id_user = CustomUser.objects.all()[0].id
account_url = reverse('account', args=[id_user])
response = self.client.get(account_url)
self.assertTemplateUsed(response, 'user/account.html')
def test_get_account_unauthenticated(self):
response = self.client.get(self.account_url)
self.assertRedirects(response, self.home_url, status_code=302)
def test_get_myaccount_authenticated_with_good_id(self):
self.client.force_login(CustomUser.objects.get_or_create(username='******')[0])
id_user = CustomUser.objects.all()[0].id
myaccount_url = reverse('myaccount', args=[id_user])
response = self.client.get(myaccount_url)
self.assertTemplateUsed(response, 'user/myaccount.html')
def test_get_myaccount_with_bad_id(self):
self.client.force_login(CustomUser.objects.get_or_create(username='******')[0])
CustomUser(username="******").save()
myaccount_url = reverse('myaccount', args=[CustomUser.objects.all()[1].id])
account_url = reverse('account', args=[CustomUser.objects.all()[1].id])
response = self.client.get(myaccount_url)
self.assertRedirects(response, account_url, status_code=302)
def test_get_myaccount_unauthenticated(self):
response = self.client.get(self.myaccount_url)
self.assertRedirects(response, self.home_url, status_code=302)
def test_get_paramter_account_authenticated(self):
self.client.force_login(CustomUser.objects.get_or_create(username='******')[0])
response = self.client.get(self.parameter_url)
self.assertTemplateUsed(response, 'user/ParameterAccount.html')
def test_get_parameter_unauthenticated(self):
response = self.client.get(self.parameter_url)
self.assertRedirects(response, self.home_url, status_code=302)
def test_get_search_unauthenticated(self):
response = self.client.get(self.search_url)
self.assertRedirects(response, self.home_url, status_code=302)
def test_get_search_authenticated(self):
self.client.force_login(CustomUser.objects.get_or_create(username='******')[0])
response = self.client.get(self.search_url)
self.assertTemplateUsed(response, 'user/search_user.html')
def test_get_legal_notice(self):
response = self.client.get(self.legal_notice_url)
self.assertTemplateUsed(response, 'cgu/legalnotice.html')
class TestLoginRedirect(TestCase):
def setUp(self):
self.client = Client()
self.supplier_group = Group.objects.get(name='supplier')
self.ap_group = Group.objects.get(name='ap_administrator')
self.user_with_eb_social = UserFactory(email='*****@*****.**')
self.user_with_eb_social.groups.add(self.supplier_group)
self.user_with_google_social = UserFactory(email='*****@*****.**')
self.user_with_google_social.groups.add(self.ap_group)
self.user_buyer_with_google_social = UserFactory(email='*****@*****.**')
self.buyer_group = Group.objects.get(name='buyer')
self.user_buyer_with_google_social.groups.add(self.buyer_group)
def test_login_fail_should_redirect_to_loginfailview(self):
response_supplier = self.client.get(SUPPLIER_HOME, follow=True)
response_ap = self.client.get(AP_HOME, follow=True)
url_ap, status_code_ap = response_ap.redirect_chain[0]
url_sup, status_code_sup = response_supplier.redirect_chain[0]
self.assertEqual(HTTPStatus.FOUND, status_code_ap)
self.assertEqual('/?next={}'.format(AP_HOME), url_ap)
self.assertEqual(HTTPStatus.FOUND, status_code_sup)
self.assertEqual('/?next={}'.format(SUPPLIER_HOME), url_sup)
def test_login_success_with_EB_should_redirect_to_supplier(self):
company = CompanyFactory(
name='Eventbrite',
description='Best event organizer platform in town'
)
CompanyUserPermissionFactory(
user=self.user_with_eb_social,
company=company
)
self.client.force_login(self.user_with_eb_social)
response = self.client.get(SUPPLIER_HOME, follow=True)
self.assertEqual(HTTPStatus.OK, response.status_code)
self.assertEqual(
'supplier_app/supplier-home.html',
response.template_name[0]
)
def test_login_success_with_Google_should_redirect_to_apsite(self):
self.user_with_google_social.groups.add(Group.objects.get(name='ap_administrator'))
self.client.force_login(self.user_with_google_social)
response = self.client.get(AP_HOME, follow=True)
self.assertEqual(HTTPStatus.OK, response.status_code)
self.assertEqual('supplier_app/ap-taxpayers.html', response.template_name[0])
def test_ap_site_permission_invoice_list(self):
self.client.force_login(self.user_with_google_social)
response = self.client.get(
reverse('invoices-list'),
follow=True,
)
self.assertEqual(response.status_code, HTTPStatus.OK)
def test_ap_site_permission_taxpayers(self):
self.user_with_google_social.groups.add(Group.objects.get(name='ap_administrator'))
self.client.force_login(self.user_with_google_social)
response = self.client.get(
reverse('ap-taxpayers'),
follow=True,
)
self.assertEqual(response.status_code, HTTPStatus.OK)
def test_ap_site_access_denied(self):
user = UserFactory(email='*****@*****.**')
user.groups.add(self.supplier_group)
self.client.force_login(user)
response = self.client.get(
reverse('ap-taxpayers'),
follow=True,
)
self.assertIn(
(
(reverse('supplier-home'), 302)
),
response.redirect_chain
)
self.assertEqual(response.status_code, HTTPStatus.OK)
self.assertIn(
'supplier_app/supplier-home.html',
response.template_name,
)
def test_ap_authenticated_access_login_view_should_redirect_to_ap_home(self):
self.client.force_login(self.user_with_google_social)
response = self.client.get(
reverse('login'),
follow=True,
)
self.assertIn(AP_HOME, [red[0] for red in response.redirect_chain])
def test_ap_authenticated_access_login_view_should_redirect_to_buyer_home(self):
self.client.force_login(self.user_buyer_with_google_social)
response = self.client.get(
reverse('login'),
follow=True,
)
self.assertIn(BUYER_HOME, [red[0] for red in response.redirect_chain])
def test_supplier_authenticated_access_login_view_should_redirect_to_supplier_home(self):
self.client.force_login(self.user_with_eb_social)
response = self.client.get(
reverse('login'),
follow=True,
)
self.assertIn(SUPPLIER_HOME, [red[0] for red in response.redirect_chain])
class PostURLTests(TestCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
cls.user = User.objects.create_user(
username='******',
)
cls.user_2 = User.objects.create_user(
username='******',
)
cls.group = Group.objects.create(
title='Test group title',
slug='test_group',
description='Test description'
)
cls.post = Post.objects.create(
text='Test post text longer than 15 characters',
author=cls.user,
group=cls.group
)
def setUp(self):
self.guest_client = Client()
self.authorized_client = Client()
self.authorized_client.force_login(self.user)
self.authorized_client_2 = Client()
self.authorized_client_2.force_login(self.user_2)
def test_404_error_url(self):
"""Некорректный URL-адрес работает корректно."""
response = self.guest_client.get('/404_error/')
self.assertEqual(response.status_code, HTTPStatus.NOT_FOUND)
def test_urls_work_for_guests(self):
"""URL-адрес работает корректно для анонимного пользователя."""
username = PostURLTests.user.username
post_id = PostURLTests.post.pk
group_slug = PostURLTests.group.slug
guests_allowed_urls = (
'/',
f'/group/{group_slug}/',
f'/{username}/',
f'/{username}/{post_id}/',
)
for url in guests_allowed_urls:
with self.subTest(url=url):
response = self.guest_client.get(url)
self.assertEqual(response.status_code, HTTPStatus.OK)
def test_urls_redirect_for_guests(self):
"""URL-адрес перенаправляет анонимного пользователя
на страницу авторизации."""
username = PostURLTests.user.username
post_id = PostURLTests.post.pk
guests_redirected_urls = {
'/follow/': reverse('login') + '?next=/follow/',
'/new/': reverse('login') + '?next=/new/',
f'/{username}/{post_id}/edit/':
reverse('login') + f'?next=/{username}/{post_id}/edit/',
}
for url, redirect_name in (guests_redirected_urls.items()):
with self.subTest(url=url):
response = self.guest_client.get(url, follow=True)
self.assertRedirects(response, redirect_name)
def test_urls_work_for_authorized(self):
"""URL-адрес работает корректно для авторизованного пользователя."""
username = PostURLTests.user.username
post_id = PostURLTests.post.pk
group_slug = PostURLTests.group.slug
authorized_allowed_urls = (
'/',
'/follow/',
'/new/',
f'/group/{group_slug}/',
f'/{username}/',
f'/{username}/{post_id}/',
f'/{username}/{post_id}/edit/',
)
for url in authorized_allowed_urls:
with self.subTest(url=url):
response = self.authorized_client.get(url)
self.assertEqual(response.status_code, HTTPStatus.OK)
def test_post_edit_url_redirects_for_no_author(self):
"""URL-адрес редактирования поста перенаправит неавтора поста
на страницу просмотра поста."""
username = PostURLTests.user.username
post_id = PostURLTests.post.pk
response = self.authorized_client_2.get(
f'/{username}/{post_id}/edit/', follow=True)
redirect_url = f'/{username}/{post_id}/'
self.assertRedirects(response, redirect_url)
def test_urls_exist_at_desired_locations(self):
"""URL-адрес использует соответствующий шаблон."""
username = PostURLTests.user.username
post_id = PostURLTests.post.pk
group_slug = PostURLTests.group.slug
templates_urls = {
'/': 'index.html',
f'/group/{group_slug}/': 'group.html',
'/new/': 'post_new.html',
f'/{username}/': 'profile.html',
f'/{username}/{post_id}/': 'post.html',
f'/{username}/{post_id}/edit/': 'post_new.html',
}
for url, template in templates_urls.items():
with self.subTest(url=url):
response = self.authorized_client.get(url)
self.assertTemplateUsed(response, template)
class PostsTest(TestCase):
def setUp(self):
cache.clear()
self.client = Client()
self.user = User.objects.create_user(username='******',
email='*****@*****.**',
password='******')
self.group = Group.objects.create(title='testers',
slug='testers',
description='test_group')
def test_profile(self):
self.client.force_login(self.user)
response = self.client.get(
reverse('profile', args=[self.user.username]))
self.assertEqual(response.status_code, 200)
def test_authorized_user_newpost_page(self):
response = self.client.get(reverse('new_post'), follow=True)
self.assertEqual(response.status_code, 200)
def test_unauthorized_user_newpost_page(self):
response = self.client.get(reverse('new_post'))
self.assertRedirects(response,
f"{reverse('login')}?next={reverse('new_post')}",
status_code=302,
target_status_code=200)
def test_new_post(self):
self.client.force_login(self.user)
current_posts_count = Post.objects.count()
data = {'text': 'New test post', 'group': self.group.id}
response = self.client.post(reverse('new_post'), data, follow=True)
self.assertEqual(Post.objects.count(), current_posts_count + 1)
paginator = response.context.get('paginator')
if paginator is not None:
result = response.context['page'][0]
else:
result = response.context['post']
self.assertEqual(result.text, data['text'])
self.assertEqual(result.author.username, self.user.username)
self.assertEqual(result.group, self.group)
def test_edit_post(self):
self.client.force_login(self.user)
self.post = Post.objects.create(text='Test post',
author=self.user,
group=self.group)
self.edit_group = Group.objects.create(title='Sec. testers',
slug='Sec. testers',
description='test_group_num_2')
first_posts_count = Post.objects.count()
edit_text = 'Test post after edit'
data = {
'text': edit_text,
'group': self.edit_group.id,
}
response_edit_post = self.client.post(
reverse('post_edit', args=[self.user.username, self.post.id]),
data)
second_posts_count = Post.objects.count()
self.assertEqual(
first_posts_count, second_posts_count,
'Страница редактировани поста создает еще одну страницу')
self.assertEqual(response_edit_post.status_code, 302)
self.post_text = Post.objects.get(id=self.post.id).text
self.assertEqual(self.post_text, edit_text)
self.post_group = Post.objects.get(id=self.post.id).group
self.assertEqual(self.post_group, self.edit_group)
def test_show_post(self):
self.client.force_login(self.user)
self.post = Post.objects.create(text='Test post',
author=self.user,
group=self.group)
urls = (
reverse('index'),
reverse('profile', args=[self.user.username]),
reverse('post', args=[self.user.username, self.post.id]),
reverse('group_posts', args=[self.group.slug]),
)
for url in urls:
cache.clear()
result_page = self.client.get(url)
with self.subTest('Поста нет на странице "' + url + '"'):
paginator = result_page.context.get('paginator')
if paginator is not None:
result = result_page.context['page'][0]
else:
result = result_page.context['post']
self.assertEqual(result.text, self.post.text)
self.assertEqual(result.group.id, self.group.id)
self.assertEqual(result.author.username, self.user.username)
def test_show_404(self):
response = self.client.get('/no_existing_page/')
self.assertEquals(response.status_code, 404)
class View_Club_Roster_TestCase(TestCase):
def setUp(self):
self.client = Client()
#client needs to be logged in
#create club owner
self.owner = get_user_model().objects.create(first_name="Owner",
last_name="McPerson",
email="*****@*****.**")
self.owner.set_password("clubsuite")
self.owner.save()
#Create club
self.club = Club.objects.create(club_name="club",
club_type="PUB",
club_description="a club")
self.club._create_permissions()
self.club._set_owner(self.owner)
#add users to club
self.user_list = []
self.user_list.append(self.owner)
for i in range(1, 20):
#create users
user = get_user_model().objects.create(
first_name="Person" + str(i),
last_name="McPerson",
email="test" + str(i) + "@test.com")
user.set_password("clubsuite")
user.save()
# add user to club
self.club.add_member(self.owner, user)
self.user_list.append(user)
def test_get_login(self):
self.client.force_login(
get_user_model().objects.get(first_name="Owner"))
response = self.client.get(reverse('suite:club_roster',
kwargs={'club_id': self.club.id}),
club_id=self.club.pk)
self.assertEqual(response.status_code, 200)
self.assertContains(response, self.club.club_name)
self.assertContains(response, self.owner.first_name)
def test_get_not_logged_in(self):
response = self.client.get(
reverse('suite:club_roster', kwargs={'club_id': self.club.id}))
self.assertRedirects(
response, "/?next=" +
reverse('suite:club_roster', kwargs={'club_id': self.club.id}),
302, 200)
def test_post_delete(self):
self.client.force_login(
get_user_model().objects.get(first_name='Owner'))
self.assertTrue(self.club.is_member(self.user_list[1]))
self.assertTrue(self.club.is_owner(self.owner))
data = {'delete': self.user_list[1].pk, 'club_id': self.club.pk}
response = self.client.post(reverse('suite:club_roster',
kwargs={'club_id': self.club.id}),
data,
follow=True)
self.assertEqual(response.status_code, 200)
self.assertFalse(self.club.is_member(self.user_list[1]))
def test_post_promote(self):
self.client.force_login(
get_user_model().objects.get(first_name='Owner'))
data = {'promote': self.user_list[1].pk, 'club_id': self.club.pk}
response = self.client.post(reverse('suite:club_roster',
kwargs={'club_id': self.club.id}),
data,
follow=True)
self.assertEqual(response.status_code, 200)
self.assertTrue(self.club.is_officer(self.user_list[1]))
class TemplatesUseBaseTests(TestCase):
def setUp(self):
self.client = Client()
try:
from populate_dogs import populate
populate()
except ImportError:
print("The module populate_dogs does not exist")
except NameError:
print("The function populate() does not exist or is incorrect")
except:
print("Error in populate() function")
def test_home_template(self):
response = self.client.get(reverse('index'))
self.assertTemplateUsed(response, 'home.html', 'base.html')
def test_login_template(self):
response = self.client.get(reverse('account_login'))
self.assertTemplateUsed(response, 'account/login.html', 'base.html')
def test_signup_template(self):
response = self.client.get(reverse('signup'))
self.assertTemplateUsed(response, 'signup.html', 'base.html')
def test_vote_template(self):
user = get_user_model()
self.client.force_login(user.objects.get_or_create(username='******')[0])
response = self.client.get(reverse('vote'))
self.assertTemplateUsed(response, 'vote.html', 'base.html')
@skip
def test_no_dog_template(self):
response = self.client.get(reverse('vote'))
self.assertTemplateUsed(response, 'nodog.html', 'base.html')
@skip
def test_profile_template(self):
user = get_user_model()
self.client.force_login(user.objects.get_or_create(username='******')[0])
response = self.client.get(reverse('profile'))
self.assertTemplateUsed(response, 'profile.html', 'base.html')
@skip
def test_dog_profile_template(self):
response = self.client.get(reverse('dog/8'))
self.assertTemplateUsed(response, 'dogprofile.html', 'base.html')
def test_upload_template(self):
user = get_user_model()
self.client.force_login(user.objects.get_or_create(username='******')[0])
response = self.client.get(reverse('upload'))
self.assertTemplateUsed(response, 'upload.html', 'base.html')
@skip
def test_success_template(self):
user = get_user_model()
self.client.force_login(user.objects.get_or_create(username='******')[0])
response = self.client.get(reverse('upload'))
self.assertTemplateUsed(response, 'success.html', 'base.html')
class TestAdmin(TestCase):
def setUp(self):
self.client = Client()
self.ap_user = UserFactory(email='*****@*****.**')
manager_group = Group.objects.get(name='ap_manager')
self.ap_user.groups.add(manager_group)
self.user_buyer_with_google_social = UserFactory(email='*****@*****.**')
self.buyer_group = Group.objects.get(name='buyer')
self.user_buyer_with_google_social.groups.add(self.buyer_group)
def test_admin_list_view(self):
self.client.force_login(self.ap_user)
response = self.client.get(
reverse('manage-admins')
)
self.assertEqual(response.status_code, HTTPStatus.OK)
def test_admin_list_view_only_ap(self):
self.client.force_login(self.ap_user)
response = self.client.get(
reverse('manage-admins'),
{'only_ap': 'only_ap'}
)
self.assertEqual(len(response.context_data['object_list']), 1)
def test_admin_list_view_all_eb_users(self):
self.client.force_login(self.ap_user)
response = self.client.get(
reverse('manage-admins'),
{'all_eb_users': 'all_eb_users'}
)
self.assertEqual(len(response.context_data['object_list']), 2)
def test_change_admin_group_view(self):
self.client.force_login(self.ap_user)
response = self.client.post(
reverse('change-ap-permission', kwargs={'pk': self.ap_user.id}),
{'group_name': 'ap_reporter'}
)
self.assertEqual(response.status_code, HTTPStatus.FOUND)
self.assertTrue(self.ap_user.groups.filter(name='ap_reporter').exists())
def test_admin_remove_group(self):
self.client.force_login(self.ap_user)
response = self.client.post(
reverse('change-ap-permission', kwargs={'pk': self.ap_user.id}),
{'group_name': 'ap_manager'}
)
self.assertEqual(response.status_code, HTTPStatus.FOUND)
self.assertFalse(self.ap_user.groups.filter(name='ap_manager').exists())
def test_change_admin_invalid_group_view(self):
self.client.force_login(self.ap_user)
response = self.client.post(
reverse('change-ap-permission', kwargs={'pk': self.ap_user.id}),
{'group_name': 'bad_group'}
)
self.assertEqual(response.status_code, HTTPStatus.BAD_REQUEST)
def test_create_ap_user_valid_email(self):
self.client.force_login(self.ap_user)
group = Group.objects.get(name='ap_manager')
response = self.client.post(
reverse('create-admin'),
{
'email': '*****@*****.**',
'groups': group.id,
},
)
self.assertEqual(response.status_code, HTTPStatus.FOUND)
def test_create_ap_user_form_valid_email(self):
self.client.force_login(self.ap_user)
group = Group.objects.get(name='ap_manager')
form = UserAdminForm(
data={
'email': '*****@*****.**',
'groups': [group.id],
},
)
self.assertTrue(form.is_valid())
def test_create_ap_user_form_invalid_email(self):
self.client.force_login(self.ap_user)
group = Group.objects.get(name='ap_manager')
form = UserAdminForm(
data={
'email': '*****@*****.**',
'groups': [group.id],
},
)
self.assertFalse(form.is_valid())
def test_create_ap_user_form_invalid_group(self):
self.client.force_login(self.ap_user)
form = UserAdminForm(
data={
'email': '*****@*****.**',
'groups': [312],
},
)
self.assertFalse(form.is_valid())
def test_admin_can_go_to_articles_in_admin_panel(self, admin_user):
client = Client()
client.force_login(admin_user)
response = client.get("/articles/")
assert response.status_code == 200
def test_admin_can_see_articles_in_admin_panel(self, admin_user):
client = Client()
client.force_login(admin_user)
response = client.get("/")
assert response.status_code == 200
assert '/articles' in str(response.content)
class PostFormTests(TestCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
cls.small_gif = (b'\x47\x49\x46\x38\x39\x61\x02\x00'
b'\x01\x00\x80\x00\x00\x00\x00\x00'
b'\xFF\xFF\xFF\x21\xF9\x04\x00\x00'
b'\x00\x00\x00\x2C\x00\x00\x00\x00'
b'\x02\x00\x01\x00\x00\x02\x02\x0C'
b'\x0A\x00\x3B')
cls.user = User.objects.create_user(username='******', )
cls.group = Group.objects.create(title='Test group title',
slug='test_group',
description='Test description')
cls.group_2 = Group.objects.create(title='Test group 2 title',
slug='test_group_2',
description='Test description 2')
cls.post = Post.objects.create(text='Post for edition',
author=cls.user,
group=cls.group)
@classmethod
def tearDownClass(cls):
shutil.rmtree(settings.MEDIA_ROOT, ignore_errors=True)
super().tearDownClass()
def setUp(self):
self.authorized_client = Client()
self.authorized_client.force_login(self.user)
def test_create_post(self):
"""Валидная форма создает запись в Post."""
uploaded = SimpleUploadedFile(name='small_1.gif',
content=PostFormTests.small_gif,
content_type='image/gif')
form_data = {
'text': 'Created post',
'group': PostFormTests.group.id,
'image': uploaded
}
response = self.authorized_client.post(reverse('posts:new_post'),
data=form_data,
follow=True)
post = Post.objects.get(text='Created post')
self.assertRedirects(response, reverse('posts:index'))
self.assertEqual(Post.objects.count(), 2)
self.assertEqual(post.text, form_data['text'])
self.assertEqual(post.group.id, form_data['group'])
self.assertEqual(post.author, self.user)
self.assertEqual(post.image, 'posts/small_1.gif')
self.assertEqual(response.status_code, 200)
def test_edit_post(self):
"""Валидная форма редактирует запись в Post."""
user = PostFormTests.user
post = PostFormTests.post
uploaded = SimpleUploadedFile(
name='small_2.gif',
content=PostFormTests.small_gif,
content_type='image/gif',
)
form_data = {
'text': 'Edited post text',
'group': PostFormTests.group_2.id,
'image': uploaded
}
post_edit_url = reverse('posts:post_edit',
kwargs={
'username': user.username,
'post_id': post.id
})
redirect_edited_url = reverse('posts:post',
kwargs={
'username': user.username,
'post_id': post.id
})
group_posts_url = reverse('posts:group_posts',
kwargs={'slug': PostFormTests.group.slug})
response = self.authorized_client.post(post_edit_url,
data=form_data,
follow=True)
edited_post = response.context['post']
group_posts_response = self.authorized_client.get(group_posts_url)
group_posts_context = group_posts_response.context_data['page'][:]
self.assertRedirects(response, redirect_edited_url)
self.assertEqual(edited_post.text, form_data['text'])
self.assertEqual(edited_post.group_id, form_data['group'])
self.assertEqual(edited_post.image, f"posts/{form_data['image'].name}")
self.assertNotIn(edited_post, group_posts_context)
def test_comment_post_for_authorized(self):
"""Авторизированный пользователь может комментировать посты."""
user = PostFormTests.user
post = PostFormTests.post
form_data = {'text': 'Post comment'}
auth_redirect_url = reverse('posts:post',
kwargs={
'username': user.username,
'post_id': post.id
})
auth_response = self.authorized_client.post(reverse(
'posts:add_comment',
kwargs={
'username': user.username,
'post_id': post.id
}),
data=form_data,
follow=True)
self.assertRedirects(auth_response, auth_redirect_url)
self.assertTrue(
Comment.objects.filter(text=form_data['text']).exists())
def test_comment_post_redirects_unauthorized(self):
"""Неавторизированный пользователь перенаправляется
на страницу авторизации."""
user = PostFormTests.user
post = PostFormTests.post
guest_client = Client()
form_data = {'text': 'Post comment'}
url = reverse('posts:add_comment',
kwargs={
'username': user.username,
'post_id': post.id
})
guest_redirect_url = reverse('login') + f'?next={url}'
guest_response = guest_client.post(url, data=form_data, follow=True)
self.assertRedirects(guest_response, guest_redirect_url)
class StaticURLTests(TestCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
cls.author = User.objects.create_user(username='******')
cls.user = User.objects.create_user(username='******')
cls.group = Group.objects.create(
title='Котики',
slug='test-slug',
)
Post.objects.create(text='Текст', author=cls.author, group=cls.group)
cls.site = Site.objects.first()
cls.flatpages1 = FlatPage.objects.create(
url='/about-author/',
title='Об авторе',
content='<b>content</b>',
)
cls.flatpages2 = FlatPage.objects.create(
url='/about-spec/',
title='Технологии',
content='<b>content</b>',
)
cls.flatpages1.sites.add(cls.site)
cls.flatpages2.sites.add(cls.site)
def setUp(self):
self.guest_client = Client()
self.authorized_client_author = Client()
self.authorized_client = Client()
self.authorized_client_author.force_login(StaticURLTests.author)
self.authorized_client.force_login(StaticURLTests.user)
def test_url_for_all_users(self):
"""Страницы доступны любому пользователю."""
url_status_code = [
reverse('index'),
reverse('author'),
reverse('spec'),
reverse('group', kwargs={'slug': 'test-slug'}),
reverse('profile', kwargs={'username': '******'}),
reverse('post', kwargs={
'username': '******',
'post_id': 1
}),
]
for url in url_status_code:
with self.subTest():
response = self.guest_client.get(url)
self.assertEqual(response.status_code, 200)
def test_url_redirect_anonymous_on_login(self):
"""
Страница по адресу /new/,
/<str:username>/<int:post_id>/edit/ и
/<str:username>/<int:post_id>/comment/
перенаправит анонимного
пользователя на страницу логина.
"""
login_url = reverse('login')
new_post_url = reverse('new_post')
post_edit_url = reverse('post_edit',
kwargs={
'username': '******',
'post_id': 1
})
comment_url = reverse('add_comment',
kwargs={
'username': '******',
'post_id': 1
})
url_to_login = {
new_post_url: f"{login_url}?next={new_post_url}",
post_edit_url: f"{login_url}?next={post_edit_url}",
comment_url: f"{login_url}?next={comment_url}",
}
for url, next_url in url_to_login.items():
with self.subTest():
response = self.guest_client.get(url, follow=True)
self.assertRedirects(response, next_url)
def test_edit_for_authorized_user_author(self):
"""
Страница /<str:username>/<int:post_id>/edit/ доступна
авторизованному пользователю-автору поста и недоступна для
пользователя-не автора.
"""
url_status_code = {
reverse('post_edit', kwargs={
'username': '******',
'post_id': 1
}): 200,
reverse('post_edit', kwargs={
'username': '******',
'post_id': 1
}): 302,
}
for url, status_code in url_status_code.items():
with self.subTest():
response = self.authorized_client_author.get(url)
self.assertEqual(response.status_code, status_code)
def test_new_for_authorized_user(self):
"""
Страница /new/ и /<str:username>/<int:post_id>/comment/ доступна
авторизованному пользователю.
"""
url_status_code = {
reverse('new_post'),
reverse('add_comment', kwargs={
'username': '******',
'post_id': 1
}),
}
for url in url_status_code:
with self.subTest():
response = self.authorized_client.get(url)
self.assertEqual(response.status_code, 200)
def test_url_uses_correct_template(self):
"""URL-адрес использует соответствующий шаблон."""
url_uses_templates = {
reverse('index'): 'index.html',
reverse('group', kwargs={'slug': 'test-slug'}): 'group.html',
reverse('new_post'): 'new_post.html',
reverse('profile', kwargs={'username': '******'}): 'profile.html',
reverse('post', kwargs={
'username': '******',
'post_id': 1
}): 'post.html',
reverse('follow_index'): 'follow.html',
}
for url, template in url_uses_templates.items():
with self.subTest():
response = self.authorized_client.get(url)
self.assertTemplateUsed(response, template)
def test_edit_redirect_authorized_user(self):
"""
Перенаправляет пользователя на страницу /<str:username>/<int:post_id>/,
если он не является автором поста
"""
response = self.authorized_client.get(
reverse('post_edit', kwargs={
'username': '******',
'post_id': 1
}))
self.assertRedirects(
response,
reverse('post', kwargs={
'username': '******',
'post_id': 1
}))
def test_page_not_found(self):
"""
Проверяет, возвращает ли сервер код 404, если страница не найдена.
"""
response = self.guest_client.get('/not-found/')
self.assertEqual(response.status_code, 404)
def test_auth_user_follow(self):
"""
Авторизованный пользователь может подписываться
на других пользователей
"""
self.authorized_client.get(
reverse('profile_follow', kwargs={'username': '******'}))
self.assertEqual(
Follow.objects.filter(user=StaticURLTests.user).count(), 1)
def test_auth_user_unfollow(self):
"""
Авторизованный пользователь может удалять из подписок
других пользователей
"""
self.authorized_client.get(
reverse('profile_unfollow', kwargs={'username': '******'}))
self.assertEqual(
Follow.objects.filter(user=StaticURLTests.user).count(), 0)
def test_show_follow_posts(self):
"""
Новая запись пользователя появляется в ленте тех, кто на него подписан
и не появляется в ленте тех, кто не подписан на него.
"""
self.authorized_client.get(
reverse('profile_follow', kwargs={'username': '******'}))
self.assertEqual(
Post.objects.filter(
author__following__user=StaticURLTests.user).count(), 1)
self.assertEqual(
Post.objects.filter(
author__following__user=StaticURLTests.author).count(), 0)
class PostURLTests(TestCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
cls.user = User.objects.create(username='******')
cls.another_user = User.objects.create(username='******')
cls.group = Group.objects.create(title='Test',
description='Много букв')
cls.post = Post.objects.create(author=cls.user,
text='Тестовый текст',
group=cls.group)
def setUp(self):
# Создаем неавторизованный клиент
self.guest_client = Client()
# Создаем второй клиент
self.authorized_client = Client()
# Авторизуем пользователя
self.authorized_client.force_login(self.user)
self.templates_urls = {
'index.html': '/',
'group.html': '/group/' + self.group.slug,
'new.html': '/new/',
'profile.html': '/' + self.user.username + '/',
'post.html':
'/' + self.user.username + '/' + str(self.post.id) + '/',
'post_edit.html':
'/' + self.user.username + '/' + str(self.post.id) + '/edit/',
'about/author.html': '/about/author/',
'about/tech.html': '/about/tech/',
}
def test_urls_200(self):
"""Тестируем доступность страниц для пользователя"""
for value in self.templates_urls.values():
with self.subTest():
response = self.authorized_client.get(value)
self.assertEqual(response.status_code, 200)
def test_edit_page_for_not_author(self):
"""Тестируем доступность страницы /<str:username>/<int:post_id>/edit/
для авторизованного пользователя, не автора поста"""
authorized_client = Client()
authorized_client.force_login(self.another_user)
response = authorized_client.get(self.templates_urls['post.html'] +
'/edit/')
self.assertEqual(response.status_code, 404)
def test_redirect_guest_client(self):
"""Тестируем редирект для страницы /new/"""
response = self.guest_client.get('/new/', follow=True)
self.assertRedirects(response, '/auth/login/?next=/new/')
def test_redirect_guest_client_for_edit_page(self):
"""Тестируем редирект для страницы
/<str:username>/<int:post_id>/edit/ """
response = self.guest_client.get('/' + self.user.username + '/' +
str(self.post.id) + '/edit/',
follow=True)
self.assertRedirects(
response, '/auth/login/?next=/' + self.user.username + '/' +
str(self.post.id) + '/edit/')
response = self.guest_client.get('/' + self.user.username + '/' +
str(self.post.id) + '/edit/',
follow=True)
self.assertRedirects(
response, '/auth/login/?next=/' + self.user.username + '/' +
str(self.post.id) + '/edit/')
def test_url_correct_template(self):
"""Тестируем шаблоны страниц"""
for template, reverse_name in self.templates_urls.items():
with self.subTest():
response = self.authorized_client.get(reverse_name)
self.assertTemplateUsed(response, template)
def test_editor_cant_go_to_articles_in_admin_panel(self, editor_user):
client = Client()
client.force_login(editor_user)
response = client.get("/articles/")
assert response.status_code == 404
class PostViewsTest(TestCase):
def setUp(self):
self.user = User.objects.create_user(username='******',
password='******')
self.client = Client()
def test_existing_post_view(self):
post_title = 'Velocità con #animato'
# Create Post and published
post = Post.objects.create(user=self.user,
title=post_title,
status='published',
visibility='public')
# Create post URL
post_view_url = reverse('post_detail',
kwargs={'hash_id': post.hash_id})
# Issue a GET request
response = self.client.get(post_view_url)
# Check that the response is 200 OK
self.assertEqual(response.status_code, 200)
# Check that the title of the Post matches with the original title
self.assertEqual(response.context['post'].title, post_title)
def test_unpublished_post_view(self):
from django.core.exceptions import PermissionDenied
post_title = 'Velocità con #animato'
# Create Post
post = Post.objects.create(user=self.user, title=post_title)
# Create post URL
post_view_url = reverse('post_detail',
kwargs={'hash_id': post.hash_id})
# Issue a GET request
response = self.client.get(post_view_url)
# Check that the response is 400 Not Allowed
self.assertEqual(response.status_code, 400)
self.client.force_login(self.user)
response = self.client.get(post_view_url)
# Check that the response is 200 OK
self.assertEqual(response.status_code, 200)
def test_non_existing_post_view(self):
from hashid_field import Hashid
non_existing_post_id = 99
hash_id = Hashid(non_existing_post_id).hashid
# Ensure that Post with ID 99 does not exist
with self.assertRaises(Post.DoesNotExist):
Post.objects.get(hash_id=hash_id)
# Create url for non-existing post
post_view_url = reverse('post_detail', kwargs={'hash_id': hash_id})
# Issue a GET request
response = self.client.get(post_view_url)
# Check that the response is 404
self.assertEqual(response.status_code, 404)
def test_post_create_view(self):
post_create_url = reverse('post_create')
# Ensure that the view is not available if anonymous
response = self.client.get(post_create_url)
self.assertEqual(response.status_code, 302)
# Log in the user
self.client.force_login(self.user)
# Create a Post
response = self.client.get(post_create_url)
self.assertEqual(response.status_code, 200)
# Ensure Post is in the database
self.assertEqual(1, Post.objects.count())
# TODO(fsiddi): Test submission of invalid form
def test_report_post(self):
post_title = 'Velocità con #animato'
post = Post.objects.create(user=self.user, title=post_title)
report_content_url = reverse(
'report_content',
kwargs={
'content_type_id': post.content_type_id,
'object_id': post.id,
},
)
# Ensure that the view is not available if anonymous
response = self.client.get(report_content_url)
self.assertEqual(response.status_code, 302)
self.assertEqual(0, ContentReports.objects.count())
# Log in the user
self.client.force_login(self.user)
# Create a Post
self.client.post(report_content_url, {'reason': 'inappropriate'})
self.assertEqual(1, ContentReports.objects.count())
def test_post_status(self):
post_title = 'Velocità con #animato'
post = Post.objects.create(user=self.user, title=post_title)
post_status_url = reverse('post_status',
kwargs={'hash_id': post.hash_id})
response = self.client.get(post_status_url)
self.assertEqual(302, response.status_code)
self.client.force_login(self.user)
response = self.client.get(post_status_url)
self.assertJSONEqual(response.content, {'status': 'draft'})
@override_settings(
MEDIA_ROOT=tempfile.TemporaryDirectory(prefix='animato_test').name)
def test_post_upload_video(self):
import os
post_title = 'Velocità con #animato'
# Create Post
post = Post.objects.create(user=self.user, title=post_title)
# Create post URL
post_file_upload_url = reverse('post_file_upload',
kwargs={'hash_id': post.hash_id})
# Build file path
this_dir = os.path.dirname(os.path.abspath(__file__))
path_square_video = os.path.join(this_dir,
'upload_test_files/square_video.mp4')
# Ensure anonymous upload is not allowed
with open(path_square_video, 'rb') as video_file:
response = self.client.post(post_file_upload_url,
{'file': video_file})
self.assertEqual(response.status_code, 302)
# Log in the user
self.client.force_login(self.user)
with open(path_square_video, 'rb') as video_file:
response = self.client.post(post_file_upload_url,
{'file': video_file})
self.assertEqual(response.status_code, 200)
# Ensure that a video has been attached to the post
self.assertEqual(1, len(post.videos))
# Ensure that the framerate of the video has been added in the database
self.assertEqual(24, post.videos[0].framerate)
# Modify settings to prevent videos lasting more than 5 sec to be uploaded
settings.MEDIA_UPLOADS_VIDEO_MAX_DURATION_SECONDS = 5
with open(path_square_video, 'rb') as video_file:
response = self.client.post(post_file_upload_url,
{'file': video_file})
self.assertEqual(response.status_code, 422)
def test_editor_doesnt_see_articles_in_admin_panel(self, editor_user):
client = Client()
client.force_login(editor_user)
response = client.get("/")
assert response.status_code == 200
assert '/articles/' not in str(response.content)
class TestToolbarCookieMiddleware(TestCase):
def _create_user(self, email, **kwargs) -> User:
user = User.objects.create_user(email, **kwargs)
self.team.users.add(user)
self.team.save()
return user
def setUp(self):
super().setUp()
self.team: Team = Team.objects.create(api_token="token123")
self.user = self._create_user("user1", password="******")
self.client = Client()
def test_logged_out_client(self):
response = self.client.get("/")
self.assertEqual(0, len(response.cookies))
def test_logged_in_client(self):
with self.settings(TOOLBAR_COOKIE_NAME="phtoolbar", TOOLBAR_COOKIE_SECURE=False):
self.client.force_login(self.user)
response = self.client.get("/")
toolbar_cookie = response.cookies[settings.TOOLBAR_COOKIE_NAME]
self.assertEqual(toolbar_cookie.key, settings.TOOLBAR_COOKIE_NAME)
self.assertEqual(toolbar_cookie.value, "yes")
self.assertEqual(toolbar_cookie["path"], "/")
self.assertEqual(toolbar_cookie["samesite"], "None")
self.assertEqual(toolbar_cookie["httponly"], True)
self.assertEqual(toolbar_cookie["domain"], "")
self.assertEqual(toolbar_cookie["comment"], "")
self.assertEqual(toolbar_cookie["secure"], "")
self.assertEqual(toolbar_cookie["max-age"], 31536000)
def test_logged_in_client_secure(self):
with self.settings(TOOLBAR_COOKIE_NAME="phtoolbar", TOOLBAR_COOKIE_SECURE=True):
self.client.force_login(self.user)
response = self.client.get("/")
toolbar_cookie = response.cookies[settings.TOOLBAR_COOKIE_NAME]
self.assertEqual(toolbar_cookie.key, "phtoolbar")
self.assertEqual(toolbar_cookie.value, "yes")
self.assertEqual(toolbar_cookie["path"], "/")
self.assertEqual(toolbar_cookie["samesite"], "None")
self.assertEqual(toolbar_cookie["httponly"], True)
self.assertEqual(toolbar_cookie["domain"], "")
self.assertEqual(toolbar_cookie["comment"], "")
self.assertEqual(toolbar_cookie["secure"], True)
self.assertEqual(toolbar_cookie["max-age"], 31536000)
def test_logout(self):
with self.settings(TOOLBAR_COOKIE_NAME="phtoolbar"):
self.client.force_login(self.user)
response = self.client.get("/")
self.assertEqual(response.cookies[settings.TOOLBAR_COOKIE_NAME].key, "phtoolbar")
self.assertEqual(response.cookies[settings.TOOLBAR_COOKIE_NAME].value, "yes")
self.assertEqual(response.cookies[settings.TOOLBAR_COOKIE_NAME]["max-age"], 31536000)
response = self.client.get("/logout")
self.assertEqual(response.cookies[settings.TOOLBAR_COOKIE_NAME].key, "phtoolbar")
self.assertEqual(response.cookies[settings.TOOLBAR_COOKIE_NAME].value, "")
self.assertEqual(response.cookies[settings.TOOLBAR_COOKIE_NAME]["max-age"], 0)
def test_publication(self):
"""
Publication API
"""
req = Client()
user = ContextUnitTest.create_user()
user2 = ContextUnitTest.create_user(username='******',
is_staff=True)
pub = PublicationUnitTest.create_pub()
block = TemplateUnitTest.create_block_template()
# pulication list
url = reverse('unicms_api:editorial-board-publication-blocks',
kwargs={'publication_id': pub.pk})
# accessible to staff users only
res = req.get(url)
assert res.status_code == 403
user.is_staff = True
user.is_superuser = True
user.save()
req.force_login(user)
res = req.get(url)
assert isinstance(res.json(), dict)
# POST
data = {'publication': pub.pk,
'block': block.pk,
}
# user hasn't permission
req.force_login(user2)
res = req.post(url, data=data, follow=1)
assert res.status_code == 403
# user has permission
req.force_login(user)
res = req.post(url, data=data, follow=1,
content_type='application/json')
pub_block = PublicationBlock.objects.filter(publication=pub,
block=block).first()
assert(pub_block)
# GET LOGS
url = reverse('unicms_api:editorial-board-publication-block-logs',
kwargs={'publication_id': pub.pk,
'pk': pub_block.pk})
res = req.get(url, content_type='application/json',)
assert isinstance(res.json(), dict)
# GET, patch, put, delete
url = reverse('unicms_api:editorial-board-publication-block',
kwargs={'publication_id': pub.pk,
'pk': pub_block.pk})
# GET
res = req.get(url, content_type='application/json',)
assert isinstance(res.json(), dict)
# PATCH
block2 = TemplateUnitTest.create_block_template()
data = {'block': block2.pk}
# user hasn't permission
req.force_login(user2)
res = req.patch(url, data,
content_type='application/json',
follow=1)
assert res.status_code == 403
# user has permission
pub.created_by = user2
pub.save()
content_type = ContentType.objects.get_for_model(Publication)
edit_perm = Permission.objects.get(content_type=content_type, codename='change_publication')
user2.user_permissions.add(edit_perm)
user2.refresh_from_db()
req.force_login(user2)
res = req.patch(url, data,
content_type='application/json',
follow=1)
pub_block.refresh_from_db()
assert pub_block.block == block2
# PUT
pub.created_by = None
pub.save()
data = {'publication': pub.pk,
'block': block.pk,
}
# user hasn't permission
req.force_login(user2)
res = req.put(url, data, content_type='application/json')
assert res.status_code == 403
# user has permission
req.force_login(user)
res = req.put(url, data, content_type='application/json')
pub_block.refresh_from_db()
assert pub_block.block == block
# DELETE
# user hasn't permission
req.force_login(user2)
res = req.delete(url)
assert res.status_code == 403
# user has permission
req.force_login(user)
res = req.delete(url)
try:
pub_block.refresh_from_db()
except ObjectDoesNotExist:
assert True
class ViewTest(TestCase):
fixtures = ["webmap", "cyklomapa"]
def setUp(self):
# Every test needs access to the request factory.
self.factory = RequestFactory()
self.client = Client(HTTP_HOST="testing-sector.testserver")
self.user = User.objects.create_superuser(
username='******',
email='test_user@test_user.com',
password='******',
)
self.user.save()
try:
self.client.force_login(user=self.user)
except AttributeError: # Django<=1.8
self.client.login(username='******', password='******')
def test_uzavirky_view(self):
address = reverse("uzavirky_view")
response = self.client.get(address, secure=True)
self.assertContains(
response,
'<a href="https://mapa.prahounakole.cz/misto/1" target="_top" title="Description">Testing poi</a>',
html=True)
def test_uzavirky_feed(self):
address = reverse("uzavirky_feed")
response = self.client.get(address, secure=True)
self.assertContains(
response,
'<title>Testing poi</title><link>https://example.com#misto=l_1/</link>'
)
def test_novinky_feed(self):
address = reverse("novinky_feed")
response = self.client.get(address, secure=True)
self.assertContains(
response,
'<title>Testing poi</title><link>https://example.com#misto=l_1/</link>'
)
def test_panel_mapa_view(self):
address = reverse("panel_mapa_view")
response = self.client.get(address, secure=True)
self.assertContains(response, '<div> Lorem ipsum </div>', html=True)
def test_panel_hledani_view(self):
address = reverse("panel_hledani_view")
response = self.client.get(address, secure=True)
self.assertContains(response,
'<div id="jpPlanMessage">Čekání na server</div>',
html=True)
def test_kml_view(self):
address = reverse("kml_view", args=("l", ))
response = self.client.get(address, secure=True)
self.assertContains(response,
'<ikona>/media/DSC00002.JPG</ikona>',
html=True)
def test_search_view(self):
address = reverse(webmap_views.search_view, args=("poi", ))
response = self.client.get(address, secure=True)
self.assertContains(response, '<name>Testing poi</name>', html=True)
def test_metro_view(self):
address = reverse("metro_view")
response = self.client.get(address, secure=True)
self.assertContains(response, '<b>Testing poi 1</b>', html=True)
def test_popup_list_view(self):
address = reverse("popup-list")
response = self.client.get(address, secure=True)
self.assertContains(response,
'<a href="http://www.test.cz">Místo 1</a>',
html=True)
def test_panel_informace_view(self):
address = reverse("panel_informace_view")
response = self.client.get(address, secure=True)
self.assertContains(
response,
'<table id="legenda_table">'
'<tr>'
'<td> <img src="/media/DSC00002.JPG" alt="Testing legend item 1"> </td>'
'<td> Testing legend item 1 </td>'
'</tr> '
'<tr>'
'<td> </td>'
'<td> Testing legend item </td>'
'</tr>'
'</table>',
html=True,
)
def test_znacky_view(self):
address = reverse("znacky_view")
response = self.client.get(address, secure=True)
self.assertContains(
response,
'<dt><a name="tli"></a> <b>Testing legend item</b></dt>',
html=True)
self.assertContains(response,
'<dd>Legend item description</dd>',
html=True)
self.assertContains(
response,
'<dt><a name="tli1"></a><img src="/media/DSC00002.JPG" alt="Testing legend item 1"> <b>Testing legend item 1</b></dt>',
html=True,
)
self.assertContains(
response,
'<dt><a name="vyluka_akt"></a><img src="/media/DSC00002.JPG" alt="Testing marker"/> <b>Testing marker</b></dt>',
html=True)
self.assertContains(response, '<dd>Marker description</dd>', html=True)
def test_mapa_view(self):
address = reverse("mapa_view")
response = self.client.get(address, secure=True)
self.assertContains(
response,
'mapconfig[\'address_search_area\'] = "14.288920739775005,49.99501600356955,14.656276086402867,50.16553949570296";'
)
self.assertContains(
response,
'mapconfig[\'vrstvy\'].push(["Testing layer", "/kml/l/", enabled, "l"]);'
)
self.assertContains(
response,
'<a href="javascript:void(0)" data-dismiss="modal"><img src="/media/DSC00002.JPG" alt="Preset name" class=""/>Preset name</a>',
html=True)
def test_mapa_view_nonexistent_misto(self):
address = reverse("mapa_view", args=(123, ))
response = self.client.get(address, secure=True)
self.assertContains(
response,
'mapconfig[\'address_search_area\'] = "14.288920739775005,49.99501600356955,14.656276086402867,50.16553949570296";'
)
self.assertNotContains(response, 'mapconfig[\'center_feature\']')
def test_mapa_view_misto(self):
address = reverse("mapa_view", args=(1, ))
response = self.client.get(address, secure=True)
self.assertContains(
response,
'mapconfig[\'address_search_area\'] = "14.288920739775005,49.99501600356955,14.656276086402867,50.16553949570296";'
)
self.assertContains(response, 'mapconfig[\'center_feature\'] = 1;')
self.assertContains(
response,
'enabled = "False";\n \n mapconfig[\'vrstvy\'].push(["Disabled layer", "/kml/d/", enabled, "d"]);'
)
self.assertContains(
response,
'<a href="javascript:void(0)" data-dismiss="modal"><img src="/media/DSC00002.JPG" alt="Preset name" class=""/>Preset name</a>',
html=True)
def test_mapa_view_misto_enabled_layer(self):
address = reverse("mapa_view", args=(2, ))
response = self.client.get(address, secure=True)
self.assertContains(
response,
'mapconfig[\'address_search_area\'] = "14.288920739775005,49.99501600356955,14.656276086402867,50.16553949570296";'
)
self.assertContains(response, 'mapconfig[\'center_feature\'] = 2;')
self.assertContains(
response,
'enabled = "True";\n \n mapconfig[\'vrstvy\'].push(["Disabled layer", "/kml/d/", enabled, "d"]);'
)
self.assertContains(
response,
'<a href="javascript:void(0)" data-dismiss="modal"><img src="/media/DSC00002.JPG" alt="Preset name" class=""/>Preset name</a>',
html=True)
def test_popup(self):
address = reverse("popup_view", args=(1, ))
response = self.client.get(address, secure=True)
self.assertContains(
response,
'<a href="https://maps.google.com/?q=Testing%[email protected],14.422134381874203&z=18&t=h"'
' target="pnk_gmap" title="Zobrazit v Google Maps" class="sprite btn gmap"></a>',
html=True,
)
self.assertContains(
response,
'<p>Description</p>',
html=True,
)
self.assertContains(
response,
'<a href="%s" class="btn edit" title="Upravit">⚒</a>' %
reverse("admin:webmap_poi_change", args=(1, )),
html=True,
)
self.assertContains(
response,
'<a href="/media/DSC00002.JPG" title="Testing photo" data-lightbox="poi-image" data-title="Testing photo">'
'<img src="/media/DSC00002.JPG.300x0_q85.jpg" title="Testing photo" width="300" height="225" class="foto_thumb"/></a>',
html=True,
)
self.assertContains(
response,
'<h4>Testing user<span class="comment-date">poslal Lis. 12, 2015, 6:53 odp.</span></h4>',
html=True,
)
def test_popup_poi_without_desc(self):
address = reverse("popup_view", args=(205, ))
response = self.client.get(address, secure=True)
self.assertContains(
response,
'<p>Metro A</p>',
html=True,
)
