taiga
/
taiga-back
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Make integration tests as functions.

remotes/origin/enhancement/email-actions
Andrey Antukh 2014-05-26 17:18:36 +02:00
parent 2b087678b9
commit 4ec6ba621b
2 changed files with 165 additions and 217 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

68
tests/integration/test_auth_api.py
View File

@ -1,50 +1,42 @@
from unittest import mock
import pytest import pytest
from django.core.urlresolvers import reverse from django.core.urlresolvers import reverse
from .. import factories from .. import factories
pytestmark = pytest.mark.django_db pytestmark = pytest.mark.django_db
@pytest.fixture
def setup_module(module): def register_form():
module.patcher = mock.patch("taiga.domains.base.get_default_domain", return {"username": "username",
mock.Mock(return_value=factories.DomainFactory())) "password": "password",
module.patcher.start() "first_name": "fname",
"last_name": "lname",
def teardown_module(module): "email": "user@email.com",
module.patcher.stop() "type": "public"}
class TestPublicRegistration: def test_respond_201_if_domain_allows_public_registration(client, register_form):
@classmethod response = client.post(reverse("auth-register"), register_form)
def setup_class(cls): assert response.status_code == 201
cls.form = {"username": "username", "password": "password", "first_name": "fname",
"last_name": "lname", "email": "user@email.com", "type": "public"}
def test_respond_201_if_domain_allows_public_registration(self, client):
domain = factories.DomainFactory(public_register=True)
response = client.post(reverse("auth-register"), self.form, HTTP_X_HOST=domain.domain)
assert response.status_code == 201
def test_respond_400_if_domain_does_not_allow_public_registration(self, client):
domain = factories.DomainFactory(public_register=False)
response = client.post(reverse("auth-register"), self.form, HTTP_X_HOST=domain.domain)
assert response.status_code == 400
@pytest.mark.xfail def test_respond_400_if_domain_does_not_allow_public_registration(client, register_form):
class TestPrivateRegistration: response = client.post(reverse("auth-register"), register_form)
@classmethod assert response.status_code == 400
def setup_class(cls):
cls.form = {"username": "username", "password": "password", "first_name": "fname",
"last_name": "lname", "email": "user@email.com", "type": "private",
"existing": "1"}
def test_respond_201_if_domain_allows_public_registration(self, client):
domain = factories.DomainFactory(public_register=True) def test_respond_201_if_domain_allows_public_registration(client, register_form):
membership = factories.MembershipFactory() user = factories.UserFactory()
headers = {"HTTP_X_HOST": domain.domain} membership = factories.MembershipFactory(user=user)
response = client.post(reverse("auth-register"), self.form, **headers)
assert response.status_code == 201 register_form.update({
"type": "private",
"existing": "1",
"token": membership.token,
"username": user.username,
"email": user.email,
"password": user.username,
})
response = client.post(reverse("auth-register"), register_form)
assert response.status_code == 201

314
tests/integration/test_userstorage_api.py
View File

@ -8,211 +8,167 @@ from .. import factories
pytestmark = pytest.mark.django_db pytestmark = pytest.mark.django_db
class TestListStorageEntries(object): def test_list_userstories(client):
def _load_initial_data(self): user1 = factories.UserFactory()
self.user1 = factories.UserFactory() user2 = factories.UserFactory()
self.user2 = factories.UserFactory() storage11 = factories.StorageEntryFactory(owner=user1)
self.storage11 = factories.StorageEntryFactory(owner=self.user1) storage12 = factories.StorageEntryFactory(owner=user1)
self.storage12 = factories.StorageEntryFactory(owner=self.user1) storage13 = factories.StorageEntryFactory(owner=user1)
self.storage13 = factories.StorageEntryFactory(owner=self.user1) storage21 = factories.StorageEntryFactory(owner=user2)
self.storage21 = factories.StorageEntryFactory(owner=self.user2)
def test_list_by_anonymous_user(self, client): # List by anonumous user
self._load_initial_data() response = client.get(reverse("user-storage-list"))
response = client.get(reverse("user-storage-list")) assert response.status_code == 401
assert response.status_code == 401
def test_list_only_user1_entriees(self, client): # List own entries
self._load_initial_data() client.login(username=user1.username, password=user1.username)
response = client.login(username=self.user1.username, password=self.user1.username) response = client.get(reverse("user-storage-list"))
response = client.get(reverse("user-storage-list")) assert response.status_code == 200
assert response.status_code == 200 assert len(response.data) == 3
entries = response.data
assert len(entries) == 3
response = client.logout()
def test_list_only_user2_entriees(self, client): client.login(username=user2.username, password=user2.username)
self._load_initial_data() response = client.get(reverse("user-storage-list"))
response = client.login(username=self.user2.username, password=self.user2.username) assert response.status_code == 200
response = client.get(reverse("user-storage-list")) assert len(response.data) == 1
assert response.status_code == 200
entries = response.data
assert len(entries) == 1
response = client.logout()
def test_list_only_user1_entriees_filter_by_keys(self, client): # Filter results by key
self._load_initial_data() client.login(username=user1.username, password=user1.username)
response = client.login(username=self.user1.username, password=self.user1.username) keys = ",".join([storage11.key, storage13.key])
keys = "{},{}".format(self.storage11.key, self.storage13.key) url = "{}?keys={}".format(reverse("user-storage-list"), keys)
response = client.get("{}?keys={}".format(reverse("user-storage-list"), keys))
assert response.status_code == 200 response = client.get(url)
entries = response.data assert response.status_code == 200
assert len(entries) == 2 assert len(response.data) == 2
response = client.logout()
client.logout()
class TestViewStorageEntries(object): def test_view_storage_entries(client):
def _load_initial_data(self): user1 = factories.UserFactory()
self.user1 = factories.UserFactory() user2 = factories.UserFactory()
self.user2 = factories.UserFactory() storage11 = factories.StorageEntryFactory(owner=user1)
self.storage11 = factories.StorageEntryFactory(owner=self.user1)
def test_view_an_entry_by_anonymous_user(self, client): # Get by anonymous user
self._load_initial_data() response = client.get(reverse("user-storage-detail", args=[storage11.key]))
response = client.get(reverse("user-storage-detail", args=[self.storage11.key])) assert response.status_code == 401
assert response.status_code == 401
def test_view_an_entry(self, client): # Get single entry
self._load_initial_data() client.login(username=user1.username, password=user1.username)
response = client.login(username=self.user1.username, password=self.user1.username) response = client.get(reverse("user-storage-detail", args=[storage11.key]))
response = client.get(reverse("user-storage-detail", args=[self.storage11.key])) assert response.status_code == 200
assert response.status_code == 200 assert response.data["key"] == storage11.key
entry = response.data assert response.data["value"] == storage11.value
assert entry["key"] == self.storage11.key
assert entry["value"] == self.storage11.value
response = client.logout()
def test_view_an_entry_by_incorrect_user(self, client): # Get not existent key
self._load_initial_data() client.login(username=user2.username, password=user2.username)
response = client.login(username=self.user2.username, password=self.user2.username) response = client.get(reverse("user-storage-detail", args=[storage11.key]))
response = client.get(reverse("user-storage-detail", args=[self.storage11.key])) assert response.status_code == 404
assert response.status_code == 404
response = client.logout()
def test_view_non_existent_entry(self, client): response = client.get(reverse("user-storage-detail", args=["foobar"]))
self._load_initial_data() assert response.status_code == 404
response = client.login(username=self.user1.username, password=self.user1.username)
response = client.get(reverse("user-storage-detail", args=["foo"])) client.logout()
assert response.status_code == 404
response = client.logout()
class TestCreateStorageEntries(object): def test_create_entries(client):
@classmethod user1 = factories.UserFactory()
def setup_class(cls): user2 = factories.UserFactory()
cls.form = {"key": "foo", storage11 = factories.StorageEntryFactory(owner=user1)
"value": "bar"}
cls.form_without_key = {"value": "bar"}
cls.form_without_value = {"key": "foo"}
def _load_initial_data(self): form = {"key": "foo",
self.user1 = factories.UserFactory() "value": "bar"}
self.user2 = factories.UserFactory() form_without_key = {"value": "bar"}
self.storage11 = factories.StorageEntryFactory(owner=self.user1) form_without_value = {"key": "foo"}
error_form = {"key": storage11.key,
"value": "bar"}
def test_create_entry_by_anonymous_user_with_error(self, client): # Create entry by anonymous user
self._load_initial_data() response = client.post(reverse("user-storage-list"), form)
response = client.post(reverse("user-storage-list"), self.form) assert response.status_code == 401
assert response.status_code == 401
def test_create_entry_successfully(self, client): # Create by logged user
self._load_initial_data() client.login(username=user1.username, password=user1.username)
response = client.login(username=self.user1.username, password=self.user1.username) response = client.post(reverse("user-storage-list"), form)
response = client.post(reverse("user-storage-list"), self.form) assert response.status_code == 201
assert response.status_code == 201 response = client.get(reverse("user-storage-detail", args=[form["key"]]))
response = client.get(reverse("user-storage-detail", args=[self.form["key"]])) assert response.status_code == 200
assert response.status_code == 200
response = client.logout()
def test_create_entry_with_incorret_form_error(self, client): # Wrong data
self._load_initial_data() client.login(username=user1.username, password=user1.username)
response = client.login(username=self.user1.username, password=self.user1.username) response = client.post(reverse("user-storage-list"), form_without_key)
response = client.post(reverse("user-storage-list"), self.form_without_key) assert response.status_code == 400
assert response.status_code == 400 response = client.post(reverse("user-storage-list"), form_without_value)
response = client.post(reverse("user-storage-list"), self.form_without_value) assert response.status_code == 400
assert response.status_code == 400 response = client.post(reverse("user-storage-list"), error_form)
response = client.logout() assert response.status_code == 400
def test_create_entry_with_integrity_error(self, client): client.logout()
self._load_initial_data()
response = client.login(username=self.user1.username, password=self.user1.username)
error_form = {"key": self.storage11.key,
"value": "bar"}
response = client.post(reverse("user-storage-list"), error_form)
assert response.status_code == 400
response = client.logout()
class TestUpdateStorageEntries(object): def test_update_entries(client):
@classmethod user1 = factories.UserFactory()
def setup_class(cls): user2 = factories.UserFactory()
cls.form = {"value": "bar"} storage11 = factories.StorageEntryFactory(owner=user1)
def _load_initial_data(self): # Update by anonymous user
self.user1 = factories.UserFactory() form = {"value": "bar", "key": storage11.key}
self.user2 = factories.UserFactory() response = client.put(reverse("user-storage-detail", args=[storage11.key]),
self.storage11 = factories.StorageEntryFactory(owner=self.user1) json.dumps(form),
content_type='application/json')
assert response.status_code == 401
def test_update_entry_by_anonymous_user(self, client): # Update by logged user
self._load_initial_data() client.login(username=user1.username, password=user1.username)
self.form["key"] = self.storage11.key form = {"value": "bar", "key": storage11.key}
response = client.put(reverse("user-storage-detail", args=[self.storage11.key]),
json.dumps(self.form),
content_type='application/json')
assert response.status_code == 401
def test_update_entry(self, client): response = client.put(reverse("user-storage-detail", args=[storage11.key]),
self._load_initial_data() json.dumps(form),
response = client.login(username=self.user1.username, password=self.user1.username) content_type='application/json')
self.form["key"] = self.storage11.key assert response.status_code == 200
response = client.put(reverse("user-storage-detail", args=[self.storage11.key]), response = client.get(reverse("user-storage-detail", args=[storage11.key]))
json.dumps(self.form), assert response.status_code == 200
content_type='application/json') assert response.data["value"] == form["value"]
assert response.status_code == 200
response = client.get(reverse("user-storage-detail", args=[self.storage11.key]))
assert response.status_code == 200
entry = response.data
assert entry["value"] == self.form["value"]
response = client.logout()
def test_update_non_existent_entry(self, client): # Update not existing entry
self._load_initial_data() form = {"value": "bar", "key": "foo"}
response = client.login(username=self.user1.username, password=self.user1.username) response = client.get(reverse("user-storage-detail", args=[form["key"]]))
self.form["key"] = "foo" assert response.status_code == 404
response = client.get(reverse("user-storage-detail", args=[self.form["key"]])) response = client.put(reverse("user-storage-detail", args=[form["key"]]),
assert response.status_code == 404 json.dumps(form),
response = client.put(reverse("user-storage-detail", args=[self.form["key"]]), content_type='application/json')
json.dumps(self.form), assert response.status_code == 201
content_type='application/json') response = client.get(reverse("user-storage-detail", args=[form["key"]]))
assert response.status_code == 201 assert response.status_code == 200
response = client.get(reverse("user-storage-detail", args=[self.form["key"]])) assert response.data["value"] == form["value"]
assert response.status_code == 200
entry = response.data client.logout()
assert entry["value"] == self.form["value"]
response = client.logout()
class TestDeleteStorageEntries(object):
def _load_initial_data(self):
self.user1 = factories.UserFactory()
self.user2 = factories.UserFactory()
self.storage11 = factories.StorageEntryFactory(owner=self.user1)
def test_delete_entry_by_anonymous_user(self, client): def test_delete_storage_entry(client):
self._load_initial_data() user1 = factories.UserFactory()
response = client.delete(reverse("user-storage-detail", args=[self.storage11.key])) user2 = factories.UserFactory()
assert response.status_code == 401 storage11 = factories.StorageEntryFactory(owner=user1)
def test_delete_entry(self, client): # Delete by anonumous user
self._load_initial_data() response = client.delete(reverse("user-storage-detail", args=[storage11.key]))
response = client.login(username=self.user1.username, password=self.user1.username) assert response.status_code == 401
key = self.storage11.key
response = client.delete(reverse("user-storage-detail", args=[key]))
assert response.status_code == 204
response = client.get(reverse("user-storage-detail", args=[key]))
assert response.status_code == 404
response = client.logout()
def test_delete_entry_by_incorrect_user(self, client): # Delete by logged user
self._load_initial_data() client.login(username=user1.username, password=user1.username)
response = client.login(username=self.user2.username, password=self.user2.username) response = client.delete(reverse("user-storage-detail", args=[storage11.key]))
response = client.delete(reverse("user-storage-detail", args=[self.storage11.key])) assert response.status_code == 204
assert response.status_code == 404
response = client.logout() response = client.get(reverse("user-storage-detail", args=[storage11.key]))
assert response.status_code == 404
# Delete not existent entry
response = client.delete(reverse("user-storage-detail", args=["foo"]))
assert response.status_code == 404
client.login(username=user2.username, password=user2.username)
response = client.delete(reverse("user-storage-detail", args=[storage11.key]))
assert response.status_code == 404
client.logout()
def test_delete_non_existent_entry(self, client):
self._load_initial_data()
response = client.login(username=self.user1.username, password=self.user1.username)
response = client.delete(reverse("user-storage-detail", args=["foo"]))
assert response.status_code == 404
response = client.logout()